





'''simple docstring'''

import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
   import os

   # The slow tests are often failing with OOM error on GPU
   # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
   # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
   lowercase__						:      int	=    'platform'

   import jax
   import jax.numpy as jnp

   from transformers import BlenderbotTokenizer
   from transformers.models.blenderbot.modeling_flax_blenderbot import (
       FlaxBlenderbotForConditionalGeneration,
       FlaxBlenderbotModel,
       shift_tokens_right,
   )







def  a__    (    lowercase :					str, lowercase :					Union[str, Any], lowercase :					Optional[int]=None, lowercase :					List[str]=None, lowercase :					str=None, lowercase :					str=None, lowercase :					int=None, lowercase :					Tuple=None, )		->		Dict:





     """simple docstring"""

     if attention_mask is None:
          _UpperCamelCase       =	np.where(input_ids != config.pad_token_id, 1, 0				)
     if decoder_attention_mask is None:
          _UpperCamelCase       =	np.where(decoder_input_ids != config.pad_token_id, 1, 0				)
     if head_mask is None:
          _UpperCamelCase       =	np.ones((config.encoder_layers, config.encoder_attention_heads)				)
     if decoder_head_mask is None:
          _UpperCamelCase       =	np.ones((config.decoder_layers, config.decoder_attention_heads)				)
     if cross_attn_head_mask is None:
          _UpperCamelCase       =	np.ones((config.decoder_layers, config.decoder_attention_heads)				)
     return {
         "input_ids": input_ids,
         "decoder_input_ids": decoder_input_ids,
         "attention_mask": attention_mask,
         "decoder_attention_mask": attention_mask,
     }
