claude-all-hands 1.0.0 → 1.0.2

package/.claude/envoy/.venv/lib/python3.9/site-packages/pydantic/_internal/_namespace_utils.py

@@ -1,293 +0,0 @@
-from __future__ import annotations
-
-import sys
-from collections.abc import Generator, Iterator, Mapping
-from contextlib import contextmanager
-from functools import cached_property
-from typing import Any, Callable, NamedTuple, TypeVar
-
-from typing_extensions import ParamSpec, TypeAlias, TypeAliasType, TypeVarTuple
-
-GlobalsNamespace: TypeAlias = 'dict[str, Any]'
-"""A global namespace.
-
-In most cases, this is a reference to the `__dict__` attribute of a module.
-This namespace type is expected as the `globals` argument during annotations evaluation.
-"""
-
-MappingNamespace: TypeAlias = Mapping[str, Any]
-"""Any kind of namespace.
-
-In most cases, this is a local namespace (e.g. the `__dict__` attribute of a class,
-the [`f_locals`][frame.f_locals] attribute of a frame object, when dealing with types
-defined inside functions).
-This namespace type is expected as the `locals` argument during annotations evaluation.
-"""
-
-_TypeVarLike: TypeAlias = 'TypeVar | ParamSpec | TypeVarTuple'
-
-
-class NamespacesTuple(NamedTuple):
-    """A tuple of globals and locals to be used during annotations evaluation.
-
-    This datastructure is defined as a named tuple so that it can easily be unpacked:
-
-    ```python {lint="skip" test="skip"}
-    def eval_type(typ: type[Any], ns: NamespacesTuple) -> None:
-        return eval(typ, *ns)
-    ```
-    """
-
-    globals: GlobalsNamespace
-    """The namespace to be used as the `globals` argument during annotations evaluation."""
-
-    locals: MappingNamespace
-    """The namespace to be used as the `locals` argument during annotations evaluation."""
-
-
-def get_module_ns_of(obj: Any) -> dict[str, Any]:
-    """Get the namespace of the module where the object is defined.
-
-    Caution: this function does not return a copy of the module namespace, so the result
-    should not be mutated. The burden of enforcing this is on the caller.
-    """
-    module_name = getattr(obj, '__module__', None)
-    if module_name:
-        try:
-            return sys.modules[module_name].__dict__
-        except KeyError:
-            # happens occasionally, see https://github.com/pydantic/pydantic/issues/2363
-            return {}
-    return {}
-
-
-# Note that this class is almost identical to `collections.ChainMap`, but need to enforce
-# immutable mappings here:
-class LazyLocalNamespace(Mapping[str, Any]):
-    """A lazily evaluated mapping, to be used as the `locals` argument during annotations evaluation.
-
-    While the [`eval`][eval] function expects a mapping as the `locals` argument, it only
-    performs `__getitem__` calls. The [`Mapping`][collections.abc.Mapping] abstract base class
-    is fully implemented only for type checking purposes.
-
-    Args:
-        *namespaces: The namespaces to consider, in ascending order of priority.
-
-    Example:
-        ```python {lint="skip" test="skip"}
-        ns = LazyLocalNamespace({'a': 1, 'b': 2}, {'a': 3})
-        ns['a']
-        #> 3
-        ns['b']
-        #> 2
-        ```
-    """
-
-    def __init__(self, *namespaces: MappingNamespace) -> None:
-        self._namespaces = namespaces
-
-    @cached_property
-    def data(self) -> dict[str, Any]:
-        return {k: v for ns in self._namespaces for k, v in ns.items()}
-
-    def __len__(self) -> int:
-        return len(self.data)
-
-    def __getitem__(self, key: str) -> Any:
-        return self.data[key]
-
-    def __contains__(self, key: object) -> bool:
-        return key in self.data
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self.data)
-
-
-def ns_for_function(obj: Callable[..., Any], parent_namespace: MappingNamespace | None = None) -> NamespacesTuple:
-    """Return the global and local namespaces to be used when evaluating annotations for the provided function.
-
-    The global namespace will be the `__dict__` attribute of the module the function was defined in.
-    The local namespace will contain the `__type_params__` introduced by PEP 695.
-
-    Args:
-        obj: The object to use when building namespaces.
-        parent_namespace: Optional namespace to be added with the lowest priority in the local namespace.
-            If the passed function is a method, the `parent_namespace` will be the namespace of the class
-            the method is defined in. Thus, we also fetch type `__type_params__` from there (i.e. the
-            class-scoped type variables).
-    """
-    locals_list: list[MappingNamespace] = []
-    if parent_namespace is not None:
-        locals_list.append(parent_namespace)
-
-    # Get the `__type_params__` attribute introduced by PEP 695.
-    # Note that the `typing._eval_type` function expects type params to be
-    # passed as a separate argument. However, internally, `_eval_type` calls
-    # `ForwardRef._evaluate` which will merge type params with the localns,
-    # essentially mimicking what we do here.
-    type_params: tuple[_TypeVarLike, ...] = getattr(obj, '__type_params__', ())
-    if parent_namespace is not None:
-        # We also fetch type params from the parent namespace. If present, it probably
-        # means the function was defined in a class. This is to support the following:
-        # https://github.com/python/cpython/issues/124089.
-        type_params += parent_namespace.get('__type_params__', ())
-
-    locals_list.append({t.__name__: t for t in type_params})
-
-    # What about short-circuiting to `obj.__globals__`?
-    globalns = get_module_ns_of(obj)
-
-    return NamespacesTuple(globalns, LazyLocalNamespace(*locals_list))
-
-
-class NsResolver:
-    """A class responsible for the namespaces resolving logic for annotations evaluation.
-
-    This class handles the namespace logic when evaluating annotations mainly for class objects.
-
-    It holds a stack of classes that are being inspected during the core schema building,
-    and the `types_namespace` property exposes the globals and locals to be used for
-    type annotation evaluation. Additionally -- if no class is present in the stack -- a
-    fallback globals and locals can be provided using the `namespaces_tuple` argument
-    (this is useful when generating a schema for a simple annotation, e.g. when using
-    `TypeAdapter`).
-
-    The namespace creation logic is unfortunately flawed in some cases, for backwards
-    compatibility reasons and to better support valid edge cases. See the description
-    for the `parent_namespace` argument and the example for more details.
-
-    Args:
-        namespaces_tuple: The default globals and locals to use if no class is present
-            on the stack. This can be useful when using the `GenerateSchema` class
-            with `TypeAdapter`, where the "type" being analyzed is a simple annotation.
-        parent_namespace: An optional parent namespace that will be added to the locals
-            with the lowest priority. For a given class defined in a function, the locals
-            of this function are usually used as the parent namespace:
-
-            ```python {lint="skip" test="skip"}
-            from pydantic import BaseModel
-
-            def func() -> None:
-                SomeType = int
-
-                class Model(BaseModel):
-                    f: 'SomeType'
-
-                # when collecting fields, an namespace resolver instance will be created
-                # this way:
-                # ns_resolver = NsResolver(parent_namespace={'SomeType': SomeType})
-            ```
-
-            For backwards compatibility reasons and to support valid edge cases, this parent
-            namespace will be used for *every* type being pushed to the stack. In the future,
-            we might want to be smarter by only doing so when the type being pushed is defined
-            in the same module as the parent namespace.
-
-    Example:
-        ```python {lint="skip" test="skip"}
-        ns_resolver = NsResolver(
-            parent_namespace={'fallback': 1},
-        )
-
-        class Sub:
-            m: 'Model'
-
-        class Model:
-            some_local = 1
-            sub: Sub
-
-        ns_resolver = NsResolver()
-
-        # This is roughly what happens when we build a core schema for `Model`:
-        with ns_resolver.push(Model):
-            ns_resolver.types_namespace
-            #> NamespacesTuple({'Sub': Sub}, {'Model': Model, 'some_local': 1})
-            # First thing to notice here, the model being pushed is added to the locals.
-            # Because `NsResolver` is being used during the model definition, it is not
-            # yet added to the globals. This is useful when resolving self-referencing annotations.
-
-            with ns_resolver.push(Sub):
-                ns_resolver.types_namespace
-                #> NamespacesTuple({'Sub': Sub}, {'Sub': Sub, 'Model': Model})
-                # Second thing to notice: `Sub` is present in both the globals and locals.
-                # This is not an issue, just that as described above, the model being pushed
-                # is added to the locals, but it happens to be present in the globals as well
-                # because it is already defined.
-                # Third thing to notice: `Model` is also added in locals. This is a backwards
-                # compatibility workaround that allows for `Sub` to be able to resolve `'Model'`
-                # correctly (as otherwise models would have to be rebuilt even though this
-                # doesn't look necessary).
-        ```
-    """
-
-    def __init__(
-        self,
-        namespaces_tuple: NamespacesTuple | None = None,
-        parent_namespace: MappingNamespace | None = None,
-    ) -> None:
-        self._base_ns_tuple = namespaces_tuple or NamespacesTuple({}, {})
-        self._parent_ns = parent_namespace
-        self._types_stack: list[type[Any] | TypeAliasType] = []
-
-    @cached_property
-    def types_namespace(self) -> NamespacesTuple:
-        """The current global and local namespaces to be used for annotations evaluation."""
-        if not self._types_stack:
-            # TODO: should we merge the parent namespace here?
-            # This is relevant for TypeAdapter, where there are no types on the stack, and we might
-            # need access to the parent_ns. Right now, we sidestep this in `type_adapter.py` by passing
-            # locals to both parent_ns and the base_ns_tuple, but this is a bit hacky.
-            # we might consider something like:
-            # if self._parent_ns is not None:
-            #     # Hacky workarounds, see class docstring:
-            #     # An optional parent namespace that will be added to the locals with the lowest priority
-            #     locals_list: list[MappingNamespace] = [self._parent_ns, self._base_ns_tuple.locals]
-            #     return NamespacesTuple(self._base_ns_tuple.globals, LazyLocalNamespace(*locals_list))
-            return self._base_ns_tuple
-
-        typ = self._types_stack[-1]
-
-        globalns = get_module_ns_of(typ)
-
-        locals_list: list[MappingNamespace] = []
-        # Hacky workarounds, see class docstring:
-        # An optional parent namespace that will be added to the locals with the lowest priority
-        if self._parent_ns is not None:
-            locals_list.append(self._parent_ns)
-        if len(self._types_stack) > 1:
-            first_type = self._types_stack[0]
-            locals_list.append({first_type.__name__: first_type})
-
-        # Adding `__type_params__` *before* `vars(typ)`, as the latter takes priority
-        # (see https://github.com/python/cpython/pull/120272).
-        # TODO `typ.__type_params__` when we drop support for Python 3.11:
-        type_params: tuple[_TypeVarLike, ...] = getattr(typ, '__type_params__', ())
-        if type_params:
-            # Adding `__type_params__` is mostly useful for generic classes defined using
-            # PEP 695 syntax *and* using forward annotations (see the example in
-            # https://github.com/python/cpython/issues/114053). For TypeAliasType instances,
-            # it is way less common, but still required if using a string annotation in the alias
-            # value, e.g. `type A[T] = 'T'` (which is not necessary in most cases).
-            locals_list.append({t.__name__: t for t in type_params})
-
-        # TypeAliasType instances don't have a `__dict__` attribute, so the check
-        # is necessary:
-        if hasattr(typ, '__dict__'):
-            locals_list.append(vars(typ))
-
-        # The `len(self._types_stack) > 1` check above prevents this from being added twice:
-        locals_list.append({typ.__name__: typ})
-
-        return NamespacesTuple(globalns, LazyLocalNamespace(*locals_list))
-
-    @contextmanager
-    def push(self, typ: type[Any] | TypeAliasType, /) -> Generator[None]:
-        """Push a type to the stack."""
-        self._types_stack.append(typ)
-        # Reset the cached property:
-        self.__dict__.pop('types_namespace', None)
-        try:
-            yield
-        finally:
-            self._types_stack.pop()
-            self.__dict__.pop('types_namespace', None)

