




'''simple docstring'''


import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

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


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    TFEfficientFormerForImageClassification,
				    TFEfficientFormerForImageClassificationWithTeacher,
				    TFEfficientFormerModel,
				)
				from transformers.models.efficientformer.modeling_tf_efficientformer import (
				    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				)


if is_vision_available():
				from PIL import Image

				from transformers import EfficientFormerImageProcessor

class      A       :







							def __init__(    self			:    List[str]				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    int = 13				,     lowerCAmelCase_			:    int = 64				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 3				,     lowerCAmelCase_			:    int = 3				,     lowerCAmelCase_			:    bool = True				,     lowerCAmelCase_			:    bool = True				,     lowerCAmelCase_			:    int = 1_28				,     lowerCAmelCase_			:    Any=[16, 32, 64, 1_28]				,     lowerCAmelCase_			:    int = 7				,     lowerCAmelCase_			:    int = 4				,     lowerCAmelCase_			:    int = 37				,     lowerCAmelCase_			:    str = "gelu"				,     lowerCAmelCase_			:    float = 0.1				,     lowerCAmelCase_			:    float = 0.1				,     lowerCAmelCase_			:    int = 10				,     lowerCAmelCase_			:    float = 0.0_2				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 1				,     lowerCAmelCase_			:    int = 1_28				,     lowerCAmelCase_			:    List[int] = [2, 2, 2, 2]				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 2				,     )     ->				Optional[Any]:


														"""simple docstring"""


														_a      	=							parent
														_a      	=							batch_size
														_a      	=							image_size
														_a      	=							patch_size
														_a      	=							num_channels
														_a      	=							is_training
														_a      	=							use_labels
														_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      	=							type_sequence_label_size
														_a      	=							initializer_range
														_a      	=							encoder_stride
														_a      	=							num_attention_outputs
														_a      	=							embed_dim
														_a      	=							embed_dim + 1
														_a      	=							resolution
														_a      	=							depths
														_a      	=							hidden_sizes
														_a      	=							dim
														_a      	=							mlp_expansion_ratio







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


														"""simple docstring"""


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

														_a      	=							None
														if self.use_labels:
																					_a      	=							ids_tensor([self.batch_size]				,     self.type_sequence_label_size   )

														_a      	=							self.get_config()

														return config, pixel_values, labels







							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				int:


														"""simple docstring"""


														return EfficientFormerConfig(
														    image_size=self.image_size				,     patch_size=self.patch_size				,     num_channels=self.num_channels				,     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				,     is_decoder=lowerCAmelCase_				,     initializer_range=self.initializer_range				,     encoder_stride=self.encoder_stride				,     resolution=self.resolution				,     depths=self.depths				,     hidden_sizes=self.hidden_sizes				,     dim=self.dim				,     mlp_expansion_ratio=self.mlp_expansion_ratio				,     )







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


														"""simple docstring"""


														_a      	=							TFEfficientFormerModel(config=lowerCAmelCase_   )
														_a      	=							model(lowerCAmelCase_				,     training=lowerCAmelCase_   )
														self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)   )







							def   __lowerCAmelCase     (    self			:    Tuple				,     lowerCAmelCase_			:    Any				,     lowerCAmelCase_			:    Dict				,     lowerCAmelCase_			:    Dict   )     ->				Tuple:


														"""simple docstring"""


														_a      	=							self.type_sequence_label_size
														_a      	=							TFEfficientFormerForImageClassification(lowerCAmelCase_   )
														_a      	=							model(lowerCAmelCase_				,     labels=lowerCAmelCase_				,     training=lowerCAmelCase_   )
														self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.type_sequence_label_size)   )

														# test greyscale images
														_a      	=							1
														_a      	=							TFEfficientFormerForImageClassification(lowerCAmelCase_   )

														_a      	=							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
														_a      	=							model(lowerCAmelCase_				,     labels=lowerCAmelCase_   )
														self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.type_sequence_label_size)   )







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


														"""simple docstring"""


														_a      	=							self.prepare_config_and_inputs()
														_a	,				_a	,				_a      	=							config_and_inputs
														_a      	=							{'''pixel_values''': pixel_values}
														return config, inputs_dict



