qtype 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

qtype/commands/generate.py

@@ -2,24 +2,48 @@ import argparse
 import json
 import logging
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 from qtype.dsl.model import Document
 
 logger = logging.getLogger(__name__)
 
 
+def generate_aws_bedrock_models() -> 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
+
+
 def run_dump_commons_library(args: argparse.Namespace) -> None:
     """Generate commons library tools and AWS Bedrock models."""
-    import logging
     from pathlib import Path
 
-    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...")
@@ -38,7 +62,7 @@ def run_dump_commons_library(args: argparse.Namespace) -> None:
         # Generate AWS Bedrock models
         logger.info("Generating AWS Bedrock models...")
         try:
-            model_definitions = facade.generate_aws_bedrock_models()
+            model_definitions = generate_aws_bedrock_models()
 
             model_list = ModelList(
                 root=[
@@ -51,7 +75,11 @@ def run_dump_commons_library(args: argparse.Namespace) -> None:
             )
 
             # Convert to YAML and save
-            content = facade.convert_document(model_list)
+            from pydantic_yaml import to_yaml_str
+
+            content = to_yaml_str(
+                model_list, exclude_none=True, exclude_unset=True
+            )
             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}")
@@ -76,6 +104,51 @@ def run_generate_documentation(args: argparse.Namespace) -> None:
     generate_documentation(Path(args.output))
 
 
+def _copy_resource_file(resource, rel_path: Path, output_file: Path) -> None:
+    """Copy a file from a resource directory to an output location."""
+    content = resource.get_file(str(rel_path))
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    output_file.write_text(content, encoding="utf-8")
+
+
+def run_generate_skill(args: argparse.Namespace) -> None:
+    """Generate a Claude skill with QType documentation and examples.
+
+    Args:
+        args: Command-line arguments with 'output' path.
+    """
+    from qtype.mcp.server import _docs_resource, _examples_resource
+
+    output_path = Path(args.output) / "qtype-architect"
+
+    # Copy skill documentation files
+    skills_path = _docs_resource.get_path() / "skills" / "architect"
+    skill_count = 0
+    for skill_file in skills_path.rglob("*.*"):
+        rel_path = skill_file.relative_to(_docs_resource.get_path())
+        _copy_resource_file(
+            _docs_resource,
+            rel_path,
+            output_path / rel_path.relative_to("skills/architect"),
+        )
+        skill_count += 1
+
+    # Copy all example files
+    example_count = 0
+    for yaml_file in _examples_resource.get_path().rglob("*.yaml"):
+        rel_path = yaml_file.relative_to(_examples_resource.get_path())
+        if "legacy" not in rel_path.parts:
+            _copy_resource_file(
+                _examples_resource, rel_path, output_path / "assets" / rel_path
+            )
+            example_count += 1
+
+    logger.info(
+        f"Skill generated at {output_path}: "
+        f"{skill_count} docs, {example_count} examples"
+    )
+
+
 def generate_schema(args: argparse.Namespace) -> None:
     """Generate and output the JSON schema for Document.
 
@@ -118,8 +191,8 @@ def generate_schema(args: argparse.Namespace) -> None:
 
     schema["$defs"]["qtype_env_var"] = {
         "type": "string",
-        "pattern": "^.*\\$\\{[^}:]+(?::[^}]*)?\\}.*$",
-        "description": "String with environment variable substitution using ${VAR_NAME} or ${VAR_NAME:default} syntax",
+        "pattern": "^.*\\$\\{[^}:]+(?::-[^}]*)?\\}.*$",
+        "description": "String with environment variable substitution using ${VAR_NAME} or ${VAR_NAME:-default} syntax",
     }
 
     output = json.dumps(schema, indent=2)
@@ -180,6 +253,20 @@ def parser(subparsers: argparse._SubParsersAction) -> None:
     )
     dsl_parser.set_defaults(func=run_generate_documentation)
 
+    # Parser for generating Agent skills
+    skill_parser = generate_subparsers.add_parser(
+        "skills",
+        help="Generates Agent skills with QType documentation and examples.",
+    )
+    skill_parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        default=".claude/skills",
+        help="Output directory for the skills (default: .claude/skills)",
+    )
+    skill_parser.set_defaults(func=run_generate_skill)
+
     # Parser for generating the semantic model
     # only add this if networkx and ruff are installed
     try:

qtype/commands/mcp.py

@@ -0,0 +1,68 @@
+"""
+Command-line interface for starting the QType MCP server.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from typing import Any
+
+from qtype.mcp.server import mcp
+
+logger = logging.getLogger(__name__)
+
+
+def main(args: Any) -> None:
+    """
+    Start the QType MCP server with the specified transport.
+
+    Args:
+        args: Arguments passed from the command line or calling context.
+    """
+
+    # Update server settings with CLI arguments
+    mcp.settings.host = args.host
+    mcp.settings.port = args.port
+
+    logger.info(f"Starting QType MCP server with {args.transport} transport")
+
+    if args.transport in ("sse", "streamable-http"):
+        logger.info(f"Server will be available at {args.host}:{args.port}")
+
+    # Run the server with the specified transport
+    mcp.run(transport=args.transport)
+
+
+def parser(subparsers: argparse._SubParsersAction) -> None:
+    """Set up the mcp subcommand parser.
+
+    Args:
+        subparsers: The subparsers object to add the command to.
+    """
+    cmd_parser = subparsers.add_parser(
+        "mcp",
+        help="Start the QType MCP server for AI agent integration.",
+    )
+    cmd_parser.add_argument(
+        "-t",
+        "--transport",
+        type=str,
+        choices=["stdio", "sse", "streamable-http"],
+        default="stdio",
+        help="Transport protocol to use (default: stdio)",
+    )
+    cmd_parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host to bind to for HTTP/SSE transports (default: 0.0.0.0)",
+    )
+    cmd_parser.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        default=8000,
+        help="Port to bind to for HTTP/SSE transports (default: 8000)",
+    )
+    cmd_parser.set_defaults(func=main)

