o  hP @sFddlZddlZddlZddlZddlZddlmZmZmZddl m Z ddl m Z ddl m Z ddlmZddlmZddlmZmZmZmZmZmZmZddlZed eZed eZd d Zd edeegeffddZ ddej!ej!dddeeeeefdeededegefdee"dej#f ddZ$GdddeZ%dS)N)ArgumentDefaultsHelpFormatterArgumentParserArgumentTypeError)Iterable)copy)Enum)isclassPath)AnyCallableLiteralNewTypeOptionalUnionget_type_hints DataClass DataClassTypecCs>t|tr|S|dvrdS|dvrdStd|d)N)yestruety1T)nofalsefn0FzTruthy value expected: got zJ but expected one of yes/no, true/false, t/f, y/n, 1/0 (case insensitive).) isinstanceboollowerr)vr"m/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/transformers/hf_argparser.pystring_to_bool$s    r$choicesreturncsdd|DfddS)aN 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. cSsi|]}t||qSr")str).0choicer"r"r# <sz-make_choice_type_function..cs ||SN)get)arg str_to_choicer"r#=s z+make_choice_type_function..r")r%r"r.r#make_choice_type_function1s r1)aliaseshelpdefaultdefault_factorymetadatar2r3r4r5r6cKsD|duri}|dur||d<|dur||d<tjd|||d|S)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. Nr2r3)r6r4r5r") dataclassesfield)r2r3r4r5r6kwargsr"r"r#HfArg@s$r:c seZdZUdZeeed<ddeeeeefffdd Z e de de j fdd Zd efd d Z    ddeedffddZddeeefdedeedffddZ ddeeejfdedeedffddZ ddeeejfdedeedffddZZS) HfArgumentParsera 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 st|durg}nt|ts|g}d|vrt|d<tjdi|t|r(|g}t||_|jD]}| |q0dS)Nformatter_classr") rrrsuper__init__r7 is_dataclasslistr<_add_dataclass_arguments)selfr<r9dtype __class__r"r#r?s     zHfArgumentParser.__init__parserr8cCsd|jg}d|jvr|d|jdd|j}t|jtr(td| dg}t|tr6|g}t |jd|j}|t usMt t drt|t jrt|jjvrlt|jjdksctd|jjvrltd |jd td|jjvr|jjd tur|jjd n|jjd |_t |jd|j}n$t|jjvrtd|jjd r|jjd n|jjd |_t |jd|j}i}|tust|jtrt|jtr|tur|jj|d <n dd|jD|d <t|d |d<|jtjur|j|d<nd|d<n|jtus|jttkr8t|}t|d<|jtus|jdur7|jtjur7|jtjur(dn|j}||d<d|d<d|d<nUt|rit|tri|jjd |d<d|d<|jtjur]||d<n0|jtjurhd|d<n$|j|d<|jtjur{|j|d<n|jtjur||d<nd|d<|jg||Ri||jdur|jtus|jttkrd|d<|jd|jd|jddfd|jd|dSdSdS)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%cSsg|]}|jqSr")value)r(xr"r"r# sz;HfArgumentParser._parse_dataclass_field..typer4TrequiredF?nargsconst+z--no_z--no- store_false)actiondest) nameappendreplacer6rrrQr' RuntimeErrorpopgetattrrhasattrtypesrK__args__len ValueErrorrr issubclassrr1r4r7MISSINGrr$rrAr5 add_argument)rGr8 long_optionsr9r2 origin_type bool_kwargsr4r"r"r#_parse_dataclass_fields       * (    &  (  z'HfArgumentParser._parse_dataclass_fieldrDc Cst|dr ||j}n|}zt|}WnCty#td|dtyW}z)tjdddkrRdt |vrRd t t tjdd}td|d |d |d}~wwt |D]}|jscq]||j|_|||q]dS) N_argument_group_namezType resolution failed for z. Try declaring the class in global scope or removing line of `from __future__ import annotations` which opts in Postponed Evaluation of Annotations (PEP 563)rL) z!unsupported operand type(s) for |.rmz on Python a6. Try removing line of `from __future__ import annotations` which opts in union types as `X | Y` (PEP 604) via Postponed Evaluation of Annotations (PEP 563). To support Python versions that lower than 3.10, you need to use `typing.Union[X, Y]` instead of `X | Y` and `typing.Optional[X]` instead of `X | None`.)r`add_argument_grouprlr NameErrorr] TypeErrorsys version_infor'joinmapr7fieldsinitrZrQrk)rCrDrG type_hintsexpython_versionr8r"r"r#rBs4     z)HfArgumentParser._add_dataclass_argumentsFTr&.cs|s |s |r{ttjr{g}|r|t|n|r+ttjr+|ttjdd|rWt}|j|tdd|j |d\}}t | | dd} | rW| dd | Dg} |D]} | ri| | 7} q[|durr| |n| tjd d}|j |d\} } g}|jD]/}d d t|Dfd dt | D}D]}t| |q|di|}||qt| jdkr|| |rg|| RS| rtd| g|RS)a' Parse command-line args into instances of the specified dataclass types. This relies on argparse's `ArgumentParser.parse_known_args`. See the doc at: docs.python.org/3.7/library/argparse.html#argparse.ArgumentParser.parse_args Args: args: List of strings to parse. The default is taken from sys.argv. (same as argparse.ArgumentParser) return_remaining_strings: If true, also return a list of remaining argument strings. look_for_args_file: If true, will look for a ".args" file with the same base name as the entry point script for this process, and will append its potential content to the command line args. args_filename: If not None, will uses this file instead of the ".args" file specified in the previous argument. args_file_flag: If not None, will look for a file in the command-line args specified with this flag. The flag can be specified multiple times and precedence is determined by the order (last one wins). Returns: Tuple consisting of: - the dataclass instances in the same order as they were passed to the initializer.abspath - if applicable, an additional namespace for more (non-dataclass backed) arguments added to the parser after initialization. - The potential list of remaining argument strings. (same as argparse.ArgumentParser.parse_known_args) rz.argsr[)rQrX)argsrINcSsg|]}t|qSr"r )r(pr"r"r#rPUsz@HfArgumentParser.parse_args_into_dataclasses..rMcSh|]}|jr|jqSr"rxrZr(rr"r"r# bz?HfArgumentParser.parse_args_into_dataclasses..ci|] \}}|vr||qSr"r"r(kr!keysr"r#r*cz@HfArgumentParser.parse_args_into_dataclasses..z?Some specified arguments are not used by the HfArgumentParser: r")rcrsargvr[r with_suffixrrgr'parse_known_argsvarsr,lstripextendexists read_textsplitr<r7rwitemsdelattr__dict__rd)rCr|return_remaining_stringslook_for_args_file args_filenameargs_file_flag args_filesargs_file_parsercfgcmd_args_file_paths file_args args_file namespaceremaining_argsoutputsrDinputsrobjr"rr#parse_args_into_dataclassessF%"     z,HfArgumentParser.parse_args_into_dataclassesr|allow_extra_keyscst|}g}|jD]*}ddt|Dfdd|D}|||di|}||q |sC|rCtdt |t |S)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. cSr~r"rrr"r"r#rrz.HfArgumentParser.parse_dict..crr"r"rrr"r#r*rz/HfArgumentParser.parse_dict..z0Some keys are not used by the HfArgumentParser: Nr") setrr<r7rwrdifference_updater[rdsortedtuple)rCr|r unused_keysrrDrrr"rr# parse_dictss   zHfArgumentParser.parse_dict json_filecCsTtt|dd}t|}Wdn1swY|j||d}t|S)at 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)rCrropen_json_filedatarr"r"r#parse_json_files z HfArgumentParser.parse_json_file yaml_filecCs$|jtt||d}t|S)at 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)rCrrrr"r"r#parse_yaml_filesz HfArgumentParser.parse_yaml_filer+)NFTNN)F)__name__ __module__ __qualname____doc__rr__annotations__rrr? staticmethodrr7FieldrkrBrrrdictr'r rrosPathLikerr __classcell__r"r"rEr#r;os@  $i$  (V     r;)&r7rrrsraargparserrrcollections.abcrrenumrinspectrpathlibr typingr r r rrrrrrrr$rAr'r1rfrrr:r;r"r"r"r#sH     $     /