anthropic 0.66.0__py3-none-any.whl → 0.68.0__py3-none-any.whl

anthropic/_utils/_datetime_parse.py

@@ -0,0 +1,136 @@
+"""
+This file contains code from https://github.com/pydantic/pydantic/blob/main/pydantic/v1/datetime_parse.py
+without the Pydantic v1 specific errors.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, Union, Optional
+from datetime import date, datetime, timezone, timedelta
+
+from .._types import StrBytesIntFloat
+
+date_expr = r"(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})"
+time_expr = (
+    r"(?P<hour>\d{1,2}):(?P<minute>\d{1,2})"
+    r"(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?"
+    r"(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$"
+)
+
+date_re = re.compile(f"{date_expr}$")
+datetime_re = re.compile(f"{date_expr}[T ]{time_expr}")
+
+
+EPOCH = datetime(1970, 1, 1)
+# if greater than this, the number is in ms, if less than or equal it's in seconds
+# (in seconds this is 11th October 2603, in ms it's 20th August 1970)
+MS_WATERSHED = int(2e10)
+# slightly more than datetime.max in ns - (datetime.max - EPOCH).total_seconds() * 1e9
+MAX_NUMBER = int(3e20)
+
+
+def _get_numeric(value: StrBytesIntFloat, native_expected_type: str) -> Union[None, int, float]:
+    if isinstance(value, (int, float)):
+        return value
+    try:
+        return float(value)
+    except ValueError:
+        return None
+    except TypeError:
+        raise TypeError(f"invalid type; expected {native_expected_type}, string, bytes, int or float") from None
+
+
+def _from_unix_seconds(seconds: Union[int, float]) -> datetime:
+    if seconds > MAX_NUMBER:
+        return datetime.max
+    elif seconds < -MAX_NUMBER:
+        return datetime.min
+
+    while abs(seconds) > MS_WATERSHED:
+        seconds /= 1000
+    dt = EPOCH + timedelta(seconds=seconds)
+    return dt.replace(tzinfo=timezone.utc)
+
+
+def _parse_timezone(value: Optional[str]) -> Union[None, int, timezone]:
+    if value == "Z":
+        return timezone.utc
+    elif value is not None:
+        offset_mins = int(value[-2:]) if len(value) > 3 else 0
+        offset = 60 * int(value[1:3]) + offset_mins
+        if value[0] == "-":
+            offset = -offset
+        return timezone(timedelta(minutes=offset))
+    else:
+        return None
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    """
+    Parse a datetime/int/float/string and return a datetime.datetime.
+
+    This function supports time zone offsets. When the input contains one,
+    the output uses a timezone with a fixed offset from UTC.
+
+    Raise ValueError if the input is well formatted but not a valid datetime.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, datetime):
+        return value
+
+    number = _get_numeric(value, "datetime")
+    if number is not None:
+        return _from_unix_seconds(number)
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+
+    match = datetime_re.match(value)
+    if match is None:
+        raise ValueError("invalid datetime format")
+
+    kw = match.groupdict()
+    if kw["microsecond"]:
+        kw["microsecond"] = kw["microsecond"].ljust(6, "0")
+
+    tzinfo = _parse_timezone(kw.pop("tzinfo"))
+    kw_: Dict[str, Union[None, int, timezone]] = {k: int(v) for k, v in kw.items() if v is not None}
+    kw_["tzinfo"] = tzinfo
+
+    return datetime(**kw_)  # type: ignore
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    """
+    Parse a date/int/float/string and return a datetime.date.
+
+    Raise ValueError if the input is well formatted but not a valid date.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, date):
+        if isinstance(value, datetime):
+            return value.date()
+        else:
+            return value
+
+    number = _get_numeric(value, "date")
+    if number is not None:
+        return _from_unix_seconds(number).date()
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+    match = date_re.match(value)
+    if match is None:
+        raise ValueError("invalid date format")
+
+    kw = {k: int(v) for k, v in match.groupdict().items()}
+
+    try:
+        return date(**kw)
+    except ValueError:
+        raise ValueError("invalid date format") from None

anthropic/_utils/_transform.py

@@ -19,6 +19,7 @@ from ._utils import (
     is_sequence,
 )
 from .._files import is_base64_file_input
+from ._compat import get_origin, is_typeddict
 from ._typing import (
     is_list_type,
     is_union_type,
@@ -29,7 +30,6 @@ from ._typing import (
     is_annotated_type,
     strip_annotated_type,
 )
-from .._compat import get_origin, model_dump, is_typeddict
 
 _T = TypeVar("_T")
 
@@ -169,6 +169,8 @@ def _transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -333,6 +335,8 @@ async def _async_transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 

anthropic/_utils/_typing.py

@@ -15,7 +15,7 @@ from typing_extensions import (
 
 from ._utils import lru_cache
 from .._types import InheritsGeneric
-from .._compat import is_union as _is_union
+from ._compat import is_union as _is_union
 
 
 def is_annotated_type(typ: type) -> bool:

anthropic/_utils/_utils.py

@@ -22,7 +22,6 @@ from typing_extensions import TypeGuard
 import sniffio
 
 from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike
-from .._compat import parse_date as parse_date, parse_datetime as parse_datetime
 
 _T = TypeVar("_T")
 _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...])

anthropic/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "anthropic"
-__version__ = "0.66.0"  # x-release-please-version
+__version__ = "0.68.0"  # x-release-please-version

anthropic/lib/tools/__init__.py

@@ -0,0 +1,20 @@
+from ._beta_runner import BetaToolRunner, BetaAsyncToolRunner, BetaStreamingToolRunner, BetaAsyncStreamingToolRunner
+from ._beta_functions import (
+    BetaFunctionTool,
+    BetaAsyncFunctionTool,
+    BetaFunctionToolResultType,
+    beta_tool,
+    beta_async_tool,
+)
+
+__all__ = [
+    "beta_tool",
+    "beta_async_tool",
+    "BetaFunctionTool",
+    "BetaAsyncFunctionTool",
+    "BetaToolRunner",
+    "BetaAsyncStreamingToolRunner",
+    "BetaStreamingToolRunner",
+    "BetaAsyncToolRunner",
+    "BetaFunctionToolResultType",
+]

anthropic/lib/tools/_beta_functions.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Union, Generic, TypeVar, Callable, Iterable, Coroutine, cast, overload
+from inspect import iscoroutinefunction
+from typing_extensions import TypeAlias, override
+
+import pydantic
+import docstring_parser
+from pydantic import BaseModel
+
+from ... import _compat
+from ..._utils import is_dict
+from ..._compat import cached_property
+from ..._models import TypeAdapter
+from ..._utils._utils import CallableT
+from ...types.tool_param import ToolParam, InputSchema
+from ...types.beta.beta_tool_result_block_param import Content as BetaContent
+
+log = logging.getLogger(__name__)
+
+BetaFunctionToolResultType: TypeAlias = Union[str, Iterable[BetaContent]]
+
+Function = Callable[..., BetaFunctionToolResultType]
+FunctionT = TypeVar("FunctionT", bound=Function)
+
+AsyncFunction = Callable[..., Coroutine[Any, Any, BetaFunctionToolResultType]]
+AsyncFunctionT = TypeVar("AsyncFunctionT", bound=AsyncFunction)
+
+
+class BaseFunctionTool(Generic[CallableT]):
+    func: CallableT
+    """The function this tool is wrapping"""
+
+    name: str
+    """The name of the tool that will be sent to the API"""
+
+    description: str
+
+    input_schema: InputSchema
+
+    def __init__(
+        self,
+        func: CallableT,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        input_schema: InputSchema | type[BaseModel] | None = None,
+    ) -> None:
+        if _compat.PYDANTIC_V1:
+            raise RuntimeError("Tool functions are only supported with Pydantic v2")
+
+        self.func = func
+        self._func_with_validate = pydantic.validate_call(func)
+        self.name = name or func.__name__
+
+        self.description = description or self._get_description_from_docstring()
+
+        if input_schema is not None:
+            if isinstance(input_schema, type):
+                self.input_schema: InputSchema = input_schema.model_json_schema()
+            else:
+                self.input_schema = input_schema
+        else:
+            self.input_schema = self._create_schema_from_function()
+
+    @property
+    def __call__(self) -> CallableT:
+        return self.func
+
+    def to_dict(self) -> ToolParam:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": self.input_schema,
+        }
+
+    @cached_property
+    def _parsed_docstring(self) -> docstring_parser.Docstring:
+        return docstring_parser.parse(self.func.__doc__ or "")
+
+    def _get_description_from_docstring(self) -> str:
+        """Extract description from parsed docstring."""
+        if self._parsed_docstring.short_description:
+            description = self._parsed_docstring.short_description
+            if self._parsed_docstring.long_description:
+                description += f"\n\n{self._parsed_docstring.long_description}"
+            return description
+        return ""
+
+    def _create_schema_from_function(self) -> InputSchema:
+        """Create JSON schema from function signature using pydantic."""
+
+        from pydantic_core import CoreSchema
+        from pydantic.json_schema import JsonSchemaValue, GenerateJsonSchema
+        from pydantic_core.core_schema import ArgumentsParameter
+
+        class CustomGenerateJsonSchema(GenerateJsonSchema):
+            def __init__(self, *, func: Callable[..., Any], parsed_docstring: Any) -> None:
+                super().__init__()
+                self._func = func
+                self._parsed_docstring = parsed_docstring
+
+            def __call__(self, *_args: Any, **_kwds: Any) -> "CustomGenerateJsonSchema":  # noqa: ARG002
+                return self
+
+            @override
+            def kw_arguments_schema(
+                self,
+                arguments: "list[ArgumentsParameter]",
+                var_kwargs_schema: CoreSchema | None,
+            ) -> JsonSchemaValue:
+                schema = super().kw_arguments_schema(arguments, var_kwargs_schema)
+                if schema.get("type") != "object":
+                    return schema
+
+                properties = schema.get("properties")
+                if not properties or not is_dict(properties):
+                    return schema
+
+                # Add parameter descriptions from docstring
+                for param in self._parsed_docstring.params:
+                    prop_schema = properties.get(param.arg_name)
+                    if not prop_schema or not is_dict(prop_schema):
+                        continue
+
+                    if param.description and "description" not in prop_schema:
+                        prop_schema["description"] = param.description
+
+                return schema
+
+        schema_generator = CustomGenerateJsonSchema(func=self.func, parsed_docstring=self._parsed_docstring)
+        return self._adapter.json_schema(schema_generator=schema_generator)  # type: ignore
+
+    @cached_property
+    def _adapter(self) -> TypeAdapter[Any]:
+        return TypeAdapter(self._func_with_validate)
+
+
+class BetaFunctionTool(BaseFunctionTool[FunctionT]):
+    def call(self, input: object) -> BetaFunctionToolResultType:
+        if iscoroutinefunction(self.func):
+            raise RuntimeError("Cannot call a coroutine function synchronously. Use `@async_tool` instead.")
+
+        if not is_dict(input):
+            raise TypeError(f"Input must be a dictionary, got {type(input).__name__}")
+
+        try:
+            return self._func_with_validate(**cast(Any, input))
+        except pydantic.ValidationError as e:
+            raise ValueError(f"Invalid arguments for function {self.name}") from e
+
+
+class BetaAsyncFunctionTool(BaseFunctionTool[AsyncFunctionT]):
+    async def call(self, input: object) -> BetaFunctionToolResultType:
+        if not iscoroutinefunction(self.func):
+            raise RuntimeError("Cannot call a synchronous function asynchronously. Use `@tool` instead.")
+
+        if not is_dict(input):
+            raise TypeError(f"Input must be a dictionary, got {type(input).__name__}")
+
+        try:
+            return await self._func_with_validate(**cast(Any, input))
+        except pydantic.ValidationError as e:
+            raise ValueError(f"Invalid arguments for function {self.name}") from e
+
+
+@overload
+def beta_tool(func: FunctionT) -> BetaFunctionTool[FunctionT]: ...
+
+
+@overload
+def beta_tool(
+    func: FunctionT,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+    input_schema: InputSchema | type[BaseModel] | None = None,
+) -> BetaFunctionTool[FunctionT]: ...
+
+
+@overload
+def beta_tool(
+    *,
+    name: str | None = None,
+    description: str | None = None,
+    input_schema: InputSchema | type[BaseModel] | None = None,
+) -> Callable[[FunctionT], BetaFunctionTool[FunctionT]]: ...
+
+
+def beta_tool(
+    func: FunctionT | None = None,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+    input_schema: InputSchema | type[BaseModel] | None = None,
+) -> BetaFunctionTool[FunctionT] | Callable[[FunctionT], BetaFunctionTool[FunctionT]]:
+    """Create a FunctionTool from a function with automatic schema inference.
+
+    Can be used as a decorator with or without parentheses:
+
+    @function_tool
+    def my_func(x: int) -> str: ...
+
+    @function_tool()
+    def my_func(x: int) -> str: ...
+
+    @function_tool(name="custom_name")
+    def my_func(x: int) -> str: ...
+    """
+    if _compat.PYDANTIC_V1:
+        raise RuntimeError("Tool functions are only supported with Pydantic v2")
+
+    if func is not None:
+        # @beta_tool called without parentheses
+        return BetaFunctionTool(func=func, name=name, description=description, input_schema=input_schema)
+
+    # @beta_tool()
+    def decorator(func: FunctionT) -> BetaFunctionTool[FunctionT]:
+        return BetaFunctionTool(func=func, name=name, description=description, input_schema=input_schema)
+
+    return decorator
+
+
+@overload
+def beta_async_tool(func: AsyncFunctionT) -> BetaAsyncFunctionTool[AsyncFunctionT]: ...
+
+
+@overload
+def beta_async_tool(
+    func: AsyncFunctionT,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+    input_schema: InputSchema | type[BaseModel] | None = None,
+) -> BetaAsyncFunctionTool[AsyncFunctionT]: ...
+
+
+@overload
+def beta_async_tool(
+    *,
+    name: str | None = None,
+    description: str | None = None,
+    input_schema: InputSchema | type[BaseModel] | None = None,
+) -> Callable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]]: ...
+
+
+def beta_async_tool(
+    func: AsyncFunctionT | None = None,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+    input_schema: InputSchema | type[BaseModel] | None = None,
+) -> BetaAsyncFunctionTool[AsyncFunctionT] | Callable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]]:
+    """Create an AsyncFunctionTool from a function with automatic schema inference.
+
+    Can be used as a decorator with or without parentheses:
+
+    @async_tool
+    async def my_func(x: int) -> str: ...
+
+    @async_tool()
+    async def my_func(x: int) -> str: ...
+
+    @async_tool(name="custom_name")
+    async def my_func(x: int) -> str: ...
+    """
+    if _compat.PYDANTIC_V1:
+        raise RuntimeError("Tool functions are only supported with Pydantic v2")
+
+    if func is not None:
+        # @beta_async_tool called without parentheses
+        return BetaAsyncFunctionTool(
+            func=func,
+            name=name,
+            description=description,
+            input_schema=input_schema,
+        )
+
+    # @beta_async_tool()
+    def decorator(func: AsyncFunctionT) -> BetaAsyncFunctionTool[AsyncFunctionT]:
+        return BetaAsyncFunctionTool(
+            func=func,
+            name=name,
+            description=description,
+            input_schema=input_schema,
+        )
+
+    return decorator