claude-all-hands 1.0.0 → 1.0.2

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

@@ -1,413 +0,0 @@
-"""Provide an enhanced dataclass that performs validation."""
-
-from __future__ import annotations as _annotations
-
-import dataclasses
-import functools
-import sys
-import types
-from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, NoReturn, TypeVar, overload
-from warnings import warn
-
-from typing_extensions import TypeGuard, dataclass_transform
-
-from ._internal import _config, _decorators, _mock_val_ser, _namespace_utils, _typing_extra
-from ._internal import _dataclasses as _pydantic_dataclasses
-from ._migration import getattr_migration
-from .config import ConfigDict
-from .errors import PydanticUserError
-from .fields import Field, FieldInfo, PrivateAttr
-
-if TYPE_CHECKING:
-    from ._internal._dataclasses import PydanticDataclass
-    from ._internal._namespace_utils import MappingNamespace
-
-__all__ = 'dataclass', 'rebuild_dataclass'
-
-_T = TypeVar('_T')
-
-if sys.version_info >= (3, 10):
-
-    @dataclass_transform(field_specifiers=(dataclasses.field, Field, PrivateAttr))
-    @overload
-    def dataclass(
-        *,
-        init: Literal[False] = False,
-        repr: bool = True,
-        eq: bool = True,
-        order: bool = False,
-        unsafe_hash: bool = False,
-        frozen: bool = False,
-        config: ConfigDict | type[object] | None = None,
-        validate_on_init: bool | None = None,
-        kw_only: bool = ...,
-        slots: bool = ...,
-    ) -> Callable[[type[_T]], type[PydanticDataclass]]:  # type: ignore
-        ...
-
-    @dataclass_transform(field_specifiers=(dataclasses.field, Field, PrivateAttr))
-    @overload
-    def dataclass(
-        _cls: type[_T],  # type: ignore
-        *,
-        init: Literal[False] = False,
-        repr: bool = True,
-        eq: bool = True,
-        order: bool = False,
-        unsafe_hash: bool = False,
-        frozen: bool | None = None,
-        config: ConfigDict | type[object] | None = None,
-        validate_on_init: bool | None = None,
-        kw_only: bool = ...,
-        slots: bool = ...,
-    ) -> type[PydanticDataclass]: ...
-
-else:
-
-    @dataclass_transform(field_specifiers=(dataclasses.field, Field, PrivateAttr))
-    @overload
-    def dataclass(
-        *,
-        init: Literal[False] = False,
-        repr: bool = True,
-        eq: bool = True,
-        order: bool = False,
-        unsafe_hash: bool = False,
-        frozen: bool | None = None,
-        config: ConfigDict | type[object] | None = None,
-        validate_on_init: bool | None = None,
-    ) -> Callable[[type[_T]], type[PydanticDataclass]]:  # type: ignore
-        ...
-
-    @dataclass_transform(field_specifiers=(dataclasses.field, Field, PrivateAttr))
-    @overload
-    def dataclass(
-        _cls: type[_T],  # type: ignore
-        *,
-        init: Literal[False] = False,
-        repr: bool = True,
-        eq: bool = True,
-        order: bool = False,
-        unsafe_hash: bool = False,
-        frozen: bool | None = None,
-        config: ConfigDict | type[object] | None = None,
-        validate_on_init: bool | None = None,
-    ) -> type[PydanticDataclass]: ...
-
-
-@dataclass_transform(field_specifiers=(dataclasses.field, Field, PrivateAttr))
-def dataclass(
-    _cls: type[_T] | None = None,
-    *,
-    init: Literal[False] = False,
-    repr: bool = True,
-    eq: bool = True,
-    order: bool = False,
-    unsafe_hash: bool = False,
-    frozen: bool | None = None,
-    config: ConfigDict | type[object] | None = None,
-    validate_on_init: bool | None = None,
-    kw_only: bool = False,
-    slots: bool = False,
-) -> Callable[[type[_T]], type[PydanticDataclass]] | type[PydanticDataclass]:
-    """!!! abstract "Usage Documentation"
-        [`dataclasses`](../concepts/dataclasses.md)
-
-    A decorator used to create a Pydantic-enhanced dataclass, similar to the standard Python `dataclass`,
-    but with added validation.
-
-    This function should be used similarly to `dataclasses.dataclass`.
-
-    Args:
-        _cls: The target `dataclass`.
-        init: Included for signature compatibility with `dataclasses.dataclass`, and is passed through to
-            `dataclasses.dataclass` when appropriate. If specified, must be set to `False`, as pydantic inserts its
-            own  `__init__` function.
-        repr: A boolean indicating whether to include the field in the `__repr__` output.
-        eq: Determines if a `__eq__` method should be generated for the class.
-        order: Determines if comparison magic methods should be generated, such as `__lt__`, but not `__eq__`.
-        unsafe_hash: Determines if a `__hash__` method should be included in the class, as in `dataclasses.dataclass`.
-        frozen: Determines if the generated class should be a 'frozen' `dataclass`, which does not allow its
-            attributes to be modified after it has been initialized. If not set, the value from the provided `config` argument will be used (and will default to `False` otherwise).
-        config: The Pydantic config to use for the `dataclass`.
-        validate_on_init: A deprecated parameter included for backwards compatibility; in V2, all Pydantic dataclasses
-            are validated on init.
-        kw_only: Determines if `__init__` method parameters must be specified by keyword only. Defaults to `False`.
-        slots: Determines if the generated class should be a 'slots' `dataclass`, which does not allow the addition of
-            new attributes after instantiation.
-
-    Returns:
-        A decorator that accepts a class as its argument and returns a Pydantic `dataclass`.
-
-    Raises:
-        AssertionError: Raised if `init` is not `False` or `validate_on_init` is `False`.
-    """
-    assert init is False, 'pydantic.dataclasses.dataclass only supports init=False'
-    assert validate_on_init is not False, 'validate_on_init=False is no longer supported'
-
-    if sys.version_info >= (3, 10):
-        kwargs = {'kw_only': kw_only, 'slots': slots}
-    else:
-        kwargs = {}
-
-    def create_dataclass(cls: type[Any]) -> type[PydanticDataclass]:
-        """Create a Pydantic dataclass from a regular dataclass.
-
-        Args:
-            cls: The class to create the Pydantic dataclass from.
-
-        Returns:
-            A Pydantic dataclass.
-        """
-        from ._internal._utils import is_model_class
-
-        if is_model_class(cls):
-            raise PydanticUserError(
-                f'Cannot create a Pydantic dataclass from {cls.__name__} as it is already a Pydantic model',
-                code='dataclass-on-model',
-            )
-
-        original_cls = cls
-
-        # we warn on conflicting config specifications, but only if the class doesn't have a dataclass base
-        # because a dataclass base might provide a __pydantic_config__ attribute that we don't want to warn about
-        has_dataclass_base = any(dataclasses.is_dataclass(base) for base in cls.__bases__)
-        if not has_dataclass_base and config is not None and hasattr(cls, '__pydantic_config__'):
-            warn(
-                f'`config` is set via both the `dataclass` decorator and `__pydantic_config__` for dataclass {cls.__name__}. '
-                f'The `config` specification from `dataclass` decorator will take priority.',
-                category=UserWarning,
-                stacklevel=2,
-            )
-
-        # if config is not explicitly provided, try to read it from the type
-        config_dict = config if config is not None else getattr(cls, '__pydantic_config__', None)
-        config_wrapper = _config.ConfigWrapper(config_dict)
-        decorators = _decorators.DecoratorInfos.build(cls)
-        decorators.update_from_config(config_wrapper)
-
-        # Keep track of the original __doc__ so that we can restore it after applying the dataclasses decorator
-        # Otherwise, classes with no __doc__ will have their signature added into the JSON schema description,
-        # since dataclasses.dataclass will set this as the __doc__
-        original_doc = cls.__doc__
-
-        if _pydantic_dataclasses.is_stdlib_dataclass(cls):
-            # Vanilla dataclasses include a default docstring (representing the class signature),
-            # which we don't want to preserve.
-            original_doc = None
-
-            # We don't want to add validation to the existing std lib dataclass, so we will subclass it
-            #   If the class is generic, we need to make sure the subclass also inherits from Generic
-            #   with all the same parameters.
-            bases = (cls,)
-            if issubclass(cls, Generic):
-                generic_base = Generic[cls.__parameters__]  # type: ignore
-                bases = bases + (generic_base,)
-            cls = types.new_class(cls.__name__, bases)
-
-        # Respect frozen setting from dataclass constructor and fallback to config setting if not provided
-        if frozen is not None:
-            frozen_ = frozen
-            if config_wrapper.frozen:
-                # It's not recommended to define both, as the setting from the dataclass decorator will take priority.
-                warn(
-                    f'`frozen` is set via both the `dataclass` decorator and `config` for dataclass {cls.__name__!r}.'
-                    'This is not recommended. The `frozen` specification on `dataclass` will take priority.',
-                    category=UserWarning,
-                    stacklevel=2,
-                )
-        else:
-            frozen_ = config_wrapper.frozen or False
-
-        # Make Pydantic's `Field()` function compatible with stdlib dataclasses. As we'll decorate
-        # `cls` with the stdlib `@dataclass` decorator first, there are two attributes, `kw_only` and
-        # `repr` that need to be understood *during* the stdlib creation. We do so in two steps:
-
-        # 1. On the decorated class, wrap `Field()` assignment with `dataclass.field()`, with the
-        # two attributes set (done in `as_dataclass_field()`)
-        cls_anns = _typing_extra.safe_get_annotations(cls)
-        for field_name in cls_anns:
-            # We should look for assignments in `__dict__` instead, but for now we follow
-            # the same behavior as stdlib dataclasses (see https://github.com/python/cpython/issues/88609)
-            field_value = getattr(cls, field_name, None)
-            if isinstance(field_value, FieldInfo):
-                setattr(cls, field_name, _pydantic_dataclasses.as_dataclass_field(field_value))
-
-        # 2. For bases of `cls` that are stdlib dataclasses, we temporarily patch their fields
-        # (see the docstring of the context manager):
-        with _pydantic_dataclasses.patch_base_fields(cls):
-            cls = dataclasses.dataclass(  # pyright: ignore[reportCallIssue]
-                cls,
-                # the value of init here doesn't affect anything except that it makes it easier to generate a signature
-                init=True,
-                repr=repr,
-                eq=eq,
-                order=order,
-                unsafe_hash=unsafe_hash,
-                frozen=frozen_,
-                **kwargs,
-            )
-
-        if config_wrapper.validate_assignment:
-            original_setattr = cls.__setattr__
-
-            @functools.wraps(cls.__setattr__)
-            def validated_setattr(instance: PydanticDataclass, name: str, value: Any, /) -> None:
-                if frozen_:
-                    return original_setattr(instance, name, value)  # pyright: ignore[reportCallIssue]
-                inst_cls = type(instance)
-                attr = getattr(inst_cls, name, None)
-
-                if isinstance(attr, property):
-                    attr.__set__(instance, value)
-                elif isinstance(attr, functools.cached_property):
-                    instance.__dict__.__setitem__(name, value)
-                else:
-                    inst_cls.__pydantic_validator__.validate_assignment(instance, name, value)
-
-            cls.__setattr__ = validated_setattr.__get__(None, cls)  # type: ignore
-
-            if slots and not hasattr(cls, '__setstate__'):
-                # If slots is set, `pickle` (relied on by `copy.copy()`) will use
-                # `__setattr__()` to reconstruct the dataclass. However, the custom
-                # `__setattr__()` set above relies on `validate_assignment()`, which
-                # in turn expects all the field values to be already present on the
-                # instance, resulting in attribute errors.
-                # As such, we make use of `object.__setattr__()` instead.
-                # Note that we do so only if `__setstate__()` isn't already set (this is the
-                # case if on top of `slots`, `frozen` is used).
-
-                # Taken from `dataclasses._dataclass_get/setstate()`:
-                def _dataclass_getstate(self: Any) -> list[Any]:
-                    return [getattr(self, f.name) for f in dataclasses.fields(self)]
-
-                def _dataclass_setstate(self: Any, state: list[Any]) -> None:
-                    for field, value in zip(dataclasses.fields(self), state):
-                        object.__setattr__(self, field.name, value)
-
-                cls.__getstate__ = _dataclass_getstate  # pyright: ignore[reportAttributeAccessIssue]
-                cls.__setstate__ = _dataclass_setstate  # pyright: ignore[reportAttributeAccessIssue]
-
-        # This is an undocumented attribute to distinguish stdlib/Pydantic dataclasses.
-        # It should be set as early as possible:
-        cls.__is_pydantic_dataclass__ = True
-        cls.__pydantic_decorators__ = decorators  # type: ignore
-        cls.__doc__ = original_doc
-        # Can be non-existent for dynamically created classes:
-        firstlineno = getattr(original_cls, '__firstlineno__', None)
-        cls.__module__ = original_cls.__module__
-        if sys.version_info >= (3, 13) and firstlineno is not None:
-            # As per https://docs.python.org/3/reference/datamodel.html#type.__firstlineno__:
-            # Setting the `__module__` attribute removes the `__firstlineno__` item from the type’s dictionary.
-            original_cls.__firstlineno__ = firstlineno
-            cls.__firstlineno__ = firstlineno
-        cls.__qualname__ = original_cls.__qualname__
-        cls.__pydantic_fields_complete__ = classmethod(_pydantic_fields_complete)
-        cls.__pydantic_complete__ = False  # `complete_dataclass` will set it to `True` if successful.
-        # TODO `parent_namespace` is currently None, but we could do the same thing as Pydantic models:
-        # fetch the parent ns using `parent_frame_namespace` (if the dataclass was defined in a function),
-        # and possibly cache it (see the `__pydantic_parent_namespace__` logic for models).
-        _pydantic_dataclasses.complete_dataclass(cls, config_wrapper, raise_errors=False)
-        return cls
-
-    return create_dataclass if _cls is None else create_dataclass(_cls)
-
-
-def _pydantic_fields_complete(cls: type[PydanticDataclass]) -> bool:
-    """Return whether the fields where successfully collected (i.e. type hints were successfully resolves).
-
-    This is a private property, not meant to be used outside Pydantic.
-    """
-    return all(field_info._complete for field_info in cls.__pydantic_fields__.values())
-
-
-__getattr__ = getattr_migration(__name__)
-
-if sys.version_info < (3, 11):
-    # Monkeypatch dataclasses.InitVar so that typing doesn't error if it occurs as a type when evaluating type hints
-    # Starting in 3.11, typing.get_type_hints will not raise an error if the retrieved type hints are not callable.
-
-    def _call_initvar(*args: Any, **kwargs: Any) -> NoReturn:
-        """This function does nothing but raise an error that is as similar as possible to what you'd get
-        if you were to try calling `InitVar[int]()` without this monkeypatch. The whole purpose is just
-        to ensure typing._type_check does not error if the type hint evaluates to `InitVar[<parameter>]`.
-        """
-        raise TypeError("'InitVar' object is not callable")
-
-    dataclasses.InitVar.__call__ = _call_initvar
-
-
-def rebuild_dataclass(
-    cls: type[PydanticDataclass],
-    *,
-    force: bool = False,
-    raise_errors: bool = True,
-    _parent_namespace_depth: int = 2,
-    _types_namespace: MappingNamespace | None = None,
-) -> bool | None:
-    """Try to rebuild the pydantic-core schema for the dataclass.
-
-    This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
-    the initial attempt to build the schema, and automatic rebuilding fails.
-
-    This is analogous to `BaseModel.model_rebuild`.
-
-    Args:
-        cls: The class to rebuild the pydantic-core schema for.
-        force: Whether to force the rebuilding of the schema, defaults to `False`.
-        raise_errors: Whether to raise errors, defaults to `True`.
-        _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
-        _types_namespace: The types namespace, defaults to `None`.
-
-    Returns:
-        Returns `None` if the schema is already "complete" and rebuilding was not required.
-        If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
-    """
-    if not force and cls.__pydantic_complete__:
-        return None
-
-    for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'):
-        if attr in cls.__dict__ and not isinstance(getattr(cls, attr), _mock_val_ser.MockValSer):
-            # Deleting the validator/serializer is necessary as otherwise they can get reused in
-            # pydantic-core. Same applies for the core schema that can be reused in schema generation.
-            delattr(cls, attr)
-
-    cls.__pydantic_complete__ = False
-
-    if _types_namespace is not None:
-        rebuild_ns = _types_namespace
-    elif _parent_namespace_depth > 0:
-        rebuild_ns = _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth, force=True) or {}
-    else:
-        rebuild_ns = {}
-
-    ns_resolver = _namespace_utils.NsResolver(
-        parent_namespace=rebuild_ns,
-    )
-
-    return _pydantic_dataclasses.complete_dataclass(
-        cls,
-        _config.ConfigWrapper(cls.__pydantic_config__, check=False),
-        raise_errors=raise_errors,
-        ns_resolver=ns_resolver,
-        # We could provide a different config instead (with `'defer_build'` set to `True`)
-        # of this explicit `_force_build` argument, but because config can come from the
-        # decorator parameter or the `__pydantic_config__` attribute, `complete_dataclass`
-        # will overwrite `__pydantic_config__` with the provided config above:
-        _force_build=True,
-    )
-
-
-def is_pydantic_dataclass(class_: type[Any], /) -> TypeGuard[type[PydanticDataclass]]:
-    """Whether a class is a pydantic dataclass.
-
-    Args:
-        class_: The class.
-
-    Returns:
-        `True` if the class is a pydantic dataclass, `False` otherwise.
-    """
-    try:
-        return '__is_pydantic_dataclass__' in class_.__dict__ and dataclasses.is_dataclass(class_)
-    except AttributeError:
-        return False

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