package/.claude/envoy/.venv/lib/python3.9/site-packages/pydantic/_internal/_repr.py

@@ -1,124 +0,0 @@
-"""Tools to provide pretty/human-readable display of objects."""
-
-from __future__ import annotations as _annotations
-
-import types
-from collections.abc import Callable, Collection, Generator, Iterable
-from typing import TYPE_CHECKING, Any, ForwardRef, cast
-
-import typing_extensions
-from typing_extensions import TypeAlias
-from typing_inspection import typing_objects
-from typing_inspection.introspection import is_union_origin
-
-from . import _typing_extra
-
-if TYPE_CHECKING:
-    # TODO remove type error comments when we drop support for Python 3.9
-    ReprArgs: TypeAlias = Iterable[tuple[str | None, Any]]  # pyright: ignore[reportGeneralTypeIssues]
-    RichReprResult: TypeAlias = Iterable[Any | tuple[Any] | tuple[str, Any] | tuple[str, Any, Any]]  # pyright: ignore[reportGeneralTypeIssues]
-
-
-class PlainRepr(str):
-    """String class where repr doesn't include quotes. Useful with Representation when you want to return a string
-    representation of something that is valid (or pseudo-valid) python.
-    """
-
-    def __repr__(self) -> str:
-        return str(self)
-
-
-class Representation:
-    # Mixin to provide `__str__`, `__repr__`, and `__pretty__` and `__rich_repr__` methods.
-    # `__pretty__` is used by [devtools](https://python-devtools.helpmanual.io/).
-    # `__rich_repr__` is used by [rich](https://rich.readthedocs.io/en/stable/pretty.html).
-    # (this is not a docstring to avoid adding a docstring to classes which inherit from Representation)
-
-    __slots__ = ()
-
-    def __repr_args__(self) -> ReprArgs:
-        """Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
-
-        Can either return:
-        * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
-        * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
-        """
-        attrs_names = cast(Collection[str], self.__slots__)
-        if not attrs_names and hasattr(self, '__dict__'):
-            attrs_names = self.__dict__.keys()
-        attrs = ((s, getattr(self, s)) for s in attrs_names)
-        return [(a, v if v is not self else self.__repr_recursion__(v)) for a, v in attrs if v is not None]
-
-    def __repr_name__(self) -> str:
-        """Name of the instance's class, used in __repr__."""
-        return self.__class__.__name__
-
-    def __repr_recursion__(self, object: Any) -> str:
-        """Returns the string representation of a recursive object."""
-        # This is copied over from the stdlib `pprint` module:
-        return f'<Recursion on {type(object).__name__} with id={id(object)}>'
-
-    def __repr_str__(self, join_str: str) -> str:
-        return join_str.join(repr(v) if a is None else f'{a}={v!r}' for a, v in self.__repr_args__())
-
-    def __pretty__(self, fmt: Callable[[Any], Any], **kwargs: Any) -> Generator[Any]:
-        """Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects."""
-        yield self.__repr_name__() + '('
-        yield 1
-        for name, value in self.__repr_args__():
-            if name is not None:
-                yield name + '='
-            yield fmt(value)
-            yield ','
-            yield 0
-        yield -1
-        yield ')'
-
-    def __rich_repr__(self) -> RichReprResult:
-        """Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects."""
-        for name, field_repr in self.__repr_args__():
-            if name is None:
-                yield field_repr
-            else:
-                yield name, field_repr
-
-    def __str__(self) -> str:
-        return self.__repr_str__(' ')
-
-    def __repr__(self) -> str:
-        return f'{self.__repr_name__()}({self.__repr_str__(", ")})'
-
-
-def display_as_type(obj: Any) -> str:
-    """Pretty representation of a type, should be as close as possible to the original type definition string.
-
-    Takes some logic from `typing._type_repr`.
-    """
-    if isinstance(obj, (types.FunctionType, types.BuiltinFunctionType)):
-        return obj.__name__
-    elif obj is ...:
-        return '...'
-    elif isinstance(obj, Representation):
-        return repr(obj)
-    elif isinstance(obj, ForwardRef) or typing_objects.is_typealiastype(obj):
-        return str(obj)
-
-    if not isinstance(obj, (_typing_extra.typing_base, _typing_extra.WithArgsTypes, type)):
-        obj = obj.__class__
-
-    if is_union_origin(typing_extensions.get_origin(obj)):
-        args = ', '.join(map(display_as_type, typing_extensions.get_args(obj)))
-        return f'Union[{args}]'
-    elif isinstance(obj, _typing_extra.WithArgsTypes):
-        if typing_objects.is_literal(typing_extensions.get_origin(obj)):
-            args = ', '.join(map(repr, typing_extensions.get_args(obj)))
-        else:
-            args = ', '.join(map(display_as_type, typing_extensions.get_args(obj)))
-        try:
-            return f'{obj.__qualname__}[{args}]'
-        except AttributeError:
-            return str(obj).replace('typing.', '').replace('typing_extensions.', '')  # handles TypeAliasType in 3.12
-    elif isinstance(obj, type):
-        return obj.__qualname__
-    else:
-        return repr(obj).replace('typing.', '').replace('typing_extensions.', '')

