qtype 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

qtype/converters/tools_from_module.py

@@ -1,44 +1,22 @@
 import importlib
 import inspect
-from datetime import date, datetime, time
 from typing import Any, Type, Union, get_args, get_origin
 
 from pydantic import BaseModel
 
+from qtype.converters.types import PYTHON_TYPE_TO_PRIMITIVE_TYPE
+from qtype.dsl.base_types import PrimitiveTypeEnum
 from qtype.dsl.model import (
-    ArrayTypeDefinition,
-    ObjectTypeDefinition,
-    PrimitiveTypeEnum,
+    CustomType,
     PythonFunctionTool,
     Variable,
     VariableType,
 )
 
-VARIABLE_TO_TYPE = {
-    # VariableTypeEnum.audio: bytes, # TODO: Define a proper audio type
-    PrimitiveTypeEnum.boolean: bool,  # No boolean type in enum, using Python's
-    PrimitiveTypeEnum.bytes: bytes,
-    PrimitiveTypeEnum.date: date,
-    PrimitiveTypeEnum.datetime: datetime,
-    PrimitiveTypeEnum.int: int,
-    # VariableTypeEnum.file: bytes,  # TODO: Define a proper file type
-    # VariableTypeEnum.image: bytes,  # TODO: Define a proper image type
-    PrimitiveTypeEnum.float: float,
-    PrimitiveTypeEnum.text: str,
-    PrimitiveTypeEnum.time: time,
-    # VariableTypeEnum.video: bytes,  # TODO: Define a proper video type
-}
-
-TYPE_TO_VARIABLE = {v: k for k, v in VARIABLE_TO_TYPE.items()}
-
-assert len(VARIABLE_TO_TYPE) == len(
-    TYPE_TO_VARIABLE
-), "Variable to type mapping is not one-to-one"
-
 
 def tools_from_module(
     module_path: str,
-) -> list[PythonFunctionTool]:
+) -> tuple[list[PythonFunctionTool], list[CustomType]]:
     """
     Load tools from a Python module by introspecting its functions.
 
@@ -64,11 +42,14 @@ def tools_from_module(
                 f"No public functions found in module '{module_path}'"
             )
 
+        custom_types: dict[str, CustomType] = {}
+
         # Create Tool instances from functions
-        return [
-            _create_tool_from_function(func_name, func_info)
+        tools = [
+            _create_tool_from_function(func_name, func_info, custom_types)
             for func_name, func_info in functions.items()
         ]
+        return (tools, list(custom_types.values()))
     except ImportError as e:
         raise ImportError(f"Cannot import module '{module_path}': {e}") from e
 
@@ -132,7 +113,9 @@ def _get_module_functions(
 
 
 def _create_tool_from_function(
-    func_name: str, func_info: dict[str, Any]
+    func_name: str,
+    func_info: dict[str, Any],
+    custom_types: dict[str, CustomType],
 ) -> PythonFunctionTool:
     """
     Convert function metadata into a Tool instance.
