qtype 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

qtype/application/__init__.py

@@ -0,0 +1,12 @@
+"""Application layer for orchestrating qtype operations."""
+
+from __future__ import annotations
+
+from . import commons, converters
+from .facade import QTypeFacade
+
+__all__ = [
+    "QTypeFacade",
+    "converters",
+    "commons",
+]

qtype/application/commons/__init__.py

@@ -0,0 +1,7 @@
+"""Common tools and utilities for qtype applications."""
+
+from __future__ import annotations
+
+from . import tools
+
+__all__ = ["tools"]

qtype/{converters → application/converters}/tools_from_module.py

@@ -4,7 +4,7 @@ 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.application.converters.types import PYTHON_TYPE_TO_PRIMITIVE_TYPE
 from qtype.dsl.base_types import PrimitiveTypeEnum
 from qtype.dsl.model import (
     CustomType,
@@ -239,7 +239,7 @@ def _map_python_type_to_variable_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
+        return python_type  # type: ignore[no-any-return]
     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)

qtype/{converters → application/converters}/types.py

@@ -31,36 +31,3 @@ PYTHON_TYPE_TO_PRIMITIVE_TYPE = {
     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/document.py → application/documentation.py}

@@ -1,3 +1,5 @@
+"""Documentation generation utilities for DSL classes."""
+
 import inspect
 from pathlib import Path
 from typing import Any, Type, Union, get_args, get_origin

qtype/application/facade.py

