





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

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

   '''simple docstring'''







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







@dataclass
class __a			:
   __UpperCamelCase :			int
   __UpperCamelCase :			float
   __UpperCamelCase :			str
   __UpperCamelCase :			bool







@dataclass
class __a			:
   __UpperCamelCase :			int						   =						42
   __UpperCamelCase :			str						   =						field(default='toto', metadata={'help': 'help message'}      )







@dataclass
class __a			:
   __UpperCamelCase :			bool						   =						False
   __UpperCamelCase :			bool						   =						True
   __UpperCamelCase :			Optional[bool]						   =						None







class __a			( _snake_case      ):
   __UpperCamelCase :			Any						   =						'titi'
   __UpperCamelCase :			Union[str, Any]						   =						'toto'







class __a			( _snake_case      ):
   __UpperCamelCase :			Optional[int]						   =						'titi'
   __UpperCamelCase :			int						   =						'toto'
   __UpperCamelCase :			Optional[Any]						   =						42







@dataclass
class __a			:
   __UpperCamelCase :			BasicEnum						   =						"toto"





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							BasicEnum(self.foo     )







@dataclass
class __a			:
   __UpperCamelCase :			MixedTypeEnum						   =						"toto"





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							MixedTypeEnum(self.foo     )







@dataclass
class __a			:
   __UpperCamelCase :			Optional[int]						   =						None
   __UpperCamelCase :			Optional[float]						   =						field(default=_snake_case, metadata={'help': 'help message'}      )
   __UpperCamelCase :			Optional[str]						   =						None
   __UpperCamelCase :			Optional[List[str]]						   =						list_field(default=[]      )
   __UpperCamelCase :			Optional[List[int]]						   =						list_field(default=[]      )







@dataclass
class __a			:
   __UpperCamelCase :			List[int]						   =						list_field(default=[]      )
   __UpperCamelCase :			List[int]						   =						list_field(default=[1, 2, 3]      )
   __UpperCamelCase :			List[str]						   =						list_field(default=['Hallo', 'Bonjour', 'Hello']      )
   __UpperCamelCase :			List[float]						   =						list_field(default=[0.1, 0.2, 0.3]      )







@dataclass
class __a			:
   __UpperCamelCase :			List[int]						   =						field()
   __UpperCamelCase :			str						   =						field()
   __UpperCamelCase :			BasicEnum						   =						field()





   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							BasicEnum(self.required_enum     )







@dataclass
class __a			:
   __UpperCamelCase :			int
   __UpperCamelCase :			"BasicEnum"						   =						field()
   __UpperCamelCase :			"Optional[bool]"						   =						None
   __UpperCamelCase :			"str"						   =						field(default='toto', metadata={'help': 'help message'}      )
   __UpperCamelCase :			"List[str]"						   =						list_field(default=['Hallo', 'Bonjour', 'Hello']      )


if is_python_no_less_than_3_10:







    @dataclass
    class __a			:
       __UpperCamelCase :			bool						   =						False
       __UpperCamelCase :			bool						   =						True
       __UpperCamelCase :			bool | None						   =						None







    @dataclass
    class __a			:
       __UpperCamelCase :			int | None						   =						None
       __UpperCamelCase :			float | None						   =						field(default=_snake_case, metadata={'help': 'help message'}      )
       __UpperCamelCase :			str | None						   =						None
       __UpperCamelCase :			list[str] | None						   =						list_field(default=[]      )
       __UpperCamelCase :			list[int] | None						   =						list_field(default=[]      )







