claude-all-hands 1.0.0 → 1.0.1

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

@@ -1,141 +0,0 @@
-import datetime
-import warnings
-from collections import deque
-from decimal import Decimal
-from enum import Enum
-from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network
-from pathlib import Path
-from re import Pattern
-from types import GeneratorType
-from typing import TYPE_CHECKING, Any, Callable, Union
-from uuid import UUID
-
-from typing_extensions import deprecated
-
-from .._internal._import_utils import import_cached_base_model
-from ..color import Color
-from ..networks import NameEmail
-from ..types import SecretBytes, SecretStr
-from ..warnings import PydanticDeprecatedSince20
-
-if not TYPE_CHECKING:
-    # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915
-    # and https://youtrack.jetbrains.com/issue/PY-51428
-    DeprecationWarning = PydanticDeprecatedSince20
-
-__all__ = 'pydantic_encoder', 'custom_pydantic_encoder', 'timedelta_isoformat'
-
-
-def isoformat(o: Union[datetime.date, datetime.time]) -> str:
-    return o.isoformat()
-
-
-def decimal_encoder(dec_value: Decimal) -> Union[int, float]:
-    """Encodes a Decimal as int of there's no exponent, otherwise float.
-
-    This is useful when we use ConstrainedDecimal to represent Numeric(x,0)
-    where a integer (but not int typed) is used. Encoding this as a float
-    results in failed round-tripping between encode and parse.
-    Our Id type is a prime example of this.
-
-    >>> decimal_encoder(Decimal("1.0"))
-    1.0
-
-    >>> decimal_encoder(Decimal("1"))
-    1
-    """
-    exponent = dec_value.as_tuple().exponent
-    if isinstance(exponent, int) and exponent >= 0:
-        return int(dec_value)
-    else:
-        return float(dec_value)
-
-
-ENCODERS_BY_TYPE: dict[type[Any], Callable[[Any], Any]] = {
-    bytes: lambda o: o.decode(),
-    Color: str,
-    datetime.date: isoformat,
-    datetime.datetime: isoformat,
-    datetime.time: isoformat,
-    datetime.timedelta: lambda td: td.total_seconds(),
-    Decimal: decimal_encoder,
-    Enum: lambda o: o.value,
-    frozenset: list,
-    deque: list,
-    GeneratorType: list,
-    IPv4Address: str,
-    IPv4Interface: str,
-    IPv4Network: str,
-    IPv6Address: str,
-    IPv6Interface: str,
-    IPv6Network: str,
-    NameEmail: str,
-    Path: str,
-    Pattern: lambda o: o.pattern,
-    SecretBytes: str,
-    SecretStr: str,
-    set: list,
-    UUID: str,
-}
-
-
-@deprecated(
-    '`pydantic_encoder` is deprecated, use `pydantic_core.to_jsonable_python` instead.',
-    category=None,
-)
-def pydantic_encoder(obj: Any) -> Any:
-    warnings.warn(
-        '`pydantic_encoder` is deprecated, use `pydantic_core.to_jsonable_python` instead.',
-        category=PydanticDeprecatedSince20,
-        stacklevel=2,
-    )
-    from dataclasses import asdict, is_dataclass
-
-    BaseModel = import_cached_base_model()
-
-    if isinstance(obj, BaseModel):
-        return obj.model_dump()
-    elif is_dataclass(obj):
-        return asdict(obj)  # type: ignore
-
-    # Check the class type and its superclasses for a matching encoder
-    for base in obj.__class__.__mro__[:-1]:
-        try:
-            encoder = ENCODERS_BY_TYPE[base]
-        except KeyError:
-            continue
-        return encoder(obj)
-    else:  # We have exited the for loop without finding a suitable encoder
-        raise TypeError(f"Object of type '{obj.__class__.__name__}' is not JSON serializable")
-
-
-# TODO: Add a suggested migration path once there is a way to use custom encoders
-@deprecated(
-    '`custom_pydantic_encoder` is deprecated, use `BaseModel.model_dump` instead.',
-    category=None,
-)
-def custom_pydantic_encoder(type_encoders: dict[Any, Callable[[type[Any]], Any]], obj: Any) -> Any:
-    warnings.warn(
-        '`custom_pydantic_encoder` is deprecated, use `BaseModel.model_dump` instead.',
-        category=PydanticDeprecatedSince20,
-        stacklevel=2,
-    )
-    # Check the class type and its superclasses for a matching encoder
-    for base in obj.__class__.__mro__[:-1]:
-        try:
-            encoder = type_encoders[base]
-        except KeyError:
-            continue
-
-        return encoder(obj)
-    else:  # We have exited the for loop without finding a suitable encoder
-        return pydantic_encoder(obj)
-
-
-@deprecated('`timedelta_isoformat` is deprecated.', category=None)
-def timedelta_isoformat(td: datetime.timedelta) -> str:
-    """ISO 8601 encoding for Python timedelta object."""
-    warnings.warn('`timedelta_isoformat` is deprecated.', category=PydanticDeprecatedSince20, stacklevel=2)
-    minutes, seconds = divmod(td.seconds, 60)
-    hours, minutes = divmod(minutes, 60)
-    return f'{"-" if td.days < 0 else ""}P{abs(td.days)}DT{hours:d}H{minutes:d}M{seconds:d}.{td.microseconds:06d}S'

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

