mirascope 1.0.5__py3-none-any.whl → 2.1.1__py3-none-any.whl

mirascope/core/base/_call_factory.py

@@ -1,323 +0,0 @@
-"""The `call_factory` method for generating provider specific call decorators."""
-
-from collections.abc import AsyncIterable, Callable, Iterable
-from enum import Enum
-from functools import partial
-from typing import (
-    Annotated,
-    Literal,
-    NoReturn,
-    TypeVar,
-    overload,
-)
-
-from pydantic import BaseModel
-
-from ._create import create_factory
-from ._extract import extract_factory
-from ._utils import (
-    BaseType,
-    GetJsonOutput,
-    HandleStream,
-    HandleStreamAsync,
-    LLMFunctionDecorator,
-    SetupCall,
-)
-from .call_params import BaseCallParams
-from .call_response import BaseCallResponse
-from .call_response_chunk import BaseCallResponseChunk
-from .dynamic_config import BaseDynamicConfig
-from .stream import BaseStream, stream_factory
-from .structured_stream import structured_stream_factory
-from .tool import BaseTool
-
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound=BaseCallResponse)
-_BaseCallResponseChunkT = TypeVar(
-    "_BaseCallResponseChunkT", bound=BaseCallResponseChunk
-)
-_ResponseModelT = TypeVar(
-    "_ResponseModelT", bound=BaseModel | BaseType | Enum | Annotated
-)
-_ParsedOutputT = TypeVar("_ParsedOutputT")
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", bound=BaseCallParams)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-_BaseStreamT = TypeVar("_BaseStreamT", bound=BaseStream)
-_BaseClientT = TypeVar("_BaseClientT", bound=object)
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_ResponseT = TypeVar("_ResponseT")
-_ResponseChunkT = TypeVar("_ResponseChunkT")
-
-
-def call_factory(  # noqa: ANN202
-    *,
-    TCallResponse: type[_BaseCallResponseT],
-    TCallResponseChunk: type[_BaseCallResponseChunkT],
-    TDynamicConfig: type[_BaseDynamicConfigT],
-    TToolType: type[_BaseToolT],
-    TStream: type[_BaseStreamT],
-    TCallParams: type[_BaseCallParamsT],
-    default_call_params: _BaseCallParamsT,
-    setup_call: SetupCall[
-        _BaseClientT,
-        _BaseDynamicConfigT,
-        _BaseCallParamsT,
-        _ResponseT,
-        _ResponseChunkT,
-        _BaseToolT,
-    ],
-    get_json_output: GetJsonOutput[_BaseCallResponseT | _BaseCallResponseChunkT],
-    handle_stream: HandleStream[_ResponseChunkT, _BaseCallResponseChunkT, _BaseToolT],
-    handle_stream_async: HandleStreamAsync[
-        _ResponseChunkT, _BaseCallResponseChunkT, _BaseToolT
-    ],
-):
-    """A factory method for creating provider-specific call decorators.
-
-    Args:
-        TCallResponse: The provider-specific `BaseCallResponse` type.
-        TCallResponseChunk: The provider-specific `BaseCallResponseChunk` type.
-        TDynamicConfig: The provider-specific `BaseDynamicConfig` type.
-        TToolType: The provider-specific `BaseTool` type.
-        TStream: The provider-specific `BaseStream` type.
-        TCallParams: The provider-specific `BaseCallParams` type.
-        default_call_params: The default call parameters to use, which must match the
-            `TCallParams` type if provided.
-        setup_call: The helper method for setting up a call, which returns the
-            configured create function, the prompt template, the list of
-            provider-specific messages, the list of provider-specific tool types, and
-            the finalized `call_kwargs` with which to make the API call with the create
-            function.
-        get_json_output: The helper method for getting JSON output from a call response.
-        handle_stream: The helper method for converting a provider's original stream
-            generator into a generator that returns tuples of `(chunk, tool)` where
-            `chunk` and `tool` are provider-specific `BaseCallResponseChunk` and
-            `BaseTool` instances, respectively.
-        handle_stream_async: The same helper method as `handle_stream` except for
-            handling asynchronous streaming.
-    """
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> LLMFunctionDecorator[TDynamicConfig, TCallResponse, TCallResponse]: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[TCallResponse], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> LLMFunctionDecorator[TDynamicConfig, _ParsedOutputT, _ParsedOutputT]: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[TCallResponseChunk], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> NoReturn: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[True] = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> LLMFunctionDecorator[TDynamicConfig, TStream, TStream]: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[True] = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[TCallResponseChunk], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> NoReturn: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[True] = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[TCallResponse], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> NoReturn: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> LLMFunctionDecorator[TDynamicConfig, _ResponseModelT, _ResponseModelT]: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> LLMFunctionDecorator[TDynamicConfig, _ParsedOutputT, _ParsedOutputT]: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[True],
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> LLMFunctionDecorator[
-        TDynamicConfig, Iterable[_ResponseModelT], AsyncIterable[_ResponseModelT]
-    ]: ...
-
-    @overload
-    def base_call(
-        model: str,
-        *,
-        stream: Literal[True],
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[TCallResponse], _ParsedOutputT]
-        | Callable[[TCallResponseChunk], _ParsedOutputT]
-        | Callable[[_ResponseModelT], _ParsedOutputT]
-        | None,
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> NoReturn: ...
-
-    def base_call(
-        model: str,
-        *,
-        stream: bool = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT] | None = None,
-        output_parser: Callable[[TCallResponse], _ParsedOutputT]
-        | Callable[[TCallResponseChunk], _ParsedOutputT]
-        | Callable[[_ResponseModelT], _ParsedOutputT]
-        | None = None,
-        json_mode: bool = False,
-        client: _BaseClientT | None = None,
-        call_params: TCallParams | None = None,
-    ) -> LLMFunctionDecorator[
-        TDynamicConfig,
-        TCallResponse
-        | _ParsedOutputT
-        | TStream
-        | _ResponseModelT
-        | Iterable[_ResponseModelT],
-        TCallResponse
-        | _ParsedOutputT
-        | TStream
-        | _ResponseModelT
-        | AsyncIterable[_ResponseModelT],
-    ]:
-        if stream and output_parser:
-            raise ValueError("Cannot use `output_parser` with `stream=True`.")
-
-        if call_params is None:
-            call_params = default_call_params
-
-        if response_model:
-            if stream:
-                return partial(
-                    structured_stream_factory(
-                        TCallResponse=TCallResponse,
-                        TCallResponseChunk=TCallResponseChunk,
-                        TStream=TStream,
-                        TToolType=TToolType,
-                        setup_call=setup_call,
-                        get_json_output=get_json_output,
-                    ),
-                    model=model,
-                    response_model=response_model,
-                    json_mode=json_mode,
-                    client=client,
-                    call_params=call_params,
-                )  # type: ignore
-            else:
-                return partial(
-                    extract_factory(
-                        TCallResponse=TCallResponse,
-                        TToolType=TToolType,
-                        setup_call=setup_call,
-                        get_json_output=get_json_output,
-                    ),
-                    model=model,
-                    response_model=response_model,
-                    output_parser=output_parser,
-                    json_mode=json_mode,
-                    client=client,
-                    call_params=call_params,
-                )  # type: ignore
-        if stream:
-            return partial(
-                stream_factory(
-                    TCallResponse=TCallResponse,
-                    TStream=TStream,
-                    setup_call=setup_call,
-                    handle_stream=handle_stream,
-                    handle_stream_async=handle_stream_async,
-                ),
-                model=model,
-                tools=tools,
-                json_mode=json_mode,
-                client=client,
-                call_params=call_params,
-            )  # type: ignore
-        return partial(
-            create_factory(TCallResponse=TCallResponse, setup_call=setup_call),
-            model=model,
-            tools=tools,
-            output_parser=output_parser,
-            json_mode=json_mode,
-            client=client,
-            call_params=call_params,
-        )  # type: ignore
-
-    return base_call