class     __lowerCAmelCase					:






       """simple docstring"""





       def __init__(							self       :		List[str]	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		Tuple=13	,			lowerCAmelCase__       :		List[Any]=7	,			lowerCAmelCase__       :		Tuple=True	,			lowerCAmelCase__       :		int=False	,			lowerCAmelCase__       :		Tuple=99	,			lowerCAmelCase__       :		List[str]=16	,			lowerCAmelCase__       :		List[Any]=2	,			lowerCAmelCase__       :		Any=4	,			lowerCAmelCase__       :		Optional[int]=4	,			lowerCAmelCase__       :		List[str]="gelu"	,			lowerCAmelCase__       :		List[str]=0.1	,			lowerCAmelCase__       :		int=0.1	,			lowerCAmelCase__       :		List[str]=32	,			lowerCAmelCase__       :		List[Any]=2	,			lowerCAmelCase__       :		str=1	,			lowerCAmelCase__       :		List[str]=0	,			lowerCAmelCase__       :		Dict=0.02	,			)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	parent
            _UpperCamelCase       =	batch_size
            _UpperCamelCase       =	seq_length
            _UpperCamelCase       =	is_training
            _UpperCamelCase       =	use_labels
            _UpperCamelCase       =	vocab_size
            _UpperCamelCase       =	hidden_size
            _UpperCamelCase       =	num_hidden_layers
            _UpperCamelCase       =	num_attention_heads
            _UpperCamelCase       =	intermediate_size
            _UpperCamelCase       =	hidden_act
            _UpperCamelCase       =	hidden_dropout_prob
            _UpperCamelCase       =	attention_probs_dropout_prob
            _UpperCamelCase       =	max_position_embeddings
            _UpperCamelCase       =	eos_token_id
            _UpperCamelCase       =	pad_token_id
            _UpperCamelCase       =	bos_token_id
            _UpperCamelCase       =	initializer_range





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

            '''simple docstring'''




            _UpperCamelCase       =	np.clip(ids_tensor([self.batch_size, self.seq_length - 1]	,			self.vocab_size					)	,			3	,			self.vocab_size					)
            _UpperCamelCase       =	np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)	,			dtype=np.intaa					))	,			-1					)

            _UpperCamelCase       =	shift_tokens_right(lowerCAmelCase__	,			1	,			2					)

            _UpperCamelCase       =	BlenderbotConfig(
                vocab_size=self.vocab_size	,			d_model=self.hidden_size	,			encoder_layers=self.num_hidden_layers	,			decoder_layers=self.num_hidden_layers	,			encoder_attention_heads=self.num_attention_heads	,			decoder_attention_heads=self.num_attention_heads	,			encoder_ffn_dim=self.intermediate_size	,			decoder_ffn_dim=self.intermediate_size	,			dropout=self.hidden_dropout_prob	,			attention_dropout=self.attention_probs_dropout_prob	,			max_position_embeddings=self.max_position_embeddings	,			eos_token_id=self.eos_token_id	,			bos_token_id=self.bos_token_id	,			pad_token_id=self.pad_token_id	,			initializer_range=self.initializer_range	,			use_cache=lowerCAmelCase__	,			)
            _UpperCamelCase       =	prepare_blenderbot_inputs_dict(lowerCAmelCase__	,			lowerCAmelCase__	,			lowerCAmelCase__					)
            return config, inputs_dict





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

            '''simple docstring'''




            _UpperCamelCase   ,    _UpperCamelCase       =	self.prepare_config_and_inputs()
            return config, inputs_dict





       def snake_case__						(							self       :		Tuple	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Any	,			lowerCAmelCase__       :		str					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	20
            _UpperCamelCase       =	model_class_name(lowerCAmelCase__					)

            _UpperCamelCase       =	model.encode(inputs_dict['''input_ids''']					)

            _UpperCamelCase   ,    _UpperCamelCase       =	(
                inputs_dict['''decoder_input_ids'''],
                inputs_dict['''decoder_attention_mask'''],
            )

            _UpperCamelCase       =	model.init_cache(decoder_input_ids.shape[0]	,			lowerCAmelCase__	,			lowerCAmelCase__					)
            _UpperCamelCase       =	jnp.ones((decoder_input_ids.shape[0], max_decoder_length)	,			dtype='''i4'''					)

            _UpperCamelCase       =	jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1					)[None, :]	,			(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)	,			)
            _UpperCamelCase       =	model.decode(
                decoder_input_ids[:, :-1]	,			lowerCAmelCase__	,			decoder_attention_mask=lowerCAmelCase__	,			past_key_values=lowerCAmelCase__	,			decoder_position_ids=lowerCAmelCase__	,			)

            _UpperCamelCase       =	jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]	,			dtype='''i4'''					)
            _UpperCamelCase       =	model.decode(
                decoder_input_ids[:, -1:]	,			lowerCAmelCase__	,			decoder_attention_mask=lowerCAmelCase__	,			past_key_values=outputs_cache.past_key_values	,			decoder_position_ids=lowerCAmelCase__	,			)

            _UpperCamelCase       =	model.decode(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])					)					)
            self.parent.assertTrue(diff < 1e-3	,			msg=f"""Max diff is {diff}"""					)







       def snake_case__						(							self       :		List[Any]	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Tuple					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	20
            _UpperCamelCase       =	model_class_name(lowerCAmelCase__					)

            _UpperCamelCase       =	model.encode(inputs_dict['''input_ids''']					)

            _UpperCamelCase   ,    _UpperCamelCase       =	(
                inputs_dict['''decoder_input_ids'''],
                inputs_dict['''decoder_attention_mask'''],
            )

            _UpperCamelCase       =	jnp.concatenate(
                [
                    decoder_attention_mask,
                    jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])					),
                ]	,			axis=-1	,			)

            _UpperCamelCase       =	model.init_cache(decoder_input_ids.shape[0]	,			lowerCAmelCase__	,			lowerCAmelCase__					)
            _UpperCamelCase       =	jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1					)[None, :]	,			(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)	,			)

            _UpperCamelCase       =	model.decode(
                decoder_input_ids[:, :-1]	,			lowerCAmelCase__	,			decoder_attention_mask=lowerCAmelCase__	,			past_key_values=lowerCAmelCase__	,			decoder_position_ids=lowerCAmelCase__	,			)
            _UpperCamelCase       =	jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]	,			dtype='''i4'''					)
            _UpperCamelCase       =	model.decode(
                decoder_input_ids[:, -1:]	,			lowerCAmelCase__	,			past_key_values=outputs_cache.past_key_values	,			decoder_attention_mask=lowerCAmelCase__	,			decoder_position_ids=lowerCAmelCase__	,			)

            _UpperCamelCase       =	model.decode(lowerCAmelCase__	,			lowerCAmelCase__	,			decoder_attention_mask=lowerCAmelCase__					)

            _UpperCamelCase       =	np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])					)					)
            self.parent.assertTrue(diff < 1e-3	,			msg=f"""Max diff is {diff}"""					)

