o hEA@sdZddlmZddlmZmZmZddlZddlm Z ddl m Z m Z ddl mZmZddlmZmZmZmZmZmZmZmZmZd Zed ed Zed ed Zed ZedZd+ddZd,ddZ GdddeeefZ!ed-dd Z"ed.d$d Z"ed/d'd Z"d(d Z"d/d)d*Z#dS)0a Cycler ====== Cycling through combinations of values, producing dictionaries. You can add cyclers:: from cycler import cycler cc = (cycler(color=list('rgb')) + cycler(linestyle=['-', '--', '-.'])) for d in cc: print(d) Results in:: {'color': 'r', 'linestyle': '-'} {'color': 'g', 'linestyle': '--'} {'color': 'b', 'linestyle': '-.'} You can multiply cyclers:: from cycler import cycler cc = (cycler(color=list('rgb')) * cycler(linestyle=['-', '--', '-.'])) for d in cc: print(d) Results in:: {'color': 'r', 'linestyle': '-'} {'color': 'r', 'linestyle': '--'} {'color': 'r', 'linestyle': '-.'} {'color': 'g', 'linestyle': '-'} {'color': 'g', 'linestyle': '--'} {'color': 'g', 'linestyle': '-.'} {'color': 'b', 'linestyle': '-'} {'color': 'b', 'linestyle': '--'} {'color': 'b', 'linestyle': '-.'} ) annotations)HashableIterable GeneratorN)reduce)productcycle)muladd) TypeVarGenericCallableUnionDictListAnyoverloadcastz0.12.1K)boundLVUleft#Cycler[K, V] | Iterable[dict[K, V]]right*Cycler[K, V] | Iterable[dict[K, V]] | Nonereturnset[K]cCs`|gkr tt|ni}|durtt|ni}t|}t|}||@r,td||BS)a Helper function to compose cycler keys. Parameters ---------- left, right : iterable of dictionaries or None The cyclers to be composed. Returns ------- keys : set The keys in the composition of the two cyclers. Nz"Can not compose overlapping cycles)nextitersetkeys ValueError)rrl_peekr_peekl_keyr_keyr(c/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/cycler/__init__.py _process_keys>s  r* Cycler[K, V] Cycler[K, U]Cycler[K, V | U]cs|j|jkrtdj|j|j@|j|jAdttttttt ff| ttttttt ff| t t fdd|jDS)aS Concatenate `Cycler`\s, as if chained using `itertools.chain`. The keys must match exactly. Examples -------- >>> num = cycler('a', range(3)) >>> let = cycler('a', 'abc') >>> num.concat(let) cycler('a', [0, 1, 2, 'a', 'b', 'c']) Returns ------- `Cycler` The concatenated cycler. zBKeys do not match: Intersection: {both!r} Disjoint: {just_one!r})bothjust_onec3s&|]}t|||VqdSN_cycler.0k_l_rr(r) ts$zconcat..) r"r#formatrrrrrrrby_keyrr )rrr(r6r)concatXs ""r<c@seZdZdZddZ  dIdJd d Zd dZedKddZdLddZ e dMddZ dNd!d"Z dOd$d%Z dPd)d*ZedPd+d,ZedQd.d,Zd/d,ZedPd0d1ZedQd2d1Zd3d1ZdRd4d5ZdSd6d7ZdTd9d:ZdUd=d>ZdZdVd@dAZdVdBdCZdWdEdFZeZdXdGdHZeZdS)YCyclera Composable cycles. This class has compositions methods: ``+`` for 'inner' products (zip) ``+=`` in-place ``+`` ``*`` for outer products (`itertools.product`) and integer multiplication ``*=`` in-place ``*`` and supports basic slicing via ``[]``. Parameters ---------- left, right : Cycler or None The 'left' and 'right' cyclers. op : func or None Function which composes the 'left' and 'right' cyclers. cCst|Sr0)rselfr(r(r)__call__zCycler.__call__NrrrCycler[K, V] | NoneoprcCst|trt|j|j|j|_n|durdd|D|_ng|_t|tr0t|j|j|j|_nd|_t|j|j|_||_dS)zf Semi-private init. Do not use this directly, use `cycler` function instead. NcSsg|]}t|qSr()copyr4vr(r(r) sz#Cycler.__init__..) isinstancer=_left_right_opr*_keys)r?rrrCr(r(r)__init__s     zCycler.__init__cCs ||jvSr0)rL)r?r5r(r(r) __contains__s zCycler.__contains__rrcCs t|jS)z!The keys this Cycler knows about.)r!rLr>r(r(r)r"s z Cycler.keysoldrnewNonecskrdS|jvrtdddd|jvr,tdddd|j|j|jdurL|jjvrL|jdSt|j t r[|j dSfdd|j D|_ dS) a Change a key in this cycler to a new name. Modification is performed in-place. Does nothing if the old key is the same as the new key. Raises a ValueError if the new key is already a key. Raises a KeyError if the old key isn't a key. NzCan't replace z with , z is already a keyz is not a keycsg|]}|iqSr(r()r4entryrPrOr(r)rGsz%Cycler.change_key..) rLr#KeyErrorremover rJr" change_keyrHrIr=)r?rOrPr(rTr)rWs"      zCycler.change_keylabelitr Iterable[V]r+cs,|d}tfdd|D|_h|_|S)a Class method to create 'base' Cycler objects that do not have a 'right' or 'op' and for which the 'left' object is not another Cycler. Parameters ---------- label : hashable The property key. itr : iterable Finite length iterable of the property values. Returns ------- `Cycler` New 'base' cycler. Nc3s|]}|iVqdSr0r(rErXr(r)r9z$Cycler._from_iter..)listrIrL)clsrXrYretr(r[r) _from_iterszCycler._from_iterkeyslicecs6ttr|}ttfdd|DStd)Nc3s"|] \}}t||VqdSr0r1r4r5rFrar(r)r9 z%Cycler.__getitem__..z+Can only use slices with Cycler.__getitem__)rHrbr;rr itemsr#)r?ratransr(rdr) __getitem__s zCycler.__getitem__!Generator[dict[K, V], None, None]ccst|jdur|jD]}t|Vq dS|jdurtd||j|jD]\}}i}|||||Vq$dS)Nz=Operation cannot be None when both left and right are defined)rJrIdictrK TypeErrorupdate)r?raboutr(r(r)__iter__s      zCycler.__iter__other Cycler[L, U]Cycler[K | L, V | U]cCstt|t|krtdt|dt|ttttttftttff|tttttftttff|t S)z Pair-wise combine two equal length cyclers (zip). Parameters ---------- other : Cycler z&Can only add equal length cycles, not z and ) lenr#r=rrrrrrzipr?rqr(r(r)__add__s  zCycler.__add__cCdSr0r(rvr(r(r)__mul__$zCycler.__mul__intcCrxr0r(rvr(r(r)ry(rzcsttr)ttttttftttff|tttttftttfftStt r@| }t t fdd| DStS)z Outer product of two cyclers (`itertools.product`) or integer multiplication. Parameters ---------- other : Cycler or int c3s"|] \}}t||VqdSr0r1rcrqr(r)r9>rez!Cycler.__mul__..)rHr=rrrrrrrr{r;rr rfNotImplemented)r?rqrgr(r|r)ry,s    cCrxr0r(rvr(r(r)__rmul__CrzzCycler.__rmul__cCrxr0r(rvr(r(r)r~GrzcCs||Sr0r(rvr(r(r)r~KrAcCsDtttti}|jdurt|jSt|j}t|j}||j||Sr0)ruminrr rJrtrIrK)r?op_dictl_lenr_lenr(r(r)__len__Ns     zCycler.__len__cCLt|ts tdt|}t|||_||_t|_t|j|j |j|_ |S)z In-place pair-wise combine two equal length cyclers (zip). Parameters ---------- other : Cycler z"Cannot += with a non-Cycler object) rHr=rkrDr*rLrIrurKrJr?rqold_selfr(r(r)__iadd__X   zCycler.__iadd__Cycler[K, V] | intcCr)z In-place outer product of two cyclers (`itertools.product`). Parameters ---------- other : Cycler z"Cannot *= with a non-Cycler object) rHr=rkrDr*rLrIrrKrJrr(r(r)__imul__jrzCycler.__imul__objectboolcCsJt|tsdSt|t|krdS|j|jArdStddt||DS)NFcss|] \}}||kVqdSr0r()r4rmrnr(r(r)r9sz Cycler.__eq__..)rHr=rtr"allrurvr(r(r)__eq__|s  z Cycler.__eq__strcsntdtdi}|jdur$|jtfdd|D}dd|dS||jd}d }|j|j ||jd S) N+*c3|]}|VqdSr0r(rElabr(r)r9r\z"Cycler.__repr__..zcycler(rR)?z({left!r} {op} {right!r}))rrCr) rurrJr"popr]getrKr:rI)r?op_maprYrCmsgr(rr)__repr__s   zCycler.__repr__cCstd}t|jtd}|D] }|d|d7}q t|D]}|d7}|D] }|d||d7}q"|d7}q|d 7}|S) Nzrdzzzzz
z
z
)sortedr"reprr )r?output sorted_keysradr5r(r(r) _repr_html_s  zCycler._repr_html_dict[K, list[V]]cCs>|j}dd|D}|D]}|D] }||||qq |S)a Values by key. This returns the transposed values of the cycler. Iterating over a `Cycler` yields dicts with a single value for each key, this method returns a `dict` of `list` which are the values for the given key. The returned value can be used to create an equivalent `Cycler` using only `+`. Returns ------- transpose : dict dict of lists of the values for each key. cSsi|]}|tqSr()r]r3r(r(r) sz!Cycler.by_key..)r"append)r?r"rorr5r(r(r)r;sz Cycler.by_keycCs |}ttdd|DS)z Simplify the cycler into a sum (but no products) of cyclers. Returns ------- simple : Cycler cs|] \}}t||VqdSr0r1rcr(r(r)r9z"Cycler.simplify..)r;rr rf)r?rgr(r(r)simplifys zCycler.simplify)NN)rrrrBrCr)rr)rOrrPrrrQrXrrYrZrr+)rarbrr+)rri)rqrrrrs)rqr{rr+)rr{)rqr+rr+)rqrrr+)rqrrr)rr)rr)rr+)__name__ __module__ __qualname____doc__r@rMrNpropertyr"rW classmethodr`rhrprwrryr~rrrr__hash__rrr; _transposerr<r(r(r(r)r=wsH    $              r=argcCrxr0r()rr(r(r)cyclerrzrkwargsrZCycler[str, V]cKrxr0r()rr(r(r)rrzrXrYcCrxr0r()rXrYr(r(r)rrzcOs|r|rtdt|dkrt|dtstdt|dSt|dkr)t|St|dkr3td|rAttdd|DStd ) a Create a new `Cycler` object from a single positional argument, a pair of positional arguments, or the combination of keyword arguments. cycler(arg) cycler(label1=itr1[, label2=iter2[, ...]]) cycler(label, itr) Form 1 simply copies a given `Cycler` object. Form 2 composes a `Cycler` as an inner product of the pairs of keyword arguments. In other words, all of the iterables are cycled simultaneously, as if through zip(). Form 3 creates a `Cycler` from a label and an iterable. This is useful for when the label cannot be a keyword argument (e.g., an integer or a name that has a space in it). Parameters ---------- arg : Cycler Copy constructor for Cycler (does a shallow copy of iterables). label : name The property key. In the 2-arg form of the function, the label can be any hashable object. In the keyword argument form of the function, it must be a valid python identifier. itr : iterable Finite length iterable of the property values. Can be a single-property `Cycler` that would be like a key change, but as a shallow copy. Returns ------- cycler : Cycler New `Cycler` for the given property zEcycler() can only accept positional OR keyword arguments -- not both.rzDIf only one positional argument given, it must be a Cycler instance.zdOnly a single Cycler can be accepted as the lone positional argument. Use keyword arguments instead.csrr0r1rcr(r(r)r9rzcycler..z4Must have at least a positional OR keyword arguments)rkrtrHr=r2rr rf)argsrr(r(r)rs&&    csNt|tr!|j}t|dkrd}t||fdd|D}t||S)aD Create a new `Cycler` object from a property name and iterable of values. Parameters ---------- label : hashable The property key. itr : iterable Finite length iterable of the property values. Returns ------- cycler : Cycler New `Cycler` for the given property rz2Can not create Cycler from a multi-property Cyclerc3rr0r(rErr(r)r9;r\z_cycler..)rHr=r"rtr#rr`)rXrYr"rr(rr)r2"s   r2)rrrrrr)rr+rr,rr-)rr+rr+)rrZrrr)$r __future__rcollections.abcrrrrD functoolsr itertoolsrroperatorr r typingr r r rrrrrr __version__rrrrr*r<r=rr2r(r(r(r)s4 + ,    ^   @