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

qtype/interpreter/batch/step.py

@@ -1,63 +0,0 @@
-from functools import partial
-from typing import Any, Tuple
-
-import pandas as pd
-
-from qtype.interpreter.batch.sql_source import execute_sql_source
-from qtype.interpreter.batch.types import BatchConfig
-from qtype.interpreter.batch.utils import (
-    batch_iterator,
-    single_step_adapter,
-    validate_inputs,
-)
-from qtype.interpreter.exceptions import InterpreterError
-from qtype.semantic.model import (
-    Condition,
-    Decoder,
-    Flow,
-    PromptTemplate,
-    Search,
-    SQLSource,
-    Step,
-    Tool,
-)
-
-SINGLE_WRAP_STEPS = {Decoder, Condition, PromptTemplate, Search, Tool}
-
-
-def batch_execute_step(
-    step: Step,
-    inputs: pd.DataFrame,
-    batch_config: BatchConfig,
-    **kwargs: dict[str, Any],
-) -> Tuple[pd.DataFrame, pd.DataFrame]:
-    """
-    Executes a given step in a batch processing pipeline.
-
-    Args:
-        step (Step): The step to be executed.
-        inputs (pd.DataFrame): The input data for the step.
-        batch_config (BatchConfig): Configuration for batch processing.
-        **kwargs: Additional keyword arguments.
-
-    Returns:
-        Tuple[pd.DataFrame, pd.DataFrame]: A tuple containing the output results and any rows that returned errors.
-    """
-
-    validate_inputs(inputs, step)
-
-    if isinstance(step, Flow):
-        from qtype.interpreter.batch.flow import batch_execute_flow
-
-        return batch_execute_flow(step, inputs, batch_config, **kwargs)
-    elif isinstance(step, SQLSource):
-        return execute_sql_source(step, inputs, batch_config, **kwargs)
-    elif step in SINGLE_WRAP_STEPS:
-        return batch_iterator(
-            f=partial(single_step_adapter, step=step),
-            batch=inputs,
-            batch_config=batch_config,
-        )
-    # TODO: implement batching for multi-row steps. For example, llm inference can be sped up in batch...
-    else:
-        raise InterpreterError(f"Unsupported step type: {type(step).__name__}")

qtype/interpreter/batch/types.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-
-from pydantic import BaseModel, Field
-
-
-class ErrorMode(str, Enum):
-    """Error handling mode for batch processing."""
-
-    FAIL = "fail"
-    DROP = "drop"
-
-
-class BatchConfig(BaseModel):
-    """Configuration for batch execution.
-
-    Attributes:
-        num_workers: Number of async workers for batch operations.
-        batch_size: Maximum number of rows to send to a step at a time.
-        error_mode: Error handling mode for batch processing.
-    """
-
-    num_workers: int = Field(
-        default=4,
-        description="Number of async workers for batch operations",
-        gt=0,
-    )
-    batch_size: int = Field(
-        default=512,
-        description="Max number of rows to send to a step at a time",
-        gt=0,
-    )
-    error_mode: ErrorMode = Field(
-        default=ErrorMode.FAIL,
-        description="Error handling mode for batch processing",
-    )
-    write_errors_to: str | None = Field(
-        default=None,
-        description="If error mode is DROP, the errors for any step are saved to this directory",
-    )

qtype/interpreter/batch/utils.py

