pydantic-ai-slim 0.0.6__tar.gz

pydantic_ai_slim-0.0.6/.gitignore

@@ -0,0 +1,15 @@
+site
+.python-version
+.venv
+dist
+__pycache__
+*.env
+/scratch/
+/.coverage
+env*/
+/TODO.md
+/postgres-data/
+.DS_Store
+/pydantic_ai_examples/.chat_app_messages.jsonl
+.cache/
+.docs-insiders-install

pydantic_ai_slim-0.0.6/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.3
+Name: pydantic-ai-slim
+Version: 0.0.6
+Summary: Agent Framework / shim to use Pydantic with LLMs
+Author-email: Samuel Colvin <samuel@pydantic.dev>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: eval-type-backport>=0.2.0
+Requires-Dist: griffe>=1.3.2
+Requires-Dist: httpx>=0.27.2
+Requires-Dist: logfire-api>=1.2.0
+Requires-Dist: pydantic>=2.10
+Provides-Extra: groq
+Requires-Dist: groq>=0.12.0; extra == 'groq'
+Provides-Extra: logfire
+Requires-Dist: logfire>=2.3; extra == 'logfire'
+Provides-Extra: openai
+Requires-Dist: openai>=1.54.3; extra == 'openai'
+Provides-Extra: vertexai
+Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
+Requires-Dist: requests>=2.32.3; extra == 'vertexai'
+Description-Content-Type: text/markdown
+
+# Coming soon
+
+[![CI](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml?query=branch%3Amain)
+[![Coverage](https://coverage-badge.samuelcolvin.workers.dev/pydantic/pydantic-ai.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/pydantic/pydantic-ai)
+[![PyPI](https://img.shields.io/pypi/v/pydantic-ai.svg)](https://pypi.python.org/pypi/pydantic-ai)
+[![versions](https://img.shields.io/pypi/pyversions/pydantic-ai.svg)](https://github.com/pydantic/pydantic-ai)
+[![license](https://img.shields.io/github/license/pydantic/pydantic-ai.svg?v)](https://github.com/pydantic/pydantic-ai/blob/main/LICENSE)

pydantic_ai_slim-0.0.6/README.md

@@ -0,0 +1,7 @@
+# Coming soon
+
+[![CI](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml?query=branch%3Amain)
+[![Coverage](https://coverage-badge.samuelcolvin.workers.dev/pydantic/pydantic-ai.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/pydantic/pydantic-ai)
+[![PyPI](https://img.shields.io/pypi/v/pydantic-ai.svg)](https://pypi.python.org/pypi/pydantic-ai)
+[![versions](https://img.shields.io/pypi/pyversions/pydantic-ai.svg)](https://github.com/pydantic/pydantic-ai)
+[![license](https://img.shields.io/github/license/pydantic/pydantic-ai.svg?v)](https://github.com/pydantic/pydantic-ai/blob/main/LICENSE)

pydantic_ai_slim-0.0.6/pydantic_ai/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import version
+
+from .agent import Agent
+from .dependencies import CallContext
+from .exceptions import ModelRetry, UnexpectedModelBehavior, UserError
+
+__all__ = 'Agent', 'CallContext', 'ModelRetry', 'UnexpectedModelBehavior', 'UserError', '__version__'
+__version__ = version('pydantic_ai_slim')

pydantic_ai_slim-0.0.6/pydantic_ai/_griffe.py

@@ -0,0 +1,128 @@
+from __future__ import annotations as _annotations
+
+import re
+from inspect import Signature
+from typing import Any, Callable, Literal, cast
+
+from _griffe.enumerations import DocstringSectionKind
+from _griffe.models import Docstring, Object as GriffeObject
+
+DocstringStyle = Literal['google', 'numpy', 'sphinx']
+
+
+def doc_descriptions(
+    func: Callable[..., Any], sig: Signature, *, style: DocstringStyle | None = None
+) -> tuple[str, dict[str, str]]:
+    """Extract the function description and parameter descriptions from a function's docstring.
+
+    Returns:
+        A tuple of (main function description, parameter descriptions).
+    """
+    doc = func.__doc__
+    if doc is None:
+        return '', {}
+
+    # see https://github.com/mkdocstrings/griffe/issues/293
+    parent = cast(GriffeObject, sig)
+
+    docstring = Docstring(doc, lineno=1, parser=style or _infer_docstring_style(doc), parent=parent)
+    sections = docstring.parse()
+
+    params = {}
+    if parameters := next((p for p in sections if p.kind == DocstringSectionKind.parameters), None):
+        params = {p.name: p.description for p in parameters.value}
+
+    main_desc = ''
+    if main := next((p for p in sections if p.kind == DocstringSectionKind.text), None):
+        main_desc = main.value
+
+    return main_desc, params
+
+
+def _infer_docstring_style(doc: str) -> DocstringStyle:
+    """Simplistic docstring style inference."""
+    for pattern, replacements, style in _docstring_style_patterns:
+        matches = (
+            re.search(pattern.format(replacement), doc, re.IGNORECASE | re.MULTILINE) for replacement in replacements
+        )
+        if any(matches):
+            return style
+    # fallback to google style
+    return 'google'
+
+
+# See https://github.com/mkdocstrings/griffe/issues/329#issuecomment-2425017804
+_docstring_style_patterns: list[tuple[str, list[str], DocstringStyle]] = [
+    (
+        r'\n[ \t]*:{0}([ \t]+\w+)*:([ \t]+.+)?\n',
+        [
+            'param',
+            'parameter',
+            'arg',
+            'argument',
+            'key',
+            'keyword',
+            'type',
+            'var',
+            'ivar',
+            'cvar',
+            'vartype',
+            'returns',
+            'return',
+            'rtype',
+            'raises',
+            'raise',
+            'except',
+            'exception',
+        ],
+        'sphinx',
+    ),
+    (
+        r'\n[ \t]*{0}:([ \t]+.+)?\n[ \t]+.+',
+        [
+            'args',
+            'arguments',
+            'params',
+            'parameters',
+            'keyword args',
+            'keyword arguments',
+            'other args',
+            'other arguments',
+            'other params',
+            'other parameters',
+            'raises',
+            'exceptions',
+            'returns',
+            'yields',
+            'receives',
+            'examples',
+            'attributes',
+            'functions',
+            'methods',
+            'classes',
+            'modules',
+            'warns',
+            'warnings',
+        ],
+        'google',
+    ),
+    (
+        r'\n[ \t]*{0}\n[ \t]*---+\n',
+        [
+            'deprecated',
+            'parameters',
+            'other parameters',
+            'returns',
+            'yields',
+            'receives',
+            'raises',
+            'warns',
+            'attributes',
+            'functions',
+            'methods',
+            'classes',
+            'modules',
+        ],
+        'numpy',
+    ),
+]

pydantic_ai_slim-0.0.6/pydantic_ai/_pydantic.py

@@ -0,0 +1,216 @@
+"""Used to build pydantic validators and JSON schemas from functions.
+
+This module has to use numerous internal Pydantic APIs and is therefore brittle to changes in Pydantic.
+"""
+
+from __future__ import annotations as _annotations
+
+from inspect import Parameter, signature
+from typing import TYPE_CHECKING, Any, TypedDict, cast, get_origin
+
+from pydantic import ConfigDict, TypeAdapter
+from pydantic._internal import _decorators, _generate_schema, _typing_extra
+from pydantic._internal._config import ConfigWrapper
+from pydantic.fields import FieldInfo
+from pydantic.json_schema import GenerateJsonSchema
+from pydantic.plugin._schema_validator import create_schema_validator
+from pydantic_core import SchemaValidator, core_schema
+
+from ._griffe import doc_descriptions
+from ._utils import ObjectJsonSchema, check_object_json_schema, is_model_like
+
+if TYPE_CHECKING:
+    from . import _retriever
+    from .dependencies import AgentDeps, RetrieverParams
+
+
+__all__ = 'function_schema', 'LazyTypeAdapter'
+
+
+class FunctionSchema(TypedDict):
+    """Internal information about a function schema."""
+
+    description: str
+    validator: SchemaValidator
+    json_schema: ObjectJsonSchema
+    # if not None, the function takes a single by that name (besides potentially `info`)
+    single_arg_name: str | None
+    positional_fields: list[str]
+    var_positional_field: str | None
+
+
+def function_schema(either_function: _retriever.RetrieverEitherFunc[AgentDeps, RetrieverParams]) -> FunctionSchema:  # noqa: C901
+    """Build a Pydantic validator and JSON schema from a retriever function.
+
+    Args:
+        either_function: The function to build a validator and JSON schema for.
+
+    Returns:
+        A `FunctionSchema` instance.
+    """
+    function = either_function.whichever()
+    takes_ctx = either_function.is_left()
+    config = ConfigDict(title=function.__name__)
+    config_wrapper = ConfigWrapper(config)
+    gen_schema = _generate_schema.GenerateSchema(config_wrapper)
+
+    sig = signature(function)
+
+    type_hints = _typing_extra.get_function_type_hints(function)
+
+    var_kwargs_schema: core_schema.CoreSchema | None = None
+    fields: dict[str, core_schema.TypedDictField] = {}
+    positional_fields: list[str] = []
+    var_positional_field: str | None = None
+    errors: list[str] = []
+    decorators = _decorators.DecoratorInfos()
+    description, field_descriptions = doc_descriptions(function, sig)
+
+    for index, (name, p) in enumerate(sig.parameters.items()):
+        if p.annotation is sig.empty:
+            if takes_ctx and index == 0:
+                # should be the `context` argument, skip
+                continue
+            # TODO warn?
+            annotation = Any
+        else:
+            annotation = type_hints[name]
+
+            if index == 0 and takes_ctx:
+                if not _is_call_ctx(annotation):
+                    errors.append('First argument must be a CallContext instance when using `.retriever`')
+                continue
+            elif not takes_ctx and _is_call_ctx(annotation):
+                errors.append('CallContext instance can only be used with `.retriever`')
+                continue
+            elif index != 0 and _is_call_ctx(annotation):
+                errors.append('CallContext instance can only be used as the first argument')
+                continue
+
+        field_name = p.name
+        if p.kind == Parameter.VAR_KEYWORD:
+            var_kwargs_schema = gen_schema.generate_schema(annotation)
+        else:
+            if p.kind == Parameter.VAR_POSITIONAL:
+                annotation = list[annotation]
+
+            # FieldInfo.from_annotation expects a type, `annotation` is Any
+            annotation = cast(type[Any], annotation)
+            field_info = FieldInfo.from_annotation(annotation)
+            if field_info.description is None:
+                field_info.description = field_descriptions.get(field_name)
+
+            fields[field_name] = td_schema = gen_schema._generate_td_field_schema(  # pyright: ignore[reportPrivateUsage]
+                field_name,
+                field_info,
+                decorators,
+            )
+            # noinspection PyTypeChecker
+            td_schema.setdefault('metadata', {})['is_model_like'] = is_model_like(annotation)
+
+            if p.kind == Parameter.POSITIONAL_ONLY:
+                positional_fields.append(field_name)
+            elif p.kind == Parameter.VAR_POSITIONAL:
+                var_positional_field = field_name
+
+    if errors:
+        from .exceptions import UserError
+
+        error_details = '\n  '.join(errors)
+        raise UserError(f'Error generating schema for {function.__qualname__}:\n  {error_details}')
+
+    core_config = config_wrapper.core_config(None)
+    # noinspection PyTypedDict
+    core_config['extra_fields_behavior'] = 'allow' if var_kwargs_schema else 'forbid'
+
+    schema, single_arg_name = _build_schema(fields, var_kwargs_schema, gen_schema, core_config)
+    schema = gen_schema.clean_schema(schema)
+    # noinspection PyUnresolvedReferences
+    schema_validator = create_schema_validator(
+        schema,
+        function,
+        function.__module__,
+        function.__qualname__,
+        'validate_call',
+        core_config,
+        config_wrapper.plugin_settings,
+    )
+    # PluggableSchemaValidator is api compatible with SchemaValidator
+    schema_validator = cast(SchemaValidator, schema_validator)
+    json_schema = GenerateJsonSchema().generate(schema)
+
+    # workaround for https://github.com/pydantic/pydantic/issues/10785
+    # if we build a custom TypeDict schema (matches when `single_arg_name` is None), we manually set
+    # `additionalProperties` in the JSON Schema
+    if single_arg_name is None:
+        json_schema['additionalProperties'] = bool(var_kwargs_schema)
+
+    # instead of passing `description` through in core_schema, we just add it here
+    if description:
+        json_schema = {'description': description} | json_schema
+
+    return FunctionSchema(
+        description=description,
+        validator=schema_validator,
+        json_schema=check_object_json_schema(json_schema),
+        single_arg_name=single_arg_name,
+        positional_fields=positional_fields,
+        var_positional_field=var_positional_field,
+    )
+
+
+def _build_schema(
+    fields: dict[str, core_schema.TypedDictField],
+    var_kwargs_schema: core_schema.CoreSchema | None,
+    gen_schema: _generate_schema.GenerateSchema,
+    core_config: core_schema.CoreConfig,
+) -> tuple[core_schema.CoreSchema, str | None]:
+    """Generate a typed dict schema for function parameters.
+
+    Args:
+        fields: The fields to generate a typed dict schema for.
+        var_kwargs_schema: The variable keyword arguments schema.
+        gen_schema: The `GenerateSchema` instance.
+        core_config: The core configuration.
+
+    Returns:
+        tuple of (generated core schema, single arg name).
+    """
+    if len(fields) == 1 and var_kwargs_schema is None:
+        name = next(iter(fields))
+        td_field = fields[name]
+        if td_field['metadata']['is_model_like']:  # type: ignore
+            return td_field['schema'], name
+
+    td_schema = core_schema.typed_dict_schema(
+        fields,
+        config=core_config,
+        extras_schema=gen_schema.generate_schema(var_kwargs_schema) if var_kwargs_schema else None,
+    )
+    return td_schema, None
+
+
+def _is_call_ctx(annotation: Any) -> bool:
+    from .dependencies import CallContext
+
+    return annotation is CallContext or (
+        _typing_extra.is_generic_alias(annotation) and get_origin(annotation) is CallContext
+    )
+
+
+if TYPE_CHECKING:
+    LazyTypeAdapter = TypeAdapter
+else:
+
+    class LazyTypeAdapter:
+        __slots__ = '_args', '_kwargs', '_type_adapter'
+
+        def __init__(self, *args, **kwargs):
+            self._args = args
+            self._kwargs = kwargs
+            self._type_adapter = None
+
+        def __getattr__(self, item):
+            if self._type_adapter is None:
+                self._type_adapter = TypeAdapter(*self._args, **self._kwargs)
+            return getattr(self._type_adapter, item)

pydantic_ai_slim-0.0.6/pydantic_ai/_result.py

@@ -0,0 +1,258 @@
+from __future__ import annotations as _annotations
+
+import inspect
+import sys
+import types
+from collections.abc import Awaitable
+from dataclasses import dataclass, field
+from typing import Any, Callable, Generic, Literal, Union, cast, get_args, get_origin
+
+from pydantic import TypeAdapter, ValidationError
+from typing_extensions import Self, TypeAliasType, TypedDict
+
+from . import _utils, messages
+from .dependencies import AgentDeps, CallContext, ResultValidatorFunc
+from .exceptions import ModelRetry
+from .messages import ModelStructuredResponse, ToolCall
+from .result import ResultData
+
+
+@dataclass
+class ResultValidator(Generic[AgentDeps, ResultData]):
+    function: ResultValidatorFunc[AgentDeps, ResultData]
+    _takes_ctx: bool = field(init=False)
+    _is_async: bool = field(init=False)
+
+    def __post_init__(self):
+        self._takes_ctx = len(inspect.signature(self.function).parameters) > 1
+        self._is_async = inspect.iscoroutinefunction(self.function)
+
+    async def validate(
+        self, result: ResultData, deps: AgentDeps, retry: int, tool_call: messages.ToolCall | None
+    ) -> ResultData:
+        """Validate a result but calling the function.
+
+        Args:
+            result: The result data after Pydantic validation the message content.
+            deps: The agent dependencies.
+            retry: The current retry number.
+            tool_call: The original tool call message, `None` if there was no tool call.
+
+        Returns:
+            Result of either the validated result data (ok) or a retry message (Err).
+        """
+        if self._takes_ctx:
+            args = CallContext(deps, retry, tool_call.tool_name if tool_call else None), result
+        else:
+            args = (result,)
+
+        try:
+            if self._is_async:
+                function = cast(Callable[[Any], Awaitable[ResultData]], self.function)
+                result_data = await function(*args)
+            else:
+                function = cast(Callable[[Any], ResultData], self.function)
+                result_data = await _utils.run_in_executor(function, *args)
+        except ModelRetry as r:
+            m = messages.RetryPrompt(content=r.message)
+            if tool_call is not None:
+                m.tool_name = tool_call.tool_name
+                m.tool_id = tool_call.tool_id
+            raise ToolRetryError(m) from r
+        else:
+            return result_data
+
+
+class ToolRetryError(Exception):
+    """Internal exception used to signal a `ToolRetry` message should be returned to the LLM."""
+
+    def __init__(self, tool_retry: messages.RetryPrompt):
+        self.tool_retry = tool_retry
+        super().__init__()
+
+
+@dataclass
+class ResultSchema(Generic[ResultData]):
+    """Model the final response from an agent run.
+
+    Similar to `Retriever` but for the final result of running an agent.
+    """
+
+    tools: dict[str, ResultTool[ResultData]]
+    allow_text_result: bool
+
+    @classmethod
+    def build(cls, response_type: type[ResultData], name: str, description: str | None) -> Self | None:
+        """Build a ResultSchema dataclass from a response type."""
+        if response_type is str:
+            return None
+
+        if response_type_option := extract_str_from_union(response_type):
+            response_type = response_type_option.value
+            allow_text_result = True
+        else:
+            allow_text_result = False
+
+        def _build_tool(a: Any, tool_name_: str, multiple: bool) -> ResultTool[ResultData]:
+            return cast(
+                ResultTool[ResultData],
+                ResultTool.build(a, tool_name_, description, multiple),  # pyright: ignore[reportUnknownMemberType]
+            )
+
+        tools: dict[str, ResultTool[ResultData]] = {}
+        if args := get_union_args(response_type):
+            for i, arg in enumerate(args, start=1):
+                tool_name = union_tool_name(name, arg)
+                while tool_name in tools:
+                    tool_name = f'{tool_name}_{i}'
+                tools[tool_name] = _build_tool(arg, tool_name, True)
+        else:
+            tools[name] = _build_tool(response_type, name, False)
+
+        return cls(tools=tools, allow_text_result=allow_text_result)
+
+    def find_tool(self, message: ModelStructuredResponse) -> tuple[ToolCall, ResultTool[ResultData]] | None:
+        """Find a tool that matches one of the calls."""
+        for call in message.calls:
+            if result := self.tools.get(call.tool_name):
+                return call, result
+
+    def tool_names(self) -> list[str]:
+        """Return the names of the tools."""
+        return list(self.tools.keys())
+
+
+DEFAULT_DESCRIPTION = 'The final response which ends this conversation'
+
+
+@dataclass
+class ResultTool(Generic[ResultData]):
+    name: str
+    description: str
+    type_adapter: TypeAdapter[Any]
+    json_schema: _utils.ObjectJsonSchema
+    outer_typed_dict_key: str | None
+
+    @classmethod
+    def build(cls, response_type: type[ResultData], name: str, description: str | None, multiple: bool) -> Self | None:
+        """Build a ResultTool dataclass from a response type."""
+        assert response_type is not str, 'ResultTool does not support str as a response type'
+
+        if _utils.is_model_like(response_type):
+            type_adapter = TypeAdapter(response_type)
+            outer_typed_dict_key: str | None = None
+            # noinspection PyArgumentList
+            json_schema = _utils.check_object_json_schema(type_adapter.json_schema())
+        else:
+            response_data_typed_dict = TypedDict('response_data_typed_dict', {'response': response_type})  # noqa
+            type_adapter = TypeAdapter(response_data_typed_dict)
+            outer_typed_dict_key = 'response'
+            # noinspection PyArgumentList
+            json_schema = _utils.check_object_json_schema(type_adapter.json_schema())
+            # including `response_data_typed_dict` as a title here doesn't add anything and could confuse the LLM
+            json_schema.pop('title')
+
+        if json_schema_description := json_schema.pop('description', None):
+            if description is None:
+                tool_description = json_schema_description
+            else:
+                tool_description = f'{description}. {json_schema_description}'
+        else:
+            tool_description = description or DEFAULT_DESCRIPTION
+            if multiple:
+                tool_description = f'{union_arg_name(response_type)}: {tool_description}'
+
+        return cls(
+            name=name,
+            description=tool_description,
+            type_adapter=type_adapter,
+            json_schema=json_schema,
+            outer_typed_dict_key=outer_typed_dict_key,
+        )
+
+    def validate(
+        self, tool_call: messages.ToolCall, allow_partial: bool = False, wrap_validation_errors: bool = True
+    ) -> ResultData:
+        """Validate a result message.
+
+        Args:
+            tool_call: The tool call from the LLM to validate.
+            allow_partial: If true, allow partial validation.
+            wrap_validation_errors: If true, wrap the validation errors in a retry message.
+
+        Returns:
+            Either the validated result data (left) or a retry message (right).
+        """
+        try:
+            pyd_allow_partial: Literal['off', 'trailing-strings'] = 'trailing-strings' if allow_partial else 'off'
+            if isinstance(tool_call.args, messages.ArgsJson):
+                result = self.type_adapter.validate_json(
+                    tool_call.args.args_json or '', experimental_allow_partial=pyd_allow_partial
+                )
+            else:
+                result = self.type_adapter.validate_python(
+                    tool_call.args.args_object, experimental_allow_partial=pyd_allow_partial
+                )
+        except ValidationError as e:
+            if wrap_validation_errors:
+                m = messages.RetryPrompt(
+                    tool_name=tool_call.tool_name,
+                    content=e.errors(include_url=False),
+                    tool_id=tool_call.tool_id,
+                )
+                raise ToolRetryError(m) from e
+            else:
+                raise
+        else:
+            if k := self.outer_typed_dict_key:
+                result = result[k]
+            return result
+
+
+def union_tool_name(base_name: str, union_arg: Any) -> str:
+    return f'{base_name}_{union_arg_name(union_arg)}'
+
+
+def union_arg_name(union_arg: Any) -> str:
+    return union_arg.__name__
+
+
+def extract_str_from_union(response_type: Any) -> _utils.Option[Any]:
+    """Extract the string type from a Union, return the remaining union or remaining type."""
+    union_args = get_union_args(response_type)
+    if any(t is str for t in union_args):
+        remain_args: list[Any] = []
+        includes_str = False
+        for arg in union_args:
+            if arg is str:
+                includes_str = True
+            else:
+                remain_args.append(arg)
+        if includes_str:
+            if len(remain_args) == 1:
+                return _utils.Some(remain_args[0])
+            else:
+                return _utils.Some(Union[tuple(remain_args)])
+
+
+def get_union_args(tp: Any) -> tuple[Any, ...]:
+    """Extract the arguments of a Union type if `response_type` is a union, otherwise return an empty union."""
+    if isinstance(tp, TypeAliasType):
+        tp = tp.__value__
+
+    origin = get_origin(tp)
+    if origin_is_union(origin):
+        return get_args(tp)
+    else:
+        return ()
+
+
+if sys.version_info < (3, 10):
+
+    def origin_is_union(tp: type[Any] | None) -> bool:
+        return tp is Union
+
+else:
+
+    def origin_is_union(tp: type[Any] | None) -> bool:
+        return tp is Union or tp is types.UnionType