
from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
					    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
					    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
					    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
					    LayoutLMvaConfig,
					    TFLayoutLMvaForQuestionAnswering,
					    TFLayoutLMvaForSequenceClassification,
					    TFLayoutLMvaForTokenClassification,
					    TFLayoutLMvaModel,
					)

if is_vision_available():
					from PIL import Image

					from transformers import LayoutLMvaImageProcessor





class 							UpperCAmelCase      :




	'''simple docstring'''





	def __init__(       self					: List[Any]							,A					: Optional[Any]							,A					: Optional[Any]=2							,A					: Dict=3							,A					: Union[str, Any]=4							,A					: str=2							,A					: Any=7							,A					: List[str]=True							,A					: List[str]=True							,A					: Optional[Any]=True							,A					: Optional[Any]=True							,A					: Optional[Any]=99							,A					: str=36							,A					: Optional[Any]=2							,A					: List[str]=4							,A					: Optional[Any]=37							,A					: int="gelu"							,A					: int=0.1							,A					: str=0.1							,A					: str=5_12							,A					: str=16							,A					: Tuple=2							,A					: Dict=0.02							,A					: str=6							,A					: Optional[Any]=6							,A					: Tuple=3							,A					: Optional[int]=4							,A					: int=None							,A					: Dict=10_00							,):
					__A   			= parent
					__A   			= batch_size
					__A   			= num_channels
					__A   			= image_size
					__A   			= patch_size
					__A   			= is_training
					__A   			= use_input_mask
					__A   			= use_token_type_ids
					__A   			= use_labels
					__A   			= vocab_size
					__A   			= hidden_size
					__A   			= num_hidden_layers
					__A   			= num_attention_heads
					__A   			= intermediate_size
					__A   			= hidden_act
					__A   			= hidden_dropout_prob
					__A   			= attention_probs_dropout_prob
					__A   			= max_position_embeddings
					__A   			= type_vocab_size
					__A   			= type_sequence_label_size
					__A   			= initializer_range
					__A   			= coordinate_size
					__A   			= shape_size
					__A   			= num_labels
					__A   			= num_choices
					__A   			= scope
					__A   			= range_bbox

					# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
					__A   			= text_seq_length
					__A   			= (image_size // patch_size) ** 2 + 1
					__A   			= self.text_seq_length + self.image_seq_length






	def 				UpperCamelCase_  (       self					: Dict ):
					__A   			= ids_tensor([self.batch_size, self.text_seq_length]							,self.vocab_size )

					__A   			= ids_tensor([self.batch_size, self.text_seq_length, 4]							,self.range_bbox )
					__A   			= bbox.numpy()
					# Ensure that bbox is legal
					for i in range(bbox.shape[0] ):
									for j in range(bbox.shape[1] ):
													if bbox[i, j, 3] < bbox[i, j, 1]:
																	__A   			= bbox[i, j, 3]
																	__A   			= bbox[i, j, 1]
																	__A   			= tmp_coordinate
													if bbox[i, j, 2] < bbox[i, j, 0]:
																	__A   			= bbox[i, j, 2]
																	__A   			= bbox[i, j, 0]
																	__A   			= tmp_coordinate
					__A   			= tf.constant(A )

					__A   			= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

					__A   			= None
					if self.use_input_mask:
									__A   			= random_attention_mask([self.batch_size, self.text_seq_length] )

					__A   			= None
					if self.use_token_type_ids:
									__A   			= ids_tensor([self.batch_size, self.text_seq_length]							,self.type_vocab_size )

					__A   			= None
					__A   			= None
					if self.use_labels:
									__A   			= ids_tensor([self.batch_size]							,self.type_sequence_label_size )
									__A   			= ids_tensor([self.batch_size, self.text_seq_length]							,self.num_labels )

					__A   			= LayoutLMvaConfig(
					    vocab_size=self.vocab_size							,hidden_size=self.hidden_size							,num_hidden_layers=self.num_hidden_layers							,num_attention_heads=self.num_attention_heads							,intermediate_size=self.intermediate_size							,hidden_act=self.hidden_act							,hidden_dropout_prob=self.hidden_dropout_prob							,attention_probs_dropout_prob=self.attention_probs_dropout_prob							,max_position_embeddings=self.max_position_embeddings							,type_vocab_size=self.type_vocab_size							,initializer_range=self.initializer_range							,coordinate_size=self.coordinate_size							,shape_size=self.shape_size							,input_size=self.image_size							,patch_size=self.patch_size							,)

					return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels






	def 				UpperCamelCase_  (       self					: Any							,A					: Optional[Any]							,A					: List[str]							,A					: Optional[Any]							,A					: Any							,A					: Optional[int]							,A					: Union[str, Any] ):
					__A   			= TFLayoutLMvaModel(config=A )

					# text + image
					__A   			= model(A							,pixel_values=A							,training=A )
					__A   			= model(
					    A							,bbox=A							,pixel_values=A							,attention_mask=A							,token_type_ids=A							,training=A							,)
					__A   			= model(A							,bbox=A							,pixel_values=A							,training=A )

					self.parent.assertEqual(result.last_hidden_state.shape							,(self.batch_size, self.seq_length, self.hidden_size) )

					# text only
					__A   			= model(A							,training=A )
					self.parent.assertEqual(
					    result.last_hidden_state.shape							,(self.batch_size, self.text_seq_length, self.hidden_size) )

					# image only
					__A   			= model({"pixel_values": pixel_values}							,training=A )
					self.parent.assertEqual(
					    result.last_hidden_state.shape							,(self.batch_size, self.image_seq_length, self.hidden_size) )






	def 				UpperCamelCase_  (       self					: Union[str, Any]							,A					: Tuple							,A					: List[Any]							,A					: Tuple							,A					: List[str]							,A					: Tuple							,A					: Union[str, Any]							,A					: Tuple ):
					__A   			= self.num_labels
					__A   			= TFLayoutLMvaForSequenceClassification(config=A )
					__A   			= model(
					    A							,bbox=A							,pixel_values=A							,attention_mask=A							,token_type_ids=A							,labels=A							,training=A							,)
					self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.num_labels) )






	def 				UpperCamelCase_  (       self					: int							,A					: Dict							,A					: str							,A					: Tuple							,A					: Optional[Any]							,A					: int							,A					: Any							,A					: Any ):
					__A   			= self.num_labels
					__A   			= TFLayoutLMvaForTokenClassification(config=A )
					__A   			= model(
					    A							,bbox=A							,pixel_values=A							,attention_mask=A							,token_type_ids=A							,labels=A							,training=A							,)
					self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.text_seq_length, self.num_labels) )






	def 				UpperCamelCase_  (       self					: Union[str, Any]							,A					: int							,A					: Tuple							,A					: Optional[Any]							,A					: List[Any]							,A					: List[Any]							,A					: str							,A					: Tuple ):
					__A   			= 2
					__A   			= TFLayoutLMvaForQuestionAnswering(config=A )
					__A   			= model(
					    A							,bbox=A							,pixel_values=A							,attention_mask=A							,token_type_ids=A							,start_positions=A							,end_positions=A							,training=A							,)
					self.parent.assertEqual(result.start_logits.shape							,(self.batch_size, self.seq_length) )
					self.parent.assertEqual(result.end_logits.shape							,(self.batch_size, self.seq_length) )







	def 				UpperCamelCase_  (       self					: int ):
					__A   			= self.prepare_config_and_inputs()
					((__A)			,							(__A)			,							(__A)			,							(__A)			,							(__A)			,							(__A)			,							(__A)			,							(__A))   			= config_and_inputs
					__A   			= {
					    "input_ids": input_ids,
					    "bbox": bbox,
					    "pixel_values": pixel_values,
					    "token_type_ids": token_type_ids,
					    "attention_mask": input_mask,
					}
					return config, inputs_dict