@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-import json
-import pickle
-import warnings
-from enum import Enum
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable
-
-from typing_extensions import deprecated
-
-from ..warnings import PydanticDeprecatedSince20
-
-if not TYPE_CHECKING:
-    # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915
-    # and https://youtrack.jetbrains.com/issue/PY-51428
-    DeprecationWarning = PydanticDeprecatedSince20
-
-
-class Protocol(str, Enum):
-    json = 'json'
-    pickle = 'pickle'
-
-
-@deprecated('`load_str_bytes` is deprecated.', category=None)
-def load_str_bytes(
-    b: str | bytes,
-    *,
-    content_type: str | None = None,
-    encoding: str = 'utf8',
-    proto: Protocol | None = None,
-    allow_pickle: bool = False,
-    json_loads: Callable[[str], Any] = json.loads,
-) -> Any:
-    warnings.warn('`load_str_bytes` is deprecated.', category=PydanticDeprecatedSince20, stacklevel=2)
-    if proto is None and content_type:
-        if content_type.endswith(('json', 'javascript')):
-            pass
-        elif allow_pickle and content_type.endswith('pickle'):
-            proto = Protocol.pickle
-        else:
-            raise TypeError(f'Unknown content-type: {content_type}')
-
-    proto = proto or Protocol.json
-
-    if proto == Protocol.json:
-        if isinstance(b, bytes):
-            b = b.decode(encoding)
-        return json_loads(b)  # type: ignore
-    elif proto == Protocol.pickle:
-        if not allow_pickle:
-            raise RuntimeError('Trying to decode with pickle with allow_pickle=False')
-        bb = b if isinstance(b, bytes) else b.encode()  # type: ignore
-        return pickle.loads(bb)
-    else:
-        raise TypeError(f'Unknown protocol: {proto}')
-
-
-@deprecated('`load_file` is deprecated.', category=None)
-def load_file(
-    path: str | Path,
-    *,
-    content_type: str | None = None,
-    encoding: str = 'utf8',
-    proto: Protocol | None = None,
-    allow_pickle: bool = False,
-    json_loads: Callable[[str], Any] = json.loads,
-) -> Any:
-    warnings.warn('`load_file` is deprecated.', category=PydanticDeprecatedSince20, stacklevel=2)
-    path = Path(path)
-    b = path.read_bytes()
-    if content_type is None:
-        if path.suffix in ('.js', '.json'):
-            proto = Protocol.json
-        elif path.suffix == '.pkl':
-            proto = Protocol.pickle
-
-    return load_str_bytes(
-        b, proto=proto, content_type=content_type, encoding=encoding, allow_pickle=allow_pickle, json_loads=json_loads
-    )

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

