qtype 0.0.10__tar.gz → 0.0.12__tar.gz

{qtype-0.0.10/qtype.egg-info → qtype-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qtype
-Version: 0.0.10
+Version: 0.0.12
 Summary: DSL for Generative AI Prototyping
 Author-email: Lou Kratz <lou.kratz+qtype@bazaarvoice.com>
 License-Expression: Apache-2.0
@@ -17,6 +17,7 @@ Requires-Dist: fsspec>=2025.5.1
 Requires-Dist: pydantic-yaml>=1.5.1
 Requires-Dist: mkdocs-awesome-pages-plugin>=2.10.1
 Requires-Dist: mermaid-py>=0.8.0
+Requires-Dist: pip-system-certs>=5.2
 Provides-Extra: interpreter
 Requires-Dist: arize-phoenix-otel>=0.12.1; extra == "interpreter"
 Requires-Dist: boto3>=1.34.0; extra == "interpreter"
@@ -27,8 +28,11 @@ Requires-Dist: llama-index-llms-bedrock-converse>=0.7.4; extra == "interpreter"
 Requires-Dist: llama-index-llms-bedrock>=0.3.8; extra == "interpreter"
 Requires-Dist: llama-index>=0.12.45; extra == "interpreter"
 Requires-Dist: openinference-instrumentation-llama-index>=4.3.4; extra == "interpreter"
+Requires-Dist: pandas>=2.2.3; extra == "interpreter"
 Requires-Dist: psycopg2-binary>=2.9.10; extra == "interpreter"
+Requires-Dist: pyathena[sqlalchemy]>=3.18.0; extra == "interpreter"
 Requires-Dist: python-magic>=0.4.27; extra == "interpreter"
+Requires-Dist: sqlalchemy>=2.0.42; extra == "interpreter"
 Requires-Dist: uvicorn[standard]>=0.35.0; extra == "interpreter"
 Dynamic: license-file
 

{qtype-0.0.10 → qtype-0.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qtype"
-version = "0.0.10"
+version = "0.0.12"
 description = "DSL for Generative AI Prototyping"
 authors = [{ name="Lou Kratz", email="lou.kratz+qtype@bazaarvoice.com" }]
 readme = "README.md"
@@ -15,6 +15,7 @@ dependencies = [
     "pydantic-yaml>=1.5.1",
     "mkdocs-awesome-pages-plugin>=2.10.1",
     "mermaid-py>=0.8.0",
+    "pip-system-certs>=5.2",
 ]
 license = "APACHE-2.0"
 license-files = ["LICEN[CS]E*"]
@@ -33,8 +34,11 @@ interpreter = [
     "llama-index-llms-bedrock>=0.3.8",
     "llama-index>=0.12.45",
     "openinference-instrumentation-llama-index>=4.3.4",
+    "pandas>=2.2.3",
     "psycopg2-binary>=2.9.10",
+    "pyathena[sqlalchemy]>=3.18.0",
     "python-magic>=0.4.27",
+    "sqlalchemy>=2.0.42",
     "uvicorn[standard]>=0.35.0",
 ]
 
@@ -52,13 +56,17 @@ dev = [
     "mkdocstrings>=0.30.0",
     "mypy>=1.8.0",
     "networkx>=3.4.2",
+    "pandas-stubs>=2.3.2.250827",
     "pkginfo>=1.12.1.2",
     "pre-commit>=3.6.0",
     "pymdown-extensions>=10.16",
     "pytest-cov>=6.0.0",
     "pytest>=8.4.1",
     "ruff>=0.1.0",
+    "types-cachetools>=6.2.0.20250827",
+    "types-networkx>=3.5.0.20250901",
     "types-PyYAML>=6.0.2",
+    "types-requests>=2.32.4.20250809",
 ]
 docs = [
     "mkdocs>=1.5.0",
@@ -110,12 +118,17 @@ python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
+explicit_package_bases = true
 plugins = ["pydantic.mypy"]
 
 [[tool.mypy.overrides]]
 module = "tests.*"
 disallow_untyped_defs = false
 
+[[tool.mypy.overrides]]
+module = "qtype.semantic.model"
+ignore_errors = true
+
 [tool.pydantic-mypy]
 init_forbid_extra = true
 init_typed = true
@@ -124,11 +137,9 @@ warn_required_dynamic_aliases = true
 [tool.coverage.run]
 source = ["qtype"]
 omit = [
-    "*/tests/*",
-    "*/test_*",
-    "*/__pycache__/*",
-    "*/venv/*",
-    "*/.venv/*",
+    "qtype/commands/*",
+    "qtype/interpreter/*", # TODO: expand coverage here.
+    "qtype/*.py",
 ]
 
 [tool.coverage.report]

qtype-0.0.12/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-0.0.12/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-0.0.10/qtype → qtype-0.0.12/qtype/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-0.0.12/qtype/application/converters/types.py

@@ -0,0 +1,33 @@
+from datetime import date, datetime, time
+
+from qtype.dsl.base_types import PrimitiveTypeEnum
+
+"""
+Mapping of QType primitive types to Python types for internal representations.
+"""
+PRIMITIVE_TO_PYTHON_TYPE = {
+    PrimitiveTypeEnum.audio: bytes,
+    PrimitiveTypeEnum.boolean: bool,
+    PrimitiveTypeEnum.bytes: bytes,
+    PrimitiveTypeEnum.date: date,
+    PrimitiveTypeEnum.datetime: datetime,
+    PrimitiveTypeEnum.int: int,
+    PrimitiveTypeEnum.file: bytes,  # Use bytes for file content
+    PrimitiveTypeEnum.float: float,
+    PrimitiveTypeEnum.image: bytes,  # Use bytes for image data
+    PrimitiveTypeEnum.text: str,
+    PrimitiveTypeEnum.time: time,  # Use time 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
+}

qtype-0.0.10/qtype/dsl/document.py → qtype-0.0.12/qtype/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-0.0.12/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-0.0.12/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-0.0.12/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-0.0.12/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-0.0.12/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-0.0.12/qtype/commands/convert.py

@@ -0,0 +1,104 @@
+"""
+Command-line interface for converting tools and APIs to qtype format.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+
+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}"
+            )
+
+        # 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:
+    """Set up the converter subcommand parser."""
+    cmd_parser = subparsers.add_parser(
+        "convert", help="Creates qtype files from different sources."
+    )
+
+    # Create a new subparser for "convert api", "convert module", etc.
+    convert_subparsers = cmd_parser.add_subparsers(
+        dest="convert_command", required=True
+    )
+
+    # Convert from Python module
+    module_parser = convert_subparsers.add_parser(
+        "module", help="Convert a Python module to qtype tools format."
+    )
+    module_parser.add_argument(
+        "module_path", type=str, help="Path to the Python module to convert."
+    )
+    module_parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        help="Output file path. If not specified, prints to stdout.",
+    )
+    module_parser.set_defaults(func=convert_module)
+
+    # Convert from API specification
+    api_parser = convert_subparsers.add_parser(
+        "api", help="Convert an API specification to qtype format."
+    )
+    api_parser.add_argument(
+        "api_spec", type=str, help="Path to the API specification file."
+    )
+    api_parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        help="Output file path. If not specified, prints to stdout.",
+    )
+    api_parser.set_defaults(func=convert_api)

{qtype-0.0.10 → qtype-0.0.12}/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