Vi tSrSSKrSSKrSSKJr SSKJr SSKJr SSKJ r J r J r J r J r JrJrJrJrJr \"S5r"S S \ 5r"S S \\5r"S S\5r\"\SS5r\"\S\R8\R:45r\"SSRA\!"S\555-5r"Sr#\R:"SS5 \#\$"S54- r#\R:"SS5 \#\$"S54- r#"SS\5r&Sr'"SS\5r("SS\(5r)"SS\(5r*"SS \(5r+S!S"S#S$S%.r,"S&S'\5r-"S(S)\5r."S*S+\5r/\/"5r0"S,S-\5r1"S.S/\5r2S0r3S1r4S2r5"S3S4\5r6\"S55r7"S6S7\5r8"S8S9\ 5r9g!\%a Nf=f!\%a Nf=f):a .. versionadded:: 20.7.0 Sometimes you want to confirm that your target data matches your code's assumptions. With glom, you don't need a separate validation step, you can do these checks inline with your glom spec, using :class:`~glom.Match` and friends. N)pprint) is_iterable) make_sentinel) GlomErrorglomTMODEbbreprbbformatformat_invocationPath chain_childVal_MISSINGc2^\rSrSrSrU4SjrSrSrU=r$) MatchErrorz Raised when a :class:`Match` or :data:`M` check fails. >>> glom({123: 'a'}, Match({'id': int})) Traceback (most recent call last): ... MatchError: key 123 didn't match any of ['id'] c0>[[U] "U/UQ76 gN)superr__init__)selffmtargs __class__s `/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/glom/matching.pyrMatchError.__init__%s j$(4t4cTURSURSSp![U/UQ76$)Nrr)rr )rrrs r get_messageMatchError.get_message(s+IIaL$))AB-T#d##r) __name__ __module__ __qualname____firstlineno____doc__rr!__static_attributes__ __classcell__rs@rrrs5$$rrc2^\rSrSrSrU4SjrSrSrU=r$)TypeMatchError-a:exc:`MatchError` subtype raised when a :class:`Match` fails a type check. >>> glom({'id': 'a'}, Match({'id': int})) Traceback (most recent call last): ... TypeMatchError: error raised while processing. Target-spec trace, with error detail (most recent last): - Target: {'id': 'a'} - Spec: Match({'id': }) - Spec: {'id': } - Target: 'a' - Spec: int TypeMatchError: expected type int, not str c.>[[U] SX!5 g)Nz,expected type {0.__name__}, not {1.__name__})rr-r)ractualexpectedrs rrTypeMatchError.__init__>s nd, :H NrcN[URSURS5$)Nr)r-rrs r__copy__TypeMatchError.__copy__Bs!diilDIIaL99rr#) r$r%r&r'r(rr6r)r*r+s@rr-r--s N::rr-c<\rSrSrSr\4SjrSrSrSr Sr Sr g ) MatchHaf glom's ``Match`` specifier type enables a new mode of glom usage: pattern matching. In particular, this mode has been designed for nested data validation. Pattern specs are evaluated as follows: 1. Spec instances are always evaluated first 2. Types match instances of that type 3. Instances of :class:`dict`, :class:`list`, :class:`tuple`, :class:`set`, and :class:`frozenset` are matched recursively 4. Any other values are compared for equality to the target with ``==`` By itself, this allows to assert that structures match certain patterns, and may be especially familiar to users of the `schema`_ library. For example, let's load some data:: >>> target = [ ... {'id': 1, 'email': 'alice@example.com'}, ... {'id': 2, 'email': 'bob@example.com'}] A :class:`Match` pattern can be used to ensure this data is in its expected form: >>> spec = Match([{'id': int, 'email': str}]) This ``spec`` succinctly describes our data structure's pattern Specifically, a :class:`list` of :class:`dict` objects, each of which has exactly two keys, ``'id'`` and ``'email'``, whose values are an :class:`int` and :class:`str`, respectively. Now, :func:`~glom.glom` will ensure our ``target`` matches our pattern ``spec``: >>> result = glom(target, spec) >>> assert result == \ ... [{'id': 1, 'email': 'alice@example.com'}, {'id': 2, 'email': 'bob@example.com'}] With a more complex :class:`Match` spec, we can be more precise: >>> spec = Match([{'id': And(M > 0, int), 'email': Regex('[^@]+@[^@]+')}]) :class:`~glom.And` allows multiple conditions to be applied. :class:`~glom.Regex` evaluates the regular expression against the target value under the ``'email'`` key. In this case, we take a simple approach: an email has exactly one ``@``, with at least one character before and after. Finally, :attr:`~glom.M` is our stand-in for the current target we're matching against, allowing us to perform in-line comparisons using Python's native greater-than operator (as well as others). We apply our :class:`Match` pattern as before:: >>> assert glom(target, spec) == \ ... [{'id': 1, 'email': 'alice@example.com'}, {'id': 2, 'email': 'bob@example.com'}] And as usual, upon a successful match, we get the matched result. .. note:: For Python 3.6+ where dictionaries are ordered, keys in the target are matched against keys in the spec in their insertion order. .. _schema: https://github.com/keleshev/schema Args: spec: The glomspec representing the pattern to match data against. default: The default value to be returned if a match fails. If not set, a match failure will raise a :class:`MatchError`. cXlX lgr)specdefault)rr<r=s rrMatch.__init__s   rc[U['U["XRU5nU$![a$ UR [ LaeUR nU$f=fr) _glom_matchr rr<rr=r)rtargetscoperets rglomit Match.glomitsY!d  +fii7C   ||x',,C  s+*AAc[X5$)zA convenience function a :class:`Match` instance which returns the matched value when *target* matches, or raises a :exc:`MatchError` when it does not. Args: target: Target value or data structure to match against. Raises: glom.MatchError )rrrAs rverify Match.verifysF!!rc<[X5 g![a gf=f)zA convenience method on a :class:`Match` instance, returns ``True`` if the *target* matches, ``False`` if not. >>> Match(int).matches(-1.0) False Args: target: Target value or data structure to match against. FT)rrrGs rmatches Match.matchess(     s  cdURR<S[UR5<S3$N())rr$r r<r5s r__repr__Match.__repr__s >>22F4994EFFr)r=r<N) r$r%r&r'r(rrrDrHrKrQr)r#rrr9r9Hs(FN&. " Grr9 fullmatchz'func' must be one of %s, c#\# UH"o=(a UR=(d Sv M$ g7f)NoneN)r$).0es r rYs ?!  %v %s*,r#rc2\rSrSrSrSrSSjrSrSrSr g) Regexz checks that target is a string which matches the passed regex pattern raises MatchError if there isn't a match; returns Target if match variables captures in regex are added to the scope so they can be used by downstream processes )flagsfunc match_funcpatternNcU[;a[e[R"X5nU[RLa URnOjU[R La UR nOJ[ (a URnO2[R"SRU5U5nURnX#sUl Ul XQsUl Ul g)Nz(?:{})\Z) _RE_VALID_FUNCS_RE_FUNC_ERRORrecompilematchsearch _RE_FULLMATCHrSformatr^r_r`ra)rrar^r_regexr`s rrRegex.__init__s  &  7* 288 J RYY J}"__  ;#5#5g#>F"[[ % DI(2%rc[U5[;a[S[U5[5eURU5nU(d[SUR5eUR UR 55 U$)Nz3{0!r} not valid as a Regex target -- expected {1!r}z"target did not match pattern {0!r})type _RE_TYPESrr`raupdate groupdictrrArBrgs rrD Regex.glomitsd  zE{ E6 " "VE]"S(( %=rc>\rSrSrSrSrSrSrSrSr Sr S r g ) _BoolicXlU(d.[SRURR55eUR S[ 5UlU(a%[S[UR55-5eg)Nz need at least one operand for {}r=zgot unexpected kwargs: %r) children ValueErrorrjrr$poprr= TypeErrorlistkeys)rrkws rr_Bool.__init__sg ?FF'')* *vvi2 7$rwwy/IJ J rc[X5$rAndrothers r__and__ _Bool.__and__ 4rc[X5$rOrrs r__or__ _Bool.__or__ $rc[U5$rNotr5s r __invert___Bool.__invert__ 4yrcURX5$![a# UR[LaURs$ef=fr)_glomitrr=rrrArBs rrD _Bool.glomits> <<. . ||8+||#  s)AAc[URS[[45(ag[ URS5[ [ [4;aURSR5$g)zshould this Or() repr as M |?rTF) rzr_MTyper{rnrrr_m_reprr5s rr _Bool._m_repr"sY dmmA&(8 9 9  a !c2s^ 3==#++- -rcURVs/sHn[U5PM nnUR5(a=UR[La*SR UR 5RU5$UR[La'URS[UR5-5 URRS-SRU5-S-$s snf)Nz {} zdefault=rOrTrP) rr~rr=rrjOPjoinappendryrr$)rc child_reprss rrQ_Bool.__repr__+s48MMBMq'*M B <<>>dllh6==)..{; ; <> ?~~&&,tyy/EEKK CsC )rr=N) r$r%r&r'rrrrrDrrQr)r#rrrrs'K Lrrc,\rSrSrSrSrSrSrSrSr g) ri4zz Applies child specs one after the other to the target; if none of the specs raises `GlomError`, returns the last result. &rcPUnURHnU["XU5nM U$r)rr)rrArBresultr}s rr And._glomit<s*]]E4[6F# rc.[URU4-6$r)rrrs rr And.__and__CsT]]eX-//rr#N) r$r%r&r'r(rrvrrr)r#rrrr4s BI0rrc,\rSrSrSrSrSrSrSrSr g) riHz Tries to apply the first child spec to the target, and return the result. If `GlomError` is raised, try the next child spec until there are no all child specs have been tried, then raise `MatchError`. |rcURSSHnU["XU5s $ U["XRSU5$![a MBf=f)N)rrr)rrArBr}s rr Or._glomitQs]]]3B'E T{6%88( T{6==#4e<<  sA AAc.[URU4-6$r)rrrs rr Or.__or__YsDMMUH,..rr#N) r$r%r&r'r(rrvrrr)r#rrrrHs BI=/rrc4\rSrSrSrSrSrSrSrSr Sr g) ri^z Inverts the *child*. Child spec will be expected to raise :exc:`GlomError` (or subtype), in which case the target will be returned. If the child spec does not raise :exc:`GlomError`, :exc:`MatchError` will be raised. r|cXlgrr|)rr}s rr Not.__init__hs rcU["XRU5 [SUR5e![a Us$f=f)Nzchild shouldn't have passed)rr}rrs rrD Not.glomitksD G $K E 294::F F M s2 AAc[UR[[45(ag[ UR5[ [ [4;agURR5$)NTF) rzr}rr{rnrrrrr5s rr Not._m_reprssH djj66"2 3 3  CS> 1zz!!##rcUR[LagUR5(aS[UR5-S-$S[UR5-S-$)Nz~Mz~(rPzNot()r}rxrr r5s rrQ Not.__repr__zsM ::? <<>>&,,s2 2tzz**S00rN) r$r%r&r'r(rvrrDrrQr)r#rrrr^s#IG$1rrz==z!=z>=z<=)=!glcR\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rg) _MSubspeciz8used by MType.__call__ to wrap a sub-spec for comparisonr<cXlgrr<rr<s rr_MSubspec.__init__s rc[USU5$Nrr{rs r__eq___MSubspec.__eq__dC''rc[USU5$Nrrrs r__ne___MSubspec.__ne__rrc[USU5$N>rrs r__gt___MSubspec.__gt__rrc[USU5$N US:H=(a X5:=(d' US:H=(a X5:=(d US:H=(a X5:*nU(aU$[SU[RXD5U5e)Nrrrrrrz{0!r} {1} {2!r}) rrrrxrnrrr<r _M_OP_MAPget)rrArBrrrmatcheds rrD _MExpr.glomitsxx$(( !8C !8C 9 !+fhh6C 9 !+fhh6C 3Y %3: ' 3Y %3: ' 3Y $39 '3Y $39 '3Y %3:  ' 3Y %3:  M*Cr1FLLrc[RURUR5nSRURXR 5$)Nz {!r} {} {!r})rrrrjrr)rrs rrQ_MExpr.__repr__s5 ]]477DGG ,$$TXXr88<>> glom(1, M > 0) 1 >>> glom(0, M == 0) 0 >>> glom('a', M != 'b') == 'a' True :attr:`~glom.M` by itself evaluates the current target for truthiness. For example, `M | Val(None)` is a simple idiom for normalizing all falsey values to None: >>> from glom import Val >>> glom([0, False, "", None], [M | Val(None)]) [None, None, None, None] For convenience, ``&`` and ``|`` operators are overloaded to construct :attr:`~glom.And` and :attr:`~glom.Or` instances. >>> glom(1.0, (M > 0) & float) 1.0 .. note:: Python's operator overloading may make for concise code, but it has its limits. Because bitwise operators (``&`` and ``|``) have higher precedence than comparison operators (``>``, ``<``, etc.), expressions must be parenthesized. >>> M > 0 & float Traceback (most recent call last): ... TypeError: unsupported operand type(s) for &: 'int' and 'type' Similarly, because of special handling around ternary comparisons (``1 < M < 5``) are implemented via short-circuiting evaluation, they also cannot be captured by :data:`M`. r#c[U[[55(d![S[U5R-5e[ U5$)zDwrap a sub-spec in order to apply comparison operators to the resultz&M() only accepts T-style specs, not %s)rzrnr rr$rrs r__call___MType.__call__ s:$Q((DtDzGZGZZ[ [rc[USU5$rrrs rr _MType.__eq__rrc[USU5$rrrs rr _MType.__ne__rrc[USU5$rrrs rr _MType.__gt__rrc[USU5$rrrs rr _MType.__lt__rrc[USU5$rrrs rr _MType.__ge__rrc[USU5$rrrs rr _MType.__le__ rrc[X5$rrrs rr_MType.__and__#rrc[X5$rrrs rr _MType.__or__(rrc[U5$rrr5s rr_MType.__invert__+rrcg)Nrxr#r5s rrQ_MType.__repr__.src,U(aU$[SU5e)Nz{0!r} not truthy)r)rrAr<s rrD _MType.glomit1s M+V44rN)r$r%r&r'r(rvrrrrrrrrrrrrQrDr)r#rrrrsR1dI(((((( H5rrc4\rSrSrSrSr\4SjrSrSr Sr g) Optionali;aUsed as a :class:`dict` key in a :class:`~glom.Match()` spec, marks that a value match key which would otherwise be required is optional and should not raise :exc:`~glom.MatchError` even if no keys match. For example:: >>> spec = Match({Optional("name"): str}) >>> glom({"name": "alice"}, spec) {'name': 'alice'} >>> glom({}, spec) {} >>> spec = Match({Optional("name", default=""): str}) >>> glom({}, spec) {'name': ''} )keyr=c[U5[[4;a [S5e[ U5 [ U5S:wa[ SRU55eXsUlUl g)Nzdouble wrapping of Optionalrz4Optional() keys must be == match constants, not {!r}) rnRequiredrrhash _precedencerrjr r=)rr r=s rrOptional.__init__OsY 98, ,9: : S s q SZZ[^_` `!$$,rcPXR:wa[SXR5eU$)Nztarget {0} != spec {1})r rrs rrDOptional.glomitWs# XX 5vxxH H rcdURR<S[UR5<S3$rNrr$r r r5s rrQOptional.__repr__\ >>22F4884DEEr)r=r N) r$r%r&r'r(rvrrrDrQr)r#rrrr;s!"#I$,. Frrc(\rSrSrSrSrSrSrSrg)r"i`a6Used as a :class:`dict` key in :class:`~glom.Match()` mode, marks that a key which might otherwise not be required should raise :exc:`~glom.MatchError` if the key in the target does not match. For example:: >>> spec = Match({object: object}) This spec will match any dict, because :class:`object` is the base type of every object:: >>> glom({}, spec) {} ``{}`` will also match because match mode does not require at least one match by default. If we want to require that a key matches, we can use :class:`~glom.Required`:: >>> spec = Match({Required(object): object}) >>> glom({}, spec) Traceback (most recent call last): ... MatchError: error raised while processing. Target-spec trace, with error detail (most recent last): - Target: {} - Spec: Match({Required(object): }) - Spec: {Required(object): } MatchError: target missing expected keys Required(object) Now our spec requires at least one key of any type. You can refine the spec by putting more specific subpatterns inside of :class:`~glom.Required`. r c[U5[[4;a [S5e[ U5 [ U5S:Xa[ S[U5-5eXlg)Nzdouble wrapping of Requiredrz)== match constants are already required: ) rnr"rrr#r$rr r )rr s rrRequired.__init__sN 98, ,9: : S s q H6RU;VW WrcdURR<S[UR5<S3$rNr)r5s rrQRequired.__repr__r+rN) r$r%r&r'r(rvrrQr)r#rrr"r"`s!DIFrr"c4[U5[[4;a URn[U5[[ 4;a-U(dg[ UVs/sHn[U5PM sn5$[U[5(ag[US5(aggs snf)z in a dict spec, target-keys may match many spec-keys (e.g. 1 will match int, M > 0, and 1); therefore we need a precedence for which order to try keys in; higher = later rr4rDr) rnr"rr tuple frozensetmaxr$rzhasattr)rgitems rr$r$s| E{x**  E{ui((%8%$K%%899%uh 9sBc [U[5(d[[U5[5eUn[R S:a[ U[S9nUVs1sH:n[U5S:Xa[U5[Ld[U5[LdM8UiM< nnUVs0sHCn[U5[LdMUR[LdM,URUR_ME nnUR5HzupGUHen[U5[La URn OUn U["XIU5nU["XqU[U55Xd'UR!U5 Mn [%SXC5e U(a5[%SSR'UV s/sHn [)U 5PM sn 55eU$s snfs snf!["a Mf=fs sn f)N)r-rz#key {0!r} didn't match any of {1!r}z!target missing expected keys: {0}rT)rzdictr-rnsys version_infosortedr$rr"r=rr itemsrrdiscardrrrr ) rAr<rB spec_keysr requiredrvalmaybe_spec_keyspec_keyrs r _handle_dictrGs fd # #T&\400I & 9+6  "  s q T#Yh%> 9  y " )2B(1 9  %([[%@   BLLN'NN#x/)--) Dk#7$Dk#N/C[QVEWX   0(BCS S!#"fgg M5"B  Ifs67F6F6F;8F; F;&GG G Gc [U[5(a([X5(d[[U5U5eU$[U[5(a [ XU5$[U[ [ [45(a[U[U55(d[[U5[U55e/nUH[nUH$nURU["XEU55 M+ U(a'U(d [SU[U5R5eWe [U5[ La[U5"U5$U$[U[5(a[U[5(d[[U5[5e[U5[U5:wa [SX5e/n[X5H$upURU["XU55 M& [U5$[!U5(a(U"U5(aU$[SURU5eX:wa [SX5eU$![anUnSnAGMSnAff=f!["an[SURX5eSnAff=f)Nz{0!r} does not match empty {1}z{0!r} does not match {1!r}z1{0}({1!r}) did not validate (got exception {2!r})z/{0}({1!r}) did not validate (non truthy return))rzrnr-r;rGrsetr4rrrrr$r3lenzipcallable Exception) rAr<rBrr7r}rX last_error sub_targetsub_specs rr@r@s5$&'' ft4 4(Z MW D$  F%00 D4i0 1 1&$t*-- ftDz: :D#MM%+d5"AB$$8&$t*BUBUWW!  :T !:f% % D% &%(( fu5 5 v;#d) #96H H$'$5 J MM%+jEB C%6V} $ _F||   =t}}fV V 5vDD MA!#!"J#2 _CT]]TZ_ _ _s0H17I 1 I ;II  I2I--I2c0\rSrSrSr\4SjrSrSrSr g)Switchia The :class:`Switch` specifier type routes data processing based on matching keys, much like the classic switch statement. Here is a spec which differentiates between lowercase English vowel and consonant characters: >>> switch_spec = Match(Switch([(Or('a', 'e', 'i', 'o', 'u'), Val('vowel')), ... (And(str, M, M(T[2:]) == ''), Val('consonant'))])) The constructor accepts a :class:`dict` of ``{keyspec: valspec}`` or a list of items, ``[(keyspec, valspec)]``. Keys are tried against the current target in order. If a keyspec raises :class:`GlomError`, the next keyspec is tried. Once a keyspec succeeds, the corresponding valspec is evaluated and returned. Let's try it out: >>> glom('a', switch_spec) 'vowel' >>> glom('z', switch_spec) 'consonant' If no keyspec succeeds, a :class:`MatchError` is raised. Our spec only works on characters (strings of length 1). Let's try a non-character, the integer ``3``: >>> glom(3, switch_spec) Traceback (most recent call last): ... glom.matching.MatchError: error raised while processing, details below. Target-spec trace (most recent last): - Target: 3 - Spec: Match(Switch([(Or('a', 'e', 'i', 'o', 'u'), Val('vowel')), (And(str, M, (M(T[2:]) == '')), Val('... + Spec: Switch([(Or('a', 'e', 'i', 'o', 'u'), Val('vowel')), (And(str, M, (M(T[2:]) == '')), Val('conson... |\ Spec: Or('a', 'e', 'i', 'o', 'u') ||\ Spec: 'a' ||X glom.matching.MatchError: 3 does not match 'a' ||\ Spec: 'e' ||X glom.matching.MatchError: 3 does not match 'e' ||\ Spec: 'i' ||X glom.matching.MatchError: 3 does not match 'i' ||\ Spec: 'o' ||X glom.matching.MatchError: 3 does not match 'o' ||\ Spec: 'u' ||X glom.matching.MatchError: 3 does not match 'u' |X glom.matching.MatchError: 3 does not match 'u' |\ Spec: And(str, M, (M(T[2:]) == '')) || Spec: str |X glom.matching.TypeMatchError: expected type str, not int glom.matching.MatchError: no matches for target in Switch .. note:: :class:`~glom.Switch` is one of several *branching* specifier types in glom. See ":ref:`branched-exceptions`" for details on interpreting its exception messages. A *default* value can be passed to the spec to be returned instead of raising a :class:`MatchError`. .. note:: Switch implements control flow similar to the switch statement proposed in `PEP622 `_. cL[U5[La[UR55n[U5[La#[ SR [U555eXlX lU(d1[SURR<SUR <35eg)Nz\expected cases argument to be of format {{keyspec: valspec}} or [(keyspec, valspec)] not: {}zexpected at least one case in z, got: ) rnr;rr?rrjcasesr=rrr$)rrTr=s rrSwitch.__init__>s ;$ 'E ;d "3396$u+3FH H   $ 7 7EF Frc2URH/up4U["XU5 U["X[U55s $ UR[ La UR$[ SURR-5e![a nSnAMSnAff=f)Nzno matches for target in %s) rTrrrr=rrrr$)rrArBkeyspecvalspecges rrD Switch.glomitOs $ G d FU3;v E0BC C !+ <>22F4::4FGGr)rTr=N) r$r%r&r'r(rrrDrQr)r#rrrRrRsAD'/" SHrrRRAISEcF\rSrSrSr\4Sjr"SS\5rSr Sr Sr g ) CheckiaaCheck objects are used to make assertions about the target data, and either pass through the data or raise exceptions if there is a problem. If any check condition fails, a :class:`~glom.CheckError` is raised. Args: spec: a sub-spec to extract the data to which other assertions will be checked (defaults to applying checks to the target itself) type: a type or sequence of types to be checked for exact match equal_to: a value to be checked for equality match ("==") validate: a callable or list of callables, each representing a check condition. If one or more return False or raise an exception, the Check will fail. instance_of: a type or sequence of types to be checked with isinstance() one_of: an iterable of values, any of which can match the target ("in") default: an optional default value to replace the value when the check fails (if default is not specified, GlomCheckError will be raised) Aside from *spec*, all arguments are keyword arguments. Each argument, except for *default*, represent a check condition. Multiple checks can be passed, and if all check conditions are left unset, Check defaults to performing a basic truthy check on the value. c Xl[U5UlURS[5UlSSjnSnURSU(a[ OU5nURS[ 5nURS[ 5nURS[ 5nURS[ 5n U(a[S UR5-5eU"SS [U5Ul U"SS S US 5Ul U"SS SUS 5Ul U[ LaU4Ul U [ La [S5egU [ La;[U 5(d[SU -5eU (d[SU <35eXl gSUl g)Nr=c U[Lag[U5(dU4nO!U(dU(d[SU<SU<35eUH'nU"U5(aM[SU<SU<SU<35e U$)Nr#z expected z. argument to contain at least one value, not: z argument to be z, not: )rrr)namecondr_rC can_be_emptyvs r _get_arg_val$Check.__init__.._get_arg_valsmhs##f /3S":;;Aww$(,dA&788Jrc[U5$r)bool)rCs rtruthyCheck.__init__..truthys 9 rvalidatern instance_ofequal_toone_ofz unexpected keyword arguments: %rrLza typec"[U[5$rrzrnxs r Check.__init__..s *Q2ErFc"[U[5$rrqrrs rrtrus Jq$,?rzIexpected "one_of" argument to be unset when "equal_to" argument is passedz3expected "one_of" argument to be iterable , not: %rz6expected "one_of" to contain at least one value, not: r#)T)r<r; _orig_kwargsrr]r=rrrrL validatorsrmtypesvalsrr) rr<kwargsrfrjrltype_argrmrnros rrCheck.__init__s}  Lzz)U3  " ::jf(&I::fh/jj9 ::j(3Hh/ >NO O&z:xR' x(E{TY[!&("?5R  8 #! DIX%!ABB& 8 #v&& ".06"788 :@"CDDI DIrc\rSrSrSrSrg)Check._ValidationErroriz%for internal use inside of Check onlyr#N)r$r%r&r'r(r)r#rr_ValidationErrorrs/ rrc Un/nUR[LaU["XRU5nUR(a[ U5UR;aUR [ La UR $URS[UR5S:XaURSRO.[URVs/sHoURPM sn5<S[ U5R<35 UR(aXR;aUR [ La UR $[UR5S:Xa/URSRURSU55 O+URSRURU55 UR(a8[UR5HupgU"U5nUSLa UReM! UR$(a['XR$5(dUR [ La UR $URS [UR$5S:XaUR$SRO.[UR$Vs/sHoURPM sn5<S [ U5R<35 U(a[)X@U[*5eU$s snf![ an S[#US S5-=(d S U-n [ U 5URLa'UR [ LaUR sSn A s $OU S U -- n URU 5 Sn A GMSn A ff=fs snf)Nzexpected type to be rrz , found type zexpected {}, found {}zexpected one of {}, found {}Fz$expected %r check to validate targetr$z#%sz (got exception: %r)zexpected instance of z, found instance of )r<r rryrnr=r]rrJr$r3rzrjrx enumeraterrMgetattrrmrz CheckErrorr) rrArBrCerrsti validatorresrXmsgs rrD Check.glomits 99A 4[E:F ::$v,djj8||5(||# KK36tzz?a3GA//#$DAZZ$DEFf..0 1 99yy0||5(||#499~" 3::499Q<PQ :AA$))VTU ?? )$// :  %#F+Ce|"333$!;   Jv7G7G$H$H||5(||# KK9 ^^ $ $"&))1"4499," d.?.?fMMr)rwr=rmr<ryrxrzN) r$r%r&r'r(r rrMrrDrQr)r#rrr_r_as*>6p 9 2hNrr_c0\rSrSrSrSrSrSrSrSr g) riaThis :exc:`GlomError` subtype is raised when target data fails to pass a :class:`Check`'s specified validation. An uncaught ``CheckError`` looks like this:: >>> target = {'a': {'b': 'c'}} >>> glom(target, {'b': ('a.b', Check(type=int))}) Traceback (most recent call last): ... CheckError: target at path ['a.b'] failed check, got error: "expected type to be 'int', found type 'str'" If the ``Check`` contains more than one condition, there may be more than one error message. The string rendition of the ``CheckError`` will include all messages. You can also catch the ``CheckError`` and programmatically access messages through the ``msgs`` attribute on the ``CheckError`` instance. c(XlX lX0lgr)msgs check_objpath)rrcheckrs rrCheckError.__init__ s  rcNSUR-nURR[LaUSURR<3- n[ UR 5S:XaUSUR S<3- nU$US[ UR 5<SUR <3- nU$)Nztarget at path %s failed check,z subtarget at rz got error: rz got z errors: )rrr<r rJr)rrs rr!CheckError.get_messages/$)); >>  a ' )<)<> >C tyy>Q  tyy|5 5C  3tyy>499E EC rcd[U5"URURUR5$r)rnrrrr5s rr6CheckError.__copy__s!Dz$))T^^TYY??rcURRnU<SUR<SUR<SUR<S3$)NrOrTrP)rr$rrr)rrs rrQCheckError.__repr__s, ^^ $ $#%tyy$..$))LLr)rrrN) r$r%r&r'r(rr!r6rQr)r#rrrrs( @Mrr):r(rer<rboltons.iterutilsrboltons.typeutilsrcorerrr r r r r rrrrrrr-objectr9rrirIrhrgrcrrr>rdrornrMr\r~rrrrrrr{rrxrr"r$rGr@rRr]r_rr#rrrs  )+ggg  $$$$:Z:6uGFuGpK. }dBIIrxx@A6$)) ? ??;ABC   xxST#YL y xxST#YL y-.F-.b*LF*LZ0%0(//,!1%!1HT4 8  Z ZF)=V)=X`5V`5F H"Fv"FJ.Fv.Fb (!H/d`HV`HF gSNFSNl*M*Ma$$s$2F"F."F+*F+.F76F7