ai-pipeline-core 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

ai_pipeline_core/__init__.py

@@ -1,7 +1,23 @@
 """Pipeline Core - Shared infrastructure for AI pipelines."""
 
-from .documents import Document, DocumentList, FlowDocument, TaskDocument
-from .flow import FlowConfig
+from . import llm
+from .documents import (
+    Document,
+    DocumentList,
+    FlowDocument,
+    TaskDocument,
+    canonical_name_key,
+    sanitize_url,
+)
+from .flow import FlowConfig, FlowOptions
+from .llm import (
+    AIMessages,
+    AIMessageType,
+    ModelName,
+    ModelOptions,
+    ModelResponse,
+    StructuredModelResponse,
+)
 from .logging import (
     LoggerMixin,
     LoggingConfig,
@@ -9,28 +25,53 @@ from .logging import (
     get_pipeline_logger,
     setup_logging,
 )
-from .logging import (
-    get_pipeline_logger as get_logger,
-)
+from .logging import get_pipeline_logger as get_logger
+from .pipeline import pipeline_flow, pipeline_task
+from .prefect import flow, task
 from .prompt_manager import PromptManager
 from .settings import settings
-from .tracing import trace
+from .tracing import TraceInfo, TraceLevel, trace
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 
 __all__ = [
-    "Document",
-    "DocumentList",
-    "FlowConfig",
-    "FlowDocument",
+    # Config/Settings
+    "settings",
+    # Logging
     "get_logger",
     "get_pipeline_logger",
     "LoggerMixin",
     "LoggingConfig",
-    "PromptManager",
-    "settings",
     "setup_logging",
     "StructuredLoggerMixin",
+    # Documents
+    "Document",
+    "DocumentList",
+    "FlowDocument",
     "TaskDocument",
+    "canonical_name_key",
+    "sanitize_url",
+    # Flow/Task
+    "FlowConfig",
+    "FlowOptions",
+    # Prefect decorators (clean, no tracing)
+    "task",
+    "flow",
+    # Pipeline decorators (with tracing)
+    "pipeline_task",
+    "pipeline_flow",
+    # LLM
+    "llm",
+    "ModelName",
+    "ModelOptions",
+    "ModelResponse",
+    "StructuredModelResponse",
+    "AIMessages",
+    "AIMessageType",
+    # Tracing
     "trace",
+    "TraceLevel",
+    "TraceInfo",
+    # Utils
+    "PromptManager",
 ]

ai_pipeline_core/documents/__init__.py

@@ -2,10 +2,13 @@ from .document import Document
 from .document_list import DocumentList
 from .flow_document import FlowDocument
 from .task_document import TaskDocument
+from .utils import canonical_name_key, sanitize_url
 
 __all__ = [
     "Document",
     "DocumentList",
     "FlowDocument",
     "TaskDocument",
+    "canonical_name_key",
+    "sanitize_url",
 ]

ai_pipeline_core/flow/__init__.py

@@ -1,3 +1,7 @@
 from .config import FlowConfig
+from .options import FlowOptions
 
-__all__ = ["FlowConfig"]
+__all__ = [
+    "FlowConfig",
+    "FlowOptions",
+]

ai_pipeline_core/flow/options.py

@@ -0,0 +1,26 @@
+from typing import TypeVar
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from ai_pipeline_core.llm import ModelName
+
+T = TypeVar("T", bound="FlowOptions")
+
+
+class FlowOptions(BaseSettings):
+    """Base configuration for AI Pipeline flows."""
+
+    core_model: ModelName | str = Field(
+        default="gpt-5",
+        description="Primary model for complex analysis and generation tasks.",
+    )
+    small_model: ModelName | str = Field(
+        default="gpt-5-mini",
+        description="Fast, cost-effective model for simple tasks and orchestration.",
+    )
+
+    model_config = SettingsConfigDict(frozen=True, extra="ignore")
+
+
+__all__ = ["FlowOptions"]

ai_pipeline_core/llm/client.py

@@ -118,11 +118,13 @@ async def _generate_with_retry(
                 span.set_attributes(response.get_laminar_metadata())
                 Laminar.set_span_output(response.content)
                 if not response.content:
-                    # disable cache in case of empty response
-                    completion_kwargs["extra_body"]["cache"] = {"no-cache": True}
                     raise ValueError(f"Model {model} returned an empty response.")
                 return response
         except (asyncio.TimeoutError, ValueError, Exception) as e:
+            if not isinstance(e, asyncio.TimeoutError):
+                # disable cache if it's not a timeout because it may cause an error
+                completion_kwargs["extra_body"]["cache"] = {"no-cache": True}
+
             logger.warning(
                 "LLM generation failed (attempt %d/%d): %s",
                 attempt + 1,
@@ -167,7 +169,7 @@ T = TypeVar("T", bound=BaseModel)
 
 @trace(ignore_inputs=["context"])
 async def generate_structured(
-    model: ModelName,
+    model: ModelName | str,
     response_format: type[T],
     *,
     context: AIMessages = AIMessages(),

ai_pipeline_core/pipeline.py

@@ -0,0 +1,418 @@
+"""Pipeline decorators that combine Prefect functionality with tracing support.
+
+These decorators extend the base Prefect decorators with automatic tracing capabilities.
+"""
+
+import datetime
+import functools
+import inspect
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Iterable,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+from prefect.assets import Asset
+from prefect.cache_policies import CachePolicy
+from prefect.context import TaskRunContext
+from prefect.flows import Flow, FlowStateHook
+from prefect.futures import PrefectFuture
+from prefect.results import ResultSerializer, ResultStorage
+from prefect.task_runners import TaskRunner
+from prefect.tasks import (
+    RetryConditionCallable,
+    StateHookCallable,
+    Task,
+    TaskRunNameValueOrCallable,
+)
+from prefect.utilities.annotations import NotSet
+from typing_extensions import Concatenate, ParamSpec
+
+from ai_pipeline_core.documents import DocumentList
+from ai_pipeline_core.flow.options import FlowOptions
+from ai_pipeline_core.prefect import flow, task
+from ai_pipeline_core.tracing import TraceLevel, trace
+
+if TYPE_CHECKING:
+    pass
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+# ============================================================================
+# PIPELINE TASK DECORATOR
+# ============================================================================
+
+
+@overload
+def pipeline_task(__fn: Callable[P, R], /) -> Task[P, R]: ...
+
+
+@overload
+def pipeline_task(
+    *,
+    # Tracing parameters
+    trace_level: TraceLevel = "always",
+    trace_ignore_input: bool = False,
+    trace_ignore_output: bool = False,
+    trace_ignore_inputs: list[str] | None = None,
+    trace_input_formatter: Optional[Callable[..., str]] = None,
+    trace_output_formatter: Optional[Callable[..., str]] = None,
+    # Prefect parameters
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    tags: Optional[Iterable[str]] = None,
+    version: Optional[str] = None,
+    cache_policy: Union[CachePolicy, type[NotSet]] = NotSet,
+    cache_key_fn: Optional[Callable[[TaskRunContext, Dict[str, Any]], Optional[str]]] = None,
+    cache_expiration: Optional[datetime.timedelta] = None,
+    task_run_name: Optional[TaskRunNameValueOrCallable] = None,
+    retries: Optional[int] = None,
+    retry_delay_seconds: Optional[
+        Union[float, int, list[float], Callable[[int], list[float]]]
+    ] = None,
+    retry_jitter_factor: Optional[float] = None,
+    persist_result: Optional[bool] = None,
+    result_storage: Optional[Union[ResultStorage, str]] = None,
+    result_serializer: Optional[Union[ResultSerializer, str]] = None,
+    result_storage_key: Optional[str] = None,
+    cache_result_in_memory: bool = True,
+    timeout_seconds: Union[int, float, None] = None,
+    log_prints: Optional[bool] = False,
+    refresh_cache: Optional[bool] = None,
+    on_completion: Optional[list[StateHookCallable]] = None,
+    on_failure: Optional[list[StateHookCallable]] = None,
+    retry_condition_fn: Optional[RetryConditionCallable] = None,
+    viz_return_value: Optional[bool] = None,
+    asset_deps: Optional[list[Union[str, Asset]]] = None,
+) -> Callable[[Callable[P, R]], Task[P, R]]: ...
+
+
+def pipeline_task(
+    __fn: Optional[Callable[P, R]] = None,
+    /,
+    *,
+    # Tracing parameters
+    trace_level: TraceLevel = "always",
+    trace_ignore_input: bool = False,
+    trace_ignore_output: bool = False,
+    trace_ignore_inputs: list[str] | None = None,
+    trace_input_formatter: Optional[Callable[..., str]] = None,
+    trace_output_formatter: Optional[Callable[..., str]] = None,
+    # Prefect parameters
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    tags: Optional[Iterable[str]] = None,
+    version: Optional[str] = None,
+    cache_policy: Union[CachePolicy, type[NotSet]] = NotSet,
+    cache_key_fn: Optional[Callable[[TaskRunContext, Dict[str, Any]], Optional[str]]] = None,
+    cache_expiration: Optional[datetime.timedelta] = None,
+    task_run_name: Optional[TaskRunNameValueOrCallable] = None,
+    retries: Optional[int] = None,
+    retry_delay_seconds: Optional[
+        Union[float, int, list[float], Callable[[int], list[float]]]
+    ] = None,
+    retry_jitter_factor: Optional[float] = None,
+    persist_result: Optional[bool] = None,
+    result_storage: Optional[Union[ResultStorage, str]] = None,
+    result_serializer: Optional[Union[ResultSerializer, str]] = None,
+    result_storage_key: Optional[str] = None,
+    cache_result_in_memory: bool = True,
+    timeout_seconds: Union[int, float, None] = None,
+    log_prints: Optional[bool] = False,
+    refresh_cache: Optional[bool] = None,
+    on_completion: Optional[list[StateHookCallable]] = None,
+    on_failure: Optional[list[StateHookCallable]] = None,
+    retry_condition_fn: Optional[RetryConditionCallable] = None,
+    viz_return_value: Optional[bool] = None,
+    asset_deps: Optional[list[Union[str, Asset]]] = None,
+) -> Union[Task[P, R], Callable[[Callable[P, R]], Task[P, R]]]:
+    """
+    Pipeline task decorator that combines Prefect task functionality with automatic tracing.
+
+    This decorator applies tracing before the Prefect task decorator, allowing you to
+    monitor task execution with LMNR while maintaining all Prefect functionality.
+
+    Args:
+        trace_level: Control tracing ("always", "debug", "off")
+        trace_ignore_input: Whether to ignore input in traces
+        trace_ignore_output: Whether to ignore output in traces
+        trace_ignore_inputs: List of input parameter names to ignore
+        trace_input_formatter: Custom formatter for inputs
+        trace_output_formatter: Custom formatter for outputs
+
+        Plus all standard Prefect task parameters...
+    """
+
+    def decorator(fn: Callable[P, R]) -> Task[P, R]:
+        # Apply tracing first if enabled
+        if trace_level != "off":
+            traced_fn = trace(
+                level=trace_level,
+                name=name or fn.__name__,
+                ignore_input=trace_ignore_input,
+                ignore_output=trace_ignore_output,
+                ignore_inputs=trace_ignore_inputs,
+                input_formatter=trace_input_formatter,
+                output_formatter=trace_output_formatter,
+            )(fn)
+        else:
+            traced_fn = fn
+
+        # Then apply Prefect task decorator
+        return task(  # pyright: ignore[reportCallIssue,reportUnknownVariableType]
+            traced_fn,  # pyright: ignore[reportArgumentType]
+            name=name,
+            description=description,
+            tags=tags,
+            version=version,
+            cache_policy=cache_policy,
+            cache_key_fn=cache_key_fn,
+            cache_expiration=cache_expiration,
+            task_run_name=task_run_name,
+            retries=retries or 0,
+            retry_delay_seconds=retry_delay_seconds,
+            retry_jitter_factor=retry_jitter_factor,
+            persist_result=persist_result,
+            result_storage=result_storage,
+            result_serializer=result_serializer,
+            result_storage_key=result_storage_key,
+            cache_result_in_memory=cache_result_in_memory,
+            timeout_seconds=timeout_seconds,
+            log_prints=log_prints,
+            refresh_cache=refresh_cache,
+            on_completion=on_completion,
+            on_failure=on_failure,
+            retry_condition_fn=retry_condition_fn,
+            viz_return_value=viz_return_value,
+            asset_deps=asset_deps,
+        )
+
+    if __fn:
+        return decorator(__fn)
+    return decorator
+
+
+# ============================================================================
+# PIPELINE FLOW DECORATOR WITH DOCUMENT PROCESSING
+# ============================================================================
+
+# Type aliases for document flow signatures
+DocumentsFlowSig = Callable[
+    Concatenate[str, DocumentList, FlowOptions, P],
+    Union[DocumentList, Coroutine[Any, Any, DocumentList]],
+]
+
+DocumentsFlowResult = Flow[Concatenate[str, DocumentList, FlowOptions, P], DocumentList]
+
+
+@overload
+def pipeline_flow(
+    __fn: DocumentsFlowSig[P],
+    /,
+) -> DocumentsFlowResult[P]: ...
+
+
+@overload
+def pipeline_flow(
+    *,
+    # Tracing parameters
+    trace_level: TraceLevel = "always",
+    trace_ignore_input: bool = False,
+    trace_ignore_output: bool = False,
+    trace_ignore_inputs: list[str] | None = None,
+    trace_input_formatter: Optional[Callable[..., str]] = None,
+    trace_output_formatter: Optional[Callable[..., str]] = None,
+    # Prefect parameters
+    name: Optional[str] = None,
+    version: Optional[str] = None,
+    flow_run_name: Optional[Union[Callable[[], str], str]] = None,
+    retries: Optional[int] = None,
+    retry_delay_seconds: Optional[Union[int, float]] = None,
+    task_runner: Optional[TaskRunner[PrefectFuture[Any]]] = None,
+    description: Optional[str] = None,
+    timeout_seconds: Union[int, float, None] = None,
+    validate_parameters: bool = True,
+    persist_result: Optional[bool] = None,
+    result_storage: Optional[Union[ResultStorage, str]] = None,
+    result_serializer: Optional[Union[ResultSerializer, str]] = None,
+    cache_result_in_memory: bool = True,
+    log_prints: Optional[bool] = None,
+    on_completion: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_failure: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_cancellation: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_crashed: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_running: Optional[list["FlowStateHook[..., Any]"]] = None,
+) -> Callable[[DocumentsFlowSig[P]], DocumentsFlowResult[P]]: ...
+
+
+def pipeline_flow(
+    __fn: Optional[DocumentsFlowSig[P]] = None,
+    /,
+    *,
+    # Tracing parameters
+    trace_level: TraceLevel = "always",
+    trace_ignore_input: bool = False,
+    trace_ignore_output: bool = False,
+    trace_ignore_inputs: list[str] | None = None,
+    trace_input_formatter: Optional[Callable[..., str]] = None,
+    trace_output_formatter: Optional[Callable[..., str]] = None,
+    # Prefect parameters
+    name: Optional[str] = None,
+    version: Optional[str] = None,
+    flow_run_name: Optional[Union[Callable[[], str], str]] = None,
+    retries: Optional[int] = None,
+    retry_delay_seconds: Optional[Union[int, float]] = None,
+    task_runner: Optional[TaskRunner[PrefectFuture[Any]]] = None,
+    description: Optional[str] = None,
+    timeout_seconds: Union[int, float, None] = None,
+    validate_parameters: bool = True,
+    persist_result: Optional[bool] = None,
+    result_storage: Optional[Union[ResultStorage, str]] = None,
+    result_serializer: Optional[Union[ResultSerializer, str]] = None,
+    cache_result_in_memory: bool = True,
+    log_prints: Optional[bool] = None,
+    on_completion: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_failure: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_cancellation: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_crashed: Optional[list["FlowStateHook[..., Any]"]] = None,
+    on_running: Optional[list["FlowStateHook[..., Any]"]] = None,
+) -> Union[DocumentsFlowResult[P], Callable[[DocumentsFlowSig[P]], DocumentsFlowResult[P]]]:
+    """
+    Pipeline flow for document processing with standardized signature.
+
+    This decorator enforces a specific signature for document processing flows:
+    - First parameter: project_name (str)
+    - Second parameter: documents (DocumentList)
+    - Third parameter: flow_options (FlowOptions or subclass)
+    - Additional parameters allowed
+    - Must return DocumentList
+
+    It includes automatic tracing and all Prefect flow functionality.
+
+    Args:
+        trace_level: Control tracing ("always", "debug", "off")
+        trace_ignore_input: Whether to ignore input in traces
+        trace_ignore_output: Whether to ignore output in traces
+        trace_ignore_inputs: List of input parameter names to ignore
+        trace_input_formatter: Custom formatter for inputs
+        trace_output_formatter: Custom formatter for outputs
+
+        Plus all standard Prefect flow parameters...
+    """
+
+    def decorator(func: DocumentsFlowSig[P]) -> DocumentsFlowResult[P]:
+        sig = inspect.signature(func)
+        params = list(sig.parameters.values())
+
+        if len(params) < 3:
+            raise TypeError(
+                f"@pipeline_flow '{func.__name__}' must accept at least 3 arguments: "
+                "(project_name, documents, flow_options)"
+            )
+
+        # Validate parameter types (optional but recommended)
+        # We check names as a convention, not strict type checking at decoration time
+        expected_names = ["project_name", "documents", "flow_options"]
+        for i, expected in enumerate(expected_names):
+            if i < len(params) and params[i].name != expected:
+                print(
+                    f"Warning: Parameter {i + 1} of '{func.__name__}' is named '{params[i].name}' "
+                    f"but convention suggests '{expected}'"
+                )
+
+        # Create wrapper that ensures return type
+        if inspect.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def wrapper(  # pyright: ignore[reportRedeclaration]
+                project_name: str,
+                documents: DocumentList,
+                flow_options: FlowOptions,
+                *args,  # pyright: ignore[reportMissingParameterType]
+                **kwargs,  # pyright: ignore[reportMissingParameterType]
+            ) -> DocumentList:
+                result = await func(project_name, documents, flow_options, *args, **kwargs)
+                # Runtime type checking
+                DL = DocumentList  # Avoid recomputation
+                if not isinstance(result, DL):
+                    raise TypeError(
+                        f"Flow '{func.__name__}' must return a DocumentList, "
+                        f"but returned {type(result).__name__}"
+                    )
+                return result
+        else:
+
+            @functools.wraps(func)
+            def wrapper(  # pyright: ignore[reportRedeclaration]
+                project_name: str,
+                documents: DocumentList,
+                flow_options: FlowOptions,
+                *args,  # pyright: ignore[reportMissingParameterType]
+                **kwargs,  # pyright: ignore[reportMissingParameterType]
+            ) -> DocumentList:
+                result = func(project_name, documents, flow_options, *args, **kwargs)
+                # Runtime type checking
+                DL = DocumentList  # Avoid recomputation
+                if not isinstance(result, DL):
+                    raise TypeError(
+                        f"Flow '{func.__name__}' must return a DocumentList, "
+                        f"but returned {type(result).__name__}"
+                    )
+                return result
+
+        # Apply tracing first if enabled
+        if trace_level != "off":
+            traced_wrapper = trace(
+                level=trace_level,
+                name=name or func.__name__,
+                ignore_input=trace_ignore_input,
+                ignore_output=trace_ignore_output,
+                ignore_inputs=trace_ignore_inputs,
+                input_formatter=trace_input_formatter,
+                output_formatter=trace_output_formatter,
+            )(wrapper)
+        else:
+            traced_wrapper = wrapper
+
+        # Then apply Prefect flow decorator
+        return cast(
+            DocumentsFlowResult[P],
+            flow(  # pyright: ignore[reportCallIssue,reportUnknownVariableType]
+                traced_wrapper,  # pyright: ignore[reportArgumentType]
+                name=name,
+                version=version,
+                flow_run_name=flow_run_name,
+                retries=retries,
+                retry_delay_seconds=retry_delay_seconds,
+                task_runner=task_runner,
+                description=description,
+                timeout_seconds=timeout_seconds,
+                validate_parameters=validate_parameters,
+                persist_result=persist_result,
+                result_storage=result_storage,
+                result_serializer=result_serializer,
+                cache_result_in_memory=cache_result_in_memory,
+                log_prints=log_prints,
+                on_completion=on_completion,
+                on_failure=on_failure,
+                on_cancellation=on_cancellation,
+                on_crashed=on_crashed,
+                on_running=on_running,
+            ),
+        )
+
+    if __fn:
+        return decorator(__fn)
+    return decorator
+
+
+__all__ = ["pipeline_task", "pipeline_flow"]

ai_pipeline_core/prefect.py

@@ -0,0 +1,7 @@
+"""Prefect core features."""
+
+from prefect import flow, task
+from prefect.logging import disable_run_logger
+from prefect.testing.utilities import prefect_test_harness
+
+__all__ = ["task", "flow", "disable_run_logger", "prefect_test_harness"]

ai_pipeline_core/simple_runner/__init__.py

@@ -0,0 +1,19 @@
+from .cli import run_cli
+from .simple_runner import (
+    ConfigSequence,
+    FlowSequence,
+    load_documents_from_directory,
+    run_pipeline,
+    run_pipelines,
+    save_documents_to_directory,
+)
+
+__all__ = [
+    "run_cli",
+    "run_pipeline",
+    "run_pipelines",
+    "load_documents_from_directory",
+    "save_documents_to_directory",
+    "FlowSequence",
+    "ConfigSequence",
+]

ai_pipeline_core/simple_runner/cli.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Callable, Type, TypeVar, cast
+
+from lmnr import Laminar
+from pydantic_settings import CliPositionalArg, SettingsConfigDict
+
+from ai_pipeline_core.documents import DocumentList
+from ai_pipeline_core.flow.options import FlowOptions
+from ai_pipeline_core.logging import get_pipeline_logger, setup_logging
+
+from .simple_runner import ConfigSequence, FlowSequence, run_pipelines, save_documents_to_directory
+
+logger = get_pipeline_logger(__name__)
+
+TOptions = TypeVar("TOptions", bound=FlowOptions)
+InitializerFunc = Callable[[FlowOptions], tuple[str, DocumentList]] | None
+
+
+def _initialize_environment() -> None:
+    setup_logging()
+    try:
+        Laminar.initialize()
+        logger.info("LMNR tracing initialized.")
+    except Exception as e:
+        logger.warning(f"Failed to initialize LMNR tracing: {e}")
+
+
+def run_cli(
+    *,
+    flows: FlowSequence,
+    flow_configs: ConfigSequence,
+    options_cls: Type[TOptions],
+    initializer: InitializerFunc = None,
+) -> None:
+    """
+    Parse CLI+env into options, then run the pipeline.
+
+    - working_directory: required positional arg
+    - --project-name: optional, defaults to directory name
+    - --start/--end: optional, 1-based step bounds
+    - all other flags come from options_cls (fields & Field descriptions)
+    """
+    _initialize_environment()
+
+    class _RunnerOptions(  # type: ignore[reportRedeclaration]
+        options_cls,
+        cli_parse_args=True,
+        cli_kebab_case=True,
+        cli_exit_on_error=False,
+    ):
+        working_directory: CliPositionalArg[Path]
+        project_name: str | None = None
+        start: int = 1
+        end: int | None = None
+
+        model_config = SettingsConfigDict(frozen=True, extra="ignore")
+
+    opts = cast(FlowOptions, _RunnerOptions())  # type: ignore[reportCallIssue]
+
+    wd: Path = cast(Path, getattr(opts, "working_directory"))
+    wd.mkdir(parents=True, exist_ok=True)
+
+    # Get project name from options or use directory basename
+    project_name = getattr(opts, "project_name", None)
+    if not project_name:  # None or empty string
+        project_name = wd.name
+
+    # Ensure project_name is not empty
+    if not project_name:
+        raise ValueError("Project name cannot be empty")
+
+    # Use initializer if provided, otherwise use defaults
+    initial_documents = DocumentList([])
+    if initializer:
+        init_result = initializer(opts)
+        # Always expect tuple format from initializer
+        _, initial_documents = init_result  # Ignore project name from initializer
+
+        if getattr(opts, "start", 1) == 1 and initial_documents:
+            save_documents_to_directory(wd, initial_documents)
+
+    asyncio.run(
+        run_pipelines(
+            project_name=project_name,
+            output_dir=wd,
+            flows=flows,
+            flow_configs=flow_configs,
+            flow_options=opts,
+            start_step=getattr(opts, "start", 1),
+            end_step=getattr(opts, "end", None),
+        )
+    )

ai_pipeline_core/simple_runner/simple_runner.py

@@ -0,0 +1,147 @@
+from pathlib import Path
+from typing import Any, Callable, Sequence, Type
+
+from ai_pipeline_core.documents import Document, DocumentList, FlowDocument
+from ai_pipeline_core.flow.config import FlowConfig
+from ai_pipeline_core.flow.options import FlowOptions
+from ai_pipeline_core.logging import get_pipeline_logger
+
+logger = get_pipeline_logger(__name__)
+
+FlowSequence = Sequence[Callable[..., Any]]
+ConfigSequence = Sequence[Type[FlowConfig]]
+
+
+def load_documents_from_directory(
+    base_dir: Path, document_types: Sequence[Type[FlowDocument]]
+) -> DocumentList:
+    """Loads documents using canonical_name."""
+    documents = DocumentList()
+
+    for doc_class in document_types:
+        dir_name = doc_class.canonical_name()
+        type_dir = base_dir / dir_name
+
+        if not type_dir.exists() or not type_dir.is_dir():
+            continue
+
+        logger.info(f"Loading documents from {type_dir.relative_to(base_dir)}")
+
+        for file_path in type_dir.iterdir():
+            if not file_path.is_file() or file_path.name.endswith(Document.DESCRIPTION_EXTENSION):
+                continue
+
+            try:
+                content = file_path.read_bytes()
+                doc = doc_class(name=file_path.name, content=content)
+
+                desc_file = file_path.with_name(file_path.name + Document.DESCRIPTION_EXTENSION)
+                if desc_file.exists():
+                    object.__setattr__(doc, "description", desc_file.read_text(encoding="utf-8"))
+
+                documents.append(doc)
+            except Exception as e:
+                logger.error(
+                    f"  Failed to load {file_path.name} as {doc_class.__name__}: {e}", exc_info=True
+                )
+
+    return documents
+
+
+def save_documents_to_directory(base_dir: Path, documents: DocumentList) -> None:
+    """Saves documents using canonical_name."""
+    for document in documents:
+        if not isinstance(document, FlowDocument):
+            continue
+
+        dir_name = document.canonical_name()
+        document_dir = base_dir / dir_name
+        document_dir.mkdir(parents=True, exist_ok=True)
+
+        file_path = document_dir / document.name
+        file_path.write_bytes(document.content)
+        logger.info(f"Saved: {dir_name}/{document.name}")
+
+        if document.description:
+            desc_file = file_path.with_name(file_path.name + Document.DESCRIPTION_EXTENSION)
+            desc_file.write_text(document.description, encoding="utf-8")
+
+
+async def run_pipeline(
+    flow_func: Callable[..., Any],
+    config: Type[FlowConfig],
+    project_name: str,
+    output_dir: Path,
+    flow_options: FlowOptions,
+    flow_name: str | None = None,
+) -> DocumentList:
+    """Execute a single pipeline flow."""
+    if flow_name is None:
+        flow_name = getattr(flow_func, "name", getattr(flow_func, "__name__", "flow"))
+
+    logger.info(f"Running Flow: {flow_name}")
+
+    input_documents = load_documents_from_directory(output_dir, config.INPUT_DOCUMENT_TYPES)
+
+    if not config.has_input_documents(input_documents):
+        raise RuntimeError(f"Missing input documents for flow {flow_name}")
+
+    result_documents = await flow_func(project_name, input_documents, flow_options)
+
+    config.validate_output_documents(result_documents)
+
+    save_documents_to_directory(output_dir, result_documents)
+
+    logger.info(f"Completed Flow: {flow_name}")
+
+    return result_documents
+
+
+async def run_pipelines(
+    project_name: str,
+    output_dir: Path,
+    flows: FlowSequence,
+    flow_configs: ConfigSequence,
+    flow_options: FlowOptions,
+    start_step: int = 1,
+    end_step: int | None = None,
+) -> None:
+    """Executes multiple pipeline flows sequentially."""
+    if len(flows) != len(flow_configs):
+        raise ValueError("The number of flows and flow configs must match.")
+
+    num_steps = len(flows)
+    start_index = start_step - 1
+    end_index = (end_step if end_step is not None else num_steps) - 1
+
+    if (
+        not (0 <= start_index < num_steps)
+        or not (0 <= end_index < num_steps)
+        or start_index > end_index
+    ):
+        raise ValueError("Invalid start/end steps.")
+
+    logger.info(f"Starting pipeline '{project_name}' (Steps {start_step} to {end_index + 1})")
+
+    for i in range(start_index, end_index + 1):
+        flow_func = flows[i]
+        config = flow_configs[i]
+        flow_name = getattr(flow_func, "name", getattr(flow_func, "__name__", f"flow_{i + 1}"))
+
+        logger.info(f"--- [Step {i + 1}/{num_steps}] Running Flow: {flow_name} ---")
+
+        try:
+            await run_pipeline(
+                flow_func=flow_func,
+                config=config,
+                project_name=project_name,
+                output_dir=output_dir,
+                flow_options=flow_options,
+                flow_name=f"[Step {i + 1}/{num_steps}] {flow_name}",
+            )
+
+        except Exception as e:
+            logger.error(
+                f"--- [Step {i + 1}/{num_steps}] Flow {flow_name} Failed: {e} ---", exc_info=True
+            )
+            raise

ai_pipeline_core/tracing.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 import inspect
 import os
 from functools import wraps
-from typing import Any, Callable, ParamSpec, TypeVar, cast, overload
+from typing import Any, Callable, Literal, ParamSpec, TypeVar, cast, overload
 
 from lmnr import Instruments, Laminar, observe
 from pydantic import BaseModel
@@ -24,6 +24,8 @@ from ai_pipeline_core.settings import settings
 P = ParamSpec("P")
 R = TypeVar("R")
 
+TraceLevel = Literal["always", "debug", "off"]
+
 
 # ---------------------------------------------------------------------------
 # ``TraceInfo`` – metadata container
@@ -67,22 +69,28 @@ def _initialise_laminar() -> None:
     if settings.lmnr_project_api_key:
         Laminar.initialize(
             project_api_key=settings.lmnr_project_api_key,
-            disabled_instruments=[Instruments.OPENAI],
+            disabled_instruments=[Instruments.OPENAI] if Instruments.OPENAI else [],
         )
 
 
-# Overload for calls like @trace(name="...", test=True)
+# Overload for calls like @trace(name="...", level="debug")
 @overload
 def trace(
     *,
+    level: TraceLevel = "always",
     name: str | None = None,
-    test: bool = False,
-    debug_only: bool = False,
+    session_id: str | None = None,
+    user_id: str | None = None,
+    metadata: dict[str, Any] | None = None,
+    tags: list[str] | None = None,
+    span_type: str | None = None,
     ignore_input: bool = False,
     ignore_output: bool = False,
     ignore_inputs: list[str] | None = None,
     input_formatter: Callable[..., str] | None = None,
     output_formatter: Callable[..., str] | None = None,
+    ignore_exceptions: bool = False,
+    preserve_global_context: bool = True,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
 
 
@@ -95,56 +103,76 @@ def trace(func: Callable[P, R]) -> Callable[P, R]: ...
 def trace(
     func: Callable[P, R] | None = None,
     *,
+    level: TraceLevel = "always",
     name: str | None = None,
-    test: bool = False,
-    debug_only: bool = False,
+    session_id: str | None = None,
+    user_id: str | None = None,
+    metadata: dict[str, Any] | None = None,
+    tags: list[str] | None = None,
+    span_type: str | None = None,
     ignore_input: bool = False,
     ignore_output: bool = False,
     ignore_inputs: list[str] | None = None,
     input_formatter: Callable[..., str] | None = None,
     output_formatter: Callable[..., str] | None = None,
+    ignore_exceptions: bool = False,
     preserve_global_context: bool = True,
 ) -> Callable[[Callable[P, R]], Callable[P, R]] | Callable[P, R]:
     """Decorator that wires Laminar tracing and observation into a function.
 
     Args:
         func: The function to be traced (when used as @trace)
+        level: Trace level control:
+            - "always": Always trace (default)
+            - "debug": Only trace when LMNR_DEBUG environment variable is NOT set to "true"
+            - "off": Never trace
         name: Custom name for the observation (defaults to function name)
-        test: Mark this trace as a test run
-        debug_only: Only trace when LMNR_DEBUG=true environment variable is set
+        metadata: Additional metadata for the trace
+        tags: Additional tags for the trace
+        span_type: Type of span for the trace
         ignore_input: Ignore all inputs in the trace
         ignore_output: Ignore the output in the trace
         ignore_inputs: List of specific input parameter names to ignore
         input_formatter: Custom formatter for inputs (takes any arguments, returns string)
         output_formatter: Custom formatter for outputs (takes any arguments, returns string)
+        ignore_exceptions: Whether to ignore exceptions in tracing
+        preserve_global_context: Whether to preserve global context
 
     Returns:
         The decorated function with Laminar tracing enabled
     """
 
+    if level == "off":
+        if func:
+            return func
+        return lambda f: f
+
     def decorator(f: Callable[P, R]) -> Callable[P, R]:
+        # Handle 'debug' level logic - only trace when LMNR_DEBUG is NOT "true"
+        if level == "debug" and os.getenv("LMNR_DEBUG", "").lower() == "true":
+            return f
+
         # --- Pre-computation (done once when the function is decorated) ---
         _initialise_laminar()
         sig = inspect.signature(f)
         is_coroutine = inspect.iscoroutinefunction(f)
-        decorator_test_flag = test
         observe_name = name or f.__name__
         _observe = observe
 
         # Store the new parameters
+        _session_id = session_id
+        _user_id = user_id
+        _metadata = metadata
+        _tags = tags or []
+        _span_type = span_type
         _ignore_input = ignore_input
         _ignore_output = ignore_output
         _ignore_inputs = ignore_inputs
         _input_formatter = input_formatter
         _output_formatter = output_formatter
+        _ignore_exceptions = ignore_exceptions
         _preserve_global_context = preserve_global_context
 
-        # --- Check debug_only flag and environment variable ---
-        if debug_only and os.getenv("LMNR_DEBUG", "").lower() != "true":
-            # If debug_only is True but LMNR_DEBUG is not set to "true",
-            # return the original function without tracing
-            return f
-
         # --- Helper function for runtime logic ---
         def _prepare_and_get_observe_params(runtime_kwargs: dict[str, Any]) -> dict[str, Any]:
             """
@@ -157,13 +185,23 @@ def trace(
                 if "trace_info" in sig.parameters:
                     runtime_kwargs["trace_info"] = trace_info
 
-            runtime_test_flag = bool(runtime_kwargs.get("test", False))
-            if (decorator_test_flag or runtime_test_flag) and "test" not in trace_info.tags:
-                trace_info.tags.append("test")
-
             observe_params = trace_info.get_observe_kwargs()
             observe_params["name"] = observe_name
 
+            # Override with decorator-level session_id and user_id if provided
+            if _session_id:
+                observe_params["session_id"] = _session_id
+            if _user_id:
+                observe_params["user_id"] = _user_id
+
+            # Merge decorator-level metadata and tags
+            if _metadata:
+                observe_params["metadata"] = {**observe_params.get("metadata", {}), **_metadata}
+            if _tags:
+                observe_params["tags"] = observe_params.get("tags", []) + _tags
+            if _span_type:
+                observe_params["span_type"] = _span_type
+
             # Add the new Laminar parameters
             if _ignore_input:
                 observe_params["ignore_input"] = _ignore_input
@@ -175,6 +213,8 @@ def trace(
                 observe_params["input_formatter"] = _input_formatter
             if _output_formatter is not None:
                 observe_params["output_formatter"] = _output_formatter
+            if _ignore_exceptions:
+                observe_params["ignore_exceptions"] = _ignore_exceptions
             if _preserve_global_context:
                 observe_params["preserve_global_context"] = _preserve_global_context
 
@@ -207,3 +247,6 @@ def trace(
         return decorator(func)  # Called as @trace
     else:
         return decorator  # Called as @trace(...)
+
+
+__all__ = ["trace", "TraceLevel", "TraceInfo"]

{ai_pipeline_core-0.1.6.dist-info → ai_pipeline_core-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-pipeline-core
-Version: 0.1.6
+Version: 0.1.7
 Summary: Core utilities for AI-powered processing pipelines using prefect
 Project-URL: Homepage, https://github.com/bbarwik/ai-pipeline-core
 Project-URL: Repository, https://github.com/bbarwik/ai-pipeline-core
@@ -20,7 +20,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: jinja2>=3.1.6
-Requires-Dist: lmnr>=0.7.5
+Requires-Dist: lmnr>=0.7.6
 Requires-Dist: openai>=1.99.9
 Requires-Dist: prefect>=3.4.13
 Requires-Dist: pydantic-settings>=2.10.1
@@ -151,40 +151,76 @@ async def process_document(doc: Document):
     return response.parsed
 ```
 
-### Prefect Flow Integration
+### Enhanced Pipeline Decorators (New in v0.1.7)
 ```python
-from prefect import flow, task
-from ai_pipeline_core.documents import Document, DocumentList, FlowDocument
-from ai_pipeline_core.flow import FlowConfig
-from ai_pipeline_core.tracing import trace
+from ai_pipeline_core import pipeline_flow, pipeline_task
+from ai_pipeline_core.flow import FlowOptions
+from ai_pipeline_core.documents import DocumentList, FlowDocument
 
-class OutputDocument(FlowDocument):
-    """Custom output document type"""
-    def get_type(self) -> str:
-        return "output"
+class CustomFlowOptions(FlowOptions):
+    """Extend base options with your custom fields"""
+    batch_size: int = 100
+    temperature: float = 0.7
 
-class MyFlowConfig(FlowConfig):
-    INPUT_DOCUMENT_TYPES = [InputDocument]
-    OUTPUT_DOCUMENT_TYPE = OutputDocument
-
-@task
-@trace
+@pipeline_task(trace_level="always", retries=3)
 async def process_task(doc: Document) -> Document:
-    # Task-level processing with automatic tracing
+    # Task with automatic tracing and retries
     result = await process_document(doc)
-    # Convert result to JSON string for document content
-    import json
-    return OutputDocument(name="result", content=json.dumps(result.model_dump()).encode())
+    return OutputDocument(name="result", content=result.encode())
+
+@pipeline_flow(trace_level="always")
+async def my_pipeline(
+    project_name: str,
+    documents: DocumentList,
+    flow_options: CustomFlowOptions  # Type-safe custom options
+) -> DocumentList:
+    # Pipeline flow with enforced signature and tracing
+    results = []
+    for doc in documents:
+        result = await process_task(doc)
+        results.append(result)
+    return DocumentList(results)
+```
 
-@flow
-async def my_pipeline(documents: DocumentList):
-    config = MyFlowConfig()
-    input_docs = config.get_input_documents(documents)
+### Simple Runner Utility (New in v0.1.7)
+```python
+from ai_pipeline_core.simple_runner import run_cli, run_pipeline
+from ai_pipeline_core.flow import FlowOptions
+
+# CLI-based pipeline execution
+if __name__ == "__main__":
+    run_cli(
+        flows=[my_pipeline],
+        flow_configs=[MyFlowConfig],
+        options_cls=CustomFlowOptions
+    )
 
-    results = await process_task.map(input_docs)
+# Or programmatic execution
+async def main():
+    result = await run_pipeline(
+        project_name="my-project",
+        output_dir=Path("./output"),
+        flow=my_pipeline,
+        flow_config=MyFlowConfig,
+        flow_options=CustomFlowOptions(batch_size=50)
+    )
+```
 
-    config.validate_output_documents(results)
-    return results
+### Clean Prefect Decorators (New in v0.1.7)
+```python
+# Import clean Prefect decorators without tracing
+from ai_pipeline_core.prefect import flow, task
+
+# Or use pipeline decorators with tracing
+from ai_pipeline_core import pipeline_flow, pipeline_task
+
+@task  # Clean Prefect task
+def compute(x: int) -> int:
+    return x * 2
+
+@pipeline_task(trace_level="always")  # With tracing
+def compute_traced(x: int) -> int:
+    return x * 2
 ```
 
 ## Core Modules
@@ -291,8 +327,14 @@ ai_pipeline_core/
 │   ├── client.py      # Async client implementation
 │   └── model_options.py # Configuration models
 ├── flow/              # Prefect flow utilities
-│   └── config.py      # Type-safe flow configuration
+│   ├── config.py      # Type-safe flow configuration
+│   └── options.py     # FlowOptions base class (v0.1.7)
+├── simple_runner/     # Pipeline execution utilities (v0.1.7)
+│   ├── cli.py         # CLI interface
+│   └── simple_runner.py # Core runner logic
 ├── logging/           # Structured logging
+├── pipeline.py        # Enhanced decorators (v0.1.7)
+├── prefect.py         # Clean Prefect exports (v0.1.7)
 ├── tracing.py         # Observability decorators
 └── settings.py        # Centralized configuration
 ```
@@ -469,9 +511,29 @@ Built with:
 - [LiteLLM](https://litellm.ai/) - LLM proxy
 - [Pydantic](https://pydantic-docs.helpmanual.io/) - Data validation
 
+## What's New in v0.1.7
+
+### Major Additions
+- **Enhanced Pipeline Decorators**: New `pipeline_flow` and `pipeline_task` decorators combining Prefect functionality with automatic LMNR tracing
+- **FlowOptions Base Class**: Extensible configuration system for flows with type-safe inheritance
+- **Simple Runner Module**: CLI and programmatic utilities for easy pipeline execution
+- **Clean Prefect Exports**: Separate imports for Prefect decorators with and without tracing
+- **Expanded Exports**: All major components now accessible from top-level package import
+
+### API Improvements
+- Better type inference for document flows with custom options
+- Support for custom FlowOptions inheritance in pipeline flows
+- Improved error messages for invalid flow signatures
+- Enhanced document utility functions (`canonical_name_key`, `sanitize_url`)
+
+### Developer Experience
+- Simplified imports - most components available from `ai_pipeline_core` directly
+- Better separation of concerns between clean Prefect and traced pipeline decorators
+- More intuitive flow configuration with `FlowOptions` inheritance
+
 ## Stability Notice
 
-**Current Version**: 0.1.6
+**Current Version**: 0.1.7
 **Status**: Internal Preview
 **API Stability**: Unstable - Breaking changes expected
 **Recommended Use**: Learning and reference only

{ai_pipeline_core-0.1.6.dist-info → ai_pipeline_core-0.1.7.dist-info}/RECORD

@@ -1,21 +1,24 @@
-ai_pipeline_core/__init__.py,sha256=2zVmBkQNdYcy2mQmw8qO1et3a5pv6KMTXfxrcTfA7EM,779
+ai_pipeline_core/__init__.py,sha256=INcTtHr2TFY8bR0eCg7RwvIRYY6px8knCgjyIvSSKP4,1602
 ai_pipeline_core/exceptions.py,sha256=_vW0Hbw2LGb5tcVvH0YzTKMff7QOPfCRr3w-w_zPyCE,968
+ai_pipeline_core/pipeline.py,sha256=GOrPC53j756Xhpg_CShnkAKxSdkC16XHEoPeIhkjLIA,16569
+ai_pipeline_core/prefect.py,sha256=VHYkkRcUmSpdwyWosOOxuExVCncIQgT6MypqGdjcYnM,241
 ai_pipeline_core/prompt_manager.py,sha256=XmNUdMIC0WrE9fF0LIcfozAKOGrlYwj8AfXvCndIH-o,4693
 ai_pipeline_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_pipeline_core/settings.py,sha256=Zl2BPa6IHzh-B5V7cg5mtySr1dhWZQYYKxXz3BwrHlQ,615
-ai_pipeline_core/tracing.py,sha256=_bijptKWXh7V_xENFQGF11-B70rOGwV6g0qdBoF-VCw,7890
-ai_pipeline_core/documents/__init__.py,sha256=rEnKj-sSlZ9WnFlZAmSGVi1P8vnsHmU9O9_YwtP40ms,242
+ai_pipeline_core/tracing.py,sha256=T-3fTyA37TejXxotkVzTNqL2a5nOfZ0bcHg9TClLvmg,9471
+ai_pipeline_core/documents/__init__.py,sha256=TLW8eOEmthfDHOTssXjyBlqhgrZe9ZIyxlkd0LBJ3_s,340
 ai_pipeline_core/documents/document.py,sha256=e3IBr0TThucBAaOHvdqv0X--iCcBrqh2jzFTyaOp7O0,12418
 ai_pipeline_core/documents/document_list.py,sha256=HOG_uZDazA9CJB7Lr_tNcDFzb5Ff9RUt0ELWQK_eYNM,4940
 ai_pipeline_core/documents/flow_document.py,sha256=qsV-2JYOMhkvAj7lW54ZNH_4QUclld9h06CoU59tWww,815
 ai_pipeline_core/documents/mime_type.py,sha256=sBhNRoBJQ35JoHWhJzBGpp00WFDfMdEX0JZKKkR7QH0,3371
 ai_pipeline_core/documents/task_document.py,sha256=WjHqtl1d60XFBBqewNRdz1OqBErGI0jRx15oQYCTHo8,907
 ai_pipeline_core/documents/utils.py,sha256=BdE4taSl1vrBhxnFbOP5nDA7lXIcvY__AMRTHoaNb5M,2764
-ai_pipeline_core/flow/__init__.py,sha256=_Sji2yY1ICkvVX6QiiGWKzqIXtg9UAiuvhjHSK_gdO8,57
+ai_pipeline_core/flow/__init__.py,sha256=54DRfZnjXQVrimgtKEVEm5u5ErImx31cjK2PpBvHjU4,116
 ai_pipeline_core/flow/config.py,sha256=crbe_OvNE6qulIKv1D8yKoe8xrEsIlvICyxjhqHHBxQ,2266
+ai_pipeline_core/flow/options.py,sha256=WygJEwjqOa14l23a_Hp36hJX-WgxHMq-YzSieC31Z4Y,701
 ai_pipeline_core/llm/__init__.py,sha256=3XVK-bSJdOe0s6KmmO7PDbsXHfjlcZEG1MVBmaz3EeU,442
 ai_pipeline_core/llm/ai_messages.py,sha256=DwJJe05BtYdnMZeHbBbyEbDCqrW63SRvprxptoJUCn4,4586
-ai_pipeline_core/llm/client.py,sha256=IOcyjwyAKQWlqnwC5p2Hl4FeRCzOJAHC5Yqr_oCBQ8s,7703
+ai_pipeline_core/llm/client.py,sha256=VMs1nQKCfoxbcvE2mypn5QF19u90Ua87-5IiZxWOj98,7784
 ai_pipeline_core/llm/model_options.py,sha256=TvAAlDFZN-TP9-J-RZBuU_dpSocskf6paaQMw1XY9UE,1321
 ai_pipeline_core/llm/model_response.py,sha256=fIWueaemgo0cMruvToMZyKsRPzKwL6IlvUJN7DLG710,5558
 ai_pipeline_core/llm/model_types.py,sha256=rIwY6voT8-xdfsKPDC0Gkdl2iTp9Q2LuvWGSRU9Mp3k,342
@@ -23,7 +26,10 @@ ai_pipeline_core/logging/__init__.py,sha256=DOO6ckgnMVXl29Sy7q6jhO-iW96h54pCHQDz
 ai_pipeline_core/logging/logging.yml,sha256=YTW48keO_K5bkkb-KXGM7ZuaYKiquLsjsURei8Ql0V4,1353
 ai_pipeline_core/logging/logging_config.py,sha256=6MBz9nnVNvqiLDoyy9-R3sWkn6927Re5hdz4hwTptpI,4903
 ai_pipeline_core/logging/logging_mixin.py,sha256=RDaR2ju2-vKTJRzXGa0DquGPT8_UxahWjvKJnaD0IV8,7810
-ai_pipeline_core-0.1.6.dist-info/METADATA,sha256=BSLr818JTSrsTGPjOEB7bQoCv4q3ep-0YX55UgJRH4s,15869
-ai_pipeline_core-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ai_pipeline_core-0.1.6.dist-info/licenses/LICENSE,sha256=kKj8mfbdWwkyG3U6n7ztB3bAZlEwShTkAsvaY657i3I,1074
-ai_pipeline_core-0.1.6.dist-info/RECORD,,
+ai_pipeline_core/simple_runner/__init__.py,sha256=OPbTCZvqpnYdwi1Knnkj-MpmD0Nvtg5O7UwIdAKz_AY,384
+ai_pipeline_core/simple_runner/cli.py,sha256=TjiSh7lr1VnTbO1jA2DuVzC2AA6V_5sA5Z8XSuldQmc,3054
+ai_pipeline_core/simple_runner/simple_runner.py,sha256=70BHT1iz-G368H2t4tsWAVni0jw2VkWVdnKICuVtLPw,5009
+ai_pipeline_core-0.1.7.dist-info/METADATA,sha256=2Pi815TCTBlKnTp2duTaUJiKaextafqZ5yfPZdD_--o,18361
+ai_pipeline_core-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_pipeline_core-0.1.7.dist-info/licenses/LICENSE,sha256=kKj8mfbdWwkyG3U6n7ztB3bAZlEwShTkAsvaY657i3I,1074
+ai_pipeline_core-0.1.7.dist-info/RECORD,,