<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet"
        integrity="sha384-GLhlTQ8iRABdZLl6O3oVMWSktQOp6b7In1Zl3/Jr59b6EGGoI1aFkw7cmDA6j6gD" crossorigin="anonymous">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.3.0/css/all.min.css"
        integrity="sha512-SzlrxWUlpfuzQ+pcUCosxcglQRNAq/DZjVsC0lE40xsADsfeQoEypE+enwcOiGjk/bSuGGKHEyjSoQ1zVisanQ=="
        crossorigin="anonymous" referrerpolicy="no-referrer" />
</head>
</html>
B
    ÉpSe0  ã               @   s¼   d dl Z d dlZd dlZd dlZd dlmZmZmZ G dd„ deƒZG dd„ de	ƒZ
dd„ Z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S )é    N)ÚMutableMappingÚ	str_typesÚurlsplitc               @   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   Zgeturl)ÚselfÚuri© r   úB/opt/alt/python37/lib/python3.7/site-packages/jsonschema/_utils.pyÚ	normalize   s    zURIDict.normalizec             O   s   t ƒ | _| jj||Ž d S )N)ÚdictÚstoreÚupdate)r   ÚargsÚkwargsr   r   r	   Ú__init__   s    zURIDict.__init__c             C   s   | j |  |¡ S )N)r   r
   )r   r   r   r   r	   Ú__getitem__   s    zURIDict.__getitem__c             C   s   || j |  |¡< d S )N)r   r
   )r   r   Úvaluer   r   r	   Ú__setitem__   s    zURIDict.__setitem__c             C   s   | j |  |¡= d S )N)r   r
   )r   r   r   r   r	   Ú__delitem__   s    zURIDict.__delitem__c             C   s
   t | jƒS )N)Úiterr   )r   r   r   r	   Ú__iter__   s    zURIDict.__iter__c             C   s
   t | jƒS )N)Úlenr   )r   r   r   r	   Ú__len__!   s    zURIDict.__len__c             C   s
   t | jƒS )N)Ú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"   t  dd | ¡¡}t | d¡¡S )zC
    Load a schema from ./schemas/``name``.json and return it.
    Z
jsonschemazschemas/{0}.jsonzutf-8)ÚpkgutilÚget_dataÚformatÚjsonÚloadsÚdecode)ÚnameÚdatar   r   r	   Úload_schema1   s    r(   é   c                s   d  ‡ fdd„|  ¡ D ƒ¡S )z>
    A dumb version of `textwrap.indent` from Python 3.3.
    Ú
c             3   s   | ]}d dˆ   | V  qdS )ú é   Nr   )Ú.0Úline)Útimesr   r	   ú	<genexpr>?   s    zindent.<locals>.<genexpr>)ÚjoinÚ
splitlines)Ústringr/   r   )r/   r	   Úindent:   s    r4   c             C   s    | sdS dd  dd„ | D ƒ¡ S )zÕ
    Construct a single string containing indexing operations for the indices.

    For example, [1, 2, "foo"] -> [1][2]["foo"]

    Arguments:

        indices (sequence):

            The indices to format.
    Ú z[%s]z][c             s   s   | ]}t |ƒV  qd S )N)r   )r-   Úindexr   r   r	   r0   Q   s    z"format_as_index.<locals>.<genexpr>)r1   )Úindicesr   r   r	   Úformat_as_indexB   s    r8   c             c   sP   |  di ¡}d |  di ¡¡}x,| D ]$}||kr$|rBt ||¡rBq$|V  q$W 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ú|ZpatternPropertiesN)Úgetr1   ÚreÚsearch)ÚinstanceZschemar9   ZpatternsÚpropertyr   r   r	   Úfind_additional_propertiesT   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.
    r)   ZwasZwerez, c             s   s   | ]}t |ƒV  qd S )N)r   )r-   Zextrar   r   r	   r0   p   s    zextras_msg.<locals>.<genexpr>)r   r1   )ZextrasZverbr   r   r	   Ú
extras_msgg   s    rA   c          	   C   s^   g }xF|D ]>}y|  t|d ƒ¡ W q
 tk
rF   |  t|ƒ¡ Y q
X q
W d| d |¡f S )a+  
    Create an error message for a failure to match the given types.

    If the ``instance`` is an object and contains a ``name`` property, it will
    be considered to be a description of that object and used as its type.

    Otherwise the message is simply the reprs of the given ``types``.
    r&   z%r is not of type %sz, )Úappendr   Ú	Exceptionr1   )r>   ÚtypesZreprsÚtyper   r   r	   Ú	types_msgs   s    

rF   c             C   sP   t ƒ }t| tƒs| f} x0| D ](}t|tƒr:| t|ƒ¡ q| |¡ qW t|ƒS )zâ
    isinstance() can accept a bunch of really annoying different types:
        * a single type
        * a tuple of types
        * an arbitrary nested tree of tuples

    Return a flattened tuple of the given argument.
    )ÚsetÚ
isinstanceÚtupler   ÚflattenÚadd)Zsuitable_for_isinstancerD   Úthingr   r   r	   rJ   †   s    



rJ   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.
    )rH   r   )rL   r   r   r	   Úensure_listœ   s    
rM   c             C   s   t | ƒt |ƒkS )zQ
    Check if two things are equal, but evade booleans and ints being equal.
    )Úunbool)ZoneZtwor   r   r	   Úequal¨   s    rO   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	   rN   ¯   s
    rN   c             C   sÊ   yt tdd„ | D ƒƒƒt | ƒkS  tk
rÄ   yHtdd„ | D ƒƒ}t |dd¡}x"t||ƒD ]\}}||kr\dS q\W W nH ttfk
r¾   g }x*| D ]"}t|ƒ}||kr¬dS | 	|¡ q”W Y nX Y nX dS )zÙ
    Check if all of a container's elements are unique.

    Successively tries first to rely that the elements are hashable, then
    falls back on them being sortable, and finally falls back on brute
    force.
    c             s   s   | ]}t |ƒV  qd S )N)rN   )r-   Úir   r   r	   r0   Å   s    zuniq.<locals>.<genexpr>c             s   s   | ]}t |ƒV  qd S )N)rN   )r-   rS   r   r   r	   r0   È   s    r)   NFT)
r   rG   Ú	TypeErrorÚsortedÚ	itertoolsÚisliceÚzipÚNotImplementedErrorrN   rB   )Z	containerÚsortZslicedrS   ÚjÚseenÚer   r   r	   Úuniq»   s"    	
r^   )r)   )rV   r#   r    r<   Zjsonschema.compatr   r   r   r   Úobjectr   r(   r4   r8   r@   rA   rF   rJ   rM   rO   rN   r^   r   r   r   r	   Ú<module>   s"   		