@@ -1,5 +0,0 @@
-"""The `datetime_parse` module is a backport module from V1."""
-
-from ._migration import getattr_migration
-
-__getattr__ = getattr_migration(__name__)

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

@@ -1,5 +0,0 @@
-"""The `decorator` module is a backport module from V1."""
-
-from ._migration import getattr_migration
-
-__getattr__ = getattr_migration(__name__)

package/.claude/envoy/.venv/lib/python3.9/site-packages/pydantic/deprecated/class_validators.py

@@ -1,256 +0,0 @@
-"""Old `@validator` and `@root_validator` function validators from V1."""
-
-from __future__ import annotations as _annotations
-
-from functools import partial, partialmethod
-from types import FunctionType
-from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar, Union, overload
-from warnings import warn
-
-from typing_extensions import Protocol, TypeAlias, deprecated
-
-from .._internal import _decorators, _decorators_v1
-from ..errors import PydanticUserError
-from ..warnings import PydanticDeprecatedSince20
-
-_ALLOW_REUSE_WARNING_MESSAGE = '`allow_reuse` is deprecated and will be ignored; it should no longer be necessary'
-
-
-if TYPE_CHECKING:
-
-    class _OnlyValueValidatorClsMethod(Protocol):
-        def __call__(self, __cls: Any, __value: Any) -> Any: ...
-
-    class _V1ValidatorWithValuesClsMethod(Protocol):
-        def __call__(self, __cls: Any, __value: Any, values: dict[str, Any]) -> Any: ...
-
-    class _V1ValidatorWithValuesKwOnlyClsMethod(Protocol):
-        def __call__(self, __cls: Any, __value: Any, *, values: dict[str, Any]) -> Any: ...
-
-    class _V1ValidatorWithKwargsClsMethod(Protocol):
-        def __call__(self, __cls: Any, **kwargs: Any) -> Any: ...
-
-    class _V1ValidatorWithValuesAndKwargsClsMethod(Protocol):
-        def __call__(self, __cls: Any, values: dict[str, Any], **kwargs: Any) -> Any: ...
-
-    class _V1RootValidatorClsMethod(Protocol):
-        def __call__(
-            self, __cls: Any, __values: _decorators_v1.RootValidatorValues
-        ) -> _decorators_v1.RootValidatorValues: ...
-
-    V1Validator = Union[
-        _OnlyValueValidatorClsMethod,
-        _V1ValidatorWithValuesClsMethod,
-        _V1ValidatorWithValuesKwOnlyClsMethod,
-        _V1ValidatorWithKwargsClsMethod,
-        _V1ValidatorWithValuesAndKwargsClsMethod,
-        _decorators_v1.V1ValidatorWithValues,
-        _decorators_v1.V1ValidatorWithValuesKwOnly,
-        _decorators_v1.V1ValidatorWithKwargs,
-        _decorators_v1.V1ValidatorWithValuesAndKwargs,
-    ]
-
-    V1RootValidator = Union[
-        _V1RootValidatorClsMethod,
-        _decorators_v1.V1RootValidatorFunction,
-    ]
-
-    _PartialClsOrStaticMethod: TypeAlias = Union[classmethod[Any, Any, Any], staticmethod[Any, Any], partialmethod[Any]]
-
-    # Allow both a V1 (assumed pre=False) or V2 (assumed mode='after') validator
-    # We lie to type checkers and say we return the same thing we get
-    # but in reality we return a proxy object that _mostly_ behaves like the wrapped thing
-    _V1ValidatorType = TypeVar('_V1ValidatorType', V1Validator, _PartialClsOrStaticMethod)
-    _V1RootValidatorFunctionType = TypeVar(
-        '_V1RootValidatorFunctionType',
-        _decorators_v1.V1RootValidatorFunction,
-        _V1RootValidatorClsMethod,
-        _PartialClsOrStaticMethod,
-    )
-else:
-    # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915
-    # and https://youtrack.jetbrains.com/issue/PY-51428
-    DeprecationWarning = PydanticDeprecatedSince20
-
-
-@deprecated(
-    'Pydantic V1 style `@validator` validators are deprecated.'
-    ' You should migrate to Pydantic V2 style `@field_validator` validators,'
-    ' see the migration guide for more details',
-    category=None,
-)
-def validator(
-    __field: str,
-    *fields: str,
-    pre: bool = False,
-    each_item: bool = False,
-    always: bool = False,
-    check_fields: bool | None = None,
-    allow_reuse: bool = False,
-) -> Callable[[_V1ValidatorType], _V1ValidatorType]:
-    """Decorate methods on the class indicating that they should be used to validate fields.
-
-    Args:
-        __field (str): The first field the validator should be called on; this is separate
-            from `fields` to ensure an error is raised if you don't pass at least one.
-        *fields (str): Additional field(s) the validator should be called on.
-        pre (bool, optional): Whether this validator should be called before the standard
-            validators (else after). Defaults to False.
-        each_item (bool, optional): For complex objects (sets, lists etc.) whether to validate
-            individual elements rather than the whole object. Defaults to False.
-        always (bool, optional): Whether this method and other validators should be called even if
-            the value is missing. Defaults to False.
-        check_fields (bool | None, optional): Whether to check that the fields actually exist on the model.
-            Defaults to None.
-        allow_reuse (bool, optional): Whether to track and raise an error if another validator refers to
-            the decorated function. Defaults to False.
-
-    Returns:
-        Callable: A decorator that can be used to decorate a
-            function to be used as a validator.
-    """
-    warn(
-        'Pydantic V1 style `@validator` validators are deprecated.'
-        ' You should migrate to Pydantic V2 style `@field_validator` validators,'
-        ' see the migration guide for more details',
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    if allow_reuse is True:  # pragma: no cover
-        warn(_ALLOW_REUSE_WARNING_MESSAGE, DeprecationWarning, stacklevel=2)
-    fields = __field, *fields
-    if isinstance(fields[0], FunctionType):
-        raise PydanticUserError(
-            '`@validator` should be used with fields and keyword arguments, not bare. '
-            "E.g. usage should be `@validator('<field_name>', ...)`",
-            code='validator-no-fields',
-        )
-    elif not all(isinstance(field, str) for field in fields):
-        raise PydanticUserError(
-            '`@validator` fields should be passed as separate string args. '
-            "E.g. usage should be `@validator('<field_name_1>', '<field_name_2>', ...)`",
-            code='validator-invalid-fields',
-        )
-
-    mode: Literal['before', 'after'] = 'before' if pre is True else 'after'
-
-    def dec(f: Any) -> _decorators.PydanticDescriptorProxy[Any]:
-        if _decorators.is_instance_method_from_sig(f):
-            raise PydanticUserError(
-                '`@validator` cannot be applied to instance methods', code='validator-instance-method'
-            )
-        # auto apply the @classmethod decorator
-        f = _decorators.ensure_classmethod_based_on_signature(f)
-        wrap = _decorators_v1.make_generic_v1_field_validator
-        validator_wrapper_info = _decorators.ValidatorDecoratorInfo(
-            fields=fields,
-            mode=mode,
-            each_item=each_item,
-            always=always,
-            check_fields=check_fields,
-        )
-        return _decorators.PydanticDescriptorProxy(f, validator_wrapper_info, shim=wrap)
-
-    return dec  # type: ignore[return-value]
-
-
-@overload
-def root_validator(
-    *,
-    # if you don't specify `pre` the default is `pre=False`
-    # which means you need to specify `skip_on_failure=True`
-    skip_on_failure: Literal[True],
-    allow_reuse: bool = ...,
-) -> Callable[
-    [_V1RootValidatorFunctionType],
-    _V1RootValidatorFunctionType,
-]: ...
-
-
-@overload
-def root_validator(
-    *,
-    # if you specify `pre=True` then you don't need to specify
-    # `skip_on_failure`, in fact it is not allowed as an argument!
-    pre: Literal[True],
-    allow_reuse: bool = ...,
-) -> Callable[
-    [_V1RootValidatorFunctionType],
-    _V1RootValidatorFunctionType,
-]: ...
-
-
-@overload
-def root_validator(
-    *,
-    # if you explicitly specify `pre=False` then you
-    # MUST specify `skip_on_failure=True`
-    pre: Literal[False],
-    skip_on_failure: Literal[True],
-    allow_reuse: bool = ...,
-) -> Callable[
-    [_V1RootValidatorFunctionType],
-    _V1RootValidatorFunctionType,
-]: ...
-
-
-@deprecated(
-    'Pydantic V1 style `@root_validator` validators are deprecated.'
-    ' You should migrate to Pydantic V2 style `@model_validator` validators,'
-    ' see the migration guide for more details',
-    category=None,
-)
-def root_validator(
-    *__args,
-    pre: bool = False,
-    skip_on_failure: bool = False,
-    allow_reuse: bool = False,
-) -> Any:
-    """Decorate methods on a model indicating that they should be used to validate (and perhaps
-    modify) data either before or after standard model parsing/validation is performed.
-
-    Args:
-        pre (bool, optional): Whether this validator should be called before the standard
-            validators (else after). Defaults to False.
-        skip_on_failure (bool, optional): Whether to stop validation and return as soon as a
-            failure is encountered. Defaults to False.
-        allow_reuse (bool, optional): Whether to track and raise an error if another validator
-            refers to the decorated function. Defaults to False.
-
-    Returns:
-        Any: A decorator that can be used to decorate a function to be used as a root_validator.
-    """
-    warn(
-        'Pydantic V1 style `@root_validator` validators are deprecated.'
-        ' You should migrate to Pydantic V2 style `@model_validator` validators,'
-        ' see the migration guide for more details',
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    if __args:
-        # Ensure a nice error is raised if someone attempts to use the bare decorator
-        return root_validator()(*__args)  # type: ignore
-
-    if allow_reuse is True:  # pragma: no cover
-        warn(_ALLOW_REUSE_WARNING_MESSAGE, DeprecationWarning, stacklevel=2)
-    mode: Literal['before', 'after'] = 'before' if pre is True else 'after'
-    if pre is False and skip_on_failure is not True:
-        raise PydanticUserError(
-            'If you use `@root_validator` with pre=False (the default) you MUST specify `skip_on_failure=True`.'
-            ' Note that `@root_validator` is deprecated and should be replaced with `@model_validator`.',
-            code='root-validator-pre-skip',
-        )
-
-    wrap = partial(_decorators_v1.make_v1_generic_root_validator, pre=pre)
-
-    def dec(f: Callable[..., Any] | classmethod[Any, Any, Any] | staticmethod[Any, Any]) -> Any:
-        if _decorators.is_instance_method_from_sig(f):
-            raise TypeError('`@root_validator` cannot be applied to instance methods')
-        # auto apply the @classmethod decorator
-        res = _decorators.ensure_classmethod_based_on_signature(f)
-        dec_info = _decorators.RootValidatorDecoratorInfo(mode=mode)
-        return _decorators.PydanticDescriptorProxy(res, dec_info, shim=wrap)
-
-    return dec