o i1g@s&ddlZddlTddlmZeeZdZeZ eZ GdddZ GdddZ Gd d d e Z Gd d d e ZGd dde ZGddde ZGddde ZGddde ZGddde ZGddde ZGddde ZGddde ZGddde ZGdd d e Zd!d"Zd#d$ZdS)%N)*) JsonPathLexerc@HeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)JSONPathz The base class for JSONPath abstract syntax; those methods stubbed here are the interface to supported JSONPath semantics. cCt)a All `JSONPath` types support `find()`, which returns an iterable of `DatumInContext`s. They keep track of the path followed to the current location, so if the calling code has some opinion about that, it can be passed in here as a starting point. NotImplementedErrorselfdatar W/home/ubuntu/.local/lib/python3.10/site-packages/ddtrace/vendor/jsonpath_ng/jsonpath.pyfindz JSONPath.findcCs ||SN)rr r r rfind_or_create zJSONPath.find_or_createcCr)z~ Returns `data` with the specified path replaced by `val`. Only updates if the specified path exists. rr r valr r rupdate"rzJSONPath.updatecCs |||Sr)rrr r rupdate_or_create* zJSONPath.update_or_createcCr)aM Returns `data` with the specified path filtering nodes according the filter evaluation result returned by the filter function. Arguments: fn (function): unary function that accepts one argument and returns bool. data (dict|list|tuple): JSON object to filter. rr fnr r r rfilter-s zJSONPath.filtercCs>t|ts t|tr |St|tr|St|tr|St||S)zP Equivalent to Child(self, next) but with some canonicalization ) isinstanceThisRootChild)r childr r rr :s   zJSONPath.childcCst|tr|St|tddSNpathcontext)rDatumInContextr)r valuer r r make_datumGs zJSONPath.make_datumN) __name__ __module__ __qualname____doc__rrrrrr r'r r r rrs rc@sVeZdZdZeddZdddZddZed d Z ed d Z d dZ ddZ dS)r%a Represents a datum along a path from a context. Essentially a zipper but with a structure represented by JsonPath, and where the context is more of a parent pointer than a proper representation of the context. For quick-and-dirty work, this proxies any non-special attributes to the underlying datum, but the actual datum can (and usually should) be retrieved via the `value` attribute. To place `datum` within another, use `datum.in_context(context=..., path=...)` which extends the path. If the datum already has a context, it places the entire context within that passed in, so an object can be built from the inside out. cCst||r|S||Sr)r)clsr r r rwrap_s zDatumInContext.wrapNcCs4||_|pt|_|durd|_dSt||_dSr)r&rr#r%r-r$)r r&r#r$r r r__init__fs "zDatumInContext.__init__cCs<t|}|jrt|j|j|j||ddSt|j||dS)Nr")r&r#r$)r%r-r$r&r# in_contextr r$r#r r rr/ks zDatumInContext.in_contextcCs |jdur|jS|jj|jSr)r$r# full_pathr r r r rr1ss zDatumInContext.full_pathc CsNz tt|jt}Wntttfy|j}Ynw|jr%|jj |S|S)zI Looks like a path, but with ids stuck in when available ) Fieldsstrr& auto_id_field TypeErrorAttributeErrorKeyErrorr#r$ id_pseudopathr )r pseudopathr r rr9ws zDatumInContext.id_pseudopathcCd|jj|j|j|jfS)Nz!%s(value=%r, path=%r, context=%r)) __class__r(r&r#r$r2r r r__repr__zDatumInContext.__repr__cCs.t|to|j|jko|j|jko|j|jkSr)rr%r&r#r$r otherr r r__eq__.zDatumInContext.__eq__)NN) r(r)r*r+ classmethodr-r.r/propertyr1r9r=rAr r r rr%Ns     r%c@sVeZdZdZdddZeddZeddZed d Zd d Z d dZ ddZ dS)AutoIdForDatuma This behaves like a DatumInContext, but the value is always the path leading up to it, not including the "id", and with any "id" fields along the way replacing the prior segment of the path For example, it will make "foo.bar.id" return a datum that behaves like DatumInContext(value="foo.bar", path="foo.bar.id"). This is disabled by default; it can be turned on by settings the `auto_id_field` global to a value other than `None`. NcCs||_|pt|_dS)aW Invariant is that datum.path is the path from context to datum. The auto id will either be the id in the datum (if present) or the id of the context followed by the path to the datum. The path to this datum is always the path to the context, the path to the datum, and then the auto id field. N)datumr5id_field)r rFrGr r rr.s zAutoIdForDatum.__init__cCs t|jjSr)r4rFr9r2r r rr&s zAutoIdForDatum.valuecC|jSr)rGr2r r rr#zAutoIdForDatum.pathcCrHrrFr2r r rr$rIzAutoIdForDatum.contextcCd|jj|jfS)Nz%s(%r))r<r(rFr2r r rr=zAutoIdForDatum.__repr__cCst|jj||dS)Nr$r#)rErFr/r0r r rr/zAutoIdForDatum.in_contextcCs"t|to|j|jko|j|jkSr)rrErFrGr?r r rrA"zAutoIdForDatum.__eq__r) r(r)r*r+r.rDr&r#r$r=r/rAr r r rrEs     rEc@r)rz The JSONPath referring to the "root" object. Concrete syntax is '$'. The root is the topmost datum without any context attached. cCsHt|tst|tddgS|jdurt|jdtdgSt|jS)Nr"rM)rr%rr$r&rr r r rrs  z Root.findcC|Srr rr r rrz Root.updatecC||r|SdSrr rr r rrz Root.filtercCdSN$r r2r r r__str__rQz Root.__str__cCrT)NzRoot()r r2r r rr=rQz Root.__repr__cC t|tSr)rrr?r r rrArz Root.__eq__cCtdSrUhashr2r r r__hash__z Root.__hash__N r(r)r*r+rrrrWr=rAr\r r r rrs  rc@r)rzN The JSONPath referring to the current datum. Concrete syntax is '@'. cCs t|gSr)r%r-r rFr r rrrz This.findcCrPrr rr r rrrQz This.updatecCrRrr rr r rrrSz This.filtercCrT)Nz`this`r r2r r rrWrQz This.__str__cCrT)NzThis()r r2r r rr=rQz This.__repr__cCrXr)rrr?r r rrArz This.__eq__cCrY)NthisrZr2r r rr\r]z This.__hash__Nr^r r r rrs rc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS)rzi JSONPath that first matches the left, then the right. Concrete syntax is '.' cC||_||_dSrleftrightr rcrdr r rr. zChild.__init__cfddj|DS)z Extra special case: auto ids do not have children, so cut it off right now rather than auto id the auto id cs,g|]}t|tsj|D]}|qqSr )rrErdr).0subdatasubmatchr2r r s  zChild.find..rcrr_r r2rrs  z Child.findcCs&|j|D] }|j|j|q|Sr)rcrrdrr&r r rrFr r rrz Child.updatecCsLt|}g}|j|D]}t|trq |j|D]}||qq |Sr)r%r-rcrrrErdappend)r rF submatchesrirjr r rrs   zChild.find_or_createcCs*|j|D] }|j|j|qt|Sr)rcrrdrr&_clean_list_keysrmr r rr!szChild.update_or_createcCs&|j|D] }|j||jq|Sr)rcrrdrr&r rr rFr r rr&rnz Child.filtercC"t|to|j|jko|j|jkSr)rrrcrdr?r r rrA+rOz Child.__eq__cCd|j|jfS)Nz%s.%srbr2r r rrW.rSz Child.__str__cCd|jj|j|jfSNz %s(%r, %r)r<r(rcrdr2r r rr=1zChild.__repr__cCt|j|jfSrr[rcrdr2r r rr\4rSzChild.__hash__N)r(r)r*r+r.rrrrrrArWr=r\r r r rrs   rc@8eZdZdZddZddZddZdd Zd d Zd S) Parentz JSONPath that matches the parent node of the current match. Will crash if no such parent exists. Available via named operator `parent`. cCst|}|jgSr)r%r-r$r_r r rr?s z Parent.findcCrXr)rr|r?r r rrACrz Parent.__eq__cCrT)Nz`parent`r r2r r rrWFrQzParent.__str__cCrT)NzParent()r r2r r rr=IrQzParent.__repr__cCrY)NparentrZr2r r rr\Lr]zParent.__hash__N) r(r)r*r+rrArWr=r\r r r rr|8s r|c@r)Wherez JSONPath that first matches the left, and then filters for only those nodes that have a match on the right. WARNING: Subject to change. May want to have "contains" or some other better word for it. cCrarrbrer r rr.ZrfzWhere.__init__crg)Ncsg|] }j|r|qSr )rdr)rhrir2r rrk_szWhere.find..rlr r r2rr^r>z Where.findcC"||D] }|j||q|Srrr#rrmr r rraz Where.updatecCs$||D] }|j||jq|Sr)rr#rr&rrr r rrfsz Where.filtercCrt)Nz %s where %srbr2r r rrWkrSz Where.__str__cCs"t|to|j|jko|j|jkSr)rr~rcrdr?r r rrAnrOz Where.__eq__cCryrrzr2r r rr\qrSzWhere.__hash__N) r(r)r*r+r.rrrrWrAr\r r r rr~Ps  r~c@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS) Descendantsz{ JSONPath that matches first the left expression then any descendant of it which matches the right expression. cCrarrbrer r rr.zrfzDescendants.__init__cs<j|}t|ts|g}fddfdd|DS)Ncsrj}tjtrfddtdtjD}ntjtr1fddjD}ng}|t|S)Nc2g|]}tj|t|dD]}|qqSrMr%r&Index)rhirjrFmatch_recursivelyr rrk  z?Descendants.find..match_recursively..rcrr)r%r&r3)rhfieldrjrr rrkr) rdrrr&listrangelendictkeys)rF right_matchesrecursive_matchesrr rJrrs      z+Descendants.find..match_recursivelycsg|] }|D]}|qqSr r )rh left_matchrj)rr rrks  z$Descendants.find..)rcrrr)r rF left_matchesr rrr~s   zDescendants.findcCrTNFr r2r r r is_singularrQzDescendants.is_singularcsDj|}t|ts|g}fdd|D]}|jq|S)Ncst|ts t|ts dSj|t|tr*tdt|D]}||qdSt|tr<|D] }||q3dSdSNr)rrrrdrrrrr rrr update_recursivelyrr rr   z.Descendants.update..update_recursivelyrcrrrr&)r r rrrjr rrr   zDescendants.updatecsDj|}t|ts|g}fdd|D]}|jq|S)Ncst|ts t|ts dSj|t|tr*tdt|D]}||qdSt|tr<|D] }||q3dSdSr)rrrrdrrrrrfilter_recursivelyrr r rrrz.Descendants.filter..filter_recursivelyr)r rr rrjr rrrrzDescendants.filtercCrt)Nz%s..%srbr2r r rrWrSzDescendants.__str__cCrsr)rrrcrdr?r r rrArOzDescendants.__eq__cCrurvrwr2r r rr=rxzDescendants.__repr__cCryrrzr2r r rr\rSzDescendants.__hash__N) r(r)r*r+r.rrrrrWrAr=r\r r r rrts$ rc@r{) Unionas JSONPath that returns the union of the results of each match. This is pretty shoddily implemented for now. The nicest semantics in case of mismatched bits (list vs atomic) is to put them all in a list, but I haven't done that yet. WARNING: Any appearance of this being the _concatenation_ is coincidence. It may even be a bug! (or laziness) cCrarrbrer r rr.rfzUnion.__init__cCrTrr r2r r rrrQzUnion.is_singularcCs|j||j|Sr)rcrrdr r r rrsz Union.findcCrsr)rrrcrdr?r r rrArOz Union.__eq__cCryrrzr2r r rr\rSzUnion.__hash__N r(r)r*r+r.rrrAr\r r r rrs  rc@r{) IntersectaL JSONPath for bits that match *both* patterns. This can be accomplished a couple of ways. The most efficient is to actually build the intersected AST as in building a state machine for matching the intersection of regular languages. The next idea is to build a filtered data and match against that. cCrarrbrer r rr. rfzIntersect.__init__cCrTrr r2r r rrrQzIntersect.is_singularcCrrrr r r rrszIntersect.findcCrsr)rrrcrdr?r r rrArOzIntersect.__eq__cCryrrzr2r r rr\rSzIntersect.__hash__Nrr r r rrs  rc@seZdZdZddZeddZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZddZddZddZddZdS)r3z JSONPath referring to some field of the current object. Concrete syntax ix comma-separated field names. WARNING: If '*' is any of the field names, then they will all be returned. cG ||_dSr)fields)r rr r rr.'rzFields.__init__c Csn|tkrt|Sz"|j|t}|tur!|ri|j|<}nWdSt|t||dWSttfy6YdSwr!) r5rEr&getNOT_SETr%r3r6r7)rFrcreate field_valuer r rget_field_datum*szFields.get_field_datumcCsNd|jvr|jSzt|j}tdur|WS|tfWSty&YdSw)Nrr )rtupler&rr5r7)r rFrr r rreified_fields9s  zFields.reified_fieldscC|j|ddSNFr _find_baser_r r rrCz Fields.findcCrNTrrr_r r rrFrzFields.find_or_createcs4tfddD}dd|DS)Ncsg|] }|qSr )r)rhrrrFr r rrkKsz%Fields._find_base..cSsg|]}|dur|qSrr )rhfdr r rrkMs)r%r-r)r rFr field_datar rrrIs zFields._find_basecC|j||ddSr _update_baserr r rrOrSz Fields.updatecCrrrrr r rrRrSzFields.update_or_createcCsr|dur7|t|D]*}|r||vri||<t|tur6||vr6t|dr2|||||||<q |||<q |SN__call__)rr%r-typeboolhasattr)r r rrrr r rrUs  zFields._update_basecCs@|dur|t|D]}||vr|||r||q |Sr)rr%r-pop)r rr rr r rras  z Fields.filtercCsdd|jD}d|S)Nc3s@|]tfddtjDrdtdntVqdS)csg|]}|vqSr r )rhlfr rrknsz,Fields.__str__...'N)anyrliteralsr4)rhr rr ns ( z!Fields.__str__..,)rjoin)r fields_as_strr r rrWis zFields.__str__cCsd|jjdtt|jfS)Nz%s(%s)r)r<r(rmapreprrr2r r rr=szFields.__repr__cCst|tot|jt|jkSr)rr3rrr?r r rrAvrz Fields.__eq__cCstt|jSr)r[rrr2r r rr\yrzFields.__hash__N)r(r)r*r+r. staticmethodrrrrrrrrrrWr=rAr\r r r rr3s"     r3c@sxeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZdS)raQ JSONPath that matches indices of the current datum, or none if not large enough. Concrete syntax is brackets. WARNING: If the datum is None or not long enough, it will not crash but will not match anything. NOTE: For the concrete syntax of `[*]`, the abstract syntax is a Slice() with no parameters (equiv to `[:]` cCrrindex)r rr r rr.rzIndex.__init__cCrrrr_r r rrrz Index.findcCrrrr_r r rrrzIndex.find_or_createcCsbt|}|r|jikrt|j|_||j|jr/t|j|jkr/t|j|j||dgSgSr!)r%r-r&_create_list_key _pad_valuerr)r rFrr r rrs    zIndex._find_basecCrrrrr r rrrSz Index.updatecCrrrrr r rrrSzIndex.update_or_createcCsd|r|ikr t|}||t|dr$|||j||j||j<|St||jkr0|||j<|Sr)rrrrrr)r r rrr r rrs   zIndex._update_basecCs|||jr ||j|Sr)rrrr r rrs z Index.filtercCst|to |j|jkSr)rrrr?r r rrArxz Index.__eq__cCs d|jS)Nz[%i]rr2r r rrWrz Index.__str__cCrK)Nz %s(index=%r))r<r(rr2r r rr=rLzIndex.__repr__cCs>t||jkr|jt|d}|ddt|D7}dSdS)NrcSsg|]}iqSr r )rh__r r rrksz$Index._pad_value..)rrr)r r&padr r rrszIndex._pad_valuecCs t|jSr)r[rr2r r rr\rzIndex.__hash__N)r(r)r*r+r.rrrrrrrrArWr=rr\r r r rr}s   rc@sReZdZdZdddZddZddZd d Zd d Zd dZ ddZ ddZ dS)Slicea JSONPath matching a slice of an array. Because of a mismatch between JSON and XML when schema-unaware, this always returns an iterable; if the incoming data was not a list, then it returns a one element list _containing_ that data. Consider these two docs, and their schema-unaware translation to JSON: hello ==> {"a": {"b": "hello"}} hellogoodbye ==> {"a": {"b": ["hello", "goodbye"]}} If there were a schema, it would be known that "b" should always be an array (unless the schema were wonky, but that is too much to fix here) so when querying with JSON if the one writing the JSON knows that it should be an array, they can write a slice operator and it will coerce a non-array value to an array. This may be a bit unfortunate because it would be nice to always have an iterator, but dictionaries and other objects may also be iterable, so this is the compromise. NcCs||_||_||_dSrstartendstep)r rrrr r rr.s zSlice.__init__cstjs gStjtstjtstjtr*|tjgjj dS|j durH|j durH|j durHfddt dtjDSfddt dtj|j |j |j DS)Nr"c$g|]}tj|t|dqSr"rrhrrJr rrk$zSlice.find..rcrrrrrJr rrkr)r%r-r&rrintr4rr#r$rrrrrr_r rJrrs $.z Slice.findcCrrrrmr r rrrz Slice.updatecCsL t|}||D]}|j||}t||krnq |t|kr% |Sqr)rrr#r)r rr lengthrFr r rrs  z Slice.filtercCsZ|jdur|jdur|jdurdSd|jpd|jrd|jnd|jr)d|jfSdfS)Nz[*]z[%s%s%s]z:%drr2r r rrWs z Slice.__str__cCr;)Nz%s(start=%r,end=%r,step=%r))r<r(rrrr2r r rr= r>zSlice.__repr__cCs.t|to|j|jko|j|jko|j|jkSr)rrrrrr?r r rrA rBz Slice.__eq__cCst|j|j|jfSr)r[rrrr2r r rr\rNzSlice.__hash__)NNN) r(r)r*r+r.rrrrWr=rAr\r r r rrs   rcCsig|t<}|S)zf Adds a list to a dictionary by reference and returns the list. See `_clean_list_keys()` )LIST_KEY)dict_new_listr r rrsrcCslt|trt|D] \}}t|||<q |St|tr4t|vr%t|tS|D] \}}t|||<q)|S)z Replace {LIST_KEY: ['foo', 'bar']} with ['foo', 'bar']. >>> _clean_list_keys({LIST_KEY: ['foo', 'bar']}) ['foo', 'bar'] )rr enumeraterqrritems)struct_indr&keyr r rrqs   rq)logging itertoolslexerr getLoggerr(loggerr5objectrrrr%rErrrr|r~rrrr3rrrrqr r r rs.  >?1"=$t_ER