@require_tf
class 							UpperCAmelCase      (  __SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE			,			unittest.TestCase  ):




	'''simple docstring'''





	snake_case_					    =     (
	    (
	        TFLayoutLMvaModel,
	        TFLayoutLMvaForQuestionAnswering,
	        TFLayoutLMvaForSequenceClassification,
	        TFLayoutLMvaForTokenClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	snake_case_					    =     (
	    {"document-question-answering": TFLayoutLMvaForQuestionAnswering, "feature-extraction": TFLayoutLMvaModel}
	    if is_tf_available()
	    else {}
	)

	snake_case_					    =     False
	snake_case_					    =     False
	snake_case_					    =     False






	def 				UpperCamelCase_  (       self					: int							,A					: Optional[Any]							,A					: List[str]							,A					: Optional[int]							,A					: str							,A					: Tuple ):
					return True






	def 				UpperCamelCase_  (       self					: Tuple							,A					: int							,A					: List[Any]							,A					: str=False ):
					__A   			= copy.deepcopy(A )

					if model_class in get_values(A ):
									__A   			= {
									    k: tf.tile(tf.expand_dims(A							,1 )							,(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1) )
									    if isinstance(A							,tf.Tensor ) and v.ndim > 0
									    else v
									    for k, v in inputs_dict.items()
									}

					if return_labels:
									if model_class in get_values(A ):
													__A   			= tf.ones(self.model_tester.batch_size							,dtype=tf.intaa )
									elif model_class in get_values(A ):
													__A   			= tf.zeros(self.model_tester.batch_size							,dtype=tf.intaa )
													__A   			= tf.zeros(self.model_tester.batch_size							,dtype=tf.intaa )
									elif model_class in get_values(A ):
													__A   			= tf.zeros(self.model_tester.batch_size							,dtype=tf.intaa )
									elif model_class in get_values(A ):
													__A   			= tf.zeros(
													    (self.model_tester.batch_size, self.model_tester.text_seq_length)							,dtype=tf.intaa )

					return inputs_dict






	def 				UpperCamelCase_  (       self					: str ):
					__A   			= TFLayoutLMvaModelTester(self )
					__A   			= ConfigTester(self							,config_class=A							,hidden_size=37 )






	def 				UpperCamelCase_  (       self					: Union[str, Any] ):
					self.config_tester.run_common_tests()






	def 				UpperCamelCase_  (       self					: Tuple ):
					__A			,							__A   			= self.model_tester.prepare_config_and_inputs_for_common()
					for model_class in self.all_model_classes:
									__A   			= model_class(A )
									if getattr(A							,"hf_compute_loss"							,A ):
													# The number of elements in the loss should be the same as the number of elements in the label
													__A   			= self._prepare_for_class(inputs_dict.copy()							,A							,return_labels=A )
													__A   			= prepared_for_class[
													    sorted(prepared_for_class.keys() - inputs_dict.keys()							,reverse=A )[0]
													]
													__A   			= added_label.shape.as_list()[:1]

													# Test that model correctly compute the loss with kwargs
													__A   			= self._prepare_for_class(inputs_dict.copy()							,A							,return_labels=A )
													__A   			= prepared_for_class.pop("input_ids" )

													__A   			= model(A							,**A )[0]
													self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )

													# Test that model correctly compute the loss when we mask some positions
													__A   			= self._prepare_for_class(inputs_dict.copy()							,A							,return_labels=A )
													__A   			= prepared_for_class.pop("input_ids" )
													if "labels" in prepared_for_class:
																	__A   			= prepared_for_class["labels"].numpy()
																	if len(labels.shape ) > 1 and labels.shape[1] != 1:
																					__A   			= -1_00
																					__A   			= tf.convert_to_tensor(A )
																					__A   			= model(A							,**A )[0]
																					self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )
																					self.assertTrue(not np.any(np.isnan(loss.numpy() ) ) )

                # Test that model correctly compute the loss with a dict
													__A   			= self._prepare_for_class(inputs_dict.copy()							,A							,return_labels=A )
													__A   			= model(A )[0]
													self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )

													# Test that model correctly compute the loss with a tuple
													__A   			= self._prepare_for_class(inputs_dict.copy()							,A							,return_labels=A )

													# Get keys that were added with the _prepare_for_class function
													__A   			= prepared_for_class.keys() - inputs_dict.keys()
													__A   			= inspect.signature(model.call ).parameters
													__A   			= list(signature.keys() )

													# Create a dictionary holding the location of the tensors in the tuple
													__A   			= {0: "input_ids"}
													for label_key in label_keys:
																	__A   			= signature_names.index(A )
																	__A   			= label_key
													__A   			= sorted(tuple_index_mapping.items() )
													# Initialize a list with their default values, update the values and convert to a tuple
													__A   			= []

													for name in signature_names:
																	if name != "kwargs":
																					list_input.append(signature[name].default )

													for index, value in sorted_tuple_index_mapping:
																	__A   			= prepared_for_class[value]

													__A   			= tuple(A )

													# Send to model
													__A   			= model(tuple_input[:-1] )[0]

													self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )






	def 				UpperCamelCase_  (       self					: Tuple ):
					(
					    (
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							
					)   			= self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(A							,A							,A							,A							,A							,A )






	def 				UpperCamelCase_  (       self					: List[Any] ):
					(
					    (
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							
					)   			= self.model_tester.prepare_config_and_inputs()
					for type in ["absolute", "relative_key", "relative_key_query"]:
									__A   			= type
									self.model_tester.create_and_check_model(A							,A							,A							,A							,A							,A )






	def 				UpperCamelCase_  (       self					: int ):
					(
					    (
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							
					)   			= self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(
					    A							,A							,A							,A							,A							,A							,A )






	def 				UpperCamelCase_  (       self					: Dict ):
					(
					    (
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							
					)   			= self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(
					    A							,A							,A							,A							,A							,A							,A )






	def 				UpperCamelCase_  (       self					: List[Any] ):
					(
					    (
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							(
					    __A
					)			,							
					)   			= self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(
					    A							,A							,A							,A							,A							,A							,A )







	@slow
	def 				UpperCamelCase_  (       self					: str ):
					for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A   			= TFLayoutLMvaModel.from_pretrained(A )
									self.assertIsNotNone(A )





def 						UpperCAmelCase			(	)		->	Any:







				"""simple docstring"""



				__A   			= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
				return image





@require_tf
class 							UpperCAmelCase      (  unittest.TestCase  ):




	'''simple docstring'''





	@cached_property
	def 				UpperCamelCase_  (       self					: Dict ):
					return LayoutLMvaImageProcessor(apply_ocr=A ) if is_vision_available() else None







	@slow
	def 				UpperCamelCase_  (       self					: str ):
					__A   			= TFLayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base" )

					__A   			= self.default_image_processor
					__A   			= prepare_img()
					__A   			= image_processor(images=A							,return_tensors="tf" ).pixel_values

					__A   			= tf.constant([[1, 2]] )
					__A   			= tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]] )							,axis=0 )

					# forward pass
					__A   			= model(input_ids=A							,bbox=A							,pixel_values=A							,training=A )

					# verify the logits
					__A   			= (1, 1_99, 7_68)
					self.assertEqual(outputs.last_hidden_state.shape							,A )

					__A   			= tf.constant(
					    [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]] )

					self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]							,A							,atol=1E-4 ) )


