ServerSync/lib/invoke/parser/__pycache__/context.cpython-314.pyc

+
t<10>iW&<00><00><><00>^R
It^RI
HtHtHtHtHtHtHt^RI	H
t
^
RI
HtRRltRRltR	R
ltRRlt!R
R4tR
# ]d
^RIH
t
L9i;i
)<0F>N)<07>Any<6E>Dict<63>List<73>Iterable<6C>Optional<61>Tuple<6C>Union)
<01>Lexicon)
<01>Argumentc

<00>0<00>V^8<>dQ
h
R
\R\/#<00><03><00>name<6D>return<72>
<01>str)
<01>formats
"<22></tmp/pip-target-zhdecbcm/lib/python/invoke/parser/context.py<70>__annotate__rs<00><00>

:<3A>

:<3A><03>

:<3A><03>

:<3A>c
<00>b<00>VP
R4
PR4
PRR
4#)<02>
_<>
-)<03>lstrip<69>rstrip<69>replace<63>
rs
&r<00>translate_underscoresrs)<00><00><0F>;<3B>;<3B>s<EFBFBD><1B>"<22>"<22>3<EFBFBD>'<27>/<2F>/<2F><03>S<EFBFBD>9<>9rc

<00>0<00>V^8<>dQ
h
R
\R\/#r
r)
rs
"rrrs<00><00>
<17>
<17>#<23>
<17>#<23>
rc
<00>\<00>\
V4
p\V4
^
8Xd
R
V,#RV,#)<03>
rz--)r<00>lenrs
&r<00>to_flagr#s+<00><00> <20><14>&<26>D<EFBFBD>
<EFBFBD>4<EFBFBD>y<EFBFBD>A<EFBFBD>~<7E><12>T<EFBFBD>z<EFBFBD><19><0F>$<24>;<3B>rc

<00>0<00>V^8<>dQ
h
R
\R\/#<00>r<00>argr)rr)
rs
"rrrs<00><00>
7<>
7<><08>
7<>S<EFBFBD>
7rc
<00>
<00>VPp
V
Uu0uF&p\VPR4
4
^
8XgK$VkK(	ppV
Uu0uF
q"V9
gKVkK	pp\\	V'dTM
T4
^,4
#uupiuupi)
r)<05>namesr"<00>stripr<00>sorted)r&r(<00>
x<>shorts<74>longss&    r<00>sort_candidater.sp<00><00><0F>I<EFBFBD>I<EFBFBD>E<EFBFBD><1E>
9<><15>A<EFBFBD>#<23>a<EFBFBD>g<EFBFBD>g<EFBFBD>c<EFBFBD>l<EFBFBD>"3<>q<EFBFBD>"8<>a<EFBFBD>a<EFBFBD><15>F<EFBFBD>
9<><1D>1<><05>1<EFBFBD>&<26><1F>Q<EFBFBD>Q<EFBFBD><05>E<EFBFBD>1<><0E>v<EFBFBD><06>f<EFBFBD>E<EFBFBD>2<>1<EFBFBD>5<>6<>6<><36>:<3A><>1s<00>!A=<04>A=<04>B<04>Bc

<00>h<00>V^8<>dQ
h
R
\R\\\\3,,/#r%)rrr	<00>intr)
rs
"rrrs'<00><00>
<0F>
<0F>(<28>
<0F>t<EFBFBD>E<EFBFBD>#<23>s<EFBFBD>(<28>O<EFBFBD>4<>
rc
<04>T
<00>.p
\
V4
pT
P\V4
^
8Xd^
M
^4
V
PVP44
R
pVF?pY4P	4'dVP4MVP4,
pKA	V
PV4
V
#)zN
Obtain useful key list-of-ints for sorting CLI flags.

.. versionadded:: 1.0
<EFBFBD>)r.<00>appendr"<00>lower<65>isupper<65>upper)r&<00>retr+<00>inversed<65>chars&    r<00>flag_keyr:s<><00><00>"$<24>C<EFBFBD><16>s<EFBFBD><1B>A<EFBFBD><08>J<EFBFBD>J<EFBFBD>C<EFBFBD>
<01>F<EFBFBD>a<EFBFBD>K<EFBFBD>q<EFBFBD>Q<EFBFBD>'<27><08>J<EFBFBD>J<EFBFBD>q<EFBFBD>w<EFBFBD>w<EFBFBD>y<EFBFBD><19><12>H<EFBFBD><11><04><10>L<EFBFBD>L<EFBFBD>N<EFBFBD>N<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD>L<EFBFBD><04>
<EFBFBD>
<EFBFBD><0C>D<><08><12><07>J<EFBFBD>J<EFBFBD>x<EFBFBD><18><0E>Jrc<00><>a<00>]t
Rt^;toR
tRV3
RlRll
tV3
RlRltV3
RlRlt]V3
R	lR
l4t	]V3
RlRl4t
V3
R
lRltV3
RlRltV3
RlRlt
V3
RlRltRtVtR#)<17>
ParserContextz<74>
Parsing context with knowledge of flags & their format.

