qtype 0.0.1__py3-none-any.whl

qtype/dsl/document.py

@@ -0,0 +1,108 @@
+import inspect
+from pathlib import Path
+from typing import Any, Type, Union, get_args, get_origin
+
+import qtype.dsl.model as dsl
+
+
+def _format_type_name(field_type: Any) -> str:
+    """Format a type annotation for display in documentation."""
+    # Handle ForwardRef objects
+    if hasattr(field_type, "__forward_arg__"):
+        return str(field_type.__forward_arg__)
+
+    # Handle Union types (including | syntax)
+    origin = get_origin(field_type)
+    args = get_args(field_type)
+
+    if origin is Union or (
+        hasattr(field_type, "__class__")
+        and field_type.__class__.__name__ == "UnionType"
+    ):
+        return " | ".join(_format_type_name(arg) for arg in args)
+
+    # Handle list types
+    if origin is list:
+        if args:
+            inner_type = _format_type_name(args[0])
+            return f"list[{inner_type}]"
+        return "list"
+
+    # Handle dict types
+    if origin is dict:
+        if len(args) == 2:
+            key_type = _format_type_name(args[0])
+            value_type = _format_type_name(args[1])
+            return f"dict[{key_type}, {value_type}]"
+        return "dict"
+
+    # Handle basic types
+    if hasattr(field_type, "__name__"):
+        type_name = field_type.__name__
+        if type_name == "NoneType":
+            return "None"
+        return str(type_name)
+
+    return str(field_type)
+
+
+def generate_class_docstring(output_file: Path, cls: Type[Any]) -> None:
+    """Generates markdown documentation for a given DSL class.
+
+    The generated markdown contains a table of the class members and their descriptions.
+    The docstring of the class is used as the main description.
+    The field descriptions from Pydantic model_fields are used to describe each member.
+    """
+    class_name = cls.__name__
+    docstring = cls.__doc__ or "No documentation available."
+
+    with output_file.open("w", encoding="utf-8") as file:
+        file.write(f"# {class_name}\n\n{docstring}\n\n## Members\n")
+
+        # Handle Pydantic models by checking for model_fields
+        if hasattr(cls, "model_fields") and hasattr(cls, "__annotations__"):
+            # Process Pydantic model fields
+            for field_name in cls.__annotations__:
+                if field_name in cls.model_fields:
+                    field_info = cls.model_fields[field_name]
+                    field_type = field_info.annotation
+                    field_description = getattr(
+                        field_info, "description", None
+                    )
+
+                    # Format the type name for display
+                    type_name = _format_type_name(field_type)
+
+                    # Use field description or fallback
+                    description = (
+                        field_description or "(No documentation available.)"
+                    )
+
+                    file.write(
+                        f"- **{field_name}** (`{type_name}`): {description}\n"
+                    )
+        else:
+            # Fallback to inspect.getmembers for non-Pydantic classes
+            members = inspect.getmembers(
+                cls, lambda a: not inspect.isroutine(a)
+            )
+            for name, value in members:
+                if not name.startswith("_"):
+                    member_doc = (
+                        value.__doc__ or "(No documentation available.)"
+                    )
+                    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.
+    The documentation is saved in the specified output prefix directory.
+    Args:
+        output_prefix (Path): The directory where the documentation files will be saved.
+    """
+    # 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)

qtype/dsl/domain_types.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+
+from qtype.dsl.base_types import PrimitiveTypeEnum, StrictBaseModel
+
+
+class Embedding(StrictBaseModel):
+    """A standard, built-in representation of a vector embedding."""
+
+    vector: list[float] = Field(
+        ..., description="The vector representation of the embedding."
+    )
+    source_text: str | None = Field(
+        None, description="The original text that was embedded."
+    )
+    metadata: dict[str, str] | None = Field(
+        None, description="Optional metadata associated with the embedding."
+    )
+
+
+class MessageRole(str, Enum):
+    assistant = "assistant"
+    chatbot = "chatbot"
+    developer = "developer"
+    function = "function"
+    model = "model"
+    system = "system"
+    tool = "tool"
+    user = "user"
+
+
+class ChatContent(StrictBaseModel):
+    type: PrimitiveTypeEnum = Field(
+        ..., description="The type of content, such as 'text', 'image', etc."
+    )
+    content: Any = Field(
+        ...,
+        description="The actual content, which can be a string, image data, etc.",
+    )
+
+
+class ChatMessage(StrictBaseModel):
+    """A standard, built-in representation of a chat message."""
+
+    role: MessageRole = Field(
+        ...,
+        description="The role of the message sender (e.g., 'user', 'assistant').",
+    )
+    blocks: list[ChatContent] = Field(
+        ...,
+        description="The content blocks of the chat message, which can include text, images, or other media.",
+    )