@@ -154,8 +137,8 @@ def _create_tool_from_function(
     # Create input variables from function parameters
     input_variables = [
         Variable(
-            id=p["name"],
-            type=_map_python_type_to_variable_type(p["type"]),
+            id=func_name + "." + p["name"],
+            type=_map_python_type_to_variable_type(p["type"], custom_types),
         )
         for p in func_info["parameters"]
     ]
@@ -163,7 +146,9 @@ def _create_tool_from_function(
     # Create output variable based on return type
     tool_id = func_info["module"] + "." + func_name
 
-    output_type = _map_python_type_to_variable_type(func_info["return_type"])
+    output_type = _map_python_type_to_variable_type(
+        func_info["return_type"], custom_types
+    )
 
     output_variable = Variable(
         id=f"{tool_id}.result",
@@ -181,89 +166,28 @@ def _create_tool_from_function(
     )
 
 
-def _map_type_to_dsl(
-    pydantic_type: Type[Any], model_name: str
-) -> VariableType | str:
-    """
-    Recursively maps a Python/Pydantic type to a DSL Type Definition.
-
-    Args:
-        pydantic_type: The type hint to map (e.g., str, list[int], MyPydanticModel).
-        model_name: The name of the model being processed, for generating unique IDs.
-
-    Returns:
-        A PrimitiveTypeEnum member, an ObjectTypeDefinition, an ArrayTypeDefinition,
-        or a string reference to another type.
-    """
-    origin = get_origin(pydantic_type)
-    args = get_args(pydantic_type)
-
-    # --- Handle Lists ---
-    if origin in (list, list):
-        if not args:
-            raise TypeError(
-                "List types must be parameterized, e.g., list[str]."
-            )
-
-        # Recursively map the inner type of the list
-        inner_type = _map_type_to_dsl(args[0], model_name)
-
-        # Create a unique ID for this specific array definition
-        array_id = (
-            f"{model_name}.{getattr(inner_type, 'id', str(inner_type))}_Array"
-        )
-
-        return ArrayTypeDefinition(
-            id=array_id,
-            type=inner_type,
-            description=f"An array of {getattr(inner_type, 'id', inner_type)}.",
-        )
-
-    # --- Handle Unions (specifically for Optional[T]) ---
-    if origin is Union:
-        # Filter out NoneType to handle Optional[T]
-        non_none_args = [arg for arg in args if arg is not type(None)]
-        if len(non_none_args) == 1:
-            return _map_type_to_dsl(non_none_args[0], model_name)
-        else:
-            # For more complex unions, you might decide on a specific handling strategy.
-            # For now, we'll raise an error as it's ambiguous.
-            raise TypeError(
-                "Complex Union types are not supported for automatic conversion."
-            )
-
-    # --- Handle Nested Pydantic Models ---
-    if inspect.isclass(pydantic_type) and issubclass(pydantic_type, BaseModel):
-        # If it's a nested model, recursively call the main function.
-        # This returns a full definition for the nested object.
-        return pydantic_to_object_definition(pydantic_type)
-
-    # --- Handle Primitive Types ---
-    # This could be expanded with more sophisticated mapping.
-
-    if pydantic_type in TYPE_TO_VARIABLE:
-        return TYPE_TO_VARIABLE[pydantic_type]
-
-    raise TypeError(f"Unsupported type for DSL conversion: {pydantic_type}")
-
-
-def pydantic_to_object_definition(
+def _pydantic_to_custom_types(
     model_cls: Type[BaseModel],
-) -> ObjectTypeDefinition:
+    custom_types: dict[str, CustomType],
+) -> str:
     """
-    Converts a Pydantic BaseModel class into a QType ObjectTypeDefinition.
+    Converts a Pydantic BaseModel class into a QType CustomType.
+    This function extracts the model's fields and their types, converting them
+    into a CustomType definition.
 
-    This function introspects the model's fields, recursively converting them
-    into the appropriate DSL type definitions (primitive, object, or array).
+    If multiple nested types are found, they are recursively converted
+    into CustomType definitions.
 
     Args:
         model_cls: The Pydantic model class to convert.
 
     Returns:
-        An ObjectTypeDefinition representing the Pydantic model.
+        A dictionary mapping field names to their corresponding CustomType definitions.
     """
     properties = {}
     model_name = model_cls.__name__
+    if model_name in custom_types:
+        return model_name  # Already processed
 
     for field_name, field_info in model_cls.model_fields.items():
         # Use the annotation (the type hint) for the field
@@ -272,19 +196,35 @@ def pydantic_to_object_definition(
             raise TypeError(
                 f"Field '{field_name}' in '{model_name}' must have a type hint."
             )
+        elif get_origin(field_type) is Union:
+            # Assume the union means it's optional
+            field_type = [
+                t for t in get_args(field_type) if t is not type(None)
+            ][0]
+            rv = _map_python_type_to_type_str(field_type, custom_types)
+            properties[field_name] = f"{rv}?"
+        elif get_origin(field_type) is list:
+            inner_type = get_args(field_type)[0]
+            rv = _map_python_type_to_type_str(inner_type, custom_types)
+            properties[field_name] = f"list[{rv}]"
+        else:
+            properties[field_name] = _map_python_type_to_type_str(
+                field_type, custom_types
+            )
 
-        properties[field_name] = _map_type_to_dsl(field_type, model_name)
-
-    return ObjectTypeDefinition(
+    # Add the custom type to the list
+    custom_types[model_name] = CustomType(
         id=model_name,
-        description=model_cls.__doc__ or f"A definition for {model_name}.",
         properties=properties,
+        description=model_cls.__doc__ or f"Custom type for {model_name}",
     )
+    return model_name
 
 
 def _map_python_type_to_variable_type(
-    python_type: type | None,
-) -> VariableType:
+    python_type: Any,
+    custom_types: dict[str, CustomType],
+) -> str | VariableType:
     """
     Map Python type annotations to QType VariableType.
 
@@ -295,32 +235,27 @@ def _map_python_type_to_variable_type(
         VariableType compatible value.
     """
 
-    if python_type is not None:
-        if python_type in TYPE_TO_VARIABLE:
-            return TYPE_TO_VARIABLE[python_type]
-        else:
-            # If the type is a Pydantic model, use its model_dump method
-            # to convert it to a dictionary representation
-            try:
-                return pydantic_to_object_definition(python_type)
-            except AttributeError:
-                pass
+    if python_type in PYTHON_TYPE_TO_PRIMITIVE_TYPE:
+        return PYTHON_TYPE_TO_PRIMITIVE_TYPE[python_type]
+    elif python_type in get_args(VariableType):
+        # If it's a domain type, return its name
+        return python_type
+    elif inspect.isclass(python_type) and issubclass(python_type, BaseModel):
+        # If it's a Pydantic model, create or retrieve its CustomType definition
+        return _pydantic_to_custom_types(python_type, custom_types)
     raise ValueError(
         f"Unsupported Python type '{python_type}' for VariableType mapping"
     )
 
 
-VARIABLE_TO_TYPE = {
-    # VariableTypeEnum.audio: bytes, # TODO: Define a proper audio type
-    PrimitiveTypeEnum.boolean: bool,  # No boolean type in enum, using Python's
-    PrimitiveTypeEnum.bytes: bytes,
-    PrimitiveTypeEnum.date: date,
-    PrimitiveTypeEnum.datetime: datetime,
-    PrimitiveTypeEnum.int: int,
-    # VariableTypeEnum.file: bytes,  # TODO: Define a proper file type
-    # VariableTypeEnum.image: bytes,  # TODO: Define a proper image type
-    PrimitiveTypeEnum.float: float,
-    PrimitiveTypeEnum.text: str,
-    PrimitiveTypeEnum.time: time,
-    # VariableTypeEnum.video: bytes,  # TODO: Define a proper video type
-}
+def _map_python_type_to_type_str(
+    python_type: Any,
+    custom_types: dict[str, CustomType],
+) -> str:
+    var_type = _map_python_type_to_variable_type(python_type, custom_types)
+    if isinstance(var_type, PrimitiveTypeEnum):
+        return var_type.value
+    elif inspect.isclass(python_type):
+        return python_type.__name__
+    else:
+        return str(python_type)

qtype/converters/types.py

@@ -1,3 +1,5 @@
+from datetime import date, datetime, time
+
 from qtype.dsl.base_types import PrimitiveTypeEnum
 
 """
@@ -13,8 +15,52 @@ PRIMITIVE_TO_PYTHON_TYPE = {
     PrimitiveTypeEnum.file: bytes,  # Use bytes for file content
     PrimitiveTypeEnum.float: float,
     PrimitiveTypeEnum.image: bytes,  # Use bytes for image data
-    PrimitiveTypeEnum.number: float,  # Use float for number representation
     PrimitiveTypeEnum.text: str,
     PrimitiveTypeEnum.time: str,  # Use str for time representation
     PrimitiveTypeEnum.video: bytes,  # Use bytes for video data
 }
+
+PYTHON_TYPE_TO_PRIMITIVE_TYPE = {
+    bytes: PrimitiveTypeEnum.file,
+    bool: PrimitiveTypeEnum.boolean,
+    str: PrimitiveTypeEnum.text,
+    int: PrimitiveTypeEnum.int,
+    float: PrimitiveTypeEnum.float,
+    date: PrimitiveTypeEnum.date,
+    datetime: PrimitiveTypeEnum.datetime,
+    time: PrimitiveTypeEnum.time,
+    # TODO: decide on internal representation for images, video, and audio, or use annotation/hinting
+}
+
+# def create_custom_type(model_cls: Type[BaseModel],) -> CustomType:
+#     """
+#     Create a CustomType from a Pydantic BaseModel.
+
+#     Args:
+#         type: The Pydantic BaseModel class.
+
+#     Returns:
+#         A CustomType instance representing the model.
+#     """
+
+#     properties = {}
+#     for field_name, field_info in model_cls.model_fields.items():
+#         # Use the annotation (the type hint) for the field
+#         field_type = field_info.annotation
+#         if field_type is None:
+#             raise TypeError(
+#                 f"Field '{field_name}' in '{model_name}' must have a type hint."
+#             )
+#         origin = get_origin(field_type)
+
+#         if origin is Union:
+#             # Assume the union means it's optional
+
+
+#     return CustomType(
+#         id=type.__name__,
+#         properties={
+#             name: python_type_to_variable_type(field.type_)
+#             for name, field in type.__fields__.items()
+#         },
+#     )

qtype/dsl/base_types.py

@@ -19,7 +19,6 @@ class PrimitiveTypeEnum(str, Enum):
     file = "file"
     float = "float"
     image = "image"
-    number = "number"
     text = "text"
     time = "time"
     video = "video"

qtype/dsl/custom_types.py

@@ -0,0 +1,73 @@
+from typing import Any, ForwardRef, Type, Union
+
+from pydantic import BaseModel, create_model
+
+from qtype.converters.types import PRIMITIVE_TO_PYTHON_TYPE
+
+# --- This would be in your interpreter's logic ---
+
+
+def build_dynamic_types(
+    type_definitions: list[dict]
+) -> dict[str, Type[BaseModel]]:
+    """
+    Parses a list of simplified type definitions and dynamically creates
+    Pydantic BaseModel classes. It handles out-of-order definitions using
+    a two-pass approach with ForwardRef.
+    """
+    created_models: dict[str, Type[BaseModel]] = {}
+
+    PRIMITIVE_MAP = {k.value: v for k, v in PRIMITIVE_TO_PYTHON_TYPE.items()}
+
+    def _parse_type_string(type_str: str) -> tuple[Any, bool]:
+        """
+        Parses a type string and returns the resolved type and a boolean
+        indicating if the type is optional.
+        """
+        is_optional = False
+        if type_str.endswith("?"):
+            is_optional = True
+            type_str = type_str[:-1]
+
+        if type_str.startswith("list[") and type_str.endswith("]"):
+            inner_type_name = type_str[5:-1]
+            inner_type, _ = _parse_type_string(inner_type_name)
+            resolved_type = list[inner_type]
+        elif type_str in PRIMITIVE_MAP:
+            resolved_type = PRIMITIVE_MAP[type_str]
+        elif type_str in created_models:
+            resolved_type = created_models[type_str]
+        else:
+            # If the type isn't defined yet, create a ForwardRef placeholder.
+            # This is the key to handling out-of-order definitions.
+            resolved_type = ForwardRef(type_str)
+
+        if is_optional:
+            return Union[resolved_type, None], True
+
+        return resolved_type, False
+
+    # --- Pass 1: Create all models, using ForwardRef for unresolved types ---
+    for type_def in type_definitions:
+        model_name = type_def["id"]
+        field_definitions = {}
+
+        if "properties" in type_def:
+            for field_name, type_str in type_def["properties"].items():
+                resolved_type, is_optional = _parse_type_string(type_str)
+                default_value = None if is_optional else ...
+                field_definitions[field_name] = (resolved_type, default_value)
+
+        # Pass the created_models dict as the local namespace for resolution
+        DynamicModel = create_model(
+            model_name, **field_definitions, __localns=created_models
+        )
+        created_models[model_name] = DynamicModel
+
+    # --- Pass 2: Resolve all ForwardRef placeholders ---
+    # This rebuilds the models, linking the placeholders to the actual classes.
+    # We pass `created_models` as the types_namespace for resolution in Pydantic V2.
+    for model in created_models.values():
+        model.model_rebuild(_types_namespace=created_models)
+
+    return created_models

qtype/dsl/document.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import Any, Type, Union, get_args, get_origin
 
 import qtype.dsl.model as dsl
+from qtype.dsl.base_types import PrimitiveTypeEnum
 
 
 def _format_type_name(field_type: Any) -> str:
@@ -56,8 +57,13 @@ def generate_class_docstring(output_file: Path, cls: Type[Any]) -> None:
     class_name = cls.__name__
     docstring = cls.__doc__ or "No documentation available."
 
+    # new lines in the docstring often have indentation, which we want to remove
+    docstring = "\n".join(
+        line.strip() for line in docstring.splitlines() if line.strip()
+    )
+
     with output_file.open("w", encoding="utf-8") as file:
-        file.write(f"# {class_name}\n\n{docstring}\n\n## Members\n")
+        file.write(f"### {class_name}\n\n{docstring}\n\n")
 
         # Handle Pydantic models by checking for model_fields
         if hasattr(cls, "model_fields") and hasattr(cls, "__annotations__"):
@@ -93,8 +99,6 @@ def generate_class_docstring(output_file: Path, cls: Type[Any]) -> None:
                     )
                     file.write(f"- **{name}**: {member_doc}\n")
 
-        file.write("\n---\n")
-
 
 def generate_documentation(output_prefix: Path) -> None:
     """Generates markdown documentation for all DSL classes.
@@ -102,7 +106,27 @@ def generate_documentation(output_prefix: Path) -> None:
     Args:
         output_prefix (Path): The directory where the documentation files will be saved.
     """
+    # erase everything in the output directory
+    output_prefix.mkdir(parents=True, exist_ok=True)
+    for item in output_prefix.iterdir():
+        if item.is_dir():
+            for subitem in item.iterdir():
+                if subitem.is_file():
+                    subitem.unlink()
+            item.rmdir()
+        elif item.is_file():
+            item.unlink()
+
     # Get all classes from the DSL model module
     for name, cls in inspect.getmembers(dsl, inspect.isclass):  # noqa: F821
         if cls.__module__ == dsl.__name__ and not name.startswith("_"):
             generate_class_docstring(output_prefix / f"{name}.md", cls)
+    generate_class_docstring(
+        output_prefix / "PrimitiveTypeEnum.md", PrimitiveTypeEnum
+    )
+
+    for name, cls in inspect.getmembers(dsl.domain_types, inspect.isclass):  # noqa: F821
+        if cls.__module__ == dsl.domain_types.__name__ and not name.startswith(
+            "_"
+        ):
+            generate_class_docstring(output_prefix / f"{name}.md", cls)

qtype/dsl/domain_types.py

@@ -41,6 +41,9 @@ class ChatContent(StrictBaseModel):
         ...,
         description="The actual content, which can be a string, image data, etc.",
     )
+    mime_type: str | None = Field(
+        default=None, description="The MIME type of the content, if known."
+    )
 
 
 class ChatMessage(StrictBaseModel):