




'''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    :							Any										=    sys.version_info >= (3, 10)


def 						__magic_name__       (      __UpperCAmelCase=None, __UpperCAmelCase=None      )						->   List[str]:

					'''simple docstring'''

					return field(default_factory=lambda: default, metadata=__UpperCAmelCase      )






@dataclass
class 		a							:
				snake_case_           =						42
				snake_case_           =						42
				snake_case_           =						42
				snake_case_           =						42







@dataclass
class 		a							:
				snake_case_           =						42
				snake_case_           =						field(default="toto"  ,	metadata={"help": "help message"}	)







@dataclass
class 		a							:
				snake_case_           =						False
				snake_case_           =						True
				snake_case_           =						None







class 		a							(  _lowerCamelCase	):
				snake_case_           =						"titi"
				snake_case_           =						"toto"







class 		a							(  _lowerCamelCase	):
				snake_case_           =						"titi"
				snake_case_           =						"toto"
				snake_case_           =						42







@dataclass
class 		a							:
				snake_case_           =						"toto"


				def     A_					(						self       :   List[str]   ):
									snake_case_		     =							BasicEnum(self.foo   )







@dataclass
class 		a							:
				snake_case_           =						"toto"


				def     A_					(						self       :   Dict   ):
									snake_case_		     =							MixedTypeEnum(self.foo   )







@dataclass
class 		a							:
				snake_case_           =						None
				snake_case_           =						field(default=_lowerCamelCase  ,	metadata={"help": "help message"}	)
				snake_case_           =						None
				snake_case_           =						list_field(default=[]	)
				snake_case_           =						list_field(default=[]	)







@dataclass
class 		a							:
				snake_case_           =						list_field(default=[]	)
				snake_case_           =						list_field(default=[1, 2, 3]	)
				snake_case_           =						list_field(default=["Hallo", "Bonjour", "Hello"]	)
				snake_case_           =						list_field(default=[0.1, 0.2, 0.3]	)







@dataclass
class 		a							:
				snake_case_           =						field()
				snake_case_           =						field()
				snake_case_           =						field()


				def     A_					(						self       :   Any   ):
									snake_case_		     =							BasicEnum(self.required_enum   )







@dataclass
class 		a							:
				snake_case_           =						42
				snake_case_           =						field()
				snake_case_           =						None
				snake_case_           =						field(default="toto"  ,	metadata={"help": "help message"}	)
				snake_case_           =						list_field(default=["Hallo", "Bonjour", "Hello"]	)


if is_python_no_less_than_3_10:






							@dataclass
							class 		a							:
											snake_case_           =						False
											snake_case_           =						True
											snake_case_           =						None







							@dataclass
							class 		a							:
											snake_case_           =						None
											snake_case_           =						field(default=_lowerCamelCase  ,	metadata={"help": "help message"}	)
											snake_case_           =						None
											snake_case_           =						list_field(default=[]	)
											snake_case_           =						list_field(default=[]	)






class 		a							(  unittest.TestCase	):


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

														self.assertEqual(lowercase_			,							lowercase_   )


				def     A_					(						self       :   Tuple   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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

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


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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


				def     A_					(						self       :   str   ):
									snake_case_		     =							argparse.ArgumentParser()
									expected.add_argument('''--foo'''			,							type=lowercase_			,							default=lowercase_			,							const=lowercase_			,							nargs='''?'''   )
									expected.add_argument('''--baz'''			,							type=lowercase_			,							default=lowercase_			,							const=lowercase_			,							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=lowercase_			,							dest='''baz'''   )
									expected.add_argument('''--opt'''			,							type=lowercase_			,							default=lowercase_   )

									snake_case_		     =							[WithDefaultBoolExample]
									if is_python_no_less_than_3_10:
														dataclass_types.append(lowercase_   )

									for dataclass_type in dataclass_types:
														snake_case_		     =							HfArgumentParser(lowercase_   )
														self.argparsersEqual(lowercase_			,							lowercase_   )

														snake_case_		     =							parser.parse_args([]   )
														self.assertEqual(lowercase_			,							Namespace(foo=lowercase_			,							baz=lowercase_			,							opt=lowercase_   )   )

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

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

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

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


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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

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

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

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


				def     A_					(						self       :   str   ):






									@dataclass
									class 		a							:
													snake_case_           =						"toto"







									snake_case_		     =							HfArgumentParser(lowercase_   )

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

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

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

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


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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

									self.argparsersEqual(lowercase_			,							lowercase_   )

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

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


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							argparse.ArgumentParser()
									expected.add_argument('''--foo'''			,							default=lowercase_			,							type=lowercase_   )
									expected.add_argument('''--bar'''			,							default=lowercase_			,							type=lowercase_			,							help='''help message'''   )
									expected.add_argument('''--baz'''			,							default=lowercase_			,							type=lowercase_   )
									expected.add_argument('''--ces'''			,							nargs='''+'''			,							default=[]			,							type=lowercase_   )
									expected.add_argument('''--des'''			,							nargs='''+'''			,							default=[]			,							type=lowercase_   )

									snake_case_		     =							[OptionalExample]
									if is_python_no_less_than_3_10:
														dataclass_types.append(lowercase_   )

									for dataclass_type in dataclass_types:
														snake_case_		     =							HfArgumentParser(lowercase_   )

														self.argparsersEqual(lowercase_			,							lowercase_   )

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

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


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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


				def     A_					(						self       :   int   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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

									snake_case_		     =							parser.parse_dict(lowercase_   )[0]
									snake_case_		     =							BasicExample(**lowercase_   )
									self.assertEqual(lowercase_			,							lowercase_   )


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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

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


				def     A_					(						self       :   Dict   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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

									snake_case_		     =							BasicExample(**lowercase_   )
									self.assertEqual(lowercase_			,							lowercase_   )


				def     A_					(						self       :   Dict   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )

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


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							HfArgumentParser(lowercase_   )
									self.assertIsNotNone(lowercase_   )







'''simple docstring'''

from numpy import exp, pi, sqrt


def 						__magic_name__       (      __UpperCAmelCase, __UpperCAmelCase = 0.0, __UpperCAmelCase = 1.0      )						->   int:

					'''simple docstring'''

					return 1 / sqrt(2 * pi * sigma**2      ) * exp(-((x - mu) ** 2) / (2 * sigma**2)      )


if __name__ == "__main__":
							import doctest

							doctest.testmod()