qtype/commands/run.py

@@ -11,11 +11,10 @@ import warnings
 from pathlib import Path
 from typing import Any
 
-import pandas as pd
 from pydantic.warnings import UnsupportedFieldAttributeWarning
 
-from qtype.application.facade import QTypeFacade
 from qtype.base.exceptions import InterpreterError, LoadError, ValidationError
+from qtype.interpreter.converters import read_dataframe_from_file
 
 logger = logging.getLogger(__name__)
 
@@ -29,50 +28,124 @@ for name in ["httpx", "urllib3", "qdrant_client", "opensearch"]:
     logging.getLogger(name).setLevel(logging.WARNING)
 
 
-def read_data_from_file(file_path: str) -> pd.DataFrame:
-    """
-    Reads a file into a pandas DataFrame based on its MIME type.
+def register_telemetry(spec) -> None:
+    """Register telemetry if enabled in the spec."""
+    from qtype.interpreter.telemetry import register
+    from qtype.semantic.model import Application as SemanticApplication
+
+    if isinstance(spec, SemanticApplication) and spec.telemetry:
+        logger.info(
+            f"Telemetry enabled with endpoint: {spec.telemetry.endpoint}"
+        )
+        secret_mgr = create_secret_manager_for_spec(spec)
+        register(spec.telemetry, secret_mgr, spec.id)
+
+
+def create_secret_manager_for_spec(spec):
+    """Create a secret manager based on the specification."""
+    from qtype.interpreter.base.secrets import create_secret_manager
+    from qtype.semantic.model import Application as SemanticApplication
+
+    if isinstance(spec, SemanticApplication):
+        return create_secret_manager(spec.secret_manager)
+    else:
+        raise ValueError(
+            "Can't create secret manager for non-Application spec"
+        )
+
+
+async def execute_workflow(
+    path: Path,
+    inputs: dict | Any,
+    flow_name: str | None = None,
+    **kwargs: Any,
+) -> Any:
+    """Execute a complete workflow from document to results.
+
+    Args:
+        path: Path to the QType specification file
+        inputs: Dictionary of input values or DataFrame for batch
+        flow_name: Optional name of flow to execute
+        **kwargs: Additional dependencies for execution
+
+    Returns:
+        DataFrame with results (one row per input)
     """
-    from pathlib import Path
-
-    import magic
-
-    mime_type = magic.Magic(mime=True).from_file(file_path)
-
-    if mime_type == "text/csv":
-        # TODO: Restore na values and convert to optional once we support them https://github.com/bazaarvoice/qtype/issues/101
-        df = pd.read_csv(file_path)
-        return df.fillna("")
-    elif mime_type == "text/plain":
-        # For text/plain, use file extension to determine format
-        file_ext = Path(file_path).suffix.lower()
-        if file_ext == ".csv":
-            # TODO: Restore na values and convert to optional once we support them https://github.com/bazaarvoice/qtype/issues/101
-            df = pd.read_csv(file_path)
-            return df.fillna("")
-        elif file_ext == ".json":
-            return pd.read_json(file_path)
+    import pandas as pd
+    from opentelemetry import trace
+
+    from qtype.interpreter.base.executor_context import ExecutorContext
+    from qtype.interpreter.converters import (
+        dataframe_to_flow_messages,
+        flow_messages_to_dataframe,
+    )
+    from qtype.interpreter.flow import run_flow
+    from qtype.interpreter.types import Session
+    from qtype.semantic.loader import load
+    from qtype.semantic.model import Application as SemanticApplication
+
+    # Load the semantic application
+    semantic_model, type_registry = load(path)
+    assert isinstance(semantic_model, SemanticApplication)
+    register_telemetry(semantic_model)
+
+    # Find the flow to execute
+    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(
-                (
-                    f"Unsupported text/plain file extension: {file_ext}. "
-                    "Supported extensions: .csv, .json"
-                )
-            )
-    elif mime_type == "application/json":
-        return pd.read_json(file_path)
-    elif mime_type in [
-        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        "application/vnd.ms-excel",
-    ]:
-        return pd.read_excel(file_path)
-    elif mime_type in ["application/vnd.parquet", "application/octet-stream"]:
-        return pd.read_parquet(file_path)
+            raise ValueError("No flows found in application")
+
+    logger.info(f"Executing flow {target_flow.id} from {path}")
+
+    # Convert inputs to DataFrame (normalize single dict to 1-row DataFrame)
+    if isinstance(inputs, dict):
+        input_df = pd.DataFrame([inputs])
+    elif isinstance(inputs, pd.DataFrame):
+        input_df = inputs
     else:
         raise ValueError(
-            f"Unsupported MIME type for file {file_path}: {mime_type}"
+            f"Inputs must be dict or DataFrame, got {type(inputs)}"
         )
 
+    # Create session
+    session = Session(
+        session_id=kwargs.pop("session_id", "default"),
+        conversation_history=kwargs.pop("conversation_history", []),
+    )
+
+    # Convert DataFrame to FlowMessages with type conversion
+    initial_messages_list = dataframe_to_flow_messages(
+        input_df, target_flow.inputs, session=session
+    )
+
+    # Execute the flow
+    secret_manager = create_secret_manager_for_spec(semantic_model)
+
+    context = ExecutorContext(
+        secret_manager=secret_manager,
+        tracer=trace.get_tracer(__name__),
+    )
+    results = await run_flow(
+        target_flow,
+        initial_messages_list,
+        context=context,
+        **kwargs,
+    )
+
+    # Convert results back to DataFrame
+    results_df = flow_messages_to_dataframe(results, target_flow)
+
+    return results_df
+
 
 def run_flow(args: Any) -> None:
     """Run a QType YAML spec file by executing its flows.