mirascope/core/base/_create.py

@@ -1,167 +0,0 @@
-"""The `create_factory` method for generating provider specific create decorators."""
-
-import datetime
-import inspect
-from collections.abc import Awaitable, Callable
-from functools import wraps
-from typing import ParamSpec, TypeVar, overload
-
-from ._utils import (
-    SetupCall,
-    get_fn_args,
-    get_metadata,
-    get_possible_user_message_param,
-)
-from .call_params import BaseCallParams
-from .call_response import BaseCallResponse
-from .dynamic_config import BaseDynamicConfig
-from .tool import BaseTool
-
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound=BaseCallResponse)
-_BaseClientT = TypeVar("_BaseClientT", bound=object)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-_ParsedOutputT = TypeVar("_ParsedOutputT")
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", bound=BaseCallParams)
-_ResponseT = TypeVar("_ResponseT")
-_ResponseChunkT = TypeVar("_ResponseChunkT")
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_P = ParamSpec("_P")
-
-
-def create_factory(  # noqa: ANN202
-    *,
-    TCallResponse: type[_BaseCallResponseT],
-    setup_call: SetupCall[
-        _BaseClientT,
-        _BaseDynamicConfigT,
-        _BaseCallParamsT,
-        _ResponseT,
-        _ResponseChunkT,
-        _BaseToolT,
-    ],
-):
-    """Returns the wrapped function with the provider specific interfaces."""
-
-    @overload
-    def decorator(
-        fn: Callable[_P, _BaseDynamicConfigT],
-        model: str,
-        tools: list[type[BaseTool] | Callable] | None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT] | None,
-        json_mode: bool,
-        client: _BaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[_P, _BaseCallResponseT | _ParsedOutputT]: ...
-
-    @overload
-    def decorator(
-        fn: Callable[_P, Awaitable[_BaseDynamicConfigT]],
-        model: str,
-        tools: list[type[BaseTool] | Callable] | None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT] | None,
-        json_mode: bool,
-        client: _BaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[
-        _P,
-        Awaitable[_BaseCallResponseT | _ParsedOutputT],
-    ]: ...
-
-    def decorator(
-        fn: Callable[_P, _BaseDynamicConfigT | Awaitable[_BaseDynamicConfigT]],
-        model: str,
-        tools: list[type[BaseTool] | Callable] | None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT] | None,
-        json_mode: bool,
-        client: _BaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[
-        _P,
-        _BaseCallResponseT
-        | _ParsedOutputT
-        | Awaitable[_BaseCallResponseT | _ParsedOutputT],
-    ]:
-        if inspect.iscoroutinefunction(fn):
-
-            @wraps(fn)
-            async def inner_async(
-                *args: _P.args, **kwargs: _P.kwargs
-            ) -> TCallResponse | _ParsedOutputT:
-                assert SetupCall.fn_is_async(fn)
-                fn_args = get_fn_args(fn, args, kwargs)
-                dynamic_config = await fn(*args, **kwargs)
-                create, prompt_template, messages, tool_types, call_kwargs = setup_call(
-                    model=model,
-                    client=client,
-                    fn=fn,
-                    fn_args=fn_args,
-                    dynamic_config=dynamic_config,
-                    tools=tools,
-                    json_mode=json_mode,
-                    call_params=call_params,
-                    extract=False,
-                )
-                start_time = datetime.datetime.now().timestamp() * 1000
-                response = await create(stream=False, **call_kwargs)
-                end_time = datetime.datetime.now().timestamp() * 1000
-                output = TCallResponse(
-                    metadata=get_metadata(fn, dynamic_config),
-                    response=response,
-                    tool_types=tool_types,  # type: ignore
-                    prompt_template=prompt_template,
-                    fn_args=fn_args,
-                    dynamic_config=dynamic_config,
-                    messages=messages,
-                    call_params=call_params,
-                    call_kwargs=call_kwargs,
-                    user_message_param=get_possible_user_message_param(messages),
-                    start_time=start_time,
-                    end_time=end_time,
-                )
-                output._model = model
-                return output if not output_parser else output_parser(output)
-
-            return inner_async
-        else:
-
-            @wraps(fn)
-            def inner(
-                *args: _P.args, **kwargs: _P.kwargs
-            ) -> TCallResponse | _ParsedOutputT:
-                assert SetupCall.fn_is_sync(fn)
-                fn_args = get_fn_args(fn, args, kwargs)
-                dynamic_config = fn(*args, **kwargs)
-                create, prompt_template, messages, tool_types, call_kwargs = setup_call(
-                    model=model,
-                    client=client,
-                    fn=fn,
-                    fn_args=fn_args,
-                    dynamic_config=dynamic_config,
-                    tools=tools,
-                    json_mode=json_mode,
-                    call_params=call_params,
-                    extract=False,
-                )
-                start_time = datetime.datetime.now().timestamp() * 1000
-                response = create(stream=False, **call_kwargs)
-                end_time = datetime.datetime.now().timestamp() * 1000
-                output = TCallResponse(
-                    metadata=get_metadata(fn, dynamic_config),
-                    response=response,
-                    tool_types=tool_types,  # type: ignore
-                    prompt_template=prompt_template,
-                    fn_args=fn_args,
-                    dynamic_config=dynamic_config,
-                    messages=messages,
-                    call_params=call_params,
-                    call_kwargs=call_kwargs,
-                    user_message_param=get_possible_user_message_param(messages),
-                    start_time=start_time,
-                    end_time=end_time,
-                )
-                output._model = model
-                return output if not output_parser else output_parser(output)
-
-            return inner
-
-    return decorator