@@ -0,0 +1,160 @@
+"""Main facade for qtype operations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from pydantic import BaseModel
+
+from qtype.base.logging import get_logger
+from qtype.base.types import CustomTypeRegistry, DocumentRootType, PathLike
+from qtype.dsl.base_types import StepCardinality
+from qtype.dsl.model import Application as DSLApplication
+from qtype.dsl.model import DocumentType
+from qtype.interpreter.batch.types import BatchConfig
+from qtype.semantic.model import Application as SemanticApplication
+from qtype.semantic.model import Variable
+
+logger = get_logger("application.facade")
+
+
+class QTypeFacade:
+    """
+    Simplified interface for all qtype operations.
+
+    This facade hides the complexity of coordinating between DSL, semantic,
+    and interpreter layers, providing a clean API for common operations.
+    """
+
+    def load_dsl_document(
+        self, path: PathLike
+    ) -> tuple[DocumentRootType, CustomTypeRegistry]:
+        from qtype.loader import load_document
+
+        return load_document(Path(path).read_text(encoding="utf-8"))
+
+    def load_and_validate(self, path: PathLike) -> DocumentRootType:
+        """Load and validate a document."""
+        logger.info("Document loaded, proceeding to validation")
+        root, _ = self.load_dsl_document(path)
+        return root
+
+    def load_semantic_model(
+        self, path: PathLike
+    ) -> tuple[SemanticApplication, CustomTypeRegistry]:
+        """Load a document and return the resolved semantic model."""
+        from qtype.loader import load
+
+        content = Path(path).read_text(encoding="utf-8")
+        return load(content)
+
+    def execute_workflow(
+        self,
+        path: PathLike,
+        inputs: dict | pd.DataFrame,
+        flow_name: str | None = None,
+        batch_config: BatchConfig | None = None,
+        **kwargs: Any,
+    ) -> pd.DataFrame | list[Variable]:
+        """Execute a complete workflow from document to results."""
+        logger.info(f"Executing workflow from {path}")
+
+        # Load the semantic application
+        semantic_model, type_registry = self.load_semantic_model(path)
+
+        # Find the flow to execute (inlined from _find_flow)
+        if flow_name:
+            target_flow = None
+            for flow in semantic_model.flows:
+                if flow.id == flow_name:
+                    target_flow = flow
+                    break
+            if target_flow is None:
+                raise ValueError(f"Flow '{flow_name}' not found")
+        else:
+            if semantic_model.flows:
+                target_flow = semantic_model.flows[0]
+            else:
+                raise ValueError("No flows found in application")
+        if target_flow.cardinality == StepCardinality.many:
+            if isinstance(inputs, dict):
+                inputs = pd.DataFrame([inputs])
+            if not isinstance(inputs, pd.DataFrame):
+                raise ValueError(
+                    "Input must be a DataFrame for flows with 'many' cardinality"
+                )
+            from qtype.interpreter.batch.flow import batch_execute_flow
+
+            batch_config = batch_config or BatchConfig()
+            results, errors = batch_execute_flow(
+                target_flow, inputs, batch_config, **kwargs
+            )  # type: ignore
+            return results
+        else:
+            from qtype.interpreter.flow import execute_flow
+
+            args = {**kwargs, **inputs}
+            return execute_flow(target_flow, **args)
+
+    def visualize_application(self, path: PathLike) -> str:
+        """Visualize an application as Mermaid diagram."""
+        from qtype.semantic.visualize import visualize_application
+
+        semantic_model, _ = self.load_semantic_model(path)
+        return visualize_application(semantic_model)
+
+    def convert_document(self, document: DocumentType) -> str:
+        """Convert a document to YAML format."""
+        # Wrap DSLApplication in Document if needed
+        wrapped_document: BaseModel = document
+        if isinstance(document, DSLApplication):
+            from qtype.dsl.model import Document
+
+            wrapped_document = Document(root=document)
+
+        # Try to use pydantic_yaml first
+        try:
+            from pydantic_yaml import to_yaml_str
+
+            return to_yaml_str(
+                wrapped_document, exclude_unset=True, exclude_none=True
+            )
+        except ImportError:
+            # Fallback to basic YAML if pydantic_yaml is not available
+            import yaml
+
+            document_dict = wrapped_document.model_dump(
+                exclude_unset=True, exclude_none=True
+            )
+            return yaml.dump(document_dict, default_flow_style=False)
+
+    def generate_aws_bedrock_models(self) -> list[dict[str, Any]]:
+        """
+        Generate AWS Bedrock model definitions.
+
+        Returns:
+            List of model definitions for AWS Bedrock models.
+
+        Raises:
+            ImportError: If boto3 is not installed.
+            Exception: If AWS API call fails.
+        """
+        import boto3  # type: ignore[import-untyped]
+
+        logger.info("Discovering AWS Bedrock models...")
+        client = boto3.client("bedrock")
+        models = client.list_foundation_models()
+
+        model_definitions = []
+        for model_summary in models.get("modelSummaries", []):
+            model_definitions.append(
+                {
+                    "id": model_summary["modelId"],
+                    "provider": "aws-bedrock",
+                }
+            )
+
+        logger.info(f"Discovered {len(model_definitions)} AWS Bedrock models")
+        return model_definitions

qtype/base/__init__.py

@@ -0,0 +1,14 @@
+"""Base utilities and types for qtype."""
+
+from __future__ import annotations
+
+from .exceptions import QTypeError, ValidationError
+from .logging import get_logger
+from .types import JSONValue
+
+__all__ = [
+    "QTypeError",
+    "ValidationError",
+    "get_logger",
+    "JSONValue",
+]

qtype/base/exceptions.py

@@ -0,0 +1,49 @@
+"""Base exceptions for qtype."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class QTypeError(Exception):
+    """Base exception for all qtype errors."""
+
+    def __init__(
+        self, message: str, details: dict[str, Any] | None = None
+    ) -> None:
+        """Initialize the exception with message and optional details."""
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+
+class ValidationError(QTypeError):
+    """Exception raised when validation fails."""
+
+    def __init__(
+        self,
+        message: str,
+        errors: list[str] | None = None,
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        """Initialize validation error with list of error messages."""
+        super().__init__(message, details)
+        self.errors = errors or []
+
+
+class LoadError(QTypeError):
+    """Exception raised when loading documents fails."""
+
+    pass
+
+
+class SemanticError(QTypeError):
+    """Exception raised when semantic processing fails."""
+
+    pass
+
+
+class InterpreterError(QTypeError):
+    """Exception raised when interpretation/execution fails."""
+
+    pass

qtype/base/logging.py

@@ -0,0 +1,39 @@
+"""Logging utilities for qtype."""
+
+from __future__ import annotations
+
+import logging
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger with the given name and consistent formatting."""
+    logger = logging.getLogger(f"qtype.{name}")
+
+    # Only configure if not already configured
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        logger.setLevel(logging.INFO)
+
+    return logger
+
+
+def configure_logging(
+    level: str = "INFO", format_string: str | None = None
+) -> None:
+    """Configure root logging for qtype."""
+    numeric_level = getattr(logging, level.upper(), logging.INFO)
+
+    format_str = (
+        format_string or "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+    logging.basicConfig(
+        level=numeric_level,
+        format=format_str,
+        force=True,  # Override any existing configuration
+    )

qtype/base/types.py

@@ -0,0 +1,29 @@
+"""Common type definitions for qtype."""
+
+from __future__ import annotations
+
+import pathlib
+from typing import Any, Type, Union
+
+from pydantic import BaseModel
+
+from qtype.dsl import model as dsl
+
+# JSON-serializable value types
+JSONValue = Union[
+    str,
+    int,
+    float,
+    bool,
+    None,
+    dict[str, "JSONValue"],
+    list["JSONValue"],
+]
+
+# Configuration dictionary type
+ConfigDict = dict[str, Any]
+
+# Path-like type (string or Path object)
+PathLike = Union[str, pathlib.Path]
+CustomTypeRegistry = dict[str, Type[BaseModel]]
+DocumentRootType = dsl.Agent | dsl.Application | dsl.Flow | list

qtype/commands/convert.py

@@ -1,46 +1,65 @@
+"""
+Command-line interface for converting tools and APIs to qtype format.
+"""
+
+from __future__ import annotations
+
 import argparse
 import logging
+from pathlib import Path
 
-from pydantic_yaml import to_yaml_str
-
-from qtype.dsl.model import Application
+from qtype.application.facade import QTypeFacade
 
 logger = logging.getLogger(__name__)
 
 
 def convert_api(args: argparse.Namespace) -> None:
+    """Convert API specification to qtype format."""
     raise NotImplementedError("API conversion is not implemented yet.")
 
 
 def convert_module(args: argparse.Namespace) -> None:
     """Convert Python module tools to qtype format."""
+    from qtype.application.converters.tools_from_module import (
+        tools_from_module,
+    )
+    from qtype.dsl.model import Application, ToolList
+
+    try:
+        tools, types = tools_from_module(args.module_path)
+        if not tools:
+            raise ValueError(
+                f"No tools found in the module: {args.module_path}"
+            )
 
-    from qtype.commons.generate import _write_yaml_file
-    from qtype.converters.tools_from_module import tools_from_module
-    from qtype.dsl.model import ToolList
-
-    tools, types = tools_from_module(args.module_path)  # type: ignore
-    if not tools:
-        raise ValueError(f"No tools found in the module: {args.module_path}")
-    
-    if types:
-        doc = Application(
-            id=args.module_path,
-            description=f"Tools created from Python module {args.module_path}",
-            tools=list(tools),
-            types=types,
-        )
-    else:
-        doc = ToolList(root=list(tools))
-
-    if args.output:
-        _write_yaml_file(doc, args.output)
-        logger.info("Resulting yaml written to %s", args.output)
-    else:
-        logger.info(
-            "Resulting yaml:\n%s",
-            to_yaml_str(tools, exclude_unset=True, exclude_none=True),
-        )
+        # Create application document
+        if types:
+            doc: Application | ToolList = Application(
+                id=args.module_path,
+                description=f"Tools created from Python module {args.module_path}",
+                tools=list(tools),
+                types=types,
+            )
+        else:
+            doc = ToolList(
+                root=list(tools),
+            )
+
+        # Use facade to convert to YAML format
+        facade = QTypeFacade()
+        content = facade.convert_document(doc)
+
+        # Write to file or stdout
+        if args.output:
+            output_path = Path(args.output)
+            output_path.write_text(content, encoding="utf-8")
+            logger.info(f"✅ Converted tools saved to {output_path}")
+        else:
+            print(content)
+
+    except Exception as e:
+        logger.error(f"❌ Conversion failed: {e}")
+        raise
 
 
 def parser(subparsers: argparse._SubParsersAction) -> None:
@@ -54,36 +73,32 @@ def parser(subparsers: argparse._SubParsersAction) -> None:
         dest="convert_command", required=True
     )
 
-    convert_module_parser = convert_subparsers.add_parser(
-        "module", help="Converts module specifications to qtype format."
+    # Convert from Python module
+    module_parser = convert_subparsers.add_parser(
+        "module", help="Convert a Python module to qtype tools format."
     )
-    convert_module_parser.add_argument(
-        "module_path",
-        type=str,
-        help="Path to the Python module to convert.",
+    module_parser.add_argument(
+        "module_path", type=str, help="Path to the Python module to convert."
     )
-    convert_module_parser.add_argument(
+    module_parser.add_argument(
         "-o",
         "--output",
         type=str,
-        default=None,
-        help="Where to save the converted YAML file. If not specified, it is just printed to stdout.",
+        help="Output file path. If not specified, prints to stdout.",
     )
-    convert_module_parser.set_defaults(func=convert_module)
+    module_parser.set_defaults(func=convert_module)
 
-    convert_api_parser = convert_subparsers.add_parser(
-        "api", help="Converts API specifications to qtype format."
+    # Convert from API specification
+    api_parser = convert_subparsers.add_parser(
+        "api", help="Convert an API specification to qtype format."
     )
-    convert_api_parser.add_argument(
-        "openapi_spec",
-        type=str,
-        help="URL of the OpenAPI specification.",
+    api_parser.add_argument(
+        "api_spec", type=str, help="Path to the API specification file."
     )
-    convert_api_parser.add_argument(
+    api_parser.add_argument(
         "-o",
         "--output",
         type=str,
-        default=None,
-        help="Where to save the converted YAML file. If not specified, it is just printed to stdout.",
+        help="Output file path. If not specified, prints to stdout.",
     )
-    convert_api_parser.set_defaults(func=convert_api)
+    api_parser.set_defaults(func=convert_api)

qtype/commands/generate.py

@@ -10,13 +10,68 @@ logger = logging.getLogger(__name__)
 
 
 def run_dump_commons_library(args: argparse.Namespace) -> None:
-    from qtype.commons.generate import dump_commons_library
+    """Generate commons library tools and AWS Bedrock models."""
+    import logging
+    from pathlib import Path
 
-    dump_commons_library(args)
+    from qtype.application.facade import QTypeFacade
+    from qtype.dsl.model import Model, ModelList
+
+    logger = logging.getLogger(__name__)
+    facade = QTypeFacade()
+
+    try:
+        # Generate common tools using convert module functionality
+        logger.info("Generating common tools...")
+
+        # Create a mock args object for convert_module
+        import argparse
+
+        from qtype.commands.convert import convert_module
+
+        convert_args = argparse.Namespace(
+            module_path="qtype.application.commons.tools",
+            output=f"{args.prefix}/tools.qtype.yaml",
+        )
+        convert_module(convert_args)
+
+        # Generate AWS Bedrock models
+        logger.info("Generating AWS Bedrock models...")
+        try:
+            model_definitions = facade.generate_aws_bedrock_models()
+
+            model_list = ModelList(
+                root=[
+                    Model(
+                        id=model_def["id"],
+                        provider=model_def["provider"],
+                    )
+                    for model_def in model_definitions
+                ]
+            )
+
+            # Convert to YAML and save
+            content = facade.convert_document(model_list)
+            output_path = Path(f"{args.prefix}/aws.bedrock.models.qtype.yaml")
+            output_path.write_text(content, encoding="utf-8")
+            logger.info(f"AWS Bedrock models exported to {output_path}")
+
+        except ImportError:
+            logger.warning(
+                "boto3 not available. Skipping AWS Bedrock model generation."
+            )
+        except Exception as e:
+            logger.error(f"Failed to generate AWS Bedrock models: {e}")
+
+        logger.info("Commons library generation complete.")
+
+    except Exception as e:
+        logger.error(f"Failed to generate commons library: {e}")
+        raise
 
 
 def run_generate_documentation(args: argparse.Namespace) -> None:
-    from qtype.dsl.document import generate_documentation
+    from qtype.application.documentation import generate_documentation
 
     generate_documentation(Path(args.output))
 
@@ -93,7 +148,7 @@ def parser(subparsers: argparse._SubParsersAction) -> None:
     # only add this if networkx and ruff are installed
     try:
         import networkx  # noqa: F401
-        import ruff  # noqa: F401
+        import ruff  # type: ignore[import-untyped]  # noqa: F401
 
         from qtype.semantic.generate import generate_semantic_model