chore: Rollback types for backward compatability

Author: comfuture

function_schema/core.py

@@ -2,8 +2,17 @@
 import inspect
 import platform
 import packaging.version
-from typing import Annotated, Optional, Union, Callable, Literal, Any, get_args, get_origin
-from .types import OpenAIFunctionSchema, ClaudeFunctionSchema
+from typing import (
+    Annotated,
+    Optional,
+    Union,
+    Callable,
+    Literal,
+    Any,
+    get_args,
+    get_origin,
+)
+from .types import FunctionSchema
 
 current_version = packaging.version.parse(platform.python_version())
 py_310 = packaging.version.parse("3.10")
@@ -19,28 +28,35 @@
     try:
         from typing_extensions import Doc
     except ImportError:
+
         class Doc:
             def __init__(self, documentation: str, /):
                 self.documentation = documentation
 
+
 __all__ = ("get_function_schema", "guess_type", "Doc", "Annotated")
 
 
-def is_doc_meta(obj: Annotated[Any, Doc("The object to be checked.")]) -> Annotated[
-        bool, Doc("True if the object is a documentation object, False otherwise.")]:
+def is_doc_meta(
+    obj: Annotated[Any, Doc("The object to be checked.")],
+) -> Annotated[
+    bool, Doc("True if the object is a documentation object, False otherwise.")
+]:
     """
     Check if the given object is a documentation object.
 
     Example:
     >>> is_doc_meta(Doc("This is a documentation object"))
     True
     """
-    return getattr(obj, '__class__') == Doc and hasattr(obj, 'documentation')
+    return getattr(obj, "__class__") == Doc and hasattr(obj, "documentation")
 
 
-def unwrap_doc(obj: Annotated[Union[Doc, str],
-                              Doc("The object to get the documentation string from.")]) -> Annotated[
-        str, Doc("The documentation string.")]:
+def unwrap_doc(
+    obj: Annotated[
+        Union[Doc, str], Doc("The object to get the documentation string from.")
+    ],
+) -> Annotated[str, Doc("The documentation string.")]:
     """
     Get the documentation string from the given object.
 
@@ -61,8 +77,7 @@ def get_function_schema(
         Optional[Literal["openai", "claude"]],
         Doc("The format of the schema to return"),
     ] = "openai",
-) -> Annotated[Union[OpenAIFunctionSchema, ClaudeFunctionSchema],
-               Doc("The JSON schema for the given function")]:
+) -> Annotated[FunctionSchema, Doc("The JSON schema for the given function")]:
     """
     Returns a JSON schema for the given function.
 
@@ -127,13 +142,13 @@ def get_function_schema(
             # find description in param_args tuple
             try:
                 description = next(
-                    unwrap_doc(arg)
-                    for arg in param_args if isinstance(arg, Doc)
+                    unwrap_doc(arg) for arg in param_args if isinstance(arg, Doc)
                 )
             except StopIteration:
                 try:
                     description = next(
-                        arg for arg in param_args if isinstance(arg, str))
+                        arg for arg in param_args if isinstance(arg, str)
+                    )
                 except StopIteration:
                     description = "The {name} parameter"
 
@@ -163,8 +178,7 @@ def get_function_schema(
         }
 
         if enum_ is not None:
-            schema["properties"][name]["enum"] = [
-                t for t in enum_ if t is not None]
+            schema["properties"][name]["enum"] = [t for t in enum_ if t is not None]
 
         if default_value is not inspect._empty:
             schema["properties"][name]["default"] = default_value
@@ -194,8 +208,7 @@ def get_function_schema(
 def guess_type(
     T: Annotated[type, Doc("The type to guess the JSON schema type for")],
 ) -> Annotated[
-    Union[str, list[str]], Doc(
-        "str | list of str that representing JSON schema type")
+    Union[str, list[str]], Doc("str | list of str that representing JSON schema type")
 ]:
     """Guesses the JSON schema type for the given python type."""
 

function_schema/types.py

@@ -1,4 +1,4 @@
-from typing import TypedDict, Literal, TypeVar, Union, Generic
+from typing import TypedDict, Literal
 
 try:
     from typing import NotRequired
@@ -37,23 +37,7 @@ class RootProperty(TypedDict):
     properties: dict[str, ParamSchema]
 
 
-T = TypeVar("T", bound=Union["WithParameters", "WithInputSchema"])
-
-
-class WithParameters(TypedDict):
-    parameters: RootProperty
-
-
-class WithInputSchema(TypedDict):
-    input_schema: RootProperty
-
-
-class FunctionSchemaBase(TypedDict):
-    name: str
-    description: str
-
-
-class FunctionSchema(FunctionSchemaBase, Generic[T]):
+class FunctionSchema(TypedDict):
     """
     Represents the schema of a function.
     Attributes:
@@ -63,8 +47,7 @@ class FunctionSchema(FunctionSchemaBase, Generic[T]):
         input_schema (ParamSchema): The schema for the function parameters if format is "claude".
     """
 
-    pass
-
-
-OpenAIFunctionSchema = FunctionSchema[WithParameters]
-ClaudeFunctionSchema = FunctionSchema[WithInputSchema]
+    name: str
+    description: str
+    parameters: NotRequired[RootProperty]
+    input_schema: NotRequired[RootProperty]