@require_tf
class      A       (						_a	,_a	,unittest.TestCase       ):
							lowercase_							     =							(
							    (
							        TFEfficientFormerModel,
							        TFEfficientFormerForImageClassificationWithTeacher,
							        TFEfficientFormerForImageClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							lowercase_							     =							(
							    {
							        'feature-extraction': TFEfficientFormerModel,
							        'image-classification': (
							            TFEfficientFormerForImageClassification,
							            TFEfficientFormerForImageClassificationWithTeacher,
							        ),
							    }
							    if is_tf_available()
							    else {}
							)

							lowercase_							     =							False

							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False







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


														"""simple docstring"""


														_a      	=							TFEfficientFormerModelTester(self   )
														_a      	=							ConfigTester(
														    self				,     config_class=lowerCAmelCase_				,     has_text_modality=lowerCAmelCase_				,     hidden_size=37   )







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


														"""simple docstring"""


														self.config_tester.run_common_tests()







							@unittest.skip(reason='''EfficientFormer does not use inputs_embeds'''   )
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				int:


														"""simple docstring"""


														pass







							@unittest.skip(reason='''EfficientFormer does not support input and output embeddings'''   )
							def   __lowerCAmelCase     (    self			:    Any   )     ->				int:


														"""simple docstring"""


														pass







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


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					_a      	=							model_class(lowerCAmelCase_   )
																					_a      	=							inspect.signature(model.call   )
																					# signature.parameters is an OrderedDict => so arg_names order is deterministic
																					_a      	=							[*signature.parameters.keys()]

																					_a      	=							['''pixel_values''']
																					self.assertListEqual(arg_names[:1]				,     lowerCAmelCase_   )







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


														"""simple docstring"""


														def check_hidden_states_output(lowerCAmelCase_			:    List[str]				,     lowerCAmelCase_			:    Optional[Any]				,     lowerCAmelCase_			:    Optional[int]   ):
																					_a      	=							model_class(lowerCAmelCase_   )

																					_a      	=							model(**self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )				,     training=lowerCAmelCase_   )
																					_a      	=							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																					_a      	=							getattr(
																					    self.model_tester				,     '''expected_num_hidden_layers'''				,     self.model_tester.num_hidden_layers + 1   )
																					self.assertEqual(len(lowerCAmelCase_   )				,     lowerCAmelCase_   )

																					if hasattr(self.model_tester				,     '''encoder_seq_length'''   ):
																												_a      	=							self.model_tester.encoder_seq_length
																												if hasattr(self.model_tester				,     '''chunk_length'''   ) and self.model_tester.chunk_length > 1:
																																			_a      	=							seq_length * self.model_tester.chunk_length
																					else:
																												_a      	=							self.model_tester.seq_length

																					self.assertListEqual(
																					    list(hidden_states[-1].shape[-2:]   )				,     [seq_length, self.model_tester.hidden_size]				,     )

																					if config.is_encoder_decoder:
																												_a      	=							outputs.decoder_hidden_states

																												self.asseretIsInstance(lowerCAmelCase_				,     (list, tuple)   )
																												self.assertEqual(len(lowerCAmelCase_   )				,     lowerCAmelCase_   )
																												_a      	=							getattr(self.model_tester				,     '''seq_length'''				,     lowerCAmelCase_   )
																												_a      	=							getattr(self.model_tester				,     '''decoder_seq_length'''				,     lowerCAmelCase_   )

																												self.assertListEqual(
																												    list(hidden_states[-1].shape[-2:]   )				,     [decoder_seq_length, self.model_tester.hidden_size]				,     )

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					_a      	=							True
																					check_hidden_states_output(lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_   )

																					# check that output_hidden_states also work using config
																					del inputs_dict["output_hidden_states"]
																					_a      	=							True

																					check_hidden_states_output(lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_   )







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


														"""simple docstring"""


														_a      	=							super()._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_				,     return_labels=lowerCAmelCase_   )

														if return_labels:
																					if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
																												del inputs_dict["labels"]

														return inputs_dict







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


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCAmelCase_   )







							@unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet'''   )
							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				List[Any]:


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_   )







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


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_   )







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


														"""simple docstring"""


														for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					_a      	=							TFEfficientFormerModel.from_pretrained(lowerCAmelCase_   )
																					self.assertIsNotNone(lowerCAmelCase_   )







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


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()
														_a      	=							True

														_a      	=							getattr(self.model_tester				,     '''seq_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''encoder_seq_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''key_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''chunk_length'''				,     lowerCAmelCase_   )

														if chunk_length is not None and hasattr(self.model_tester				,     '''num_hashes'''   ):
																					_a      	=							encoder_seq_length * self.model_tester.num_hashes

														for model_class in self.all_model_classes:
																					_a      	=							True
																					_a      	=							False
																					_a      	=							True
																					_a      	=							model_class(lowerCAmelCase_   )

																					_a      	=							model(**self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )				,     training=lowerCAmelCase_   )
																					_a      	=							outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																					self.assertEqual(len(lowerCAmelCase_   )				,     self.model_tester.num_attention_outputs   )

																					# check that output_attentions also work using config
																					del inputs_dict["output_attentions"]
																					_a      	=							True
																					_a      	=							model_class(lowerCAmelCase_   )
																					_a      	=							model(**self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )				,     training=lowerCAmelCase_   )

																					_a      	=							outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																					self.assertEqual(len(lowerCAmelCase_   )				,     self.model_tester.num_attention_outputs   )

																					if chunk_length is not None:
																												self.assertListEqual(
																												    list(attentions[0].shape[-4:]   )				,     [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]				,     )
																					else:
																												self.assertListEqual(
																												    list(attentions[0].shape[-3:]   )				,     [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]				,     )







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


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					# Prepare our model
																					_a      	=							model_class(lowerCAmelCase_   )
																					# These are maximally general inputs for the model, with multiple None dimensions
																					# Hopefully this will catch any conditionals that fail for flexible shapes
																					_a      	=							{
																					    key: tf.keras.Input(shape=val.shape[1:]				,     dtype=val.dtype				,     name=lowerCAmelCase_   )
																					    for key, val in model.input_signature.items()
																					    if key in model.dummy_inputs
																					}
																					_a      	=							model(lowerCAmelCase_   )
																					self.assertTrue(outputs_dict is not None   )



def 						snake_case_       ():





							'''simple docstring'''


							_a      	=							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
							return image

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







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


														"""simple docstring"""


														return (
														    EfficientFormerImageProcessor.from_pretrained('''snap-research/efficientformer-l1-300'''   )
														    if is_vision_available()
														    else None
														)







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


														"""simple docstring"""


														_a      	=							TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''   )
														_a      	=							self.default_image_processor
														_a      	=							prepare_img()
														_a      	=							image_processor(images=lowerCAmelCase_				,     return_tensors='''tf'''   )
														# forward pass
														_a      	=							model(**lowerCAmelCase_				,     training=lowerCAmelCase_   )
														# verify the logits
														_a      	=							tf.TensorShape((1, 10_00)   )
														self.assertEqual(outputs.logits.shape				,     lowerCAmelCase_   )
														_a      	=							tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]   )
														self.assertTrue(np.allclose(outputs.logits[0, :3]				,     lowerCAmelCase_				,     atol=1e-4   )   )







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


														"""simple docstring"""


														_a      	=							TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
														    '''snap-research/efficientformer-l1-300'''   )
														_a      	=							self.default_image_processor
														_a      	=							prepare_img()
														_a      	=							image_processor(images=lowerCAmelCase_				,     return_tensors='''tf'''   )
														# forward pass
														_a      	=							model(**lowerCAmelCase_				,     training=lowerCAmelCase_   )
														# verify the logits
														_a      	=							tf.TensorShape((1, 10_00)   )
														self.assertEqual(outputs.logits.shape				,     lowerCAmelCase_   )
														_a      	=							tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]   )
														self.assertTrue(np.allclose(outputs.logits[0, :3]				,     lowerCAmelCase_				,     atol=1e-4   )   )







'''simple docstring'''







import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
lowercase      :   Tuple      =       sys.version_info >= (3, 10)



def        lowerCamelCase__				(      __lowercase=None     ,   __lowercase=None				):
     return field(default_factory=lambda: default     ,   metadata=__lowercase				)







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     int
     lowerCAmelCase_  :     float
     lowerCAmelCase_  :     str
     lowerCAmelCase_  :     bool







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     int          =					42
     lowerCAmelCase_  :     str          =					field(default="""toto""",		metadata={"""help""": """help message"""}	)







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     bool          =					False
     lowerCAmelCase_  :     bool          =					True
     lowerCAmelCase_  :     Optional[bool]          =					None







class 					_a (a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     int          =					"""titi"""
     lowerCAmelCase_  :     Optional[int]          =					"""toto"""







class 					_a (a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Any          =					"""titi"""
     lowerCAmelCase_  :     Dict          =					"""toto"""
     lowerCAmelCase_  :     int          =					42







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     BasicEnum          =					"toto"







     def 			snake_case_      (				self							)      ->				str:
          snake_case			:      Union[str, Any]        =			BasicEnum(self.foo							)







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     MixedTypeEnum          =					"toto"







     def 			snake_case_      (				self							)      ->				Tuple:
          snake_case			:      List[str]        =			MixedTypeEnum(self.foo							)







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     Optional[int]          =					None
     lowerCAmelCase_  :     Optional[float]          =					field(default=a__,		metadata={"""help""": """help message"""}	)
     lowerCAmelCase_  :     Optional[str]          =					None
     lowerCAmelCase_  :     Optional[List[str]]          =					list_field(default=[]	)
     lowerCAmelCase_  :     Optional[List[int]]          =					list_field(default=[]	)







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     List[int]          =					list_field(default=[]	)
     lowerCAmelCase_  :     List[int]          =					list_field(default=[1, 2, 3]	)
     lowerCAmelCase_  :     List[str]          =					list_field(default=["""Hallo""", """Bonjour""", """Hello"""]	)
     lowerCAmelCase_  :     List[float]          =					list_field(default=[0.1, 0.2, 0.3]	)







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     List[int]          =					field()
     lowerCAmelCase_  :     str          =					field()
     lowerCAmelCase_  :     BasicEnum          =					field()







     def 			snake_case_      (				self							)      ->				int:
          snake_case			:      Optional[int]        =			BasicEnum(self.required_enum							)







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     int
     lowerCAmelCase_  :     "BasicEnum"          =					field()
     lowerCAmelCase_  :     "Optional[bool]"          =					None
     lowerCAmelCase_  :     "str"          =					field(default="""toto""",		metadata={"""help""": """help message"""}	)
     lowerCAmelCase_  :     "List[str]"          =					list_field(default=["""Hallo""", """Bonjour""", """Hello"""]	)


if is_python_no_less_than_3_10:







      @dataclass
      class 					_a :





           '''simple docstring'''



           lowerCAmelCase_  :     bool          =					False
           lowerCAmelCase_  :     bool          =					True
           lowerCAmelCase_  :     bool | None          =					None







      @dataclass
      class 					_a :





           '''simple docstring'''



           lowerCAmelCase_  :     int | None          =					None
           lowerCAmelCase_  :     float | None          =					field(default=a__,		metadata={"""help""": """help message"""}	)
           lowerCAmelCase_  :     str | None          =					None
           lowerCAmelCase_  :     list[str] | None          =					list_field(default=[]	)
           lowerCAmelCase_  :     list[int] | None          =					list_field(default=[]	)







class 					_a (unittest.TestCase	):





     '''simple docstring'''



     def 			snake_case_      (				self							,__a							,__a							)      ->				Optional[int]:
          self.assertEqual(len(a._actions							)							,len(b._actions							)							)
          for x, y in zip(a._actions							,b._actions							):
               snake_case			:      Optional[int]        =			{k: v for k, v in vars(__a							).items() if k != """container"""}
               snake_case			:      Tuple        =			{k: v for k, v in vars(__a							).items() if k != """container"""}

               # Choices with mixed type have custom function as "type"
               # So we need to compare results directly for equality
               if xx.get("""choices"""							,__a							) and yy.get("""choices"""							,__a							):
                    for expected_choice in yy["choices"] + xx["choices"]:
                         self.assertEqual(xx["""type"""](__a							)							,yy["""type"""](__a							)							)
                    del xx["type"], yy["type"]

               self.assertEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				int:
          snake_case			:      str        =			HfArgumentParser(__a							)

          snake_case			:      Dict        =			argparse.ArgumentParser()
          expected.add_argument("""--foo"""							,type=__a							,required=__a							)
          expected.add_argument("""--bar"""							,type=__a							,required=__a							)
          expected.add_argument("""--baz"""							,type=__a							,required=__a							)
          expected.add_argument("""--flag"""							,type=__a							,default=__a							,const=__a							,nargs="""?"""							)
          self.argparsersEqual(__a							,__a							)

          snake_case			:      Optional[int]        =			["""--foo""", """1""", """--baz""", """quux""", """--bar""", """0.5"""]
          ((snake_case) ,		)			:      Dict        =			parser.parse_args_into_dataclasses(__a							,look_for_args_file=__a							)
          self.assertFalse(example.flag							)







     def 			snake_case_      (				self							)      ->				int:
          snake_case			:      Optional[int]        =			HfArgumentParser(__a							)

          snake_case			:      str        =			argparse.ArgumentParser()
          expected.add_argument("""--foo"""							,default=42							,type=__a							)
          expected.add_argument("""--baz"""							,default="""toto"""							,type=__a							,help="""help message"""							)
          self.argparsersEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				Optional[Any]:
          snake_case			:      Optional[int]        =			argparse.ArgumentParser()
          expected.add_argument("""--foo"""							,type=__a							,default=__a							,const=__a							,nargs="""?"""							)
          expected.add_argument("""--baz"""							,type=__a							,default=__a							,const=__a							,nargs="""?"""							)
          # A boolean no_* argument always has to come after its "default: True" regular counter-part
          # and its default must be set to False
          expected.add_argument("""--no_baz"""							,action="""store_false"""							,default=__a							,dest="""baz"""							)
          expected.add_argument("""--opt"""							,type=__a							,default=__a							)

          snake_case			:      str        =			[WithDefaultBoolExample]
          if is_python_no_less_than_3_10:
               dataclass_types.append(__a							)

          for dataclass_type in dataclass_types:
               snake_case			:      Optional[int]        =			HfArgumentParser(__a							)
               self.argparsersEqual(__a							,__a							)

               snake_case			:      List[str]        =			parser.parse_args([]							)
               self.assertEqual(__a							,Namespace(foo=__a							,baz=__a							,opt=__a							)							)

               snake_case			:      str        =			parser.parse_args(["""--foo""", """--no_baz"""]							)
               self.assertEqual(__a							,Namespace(foo=__a							,baz=__a							,opt=__a							)							)

               snake_case			:      Union[str, Any]        =			parser.parse_args(["""--foo""", """--baz"""]							)
               self.assertEqual(__a							,Namespace(foo=__a							,baz=__a							,opt=__a							)							)

               snake_case			:      Union[str, Any]        =			parser.parse_args(["""--foo""", """True""", """--baz""", """True""", """--opt""", """True"""]							)
               self.assertEqual(__a							,Namespace(foo=__a							,baz=__a							,opt=__a							)							)

               snake_case			:      List[str]        =			parser.parse_args(["""--foo""", """False""", """--baz""", """False""", """--opt""", """False"""]							)
               self.assertEqual(__a							,Namespace(foo=__a							,baz=__a							,opt=__a							)							)







     def 			snake_case_      (				self							)      ->				str:
          snake_case			:      Any        =			HfArgumentParser(__a							)

          snake_case			:      Union[str, Any]        =			argparse.ArgumentParser()
          expected.add_argument(
              """--foo"""							,default="""toto"""							,choices=["""titi""", """toto""", 42]							,type=make_choice_type_function(["""titi""", """toto""", 42]							)							,)
          self.argparsersEqual(__a							,__a							)

          snake_case			:      Any        =			parser.parse_args([]							)
          self.assertEqual(args.foo							,"""toto"""							)
          snake_case			:      str        =			parser.parse_args_into_dataclasses([]							)[0]
          self.assertEqual(enum_ex.foo							,MixedTypeEnum.toto							)

          snake_case			:      Optional[Any]        =			parser.parse_args(["""--foo""", """titi"""]							)
          self.assertEqual(args.foo							,"""titi"""							)
          snake_case			:      Optional[Any]        =			parser.parse_args_into_dataclasses(["""--foo""", """titi"""]							)[0]
          self.assertEqual(enum_ex.foo							,MixedTypeEnum.titi							)

          snake_case			:      Any        =			parser.parse_args(["""--foo""", """42"""]							)
          self.assertEqual(args.foo							,42							)
          snake_case			:      Any        =			parser.parse_args_into_dataclasses(["""--foo""", """42"""]							)[0]
          self.assertEqual(enum_ex.foo							,MixedTypeEnum.fourtytwo							)







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







          @dataclass
          class 					_a :





               '''simple docstring'''



               lowerCAmelCase_  :     Literal["titi", "toto", 42]          =					"toto"
          snake_case			:      Tuple        =			HfArgumentParser(__a							)

          snake_case			:      List[Any]        =			argparse.ArgumentParser()
          expected.add_argument(
              """--foo"""							,default="""toto"""							,choices=("""titi""", """toto""", 42)							,type=make_choice_type_function(["""titi""", """toto""", 42]							)							,)
          self.argparsersEqual(__a							,__a							)

          snake_case			:      Optional[int]        =			parser.parse_args([]							)
          self.assertEqual(args.foo							,"""toto"""							)

          snake_case			:      int        =			parser.parse_args(["""--foo""", """titi"""]							)
          self.assertEqual(args.foo							,"""titi"""							)

          snake_case			:      Optional[int]        =			parser.parse_args(["""--foo""", """42"""]							)
          self.assertEqual(args.foo							,42							)







     def 			snake_case_      (				self							)      ->				List[Any]:
          snake_case			:      Any        =			HfArgumentParser(__a							)

          snake_case			:      Dict        =			argparse.ArgumentParser()
          expected.add_argument("""--foo_int"""							,nargs="""+"""							,default=[]							,type=__a							)
          expected.add_argument("""--bar_int"""							,nargs="""+"""							,default=[1, 2, 3]							,type=__a							)
          expected.add_argument("""--foo_str"""							,nargs="""+"""							,default=["""Hallo""", """Bonjour""", """Hello"""]							,type=__a							)
          expected.add_argument("""--foo_float"""							,nargs="""+"""							,default=[0.1, 0.2, 0.3]							,type=__a							)

          self.argparsersEqual(__a							,__a							)

          snake_case			:      int        =			parser.parse_args([]							)
          self.assertEqual(
              __a							,Namespace(foo_int=[]							,bar_int=[1, 2, 3]							,foo_str=["""Hallo""", """Bonjour""", """Hello"""]							,foo_float=[0.1, 0.2, 0.3]							)							,)

          snake_case			:      Optional[int]        =			parser.parse_args("""--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7""".split()							)
          self.assertEqual(__a							,Namespace(foo_int=[1]							,bar_int=[2, 3]							,foo_str=["""a""", """b""", """c"""]							,foo_float=[0.1, 0.7]							)							)







     def 			snake_case_      (				self							)      ->				Optional[int]:
          snake_case			:      List[Any]        =			argparse.ArgumentParser()
          expected.add_argument("""--foo"""							,default=__a							,type=__a							)
          expected.add_argument("""--bar"""							,default=__a							,type=__a							,help="""help message"""							)
          expected.add_argument("""--baz"""							,default=__a							,type=__a							)
          expected.add_argument("""--ces"""							,nargs="""+"""							,default=[]							,type=__a							)
          expected.add_argument("""--des"""							,nargs="""+"""							,default=[]							,type=__a							)

          snake_case			:      Optional[Any]        =			[OptionalExample]
          if is_python_no_less_than_3_10:
               dataclass_types.append(__a							)

          for dataclass_type in dataclass_types:
               snake_case			:      Any        =			HfArgumentParser(__a							)

               self.argparsersEqual(__a							,__a							)

               snake_case			:      Any        =			parser.parse_args([]							)
               self.assertEqual(__a							,Namespace(foo=__a							,bar=__a							,baz=__a							,ces=[]							,des=[]							)							)

               snake_case			:      Any        =			parser.parse_args("""--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3""".split()							)
               self.assertEqual(__a							,Namespace(foo=12							,bar=3.14							,baz="""42"""							,ces=["""a""", """b""", """c"""]							,des=[1, 2, 3]							)							)







     def 			snake_case_      (				self							)      ->				Any:
          snake_case			:      Optional[Any]        =			HfArgumentParser(__a							)

          snake_case			:      List[Any]        =			argparse.ArgumentParser()
          expected.add_argument("""--required_list"""							,nargs="""+"""							,type=__a							,required=__a							)
          expected.add_argument("""--required_str"""							,type=__a							,required=__a							)
          expected.add_argument(
              """--required_enum"""							,type=make_choice_type_function(["""titi""", """toto"""]							)							,choices=["""titi""", """toto"""]							,required=__a							,)
          self.argparsersEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				List[Any]:
          snake_case			:      Optional[int]        =			HfArgumentParser(__a							)

          snake_case			:      Any        =			argparse.ArgumentParser()
          expected.add_argument("""--foo"""							,type=__a							,required=__a							)
          expected.add_argument(
              """--required_enum"""							,type=make_choice_type_function(["""titi""", """toto"""]							)							,choices=["""titi""", """toto"""]							,required=__a							,)
          expected.add_argument("""--opt"""							,type=__a							,default=__a							)
          expected.add_argument("""--baz"""							,default="""toto"""							,type=__a							,help="""help message"""							)
          expected.add_argument("""--foo_str"""							,nargs="""+"""							,default=["""Hallo""", """Bonjour""", """Hello"""]							,type=__a							)
          self.argparsersEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				Tuple:
          snake_case			:      str        =			HfArgumentParser(__a							)

          snake_case			:      Any        =			{
              """foo""": 12,
              """bar""": 3.14,
              """baz""": """42""",
              """flag""": True,
          }

          snake_case			:      List[str]        =			parser.parse_dict(__a							)[0]
          snake_case			:      str        =			BasicExample(**__a							)
          self.assertEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				Any:
          snake_case			:      Tuple        =			HfArgumentParser(__a							)

          snake_case			:      int        =			{
              """foo""": 12,
              """bar""": 3.14,
              """baz""": """42""",
              """flag""": True,
              """extra""": 42,
          }

          self.assertRaises(__a							,parser.parse_dict							,__a							,allow_extra_keys=__a							)







     def 			snake_case_      (				self							)      ->				Optional[int]:
          snake_case			:      List[str]        =			HfArgumentParser(__a							)

          snake_case			:      Any        =			{
              """foo""": 12,
              """bar""": 3.14,
              """baz""": """42""",
              """flag""": True,
          }
          with tempfile.TemporaryDirectory() as tmp_dir:
               snake_case			:      Dict        =			os.path.join(__a							,"""temp_json"""							)
               os.mkdir(__a							)
               with open(temp_local_path + """.json"""							,"""w+"""							) as f:
                    json.dump(__a							,__a							)
               snake_case			:      Any        =			parser.parse_yaml_file(Path(temp_local_path + """.json"""							)							)[0]

          snake_case			:      List[str]        =			BasicExample(**__a							)
          self.assertEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				str:
          snake_case			:      Union[str, Any]        =			HfArgumentParser(__a							)

          snake_case			:      Any        =			{
              """foo""": 12,
              """bar""": 3.14,
              """baz""": """42""",
              """flag""": True,
          }
          with tempfile.TemporaryDirectory() as tmp_dir:
               snake_case			:      str        =			os.path.join(__a							,"""temp_yaml"""							)
               os.mkdir(__a							)
               with open(temp_local_path + """.yaml"""							,"""w+"""							) as f:
                    yaml.dump(__a							,__a							)
               snake_case			:      Union[str, Any]        =			parser.parse_yaml_file(Path(temp_local_path + """.yaml"""							)							)[0]
          snake_case			:      Tuple        =			BasicExample(**__a							)
          self.assertEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				List[str]:
          snake_case			:      Union[str, Any]        =			HfArgumentParser(__a							)
          self.assertIsNotNone(__a							)



