qtype 0.1.0__tar.gz → 0.1.1__tar.gz

{qtype-0.1.0/qtype.egg-info → qtype-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qtype
-Version: 0.1.0
+Version: 0.1.1
 Summary: DSL for Generative AI Prototyping
 Author-email: Lou Kratz <lou.kratz+qtype@bazaarvoice.com>
 License-Expression: Apache-2.0

{qtype-0.1.0 → qtype-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qtype"
-version = "0.1.0"
+version = "0.1.1"
 description = "DSL for Generative AI Prototyping"
 authors = [{ name="Lou Kratz", email="lou.kratz+qtype@bazaarvoice.com" }]
 readme = "README.md"

{qtype-0.1.0 → qtype-0.1.1}/qtype/application/facade.py

@@ -2,10 +2,10 @@
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 from typing import Any
 
-from qtype.base.logging import get_logger
 from qtype.base.types import PathLike
 from qtype.semantic.model import Application as SemanticApplication
 from qtype.semantic.model import DocumentType as SemanticDocumentType
@@ -14,7 +14,7 @@ from qtype.semantic.model import DocumentType as SemanticDocumentType
 # That's the whole point of this facade - to avoid importing optional
 # dependencies unless these methods are called.
 
-logger = get_logger("application.facade")
+logger = logging.getLogger(__name__)
 
 
 class QTypeFacade:

{qtype-0.1.0 → qtype-0.1.1}/qtype/cli.py

@@ -7,6 +7,10 @@ import importlib
 import logging
 from pathlib import Path
 
+from qtype.base.logging import get_logger
+
+logger = get_logger("application.facade")
+
 try:
     from importlib.metadata import entry_points
 except ImportError:

{qtype-0.1.0 → qtype-0.1.1}/qtype/commands/run.py

@@ -7,10 +7,12 @@ from __future__ import annotations
 import argparse
 import json
 import logging
+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
@@ -18,6 +20,15 @@ from qtype.base.exceptions import InterpreterError, LoadError, ValidationError
 logger = logging.getLogger(__name__)
 
 
+# Supress specific pydantic warnings that llamaindex needs to fix
+warnings.filterwarnings("ignore", category=UnsupportedFieldAttributeWarning)
+
+
+# supress qdrant logging
+for name in ["httpx", "urllib3", "qdrant_client"]:
+    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.
@@ -87,7 +98,10 @@ def run_flow(args: Any) -> None:
         # Execute the workflow using the facade (now async, returns DataFrame)
         result_df = asyncio.run(
             facade.execute_workflow(
-                spec_path, flow_name=args.flow, inputs=input
+                spec_path,
+                flow_name=args.flow,
+                inputs=input,
+                show_progress=args.progress,
             )
         )
 
@@ -95,7 +109,7 @@ def run_flow(args: Any) -> None:
 
         # Display results
         if len(result_df) > 0:
-            logger.info(f"Processed {len(result_df)} input(s)")
+            logger.info(f"Processed {len(result_df)} em")
 
             # Remove 'row' and 'error' columns for display if all errors are None
             display_df = result_df.copy()
@@ -108,7 +122,7 @@ def run_flow(args: Any) -> None:
                 display_df = display_df.drop(columns=["row"])
 
             if len(display_df) > 1:
-                logger.info(f"\nResults:\n{display_df.to_string()}")
+                logger.info(f"\nResults:\n{display_df[0:10].to_string()}\n...")
             else:
                 # Print the first row with column_name: value one per line
                 fmt_str = []
@@ -172,6 +186,11 @@ def parser(subparsers: argparse._SubParsersAction) -> None:
         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(
+        "--progress",
+        action="store_true",
+        help="Show progress bars during flow execution.",
+    )
 
     cmd_parser.add_argument(
         "spec", type=str, help="Path to the QType YAML spec file."

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/base/base_step_executor.py

@@ -212,7 +212,6 @@ class StepExecutor(ABC):
                     num_workers = (
                         self.step.concurrency_config.num_workers  # type: ignore[attr-defined]
                     )
-
                 span.set_attribute("step.concurrency", num_workers)
 
                 # Prepare messages for processing (batching hook)
@@ -331,6 +330,11 @@ class StepExecutor(ABC):
             cached_result = self.cache.get(key)
             if cached_result is not None:
                 result = [from_cache_value(d, message) for d in cached_result]  # type: ignore
+                self.progress.increment_cache(
+                    self.context.on_progress,
+                    hit_delta=len(result),
+                    miss_delta=0,
+                )
                 # cache hit
                 for msg in result:
                     yield msg
@@ -341,6 +345,9 @@ class StepExecutor(ABC):
                     buf.append(output_msg)
                     yield output_msg
 
+                self.progress.increment_cache(
+                    self.context.on_progress, hit_delta=0, miss_delta=len(buf)
+                )
                 # store the results in the cache of there are no errors or if instructed to do so
                 if (
                     all(not msg.is_failed() for msg in buf)

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/base/progress_tracker.py

@@ -20,6 +20,8 @@ class ProgressTracker:
         self.items_processed = 0
         self.items_in_error = 0
         self.total_items = total_items
+        self.cache_hits = None
+        self.cache_misses = None
 
     @property
     def items_succeeded(self) -> int:
@@ -36,6 +38,8 @@ class ProgressTracker:
         on_progress: ProgressCallback | None,
         processed_delta: int,
         error_delta: int,
+        hit_delta: int | None = None,
+        miss_delta: int | None = None,
     ) -> None:
         """
         Update progress counters and invoke the progress callback.
@@ -51,6 +55,19 @@ class ProgressTracker:
         self.items_processed += processed_delta
         self.items_in_error += error_delta
 
+        if hit_delta is not None:
+            self.cache_hits = (
+                self.cache_hits + hit_delta
+                if self.cache_hits is not None
+                else hit_delta
+            )
+        if miss_delta is not None:
+            self.cache_misses = (
+                self.cache_misses + miss_delta
+                if self.cache_misses is not None
+                else miss_delta
+            )
+
         if on_progress:
             on_progress(
                 self.step_id,
@@ -58,6 +75,8 @@ class ProgressTracker:
                 self.items_in_error,
                 self.items_succeeded,
                 self.total_items,
+                self.cache_hits,
+                self.cache_misses,
             )
 
     def update_for_message(
@@ -73,3 +92,19 @@ class ProgressTracker:
             on_progress: Optional callback to notify of progress updates
         """
         self.update(on_progress, 1, 1 if message.is_failed() else 0)
+
+    def increment_cache(
+        self,
+        on_progress: ProgressCallback | None,
+        hit_delta: int = 0,
+        miss_delta: int = 0,
+    ) -> None:
+        """
+        Increment cache hit/miss counters.
+
+        Args:
+            on_progress: Optional callback to notify of progress updates
+            hit_delta: Number of cache hits to add
+            miss_delta: Number of cache misses to add
+        """
+        self.update(on_progress, 0, 0, hit_delta, miss_delta)

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/base/step_cache.py

@@ -4,7 +4,8 @@ import pathlib
 from typing import Any
 
 import diskcache as dc
-from openai import BaseModel
+from pydantic import BaseModel
+from pydantic.json import pydantic_encoder
 
 from qtype.base.types import CacheConfig
 from qtype.interpreter.types import FlowMessage
@@ -41,7 +42,7 @@ def cache_key(message: FlowMessage, step: Step) -> str:
             raise ValueError(
                 f"Input variable '{var.id}' not found in message -- caching can not be performed."
             )
-    input_str = json.dumps(inputs, sort_keys=True)
+    input_str = json.dumps(inputs, sort_keys=True, default=pydantic_encoder)
     return hashlib.sha256(input_str.encode("utf-8")).hexdigest()
 
 

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/conversions.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+import uuid
 from typing import Any
 
 from llama_index.core.base.embeddings.base import BaseEmbedding
@@ -305,7 +306,8 @@ def to_embedding_model(model: Model) -> BaseEmbedding:
         )
 
         bedrock_embedding: BaseEmbedding = BedrockEmbedding(
-            model_name=model.model_id if model.model_id else model.id
+            model_name=model.model_id if model.model_id else model.id,
+            max_retries=100,
         )
         return bedrock_embedding
     elif model.provider == "openai":
@@ -506,26 +508,30 @@ def to_text_splitter(splitter: DocumentSplitter) -> Any:
     Raises:
         InterpreterError: If the splitter class cannot be found or instantiated.
     """
-    from llama_index.core.node_parser import SentenceSplitter
 
-    # Map common splitter names to their classes
-    splitter_classes = {
-        "SentenceSplitter": SentenceSplitter,
-    }
+    module_path = "llama_index.core.node_parser"
+    class_name = splitter.splitter_name
+    try:
+        reader_module = importlib.import_module(module_path)
+        splitter_class = getattr(reader_module, class_name)
+    except (ImportError, AttributeError) as e:
+        raise ImportError(
+            f"Failed to import reader class '{class_name}' from '{module_path}': {e}"
+        ) from e
+    from llama_index.core.schema import BaseNode
 
-    # Get the splitter class
-    splitter_class = splitter_classes.get(splitter.splitter_name)
+    # TODO: let the user specify a custom ID namespace
+    namespace = uuid.UUID("12345678-1234-5678-1234-567812345678")
 
-    if splitter_class is None:
-        raise InterpreterError(
-            f"Unsupported text splitter: {splitter.splitter_name}. "
-            f"Supported splitters: {', '.join(splitter_classes.keys())}"
-        )
+    def id_func(i: int, doc: BaseNode) -> str:
+        u = uuid.uuid5(namespace, f"{doc.node_id}_{i}")
+        return str(u)
 
     # Prepare arguments for the splitter
     splitter_args = {
         "chunk_size": splitter.chunk_size,
         "chunk_overlap": splitter.chunk_overlap,
+        "id_func": id_func,
         **splitter.args,
     }
 

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/converters.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import pandas as pd
+from pydantic import BaseModel
 
 from qtype.interpreter.types import FlowMessage, Session
 from qtype.semantic.model import Flow
@@ -54,7 +55,10 @@ def flow_messages_to_dataframe(
         # Extract output variables
         for var in flow.outputs:
             if var.id in message.variables:
-                row_data[var.id] = message.variables[var.id]
+                value = message.variables[var.id]
+                if isinstance(value, BaseModel):
+                    value = value.model_dump()
+                row_data[var.id] = value
             else:
                 row_data[var.id] = None
 

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/executors/document_embedder_executor.py

@@ -1,5 +1,14 @@
 from typing import AsyncIterator
 
+from botocore.exceptions import ClientError
+from llama_index.core.base.embeddings.base import BaseEmbedding
+from tenacity import (
+    retry,
+    retry_if_exception,
+    stop_after_attempt,
+    wait_exponential,
+)
+
 from qtype.dsl.domain_types import RAGChunk
 from qtype.interpreter.base.base_step_executor import StepExecutor
 from qtype.interpreter.base.executor_context import ExecutorContext
@@ -8,6 +17,13 @@ from qtype.interpreter.types import FlowMessage
 from qtype.semantic.model import DocumentEmbedder
 
 
+def is_throttling_error(e):
+    return (
+        isinstance(e, ClientError)
+        and e.response["Error"]["Code"] == "ThrottlingException"
+    )
+
+
 class DocumentEmbedderExecutor(StepExecutor):
     """Executor for DocumentEmbedder steps."""
 
@@ -24,7 +40,25 @@ class DocumentEmbedderExecutor(StepExecutor):
             )
         self.step: DocumentEmbedder = step
         # Initialize the embedding model once for the executor
-        self.embedding_model = to_embedding_model(self.step.model)
+        self.embedding_model: BaseEmbedding = to_embedding_model(
+            self.step.model
+        )
+
+    # TODO: properly abstract this into a mixin
+    @retry(
+        retry=retry_if_exception(is_throttling_error),
+        wait=wait_exponential(multiplier=0.5, min=1, max=30),
+        stop=stop_after_attempt(10),
+    )
+    async def _embed(self, text: str) -> list[float]:
+        """Generate embedding for the given text using the embedding model.
+
+        Args:
+            text: The text to embed.
+        Returns:
+            The embedding vector as a list of floats.
+        """
+        return await self.embedding_model.aget_text_embedding(text=text)
 
     async def process_message(
         self,
@@ -52,9 +86,7 @@ class DocumentEmbedderExecutor(StepExecutor):
                 )
 
             # Generate embedding for the chunk content
-            vector = self.embedding_model.get_text_embedding(
-                text=str(chunk.content)
-            )
+            vector = await self._embed(str(chunk.content))
 
             # Create the output chunk with the vector
             embedded_chunk = RAGChunk(

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/executors/document_splitter_executor.py

@@ -72,7 +72,7 @@ class DocumentSplitterExecutor(StepExecutor):
             llama_doc = LlamaDocument(
                 text=content_text,
                 metadata=document.metadata or {},
-                id_=document.file_id,
+                doc_id=document.file_id,
             )
 
             # Split the document using the LlamaIndex splitter

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/executors/index_upsert_executor.py

@@ -65,7 +65,7 @@ class IndexUpsertExecutor(BatchedStepExecutor):
         Yields:
             FlowMessages: Success messages after upserting to the index
         """
-        logger.info(
+        logger.debug(
             f"Executing IndexUpsert step: {self.step.id} with batch size: {len(batch)}"
         )
 
@@ -102,7 +102,7 @@ class IndexUpsertExecutor(BatchedStepExecutor):
                 else:  # document index
                     await self._upsert_to_document_index(items_to_upsert)
 
-                logger.info(
+                logger.debug(
                     f"Successfully upserted {len(items_to_upsert)} items "
                     f"to {self.index_type} index in batch"
                 )

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/executors/invoke_embedding_executor.py

@@ -58,13 +58,13 @@ class InvokeEmbeddingExecutor(StepExecutor):
             if input_type == PrimitiveTypeEnum.text:
                 if not isinstance(input_value, str):
                     input_value = str(input_value)
-                vector = self.embedding_model.get_text_embedding(
+                vector = await self.embedding_model.aget_text_embedding(
                     text=input_value
                 )
                 content = input_value
             elif input_type == PrimitiveTypeEnum.image:
                 # For image embeddings
-                vector = self.embedding_model.get_image_embedding(
+                vector = await self.embedding_model.aget_image_embedding(
                     image_path=input_value
                 )
                 content = input_value

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/executors/invoke_tool_executor.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import asyncio
 import importlib
+import inspect
 import logging
 import time
 import uuid
@@ -86,7 +88,10 @@ class ToolExecutionMixin:
                         )
                     )
 
-                result = function(**inputs)
+                if inspect.iscoroutinefunction(function):
+                    result = await function(**inputs)
+                else:
+                    result = await asyncio.to_thread(function, **inputs)
                 await tool_ctx.complete(result)
                 return result
 

{qtype-0.1.0 → qtype-0.1.1}/qtype/interpreter/flow.py

@@ -12,6 +12,7 @@ from opentelemetry.trace import Status, StatusCode
 
 from qtype.interpreter.base import factory
 from qtype.interpreter.base.executor_context import ExecutorContext
+from qtype.interpreter.rich_progress import RichProgressCallback
 from qtype.interpreter.types import FlowMessage
 from qtype.semantic.model import Flow
 
@@ -19,7 +20,10 @@ logger = logging.getLogger(__name__)
 
 
 async def run_flow(
-    flow: Flow, initial: list[FlowMessage] | FlowMessage, **kwargs
+    flow: Flow,
+    initial: list[FlowMessage] | FlowMessage,
+    show_progress: bool = False,
+    **kwargs,
 ) -> list[FlowMessage]:
     """
     Main entrypoint for executing a flow.
@@ -38,11 +42,16 @@ async def run_flow(
 
     # Extract or create ExecutorContext
     exec_context = kwargs.pop("context", None)
+    progress_callback = RichProgressCallback() if show_progress else None
     if exec_context is None:
         exec_context = ExecutorContext(
             secret_manager=NoOpSecretManager(),
             tracer=trace.get_tracer(__name__),
+            on_progress=progress_callback,
         )
+    else:
+        if exec_context.on_progress is None and show_progress:
+            exec_context.on_progress = progress_callback
 
     # Use tracer from context
     tracer = exec_context.tracer or trace.get_tracer(__name__)
@@ -110,6 +119,9 @@ async def run_flow(
         # 4. Collect the final results from the last stream
         final_results = [state async for state in current_stream]
 
+        # Close the progress bars if any
+        if progress_callback is not None:
+            progress_callback.close()
         # Record flow completion metrics
         span.set_attribute("flow.output_count", len(final_results))
         error_count = sum(1 for msg in final_results if msg.is_failed())