@@ -1,103 +0,0 @@
-from __future__ import annotations
-
-import json
-import warnings
-from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union
-
-from typing_extensions import deprecated
-
-from ..json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema
-from ..type_adapter import TypeAdapter
-from ..warnings import PydanticDeprecatedSince20
-
-if not TYPE_CHECKING:
-    # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915
-    # and https://youtrack.jetbrains.com/issue/PY-51428
-    DeprecationWarning = PydanticDeprecatedSince20
-
-__all__ = 'parse_obj_as', 'schema_of', 'schema_json_of'
-
-NameFactory = Union[str, Callable[[type[Any]], str]]
-
-
-T = TypeVar('T')
-
-
-@deprecated(
-    '`parse_obj_as` is deprecated. Use `pydantic.TypeAdapter.validate_python` instead.',
-    category=None,
-)
-def parse_obj_as(type_: type[T], obj: Any, type_name: NameFactory | None = None) -> T:
-    warnings.warn(
-        '`parse_obj_as` is deprecated. Use `pydantic.TypeAdapter.validate_python` instead.',
-        category=PydanticDeprecatedSince20,
-        stacklevel=2,
-    )
-    if type_name is not None:  # pragma: no cover
-        warnings.warn(
-            'The type_name parameter is deprecated. parse_obj_as no longer creates temporary models',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-    return TypeAdapter(type_).validate_python(obj)
-
-
-@deprecated(
-    '`schema_of` is deprecated. Use `pydantic.TypeAdapter.json_schema` instead.',
-    category=None,
-)
-def schema_of(
-    type_: Any,
-    *,
-    title: NameFactory | None = None,
-    by_alias: bool = True,
-    ref_template: str = DEFAULT_REF_TEMPLATE,
-    schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema,
-) -> dict[str, Any]:
-    """Generate a JSON schema (as dict) for the passed model or dynamically generated one."""
-    warnings.warn(
-        '`schema_of` is deprecated. Use `pydantic.TypeAdapter.json_schema` instead.',
-        category=PydanticDeprecatedSince20,
-        stacklevel=2,
-    )
-    res = TypeAdapter(type_).json_schema(
-        by_alias=by_alias,
-        schema_generator=schema_generator,
-        ref_template=ref_template,
-    )
-    if title is not None:
-        if isinstance(title, str):
-            res['title'] = title
-        else:
-            warnings.warn(
-                'Passing a callable for the `title` parameter is deprecated and no longer supported',
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            res['title'] = title(type_)
-    return res
-
-
-@deprecated(
-    '`schema_json_of` is deprecated. Use `pydantic.TypeAdapter.json_schema` instead.',
-    category=None,
-)
-def schema_json_of(
-    type_: Any,
-    *,
-    title: NameFactory | None = None,
-    by_alias: bool = True,
-    ref_template: str = DEFAULT_REF_TEMPLATE,
-    schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema,
-    **dumps_kwargs: Any,
-) -> str:
-    """Generate a JSON schema (as JSON) for the passed model or dynamically generated one."""
-    warnings.warn(
-        '`schema_json_of` is deprecated. Use `pydantic.TypeAdapter.json_schema` instead.',
-        category=PydanticDeprecatedSince20,
-        stacklevel=2,
-    )
-    return json.dumps(
-        schema_of(type_, title=title, by_alias=by_alias, ref_template=ref_template, schema_generator=schema_generator),
-        **dumps_kwargs,
-    )

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

@@ -1,5 +0,0 @@
-"""The `env_settings` 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/error_wrappers.py

@@ -1,5 +0,0 @@
-"""The `error_wrappers` 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/errors.py

@@ -1,189 +0,0 @@
-"""Pydantic-specific errors."""
-
-from __future__ import annotations as _annotations
-
-import re
-from typing import Any, ClassVar, Literal
-
-from typing_extensions import Self
-from typing_inspection.introspection import Qualifier
-
-from pydantic._internal import _repr
-
-from ._migration import getattr_migration
-from .version import version_short
-
-__all__ = (
-    'PydanticUserError',
-    'PydanticUndefinedAnnotation',
-    'PydanticImportError',
-    'PydanticSchemaGenerationError',
-    'PydanticInvalidForJsonSchema',
-    'PydanticForbiddenQualifier',
-    'PydanticErrorCodes',
-)
-
-# We use this URL to allow for future flexibility about how we host the docs, while allowing for Pydantic
-# code in the while with "old" URLs to still work.
-# 'u' refers to "user errors" - e.g. errors caused by developers using pydantic, as opposed to validation errors.
-DEV_ERROR_DOCS_URL = f'https://errors.pydantic.dev/{version_short()}/u/'
-PydanticErrorCodes = Literal[
-    'class-not-fully-defined',
-    'custom-json-schema',
-    'decorator-missing-field',
-    'discriminator-no-field',
-    'discriminator-alias-type',
-    'discriminator-needs-literal',
-    'discriminator-alias',
-    'discriminator-validator',
-    'callable-discriminator-no-tag',
-    'typed-dict-version',
-    'model-field-overridden',
-    'model-field-missing-annotation',
-    'config-both',
-    'removed-kwargs',
-    'circular-reference-schema',
-    'invalid-for-json-schema',
-    'json-schema-already-used',
-    'base-model-instantiated',
-    'undefined-annotation',
-    'schema-for-unknown-type',
-    'import-error',
-    'create-model-field-definitions',
-    'validator-no-fields',
-    'validator-invalid-fields',
-    'validator-instance-method',
-    'validator-input-type',
-    'root-validator-pre-skip',
-    'model-serializer-instance-method',
-    'validator-field-config-info',
-    'validator-v1-signature',
-    'validator-signature',
-    'field-serializer-signature',
-    'model-serializer-signature',
-    'multiple-field-serializers',
-    'invalid-annotated-type',
-    'type-adapter-config-unused',
-    'root-model-extra',
-    'unevaluable-type-annotation',
-    'dataclass-init-false-extra-allow',
-    'clashing-init-and-init-var',
-    'model-config-invalid-field-name',
-    'with-config-on-model',
-    'dataclass-on-model',
-    'validate-call-type',
-    'unpack-typed-dict',
-    'overlapping-unpack-typed-dict',
-    'invalid-self-type',
-    'validate-by-alias-and-name-false',
-]
-
-
-class PydanticErrorMixin:
-    """A mixin class for common functionality shared by all Pydantic-specific errors.
-
-    Attributes:
-        message: A message describing the error.
-        code: An optional error code from PydanticErrorCodes enum.
-    """
-
-    def __init__(self, message: str, *, code: PydanticErrorCodes | None) -> None:
-        self.message = message
-        self.code = code
-
-    def __str__(self) -> str:
-        if self.code is None:
-            return self.message
-        else:
-            return f'{self.message}\n\nFor further information visit {DEV_ERROR_DOCS_URL}{self.code}'
-
-
-class PydanticUserError(PydanticErrorMixin, TypeError):
-    """An error raised due to incorrect use of Pydantic."""
-
-
-class PydanticUndefinedAnnotation(PydanticErrorMixin, NameError):
-    """A subclass of `NameError` raised when handling undefined annotations during `CoreSchema` generation.
-
-    Attributes:
-        name: Name of the error.
-        message: Description of the error.
-    """
-
-    def __init__(self, name: str, message: str) -> None:
-        self.name = name
-        super().__init__(message=message, code='undefined-annotation')
-
-    @classmethod
-    def from_name_error(cls, name_error: NameError) -> Self:
-        """Convert a `NameError` to a `PydanticUndefinedAnnotation` error.
-
-        Args:
-            name_error: `NameError` to be converted.
-
-        Returns:
-            Converted `PydanticUndefinedAnnotation` error.
-        """
-        try:
-            name = name_error.name  # type: ignore  # python > 3.10
-        except AttributeError:
-            name = re.search(r".*'(.+?)'", str(name_error)).group(1)  # type: ignore[union-attr]
-        return cls(name=name, message=str(name_error))
-
-
-class PydanticImportError(PydanticErrorMixin, ImportError):
-    """An error raised when an import fails due to module changes between V1 and V2.
-
-    Attributes:
-        message: Description of the error.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message, code='import-error')
-
-
-class PydanticSchemaGenerationError(PydanticUserError):
-    """An error raised during failures to generate a `CoreSchema` for some type.
-
-    Attributes:
-        message: Description of the error.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message, code='schema-for-unknown-type')
-
-
-class PydanticInvalidForJsonSchema(PydanticUserError):
-    """An error raised during failures to generate a JSON schema for some `CoreSchema`.
-
-    Attributes:
-        message: Description of the error.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message, code='invalid-for-json-schema')
-
-
-class PydanticForbiddenQualifier(PydanticUserError):
-    """An error raised if a forbidden type qualifier is found in a type annotation."""
-
-    _qualifier_repr_map: ClassVar[dict[Qualifier, str]] = {
-        'required': 'typing.Required',
-        'not_required': 'typing.NotRequired',
-        'read_only': 'typing.ReadOnly',
-        'class_var': 'typing.ClassVar',
-        'init_var': 'dataclasses.InitVar',
-        'final': 'typing.Final',
-    }
-
-    def __init__(self, qualifier: Qualifier, annotation: Any) -> None:
-        super().__init__(
-            message=(
-                f'The annotation {_repr.display_as_type(annotation)!r} contains the {self._qualifier_repr_map[qualifier]!r} '
-                f'type qualifier, which is invalid in the context it is defined.'
-            ),
-            code=None,
-        )
-
-
-__getattr__ = getattr_migration(__name__)

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

@@ -1 +0,0 @@
-"""The "experimental" module of pydantic contains potential new features that are subject to change."""

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

@@ -1,44 +0,0 @@
-"""Experimental module exposing a function to generate a core schema that validates callable arguments."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any, Literal
-
-from pydantic_core import CoreSchema
-
-from pydantic import ConfigDict
-from pydantic._internal import _config, _generate_schema, _namespace_utils
-
-
-def generate_arguments_schema(
-    func: Callable[..., Any],
-    schema_type: Literal['arguments', 'arguments-v3'] = 'arguments-v3',
-    parameters_callback: Callable[[int, str, Any], Literal['skip'] | None] | None = None,
-    config: ConfigDict | None = None,
-) -> CoreSchema:
-    """Generate the schema for the arguments of a function.
-
-    Args:
-        func: The function to generate the schema for.
-        schema_type: The type of schema to generate.
-        parameters_callback: A callable that will be invoked for each parameter. The callback
-            should take three required arguments: the index, the name and the type annotation
-            (or [`Parameter.empty`][inspect.Parameter.empty] if not annotated) of the parameter.
-            The callback can optionally return `'skip'`, so that the parameter gets excluded
-            from the resulting schema.
-        config: The configuration to use.
-
-    Returns:
-        The generated schema.
-    """
-    generate_schema = _generate_schema.GenerateSchema(
-        _config.ConfigWrapper(config),
-        ns_resolver=_namespace_utils.NsResolver(namespaces_tuple=_namespace_utils.ns_for_function(func)),
-    )
-
-    if schema_type == 'arguments':
-        schema = generate_schema._arguments_schema(func, parameters_callback)  # pyright: ignore[reportArgumentType]
-    else:
-        schema = generate_schema._arguments_v3_schema(func, parameters_callback)  # pyright: ignore[reportArgumentType]
-    return generate_schema.clean_schema(schema)

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

@@ -1,5 +0,0 @@
-"""Experimental module exposing a function a `MISSING` sentinel."""
-
-from pydantic_core import MISSING
-
-__all__ = ('MISSING',)