




'''simple docstring'''


import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
				from transformers import (
				    FlaxBertModel,
				    FlaxCLIPVisionModel,
				    FlaxVisionTextDualEncoderModel,
				    FlaxViTModel,
				    VisionTextDualEncoderConfig,
				    VisionTextDualEncoderProcessor,
				)
				from transformers.modeling_flax_pytorch_utils import (
				    convert_pytorch_state_dict_to_flax,
				    load_flax_weights_in_pytorch_model,
				)


if is_torch_available():
				import torch

				from transformers import VisionTextDualEncoderModel

if is_vision_available():
				from PIL import Image
def 		snake_case_   (UpperCamelCase	:  Union[str, Any]				):





							'''simple docstring'''


							if isinstance(_A			,						collections.abc.Iterable				):
														return x
							return (x, x)

@require_flax
class       A   :







							def        __lowerCAmelCase      (  self	:  Optional[int]							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  str )      ->							int:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  str )      ->							Optional[int]:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							List[Any]:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Union[str, Any]							,      lowerCAmelCase_	:  Tuple							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  Any )      ->							List[str]:


														"""simple docstring"""


														_a     					=    np.abs((a - b) ).max()
														self.assertLessEqual(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE							,      F'Difference between torch and flax is {diff} (>= {tol}).' )







							def        __lowerCAmelCase      (  self	:  Tuple							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  Tuple							,      lowerCAmelCase_	:  Tuple							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  List[str]=None							,      **lowerCAmelCase_	:  Optional[Any] )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    VisionTextDualEncoderConfig.from_vision_text_configs(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )

														_a     					=    FlaxVisionTextDualEncoderModel(_SCREAMING_SNAKE_CASE )

														_a     					=    model(input_ids=_SCREAMING_SNAKE_CASE							,      pixel_values=_SCREAMING_SNAKE_CASE							,      attention_mask=_SCREAMING_SNAKE_CASE )

														self.assertEqual(output['''text_embeds'''].shape							,      (input_ids.shape[0], config.projection_dim) )
														self.assertEqual(output['''image_embeds'''].shape							,      (pixel_values.shape[0], config.projection_dim) )







							def        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  List[Any]							,      lowerCAmelCase_	:  Optional[Any]=None							,      **lowerCAmelCase_	:  Optional[int] )      ->							List[Any]:


														"""simple docstring"""


														_a					,							_a     					=    self.get_vision_text_model(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )
														_a     					=    {'''vision_model''': vision_model, '''text_model''': text_model}
														_a     					=    FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**_SCREAMING_SNAKE_CASE )

														_a     					=    model(input_ids=_SCREAMING_SNAKE_CASE							,      pixel_values=_SCREAMING_SNAKE_CASE							,      attention_mask=_SCREAMING_SNAKE_CASE )

														self.assertEqual(output['''text_embeds'''].shape							,      (input_ids.shape[0], model.config.projection_dim) )
														self.assertEqual(output['''image_embeds'''].shape							,      (pixel_values.shape[0], model.config.projection_dim) )







							def        __lowerCAmelCase      (  self	:  Dict							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  List[Any]							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  Dict=None							,      **lowerCAmelCase_	:  int )      ->							Optional[Any]:


														"""simple docstring"""


														_a					,							_a     					=    self.get_vision_text_model(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )
														_a     					=    {'''vision_model''': vision_model, '''text_model''': text_model}
														_a     					=    FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**_SCREAMING_SNAKE_CASE )

														_a     					=    model(input_ids=_SCREAMING_SNAKE_CASE							,      pixel_values=_SCREAMING_SNAKE_CASE							,      attention_mask=_SCREAMING_SNAKE_CASE )
														_a     					=    output[0]

														with tempfile.TemporaryDirectory() as tmpdirname:
																					model.save_pretrained(_SCREAMING_SNAKE_CASE )
																					_a     					=    FlaxVisionTextDualEncoderModel.from_pretrained(_SCREAMING_SNAKE_CASE )

																					_a     					=    model(input_ids=_SCREAMING_SNAKE_CASE							,      pixel_values=_SCREAMING_SNAKE_CASE							,      attention_mask=_SCREAMING_SNAKE_CASE )
																					_a     					=    after_output[0]
																					_a     					=    np.amax(np.abs(out_a - out_a ) )
																					self.assertLessEqual(_SCREAMING_SNAKE_CASE							,      1e-3 )







							def        __lowerCAmelCase      (  self	:  Dict							,      lowerCAmelCase_	:  Optional[Any]							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Tuple							,      lowerCAmelCase_	:  Optional[int]=None							,      **lowerCAmelCase_	:  Union[str, Any] )      ->							int:


														"""simple docstring"""


														_a					,							_a     					=    self.get_vision_text_model(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )
														_a     					=    {'''vision_model''': vision_model, '''text_model''': text_model}
														_a     					=    FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**_SCREAMING_SNAKE_CASE )

														_a     					=    model(
														    input_ids=_SCREAMING_SNAKE_CASE							,      pixel_values=_SCREAMING_SNAKE_CASE							,      attention_mask=_SCREAMING_SNAKE_CASE							,      output_attentions=_SCREAMING_SNAKE_CASE )

														_a     					=    output.vision_model_output.attentions
														self.assertEqual(len(_SCREAMING_SNAKE_CASE )							,      vision_config.num_hidden_layers )

														# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
														_a     					=    to_atuple(vision_model.config.image_size )
														_a     					=    to_atuple(vision_model.config.patch_size )
														_a     					=    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
														_a     					=    num_patches + 1
														self.assertEqual(vision_attentions[0].shape[-3:]							,      (vision_config.num_attention_heads, seq_len, seq_len) )

														_a     					=    output.text_model_output.attentions
														self.assertEqual(len(_SCREAMING_SNAKE_CASE )							,      text_config.num_hidden_layers )

														self.assertEqual(
														    text_attentions[0].shape[-3:]							,      (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])							,      )







							def        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Any )      ->							Optional[int]:


														"""simple docstring"""


														pt_model.to(_SCREAMING_SNAKE_CASE )
														pt_model.eval()

														# prepare inputs
														_a     					=    inputs_dict
														_a     					=    {k: torch.tensor(v.tolist() ) for k, v in flax_inputs.items()}

														with torch.no_grad():
																					_a     					=    pt_model(**_SCREAMING_SNAKE_CASE ).to_tuple()

														_a     					=    fx_model(**_SCREAMING_SNAKE_CASE ).to_tuple()
														self.assertEqual(len(_SCREAMING_SNAKE_CASE )							,      len(_SCREAMING_SNAKE_CASE )							,      '''Output lengths differ between Flax and PyTorch''' )
														for fx_output, pt_output in zip(fx_outputs[:4]							,      pt_outputs[:4] ):
																					self.assert_almost_equals(_SCREAMING_SNAKE_CASE							,      pt_output.numpy()							,      4e-2 )

														# PT -> Flax
														with tempfile.TemporaryDirectory() as tmpdirname:
																					pt_model.save_pretrained(_SCREAMING_SNAKE_CASE )
																					_a     					=    FlaxVisionTextDualEncoderModel.from_pretrained(_SCREAMING_SNAKE_CASE							,      from_pt=_SCREAMING_SNAKE_CASE )

														_a     					=    fx_model_loaded(**_SCREAMING_SNAKE_CASE ).to_tuple()
														self.assertEqual(len(_SCREAMING_SNAKE_CASE )							,      len(_SCREAMING_SNAKE_CASE )							,      '''Output lengths differ between Flax and PyTorch''' )
														for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4]							,      pt_outputs[:4] ):
																					self.assert_almost_equals(_SCREAMING_SNAKE_CASE							,      pt_output.numpy()							,      4e-2 )

														# Flax -> PT
														with tempfile.TemporaryDirectory() as tmpdirname:
																					fx_model.save_pretrained(_SCREAMING_SNAKE_CASE )
																					_a     					=    VisionTextDualEncoderModel.from_pretrained(_SCREAMING_SNAKE_CASE							,      from_flax=_SCREAMING_SNAKE_CASE )

														pt_model_loaded.to(_SCREAMING_SNAKE_CASE )
														pt_model_loaded.eval()

														with torch.no_grad():
																					_a     					=    pt_model_loaded(**_SCREAMING_SNAKE_CASE ).to_tuple()

														self.assertEqual(len(_SCREAMING_SNAKE_CASE )							,      len(_SCREAMING_SNAKE_CASE )							,      '''Output lengths differ between Flax and PyTorch''' )
														for fx_output, pt_output_loaded in zip(fx_outputs[:4]							,      pt_outputs_loaded[:4] ):
																					self.assert_almost_equals(_SCREAMING_SNAKE_CASE							,      pt_output_loaded.numpy()							,      4e-2 )







							def        __lowerCAmelCase      (  self	:  Optional[int]							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  Dict )      ->							Tuple:


														"""simple docstring"""


														_a     					=    VisionTextDualEncoderConfig.from_vision_text_configs(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )

														_a     					=    VisionTextDualEncoderModel(_SCREAMING_SNAKE_CASE )
														_a     					=    FlaxVisionTextDualEncoderModel(_SCREAMING_SNAKE_CASE )

														_a     					=    convert_pytorch_state_dict_to_flax(pt_model.state_dict()							,      _SCREAMING_SNAKE_CASE )
														_a     					=    fx_state

														self.check_pt_flax_equivalence(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )







							def        __lowerCAmelCase      (  self	:  Any							,      lowerCAmelCase_	:  List[Any]							,      lowerCAmelCase_	:  Union[str, Any]							,      lowerCAmelCase_	:  Tuple )      ->							Dict:


														"""simple docstring"""


														_a     					=    VisionTextDualEncoderConfig.from_vision_text_configs(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )

														_a     					=    VisionTextDualEncoderModel(_SCREAMING_SNAKE_CASE )
														_a     					=    FlaxVisionTextDualEncoderModel(_SCREAMING_SNAKE_CASE )

														_a     					=    load_flax_weights_in_pytorch_model(_SCREAMING_SNAKE_CASE							,      fx_model.params )

														self.check_pt_flax_equivalence(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Tuple:


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														self.check_model_from_pretrained_configs(**_SCREAMING_SNAKE_CASE )







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							Any:


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														self.check_vision_text_dual_encoder_from_pretrained(**_SCREAMING_SNAKE_CASE )







							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							str:


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														self.check_save_load(**_SCREAMING_SNAKE_CASE )







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							str:


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														self.check_vision_text_output_attention(**_SCREAMING_SNAKE_CASE )







							@is_pt_flax_cross_test
							def        __lowerCAmelCase      (  self	:  Dict )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														_a     					=    config_inputs_dict.pop('''vision_config''' )
														_a     					=    config_inputs_dict.pop('''text_config''' )

														_a     					=    config_inputs_dict

														self.check_equivalence_pt_to_flax(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )
														self.check_equivalence_flax_to_pt(_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE )







							@slow
							def        __lowerCAmelCase      (  self	:  Dict )      ->							Dict:


														"""simple docstring"""


														_a					,							_a     					=    self.get_pretrained_model_and_inputs()

														_a     					=    model_a(**_SCREAMING_SNAKE_CASE )
														_a     					=    outputs[0]

														with tempfile.TemporaryDirectory() as tmp_dirname:
																					model_a.save_pretrained(_SCREAMING_SNAKE_CASE )
																					_a     					=    FlaxVisionTextDualEncoderModel.from_pretrained(_SCREAMING_SNAKE_CASE )

																					_a     					=    model_a(**_SCREAMING_SNAKE_CASE )
																					_a     					=    after_outputs[0]
																					_a     					=    np.amax(np.abs(out_a - out_a ) )
																					self.assertLessEqual(_SCREAMING_SNAKE_CASE							,      1e-5 )



@require_flax
class       A   (		lowerCAmelCase__					,unittest.TestCase   ):







							def        __lowerCAmelCase      (  self	:  int )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
														    '''hf-internal-testing/tiny-random-vit'''							,      '''hf-internal-testing/tiny-bert'''							,      vision_from_pt=_SCREAMING_SNAKE_CASE							,      text_from_pt=_SCREAMING_SNAKE_CASE							,      )
														_a     					=    13
														_a     					=    floats_tensor(
														    [
														        batch_size,
														        model.config.vision_config.num_channels,
														        model.config.vision_config.image_size,
														        model.config.vision_config.image_size,
														    ] )
														_a     					=    ids_tensor([batch_size, 4]							,      model.config.text_config.vocab_size )
														_a     					=    random_attention_mask([batch_size, 4] )
														_a     					=    {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

														return model, inputs







							def        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  Any )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    FlaxViTModel(_SCREAMING_SNAKE_CASE )
														_a     					=    FlaxBertModel(_SCREAMING_SNAKE_CASE )
														return vision_model, text_model







							def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    FlaxViTModelTester(self )
														_a     					=    FlaxBertModelTester(self )
														_a     					=    vit_model_tester.prepare_config_and_inputs()
														_a     					=    bert_model_tester.prepare_config_and_inputs()

														_a					,							_a     					=    vision_config_and_inputs

														_a					,							_a					,							_a					,							_a     					=    text_config_and_inputs

														# make sure that cross attention layers are added
														return {
														    "text_config": text_config,
														    "vision_config": vision_config,
														    "pixel_values": pixel_values,
														    "attention_mask": attention_mask,
														    "input_ids": input_ids,
														    "token_type_ids": token_type_ids,
														}