class __a			( unittest.TestCase      ):





   def   UpperCAmelCase__  (       self					:      List[str]					,lowerCamelCase					:      argparse.ArgumentParser					,lowerCamelCase					:      argparse.ArgumentParser     ):

      '''simple docstring'''

      self.assertEqual(len(a._actions     )					,len(b._actions     )     )
      for x, y in zip(a._actions					,b._actions     ):
         __SCREAMING_SNAKE_CASE   				=							{k: v for k, v in vars(lowerCamelCase     ).items() if k != """container"""}
         __SCREAMING_SNAKE_CASE   				=							{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   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

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

      __SCREAMING_SNAKE_CASE   				=							["""--foo""", """1""", """--baz""", """quux""", """--bar""", """0.5"""]
      ((__SCREAMING_SNAKE_CASE)				,  )   				=							parser.parse_args_into_dataclasses(lowerCamelCase					,look_for_args_file=lowerCamelCase     )
      self.assertFalse(example.flag     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							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   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

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

      __SCREAMING_SNAKE_CASE   				=							[WithDefaultBoolExample]
      if is_python_no_less_than_3_10:
         dataclass_types.append(lowerCamelCase     )

      for dataclass_type in dataclass_types:
         __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )
         self.argparsersEqual(lowerCamelCase					,lowerCamelCase     )

         __SCREAMING_SNAKE_CASE   				=							parser.parse_args([]     )
         self.assertEqual(lowerCamelCase					,Namespace(foo=lowerCamelCase					,baz=lowerCamelCase					,opt=lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							parser.parse_args(["""--foo""", """--no_baz"""]     )
         self.assertEqual(lowerCamelCase					,Namespace(foo=lowerCamelCase					,baz=lowerCamelCase					,opt=lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							parser.parse_args(["""--foo""", """--baz"""]     )
         self.assertEqual(lowerCamelCase					,Namespace(foo=lowerCamelCase					,baz=lowerCamelCase					,opt=lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							parser.parse_args(["""--foo""", """True""", """--baz""", """True""", """--opt""", """True"""]     )
         self.assertEqual(lowerCamelCase					,Namespace(foo=lowerCamelCase					,baz=lowerCamelCase					,opt=lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							parser.parse_args(["""--foo""", """False""", """--baz""", """False""", """--opt""", """False"""]     )
         self.assertEqual(lowerCamelCase					,Namespace(foo=lowerCamelCase					,baz=lowerCamelCase					,opt=lowerCamelCase     )     )





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							argparse.ArgumentParser()
      expected.add_argument(
          """--foo"""					,default="""toto"""					,choices=["""titi""", """toto""", 42]					,type=make_choice_type_function(["""titi""", """toto""", 42]     )					,)
      self.argparsersEqual(lowerCamelCase					,lowerCamelCase     )

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

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

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





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      @dataclass
      class __a			:
         __UpperCamelCase :			Literal["titi", "toto", 42]						   =						"toto"





      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							argparse.ArgumentParser()
      expected.add_argument(
          """--foo"""					,default="""toto"""					,choices=("""titi""", """toto""", 42)					,type=make_choice_type_function(["""titi""", """toto""", 42]     )					,)
      self.argparsersEqual(lowerCamelCase					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							parser.parse_args([]     )
      self.assertEqual(args.foo					,"""toto"""     )

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

      __SCREAMING_SNAKE_CASE   				=							parser.parse_args(["""--foo""", """42"""]     )
      self.assertEqual(args.foo					,42     )





   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

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

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

      __SCREAMING_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(lowerCamelCase					,Namespace(foo_int=[1]					,bar_int=[2, 3]					,foo_str=["""a""", """b""", """c"""]					,foo_float=[0.1, 0.7]     )     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

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

      __SCREAMING_SNAKE_CASE   				=							[OptionalExample]
      if is_python_no_less_than_3_10:
         dataclass_types.append(lowerCamelCase     )

      for dataclass_type in dataclass_types:
         __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

         self.argparsersEqual(lowerCamelCase					,lowerCamelCase     )

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

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

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							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   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							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   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

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

      __SCREAMING_SNAKE_CASE   				=							parser.parse_dict(lowerCamelCase     )[0]
      __SCREAMING_SNAKE_CASE   				=							BasicExample(**lowerCamelCase     )
      self.assertEqual(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

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

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





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

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

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

      __SCREAMING_SNAKE_CASE   				=							BasicExample(**lowerCamelCase     )
      self.assertEqual(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )

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





   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							HfArgumentParser(lowerCamelCase     )
      self.assertIsNotNone(lowerCamelCase     )









import datasets


snake_case							:       int										=	'''\
@InProceedings{conneau2018xnli,
  author = "Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin",
  title = "XNLI: Evaluating Cross-lingual Sentence Representations",
  booktitle = "Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing",
  year = "2018",
  publisher = "Association for Computational Linguistics",
  location = "Brussels, Belgium",
}
'''

snake_case							:       Tuple										=	'''\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
'''

snake_case							:       Union[str, Any]										=	'''
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    \'accuracy\': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric("xnli")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}
'''
def 							__lowerCamelCase		(					UpperCAmelCase_		:						List[Any]					,    UpperCAmelCase_		:						List[str]		):




      """simple docstring"""





      return (preds == labels).mean()







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,       _KWARGS_DESCRIPTION				)
class 						_snake_case    ( datasets.Metric				):




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       return datasets.MetricInfo(
           description=_DESCRIPTION   ,    citation=_CITATION   ,    inputs_description=_KWARGS_DESCRIPTION   ,    features=datasets.Features(
               {
                   '''predictions''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''       ),
                   '''references''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''       ),
               }       )   ,    codebase_urls=[]   ,    reference_urls=[]   ,    format='''numpy'''   ,    )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       return {"accuracy": simple_accuracy(_lowerCamelCase   ,    _lowerCamelCase       )}





