<!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   Ú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)Ústringr0   r	   )r0   r
   Úindent:   s    r5   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
   r1   Q   s    z"format_as_index.<locals>.<genexpr>)r2   )Úindicesr	   r	   r
   Úformat_as_indexB   s    r9   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)Úgetr2   ÚreÚsearch)ÚinstanceZschemar:   ÚpatternsÚpropertyr	   r	   r
   Úfind_additional_propertiesT   s    

rB   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*   ÚwasÚwerez, c             s   s   | ]}t |ƒV  qd S )N)r   )r.   Úextrar	   r	   r
   r1   p   s    zextras_msg.<locals>.<genexpr>)r   r2   )ÚextrasZverbr	   r	   r
   Ú
extras_msgg   s    rG   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   Ú	Exceptionr2   )r?   ÚtypesZreprsÚtyper	   r	   r
   Ú	types_msgs   s    

rL   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_isinstancerJ   Úthingr	   r	   r
   rP   †   s    



rP   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.
    )rN   r   )rR   r	   r	   r
   Úensure_listœ   s    
rS   c             C   s   t | ƒt |ƒkS )zQ
    Check if two things are equal, but evade booleans and ints being equal.
    )Úunbool)ÚoneZtwor	   r	   r
   Úequal¨   s    rV   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
   rT   ¯   s
    rT   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)rT   )r.   Úir	   r	   r
   r1   Å   s    zuniq.<locals>.<genexpr>c             s   s   | ]}t |ƒV  qd S )N)rT   )r.   rZ   r	   r	   r
   r1   È   s    r*   NFT)
r   rM   Ú	TypeErrorÚsortedÚ	itertoolsÚisliceÚzipÚNotImplementedErrorrT   rH   )Z	containerÚsortÚslicedrZ   ÚjÚseenÚer	   r	   r
   Úuniq»   s"    	
rf   )r*   )r]   r$   r!   r=   Zjsonschema.compatr   r   r   r   Úobjectr    r)   r5   r9   rB   rG   rL   rP   rS   rV   rT   rf   r	   r	   r	   r
   Ú<module>   s"   		