Generally associated with the core program or a task.

When run through a parser, will also hold runtime values filled in by the
parser.

.. versionadded:: 1.0
Nc

<00>`<
<01>V^8<>dQ
h
R
S
[S
[
,RS
[S
[
,RS
[S
[,RR/#)rr<00>aliases<65>argsrN)rrrr)r<00>
__classdict__s"<22>rr<00>ParserContext.__annotate__Gs@<00><><00><1E><1E><16>s<EFBFBD>m<EFBFBD><1E><1A>#<23><1D><1E><17>x<EFBFBD> <20>	<1E>

<0E>rc<0C><><00>\
4Vn
.Vn\
4Vn/VnWnW nVFpVPV4
K	R
#)a1
Create a new ``ParserContext`` named ``name``, with ``aliases``.

``name`` is optional, and should be a string if given. It's used to
tell ParserContext objects apart, and for use in a Parser when
determining what chunk of input might belong to a given ParserContext.

``aliases`` is also optional and should be an iterable containing
strings. Parsing will honor any aliases when trying to "find" a given
context in its input.

May give one or more ``args``, which is a quick alternative to calling
``for arg in args: self.add_arg(arg)`` after initialization.
N)r
r?<00>positional_args<67>flags<67>
inverse_flagsrr><00>add_arg)<05>selfrr>r?r&s&&&& r<00>__init__<5F>ParserContext.__init__GsF<00><00>(<1C>I<EFBFBD><04>	<09>/1<><04><1C><1C>Y<EFBFBD><04>
<EFBFBD>-/<2F><04><1A><18>	<09><1E><0C><17>C<EFBFBD><10>L<EFBFBD>L<EFBFBD><13><1D>rc

<00> <
<01>V^8<>dQ
h
R
S
[/
#<00>rrr)rr@s"<22>rrrAds<00><><00>9<>9<>#<23>9rc
<08>^
<00>Rp
VP'd+R
PRPVP4
4
p
VP'dRPVPV
4M
RpVP'dRPVP4
M
RpRPW#4#)r2z ({})<29>, z {!r}{}z: {!r}z<parser/Context{}{}>)r>r<00>joinrr?)rGr>rr?s&   r<00>__repr__<5F>ParserContext.__repr__dsx<00><00><14><07><0F><<3C><<3C><<3C><1D>n<EFBFBD>n<EFBFBD>T<EFBFBD>Y<EFBFBD>Y<EFBFBD>t<EFBFBD>|<7C>|<7C>%<<3C>=<3D>G<EFBFBD>9=<3D><19><19><19>	<09> <20> <20><14><19><19>G<EFBFBD>4<><02><04>/3<>y<EFBFBD>y<EFBFBD>y<EFBFBD><08><0F><0F><04>	<09>	<09>*<2A>b<EFBFBD><04>%<25>,<2C>,<2C>T<EFBFBD>8<>8rc

<00>*<
<01>V^8<>dQ
h
R
S
[RS
[RR/#)rr?<00>kwargsrN)
r)rr@s"<22>rrrAls"<00><><00>/=<3D>/=<3D>S<EFBFBD>/=<3D>C<EFBFBD>/=<3D>D<EFBFBD>/=rc
<0C><><00>\
V
4
^
8Xd(\V
^,\4'dV
^,pM\V
/VB
pVPF/pW@P9gKR
p\VP
V4
4
h
	VP^,pW0PV&VP'dVPPV4
W0P\V4
&VPFNpVPPWFR7VPP\V4
\V4
R7KP	VP'd(VPPVPVR7VP\ 8XdGVP"RJd5\RP
V4
4
p\V4
VP$V&R#R#R#)av
Adds given ``Argument`` (or constructor args for one) to this context.

The Argument in question is added to the following dict attributes:

* ``args``: "normal" access, i.e. the given names are directly exposed
  as keys.
* ``flags``: "flaglike" access, i.e. the given names are translated
  into CLI flags, e.g. ``"foo"`` is accessible via ``flags['--foo']``.
* ``inverse_flags``: similar to ``flags`` but containing only the
  "inverse" versions of boolean flags which default to True. This
  allows the parser to track e.g. ``--no-myflag`` and turn it into a
  False value for the ``myflag`` Argument.

.. versionadded:: 1.0
z;Tried to add an argument named {!r} but one already exists!)
<01>toTzno-{}N)r"<00>
isinstancerr(r?<00>
ValueErrorr<00>
positionalrCr3rDr#<00>	nicknames<65>alias<61>	attr_name<6D>kind<6E>bool<6F>defaultrE)rGr?rRr&r<00>msg<73>main<69>inverse_names&*,     rrF<00>ParserContext.add_arglsY
<00><00>$<0F>t<EFBFBD>9<EFBFBD>
<01>><3E>j<EFBFBD><14>a<EFBFBD><17>(<28>;<3B>;<3B><16>q<EFBFBD>'<27>C<EFBFBD><1A>D<EFBFBD>+<2B>F<EFBFBD>+<2B>C<EFBFBD><17>I<EFBFBD>I<EFBFBD>D<EFBFBD><13>y<EFBFBD>y<EFBFBD> <20>S<><03> <20><13><1A><1A>D<EFBFBD>!1<>2<>2<><1E>
<13>y<EFBFBD>y<EFBFBD><11>|<7C><04><1D>	<09>	<09>$<24><0F><0E>><3E>><3E>><3E><10> <20> <20>'<27>'<27><03>,<2C>$'<27>
<EFBFBD>
<EFBFBD>7<EFBFBD>4<EFBFBD>=<3D>!<21><17>M<EFBFBD>M<EFBFBD>D<EFBFBD><10>I<EFBFBD>I<EFBFBD>O<EFBFBD>O<EFBFBD>D<EFBFBD>O<EFBFBD>*<2A><10>J<EFBFBD>J<EFBFBD><1C><1C>W<EFBFBD>T<EFBFBD>]<5D>w<EFBFBD>t<EFBFBD>}<7D><1C>=<3D>"<22><0F>=<3D>=<3D>=<3D><10>I<EFBFBD>I<EFBFBD>O<EFBFBD>O<EFBFBD>C<EFBFBD>M<EFBFBD>M<EFBFBD>d<EFBFBD>O<EFBFBD>3<><0E>8<EFBFBD>8<EFBFBD>t<EFBFBD><1B><03><0B><0B>t<EFBFBD> 3<>#<23>7<EFBFBD>><3E>><3E>$<24>#7<>8<>L<EFBFBD>/6<>t<EFBFBD>}<7D>D<EFBFBD><1E><1E>|<7C>,<2C>!4<>rc

<00>0<
<01>V^8<>dQ
h
R
S
[S
[
,/
#rK)rr)rr@s"<22>rrrA<00>s<00><><00>
D
<01>
D
<01><14>h<EFBFBD><1E>
D
rc
<08>b<00>VPU
u.uFqPeKV
NK	up
#uup
i<00>
N)rC<00>value)rGr+s& r<00>missing_positional_args<67>%ParserContext.missing_positional_args<67>s(<00><00><1F>/<2F>/<2F>C<>/<2F>a<EFBFBD>7<EFBFBD>7<EFBFBD>
<01>
<01>/<2F>C<>C<><43>Cs<00>,<04>,c

<00>6<
<01>V^8<>dQ
h
R
S
[S
[
S
[3,/
#rK)rrr)rr@s"<22>rrrA<00>s<00><><00><13><13>4<EFBFBD><03>S<EFBFBD><08>><3E>rc
<0C>|<00>/p
VPP4FpVPWP&K	V
#)
z<>
This context's arguments' values keyed by their ``.name`` attribute.

Results in a dict suitable for use in Python contexts, where e.g. an
arg named ``foo-bar`` becomes accessible as ``foo_bar``.

.. versionadded:: 1.0
)r?<00>valuesrer)rGr7r&s&  r<00>	as_kwargs<67>ParserContext.as_kwargs<67>s4<00><00><11><03><17>9<EFBFBD>9<EFBFBD>#<23>#<23>%<25>C<EFBFBD><1F>I<EFBFBD>I<EFBFBD>C<EFBFBD><08><08>M<EFBFBD>&<26><12>
rc

<00>6<
<01>V^8<>dQ
h
R
S
[RS
[
S
[,/#<00>r<00>flagr)rr)rr@s"<22>rrrA<00>s<00><><00>?<3F>?<3F>c<EFBFBD>?<3F>d<EFBFBD>3<EFBFBD>i<EFBFBD>?rc<08>l<00>\
\V
.
VPPV
4
,4
4
#rd)<04>list<73>setrD<00>
aliases_of)rGros&&r<00>	names_for<6F>ParserContext.names_for<6F>s(<00><00><13>C<EFBFBD><14><06><14><1A><1A>!6<>!6<>t<EFBFBD>!<<3C><<3C>=<3D>><3E>>rc

<00><<
<01>V^8<>dQ
h
R
S
[RS
[
S
[S
[3,/#rn)rr)rr@s"<22>rrrA<00>s#<00><><00>% <20>% <20>S<EFBFBD>% <20>U<EFBFBD>3<EFBFBD><03>8<EFBFBD>_<EFBFBD>% rc<0C>h<00>WP9
d5R
p\VPWPP444
h
VPV
,p\R\
R/P
VP4
p.pVPV
4
F<>pV'd<>\VPR4
4
^
8Xd8VP'dRPV4
M
TpRPV4
pMmRPV4
pVP'dRPV4
pM8W`PP49dRPVR	,4
pR
pVPWh,4
K<>	RP\!V\R74
p	VP";
'gR
p
W<EFBFBD>3#)
z[
Return 2-tuple of ``(flag-spec, help-string)`` for given ``flag``.

.. versionadded:: 1.0
z@{!r} is not a valid flag for this context! Valid flags are: {!r}<7D>STRING<4E>INTrz[{}]z {}z={}z	--[no-]{}:rNNr2rM<00>
<01>key)rDrVr<00>keysrr0<00>getr[rtr"r)<00>optionalrErjr3rNr*<00>help)rGro<00>errr&re<00>
full_namesr<00>value_<65>valuestr<74>namestr<74>helpstrs&&         r<00>help_for<6F>ParserContext.help_for<6F>sJ
<00><00><10>z<EFBFBD>z<EFBFBD>!<21>T<>C<EFBFBD><1C>S<EFBFBD>Z<EFBFBD>Z<EFBFBD><04>j<EFBFBD>j<EFBFBD>o<EFBFBD>o<EFBFBD>.?<3F>@<40>A<>A<><12>j<EFBFBD>j<EFBFBD><14><1E><03><14>h<EFBFBD><03>U<EFBFBD>+<2B>/<2F>/<2F><03><08><08>9<><05><17>
<EFBFBD><18>N<EFBFBD>N<EFBFBD>4<EFBFBD>(<28>D<EFBFBD><14><17>t<EFBFBD>z<EFBFBD>z<EFBFBD>#<23><EFBFBD>'<27>1<EFBFBD>,<2C>7:<3A>|<7C>|<7C>|<7C>f<EFBFBD>m<EFBFBD>m<EFBFBD>E<EFBFBD>2<><15>F<EFBFBD>$<24>|<7C>|<7C>F<EFBFBD>3<>H<EFBFBD>$<24>|<7C>|<7C>E<EFBFBD>2<>H<EFBFBD><1A>|<7C>|<7C>|<7C>#)<29>=<3D>=<3D><18>#:<3A><08><><18>-<2D>-<2D>4<>4<>6<>6<>&<26>-<2D>-<2D>d<EFBFBD>2<EFBFBD>h<EFBFBD>7<>D<EFBFBD><1D><08><16><1D><1D>d<EFBFBD>o<EFBFBD>.<2E>')<29>(<17>)<29>)<29>F<EFBFBD>:<3A>3<EFBFBD>7<>8<><07><15>(<28>(<28>.<2E>.<2E>b<EFBFBD><07><16><1F>rc

<00>V<
<01>V^8<>dQ
h
R
S
[S
[
S
[S
[S
[,3,,/
#rK)rrrr)rr@s"<22>rrrA<00>s'<00><><00> 
<EFBFBD> 
<EFBFBD>T<EFBFBD>%<25><03>X<EFBFBD>c<EFBFBD>]<5D>(:<3A>";<3B><<3C> 
rc

<0C><>a<00>\
\V3
R
l\SPP	4\
R744
#)a
Return sorted iterable of help tuples for all member Arguments.

Sorts like so:

* General sort is alphanumerically
* Short flags win over long flags
* Arguments with *only* long flags and *no* short flags will come
  first.
* When an Argument has multiple long or short flags, it will sort using
  the most favorable (lowest alphabetically) candidate.

This will result in a help list like so::

    --alpha, --zeta # 'alpha' wins
    --beta
    -a, --query # short flag wins
    -b, --argh
    -c

.. versionadded:: 1.0
c
<00>L<
<01>S
P
\VP4
4
#rd)r<>r#r)r+rGs&<26>r<00><lambda><3E>+ParserContext.help_tuples.<locals>.<lambda><3E>s<00><><00>$<24>-<2D>-<2D><07>
<01><06><06><0F>8rrz)rq<00>mapr*rDrjr:)
rGs
fr<00>help_tuples<65>ParserContext.help_tuples<65>s4<00><><00>6<14><0F>8<><16>t<EFBFBD>z<EFBFBD>z<EFBFBD>(<28>(<28>*<2A><08>9<>
<0E>
<EFBFBD>	
rc

<00>4<
<01>V^8<>dQ
h
R
S
[S
[
R3,/
#)rr.)rr)rr@s"<22>rrrA<00>s<00><><00>
;<3B>
;<3B>E<EFBFBD>#<23>s<EFBFBD>(<28>O<EFBFBD>
;rc
<0C>v
<00>\
VPP4\R
7p
V
Uu.uF&q P	\VP4
4
NK(	ppVP\VPP44
4
\\PPV4
4
#uupi)z<>
Similar to `help_tuples` but returns flag names only, no helpstrs.

Specifically, all flag names, flattened, in rough order.

.. versionadded:: 1.0
rz)r*rDrjr:rtr#rr3rqrEr|<00>tuple<6C>	itertools<6C>chain<69>
from_iterable)rGrDr+r(s&   r<00>
flag_names<EFBFBD>ParserContext.flag_names<65>s<><00><00><17>t<EFBFBD>z<EFBFBD>z<EFBFBD>(<28>(<28>*<2A><08>9<><05>:?<3F>@<40>%<25>Q<EFBFBD><1E><1E><07>
<01><06><06><0F>0<>%<25><05>@<40>
<0A><0C><0C>T<EFBFBD>$<24>,<2C>,<2C>1<>1<>3<>4<>5<><14>Y<EFBFBD>_<EFBFBD>_<EFBFBD>2<>2<>5<EFBFBD>9<>:<3A>:<3A><>A
s<00>,B6)r>r?rDrErrC)N<>r<>)<11>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__firstlineno__<5F>__doc__rHrOrF<00>propertyrfrkrtr<>r<>r<><00>__static_attributes__<5F>__classdictcell__)
r@s
@rr<r<;s}<00><><00><00>	<08><1E><1E>:9<>9<>/=<3D>/=<3D>b
<0E>
D
<01><0E>
D
<01><0E><13><0E><13>?<3F>?<3F>% <20>% <20>N
 
<EFBFBD> 
<EFBFBD>D

;<3B>
;rr<)r<><00>typingrrrrrrr	<00>vendor.lexiconr
<00>ImportError<6F>lexicon<6F>argumentrrr#r.r:r<r<>rr<00><module>r<>
sS<00>


<01><10>D<>D<>D<>
 <20>(<28>
<1F>

:<3A>
<17>
7<>
<0F>8O
;<3B>O
;<3B><>k
<13>

 <20><1F>

 <20>s<00>A<00>
A<03>
A