@@ -1,179 +0,0 @@
-from __future__ import annotations
-
-import copy
-from typing import Any, Callable, Tuple
-
-import pandas as pd
-
-from qtype.interpreter.batch.types import BatchConfig, ErrorMode
-from qtype.semantic.model import Step
-
-
-class InputMissingError(Exception):
-    """Raised when a required input variable is missing from the DataFrame."""
-
-    pass
-
-
-def validate_inputs(batch: pd.DataFrame, step: Step) -> pd.DataFrame:
-    """Ensures all input variables for the step are columns in the DataFrame.
-    If not, an Exception is raised.
-
-    Args:
-        batch: The input DataFrame to decode.
-        decoder: The decoder step to validate.
-
-    Returns:
-        A view of the dataframe with only the input columns for the step.
-
-    Raises:
-        InputMissingError: If the decoder step does not have exactly one input or if the input column is not in the DataFrame.
-    """
-    input_ids = [input_var.id for input_var in step.inputs]
-    for input_var in input_ids:
-        if input_var not in batch.columns:
-            raise InputMissingError(
-                f"Input DataFrame must contain column '{input_var}' for step {step.id}."
-            )
-    return batch[input_ids]
-
-
-def fail_mode_wrapper(
-    f: Callable[..., dict[str, Any]],
-    row: pd.Series,
-    batch_config: BatchConfig,
-    **kwargs: dict[str, Any],
-) -> dict | Exception:
-    """Executes a function with error handling based on the batch configuration.
-
-    Args:
-        f: The function to execute that can take any arguments and returns a dict of results.
-        row: The input row as a dictionary.
-        batch_config: Configuration for error handling.
-        **kwargs: Additional keyword arguments.
-
-    Returns:
-        The result of the function or an Exception if an error occurs and the error mode is set to CONTINUE.
-    """
-    try:
-        # turn row into a dict and merge with kwargs
-        merged_kwargs = {**row.to_dict(), **kwargs}
-        return f(**merged_kwargs)
-    except Exception as e:
-        if batch_config.error_mode == ErrorMode.FAIL:
-            raise e
-        else:
-            return e
-
-
-def single_step_adapter(
-    step: Step, **inputs: dict[str, Any]
-) -> dict[str, Any]:
-    """A batch adapter for steps that have no side effects or access shared resources."""
-    from qtype.interpreter.step import execute_step
-
-    step_clone = copy.deepcopy(step)
-    for input_var in step_clone.inputs:
-        if input_var.id in inputs:
-            input_var.value = inputs[input_var.id]
-        else:
-            raise ValueError(
-                f"Input variable '{input_var.id}' not found in inputs."
-            )
-    execute_step(step_clone)
-    return {
-        output_var.id: output_var.value for output_var in step_clone.outputs
-    }
-
-
-def to_series(
-    rv: dict | Exception, error_col_name: str = "error"
-) -> pd.Series:
-    # If rv is an exception, return a series with index "error"
-    if isinstance(rv, Exception):
-        return pd.Series({error_col_name: str(rv)})
-    return pd.Series(rv)  # type: ignore[no-any-return]
-
-
-def batch_iterator(
-    f: Callable[..., dict[str, Any]],
-    batch: pd.DataFrame,
-    batch_config: BatchConfig,
-    **kwargs: Any,
-) -> Tuple[pd.DataFrame, pd.DataFrame]:
-    """Executes a step over a batch of inputs with error handling.
-
-    Args:
-        step: The step to execute.
-        batch: The input DataFrame to process.
-        batch_config: Configuration for error handling.
-        **kwargs: Additional keyword arguments to pass to the step.
-
-    Returns:
-        A tuple containing two DataFrames:
-            - The first DataFrame contains successful results with output columns.
-            - The second DataFrame contains rows that encountered errors with an 'error' column.
-    """
-
-    # Use a unique column name for errors
-    error_col = "error_" + str(id(f))
-
-    # If error_col is already in the dataframe, throw an exception
-    if error_col in batch.columns:
-        raise ValueError(
-            f"Error column name '{error_col}' already exists in the batch DataFrame."
-        )
-
-    def the_pipe(row: pd.Series) -> pd.Series:
-        return to_series(
-            fail_mode_wrapper(f, row, batch_config=batch_config, **kwargs),
-            error_col_name=error_col,
-        )
-
-    results = batch.apply(the_pipe, axis=1)
-
-    # Split the results into two dataframes, one where error_col is not defined, and one where it is.
-    success_mask = ~results[error_col].notna()
-    failed_mask = results[error_col].notna()
-
-    # Create success DataFrame (drop the error column)
-    success_df = results[success_mask].drop(columns=[error_col])
-
-    # Create failed DataFrame (keep only original columns plus error)
-    original_columns = batch.columns.tolist()
-
-    if failed_mask.any():
-        failed_df = results[failed_mask]
-        # Drop all the output columns from failed_df, keep only original input columns + error
-        failed_df = failed_df[original_columns + [error_col]]
-    else:
-        # No failed rows, create empty DataFrame with expected structure
-        failed_df = pd.DataFrame(columns=original_columns + [error_col])
-
-    return success_df, failed_df
-
-
-def reconcile_results_and_errors(
-    results: list[pd.DataFrame], errors: list[pd.DataFrame]
-) -> Tuple[pd.DataFrame, pd.DataFrame]:
-    """
-    Concatenates lists of pandas DataFrames containing results and errors into single DataFrames.
-
-    If the input lists are empty, creates empty DataFrames as placeholders.
-
-    Args:
-        results (list[pd.DataFrame]): List of DataFrames containing results.
-        errors (list[pd.DataFrame]): List of DataFrames containing errors.
-
-    Returns:
-        Tuple[pd.DataFrame, pd.DataFrame]: A tuple containing:
-            - A single DataFrame with all results concatenated.
-            - A single DataFrame with all errors concatenated.
-    """
-    if not results:
-        results = [pd.DataFrame({})]
-    if not errors:
-        errors = [pd.DataFrame({})]
-    return pd.concat(results, ignore_index=True), pd.concat(
-        errors, ignore_index=True
-    )

