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

qtype/interpreter/steps/llm_inference.py

@@ -1,150 +0,0 @@
-import logging
-from typing import Any, Callable
-
-from llama_index.core.base.llms.types import ChatResponse, CompletionResponse
-
-from qtype.dsl.domain_types import ChatMessage, Embedding
-from qtype.interpreter.conversions import (
-    from_chat_message,
-    to_chat_message,
-    to_embedding_model,
-    to_llm,
-    to_memory,
-)
-from qtype.interpreter.exceptions import InterpreterError
-from qtype.semantic.model import EmbeddingModel, LLMInference, Variable
-
-logger = logging.getLogger(__name__)
-
-
-def execute(
-    li: LLMInference,
-    stream_fn: Callable | None = None,
-    **kwargs: dict[Any, Any],
-) -> list[Variable]:
-    """Execute a LLM inference step.
-
-    Args:
-        li: The LLM inference step to execute.
-        stream_fn: Optional streaming callback function.
-        **kwargs: Additional keyword arguments including conversation_history.
-    """
-    logger.debug(f"Executing LLM inference step: {li.id}")
-
-    # Ensure we only have one output variable set.
-    if len(li.outputs) != 1:
-        raise InterpreterError(
-            "LLMInference step must have exactly one output variable."
-        )
-    output_variable = li.outputs[0]
-
-    # Determine if this is a chat session, completion, or embedding inference
-    if output_variable.type == Embedding:
-        if not isinstance(li.model, EmbeddingModel):
-            raise InterpreterError(
-                f"LLMInference step with Embedding output must use an embedding model, got {type(li.model)}"
-            )
-        if len(li.inputs) != 1:
-            raise InterpreterError(
-                "LLMInference step for completion must have exactly one input variable."
-            )
-
-        input = li.inputs[0].value
-        model = to_embedding_model(li.model)
-        result = model.get_text_embedding(text=input)
-        output_variable.value = Embedding(
-            vector=result,
-            source_text=input if isinstance(input, str) else None,
-            metadata=None,
-        )
-    elif output_variable.type == ChatMessage:
-        model = to_llm(li.model, li.system_message)
-        if not all(
-            isinstance(input.value, ChatMessage) for input in li.inputs
-        ):
-            raise InterpreterError(
-                f"LLMInference step with ChatMessage output must have ChatMessage inputs. Got {li.inputs}"
-            )
-
-        # Current user input
-        inputs = [
-            to_chat_message(input.value)  # type: ignore
-            for input in li.inputs
-        ]
-
-        # The session id is used to isolate the memory from other "users"
-        session_id = kwargs.get("session_id")
-
-        # If memory is defined, use it.
-        if li.memory:
-            memory = to_memory(session_id, li.memory)
-
-            from llama_index.core.async_utils import asyncio_run
-
-            # add the inputs to the memory
-            asyncio_run(memory.aput_messages(inputs))
-            # Use the whole memory state as inputs to the llm
-            inputs = memory.get_all()
-        else:
-            # If memory is not defined, see if a conversation history was provided.
-            # This is the list of messages from the front end
-            conversation_history = kwargs.get("conversation_history", [])  # type: ignore
-            if not isinstance(conversation_history, list):
-                raise ValueError(
-                    "Unexpected error: conversation history is not a list."
-                )
-            history: list[ChatMessage] = conversation_history
-            inputs = [to_chat_message(msg) for msg in history] + inputs
-
-        # If the stream function is set, we'll stream the results
-        chat_result: ChatResponse
-        if stream_fn:
-            generator = model.stream_chat(
-                messages=inputs,
-                **(
-                    li.model.inference_params
-                    if li.model.inference_params
-                    else {}
-                ),
-            )
-            for chat_response in generator:
-                stream_fn(li, chat_response.delta)
-            # Get the final result for processing
-            chat_result = chat_response  # Use the last result from streaming
-        else:
-            chat_result = model.chat(
-                messages=inputs,
-                **(
-                    li.model.inference_params
-                    if li.model.inference_params
-                    else {}
-                ),
-            )
-        output_variable.value = from_chat_message(chat_result.message)
-        if li.memory:
-            memory.put(chat_result.message)
-    else:
-        model = to_llm(li.model, li.system_message)
-
-        if len(li.inputs) != 1:
-            raise InterpreterError(
-                "LLMInference step for completion must have exactly one input variable."
-            )
-
-        input = li.inputs[0].value
-        if not isinstance(input, str):
-            logger.warning(
-                f"Input to LLMInference step {li.id} is not a string, converting: {input}"
-            )
-            input = str(input)
-
-        complete_result: CompletionResponse
-        if stream_fn:
-            generator = model.stream_complete(prompt=input)
-            for complete_result in generator:
-                stream_fn(li, complete_result.delta)
-        else:
-            complete_result = model.complete(prompt=input)
-        output_variable.value = complete_result.text
-
-    return li.outputs  # type: ignore[return-value]

