jM SSKrSSKrSSKrSSKrSSKrSSKJrJrJr SSK J r J r SSK J r SSK Jr SSKJr SSKJr SSKJrJrJrJrJr SSKr\"S \5r\"S \5rS rS \S \ \/\44SjrSS\R@\R@SS.S\\\-S-S\S-S\S\ /\4S\!S-S \RD4 Sjjr#"SS\5r$g)N)ArgumentDefaultsHelpFormatterArgumentParserArgumentTypeError)CallableIterable)copy)Enum)isclass)Path)AnyLiteralNewTypeUnionget_type_hints DataClass DataClassTypec[U[5(aU$UR5S;agUR5S;ag[SUS35e)N)yestruety1T)nofalsefn0FzTruthy value expected: got zJ but expected one of yes/no, true/false, t/f, y/n, 1/0 (case insensitive).) isinstanceboollowerr)vs ڧC:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\transformers/hf_argparser.pystring_to_boolr#$sR!Twwy22 4 4)!,v w  choicesreturncT^UVs0sHn[U5U_M snmU4Sj$s snf)a2 Creates a mapping function from each choices string representation to the actual value. Used to support multiple value types for a single argument. Args: choices (list): List of choices. Returns: Callable[[str], Any]: Mapping function from string representation to actual value for each choice. c&>TRX5$N)get)arg str_to_choices r"+make_choice_type_function..=s}((2r$)str)r%choicer,s @r"make_choice_type_functionr11s.8??wVS[&(w?M 22@s%)aliaseshelpdefaultdefault_factorymetadatar2r3r4r5r6c ZUc0nUbXS'UbXS'[R"SXBUS.UD6$)aArgument helper enabling a concise syntax to create dataclass fields for parsing with `HfArgumentParser`. Example comparing the use of `HfArg` and `dataclasses.field`: ``` @dataclass class Args: regular_arg: str = dataclasses.field(default="Huggingface", metadata={"aliases": ["--example", "-e"], "help": "This syntax could be better!"}) hf_arg: str = HfArg(default="Huggingface", aliases=["--example", "-e"], help="What a nice syntax!") ``` Args: aliases (Union[str, list[str]], optional): Single string or list of strings of aliases to pass on to argparse, e.g. `aliases=["--example", "-e"]`. Defaults to None. help (str, optional): Help string to pass on to argparse that can be displayed with --help. Defaults to None. default (Any, optional): Default value for the argument. If not default or default_factory is specified, the argument is required. Defaults to dataclasses.MISSING. default_factory (Callable[[], Any], optional): The default_factory is a 0-argument function called to initialize a field's value. It is useful to provide default values for mutable types, e.g. lists: `default_factory=list`. Mutually exclusive with `default=`. Defaults to dataclasses.MISSING. metadata (dict, optional): Further metadata to pass on to `dataclasses.field`. Defaults to None. Returns: Field: A `dataclasses.Field` with the desired properties. r2r3)r6r4r5) dataclassesfield)r2r3r4r5r6kwargss r"HfArgr<@sIH%     khQ` kdj kkr$c j^\rSrSr%Sr\\\S'SS\\\-S-4U4Sjjjr\ S\ S\ R4Sj5r S \4S jrSS \\S 44S jjrSS\\\4S\S \\S 44SjjrSS\\R0-S\S \\S 44SjjrSS\\R0-S\S \\S 44SjjrSrU=r$)HfArgumentParseroa This subclass of `argparse.ArgumentParser` uses type hints on dataclasses to generate arguments. The class is designed to play well with the native argparse. In particular, you can add more (non-dataclass backed) arguments to the parser after initialization and you'll get the output back after parsing as an additional namespace. Optional: To create sub argument groups use the `_argument_group_name` attribute in the dataclass. Args: dataclass_types (`DataClassType` or `Iterable[DataClassType]`, *optional*): Dataclass type, or list of dataclass types for which we will "fill" instances with the parsed args. kwargs (`dict[str, Any]`, *optional*): Passed to `argparse.ArgumentParser()` in the regular way. dataclass_typesNc $>Uc/nO[U[5(dU/nSU;a [US'[TU]"S0UD6 [ R "U5(aU/n[U5UlURHnURU5 M g)Nformatter_classr8) rrrsuper__init__r9 is_dataclasslistr@_add_dataclass_arguments)selfr@r;dtype __class__s r"rDHfArgumentParser.__init__s  " OOX66./O F *(EF$ % "6"  # #O 4 4./O#O4))E  ) )% 0*r$parserr:c2 SUR3/nSUR;a.URSURRSS535 URR 5n[ UR [5(a [S5eURS/5n[ U[5(aU/n[UR SUR 5nU[Ld6[[S5(Ga[ U[R5(Ga[UR R;a_[!UR R5S:wd#[ S5UR R;a[#S URS 35e[ S5UR R;ayUR RS [LaUR RS OUR RS Ul[UR SUR 5nO[$UR R;a[ SUR RS 5(aUR RS OUR RS Ul[UR SUR 5n0nU[&Ld>[ UR [ 5(a[)UR [*5(aU[&LaUR RUS 'O)UR Vs/sHowR,PM snUS '[/US 5US'UR0[2R4LaUR0US'GOSUS'GOUR [$LdUR [$S-:Xa[ U5n[6US'UR [$Ld*UR0bVUR0[2R4La9UR0[2R4LaSO UR0nXS'SUS'SUS'GO [9U5(a[)U[:5(auUR RS US'SUS'UR<[2R4LaUR=5US'OUR0[2R4LaSUS'OrUR US'UR0[2R4LaUR0US'O6UR<[2R4LaUR=5US'OSUS'UR>"/UQUQ70UD6 UR0SLa|UR [$LdUR [$S-:XaQSUS'UR>"SUR3SURRSS534SURS.UD6 gggs snf)Nz--_-zpUnresolved type detected, which should have been done with the help of `typing.get_type_hints` method by defaultr2 __origin__ UnionTypezOnly `Union[X, NoneType]` (i.e., `Optional[X]`) is allowed for `Union` because the argument parser only supports one type per argument. Problem encountered in field 'z'.rr%typer4TrequiredF?nargsconst+z--no_z--no- store_false)actiondest) nameappendreplacer6rrrTr/ RuntimeErrorpopgetattrrhasattrtypesrQ__args__len ValueErrorrr issubclassr valuer1r4r9MISSINGr#r rFr5 add_argument) rLr: long_optionsr;r2 origin_type bool_kwargsxr4s r"_parse_dataclass_field'HfArgumentParser._parse_dataclass_fields UZZL)* %**    "UZZ%7%7S%A$B C D$$& ejj# & &<  **Y+ gs # #iGejj, C % GE;$?$?J{\a\k\kDlDl%**---EJJ''(A-d5::CVCV1V 66;jj\E Dz!4!447\>G>v> ==D ejjD&8EJJ$QU+>I( (,'79#YRSRT=UD$($9$9t$9$D! ))E$/$6$6u$=H$=qFAFF$=DH'+I'<'<'>L'>tq!!t)dad'>FL 1%/&/C NN3  * y!! "Q & NN9 % #-W-n- - #bcqbr!sttW; 9'MILs0K %K>K, K=Kr{allow_extra_keysc[UR55n/nURHn[R"U5Vs1sH!ofR (dMUR iM# nnUR5VV s0sHupX;dM X_M n nn URU R55 U"S0U D6n URU 5 M U(dU(a[S[U535e[U5$s snfs sn nf)a Alternative helper method that does not use `argparse` at all, instead uses a dict and populating the dataclass types. Args: args (`dict`): dict containing config values allow_extra_keys (`bool`, *optional*, defaults to `False`): Defaults to False. If False, will raise an exception if the dict contains keys that are not parsed. Returns: Tuple consisting of: - the dataclass instances in the same order as they were passed to the initializer. z0Some keys are not used by the HfArgumentParser: r8) setrr@r9rvrwr]rdifference_updater^rgsortedtuple) rHr{r unused_keysrrIrrrr!rrs r" parse_dictHfArgumentParser.parse_dictfs $))+& ))E$/$6$6u$=H$=qFAFF$=DH'+zz|A|tqqydad|FA  ) )&++- 8/&/C NN3  *  KOPVWbPcOdef fW~IAsDD D D  json_filec[[U5SS9n[R"UR 55nSSS5 UR WUS9n[ U5$!,(df  N)=f)a Alternative helper method that does not use `argparse` at all, instead loading a json file and populating the dataclass types. Args: json_file (`str` or `os.PathLike`): File name of the json file to parse allow_extra_keys (`bool`, *optional*, defaults to `False`): Defaults to False. If False, will raise an exception if the json file contains keys that are not parsed. Returns: Tuple consisting of: - the dataclass instances in the same order as they were passed to the initializer. zutf-8)encodingNr)openr jsonloadsreadrr)rHrropen_json_filedatars r"parse_json_file HfArgumentParser.parse_json_filesV"$y/G 4::n1134D5//$9I/JW~5 4s %A A* yaml_filecUR[R"[U5R 55US9n[ U5$)a Alternative helper method that does not use `argparse` at all, instead loading a yaml file and populating the dataclass types. Args: yaml_file (`str` or `os.PathLike`): File name of the yaml file to parse allow_extra_keys (`bool`, *optional*, defaults to `False`): Defaults to False. If False, will raise an exception if the json file contains keys that are not parsed. Returns: Tuple consisting of: - the dataclass instances in the same order as they were passed to the initializer. r)ryaml safe_loadr rr)rHrrrs r"parse_yaml_file HfArgumentParser.parse_yaml_files7"//$..i1J1J1L"M`p/qW~r$)r@r))NFTNN)F)__name__ __module__ __qualname____firstlineno____doc__rr__annotations__rD staticmethodrr9FieldrprGrrrdictr/r rrosPathLikerr__static_attributes__ __classcell__)rJs@r"r>r>os/ m,,1 8O(ORV(V11"g~gk>O>OggR7m7.!& T y#~ TltCH~RWXacfXfRg8r{{):d_denpses_t,r{{):d_denpses_tr$r>)%r9rrr|rdargparserrrcollections.abcrrrenumr inspectr pathlibr typingr r rrrrrrr#rFr/r1rjrrr<r>r8r$r"rs UU.??  K % -    3t 3#0D 3"'+&&)4)<)< ,l 49_t #,l *,l ,l b#g& ,l Tk ,l,l^{~{r$