@@ -82,7 +155,6 @@ def run_flow(args: Any) -> None:
     """
     import asyncio
 
-    facade = QTypeFacade()
     spec_path = Path(args.spec)
 
     try:
@@ -90,7 +162,7 @@ def run_flow(args: Any) -> None:
 
         if args.input_file:
             logger.info(f"Loading input data from file: {args.input_file}")
-            input: Any = read_data_from_file(args.input_file)
+            input: Any = read_dataframe_from_file(args.input_file)
         else:
             # Parse input JSON
             try:
@@ -99,9 +171,9 @@ def run_flow(args: Any) -> None:
                 logger.error(f"❌ Invalid JSON input: {e}")
                 return
 
-        # Execute the workflow using the facade (now async, returns DataFrame)
+        # Execute the workflow using the standalone function
         result_df = asyncio.run(
-            facade.execute_workflow(
+            execute_workflow(
                 spec_path,
                 flow_name=args.flow,
                 inputs=input,

qtype/commands/validate.py

@@ -10,7 +10,7 @@ import sys
 from pathlib import Path
 from typing import Any
 
-from qtype.base.exceptions import LoadError, SemanticError, ValidationError
+from qtype.base.exceptions import LoadError, ValidationError
 from qtype.dsl.linker import DuplicateComponentError, ReferenceNotFoundError
 from qtype.dsl.loader import YAMLLoadError
 from qtype.dsl.model import Application as DSLApplication
@@ -60,9 +60,9 @@ def main(args: Any) -> None:
     except ValidationError as e:
         logger.error(f"❌ Validation failed: {e}")
         sys.exit(1)
-    except SemanticError as e:
-        logger.error(f"❌ Semantic validation failed: {e}")
-        sys.exit(1)
+    # except SemanticError as e:
+    #     logger.error(f"❌ Semantic validation failed: {e}")
+    #     sys.exit(1)
 
     # If printing is requested, load and print the document
     if args.print:

qtype/docs/.pages

@@ -0,0 +1,8 @@
+nav:
+  - index.md
+  - Tutorials
+  - Gallery
+  - How To
+  - Concepts
+  - Reference
+  - Contributing