qtype/interpreter/steps/prompt_template.py

@@ -1,54 +0,0 @@
-import logging
-import string
-from typing import Any
-
-from qtype.interpreter.exceptions import InterpreterError
-from qtype.semantic.model import PromptTemplate, Variable
-
-logger = logging.getLogger(__name__)
-
-
-def get_format_arguments(format_string: str) -> set[str]:
-    formatter = string.Formatter()
-    arguments = []
-    for literal_text, field_name, format_spec, conversion in formatter.parse(
-        format_string
-    ):
-        if field_name:
-            arguments.append(field_name)
-    return set(arguments)
-
-
-def execute(step: PromptTemplate, **kwargs: dict[str, Any]) -> list[Variable]:
-    """Execute a prompt template step.
-
-    Args:
-        step: The prompt template step to execute.
-        **kwargs: Additional keyword arguments.
-    """
-
-    logger.debug(
-        f"Executing prompt template step: {step.id} with kwargs: {kwargs}"
-    )
-
-    format_args = get_format_arguments(step.template)
-    input_map = {
-        var.id: var.value
-        for var in step.inputs
-        if var.is_set() and var.id in format_args
-    }
-    missing = format_args - input_map.keys()
-    if missing:
-        raise InterpreterError(
-            f"The following fields are in the prompt template but not in the inputs: {missing}"
-        )
-    # Drop inputs that are not in format_args
-    result = step.template.format(**input_map)
-
-    if len(step.outputs) != 1:
-        raise InterpreterError(
-            f"PromptTemplate step {step.id} must have exactly one output variable."
-        )
-    step.outputs[0].value = result
-
-    return step.outputs  # type: ignore[return-value, no-any-return]

qtype/interpreter/steps/search.py

@@ -1,24 +0,0 @@
-import logging
-from typing import Any
-
-from qtype.semantic.model import Search, Variable
-
-logger = logging.getLogger(__name__)
-
-
-def execute(search: Search, **kwargs: dict[str, Any]) -> list[Variable]:
-    """Execute a search step.
-
-    Args:
-        search: The search step to execute.
-
-    Returns:
-        A list of variables that are set based on the search results.
-    """
-    logger.info("Executing Search on: %s", search.index.id)
-    # TODO: implement search execution logic
-    raise NotImplementedError(
-        "Search execution is not yet implemented. This will be handled in a future update."
-    )
-
-    return []  # Return an empty list for now

qtype/interpreter/steps/tool.py

@@ -1,53 +0,0 @@
-import importlib
-import logging
-
-from qtype.interpreter.exceptions import InterpreterError
-from qtype.semantic.model import PythonFunctionTool, Tool, Variable
-
-logger = logging.getLogger(__name__)
-
-
-def execute(tool: Tool, **kwargs: dict) -> list[Variable]:
-    """Execute a tool step.
-
-    Args:
-        tool: The tool step to execute.
-        **kwargs: Additional keyword arguments.
-    """
-    logger.debug(f"Executing tool step: {tool.id} with kwargs: {kwargs}")
-
-    if isinstance(tool, PythonFunctionTool):
-        # import the function dynamically
-        module = importlib.import_module(tool.module_path)
-        function = getattr(module, tool.function_name, None)
-        if function is None:
-            raise InterpreterError(
-                f"Function {tool.function_name} not found in {tool.module_path}"
-            )
-        # Call the function with the provided arguments
-        if any(not inputs.is_set() for inputs in tool.inputs):
-            raise InterpreterError(
-                f"Tool {tool.id} requires all inputs to be set. Missing inputs: {[var.id for var in tool.inputs if not var.is_set()]}"
-            )
-        inputs = {var.id: var.value for var in tool.inputs if var.is_set()}
-        results = function(**inputs)
-    else:
-        # TODO: support api tools
-        raise InterpreterError(f"Unsupported tool type: {type(tool).__name__}")
-
-    if isinstance(results, dict) and len(tool.outputs) > 1:
-        for var in tool.outputs:
-            if var.id in results:
-                var.value = results[var.id]
-            else:
-                raise InterpreterError(
-                    f"Output variable {var.id} not found in function results."
-                )
-    elif len(tool.outputs) == 1:
-        tool.outputs[0].value = results
-    else:
-        raise InterpreterError(
-            f"The returned value {results} could not be assigned to outputs {[var.id for var in tool.outputs]}."
-        )
-
-    return tool.outputs  # type: ignore[return-value]