qtype/interpreter/chat/chat_api.py

@@ -1,237 +0,0 @@
-from __future__ import annotations
-
-import logging
-import uuid
-from collections.abc import Generator
-from typing import Any
-
-from fastapi import FastAPI
-from fastapi.responses import StreamingResponse
-
-from qtype.dsl.base_types import PrimitiveTypeEnum
-from qtype.dsl.domain_types import ChatContent, ChatMessage, MessageRole
-from qtype.interpreter.chat.file_conversions import file_to_content
-from qtype.interpreter.chat.vercel import (
-    ChatRequest,
-    ErrorChunk,
-    FinishChunk,
-    StartChunk,
-    TextDeltaChunk,
-    TextEndChunk,
-    TextStartChunk,
-    UIMessage,
-)
-from qtype.interpreter.flow import execute_flow
-from qtype.interpreter.streaming_helpers import create_streaming_generator
-from qtype.semantic.model import Flow
-
-
-def _ui_request_to_domain_type(request: ChatRequest) -> list[ChatMessage]:
-    """
-    Convert a ChatRequest to domain-specific ChatMessages.
-
-    Processes all UI messages from the AI SDK UI/React request format.
-    Returns the full conversation history for context.
-    """
-    if not request.messages:
-        raise ValueError("No messages provided in request.")
-
-    # Convert each UIMessage to a domain-specific ChatMessage
-    return [
-        _ui_message_to_domain_type(message) for message in request.messages
-    ]
-
-
-def _ui_message_to_domain_type(message: UIMessage) -> ChatMessage:
-    """
-    Convert a UIMessage to a domain-specific ChatMessage.
-
-    Creates one block for each part in the message content.
-    """
-    blocks = []
-
-    for part in message.parts:
-        if part.type == "text":
-            blocks.append(
-                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)
-            )
-        elif part.type == "reasoning":
-            blocks.append(
-                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)
-            )
-        elif part.type == "file":
-            blocks.append(
-                file_to_content(part.url)  # type: ignore
-            )
-        elif part.type.startswith("tool-"):
-            raise NotImplementedError(
-                "Tool call part handling is not implemented yet."
-            )
-        elif part.type == "dynamic-tool":
-            raise NotImplementedError(
-                "Dynamic tool part handling is not implemented yet."
-            )
-        elif part.type == "step-start":
-            # Step boundaries might not need content blocks
-            continue
-        elif part.type in ["source-url", "source-document"]:
-            raise NotImplementedError(
-                "Source part handling is not implemented yet."
-            )
-        elif part.type.startswith("data-"):
-            raise NotImplementedError(
-                "Data part handling is not implemented yet."
-            )
-        else:
-            # Log unknown part types for debugging
-            raise ValueError(f"Unknown part type: {part.type}")
-
-    # If no blocks were created, raise an error
-    if not blocks:
-        raise ValueError(
-            "No valid content blocks created from UIMessage parts."
-        )
-
-    return ChatMessage(
-        role=MessageRole(message.role),
-        blocks=blocks,
-    )
-
-
-def create_chat_flow_endpoint(app: FastAPI, flow: Flow) -> None:
-    """
-    Create a chat endpoint for the given Flow.
-
-    This creates an endpoint at /flows/{flow_id}/chat that follows the
-    AI SDK UI/React request format and responds with streaming data.
-
-    Args:
-        app: The FastAPI application instance
-        flow: The Flow to create an endpoint for
-    """
-    flow_id = flow.id
-
-    async def handle_chat_data(request: ChatRequest) -> StreamingResponse:
-        """Handle chat requests for the specific flow."""
-
-        try:
-            # Convert AI SDK UI request to domain ChatMessages
-            messages = _ui_request_to_domain_type(request)
-            if not len(messages):
-                raise ValueError("No input messages received")
-
-            # Pop the last message as the current input
-            current_input = messages.pop()
-            if current_input.role != MessageRole.user:
-                raise ValueError(
-                    f"Unexpected input {current_input} from non user role: {current_input.role}"
-                )
-
-            flow_copy = flow.model_copy(deep=True)
-
-            input_variable = [
-                var for var in flow_copy.inputs if var.type == ChatMessage
-            ][0]
-            input_variable.value = current_input
-
-            # Pass conversation context to flow execution for memory population
-            execution_kwargs: Any = {
-                "session_id": request.id,  # Use request ID as session identifier
-                "conversation_history": messages,
-            }
-
-            # Create a streaming generator for the flow execution
-            stream_generator, result_future = create_streaming_generator(
-                execute_flow, flow_copy, **execution_kwargs
-            )
-        except Exception as e:
-            error_chunk = ErrorChunk(errorText=str(e))
-            response = StreamingResponse(
-                [
-                    f"data: {error_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                ],
-                media_type="text/plain; charset=utf-8",
-            )
-            response.headers["x-vercel-ai-ui-message-stream"] = "v1"
-            return response
-
-        # Create generator that formats messages according to AI SDK UI streaming protocol
-        def vercel_ai_formatter() -> Generator[str, None, None]:
-            """Format stream data according to AI SDK UI streaming protocol."""
-
-            # Send start chunk
-            start_chunk = StartChunk(messageId=str(uuid.uuid4()))  # type: ignore
-            yield f"data: {start_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-            # Track text content for proper streaming
-            text_id = str(uuid.uuid4())
-            text_started = False
-
-            for step, message in stream_generator:
-                if isinstance(message, ChatMessage):
-                    # Convert ChatMessage to text content
-                    content = " ".join(
-                        [
-                            block.content
-                            for block in message.blocks
-                            if hasattr(block, "content") and block.content
-                        ]
-                    )
-                    if content.strip():
-                        # Start text block if not started
-                        if not text_started:
-                            text_start = TextStartChunk(id=text_id)
-                            yield f"data: {text_start.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                            text_started = True
-
-                        # Send text delta
-                        text_delta = TextDeltaChunk(id=text_id, delta=content)
-                        yield f"data: {text_delta.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                else:
-                    # Handle other message types as text deltas
-                    text_content = str(message)
-                    if text_content.strip():
-                        # Start text block if not started
-                        if not text_started:
-                            text_start = TextStartChunk(id=text_id)
-                            yield f"data: {text_start.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                            text_started = True
-
-                        # Send text delta
-                        text_delta = TextDeltaChunk(
-                            id=text_id, delta=text_content
-                        )
-                        yield f"data: {text_delta.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-            # End text block if it was started
-            if text_started:
-                text_end = TextEndChunk(id=text_id)
-                yield f"data: {text_end.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-            # Send finish chunk
-            try:
-                result_future.result(timeout=5.0)
-                finish_chunk = FinishChunk()
-                yield f"data: {finish_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-            except Exception as e:
-                # Send error
-                error_chunk = ErrorChunk(errorText=str(e))
-                logging.error(
-                    f"Error during flow execution: {e}", exc_info=True
-                )
-                yield f"data: {error_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-        response = StreamingResponse(
-            vercel_ai_formatter(), media_type="text/plain; charset=utf-8"
-        )
-        response.headers["x-vercel-ai-ui-message-stream"] = "v1"
-        return response
-
-    # Add the endpoint to the FastAPI app
-    app.post(
-        f"/flows/{flow_id}/chat",
-        tags=["chat"],
-        summary=f"Chat with {flow_id} flow",
-        description=flow.description,
-        response_class=StreamingResponse,
-    )(handle_chat_data)