






"""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
__a       :	int             = sys.version_info >= (3, 10)





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_=None ,     lowerCamelCase_=None):
					return field(default_factory=lambda: default ,     metadata=__A)







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =42
							_SCREAMING_SNAKE_CASE    =42
							_SCREAMING_SNAKE_CASE    =42
							_SCREAMING_SNAKE_CASE    =42







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =42
							_SCREAMING_SNAKE_CASE    =field(default='toto'       , metadata={'help': 'help message'}							)







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =False
							_SCREAMING_SNAKE_CASE    =True
							_SCREAMING_SNAKE_CASE    =None







class        _SCREAMING_SNAKE_CASE						(  __A							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    ='titi'
							_SCREAMING_SNAKE_CASE    ='toto'







class        _SCREAMING_SNAKE_CASE						(  __A							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    ='titi'
							_SCREAMING_SNAKE_CASE    ='toto'
							_SCREAMING_SNAKE_CASE    =42







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    ='toto'




							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												a__          =  BasicEnum(self.foo    )







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    ='toto'




							def  lowercase		(   self:     List[Any]    ):

												'''simple docstring'''

												a__          =  MixedTypeEnum(self.foo    )







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =None
							_SCREAMING_SNAKE_CASE    =field(default=__A       , metadata={'help': 'help message'}							)
							_SCREAMING_SNAKE_CASE    =None
							_SCREAMING_SNAKE_CASE    =list_field(default=[]							)
							_SCREAMING_SNAKE_CASE    =list_field(default=[]							)







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =list_field(default=[]							)
							_SCREAMING_SNAKE_CASE    =list_field(default=[1, 2, 3]							)
							_SCREAMING_SNAKE_CASE    =list_field(default=['Hallo', 'Bonjour', 'Hello']							)
							_SCREAMING_SNAKE_CASE    =list_field(default=[0.1, 0.2, 0.3]							)







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =field()
							_SCREAMING_SNAKE_CASE    =field()
							_SCREAMING_SNAKE_CASE    =field()




							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												a__          =  BasicEnum(self.required_enum    )







@dataclass
class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =42
							_SCREAMING_SNAKE_CASE    =field()
							_SCREAMING_SNAKE_CASE    =None
							_SCREAMING_SNAKE_CASE    =field(default='toto'       , metadata={'help': 'help message'}							)
							_SCREAMING_SNAKE_CASE    =list_field(default=['Hallo', 'Bonjour', 'Hello']							)


if is_python_no_less_than_3_10:







							@dataclass
							class        _SCREAMING_SNAKE_CASE						:





														"""simple docstring"""





														_SCREAMING_SNAKE_CASE    =False
														_SCREAMING_SNAKE_CASE    =True
														_SCREAMING_SNAKE_CASE    =None







							@dataclass
							class        _SCREAMING_SNAKE_CASE						:





														"""simple docstring"""





														_SCREAMING_SNAKE_CASE    =None
														_SCREAMING_SNAKE_CASE    =field(default=__A       , metadata={'help': 'help message'}							)
														_SCREAMING_SNAKE_CASE    =None
														_SCREAMING_SNAKE_CASE    =list_field(default=[]							)
														_SCREAMING_SNAKE_CASE    =list_field(default=[]							)







class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							def  lowercase		(   self:     List[Any]				,		__A:     argparse.ArgumentParser				,		__A:     argparse.ArgumentParser    ):

												'''simple docstring'''

												self.assertEqual(len(a._actions    )				,		len(b._actions    )    )
												for x, y in zip(a._actions				,		b._actions    ):
																	a__          =  {k: v for k, v in vars(__A    ).items() if k != '''container'''}
																	a__          =  {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  lowercase		(   self:     str    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

												a__          =  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    )

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




							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

												a__          =  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  lowercase		(   self:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  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    )

												a__          =  [WithDefaultBoolExample]
												if is_python_no_less_than_3_10:
																	dataclass_types.append(__A    )

												for dataclass_type in dataclass_types:
																	a__          =  HfArgumentParser(__A    )
																	self.argparsersEqual(__A				,		__A    )

																	a__          =  parser.parse_args([]    )
																	self.assertEqual(__A				,		Namespace(foo=__A				,		baz=__A				,		opt=__A    )    )

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

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

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

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




							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

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

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

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

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




							def  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

												@dataclass
												class        _SCREAMING_SNAKE_CASE						:





																			"""simple docstring"""





																			_SCREAMING_SNAKE_CASE    ='toto'

												a__          =  HfArgumentParser(__A    )

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

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

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

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




							def  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

												a__          =  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    )

												a__          =  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]    )				,		)

												a__          =  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  lowercase		(   self:     str    ):

												'''simple docstring'''

												a__          =  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    )

												a__          =  [OptionalExample]
												if is_python_no_less_than_3_10:
																	dataclass_types.append(__A    )

												for dataclass_type in dataclass_types:
																	a__          =  HfArgumentParser(__A    )

																	self.argparsersEqual(__A				,		__A    )

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

																	a__          =  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.1_4				,		baz='''42'''				,		ces=['''a''', '''b''', '''c''']				,		des=[1, 2, 3]    )    )




							def  lowercase		(   self:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

												a__          =  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  lowercase		(   self:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

												a__          =  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  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

												a__          =  {
												    '''foo''': 12,
												    '''bar''': 3.1_4,
												    '''baz''': '''42''',
												    '''flag''': True,
												}

												a__          =  parser.parse_dict(__A    )[0]
												a__          =  BasicExample(**__A    )
												self.assertEqual(__A				,		__A    )




							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

												a__          =  {
												    '''foo''': 12,
												    '''bar''': 3.1_4,
												    '''baz''': '''42''',
												    '''flag''': True,
												    '''extra''': 42,
												}

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




							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

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

												a__          =  BasicExample(**__A    )
												self.assertEqual(__A				,		__A    )




							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )

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





							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												a__          =  HfArgumentParser(__A    )
												self.assertIsNotNone(__A    )










"""simple docstring"""







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__a       :	str             = logging.get_logger(__name__)

__a       :	Dict             = {
    'xlm-mlm-en-2048': 'https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json',
    'xlm-mlm-ende-1024': 'https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json',
    'xlm-mlm-enfr-1024': 'https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json',
    'xlm-mlm-enro-1024': 'https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json',
    'xlm-mlm-tlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json',
    'xlm-mlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json',
    'xlm-clm-enfr-1024': 'https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json',
    'xlm-clm-ende-1024': 'https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json',
    'xlm-mlm-17-1280': 'https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json',
    'xlm-mlm-100-1280': 'https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json',
}







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    ='xlm'
							_SCREAMING_SNAKE_CASE    ={
							    'hidden_size': 'emb_dim',
							    'num_attention_heads': 'n_heads',
							    'num_hidden_layers': 'n_layers',
							    'n_words': 'vocab_size',  # For backward compatibility
							}




							def __init__(   self:     Optional[Any]				,		__A:     str=30145				,		__A:     Union[str, Any]=2048				,		__A:     Union[str, Any]=12				,		__A:     List[Any]=16				,		__A:     List[Any]=0.1				,		__A:     int=0.1				,		__A:     str=True				,		__A:     int=False				,		__A:     Optional[int]=False				,		__A:     Union[str, Any]=False				,		__A:     List[Any]=1				,		__A:     Dict=True				,		__A:     List[Any]=512				,		__A:     Optional[int]=2048**-0.5				,		__A:     Tuple=1e-12				,		__A:     Optional[int]=0.0_2				,		__A:     Optional[int]=0				,		__A:     Union[str, Any]=1				,		__A:     List[Any]=2				,		__A:     Union[str, Any]=3				,		__A:     Tuple=5				,		__A:     Tuple=True				,		__A:     Dict="first"				,		__A:     Optional[int]=True				,		__A:     int=None				,		__A:     Optional[Any]=True				,		__A:     Dict=0.1				,		__A:     Tuple=5				,		__A:     Union[str, Any]=5				,		__A:     Tuple=0				,		__A:     List[str]=0				,		__A:     int=2				,		__A:     Optional[int]=0				,		**__A:     Union[str, Any]				,		):

												'''simple docstring'''

												a__          =  vocab_size
												a__          =  emb_dim
												a__          =  n_layers
												a__          =  n_heads
												a__          =  dropout
												a__          =  attention_dropout
												a__          =  gelu_activation
												a__          =  sinusoidal_embeddings
												a__          =  causal
												a__          =  asm
												a__          =  n_langs
												a__          =  use_lang_emb
												a__          =  layer_norm_eps
												a__          =  bos_index
												a__          =  eos_index
												a__          =  pad_index
												a__          =  unk_index
												a__          =  mask_index
												a__          =  is_encoder
												a__          =  max_position_embeddings
												a__          =  embed_init_std
												a__          =  init_std
												a__          =  summary_type
												a__          =  summary_use_proj
												a__          =  summary_activation
												a__          =  summary_proj_to_labels
												a__          =  summary_first_dropout
												a__          =  start_n_top
												a__          =  end_n_top
												a__          =  mask_token_id
												a__          =  lang_id

												if "n_words" in kwargs:
																	a__          =  kwargs['''n_words''']

												super().__init__(pad_token_id=__A				,		bos_token_id=__A				,		**__A    )







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							@property
							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												if self.task == "multiple-choice":
																	a__          =  {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
												else:
																	a__          =  {0: '''batch''', 1: '''sequence'''}
												return OrderedDict(
												    [
												        ('''input_ids''', dynamic_axis),
												        ('''attention_mask''', dynamic_axis),
												        ('''token_type_ids''', dynamic_axis),
												    ]    )