@require_flax
class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					Tuple						    =   9_9





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

            '''simple docstring'''




            _UpperCamelCase       =	np.array(
                [
                    [71, 82, 18, 33, 46, 91, 2],
                    [68, 34, 26, 58, 30, 82, 2],
                    [5, 97, 17, 39, 94, 40, 2],
                    [76, 83, 94, 25, 70, 78, 2],
                    [87, 59, 41, 35, 48, 66, 2],
                    [55, 13, 16, 58, 5, 2, 1],  # note padding
                    [64, 27, 31, 51, 12, 75, 2],
                    [52, 64, 86, 17, 83, 39, 2],
                    [48, 61, 9, 24, 71, 82, 2],
                    [26, 1, 60, 48, 22, 13, 2],
                    [21, 5, 62, 28, 14, 76, 2],
                    [45, 98, 37, 86, 59, 48, 2],
                    [70, 70, 50, 9, 28, 0, 2],
                ]	,			dtype=np.intaa	,			)

            _UpperCamelCase       =	input_ids.shape[0]
            _UpperCamelCase       =	BlenderbotConfig(
                vocab_size=self.vocab_size	,			d_model=24	,			encoder_layers=2	,			decoder_layers=2	,			encoder_attention_heads=2	,			decoder_attention_heads=2	,			encoder_ffn_dim=32	,			decoder_ffn_dim=32	,			max_position_embeddings=48	,			eos_token_id=2	,			pad_token_id=1	,			bos_token_id=0	,			)
            return config, input_ids, batch_size





       def snake_case__						(							self       :		Tuple					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase       =	self._get_config_and_data()
            _UpperCamelCase       =	FlaxBlenderbotForConditionalGeneration(lowerCAmelCase__					)
            _UpperCamelCase       =	lm_model(input_ids=lowerCAmelCase__					)
            _UpperCamelCase       =	(batch_size, input_ids.shape[1], config.vocab_size)
            self.assertEqual(outputs['''logits'''].shape	,			lowerCAmelCase__					)





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

            '''simple docstring'''




            _UpperCamelCase       =	BlenderbotConfig(
                vocab_size=self.vocab_size	,			d_model=14	,			encoder_layers=2	,			decoder_layers=2	,			encoder_attention_heads=2	,			decoder_attention_heads=2	,			encoder_ffn_dim=8	,			decoder_ffn_dim=8	,			max_position_embeddings=48	,			)
            _UpperCamelCase       =	FlaxBlenderbotForConditionalGeneration(lowerCAmelCase__					)
            _UpperCamelCase       =	np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]	,			dtype=np.intaa					)
            _UpperCamelCase       =	np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]	,			dtype=np.intaa					)
            _UpperCamelCase       =	lm_model(input_ids=lowerCAmelCase__	,			decoder_input_ids=lowerCAmelCase__					)
            _UpperCamelCase       =	(*summary.shape, config.vocab_size)
            self.assertEqual(outputs['''logits'''].shape	,			lowerCAmelCase__					)







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

            '''simple docstring'''




            _UpperCamelCase       =	np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]	,			dtype=np.intaa					)
            _UpperCamelCase       =	shift_tokens_right(lowerCAmelCase__	,			1	,			2					)
            _UpperCamelCase       =	np.equal(lowerCAmelCase__	,			1					).astype(np.floataa					).sum()
            _UpperCamelCase       =	np.equal(lowerCAmelCase__	,			1					).astype(np.floataa					).sum()
            self.assertEqual(shifted.shape	,			input_ids.shape					)
            self.assertEqual(lowerCAmelCase__	,			n_pad_before - 1					)
            self.assertTrue(np.equal(shifted[:, 0]	,			2					).all()					)

