U
    kufj)                     @   s   d dl mZmZmZ d dlmZ d dlZd dlZG dd deZG dd dZ	dd	 Z
d
d Zdd Zdd Zdd Zdd Zdd Ze e fddZdd Zdd Zdd ZdS )    )MappingMutableMappingSequence)urlsplitNc                   @   sP   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dd ZdS )URIDictz8
    Dictionary which uses normalized URIs as keys.
    c                 C   s   t | S N)r   geturlselfuri r   5/tmp/pip-unpacked-wheel-k94ccfep/jsonschema/_utils.py	normalize   s    zURIDict.normalizec                 O   s   t  | _| jj|| d S r   )dictstoreupdate)r
   argskwargsr   r   r   __init__   s    zURIDict.__init__c                 C   s   | j | | S r   r   r   r	   r   r   r   __getitem__   s    zURIDict.__getitem__c                 C   s   || j | |< d S r   r   )r
   r   valuer   r   r   __setitem__   s    zURIDict.__setitem__c                 C   s   | j | |= d S r   r   r	   r   r   r   __delitem__   s    zURIDict.__delitem__c                 C   s
   t | jS r   )iterr   r
   r   r   r   __iter__   s    zURIDict.__iter__c                 C   s
   t | jS r   )lenr   r   r   r   r   __len__   s    zURIDict.__len__c                 C   s
   t | jS r   )reprr   r   r   r   r   __repr__"   s    zURIDict.__repr__N)__name__
__module____qualname____doc__r   r   r   r   r   r   r   r    r   r   r   r   r      s   r   c                   @   s   e Zd ZdZdd ZdS )UnsetzG
    An as-of-yet unset attribute or unprovided default parameter.
    c                 C   s   dS )Nz<unset>r   r   r   r   r   r    +   s    zUnset.__repr__N)r!   r"   r#   r$   r    r   r   r   r   r%   &   s   r%   c                 C   s(   |s| S |  dd dd |D  dS )aA  
    Construct a single string containing indexing operations for the indices.

    For example for a container ``bar``, [1, 2, "foo"] -> bar[1][2]["foo"]

    Arguments:

        container (str):

            A word to use for the thing being indexed

        indices (sequence):

            The indices to format.
    [z][c                 s   s   | ]}t |V  qd S r   r   ).0indexr   r   r   	<genexpr>A   s     z"format_as_index.<locals>.<genexpr>])join)	containerindicesr   r   r   format_as_index/   s    r/   c                 c   sL   | di }d| di }| D ]$}||kr"|r@t||r@q"|V  q"dS )z
    Return the set of additional properties for the given ``instance``.

    Weeds out properties that should have been validated by ``properties`` and
    / or ``patternProperties``.

    Assumes ``instance`` is dict-like already.
    
properties|patternPropertiesN)getr,   research)instanceschemar0   patternspropertyr   r   r   find_additional_propertiesD   s    	r:   c                 C   s,   t | dkrdnd}ddd | D |fS )z@
    Create an error message for extra items or properties.
       waswerez, c                 s   s   | ]}t |V  qd S r   r'   )r(   extrar   r   r   r*   [   s     zextras_msg.<locals>.<genexpr>)r   r,   )extrasZverbr   r   r   
extras_msgV   s    r@   c                 C   s   t | tr| gS | S )z]
    Wrap ``thing`` in a list if it's a single str.

    Otherwise, return it unchanged.
    )
isinstancestr)thingr   r   r   ensure_list^   s    
rD   c                    s.   t | t  krdS t fdd|  D S )zI
    Check if two mappings are equal using the semantics of `equal`.
    Fc                 3   s(   | ] \}}| kot | | V  qd S r   equal)r(   keyr   twor   r   r*   o   s   z!_mapping_equal.<locals>.<genexpr>)r   allitemsZonerI   r   rH   r   _mapping_equali   s
    rM   c                 C   s,   t | t |krdS tdd t| |D S )zJ
    Check if two sequences are equal using the semantics of `equal`.
    Fc                 s   s   | ]\}}t ||V  qd S r   rE   )r(   ijr   r   r   r*   {   s     z"_sequence_equal.<locals>.<genexpr>)r   rJ   ziprL   r   r   r   _sequence_equalu   s    rQ   c                 C   sh   t | tst |tr| |kS t | tr:t |tr:t| |S t | trXt |trXt| |S t| t|kS )z
    Check if two things are equal evading some Python type hierarchy semantics.

    Specifically in JSON Schema, evade `bool` inheriting from `int`,
    recursing into sequences to do the same.
    )rA   rB   r   rQ   r   rM   unboolrL   r   r   r   rF   ~   s    

rF   c                 C   s   | dkr|S | dkr|S | S )zH
    A hack to make True and 1 and False and 0 unique for ``uniq``.
    TFr   )elementtruefalser   r   r   rR      s
    rR   c              	   C   s   zJt dd | D }t|dd}t||D ]\}}t||r, W dS q,W nV ttfk