package/.claude/envoy/.venv/lib/python3.9/site-packages/pydantic/_internal/_schema_gather.py

@@ -1,209 +0,0 @@
-# pyright: reportTypedDictNotRequiredAccess=false, reportGeneralTypeIssues=false, reportArgumentType=false, reportAttributeAccessIssue=false
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TypedDict
-
-from pydantic_core.core_schema import ComputedField, CoreSchema, DefinitionReferenceSchema, SerSchema
-from typing_extensions import TypeAlias
-
-AllSchemas: TypeAlias = 'CoreSchema | SerSchema | ComputedField'
-
-
-class GatherResult(TypedDict):
-    """Schema traversing result."""
-
-    collected_references: dict[str, DefinitionReferenceSchema | None]
-    """The collected definition references.
-
-    If a definition reference schema can be inlined, it means that there is
-    only one in the whole core schema. As such, it is stored as the value.
-    Otherwise, the value is set to `None`.
-    """
-
-    deferred_discriminator_schemas: list[CoreSchema]
-    """The list of core schemas having the discriminator application deferred."""
-
-
-class MissingDefinitionError(LookupError):
-    """A reference was pointing to a non-existing core schema."""
-
-    def __init__(self, schema_reference: str, /) -> None:
-        self.schema_reference = schema_reference
-
-
-@dataclass
-class GatherContext:
-    """The current context used during core schema traversing.
-
-    Context instances should only be used during schema traversing.
-    """
-
-    definitions: dict[str, CoreSchema]
-    """The available definitions."""
-
-    deferred_discriminator_schemas: list[CoreSchema] = field(init=False, default_factory=list)
-    """The list of core schemas having the discriminator application deferred.
-
-    Internally, these core schemas have a specific key set in the core metadata dict.
-    """
-
-    collected_references: dict[str, DefinitionReferenceSchema | None] = field(init=False, default_factory=dict)
-    """The collected definition references.
-
-    If a definition reference schema can be inlined, it means that there is
-    only one in the whole core schema. As such, it is stored as the value.
-    Otherwise, the value is set to `None`.
-
-    During schema traversing, definition reference schemas can be added as candidates, or removed
-    (by setting the value to `None`).
-    """
-
-
-def traverse_metadata(schema: AllSchemas, ctx: GatherContext) -> None:
-    meta = schema.get('metadata')
-    if meta is not None and 'pydantic_internal_union_discriminator' in meta:
-        ctx.deferred_discriminator_schemas.append(schema)  # pyright: ignore[reportArgumentType]
-
-
-def traverse_definition_ref(def_ref_schema: DefinitionReferenceSchema, ctx: GatherContext) -> None:
-    schema_ref = def_ref_schema['schema_ref']
-
-    if schema_ref not in ctx.collected_references:
-        definition = ctx.definitions.get(schema_ref)
-        if definition is None:
-            raise MissingDefinitionError(schema_ref)
-
-        # The `'definition-ref'` schema was only encountered once, make it
-        # a candidate to be inlined:
-        ctx.collected_references[schema_ref] = def_ref_schema
-        traverse_schema(definition, ctx)
-        if 'serialization' in def_ref_schema:
-            traverse_schema(def_ref_schema['serialization'], ctx)
-        traverse_metadata(def_ref_schema, ctx)
-    else:
-        # The `'definition-ref'` schema was already encountered, meaning
-        # the previously encountered schema (and this one) can't be inlined:
-        ctx.collected_references[schema_ref] = None
-
-
-def traverse_schema(schema: AllSchemas, context: GatherContext) -> None:
-    # TODO When we drop 3.9, use a match statement to get better type checking and remove
-    # file-level type ignore.
-    # (the `'type'` could also be fetched in every `if/elif` statement, but this alters performance).
-    schema_type = schema['type']
-
-    if schema_type == 'definition-ref':
-        traverse_definition_ref(schema, context)
-        # `traverse_definition_ref` handles the possible serialization and metadata schemas:
-        return
-    elif schema_type == 'definitions':
-        traverse_schema(schema['schema'], context)
-        for definition in schema['definitions']:
-            traverse_schema(definition, context)
-    elif schema_type in {'list', 'set', 'frozenset', 'generator'}:
-        if 'items_schema' in schema:
-            traverse_schema(schema['items_schema'], context)
-    elif schema_type == 'tuple':
-        if 'items_schema' in schema:
-            for s in schema['items_schema']:
-                traverse_schema(s, context)
-    elif schema_type == 'dict':
-        if 'keys_schema' in schema:
-            traverse_schema(schema['keys_schema'], context)
-        if 'values_schema' in schema:
-            traverse_schema(schema['values_schema'], context)
-    elif schema_type == 'union':
-        for choice in schema['choices']:
-            if isinstance(choice, tuple):
-                traverse_schema(choice[0], context)
-            else:
-                traverse_schema(choice, context)
-    elif schema_type == 'tagged-union':
-        for v in schema['choices'].values():
-            traverse_schema(v, context)
-    elif schema_type == 'chain':
-        for step in schema['steps']:
-            traverse_schema(step, context)
-    elif schema_type == 'lax-or-strict':
-        traverse_schema(schema['lax_schema'], context)
-        traverse_schema(schema['strict_schema'], context)
-    elif schema_type == 'json-or-python':
-        traverse_schema(schema['json_schema'], context)
-        traverse_schema(schema['python_schema'], context)
-    elif schema_type in {'model-fields', 'typed-dict'}:
-        if 'extras_schema' in schema:
-            traverse_schema(schema['extras_schema'], context)
-        if 'computed_fields' in schema:
-            for s in schema['computed_fields']:
-                traverse_schema(s, context)
-        for s in schema['fields'].values():
-            traverse_schema(s, context)
-    elif schema_type == 'dataclass-args':
-        if 'computed_fields' in schema:
-            for s in schema['computed_fields']:
-                traverse_schema(s, context)
-        for s in schema['fields']:
-            traverse_schema(s, context)
-    elif schema_type == 'arguments':
-        for s in schema['arguments_schema']:
-            traverse_schema(s['schema'], context)
-        if 'var_args_schema' in schema:
-            traverse_schema(schema['var_args_schema'], context)
-        if 'var_kwargs_schema' in schema:
-            traverse_schema(schema['var_kwargs_schema'], context)
-    elif schema_type == 'arguments-v3':
-        for s in schema['arguments_schema']:
-            traverse_schema(s['schema'], context)
-    elif schema_type == 'call':
-        traverse_schema(schema['arguments_schema'], context)
-        if 'return_schema' in schema:
-            traverse_schema(schema['return_schema'], context)
-    elif schema_type == 'computed-field':
-        traverse_schema(schema['return_schema'], context)
-    elif schema_type == 'function-before':
-        if 'schema' in schema:
-            traverse_schema(schema['schema'], context)
-        if 'json_schema_input_schema' in schema:
-            traverse_schema(schema['json_schema_input_schema'], context)
-    elif schema_type == 'function-plain':
-        # TODO duplicate schema types for serializers and validators, needs to be deduplicated.
-        if 'return_schema' in schema:
-            traverse_schema(schema['return_schema'], context)
-        if 'json_schema_input_schema' in schema:
-            traverse_schema(schema['json_schema_input_schema'], context)
-    elif schema_type == 'function-wrap':
-        # TODO duplicate schema types for serializers and validators, needs to be deduplicated.
-        if 'return_schema' in schema:
-            traverse_schema(schema['return_schema'], context)
-        if 'schema' in schema:
-            traverse_schema(schema['schema'], context)
-        if 'json_schema_input_schema' in schema:
-            traverse_schema(schema['json_schema_input_schema'], context)
-    else:
-        if 'schema' in schema:
-            traverse_schema(schema['schema'], context)
-
-    if 'serialization' in schema:
-        traverse_schema(schema['serialization'], context)
-    traverse_metadata(schema, context)
-
-
-def gather_schemas_for_cleaning(schema: CoreSchema, definitions: dict[str, CoreSchema]) -> GatherResult:
-    """Traverse the core schema and definitions and return the necessary information for schema cleaning.
-
-    During the core schema traversing, any `'definition-ref'` schema is:
-
-    - Validated: the reference must point to an existing definition. If this is not the case, a
-      `MissingDefinitionError` exception is raised.
-    - Stored in the context: the actual reference is stored in the context. Depending on whether
-      the `'definition-ref'` schema is encountered more that once, the schema itself is also
-      saved in the context to be inlined (i.e. replaced by the definition it points to).
-    """
-    context = GatherContext(definitions)
-    traverse_schema(schema, context)
-
-    return {
-        'collected_references': context.collected_references,
-        'deferred_discriminator_schemas': context.deferred_discriminator_schemas,
-    }