qtype/interpreter/streaming_helpers.py

@@ -1,123 +0,0 @@
-"""
-Streaming helpers for bridging callback-based execution with generator patterns.
-
-This module provides utilities to convert callback-based streaming functions
-into generators that can be used with FastAPI's StreamingResponse.
-"""
-
-from __future__ import annotations
-
-import queue
-import threading
-from collections.abc import Callable, Generator
-from concurrent.futures import Future
-from typing import Any, TypeVar
-
-from qtype.dsl.domain_types import ChatMessage
-from qtype.semantic.model import Step
-
-T = TypeVar("T")
-
-
-def create_streaming_generator(
-    execution_func: Callable[..., T],
-    *args: Any,
-    timeout: float = 30.0,
-    join_timeout: float = 5.0,
-    **kwargs: Any,
-) -> tuple[Generator[tuple[Step, ChatMessage | str], None, None], Future[T]]:
-    """
-    Convert a callback-based streaming function into a generator with result future.
-
-    This function executes the provided function in a separate thread and
-    converts its stream_fn callback pattern into a generator that yields
-    (step, message) tuples. Additionally returns a Future that will contain
-    the execution function's return value.
-
-    Args:
-        execution_func: Function to execute that accepts a stream_fn parameter
-        *args: Positional arguments to pass to execution_func
-        timeout: Timeout in seconds for queue.get() operations
-        join_timeout: Timeout in seconds for thread.join()
-        **kwargs: Keyword arguments to pass to execution_func
-
-    Returns:
-        Tuple of (generator, future) where:
-        - generator yields (Step, ChatMessage | str) tuples from streaming callback
-        - future will contain the return value of execution_func
-
-    Example:
-        ```python
-        def my_flow_execution(flow: Flow, stream_fn: Callable | None = None):
-            # Some execution logic that calls stream_fn(step, message)
-            return {"status": "completed", "steps_executed": 3}
-
-        # Convert to generator with result
-        stream_gen, result_future = create_streaming_generator(
-            my_flow_execution,
-            flow_copy,
-            some_other_arg="value"
-        )
-
-        # Process streaming data
-        for step, message in stream_gen:
-            print(f"Step {step.id}: {message}")
-
-        # Get final result (blocks until execution completes)
-        final_result = result_future.result(timeout=10.0)
-        print(f"Execution result: {final_result}")
-        ```
-    """
-    # Create thread-safe queue for communication
-    stream_queue: queue.Queue[tuple[Step, ChatMessage | str] | None] = (
-        queue.Queue()
-    )
-
-    # Create future for the return value
-    result_future: Future[T] = Future()
-
-    def stream_callback(step: Step, msg: ChatMessage | str) -> None:
-        """Callback function that pushes data to the queue."""
-        stream_queue.put((step, msg))
-
-    def execution_task() -> None:
-        """Execute the function in a separate thread."""
-        try:
-            # Add the stream_fn callback to kwargs
-            kwargs_with_callback = kwargs.copy()
-            kwargs_with_callback["stream_fn"] = stream_callback
-
-            # Execute the function with the callback and capture result
-            result = execution_func(*args, **kwargs_with_callback)
-            result_future.set_result(result)
-        except Exception as e:
-            # Set exception on future if execution fails
-            result_future.set_exception(e)
-        finally:
-            # Signal end of stream
-            stream_queue.put(None)
-
-    # Start execution in separate thread
-    execution_thread = threading.Thread(target=execution_task)
-    execution_thread.start()
-
-    def generator() -> Generator[tuple[Step, ChatMessage | str], None, None]:
-        """Generator that yields streaming data from the queue."""
-        try:
-            # Yield data as it becomes available
-            while True:
-                try:
-                    # Wait for data with timeout to avoid hanging
-                    data = stream_queue.get(timeout=timeout)
-                    if data is None:
-                        # End of stream signal
-                        break
-                    yield data
-                except queue.Empty:
-                    # Handle timeout - break and let thread cleanup
-                    break
-        finally:
-            # Ensure thread cleanup
-            execution_thread.join(timeout=join_timeout)
-
-    return generator(), result_future