HEX

File: //var/opt/nydus/ops/referencing/__pycache__/_core.cpython-39.pyc
a

�,�h�`�@s`UddlmZddlmZmZmZddlmZddlm	Z	m
Z
mZmZm
Z
ddlmZmZmZddlmZmZddlmZmZmZzddlmZWney�ddlmZYn0dd	lmZdd
lmZddl m!Z!m"Z#m$Z$m%Z%m&Z&e�Z'de(d
<e�Z)de(d<Gdd�de�Z*e*j+Z,Gdd�de
e$�Z-ddd�dd�Z.ddd�dd�Z/Gdd�d�Z0eGdd �d ee$��Z1e1d!d"d#�d$d#�d%d#�d&d#�d'�e1_2eGd(d)�d)ee$��Z3d*d+�d,d-�Z4eGd.d/�d/e%e!e3e$f��Z5ed0e#e	e3e	e3e	d1�Z6eGd2d3�d3ee$e6f��Z7eGd4d5�d5ee$��Z8eGd6d7�d7ee$��Z9eGd8d9�d9ee$��Z"d:S);�)�annotations)�Iterable�Iterator�Sequence)�Enum)�Any�Callable�ClassVar�Generic�Protocol)�unquote�	urldefrag�urljoin)�evolve�field)�HashTrieMap�HashTrieSet�List)�TypeVar)�
exceptions)�frozen)�URI�Anchor�D�Mapping�Retrieve�HashTrieSet[URI]�EMPTY_UNCRAWLED�	List[URI]�EMPTY_PREVIOUS_RESOLVERSc@seZdZdZdZdS)�_Unsetz
    What sillyness...
    �N)�__name__�
__module__�__qualname__�__doc__�SENTINEL�r'r'�B/opt/nydus/tmp/pip-target-wkfpz8uv/lib/python/referencing/_core.pyr sr c@s eZdZddddd�dd�ZdS)�_MaybeInSubresourcezSequence[int | str]�Resolver[D]�Resource[D])�segments�resolver�subresource�returncCsdS�Nr')�selfr,r-r.r'r'r(�__call__$sz_MaybeInSubresource.__call__N)r"r#r$r2r'r'r'r(r)#sr)r�Specification[D]��contentsr/cCsFt|t�st�|��|�d�}t|t�s2t�|��ddlm}||�S)N�$schemar��specification_with)�
isinstancerr�CannotDetermineSpecification�get�str�referencing.jsonschemar8�r5Zjsonschema_dialect_idr8r'r'r(�_detect_or_error,s




r?�Callable[[D], Specification[D]])�defaultr/csddd��fdd�}|S)Nrr3r4cs<t|t�s�S|�d�}|dur$�Sddlm}||�d�S)Nr6rr7�rA)r9rr;r=r8r>rBr'r(�_detect<s

�z#_detect_or_default.<locals>._detectr')rArCr'rBr(�_detect_or_default9srDc@seZdZdddd�dd�ZdS)�_SpecificationDetectorzSpecification[D] | Noneztype[Specification[D]]r@)�instance�clsr/cCs|durtSt|�SdSr0)r?rD)r1rFrGr'r'r(�__get__Osz_SpecificationDetector.__get__N)r"r#r$rHr'r'r'r(rENsrEc@s~eZdZUdZded<ded<ded<ded	<ed
d�Zded
<ded<e�Zdd�dd�Z	dd�dd�Z
ddd�dd�ZdS)�
Specificationz�
    A specification which defines referencing behavior.

    The various methods of a `Specification` allow for varying referencing
    behavior across JSON Schema specification versions, etc.
    r<�namezCallable[[D], URI | None]�id_ofzCallable[[D], Iterable[D]]�subresources_ofz_MaybeInSubresource[D]�maybe_in_subresource�
anchors_in��aliasz8Callable[[Specification[D], D], Iterable[AnchorType[D]]]�_anchors_inzClassVar[Specification[Any]]�OPAQUE�r/cCsd|j�d�S)Nz<Specification name=�>)rJ�r1r'r'r(�__repr__�szSpecification.__repr__r�r5cCs|�||�S)zG
        Retrieve the anchors contained in the given document.
        )rQ�r1r5r'r'r(rN�szSpecification.anchors_inr+r4cCst||d�S)zR
        Create a resource which is interpreted using this specification.
        )r5�
specification)�ResourcerXr'r'r(�create_resource�szSpecification.create_resourceN)r"r#r$r%�__annotations__rrQrE�detectrVrNr[r'r'r'r(rIZs
�
!rI�opaquecCsdSr0r'rWr'r'r(�<lambda>��r_cCsgSr0r'rWr'r'r(r_�r`cCsgSr0r')rYr5r'r'r(r_�r`cCs|Sr0r'�r,r-r.r'r'r(r_�r`)rJrKrLrNrMc@s�eZdZUdZded<edd�Zded<eefddd	d
�dd��Z	edd	d
�dd��Z
dd�dd�Zdd�dd�Zdd�dd�Z
dddd�dd�Zd S)!rZa�
    A document (deserialized JSON) with a concrete interpretation under a spec.

    In other words, a Python object, along with an instance of `Specification`
    which describes how the document interacts with referencing -- both
    internally (how it refers to other `Resource`\ s) and externally (how it
    should be identified such that it is referenceable by other documents).
    rr5rYrOr3�_specificationz)type[Specification[D]] | Specification[D]r+)r5�default_specificationr/cCs|�|�}|j|d�S)aG
        Create a resource guessing which specification applies to the contents.

        Raises:

            `CannotDetermineSpecification`

                if the given contents don't have any discernible
                information which could be used to guess which
                specification they identify as

        rW)r]r[)rGr5rcrYr'r'r(�
from_contents�s
zResource.from_contentsr4cCstjj|d�S)z�
        Create an opaque `Resource` -- i.e. one with opaque specification.

        See `Specification.OPAQUE` for details.
        rW)rIrRr[)rGr5r'r'r(r^�szResource.opaquez
URI | NonerScCs$|j�|j�}|durdS|�d�S)�O
        Retrieve this resource's (specification-specific) identifier.
        N�#)rbrKr5�rstrip)r1�idr'r'r(rh�szResource.idzIterable[Resource[D]]cs�fdd��j��j�D�S)z8
        Retrieve this resource's subresources.
        c3s|]}tj|�jd�VqdS))rcN)rZrdrb��.0�eachrUr'r(�	<genexpr>�s
��z(Resource.subresources.<locals>.<genexpr>)rbrLr5rUr'rUr(�subresources�s
�zResource.subresourceszIterable[AnchorType[D]]cCs|j�|j�S)re)rbrNr5rUr'r'r(�anchors�szResource.anchorsr<r*�Resolved[D])�pointerr-r/c	Cs�|st|j|d�S|j}g}t|dd���d�D]�}t|t�rJt|�}n|�dd��dd�}z||}Wn8ty�}z t	j
||d�}||�WYd}~n
d}~00|�|�|}|jj
|||j�|�d	�}||ur2g}q2t||d�S)
z�
        Resolve the given JSON pointer.

        Raises:

            `exceptions.PointerToNowhere`

                if the pointer points to a location not present in the document

        �r5r-r!N�/z~1z~0�~)�ref�resourcera)�Resolvedr5r�splitr9r�int�replace�LookupErrorrZPointerToNowhere�appendrbrMr[)	r1rpr-r5r,�segment�lookup_error�error�lastr'r'r(rp�s.



�zResource.pointerN)r"r#r$r%r\rrb�classmethodrIrdr^rhrmrnrpr'r'r'r(rZ�s
	�	rZr��uricCstj|d��dS)N�rt)r�NoSuchResourcer�r'r'r(�_fail_to_retrieve%sr�c@sTeZdZUdZee�ejdd�Zded<e�Z	ded<e
Zded	<eed
d�Z
ded
<ddd�dd�Zdd�dd�Zdd�dd�Zddd�dd�Zdd�d d!�Zdd"d�d#d$�Zdd%�d&d'�Zddd(�d)d*�Zdd+d�d,d-�Zdd�d.d/�Zddd0�d1d2�Zd3dd4�d5d6�Zd7d8dd9�d:d;�Zddd<�d=d>�ZdHdd@dA�dBdC�Zdd@dD�dEdF�ZdGS)I�Registryab
    A registry of `Resource`\ s, each identified by their canonical URIs.

    Registries store a collection of in-memory resources, and optionally
    enable additional resources which may be stored elsewhere (e.g. in a
    database, a separate set of files, over the network, etc.).

    They also lazily walk their known resources, looking for subresources
    within them. In other words, subresources contained within any added
    resources will be retrievable via their own IDs (though this discovery of
    subresources will be delayed until necessary).

    Registries are immutable, and their methods return new instances of the
    registry with the additional resources added to them.

    The ``retrieve`` argument can be used to configure retrieval of resources
    dynamically, either over the network, from a database, or the like.
    Pass it a callable which will be called if any URI not present in the
    registry is accessed. It must either return a `Resource` or else raise a
    `NoSuchResource` exception indicating that the resource does not exist
    even according to the retrieval logic.
    �	resources)rA�	converterrPzHashTrieMap[URI, Resource[D]]�
_resourcesz+HashTrieMap[tuple[URI, str], AnchorType[D]]�_anchorsr�
_uncrawled�retrieve)rArPzRetrieve[D]�	_retrieverr+)r�r/cCs8z|j|�d�WSty2tj|d�d�Yn0dS)zV
        Return the (already crawled) `Resource` identified by the given URI.
        rfr�N)r�rg�KeyErrorrr��r1r�r'r'r(�__getitem__KszRegistry.__getitem__z
Iterator[URI]rScCs
t|j�S)z@
        Iterate over all crawled URIs in the registry.
        )�iterr�rUr'r'r(�__iter__TszRegistry.__iter__rxcCs
t|j�S)zU
        Count the total number of fully crawled resources in this registry.
        )�lenr�rUr'r'r(�__len__ZszRegistry.__len__z#Resource[D] | Iterable[Resource[D]]�Registry[D])�newr/cCsft|t�r|f}|j}|j}|D]6}|��}|dur@tj|d��|�|�}|�||�}q t|||d�S)a2
        Create a new registry with resource(s) added using their internal IDs.

        Resources must have a internal IDs (e.g. the :kw:`$id` keyword in
        modern JSON Schema versions), otherwise an error will be raised.

        Both a single resource as well as an iterable of resources works, i.e.:

            * ``resource @ registry`` or

            * ``[iterable, of, multiple, resources] @ registry``

        which -- again, assuming the resources have internal IDs -- is
        equivalent to calling `Registry.with_resources` as such:

        .. code:: python

            registry.with_resources(
                (resource.id(), resource) for resource in new_resources
            )

        Raises:

            `NoInternalID`

                if the resource(s) in fact do not have IDs

        N)ru�r��	uncrawled)	r9rZr�r�rhrZNoInternalID�insertr)r1r�r�r�rurhr'r'r(�__rmatmul__`s 

zRegistry.__rmatmul__r<cCsft|�}|dkrdnd}|jrNt|j�}||kr<d|��}qT|�d|�d�}n|�}d|�d|�d	�S)
Nr!rur�z
uncrawled z, z
 uncrawledz<Registry (� z)>)r�r�)r1�sizeZ
pluralizedr��summaryr'r'r(rV�s
zRegistry.__repr__zRetrieved[D, Resource[D]]c
Cs�|j�|�}|dur t||d�S|��}|j�|�}|durHt||d�Sz|�|�}WnLtjtjfyr�YnJty�}ztj	|d�|�WYd}~n"d}~00|�
||�}t||d�SdS)aE
        Get a resource from the registry, crawling or retrieving if necessary.

        May involve crawling to find the given URI if it is not already known,
        so the returned object is a `Retrieved` object which contains both the
        resource value as well as the registry which ultimately contained it.
        N)�registry�valuer�)r�r;�	Retrieved�crawlr�rr:r��	Exception�
Unretrievable�
with_resource)r1r�rur�r~r'r'r(�get_or_retrieve�s$�
$zRegistry.get_or_retriever�csN�|jvrtj�d��t||j���|j���t�fdd�|j�	�D��d�S)zX
        Return a registry with the resource identified by a given URI removed.
        r�c3s&|]\}}|d�kr||fVqdS)rNr')rj�k�vr�r'r(rl�sz"Registry.remove.<locals>.<genexpr>)r�r�rn)
r�rr�r�remover��discardrr��itemsr�r'r�r(r��s


��zRegistry.remove)r�rJcCs�|j�||f�}|dur$t||d�S|��}|j�||f�}|durPt||d�S||}|��}|dur�|j�||f�}|dur�t||d�Sd|vr�tj|||d��tj|||d��dS)zX
        Retrieve a given anchor from a resource which must already be crawled.
        N)r�r�rr)rtru�anchor)r�r;r�r�rhrZ
InvalidAnchorZNoSuchAnchor)r1r�rJr�r�ruZ
canonical_urir'r'r(r��s(�zRegistry.anchorrcCs
||jS)zV
        Retrieve the (already crawled) contents identified by the given URI.
        rWr�r'r'r(r5�szRegistry.contentscs�|j�|j}�fdd�|jD�}|r�|��\�}|��}|durVt�|�����|��|��D]}|��|jf|�}q^|�	�fdd�|�
�D��q t|�|td�S)zF
        Crawl all added resources, discovering subresources.
        csg|]}|�|f�qSr'r')rjr�)r�r'r(�
<listcomp>�r`z"Registry.crawl.<locals>.<listcomp>Nc3s|]}�|fVqdSr0r'rir�r'r(rl�r`z!Registry.crawl.<locals>.<genexpr>)r�rnr�)
r�r�r��poprhrr�rnrJ�extendrmrr)r1rnr�rurhrkr')r�r�r(r��s$
�zRegistry.crawl)r�rucCs|�||fg�S)zP
        Add the given `Resource` to the registry, without crawling it.
        ��with_resources)r1r�rur'r'r(r�szRegistry.with_resourcez!Iterable[tuple[URI, Resource[D]]])�pairsr/cCsH|j}|j}|D](\}}|�d�}|�|�}|�||�}qt|||d�S)zU
        Add the given `Resource`\ s to the registry, without crawling them.
        rfr�)r�r�rgr�r)r1r�r�r�r�rur'r'r(r�s

zRegistry.with_resourceszIterable[tuple[URI, D]]r)r��kwargsr/cs|��fdd�|D��S)zW
        Add the given contents to the registry, autodetecting when necessary.
        c3s(|] \}}|tj|fi���fVqdSr0)rZrd)rjr�rk�r�r'r(rl!s�z)Registry.with_contents.<locals>.<genexpr>r�)r1r�r�r'r�r(�
with_contentss�zRegistry.with_contents)�
registriesr/cGs�||fkr|S|j}|j}|j}|j}|D]Z}|�|j�}|�|j�}|�|j�}|jtur*|j|urrtur~nntd��|j}q*t|||||d�S)zY
        Combine together one or more other registries, producing a unified one.
        z?Cannot combine registries with conflicting retrieval functions.)rnr�r�r�)r�r�r�r��updater��
ValueErrorr)r1r�r�rnr�r�r�r'r'r(�combine&s.

��zRegistry.combine�r*)�base_urir/cCst||d�S)zV
        Return a `Resolver` which resolves references against this registry.
        �r�r�)�Resolver)r1r�r'r'r(r-DszRegistry.resolver)rur/cCs |��p
d}t||�||�d�S)zD
        Return a `Resolver` with a specific root resource.
        r�r�)rhr�r�)r1rur�r'r'r(�resolver_with_rootJs

�zRegistry.resolver_with_rootN)r�)r"r#r$r%rr�convertr�r\r�rr�r�r�r�r�r�r�rVr�r�r�r5r�r�r�r�r�r-r�r'r'r'r(r�)s2
�	-

r��AnchorOrResourcerBc@s"eZdZUdZded<ded<dS)r�z.
    A value retrieved from a `Registry`.
    r�r�r�r�N�r"r#r$r%r\r'r'r'r(r�^s
r�c@s"eZdZUdZded<ded<dS)rvz?
    A reference resolved to its contents by a `Resolver`.
    rr5r*r-Nr�r'r'r'r(rvhs
rvc@s�eZdZUdZedd�Zded<edd�Zded<ee�d	d
d�Z	ded
<ddd�dd�Z
ddd�dd�Zdd�dd�Zddd�dd�Z
dS) r�a[
    A reference resolver.

    Resolvers help resolve references (including relative ones) by
    pairing a fixed base URI with a `Registry`.

    This object, under normal circumstances, is expected to be used by
    *implementers of libraries* built on top of `referencing` (e.g. JSON Schema
    implementations or other libraries resolving JSON references),
    not directly by end-users populating registries or while writing
    schemas or other resources.

    References are resolved against the base URI, and the combined URI
    is then looked up within the registry.

    The process of resolving a reference may itself involve calculating
    a *new* base URI for future reference resolution (e.g. if an
    intermediate resource sets a new base URI), or may involve encountering
    additional subresources and adding them to a new registry.
    r�rOr�	_base_urir�r��	_registryF�previous)rA�reprrPr�	_previousro)rtr/c