mirascope/core/base/_extract.py

@@ -1,139 +0,0 @@
-"""The `extract_factory` method for generating provider specific create decorators."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from functools import wraps
-from typing import ParamSpec, TypeVar, overload
-
-from pydantic import BaseModel, ValidationError
-
-from ._create import create_factory
-from ._utils import (
-    BaseType,
-    GetJsonOutput,
-    SetupCall,
-    extract_tool_return,
-    setup_extract_tool,
-)
-from .call_params import BaseCallParams
-from .call_response import BaseCallResponse
-from .dynamic_config import BaseDynamicConfig
-from .tool import BaseTool
-
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound=BaseCallResponse)
-_BaseClientT = TypeVar("_BaseClientT", bound=object)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-_ParsedOutputT = TypeVar("_ParsedOutputT")
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", bound=BaseCallParams)
-_ResponseT = TypeVar("_ResponseT")
-_ResponseChunkT = TypeVar("_ResponseChunkT")
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_ResponseModelT = TypeVar("_ResponseModelT", bound=BaseModel | BaseType)
-_P = ParamSpec("_P")
-
-
-def extract_factory(  # noqa: ANN202
-    *,
-    TCallResponse: type[_BaseCallResponseT],
-    TToolType: type[BaseTool],
-    setup_call: SetupCall[
-        _BaseClientT,
-        _BaseDynamicConfigT,
-        _BaseCallParamsT,
-        _ResponseT,
-        _ResponseChunkT,
-        _BaseToolT,
-    ],
-    get_json_output: GetJsonOutput[_BaseCallResponseT],
-):
-    """Returns the wrapped function with the provider specific interfaces."""
-    create_decorator = create_factory(
-        TCallResponse=TCallResponse, setup_call=setup_call
-    )
-
-    @overload
-    def decorator(
-        fn: Callable[_P, _BaseDynamicConfigT],
-        model: str,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT] | None,
-        json_mode: bool,
-        client: _BaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[_P, _ResponseModelT | _ParsedOutputT]: ...
-
-    @overload
-    def decorator(
-        fn: Callable[_P, Awaitable[_BaseDynamicConfigT]],
-        model: str,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT] | None,
-        json_mode: bool,
-        client: _BaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[_P, Awaitable[_ResponseModelT | _ParsedOutputT]]: ...
-
-    def decorator(
-        fn: Callable[_P, _BaseDynamicConfigT | Awaitable[_BaseDynamicConfigT]],
-        model: str,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT] | None,
-        json_mode: bool,
-        client: _BaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[
-        _P,
-        _ResponseModelT | _ParsedOutputT | Awaitable[_ResponseModelT | _ParsedOutputT],
-    ]:
-        tool = setup_extract_tool(response_model, TToolType)
-        create_decorator_kwargs = {
-            "model": model,
-            "tools": [tool],
-            "output_parser": None,
-            "json_mode": json_mode,
-            "client": client,
-            "call_params": call_params,
-        }
-
-        if inspect.iscoroutinefunction(fn):
-
-            @wraps(fn)
-            async def inner_async(
-                *args: _P.args, **kwargs: _P.kwargs
-            ) -> _ResponseModelT:
-                assert SetupCall.fn_is_async(fn)
-                call_response = await create_decorator(
-                    fn=fn, **create_decorator_kwargs
-                )(*args, **kwargs)
-                json_output = get_json_output(call_response, json_mode)
-                try:
-                    output = extract_tool_return(response_model, json_output, False)
-                except ValidationError as e:
-                    e._response = call_response  # type: ignore
-                    raise e
-                if isinstance(output, BaseModel):
-                    output._response = call_response  # type: ignore
-                return output if not output_parser else output_parser(output)  # type: ignore
-
-            return inner_async
-        else:
-
-            @wraps(fn)
-            def inner(*args: _P.args, **kwargs: _P.kwargs) -> _ResponseModelT:
-                assert SetupCall.fn_is_sync(fn)
-                call_response = create_decorator(fn=fn, **create_decorator_kwargs)(
-                    *args, **kwargs
-                )
-                json_output = get_json_output(call_response, json_mode)
-                try:
-                    output = extract_tool_return(response_model, json_output, False)
-                except ValidationError as e:
-                    e._response = call_response  # type: ignore
-                    raise e
-                if isinstance(output, BaseModel):
-                    output._response = call_response  # type: ignore
-                return output if not output_parser else output_parser(output)  # type: ignore
-
-            return inner
-
-    return decorator

mirascope/core/base/_partial.py

@@ -1,63 +0,0 @@
-"""
---------------------------------------------------------------------------------
-Source: https://github.com/pydantic/pydantic/issues/6381#issuecomment-1831607091
-By: silviumarcu
-
-This code is used in accordance with the repository's license, and this reference
-serves as an acknowledgment of the original author's contribution to this project.
---------------------------------------------------------------------------------
-"""
-
-from copy import deepcopy
-from typing import TypeVar
-
-from pydantic import BaseModel, create_model
-from pydantic.fields import FieldInfo
-
-Model = TypeVar("Model", bound=BaseModel)
-
-
-def partial(wrapped_class: type[Model]) -> type[Model]:
-    """Generate a new class with all attributes optionals.
-
-    Notes:
-        This will wrap a class inheriting form BaseModel and will recursively
-        convert all its attributes and its children's attributes to optionals.
-
-    Example:
-
-    ```python
-    @partial
-    class User(BaseModel):
-        name: str
-
-    user = User(name="None")
-    ```
-    """
-
-    def _make_field_optional(
-        field: FieldInfo,
-    ) -> tuple[object, FieldInfo]:
-        tmp_field = deepcopy(field)
-
-        annotation = field.annotation
-        # If the field is a BaseModel, then recursively convert it's
-        # attributes to optionals.
-        if type(annotation) is type(BaseModel):
-            tmp_field.annotation = partial(annotation) | None  # pyright: ignore [reportAttributeAccessIssue,reportArgumentType]
-            tmp_field.default = {}
-        else:
-            tmp_field.annotation = field.annotation | None  # pyright: ignore [reportOptionalOperand,reportAttributeAccessIssue]
-            tmp_field.default = None
-        return tmp_field.annotation, tmp_field
-
-    return create_model(  # type: ignore[no-any-return, call-overload]
-        f"Partial{wrapped_class.__name__}",
-        __base__=wrapped_class,
-        __module__=wrapped_class.__module__,
-        __doc__=wrapped_class.__doc__,
-        **{
-            field_name: _make_field_optional(field_info)
-            for field_name, field_info in wrapped_class.model_fields.items()
-        },  # type: ignore
-    )