qtype 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

qtype/commands/run.py

@@ -5,46 +5,41 @@ Command-line interface for running QType YAML spec files.
 from __future__ import annotations
 
 import argparse
+import json
 import logging
+from pathlib import Path
 from typing import Any
 
-from qtype.dsl.domain_types import ChatMessage
-from qtype.interpreter.flow import execute_flow
-from qtype.interpreter.typing import create_input_type_model
-from qtype.loader import load
-from qtype.semantic.model import Application, Flow, Step
-
-logger = logging.getLogger(__name__)
+import magic
+import pandas as pd
 
+from qtype.application.facade import QTypeFacade
+from qtype.base.exceptions import InterpreterError, LoadError, ValidationError
 
-def _get_flow(app: Application, flow_id: str | None) -> Flow:
-    if len(app.flows) == 0:
-        raise ValueError(
-            "No flows found in the application."
-            " Please ensure the spec contains at least one flow."
-        )
+logger = logging.getLogger(__name__)
 
-    if flow_id is not None:
-        # find the first flow in the list with the given flow_id
-        flow = next((f for f in app.flows if f.id == flow_id), None)
-        if flow is None:
-            raise ValueError(f"Flow not found: {flow_id}")
 
+def read_data_from_file(file_path: str) -> pd.DataFrame:
+    """
+    Reads a file into a pandas DataFrame based on its MIME type.
+    """
+    mime_type = magic.Magic(mime=True).from_file(file_path)
+
+    if mime_type == "text/csv":
+        return pd.read_csv(file_path)
+    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)
     else:
-        flow = app.flows[0]
-
-    return flow
-
-
-def _telemetry(spec: Application) -> None:
-    if spec.telemetry:
-        logger.info(
-            f"Telemetry enabled with endpoint: {spec.telemetry.endpoint}"
+        raise ValueError(
+            f"Unsupported MIME type for file {file_path}: {mime_type}"
         )
-        # Register telemetry if needed
-        from qtype.interpreter.telemetry import register
-
-        register(spec.telemetry, spec.id)
 
 
 def run_flow(args: Any) -> None:
@@ -53,45 +48,70 @@ def run_flow(args: Any) -> None:
     Args:
         args: Arguments passed from the command line or calling context.
     """
-    spec, _ = load(args.spec)
-
-    flow = _get_flow(spec, args.flow)
-    logger.info(f"Executing flow: {flow.id}")
-    input_type = create_input_type_model(flow)
-    inputs = input_type.model_validate_json(args.input)
-    for var in flow.inputs:
-        # Get the value from the request using the variable ID
-        inputs_dict = inputs.model_dump()  # type: ignore
-        if var.id in inputs_dict:
-            var.value = getattr(inputs, var.id)
-    _telemetry(spec)
-
-    was_streamed = False
-    previous: str = ""
-
-    def stream_fn(step: Step, msg: ChatMessage | str) -> None:
-        """Stream function to handle step outputs."""
-        nonlocal was_streamed, previous
-        if step == flow.steps[-1]:
-            was_streamed = True
-            if isinstance(msg, ChatMessage):
-                content = " ".join(
-                    [m.content for m in msg.blocks if m.content]
-                )
-                # Note: streaming chat messages accumulate the content...
-                content = content.removeprefix(previous)
-                print(content, end="", flush=True)
-                previous += content
-            else:
-                print(msg, end="", flush=True)
-
-    result = execute_flow(flow, stream_fn=stream_fn)  # type: ignore
-    if not was_streamed:
-        logger.info(
-            f"Flow execution result: {', '.join([f'{var.id}: {var.value}' for var in result])}"
+    facade = QTypeFacade()
+    spec_path = Path(args.spec)
+
+    try:
+        logger.info(f"Running flow from {spec_path}")
+
+        if args.input_file:
+            logger.info(f"Loading input data from file: {args.input_file}")
+            input: Any = read_data_from_file(args.input_file)
+        else:
+            # Parse input JSON
+            try:
+                input = json.loads(args.input) if args.input else {}
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ Invalid JSON input: {e}")
+                return
+
+        # Execute the workflow using the facade
+        result = facade.execute_workflow(
+            spec_path, flow_name=args.flow, inputs=input, batch_config=None
         )
-    else:
-        print("\n")
+
+        logger.info("✅ Flow execution completed successfully")
+
+        # Print results
+        if isinstance(result, pd.DataFrame):
+            logging.info("Output DataFrame:")
+            logging.info(result)
+        elif (
+            result
+            and hasattr(result, "__iter__")
+            and not isinstance(result, str)
+        ):
+            # If result is a list of variables or similar
+            try:
+                for item in result:
+                    if hasattr(item, "id") and hasattr(item, "value"):
+                        logger.info(f"Output {item.id}: {item.value}")
+                    else:
+                        logger.info(f"Result: {item}")
+            except TypeError:
+                logger.info(f"Result: {result}")
+        elif isinstance(result, str):
+            logger.info(f"Result: {result}")
+        else:
+            logger.info("Flow completed with no output")
+
+        # save the output
+        if isinstance(result, pd.DataFrame) and args.output:
+            result.to_parquet(args.output)
+            logger.info(f"Output DataFrame saved to {args.output}")
+        elif args.output:
+            with open(args.output, "w") as f:
+                json.dump(result, f, indent=2)
+            logger.info(f"Output saved to {args.output}")
+
+    except LoadError as e:
+        logger.error(f"❌ Failed to load document: {e}")
+    except ValidationError as e:
+        logger.error(f"❌ Validation failed: {e}")
+    except InterpreterError as e:
+        logger.error(f"❌ Execution failed: {e}")
+    except Exception as e:
+        logger.error(f"❌ Unexpected error: {e}", exc_info=True)
 
 
 def parser(subparsers: argparse._SubParsersAction) -> None:
@@ -110,14 +130,31 @@ def parser(subparsers: argparse._SubParsersAction) -> None:
         default=None,
         help="The name of the flow to run. If not specified, runs the first flow found.",
     )
+    # Allow either a direct JSON string or an input file
+    input_group = cmd_parser.add_mutually_exclusive_group()
+    input_group.add_argument(
+        "-i",
+        "--input",
+        type=str,
+        default="{}",
+        help="JSON blob of input values for the flow (default: {}).",
+    )
+    input_group.add_argument(
+        "-I",
+        "--input-file",
+        type=str,
+        default=None,
+        help="Path to a file (e.g., CSV, JSON, Parquet) with input data for batch processing.",
+    )
     cmd_parser.add_argument(
-        "input",
+        "-o",
+        "--output",
         type=str,
-        help="JSON blob of input values for the flow.",
+        default=None,
+        help="Path to save output data. If input is a DataFrame, output will be saved as parquet. If single result, saved as JSON.",
     )
 
     cmd_parser.add_argument(
         "spec", type=str, help="Path to the QType YAML spec file."
     )
-
     cmd_parser.set_defaults(func=run_flow)

qtype/commands/serve.py

@@ -1,17 +1,18 @@
 """
-Command-line interface for running QType YAML spec files.
+Command-line interface for serving QType YAML spec files as web APIs.
 """
 
 from __future__ import annotations
 
 import argparse
 import logging
+from pathlib import Path
 from typing import Any
 
 import uvicorn
 
-from qtype.commands.run import _telemetry
-from qtype.loader import load
+from qtype.application.facade import QTypeFacade
+from qtype.base.exceptions import LoadError, ValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -22,31 +23,44 @@ def serve(args: Any) -> None:
     Args:
         args: Arguments passed from the command line or calling context.
     """
-    spec, _ = load(args.spec)
-    logger.info(f"Running API for spec: {args.spec}")
-    from qtype.interpreter.api import APIExecutor
-
-    # Get the name from the spec filename.
-    # so if filename is tests/specs/full_application_test.qtype.yaml, name should be "Full Application Test"
-    name = (
-        args.spec.split("/")[-1]
-        .replace(".qtype.yaml", "")
-        .replace("_", " ")
-        .title()
-    )
-
-    _telemetry(spec)
-    api_executor = APIExecutor(spec)
-    fastapi_app = api_executor.create_app(
-        name=name, ui_enabled=not args.disable_ui
-    )
-
-    uvicorn.run(
-        fastapi_app,
-        host=args.host,
-        port=args.port,
-        log_level="info",
-    )
+    facade = QTypeFacade()
+
+    try:
+        # Use facade to load and validate the document
+        spec_path = Path(args.spec)
+        logger.info(f"Loading and validating spec: {spec_path}")
+
+        semantic_model, type_registry = facade.load_semantic_model(spec_path)
+        logger.info(f"✅ Successfully loaded spec: {spec_path}")
+
+        # Import APIExecutor and create the FastAPI app
+        from qtype.interpreter.api import APIExecutor
+
+        # Get the name from the spec filename
+        name = (
+            spec_path.name.replace(".qtype.yaml", "").replace("_", " ").title()
+        )
+
+        logger.info(f"Starting server for: {name}")
+        api_executor = APIExecutor(semantic_model)
+        fastapi_app = api_executor.create_app(
+            name=name, ui_enabled=not args.disable_ui
+        )
+
+        # Start the server
+        uvicorn.run(
+            fastapi_app, host=args.host, port=args.port, log_level="info"
+        )
+
+    except LoadError as e:
+        logger.error(f"❌ Failed to load document: {e}")
+        exit(1)
+    except ValidationError as e:
+        logger.error(f"❌ Validation failed: {e}")
+        exit(1)
+    except Exception as e:
+        logger.error(f"❌ Unexpected error starting server: {e}")
+        exit(1)
 
 
 def parser(subparsers: argparse._SubParsersAction) -> None:

qtype/commands/validate.py

@@ -2,23 +2,16 @@
 Command-line interface for validating QType YAML spec files.
 """
 
+from __future__ import annotations
+
 import argparse
 import logging
 import sys
+from pathlib import Path
 from typing import Any
 
-from pydantic import ValidationError
-
-from qtype import dsl
-from qtype.dsl.custom_types import build_dynamic_types
-from qtype.dsl.validator import QTypeValidationError, validate
-from qtype.loader import (
-    _list_dynamic_types_from_document,
-    _resolve_root,
-    load_yaml,
-)
-from qtype.semantic.errors import SemanticResolutionError
-from qtype.semantic.resolver import resolve
+from qtype.application.facade import QTypeFacade
+from qtype.base.exceptions import LoadError, SemanticError, ValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -33,42 +26,32 @@ def main(args: Any) -> None:
     Exits:
         Exits with code 1 if validation fails.
     """
+    facade = QTypeFacade()
+    spec_path = Path(args.spec)
+
     try:
-        yaml_data = load_yaml(args.spec)
-        dynamic_types_lists = _list_dynamic_types_from_document(yaml_data)
-        dynamic_types_registry = build_dynamic_types(dynamic_types_lists)
-        logging.info("✅ Schema validation successful.")
+        # Use the facade for validation - it will raise exceptions on errors
+        loaded_data = facade.load_and_validate(spec_path)
+        logger.info("✅ Validation successful - document is valid.")
 
-        document = dsl.Document.model_validate(
-            yaml_data, context={"custom_types": dynamic_types_registry}
-        )
-        logging.info("✅ Model validation successful.")
-        root = _resolve_root(document)
-        if not isinstance(root, dsl.Application):
-            logging.warning(
-                "🟨 Spec is not an Application, skipping semantic resolution."
-            )
-        else:
-            root = validate(root)
-            logger.info("✅ Language validation successful")
-            app = resolve(root)
-            logger.info("✅ Semantic validation successful")
+        # If printing is requested, load and print the document
         if args.print:
-            logger.info(
-                (app if "app" in locals() else root).model_dump_json(  # type: ignore
-                    indent=2,
-                    exclude_none=True,
-                )
-            )
+            try:
+                print(loaded_data.model_dump_json(indent=2, exclude_none=True))  # type: ignore
+            except Exception as e:
+                logger.warning(f"Could not print document: {e}")
 
-    except ValidationError as exc:
-        logger.error("❌ Validation failed:\n%s", exc)
+    except LoadError as e:
+        logger.error(f"❌ Failed to load document: {e}")
+        sys.exit(1)
+    except ValidationError as e:
+        logger.error(f"❌ Validation failed: {e}")
         sys.exit(1)
-    except QTypeValidationError as exc:
-        logger.error("❌ DSL validation failed:\n%s", exc)
+    except SemanticError as e:
+        logger.error(f"❌ Semantic validation failed: {e}")
         sys.exit(1)
-    except SemanticResolutionError as exc:
-        logger.error("❌ Semantic resolution failed:\n%s", exc)
+    except Exception as e:
+        logger.error(f"❌ Unexpected error during validation: {e}")
         sys.exit(1)
 
 

qtype/commands/visualize.py

@@ -2,61 +2,75 @@
 Command-line interface for visualizing QType YAML spec files.
 """
 
+from __future__ import annotations
+
 import argparse
 import logging
 import tempfile
 import webbrowser
+from pathlib import Path
 from typing import Any
 
-from qtype.loader import load
-from qtype.semantic.visualize import visualize_application
+from qtype.application.facade import QTypeFacade
+from qtype.base.exceptions import LoadError, ValidationError
 
 logger = logging.getLogger(__name__)
 
 
 def main(args: Any) -> None:
     """
-    visualize a QType YAML spec file against the QTypeSpec schema and semantics.
+    Visualize a QType YAML spec file.
 
     Args:
         args: Arguments passed from the command line or calling context.
 
     Exits:
-        Exits with code 1 if validation fails.
+        Exits with code 1 if visualization fails.
     """
-    import mermaid as md
-
-    application, _ = load(args.spec)
-
-    diagram = visualize_application(application)
-
-    render = None
-    if args.output:
-        if args.output.endswith(".mmd") or args.output.endswith(".mermaid"):
-            with open(args.output, "w") as f:
-                f.write(diagram)
-            logger.info(f"Mermaid diagram written to {args.output}")
-        elif args.output.endswith(".svg"):
-            render = md.Mermaid(diagram)
-            render.to_svg(args.output)
-            logger.info(f"SVG diagram written to {args.output}")
-
-        elif args.output.endswith(".png"):
-            render = md.Mermaid(diagram)
-            render.to_png(args.output)
-            logger.info(f"PNG diagram written to {args.output}")
-
-    if not args.no_display:
-        if not render:
-            render = md.Mermaid(diagram)
-
-        html_content = render._repr_html_()
-        # Create a temporary HTML file to display the diagram
-        with tempfile.NamedTemporaryFile(
-            delete=False, suffix=".html"
-        ) as temp_file:
-            temp_file.write(html_content.encode("utf-8"))
-            webbrowser.open(temp_file.name)
+    facade = QTypeFacade()
+    spec_path = Path(args.spec)
+
+    try:
+        # Generate visualization using the facade
+        mermaid_content = facade.visualize_application(spec_path)
+
+        if args.output:
+            # Write to file
+            output_path = Path(args.output)
+            output_path.write_text(mermaid_content, encoding="utf-8")
+            logger.info(f"✅ Visualization saved to {output_path}")
+
+        if not args.no_display:
+            # Create temporary HTML file and open in browser
+            try:
+                import mermaid as md  # type: ignore[import-untyped]
+
+                mm = md.Mermaid(mermaid_content)
+                html_content = mm._repr_html_()
+
+                with tempfile.NamedTemporaryFile(
+                    mode="w", suffix=".html", delete=False, encoding="utf-8"
+                ) as f:
+                    f.write(html_content)
+                    temp_file = f.name
+
+                logger.info(f"Opening visualization in browser: {temp_file}")
+                webbrowser.open(f"file://{temp_file}")
+            except ImportError:
+                logger.warning(
+                    "❌ Mermaid library not installed. Cannot display in browser."
+                )
+                logger.info("Install with: pip install mermaid")
+
+    except LoadError as e:
+        logger.error(f"❌ Failed to load document: {e}")
+        exit(1)
+    except ValidationError as e:
+        logger.error(f"❌ Visualization failed: {e}")
+        exit(1)
+    except Exception as e:
+        logger.error(f"❌ Unexpected error: {e}")
+        exit(1)
 
 
 def parser(subparsers: argparse._SubParsersAction) -> None:

qtype/dsl/__init__.py

@@ -1 +1,10 @@
+"""DSL package - core data models only."""
+
+from __future__ import annotations
+
+from .base_types import *  # noqa: F403
+from .domain_types import *  # noqa: F403
 from .model import *  # noqa: F403
+
+# Note: Validation logic has been moved to qtype.semantic package
+# to avoid circular dependencies

qtype/dsl/base_types.py

@@ -24,6 +24,14 @@ class PrimitiveTypeEnum(str, Enum):
     video = "video"
 
 
+class StepCardinality(str, Enum):
+    """Does this step emit 1 (one) or 0...N (many) items?"""
+
+    one = "one"
+    many = "many"
+    auto = "auto"  # Let's the step determine this in semantic resolution. Currently only Flows can do this..
+
+
 class StrictBaseModel(BaseModel):
     """Base model with extra fields forbidden."""
 

qtype/dsl/custom_types.py

@@ -2,13 +2,13 @@ from typing import Any, ForwardRef, Type, Union
 
 from pydantic import BaseModel, create_model
 
-from qtype.converters.types import PRIMITIVE_TO_PYTHON_TYPE
+from qtype.application.converters.types import PRIMITIVE_TO_PYTHON_TYPE
 
 # --- This would be in your interpreter's logic ---
 
 
 def build_dynamic_types(
-    type_definitions: list[dict]
+    type_definitions: list[dict],
 ) -> dict[str, Type[BaseModel]]:
     """
     Parses a list of simplified type definitions and dynamically creates
@@ -32,7 +32,7 @@ def build_dynamic_types(
         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]
+            resolved_type: Any = list[inner_type]  # type: ignore[misc, valid-type]
         elif type_str in PRIMITIVE_MAP:
             resolved_type = PRIMITIVE_MAP[type_str]
         elif type_str in created_models:
@@ -60,7 +60,9 @@ def build_dynamic_types(
 
         # Pass the created_models dict as the local namespace for resolution
         DynamicModel = create_model(
-            model_name, **field_definitions, __localns=created_models
+            model_name,
+            **field_definitions,
+            __localns=created_models,  # type: ignore[call-overload]
         )
         created_models[model_name] = DynamicModel