֗jLJUdZddlmZddlZddlZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZmZddlmZdd lmZdd lmZmZmZdd l m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)ddl*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2m3Z3erddl4m5Z5ejlGddejnZ8ee8e de ffZ9de:d<ejvdGddZ<ejvdGddZ=ejvdGdde e1Z>ejvdGdde>e1Z?d d! d1d"Z@d2d#ZA d3 d4d$ZB d5d%ZC d6 d7d&ZD d8d'ZEd9d(ZF d:d)ZG d; dd,ZJd?d-ZK d@d.ZLdAd/ZMdd0l4m5Z5mNZNy)BzHDefine the external facing argument definition types provided by a user.) annotationsN)cached_property) TYPE_CHECKINGAnyCallableGenericIterableLiteralSequenceSetTextIOUnioncast) TypeAlias)Fieldextract_dataclass_metadata)complete_choices) Completion)DefaultDefaultFormatter ValueFrom)Resolved)Parserevaluate_parse parse_handler parse_literal parse_value)State)Empty EmptyTypeTypeView)DocDocTypeTdetect_choicesfind_annotations DestructurecveZdZdZdZdZdZdZdZdZ dZ d Z e dd Z e dd Ze dd Zed Zy) ArgActiona`Arg` action typee. Options: - set: Stores the given CLI value directly. - store_true: Stores a literal `True` value, causing options to not attempt to consume additional CLI arguments - store_false: Stores a literal `False` value, causing options to not attempt to consume additional CLI arguments - append: Produces a list, and accumulates the given value on top of prior values. - count: Increments an integer starting at 0 - help: Cancels argument parsing and prints the help text - version: Cancels argument parsing and prints the CLI version - completion: Cancels argument parsing and enters "completion mode" store store_true store_falseappendcounthelpversion completioncH|j|j|jhSN)r0r1r2clss NC:\Users\pivot\Documents\cueki\casual-preloader\Lib\site-packages\cappa/arg.py meta_actionszArgAction.meta_actionsMs#++s~~66c0|duxrt|t Sr4) isinstancer*r6actions r7 is_customzArgAction.is_customQsT!G*VY*G&GGr9c|tjtjtjtjtj hvSr4)r*r,r-r/r1r0r<s r7is_non_value_consumingz ArgAction.is_non_value_consumingUs=   ! ! OO    NN    r9c6||j|jhvSr4)r,r-selfs r7is_bool_actionzArgAction.is_bool_action_s)9)9:::r9N)returnzSet[ArgAction])r=z%ArgAction | Callable[..., Any] | None)__name__ __module__ __qualname____doc__setr,r-r.r/r0r1r2 classmethodr8r>r@propertyrDr9r7r*r*2s  CJK F E DGJ77HH  ;;r9r*.r ArgActionTypeT)frozenceZdZUdZdZded<dZded<dZd ed <ed Z e d dd Z e dd Z ddZ y)NumArgsuControl the number of values consumed for an argument, with optional-value support. Note: The vast majority of uses of `Arg.num_args` should be covered by supplying an integer value, or `NumArgs.unbounded()`. When `required=False`, the argument can be supplied without a value (e.g. `--foo` with no following value), yielding the `NumArgs.default` rather than the Arg's overall default. This maps to argparse's `nargs='?'` / `const` behaviour or click' s `is_flag=True` / `flag_value` behavior. Args: n: Number of values to consume. ``-1`` means unbounded. Defaults to ``1``. required: Whether a value is required when the option flag is present. When ``False``, ``--foo`` (no value) yields ``default`` and ``--foo VAL`` yields the parsed ``VAL``. Defaults to ``True``. default: Value used when the flag is present but no value follows. Only meaningful when ``required=False``. Defaults to ``None``. Example:: @dataclass class Args: # test.py -> Args(foo=5) (class default, flag not given) # test.py --foo -> Args(foo=None) (flag given, no value → NumArgs.default) # test.py --foo 4 -> Args(foo=4) (flag given with value) foo: Annotated[ int | None, Arg(long=True, num_args=NumArgs(required=False)) ] = 5 intnTboolrequiredNrdefaultc|dS)NrTrMr5s r7 unboundedzNumArgs.unboundeds Ryr9c |rv|j9t|jtr |jS||jS|jr|Stj |r |dS|j rt}g}|jD]g}|jr|j|||||} |j| j|j|j| jfit|dk(r||j!Sdj#|D cgc]\} } d| d| dc} } } t%d|d | d |j&r(|j(s|t|j*S|duxs|j, xr| } |j(xs|j/t0tf}| r|r|j3S|j/t0tt4fr2|j|jd|}||jS|Scc} } w) NrZrargr=longrR, `z` produces `num_args= On field 'z-', mismatch of arity between union variants. .)num_argsr;rQparser*r@is_unionrJ inner_types is_none_typeinferaddrTr.rawlenpopjoin ValueErroris_tupleis_variadic_tupleargsshortis_subclass_oflistr[tuple)r6 type_view field_namer^r=r_ distinct_n n_variantstype_arginferredtrT invalid_kinds is_positional is_sequenceinners r7riz NumArgs.infers ||'cllG4<<'S\\**yyu //7Qx   $'5J02J%11((99jc&t%xzz*!!8<<"<=2:!#Z^^-.. II>HIjda1QC,QCq1jIMZL(UVcUddef    i&A&AY^^,- -t CCII (Bd( 11 Y5M5M 6 [==? "  # #T3$6 7IIi33A6 CE> !u 1Js<I c>t|tr |jS|S)zHExtract the integer count from a raw (pre-normalization) num_args value.)r;rQrT)rds r7raw_nz NumArgs.raw_ns h (:: r9c,t|jSr4)strrTrBs r7__str__zNumArgs.__str__s466{r9)NNF) rw TypeView[Any]rxrr^zArg[Any] | Noner=ArgActionType | Noner_list[str] | Literal[False]rErQ)rdint | NumArgs | NonerEz int | None)rEr)rFrGrHrIrT__annotations__rVrWrKr[ri staticmethodrrrMr9r7rQrQgs:AsJHdGS $'++0 > >> > % > ) > >>@ r9rQceZdZUdZej ddZded<dZded <ej d d Z d ed <dZ ded<dZ ded<e dZ ddZe d ddZy )Groupa5Object used to control argument/subcommand grouping in generated help text. Note, when implicit group syntax is used, exclusive groups are automatically inferred, and the group identity is inferred to be the argument's `field_name`. E.g. `foo: Annotated[bool, Arg(long="--foo"), Arg(long="--bar")]`. Args: order: A number representing the relative ordering among different argument groups. Groups with the same order will be displayed alphabetically by name. name: The display name of the group in help text. exclusive: Used to control whether items in the group are mutually exclusive with each other. If `True`, the name of the group will be used to control group identity. If a string is provided, items with the same exclusive string will be considered part of the same exclusivity group. section: A secondary level of ordering. Sections have a higher order precedence than ``order``, in order to facilitate meta-ordering amongst kinds of groups (such as "meta" arguments (``--help``, ``--version``, etc) and subcommands). The default ``section`` for any normal argument/``Group`` is 0, for ``Subcommand`` it is 1, and for "meta" arguments it is 2. Examples: A non-exclusive group which just affects helptext display grouping >>> arg = Arg(group=Group(name="Colors")) An exclusive group, in which all "Colors"-named arguments are mutually exclusive >>> arg = Arg(group=Group(name="Colors", exclusive=True)) An exclusive group, in which all "colors"-identity arguments are mutually exclusive, but whose helptext is grouped alongside all other "Options". >>> arg = Arg(group=Group(name="Options", exclusive="colors")) rF)rWcomparerSorderrnameNTzbool | str | None exclusivesectionidcp|j|j|jt|jfSr4)rrrrUrrBs r7keyz Group.keys& djj$))T$..5IJJr9c dg}tj|D]k}|js|jdk7rt ||j}t ||j}||k7sQ|j |jm|Dcgc]}|dt ||}}|Dcgc]}|dt ||}}ddj |ddj |dScc}wcc}w)zReturn a string showing only the attributes that differ between two Groups. Returns a string in the format: "Group(attr=value, ...) != Group(attr=other_value, ...)" r=zGroup(r`z ) != Group()) dataclassesfieldsrrgetattrr.rn) rCotherdiffering_attrsfield self_value other_valueattr self_parts other_partss r7diffz Group.diffs '+V ''-E==UZZ4%7 uzz2J!%4K[(&&uzz2.ETTODad 367O TFUVod$q!5 89o V *-.k$))K:P9QQRSSUVs C*)C/cTd}d}d}t|jtr|jj}|jj}|jj r|jj }|jj |jj }t|jtr |j}t|jtr|j\}}| |rd}nd}d}t|tr|}n|}|||t|||S)NrOptions ArgumentsrR)rrrrr) r;grouprrrrrrrvrU)r6r^ is_optionrrrridentitys r7riz Group.infers cii 'IIOOEii''Gyy~~yy~~yy"".II// cii %99D cii '))KE4 < " i % HH9o   r9)rrrErF)r^Arg[Any]rrUr bool | strrEr)rFrGrHrIrrrrrrrrrrrrKrirMr9r7rrsB#""1e