jKjdZddlmZddlmZddlmZddlZddlmZddl m Z ddl m Z ee ee efZ e hd Zdd Z dd Z dd Zdd ZddZey)aCompatibility shim for the ``referencing`` library's private API. This module is the *only* place in jsonschema-path that touches ``referencing._core`` internals (the ``_base_uri``, ``_registry``, and ``_previous`` attributes on ``Resolver``). Every other module must go through the helpers here. The motivation is firewalling: if a future ``referencing`` release reshapes those internals, the breakage is contained to this file. The ``assert_referencing_layout`` call at import time also converts what would otherwise be silent wrong-results into a loud ``ImportError`` that names the issue, so version-skew bugs surface immediately. The helpers intentionally use ``Any``-typed generics because ``referencing`` does not expose ``Resolver`` / ``Resolved`` as ``attrs``-typed classes to type checkers, and ``Resolver._evolve`` itself is declared ``**kwargs: Any``. The runtime invariants are enforced by ``assert_referencing_layout``; ``mypy`` is asked to trust this single module. Supported ``referencing`` versions: the upper bound is pinned in ``pyproject.toml``; the lower bound is implied by these internals being ``attrs`` fields named ``_base_uri``, ``_registry``, and ``_previous``. ) annotations)Any)UnionN)Registry)Resolved)Resolver> _base_uri _previous _registryctjtDchc]}|j}}t|z }|r(t dt tdt |dycc}w)aVerify ``referencing.Resolver`` exposes the attrs fields we rebind. Called once at import time. Raises ``ImportError`` if the installed ``referencing`` is incompatible, instead of allowing rebind operations to silently produce wrong results. zyjsonschema-path is incompatible with the installed version of `referencing`. Expected `Resolver` attrs fields to include z ; missing zX. Pin `referencing` to a supported version (see jsonschema_path/_referencing_compat.py).N)attrsfieldsrname_REQUIRED_RESOLVER_FIELDS ImportErrorsorted)fieldrmissings t/Users/ahmed/devFolder/Ultron/claude-voice/.venv/lib/python3.12/site-packages/jsonschema_path/_referencing_compat.pyassert_referencing_layoutr)s\\(++E  + (&0G 789g D D   sA%c0tj||S)aReturn a new resolver identical to *resolver* but with *registry*. ``referencing.Registry`` instances are immutable and grow monotonically via ``with_resource``. A cached ``Resolver`` captured before the registry grew can be cheaply rebound to the latest registry without re-walking the schema, because: * The resolver's ``base_uri`` describes a document scope that the newer registry, being a superset, still contains. * ``Resolver._previous`` holds URIs (not resolver snapshots), and ``Resolver.dynamic_scope`` re-uses ``self._registry`` for every frame, so swapping the top resolver's registry rebinds the entire dynamic scope in one shot. Uses ``attrs.evolve`` rather than ``Resolver._evolve`` because the latter pushes onto the dynamic-scope stack when called with a differing ``base_uri``. We want a pure field replacement. )registry)r evolve)resolverrs rrebind_registryr?s, <<8 44cXt|jt|j|S)uReturn a new ``Resolved`` with the same ``contents`` but a resolver rebound to *registry*. Centralizing the ``Resolved(...)`` construction here keeps the ``call-arg`` type-ignore confined to a single line — production callers (``SchemaAccessor.get_resolved`` and ``CachedPathResolver._resolve_with_prefix_cache``) work in terms of this helper and don't have to construct ``Resolved`` themselves. )contentsr)rrrr)resolvedrs rrebind_resolvedr Xs* "" !2!2H= rcft|tr|jjS|jS)z3Return the registry backing a Resolved or Resolver.) isinstancerrr targets r registry_ofr%k(&(#(((   rcft|tr|jjS|jS)z.Return the base URI of a Resolved or Resolver.)r"rrr r#s r base_uri_ofr(rr&r)returnNone)r Resolver[Any]r Registry[Any]r)r+)r Resolved[Any]rr,r)r-)r$ResolvedOrResolverr)r,)r$r.r)str)__doc__ __future__rtypingrrr referencingrreferencing._corerrr. frozensetrrrr r%r(rrr7s2# &&8C=(3-78%&MN ,55552&r