"""simple docstring"""





import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
_a		       =							'src/diffusers'

# Matches is_xxx_available()
_a		       =							re.compile(R'is\_([a-z_]*)_available\(\)')
# Matches from xxx import bla
_a		       =							re.compile(R'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')


_a		       =							'\n{0} = None\n'

_a		       =							'\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n\n    @classmethod\n    def from_config(cls, *args, **kwargs):\n        requires_backends(cls, {1})\n\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        requires_backends(cls, {1})\n'


_a		       =							'\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n'







def 	__a     (		__lowerCamelCase  ):
   UpperCAmelCase_					:					int			     =    _re_backend.findall(__lowerCamelCase  )
   if len(__lowerCamelCase  ) == 0:
      return None

   return "_and_".join(__lowerCamelCase  )







def 	__a     (		):
   with open(os.path.join(__lowerCamelCase,		"__init__.py"  ),		"r",		encoding="utf-8",		newline="\n"  ) as f:
      UpperCAmelCase_					:					Optional[int]			     =    f.readlines()

   # Get to the point we do the actual imports for type checking
   UpperCAmelCase_					:					Union[str, Any]			     =    0
   UpperCAmelCase_					:					Optional[int]			     =    {}
   # Go through the end of the file
   while line_index < len(__lowerCamelCase  ):
      # If the line contains is_backend_available, we grab all objects associated with the `else` block
      UpperCAmelCase_					:					Union[str, Any]			     =    find_backend(lines[line_index]  )
      if backend is not None:
         while not lines[line_index].startswith("else:"  ):
            line_index += 1
         line_index += 1
         UpperCAmelCase_					:					List[str]			     =    []
         # Until we unindent, add backend objects to the list
         while line_index < len(__lowerCamelCase  ) and len(lines[line_index]  ) > 1:
            UpperCAmelCase_					:					Union[str, Any]			     =    lines[line_index]
            UpperCAmelCase_					:					Optional[Any]			     =    _re_single_line_import.search(__lowerCamelCase  )
            if single_line_import_search is not None:
               objects.extend(single_line_import_search.groups()[0].split(", "  )  )
            elif line.startswith(" " * 8  ):
               objects.append(line[8:-2]  )
            line_index += 1

         if len(__lowerCamelCase  ) > 0:
            UpperCAmelCase_					:					Optional[int]			     =    objects
      else:
         line_index += 1

   return backend_specific_objects







