M?TddlmZddlZddlZddlZ ddlZddlmZm Z ddl m Z m Z m Z mZmZmZmZmZmZmZddlmZddlmZmZmZej4ZiZej:ZdZd(dZ d)d Z!e ejDd id e jFd e jHd e jJde jLde jNde jPde jRde jTde jVde jXde jZde j\de j^de j`de jbde jdde jPe jfe jhe jje jle jndd Z8e ejDdid e jFd e jHd e jJde jrd e jtde jLde jRde jVde jXde jZde j\d!e jvde j^de j`de jbd"e jxde jde jPe jze j|e jfe jhe j~e je je jnd# dZBGd$d%eCZDefd&ZEd)d'ZFy#e$rdZYwxYw)*)divisionN)_utils _validators) Sequenceurljoinurlsplit urldefragunquoteurlopen str_types int_types iteritems lru_cache) ErrorTree)RefResolutionError SchemaError UnknownTypecfd}|S)a Register the decorated validator for a ``version`` of the specification. Registered validators and their meta schemas will be considered when parsing ``$schema`` properties' URIs. Arguments: version (str): An identifier to use as the version's name Returns: callable: a class decorator to decorate the validator with the version cb|t<d|jvr|t|jd<|S)Nid) validators META_SCHEMA meta_schemas)clsversions (lib/third_party/jsonschema/validators.py _validateszvalidates.._validates.s1! 7 COO #36L/ 0 )rrs` r validatesr s& rc5ttttdtj t tdGfddt}|9t||}|jjdddz|_ |S)N)arraybooleanintegernullnumberobjectstringceZdZeWZeWZeWZ d dZedZ d dZ d dZ dZ dZ d dZy) create..ValidatorNct|j|_|jj||tj |}||_||_||_yN) dict DEFAULT_TYPES_typesupdate RefResolver from_schemaresolverformat_checkerschema)selfr5typesr3r4s r__init__z"create..Validator.__init__CsTt112DK KK  u %&226:$DM"0D  DKrcx||jj|D]}tj|yr,)r iter_errorsr create_from)rr5errors r check_schemaz&create..Validator.check_schemaPs2S__-99&A!--e44Brc3<K| |j}|jd}|r|jj| |jd}|d|fg}n t |}|D]r\}}|j j|}|$|||||xsd} | D];} | j |||||dk7r| jj|| =t |r|jjyy#|r|jjwwxYww)Nr$refr) validatorvalidator_valueinstancer5) r5getr3 push_scoper VALIDATORS_set schema_path appendleft pop_scope) r6rB_schemascoperefrkvr@errorsr<s rr:z%create..Validator.iter_errorsUs ++KK&E ((/ .kk'*?#*C.!1J!*7!3J&DAq $ 3 3A 6I ( &tQ'BHbF!' &',-%-#* # <!--88;# "( '$MM++-5MM++-s=DBC:D:DDc3K|j||D]@}||jj|||jj||Bywr,)r:pathrHrG)r6rBr5rQrGr<s rdescendz!create..Validator.descendxsT))(F;#JJ))$/*%%00= .Validator.validates#)))4:6: ;rc||jvrt|||j|j|}t|tr2t j |}td|D}|r t|vryt||S)Nc3PK|]}t|tj ywr,) issubclassnumbersNumber).0pytypes r z4create..Validator.is_type..s EL6Jvw~~6Ws$&F)r/rr5 isinstanceboolrflattenany)r6rBtypepytypes is_numbers ris_typez!create..Validator.is_types|4;;&!$$++>>kk$'G(D) ..1 EL  W!4 h0 0rcBt|j||d}|duSr,)nextr:)r6rBrJr<s ris_validz"create..Validator.is_valids%))(Gs[*% ;' ]+ CG !  5  5! .F   1 !rrq ) listr`r rcrZr[r-r r'r titlereplacerk)rprrrorqs`` ` rcreaterw6s})$ZGNNt  W!W!FW!r&Ig&y1 $]]_44S"= K  rct|j}|j|t|j|||j S)N)rprrro)r-rEr0rwrr.)r@rrall_validatorss rextendrzsE)../N*% ))!--  rdraft3r?additionalItemsadditionalProperties dependenciesdisallow divisibleByenumextendsformatitemsmaxItems maxLengthmaximumminItems minLengthminimum multipleOf)patternpatternProperties propertiesrc uniqueItems)rprrdraft4allOfanyOf maxProperties minProperties) rnotoneOfrrrrequiredrcrceZdZdZ ddZedZdZdZe dZ e dZ e jd Ze jd Zd Zd Zd ZdZy)r1a& Resolve JSON References. Arguments: base_uri (str): The URI of the referring document referrer: The actual referring document store (dict): A mapping from URIs to documents to cache cache_remote (bool): Whether remote refs should be cached after first resolution handlers (dict): A mapping from URI schemes to functions that should be used to retrieve them urljoin_cache (functools.lru_cache): A cache that will be used for caching the results of joining the resolution scope to subscopes. remote_cache (functools.lru_cache): A cache that will be used for caching the results of resolved remote URLs. Nc|tdt}|td|j}||_||_t ||_|g|_tjdttD|_ |jj|||j|<||_||_y)Nic3>K|]\}}||jfywr,)r)r\rr@s rr^z'RefResolver.__init__..#s'$ !8 I&& '!8s)rrresolve_from_urlreferrer cache_remoter-handlers _scopes_stackrURIDictrrstorer0_urljoin_cache _remote_cache)r6base_urirrrr urljoin_cache remote_caches rr8zRefResolver.__init__s  +IdOG4M  *9T?4+@+@AL  (X &Z^^$ !*AAAc`|j|j|}||j|fSr,)rrr)r6rLrs rrzRefResolver.resolveus0!!$"7"7=D&&s+++rct|\}} |j|}|j ||S#t$r2 |j|}n#t$r}t |d}~wwxYwYLwxYwr,)r rKeyErrorresolve_remote Exceptionrresolve_fragment)r6rfragmentdocumentexcs rrzRefResolver.resolve_from_urlys|!# X .zz#H$$Xx88  . ...s3 .(-- . .s21 A,A  A, A& A!!A&&A,+A,cZ|jd}|rt|jdng}|D]F}|jddjdd}t |t r t |} ||}H|S#t$rYwxYw#ttf$rtd|zwxYw)z Resolve a ``fragment`` within the referenced ``document``. Arguments: document: The referrant document fragment (str): a URI fragment to resolve within it /z~1z~0~zUnresolvable JSON pointer: %r) lstripr splitrvr_rint ValueError TypeError LookupErrorr)r6rrpartsparts rrzRefResolver.resolve_fragments ??4(19!''-rD<<t,44UDAD(H-t9D #D> "{+ (3h> s( A=4B = B B  B*c<t|j}||jvr|j||}n|dvrtrt tj ddgt tj jr$tj|j}n[tj|j}n;tjt|jjd}|jr||j|<|S)a Resolve a remote ``uri``. If called directly, does not check the store first, but after retrieving the document at the specified URI it will be saved in the store if :attr:`cache_remote` is True. .. note:: If the requests_ library is present, ``jsonschema`` will use it to request the remote ``uri``, so that the correct encoding is detected and used. If it isn't, or if the scheme of the ``uri`` is not ``http`` or ``https``, UTF-8 is assumed. Arguments: uri (str): The URI to resolve Returns: The retrieved document .. _requests: http://pypi.python.org/pypi/requests/ )httphttpsjsonNzutf-8)rschemerrequestsgetattrResponsecallablerrCloadsr readdecoderr)r6rrresults rrzRefResolver.resolve_remotes>#%% T]] "*T]]6*3/F ) )  H%%vt 4 @))../!c*//1!c*//ZZ 1 1 3 : :7 CDF   $DJJsO r)rTrNN)rkrlrm__doc__r8rnr2rDrIpropertyrr contextlibcontextmanagerrrrrrrrrrr1r1s$T*<DD$ &&(, 9#J4rr1cj|turt}tj|jdd|S)Nz$schemars)_unsetDraft4ValidatorrrC)r5defaults r validator_forrs-&!   FJJz37 AArcv| t|}|j|||g|i|j|y)av Validate an instance under the given schema. >>> validate([2, 3, 4], {"maxItems": 2}) Traceback (most recent call last): ... ValidationError: [2, 3, 4] is too long :func:`validate` will first verify that the provided schema is itself valid, since not doing so can lead to less obvious error messages and fail in less obvious or consistent ways. If you know you have a valid schema already or don't care, you might prefer using the :meth:`~IValidator.validate` method directly on a specific validator (e.g. :meth:`Draft4Validator.validate`). Arguments: instance: The instance to validate schema: The schema to validate with cls (:class:`IValidator`): The class that will be used to validate the instance. If the ``cls`` argument is not provided, two things will happen in accordance with the specification. First, if the schema has a :validator:`$schema` property containing a known meta-schema [#]_ then the proper validator will be used. The specification recommends that all schemas contain :validator:`$schema` properties for this reason. If no :validator:`$schema` property is found, the default validator class is :class:`Draft4Validator`. Any other provided positional and keyword arguments will be passed on when instantiating the ``cls``. Raises: :exc:`ValidationError` if the instance is invalid :exc:`SchemaError` if the schema itself is invalid .. rubric:: Footnotes .. [#] known by a validator registered with :func:`validates` N)rr=rV)rBr5rrTrUs rrVrVs?f {F#V   ))(3rrjr,)G __future__rrrrZr ImportError jsonschemarrjsonschema.compatrrrr r r r r rrjsonschema.exceptionsrrrrUnsetrrrrr rwrz load_schemarLr|r}r~disallow_draft3rrextends_draft3rrrrrrrrrrproperties_draft3 type_draft3rDraft3Validator allOf_draft4 anyOf_draft4maxProperties_draft4minProperties_draft4 not_draft4 oneOf_draft4properties_draft4required_draft4 type_draft4rr'r1rrVrrrrs +,NN   v~~ 6eP"""8,K77 !A!A 11  [00   ..  !! K.. ;%% +## [)) k++ K'' [)) k++ K''!" {--#$ '');;"44((#//-0 5:"""8,K77 !A!A +**  +**  11  !! ;%% +## [)) k++ +:: K'' [)) k++ +::!" K''#$#--&&**'');;"44 00((#//58 =Dv&vr#)B 64}HsLL'&L'