r   g }| D ]4}t|}|D ]}t||rv  Y dS qv|| qfY nX dS )z
    Check if all of a container's elements are unique.

    Tries to rely on the container being recursively sortable, or otherwise
    falls back on (slow) brute force.
    c                 s   s   | ]}t |V  qd S r   )rR   )r(   rN   r   r   r   r*      s     zuniq.<locals>.<genexpr>r;   NFT)	sorted	itertoolsislicerP   rF   NotImplementedError	TypeErrorrR   append)r-   sortZslicedrN   rO   seener   r   r   uniq   s    

r_   c                 C   s  |  |drg S g }d|kr,ttt|S |d}|dk	rl| j|}|t| j	|j
|jd||j
 |d}|dk	r| j|}|t| j	|j
|jd||j
 d|kr|ttt|d 7 }d|kr@| j	|d d	|r"|t| ||d 7 }d
|kr@|t| ||d
 7 }nd|kr@|t| ||d 7 }dD ]F}||krDt|D ],\}}	| j	|| d	|	rZ|| qZqDdD ]L}||kr|| D ]2}
t| ||
d}|dkr|t| ||
7 }qq|S )z
    Get all indexes of items that get evaluated under the current schema.

    Covers all keywords related to unevaluatedItems: items, prefixItems, if,
    then, else, contains, unevaluatedItems, allOf, oneOf, anyOf
    booleanrK   $refNr7   	_resolver$dynamicRefZprefixItemsifr7   thenelse)containsZunevaluatedItemsZallOfoneOfZanyOf)is_typelistranger   r3   rc   lookupextend%find_evaluated_item_indexes_by_schemaevolvecontentsresolveris_valid	enumerater[   nextdescend)	validatorr6   r7   Zevaluated_indexesrefresolved
dynamicRefkeywordkv	subschemaerrsr   r   r   rq      s    


  
  
  


  rq   c                 C   s<  |  |drg S g }|d}|dk	rT| j|}|t| j|j|jd||j |d}|dk	r| j|}|t| j|j|jd||j dD ]Z}||kr|| }|  |dr|r||	 7 }q|  |dr|D ]}	|	|kr|
|	 qqd|kr2|D ].}	|d D ]}
t|
|	r|
|	 qqd	|krr|d	  D ](\}	}|	|kr^qH|t| ||7 }qHd
D ]L}||krv|| D ]2}t| ||d}|dkr|t| ||7 }qqvd|kr8| j|d d|r|t| ||d 7 }d|kr8|t| ||d 7 }nd|kr8|t| ||d 7 }|S )a  
    Get all keys of items that get evaluated under the current schema.

    Covers all keywords related to unevaluatedProperties: properties,
    additionalProperties, unevaluatedProperties, patternProperties,
    dependentSchemas, allOf, oneOf, anyOf, if, then, else
    r`   ra   Nrb   rd   )r0   ZadditionalPropertiesZunevaluatedPropertiesobjectr2   ZdependentSchemasrj   re   rf   rg   rh   )rl   r3   rc   ro   rp   &find_evaluated_property_keys_by_schemarr   rs   rt   keysr[   r4   r5   rK   rw   rx   ru   )ry   r6   r7   Zevaluated_keysrz   r{   r|   r}   Zschema_valuer9   patternr   r   r   r   r   r     s    




  


  
  
  
  r   )collections.abcr   r   r   urllib.parser   rW   r4   r   r%   r/   r:   r@   rD   rM   rQ   rF   r   rR   r_   rq   r   r   r   r   r   <module>   s    		M