@require_flax
class     __lowerCAmelCase					(   __magic_name__						,						unittest.TestCase						,						__magic_name__			):






       """simple docstring"""
       _snake_case     :					Any						    =   True
       _snake_case     :					int						    =   (
           (
               FlaxBlenderbotModel,
               FlaxBlenderbotForConditionalGeneration,
           )
           if is_flax_available()
           else ()
       )
       _snake_case     :					Dict						    =   (FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()





       def snake_case__						(							self       :		Tuple					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	FlaxBlenderbotModelTester(self					)





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

            '''simple docstring'''




            _UpperCamelCase   ,    _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                 self.model_tester.check_use_cache_forward(lowerCAmelCase__	,			lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase   ,    _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                 self.model_tester.check_use_cache_forward_with_attn_mask(lowerCAmelCase__	,			lowerCAmelCase__	,			lowerCAmelCase__					)





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

            '''simple docstring'''




            _UpperCamelCase   ,    _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__					):
                      _UpperCamelCase       =	self._prepare_for_class(lowerCAmelCase__	,			lowerCAmelCase__					)
                      _UpperCamelCase       =	model_class(lowerCAmelCase__					)

                      @jax.jit
                      def encode_jitted(lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		int=None	,			**lowerCAmelCase__       :		Dict					):
                           return model.encode(input_ids=lowerCAmelCase__	,			attention_mask=lowerCAmelCase__					)

                      with self.subTest('''JIT Enabled'''					):
                           _UpperCamelCase       =	encode_jitted(**lowerCAmelCase__					).to_tuple()

                      with self.subTest('''JIT Disabled'''					):
                           with jax.disable_jit():
                                _UpperCamelCase       =	encode_jitted(**lowerCAmelCase__					).to_tuple()

                      self.assertEqual(len(lowerCAmelCase__					)	,			len(lowerCAmelCase__					)					)
                      for jitted_output, output in zip(lowerCAmelCase__	,			lowerCAmelCase__					):
                           self.assertEqual(jitted_output.shape	,			output.shape					)





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

            '''simple docstring'''




            _UpperCamelCase   ,    _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__					):
                      _UpperCamelCase       =	model_class(lowerCAmelCase__					)
                      _UpperCamelCase       =	model.encode(inputs_dict['''input_ids''']	,			inputs_dict['''attention_mask''']					)

                      _UpperCamelCase       =	{
                          '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
                          '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
                          '''encoder_outputs''': encoder_outputs,
                      }

                      @jax.jit
                      def decode_jitted(lowerCAmelCase__       :		Union[str, Any]	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		Union[str, Any]					):
                           return model.decode(
                               decoder_input_ids=lowerCAmelCase__	,			decoder_attention_mask=lowerCAmelCase__	,			encoder_outputs=lowerCAmelCase__	,			)

                      with self.subTest('''JIT Enabled'''					):
                           _UpperCamelCase       =	decode_jitted(**lowerCAmelCase__					).to_tuple()

                      with self.subTest('''JIT Disabled'''					):
                           with jax.disable_jit():
                                _UpperCamelCase       =	decode_jitted(**lowerCAmelCase__					).to_tuple()

                      self.assertEqual(len(lowerCAmelCase__					)	,			len(lowerCAmelCase__					)					)
                      for jitted_output, output in zip(lowerCAmelCase__	,			lowerCAmelCase__					):
                           self.assertEqual(jitted_output.shape	,			output.shape					)





       @slow
       def snake_case__						(							self       :		Union[str, Any]					)   ->					Dict:

            '''simple docstring'''




            for model_class_name in self.all_model_classes:
                 _UpperCamelCase       =	model_class_name.from_pretrained('''facebook/blenderbot-400M-distill'''					)
                 # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
                 _UpperCamelCase       =	np.ones((1, 1)					) * model.config.eos_token_id
                 _UpperCamelCase       =	model(lowerCAmelCase__					)
                 self.assertIsNotNone(lowerCAmelCase__					)







       @unittest.skipUnless(jax_device != '''cpu'''	,			'''3B test too slow on CPU.'''					)
       @slow
       def snake_case__						(							self       :		Tuple					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	{'''num_beams''': 1, '''early_stopping''': True, '''min_length''': 15, '''max_length''': 25}
            _UpperCamelCase       =	{'''skip_special_tokens''': True, '''clean_up_tokenization_spaces''': True}

            _UpperCamelCase       =	FlaxBlenderbotForConditionalGeneration.from_pretrained('''facebook/blenderbot-3B'''	,			from_pt=lowerCAmelCase__					)
            _UpperCamelCase       =	BlenderbotTokenizer.from_pretrained('''facebook/blenderbot-3B'''					)

            _UpperCamelCase       =	['''Sam''']
            _UpperCamelCase       =	tokenizer(lowerCAmelCase__	,			return_tensors='''jax'''					)

            _UpperCamelCase       =	model.generate(**lowerCAmelCase__	,			**lowerCAmelCase__					)
            _UpperCamelCase       =	'''Sam is a great name. It means "sun" in Gaelic.'''

            _UpperCamelCase       =	tokenizer.batch_decode(lowerCAmelCase__	,			**lowerCAmelCase__					)
            assert generated_txt[0].strip() == tgt_text










'''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__						:      List[str]	=    sys.version_info >= (3, 10)







def  a__    (    lowercase :					Dict=None, lowercase :					List[str]=None				)		->		List[Any]:





     """simple docstring"""

     return field(default_factory=lambda: default, metadata=lowercase				)
@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int
       _snake_case     :					float
       _snake_case     :					str
       _snake_case     :					bool

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int						    =   4_2
       _snake_case     :					str						    =   field(default='toto'						,						metadata={'help': 'help message'}			)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					bool						    =   False
       _snake_case     :					bool						    =   True
       _snake_case     :					Optional[bool]						    =   None

class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					str						    =   'titi'
       _snake_case     :					Union[str, Any]						    =   'toto'

class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					str						    =   'titi'
       _snake_case     :					Union[str, Any]						    =   'toto'
       _snake_case     :					Any						    =   4_2

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					BasicEnum						    =   "toto"





       def snake_case__						(							self       :		List[Any]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	BasicEnum(self.foo					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					MixedTypeEnum						    =   "toto"





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

            '''simple docstring'''




            _UpperCamelCase       =	MixedTypeEnum(self.foo					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					Optional[int]						    =   None
       _snake_case     :					Optional[float]						    =   field(default=__magic_name__						,						metadata={'help': 'help message'}			)
       _snake_case     :					Optional[str]						    =   None
       _snake_case     :					Optional[List[str]]						    =   list_field(default=[]			)
       _snake_case     :					Optional[List[int]]						    =   list_field(default=[]			)

@dataclass
class     __lowerCAmelCase					:






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

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					List[int]						    =   field()
       _snake_case     :					str						    =   field()
       _snake_case     :					BasicEnum						    =   field()





       def snake_case__						(							self       :		str					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	BasicEnum(self.required_enum					)

@dataclass
class     __lowerCAmelCase					:






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


if is_python_no_less_than_3_10:
   @dataclass
   class     __lowerCAmelCase					:






          """simple docstring"""
          _snake_case     :					bool						    =   False
          _snake_case     :					bool						    =   True
          _snake_case     :					bool | None						    =   None

   @dataclass
   class     __lowerCAmelCase					:






          """simple docstring"""
          _snake_case     :					int | None						    =   None
          _snake_case     :					float | None						    =   field(default=__magic_name__						,						metadata={'help': 'help message'}			)
          _snake_case     :					str | None						    =   None
          _snake_case     :					list[str] | None						    =   list_field(default=[]			)
          _snake_case     :					list[int] | None						    =   list_field(default=[]			)




class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       def snake_case__						(							self       :		Optional[Any]	,			lowerCAmelCase__       :		argparse.ArgumentParser	,			lowerCAmelCase__       :		argparse.ArgumentParser					)   ->					str:

            '''simple docstring'''




            self.assertEqual(len(a._actions					)	,			len(b._actions					)					)
            for x, y in zip(a._actions	,			b._actions					):
                 _UpperCamelCase       =	{k: v for k, v in vars(lowerCAmelCase__					).items() if k != '''container'''}
                 _UpperCamelCase       =	{k: v for k, v in vars(lowerCAmelCase__					).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'''	,			lowerCAmelCase__					) and yy.get('''choices'''	,			lowerCAmelCase__					):
                      for expected_choice in yy["choices"] + xx["choices"]:
                           self.assertEqual(xx['''type'''](lowerCAmelCase__					)	,			yy['''type'''](lowerCAmelCase__					)					)
                      del xx["type"], yy["type"]

                 self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Dict					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--bar'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--flag'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	['''--foo''', '''1''', '''--baz''', '''quux''', '''--bar''', '''0.5''']
            ((_UpperCamelCase)   ,    )       =	parser.parse_args_into_dataclasses(lowerCAmelCase__	,			look_for_args_file=lowerCAmelCase__					)
            self.assertFalse(example.flag					)





       def snake_case__						(							self       :		int					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			default=42	,			type=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			default='''toto'''	,			type=lowerCAmelCase__	,			help='''help message'''					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            expected.add_argument('''--baz'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			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=lowerCAmelCase__	,			dest='''baz'''					)
            expected.add_argument('''--opt'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__					)

            _UpperCamelCase       =	[WithDefaultBoolExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(lowerCAmelCase__					)

            for dataclass_type in dataclass_types:
                 _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)
                 self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

                 _UpperCamelCase       =	parser.parse_args([]					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''--no_baz''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''--baz''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''True''', '''--baz''', '''True''', '''--opt''', '''True''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''False''', '''--baz''', '''False''', '''--opt''', '''False''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''	,			default='''toto'''	,			choices=['''titi''', '''toto''', 42]	,			type=make_choice_type_function(['''titi''', '''toto''', 42]					)	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(args.foo	,			'''toto'''					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses([]					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.toto					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''titi''']					)
            self.assertEqual(args.foo	,			'''titi'''					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses(['''--foo''', '''titi''']					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.titi					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''42''']					)
            self.assertEqual(args.foo	,			42					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses(['''--foo''', '''42''']					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.fourtytwo					)





       def snake_case__						(							self       :		Any					)   ->					List[Any]:

            '''simple docstring'''




            @dataclass
            class     __lowerCAmelCase					:






                   """simple docstring"""
                   _snake_case     :					Literal["titi", "toto", 4_2]						    =   "toto"

            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''	,			default='''toto'''	,			choices=('''titi''', '''toto''', 42)	,			type=make_choice_type_function(['''titi''', '''toto''', 42]					)	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(args.foo	,			'''toto'''					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''titi''']					)
            self.assertEqual(args.foo	,			'''titi'''					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''42''']					)
            self.assertEqual(args.foo	,			42					)





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

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo_int'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--bar_int'''	,			nargs='''+'''	,			default=[1, 2, 3]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--foo_str'''	,			nargs='''+'''	,			default=['''Hallo''', '''Bonjour''', '''Hello''']	,			type=lowerCAmelCase__					)
            expected.add_argument('''--foo_float'''	,			nargs='''+'''	,			default=[0.1, 0.2, 0.3]	,			type=lowerCAmelCase__					)

            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(
                lowerCAmelCase__	,			Namespace(foo_int=[]	,			bar_int=[1, 2, 3]	,			foo_str=['''Hallo''', '''Bonjour''', '''Hello''']	,			foo_float=[0.1, 0.2, 0.3]					)	,			)

            _UpperCamelCase       =	parser.parse_args('''--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7'''.split()					)
            self.assertEqual(lowerCAmelCase__	,			Namespace(foo_int=[1]	,			bar_int=[2, 3]	,			foo_str=['''a''', '''b''', '''c''']	,			foo_float=[0.1, 0.7]					)					)





       def snake_case__						(							self       :		List[str]					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__					)
            expected.add_argument('''--bar'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__	,			help='''help message'''					)
            expected.add_argument('''--baz'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__					)
            expected.add_argument('''--ces'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--des'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)

            _UpperCamelCase       =	[OptionalExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(lowerCAmelCase__					)

            for dataclass_type in dataclass_types:
                 _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

                 self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

                 _UpperCamelCase       =	parser.parse_args([]					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			bar=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			ces=[]	,			des=[]					)					)

                 _UpperCamelCase       =	parser.parse_args('''--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3'''.split()					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=12	,			bar=3.14	,			baz='''42'''	,			ces=['''a''', '''b''', '''c''']	,			des=[1, 2, 3]					)					)





       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--required_list'''	,			nargs='''+'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--required_str'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument(
                '''--required_enum'''	,			type=make_choice_type_function(['''titi''', '''toto''']					)	,			choices=['''titi''', '''toto''']	,			required=lowerCAmelCase__	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

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





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

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }

            _UpperCamelCase       =	parser.parse_dict(lowerCAmelCase__					)[0]
            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Any					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
                '''extra''': 42,
            }

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





       def snake_case__						(							self       :		str					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

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

            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





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

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

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







       def snake_case__						(							self       :		str					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)
            self.assertIsNotNone(lowerCAmelCase__					)