@require_torch
class       A   (		lowerCAmelCase__					,unittest.TestCase   ):







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Any:


														"""simple docstring"""


														_a     					=    FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
														    '''hf-internal-testing/tiny-random-clip'''							,      '''hf-internal-testing/tiny-bert'''							,      vision_from_pt=_SCREAMING_SNAKE_CASE							,      text_from_pt=_SCREAMING_SNAKE_CASE							,      )
														_a     					=    13
														_a     					=    floats_tensor(
														    [
														        batch_size,
														        model.config.vision_config.num_channels,
														        model.config.vision_config.image_size,
														        model.config.vision_config.image_size,
														    ] )
														_a     					=    ids_tensor([batch_size, 4]							,      model.config.text_config.vocab_size )
														_a     					=    random_attention_mask([batch_size, 4] )
														_a     					=    {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

														return model, inputs







							def        __lowerCAmelCase      (  self	:  Optional[Any]							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  Dict )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    FlaxCLIPVisionModel(_SCREAMING_SNAKE_CASE )
														_a     					=    FlaxBertModel(_SCREAMING_SNAKE_CASE )
														return vision_model, text_model







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							int:


														"""simple docstring"""


														_a     					=    FlaxCLIPVisionModelTester(self )
														_a     					=    FlaxBertModelTester(self )
														_a     					=    clip_model_tester.prepare_config_and_inputs()
														_a     					=    bert_model_tester.prepare_config_and_inputs()

														_a					,							_a     					=    vision_config_and_inputs

														_a					,							_a					,							_a					,							_a     					=    text_config_and_inputs

														# make sure that cross attention layers are added
														return {
														    "text_config": text_config,
														    "vision_config": vision_config,
														    "pixel_values": pixel_values,
														    "attention_mask": attention_mask,
														    "input_ids": input_ids,
														    "token_type_ids": token_type_ids,
														}



@require_flax
@require_vision
class       A   (		unittest.TestCase   ):







							@slow
							def        __lowerCAmelCase      (  self	:  Any )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    FlaxVisionTextDualEncoderModel.from_pretrained('''clip-italian/clip-italian'''							,      logit_scale_init_value=1.0 )
														_a     					=    VisionTextDualEncoderProcessor.from_pretrained('''clip-italian/clip-italian''' )

														_a     					=    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
														_a     					=    processor(
														    text=['''una foto di un gatto''', '''una foto di un cane''']							,      images=_SCREAMING_SNAKE_CASE							,      padding=_SCREAMING_SNAKE_CASE							,      return_tensors='''np''' )

														_a     					=    model(**_SCREAMING_SNAKE_CASE )

														# verify the logits
														self.assertEqual(outputs.logits_per_image.shape							,      (inputs.pixel_values.shape[0], inputs.input_ids.shape[0]) )
														self.assertEqual(
														    outputs.logits_per_text.shape							,      (inputs.input_ids.shape[0], inputs.pixel_values.shape[0])							,      )

														_a     					=    np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]] )

														self.assertTrue(np.allclose(outputs.logits_per_image							,      _SCREAMING_SNAKE_CASE							,      atol=1e-3 ) )