def 	__a     (		__lowerCamelCase,		__lowerCamelCase  ):
   if name.isupper():
      return DUMMY_CONSTANT.format(__lowerCamelCase  )
   elif name.islower():
      return DUMMY_FUNCTION.format(__lowerCamelCase,		__lowerCamelCase  )
   else:
      return DUMMY_CLASS.format(__lowerCamelCase,		__lowerCamelCase  )







def 	__a     (		__lowerCamelCase=None  ):
   if backend_specific_objects is None:
      UpperCAmelCase_					:					Tuple			     =    read_init()
   # For special correspondence backend to module name as used in the function requires_modulename
   UpperCAmelCase_					:					str			     =    {}

   for backend, objects in backend_specific_objects.items():
      UpperCAmelCase_					:					int			     =    "[" + ", ".join(f"""\"{b}\"""" for b in backend.split("_and_"  )  ) + "]"
      UpperCAmelCase_					:					Dict			     =    "# This file is autogenerated by the command `make fix-copies`, do not edit.\n"
      dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
      dummy_file += "\n".join([create_dummy_object(__lowerCamelCase,		__lowerCamelCase  ) for o in objects]  )
      UpperCAmelCase_					:					int			     =    dummy_file

   return dummy_files







def 	__a     (		__lowerCamelCase=False  ):
   UpperCAmelCase_					:					Optional[Any]			     =    create_dummy_files()
   # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
   UpperCAmelCase_					:					Union[str, Any]			     =    {"torch": "pt"}

   # Locate actual dummy modules and read their content.
   UpperCAmelCase_					:					List[str]			     =    os.path.join(__lowerCamelCase,		"utils"  )
   UpperCAmelCase_					:					Optional[int]			     =    {
       backend: os.path.join(__lowerCamelCase,		f"""dummy_{short_names.get(__lowerCamelCase,		__lowerCamelCase  )}_objects.py"""  )
       for backend in dummy_files.keys()
   }

   UpperCAmelCase_					:					Any			     =    {}
   for backend, file_path in dummy_file_paths.items():
      if os.path.isfile(__lowerCamelCase  ):
         with open(__lowerCamelCase,		"r",		encoding="utf-8",		newline="\n"  ) as f:
            UpperCAmelCase_					:					Optional[int]			     =    f.read()
      else:
         UpperCAmelCase_					:					Any			     =    ""

   for backend in dummy_files.keys():
      if dummy_files[backend] != actual_dummies[backend]:
         if overwrite:
            print(
                f"""Updating diffusers.utils.dummy_{short_names.get(__lowerCamelCase,		__lowerCamelCase  )}_objects.py as the main """
                "__init__ has new objects."  )
            with open(dummy_file_paths[backend],		"w",		encoding="utf-8",		newline="\n"  ) as f:
               f.write(dummy_files[backend]  )
         else:
            raise ValueError(
                "The main __init__ has objects that are not present in "
                f"""diffusers.utils.dummy_{short_names.get(__lowerCamelCase,		__lowerCamelCase  )}_objects.py. Run `make fix-copies` """
                "to fix this."  )


if __name__ == "__main__":
    _a		       =							argparse.ArgumentParser()
    parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
    _a		       =							parser.parse_args()

    check_dummies(args.fix_and_overwrite)