Cs|�d�r |j|dd�}}ntt|j|��\}}z|j�|�}WnTtjyftj|d�d�Yn4tj	y�}ztj|d�|�WYd}~n
d}~00|�d�r�|j
|j|d�}|jj
||d�S|r�|j�||�}|j
|j|d�}|jj|d�S|j
|j|d�}t|jj|d	�S)
a�
        Resolve the given reference to the resource it points to.

        Raises:

            `exceptions.Unresolvable`

                or a subclass thereof (see below) if the reference isn't
                resolvable

            `exceptions.NoSuchAnchor`

                if the reference is to a URI where a resource exists but
                contains a plain name fragment which does not exist within
                the resource

            `exceptions.PointerToNowhere`

                if the reference is to a URI where a resource exists but
                contains a JSON pointer to a location within the resource
                that does not exist

        rfr!Nr�rr)r�r�)rpr-�r-rq)�
startswithr�r
rr�r�rr�ZUnresolvabler��_evolver�r�rpr��resolvervr5)r1rtr��fragmentZ	retrievedr~r-r'r'r(�lookup�s$
$
zResolver.lookupr+r*)r.r/cCs(|��}|dur|St|t|j|�d�S)zV
        Create a resolver for a subresource (which may have a new base URI).
        N)r�)rhrrr�)r1r.rhr'r'r(�in_subresource�szResolver.in_subresourcez!Iterable[tuple[URI, Registry[D]]]rSccs|jD]}||jfVqdS)zT
        In specs with such a notion, return the URIs in the dynamic scope.
        N)r�r�r�r'r'r(�
dynamic_scope�s
zResolver.dynamic_scoper)r�r�cKs<|j}|jr&|r||jkr&|�|j�}t|f||d�|��S)z9
        Evolve, appending to the dynamic scope.
        )r�r�)r�r�Z
push_frontr)r1r�r�r�r'r'r(r��szResolver._evolveN)r"r#r$r%rr�r\r�rr�r�r�r�r�r'r'r'r(r�rs
/	r�c@s0eZdZUdZded<ded<dd�dd	�Zd
S)rz*
    A simple anchor in a `Resource`.
    r<rJr+rur*r�cCst|jj|d�S)z6
        Return the resource for this anchor.
        rq)rvrur5)r1r-r'r'r(r��szAnchor.resolveN)r"r#r$r%r\r�r'r'r'r(r�s
rN):�
__future__r�collections.abcrrr�enumr�typingrrr	r
r�urllib.parserr
r�attrsrrZrpdsrrrZtyping_extensionsr�ImportErrorZreferencingrZreferencing._attrsrZreferencing.typingrrZ
AnchorTyperrrrr\rr r&�_UNSETr)r?rDrErIrRrZr�r�r�r�rvr�r'r'r'r(�<module>sf	
Q�	o.�		c