'''simple docstring'''


import argparse
from collections import defaultdict

import yaml


_snake_case				:				int       							=		'docs/source/en/_toctree.yml'
def 		snake_case_   (UpperCamelCase	:  Optional[int]				):





							'''simple docstring'''


							_a     					=    defaultdict(UpperCamelCase				)
							for doc in model_doc:
														counts[doc["local"]] += 1
							_a     					=    [key for key, value in counts.items() if value > 1]

							_a     					=    []
							for duplicate_key in duplicates:
														_a     					=    list({doc['''title'''] for doc in model_doc if doc['''local'''] == duplicate_key}				)
														if len(UpperCamelCase				) > 1:
																					raise ValueError(
																					    f'{duplicate_key} is present several times in the documentation table of content at '
																					    '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the '''
																					    '''others.'''				)
														# Only add this once
														new_doc.append({'''local''': duplicate_key, '''title''': titles[0]}				)

							# Add none duplicate-keys
							new_doc.extend([doc for doc in model_doc if counts[doc['''local''']] == 1]				)

							# Sort
							return sorted(UpperCamelCase			,						key=lambda UpperCamelCase				: s["title"].lower()				)
def 		snake_case_   (UpperCamelCase	:  str=False				):





							'''simple docstring'''


							with open(UpperCamelCase			,						encoding='''utf-8'''				) as f:
														_a     					=    yaml.safe_load(f.read()				)

							# Get to the API doc
							_a     					=    0
							while content[api_idx]["title"] != "API":
														api_idx += 1
							_a     					=    content[api_idx]['''sections''']

							# Then to the model doc
							_a     					=    0
							while api_doc[model_idx]["title"] != "Models":
														model_idx += 1

							_a     					=    api_doc[model_idx]['''sections''']

							_a     					=    [(idx, section) for idx, section in enumerate(UpperCamelCase				) if '''sections''' in section]
							_a     					=    False
							for idx, modality_doc in modalities_docs:
														_a     					=    modality_doc['''sections''']
														_a     					=    clean_model_doc_toc(UpperCamelCase				)

														if old_modality_doc != new_modality_doc:
																					_a     					=    True
																					if overwrite:
																												_a     					=    new_modality_doc

							if diff:
														if overwrite:
																					_a     					=    model_doc
																					_a     					=    api_doc
																					with open(UpperCamelCase			,						'''w'''			,						encoding='''utf-8'''				) as f:
																												f.write(yaml.dump(UpperCamelCase			,						allow_unicode=UpperCamelCase				)				)
														else:
																					raise ValueError(
																					    '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.'''				)


if __name__ == "__main__":
				_snake_case				:				List[str]       							=		argparse.ArgumentParser()
				parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
				_snake_case				:				List[Any]       							=		parser.parse_args()

				check_model_doc(args.fix_and_overwrite)

