Vi]1SrSSKrSSKJr SSKJrJrJrJrJrJ r J r J r J r SSKJ r JrJrJrJrJr \ \"\SS5b \R0r"SS \5rS r"S S \5rSS jr\R=5Vs/sHn\"U\ 5(dMUPM snr!\!VVs/sH6n\""U\#"\!Vs/sHnX\ \4;dM UPM sn55(aM4UPM8 snnr$\#"\%"\$5\%"\&\'\(\\ /5- 5r)Sr*Sr+\"S\+SS9 "SS\5r,SSjr-Sr.Sr/\"S\/SS9 g!\a \rNf=fs snfs snfs snnf)a_By default, glom aims to safely return a transformed copy of your data. But sometimes you really need to transform an existing object. When you already have a large or complex bit of nested data that you are sure you want to modify in-place, glom has you covered, with the :func:`~glom.assign` function, and the :func:`~glom.Assign` specifier type. N)pprint) PathTSSpecglomUnregisteredTarget GlomErrorPathAccessErrorUP)TType register_opTargetRegistrybbreprPathAssignError _assign_op__dict__c\rSrSrSrSrSrg)PathDeleteErroraThis :exc:`GlomError` subtype is raised when an assignment fails, stemming from an :func:`~glom.delete` call or other :class:`~glom.Delete` usage. One example would be deleting an out-of-range position in a list:: >>> delete(["short", "list"], Path(5)) Traceback (most recent call last): ... PathDeleteError: could not delete 5 on object at Path(), got error: IndexError(... Other assignment failures could be due to deleting a read-only ``@property`` or exception being raised inside a ``__delattr__()``. cZSUR<SUR<SUR<3$)Nzcould not delete z on object at z , got error: ) dest_namepathexc)selfs `/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/glom/mutation.py get_messagePathDeleteError.get_message,s>>499dhh8 9N)__name__ __module__ __qualname____firstlineno____doc__r__static_attributes__r!r rrrs 9r rcURR5nU(a3[US- 5Hn[U/5nM UH nU"U5 M gU"U5 g)Nr)path_t __stars__rangesum)funcrvallayersiinners r_apply_for_eachr21sO [[ " " $F vz"Ac2,C#E K S r c.\rSrSrSrSSjrSrSrSrg) Assign<a *New in glom 18.3.0* The ``Assign`` specifier type enables glom to modify the target, performing a "deep-set" to mirror glom's original deep-get use case. ``Assign`` can be used to perform spot modifications of large data structures when making a copy is not desired:: # deep assignment into a nested dictionary >>> target = {'a': {}} >>> spec = Assign('a.b', 'value') >>> _ = glom(target, spec) >>> pprint(target) {'a': {'b': 'value'}} The value to be assigned can also be a :class:`~glom.Spec`, which is useful for copying values around within the data structure:: # copying one nested value to another >>> _ = glom(target, Assign('a.c', Spec('a.b'))) >>> pprint(target) {'a': {'b': 'value', 'c': 'value'}} Another handy use of Assign is to deep-apply a function:: # sort a deep nested list >>> target={'a':{'b':[3,1,2]}} >>> _ = glom(target, Assign('a.b', Spec(('a.b',sorted)))) >>> pprint(target) {'a': {'b': [1, 2, 3]}} Like many other specifier types, ``Assign``'s destination path can be a :data:`~glom.T` expression, for maximum control:: # changing the error message of an exception in an error list >>> err = ValueError('initial message') >>> target = {'errors': [err]} >>> _ = glom(target, Assign(T['errors'][0].args, ('new message',))) >>> str(err) 'new message' ``Assign`` has built-in support for assigning to attributes of objects, keys of mappings (like dicts), and indexes of sequences (like lists). Additional types can be registered through :func:`~glom.register()` using the ``"assign"`` operation name. Attempting to assign to an immutable structure, like a :class:`tuple`, will result in a :class:`~glom.PathAssignError`. Attempting to assign to a path that doesn't exist will raise a :class:`~PathAccessError`. To automatically backfill missing structures, you can pass a callable to the *missing* argument. This callable will be called for each path segment along the assignment which is not present. >>> target = {} >>> assign(target, 'a.b.c', 'hi', missing=dict) {'a': {'b': {'c': 'hi'}}} Nc[U[5(a[R"U5nO>[ U5[ La [U5nO [U[5(d [ S5eUR5SuUlUl Xl USSUl URS;a [S5eX lUb[U5(d[ SU<35eX0lg![a [S5ef=f)N9path argument must be a .-delimited string, Path, T, or S#path must have at least one element[.Pz,last part of path must be setattr or setitemz%expected missing to be callable, not ) isinstance basestringr from_texttyper TypeErroritemsoparg IndexError ValueError _orig_pathrr.callablemissing)rrr.rGs r__init__Assign.__init__{s dJ ' '>>$'D $Z5 :DD$''WX X D $ R 0 DGTX"I 77% KL L  G$$W VWW  DBC C Ds , C&&C<c r^^ ^ ^ ^ [UR5[LaT["XRT5m O URm URUR UR sm m m UR R[5(a$T[nUR R5nOUnUR nT["X4T5nU U U UU 4Sjn[#UT U5 U$![anUR(deURURS-SnT["UR5[UT URS9T5m URR!5URum m URSURm T["UT T5nSnANSnAff=f)NrrGc  >[UTTTTTS9$)N)destrArBr.rscope)r)rMrBrArrNr.s rAssign.glomit..sj"#3THr )r>r.rr rArBr startswithrr from_tr rGrEpart_idxr4r@r2) rtargetrN dest_target dest_pathrMpaeremaining_path_applyrBrArr.s ` @@@@rglomit Assign.glomitsa >T !+fhh6C((C499 C 99   " ")K ((*I K I 9;{u=DHHd+ ! 9<<!__S\\A-=->?N+dllnf^SRVR^R^._afgCoo++-cll;GB??=CLL1D;{D%8D 9sC.. F68B4F11F6c URRnURc"U<SUR<SUR<S3$U<SUR<SUR<S[ UR5<S3$)N(z, )z , missing=) __class__r"rGrEr.rrcns r__repr__Assign.__repr__sS ^^ $ $ << #%tA A+-t&QUQ]Q]J^__r )rErBrGrArr.N) r"r#r$r%r&rHrZrbr'r!r rr4r4<s=|8B`r r4c *[U[XUS95$)a*New in glom 18.3.0* The ``assign()`` function provides convenient "deep set" functionality, modifying nested data structures in-place:: >>> target = {'a': [{'b': 'c'}, {'d': None}]} >>> _ = assign(target, 'a.1.d', 'e') # let's give 'd' a value of 'e' >>> pprint(target) {'a': [{'b': 'c'}, {'d': 'e'}]} Missing structures can also be automatically created with the *missing* parameter. For more information and examples, see the :class:`~glom.Assign` specifier type, which this function wraps. rK)r r4)objrr.rGs rassignrgs VDw7 88r cX [U5'grdint)rTidxr.s r_set_sequence_itemrls3s8r c[U[5(ag[[USS55(a1[[USS55(a[$[ R $[$)NF __setitem__index) issubclass_UNASSIGNABLE_BASE_TYPESrFgetattrrloperatorsetitemsetattrtype_objs r_assign_autodiscoverrxsR(455-677 GHgt4 5 5% % Nr rgF) auto_funcexactc4\rSrSrSrS SjrSrSrSrSr g) Deletea1 In addition to glom's core "deep-get" and ``Assign``'s "deep-set", the ``Delete`` specifier type performs a "deep-del", which can remove items from larger data structures by key, attribute, and index. >>> target = {'dict': {'x': [5, 6, 7]}} >>> glom(target, Delete('dict.x.1')) {'dict': {'x': [5, 7]}} >>> glom(target, Delete('dict.x')) {'dict': {}} If a target path is missing, a :exc:`PathDeleteError` will be raised. To ignore missing targets, use the ``ignore_missing`` flag: >>> glom(target, Delete('does_not_exist', ignore_missing=True)) {'dict': {}} ``Delete`` has built-in support for deleting attributes of objects, keys of dicts, and indexes of sequences (like lists). Additional types can be registered through :func:`~glom.register()` using the ``"delete"`` operation name. .. versionadded:: 20.5.0 c[U[5(a[R"U5nO>[ U5[ La [U5nO [U[5(d [ S5eUR5SuUlUl Xl USSUl URS;a [S5eX lg![a [S5ef=f)Nr7r8r9r:z/last part of path must be an attribute or index)r;r<rr=r>rr?r@rArBrCrDrErignore_missing)rrrs rrHDelete.__init__s dJ ' '>>$'D $Z5 :DD$''WX X D $ R 0 DGTX"I 77% NO O, DBC C Ds , B>>CcUS:XaX gUS:Xa [ X5 gUS:Xa#U[ RSU5nU"X5 gg![a1nUR(d[XPRU5eSnAgSnAff=f![ a1nUR(d[XPRU5eSnAgSnAff=f![a1nUR(d[XPRU5eSnAgSnAff=f)N[.Pdelete) rCrrrdelattrAttributeErrorr get_handler Exception)rrMrArBrNe_deletes r_del_oneDelete._del_ones 9 =I3Y ="3YN+77$GG =" =**)!YY<<+ = " =**)!YY<<+ = =**)!YY<<+ =sEA BC B'A>>B C'B<<C C?'C::C?c^^^^ TRTRTRsm mnTRR[5(a$T[ nTRR 5nOUnTRnT["XET5n[UU UU4SjX65 U$![anTR(deSnAU$SnAff=f)Nc,>TRUTTT5$rd)r)rMrBrArNrs rrODelete.glomit..?stRe)Lr ) rArBrrQrr rRr r2r r) rrTrNrrUrVrMrWrBrAs ` ` @@rrZ Delete.glomit1s499 C 99   " ")K ((*I K I Z;{u=D Ld Y  &&'   sB&& C 0CC cVURRnU<SUR<S3$)Nr]r^)r_r"rEr`s rrbDelete.__repr__Cs ^^ $ $t//r )rErBrrArNF) r"r#r$r%r&rHrrZrbr'r!r rr|r|s4-(=*$0r r|c([U[XS95$)a\ The ``delete()`` function provides "deep del" functionality, modifying nested data structures in-place:: >>> target = {'a': [{'b': 'c'}, {'d': None}]} >>> delete(target, 'a.0.b') {'a': [{}, {'d': None}]} Attempting to delete missing keys, attributes, and indexes will raise a :exc:`PathDeleteError`. To ignore these errors, use the *ignore_missing* argument:: >>> delete(target, 'does_not_exist', ignore_missing=True) {'a': [{}, {'d': None}]} For more information and examples, see the :class:`~glom.Delete` specifier type, which this convenience function wraps. .. versionadded:: 20.5.0 )r)r r|)rfrrs rrrHs* VD@ AAr cU[U5 grdri)rTrks r_del_sequence_itemr`ss3xr c[U[5(ag[[USS55(a1[[USS55(a[$[ R $[$)NF __delitem__ro)rprqrFrrrrsdelitemrrvs r_delete_autodiscoverrdsR(455-677 GHgt4 5 5% % Nr rrdr)0r&rsrcorerrrrr r r r r rrrrrrr< NameErrorstrrr __builtins__rrr2objectr4rgvaluesr;r>_ALL_BUILTIN_TYPESrptuple_BUILTIN_BASE_TYPESsetdictlist BaseExceptionrqrlrxr|rrr)vts00rrs\\\YY  <T*6 ((L9o9*@`V@`F9$".!4!4!6N!6A*Q:Ma!6N"4U"4Q(E>P3R>P674?P6P45>P3R-ST"4U!%8!9#&dM64'P#Q"RS  H 4EBX0VX0vB0 H 4EB{ J~O3RUsAD+=D9D9!E0 D>D>EE+D65D6>E