gllm-pipeline-binary 0.4.30__cp312-cp312-win_amd64.whl → 0.4.32__cp312-cp312-win_amd64.whl

gllm_pipeline/pipeline/composer/composer.pyi

@@ -11,6 +11,7 @@ from gllm_pipeline.pipeline.pipeline import Pipeline as Pipeline
 from gllm_pipeline.schema import PipelineSteps as PipelineSteps
 from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
 from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
+from gllm_pipeline.types import Val as Val
 from typing import Any, Callable, Self, overload
 
 class Composer:
@@ -135,6 +136,34 @@ class Composer:
             name (str | None, optional): A unique identifier for this step. If None, a name will be
                 auto-generated with the prefix "no_op_". Defaults to None.
 
+        Returns:
+            Self: The composer instance with this step appended.
+        '''
+    def goto(self, name: str, target: Val | str | Callable, input_map: InputMapSpec | None = None, output_state: str | None = None, allow_end: bool = True, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> Self:
+        '''Append a goto step for dynamic flow control.
+
+        Args:
+            name (str): A unique identifier for this step.
+            target (Val | str | Callable): The jump target specification.
+                1. Val: Static target (unwrapped value)
+                2. str: State key to read target from
+                3. Callable: Function that computes the target
+            input_map (InputMapSpec | None): Input mapping for callable targets.
+                Only used when target is a callable. Defaults to None.
+            output_state (str | None): Optional key to store the resolved target in state.
+                If provided, the resolved target will be saved to this state key.
+                Defaults to None.
+            allow_end (bool): Whether jumping to "END" is allowed. If False and
+                target resolves to "END", a ValueError is raised. Defaults to True.
+            retry_config (RetryConfig | None): Configuration for retry behavior.
+                Defaults to None.
+            error_handler (BaseStepErrorHandler | None): Strategy for error handling.
+                Defaults to None.
+            cache_store (BaseCache | None): Cache store for step results.
+                Defaults to None.
+            cache_config (dict[str, Any] | None): Cache configuration.
+                Defaults to None.
+
         Returns:
             Self: The composer instance with this step appended.
         '''

gllm_pipeline/pipeline/pipeline.pyi

@@ -7,12 +7,14 @@ from gllm_pipeline.pipeline.composer import Composer as Composer
 from gllm_pipeline.pipeline.states import RAGState as RAGState
 from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
 from gllm_pipeline.steps.terminator_step import TerminatorStep as TerminatorStep
+from gllm_pipeline.types import PipelineInvocation as PipelineInvocation
 from gllm_pipeline.utils.graph import create_edge as create_edge
 from gllm_pipeline.utils.mermaid import MERMAID_HEADER as MERMAID_HEADER, combine_mermaid_diagrams as combine_mermaid_diagrams, extract_step_diagrams as extract_step_diagrams
+from gllm_pipeline.utils.schema import filter_output_by_schema as filter_output_by_schema, is_typeddict_or_basemodel as is_typeddict_or_basemodel
 from gllm_pipeline.utils.typing_compat import TypedDict as TypedDict, is_typeddict as is_typeddict
 from langgraph.graph import StateGraph
 from pydantic import BaseModel
-from typing import Any
+from typing import Any, Callable
 
 DEFAULT_TOOL_NAME: str
 INDENTATION: str
@@ -194,36 +196,25 @@ class Pipeline:
         Returns:
             Composer: A composer instance that manages this pipeline.
         """
-    def as_tool(self, description: str | None = None) -> Tool:
+    def as_tool(self, description: str | None = None, input_schema: type | None = None, output_schema: type | None = None, input_transform: Callable[[dict[str, Any]], dict[str, Any]] | None = None, output_transform: Callable[[dict[str, Any]], Any] | None = None) -> Tool:
         '''Convert the pipeline to a Tool instance.
 
-        This method allows a Pipeline instance to be used as a tool, with the input schema
-        being derived from the pipeline\'s input schema. The pipeline must have an input_type
-        defined to be convertible as a tool.
+        This method allows a Pipeline instance to be used as a tool, with flexible input/output
+        transformation support. The pipeline must have an input_type defined unless a custom
+        input_schema is provided with input_transform.
 
-        If the pipeline has a context_schema defined, the tool will accept a nested
-        structure with \'input\' and optional \'context\' keys. Otherwise, it will accept
-        flat kwargs matching the input schema (legacy behavior).
-
-        Args:
-            description (str | None, optional): Optional description to associate with the tool.
-                Defaults to None, in which case a description will be generated automatically.
-
-        Returns:
-            Tool: A Tool instance that wraps the pipeline.
-
-        Raises:
-            ValueError: If the pipeline does not have an input schema defined.
+        Note that if the input_schema is not provided, the input schema will fall back to the
+        pipeline\'s input_type and context_schema. In this case, the input_transform is ignored.
 
         Examples:
             ```python
+            # Default behavior with context schema
             class InputState(TypedDict):
                 user_query: str
 
             class ContextSchema(TypedDict):
                 session_id: str
 
-            # With context schema
             pipeline = Pipeline(
                 [retrieval_step, generation_step],
                 input_type=InputState,
@@ -236,15 +227,52 @@ class Pipeline:
                 context={"session_id": "abc123"}
             )
 
-            # Without context schema (legacy)
-            pipeline = Pipeline(
-                [retrieval_step, generation_step],
-                input_type=InputState,
-                name="rag_pipeline"
+            # Custom input schema with transforms
+            class ToolInput(TypedDict):
+                message: str
+                limit: int
+
+            def pre_transform(data):
+                return {
+                    "input": {"user_query": data["message"]},
+                    "config": {"max_results": data["limit"]}
+                }
+
+            def post_transform(data):
+                return {"processed": True, "result": data}
+
+            tool = pipeline.as_tool(
+                input_schema=ToolInput,
+                input_transform=pre_transform,
+                output_transform=post_transform
             )
-            tool = pipeline.as_tool()
-            result = await tool.invoke(user_query="What is AI?")
+            result = await tool.invoke(message="What is AI?", limit=5)
             ```
+
+        Args:
+            description (str | None, optional): Optional description to associate with the tool.
+                Defaults to None, in which case a description will be generated automatically.
+            input_schema (type | None, optional): Custom input schema for
+                the tool (TypedDict or Pydantic BaseModel). If provided,
+                input_transform must also be provided. Defaults to None.
+            output_schema (type | None, optional): Custom output schema for
+                the tool (TypedDict or Pydantic BaseModel). If provided,
+                the output will be filtered to match this schema after applying
+                output_transform. If not provided, uses the pipeline\'s output_type. Defaults to None.
+            input_transform (Callable | None, optional): Function to transform tool input
+                to pipeline invocation format. Must return dict with \'input\' key and optional
+                \'config\' key. Required if input_schema is provided. Defaults to None.
+            output_transform (Callable | None, optional): Function to transform pipeline
+                output before returning from tool. Can change the output type. Defaults to None.
+
+        Returns:
+            Tool: A Tool instance that wraps the pipeline.
+
+        Raises:
+            ValueError: If the pipeline does not have an input schema defined and no custom
+                input_schema is provided, or if input_schema is provided without
+                input_transform, or if input_schema/output_schema is not a TypedDict or BaseModel.
+
         '''
     def clear(self) -> None:
         """Clears the pipeline by resetting steps, graph, and app to their initial state.

gllm_pipeline/steps/_func.pyi

@@ -5,6 +5,7 @@ from gllm_pipeline.alias import InputMapSpec as InputMapSpec, PipelineSteps as P
 from gllm_pipeline.pipeline.pipeline import Pipeline as Pipeline
 from gllm_pipeline.steps.component_step import ComponentStep as ComponentStep
 from gllm_pipeline.steps.conditional_step import ConditionType as ConditionType, ConditionalStep as ConditionalStep, DEFAULT_BRANCH as DEFAULT_BRANCH
+from gllm_pipeline.steps.goto_step import GoToStep as GoToStep
 from gllm_pipeline.steps.guard_step import GuardStep as GuardStep
 from gllm_pipeline.steps.log_step import LogStep as LogStep
 from gllm_pipeline.steps.map_reduce_step import MapReduceStep as MapReduceStep
@@ -15,6 +16,7 @@ from gllm_pipeline.steps.state_operator_step import StateOperatorStep as StateOp
 from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
 from gllm_pipeline.steps.subgraph_step import SubgraphStep as SubgraphStep
 from gllm_pipeline.steps.terminator_step import TerminatorStep as TerminatorStep
+from gllm_pipeline.types import Val as Val
 from typing import Any, Callable
 
 def step(component: Component, input_state_map: dict[str, str] | None = None, output_state: str | list[str] | None = None, runtime_config_map: dict[str, str] | None = None, fixed_args: dict[str, Any] | None = None, input_map: InputMapSpec | None = None, emittable: bool = True, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, name: str | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> ComponentStep:
@@ -1025,3 +1027,34 @@ def copy(input_state: str | list[str], output_state: str | list[str], retry_conf
         )
         ```
     '''
+def goto(name: str, target: Val | str | Callable, input_map: InputMapSpec | None = None, output_state: str | None = None, allow_end: bool = True, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> GoToStep:
+    '''Create a GoToStep for dynamic flow control.
+
+    This convenience function creates a GoToStep that enables dynamic flow control
+    by jumping to specified nodes in the pipeline.
+
+    Args:
+        name (str): A unique identifier for this pipeline step.
+        target (Val | str | Callable): The jump target specification.
+            1. Val: Static target (unwrapped value)
+            2. str: State key to read target from
+            3. Callable: Function that computes the target
+        input_map (InputMapSpec | None): Input mapping for callable targets.
+            Only used when target is a callable. Defaults to None.
+        output_state (str | None): Optional key to store the resolved target in state.
+            If provided, the resolved target will be saved to this state key.
+            Defaults to None.
+        allow_end (bool): Whether jumping to "END" is allowed. If False and
+            target resolves to "END", a ValueError is raised. Defaults to True.
+        retry_config (RetryConfig | None): Configuration for retry behavior.
+            Defaults to None.
+        error_handler (BaseStepErrorHandler | None): Strategy for error handling.
+            Defaults to None.
+        cache_store (BaseCache | None): Cache store for step results.
+            Defaults to None.
+        cache_config (dict[str, Any] | None): Cache configuration.
+            Defaults to None.
+
+    Returns:
+        GoToStep: A configured GoToStep instance.
+    '''

gllm_pipeline/steps/goto_step.pyi

@@ -0,0 +1,114 @@
+from _typeshed import Incomplete
+from gllm_core.utils.retry import RetryConfig
+from gllm_datastore.cache.cache import BaseCache
+from gllm_pipeline.alias import InputMapSpec as InputMapSpec, PipelineState as PipelineState
+from gllm_pipeline.exclusions import ExclusionSet as ExclusionSet
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
+from gllm_pipeline.types import Val as Val
+from gllm_pipeline.utils.async_utils import execute_callable as execute_callable
+from gllm_pipeline.utils.graph import create_edge as create_edge
+from gllm_pipeline.utils.has_inputs_mixin import HasInputsMixin as HasInputsMixin
+from gllm_pipeline.utils.input_map import shallow_dump as shallow_dump
+from langchain_core.runnables import RunnableConfig as RunnableConfig
+from langgraph.runtime import Runtime
+from langgraph.types import Command, RetryPolicy
+from typing import Any, Callable
+
+class GoToStep(BasePipelineStep, HasInputsMixin):
+    '''A pipeline step that enables dynamic flow control by jumping to specified nodes.
+
+    This step allows for dynamic routing in pipelines by jumping to different nodes
+    based on runtime conditions. The target can be a static node name, a state key,
+    or a callable that determines the target at runtime.
+
+    Attributes:
+        name (str): A unique identifier for the pipeline step.
+        target (Val | str | Callable[[dict[str, Any]], str]): The target node specification.
+        input_map (dict[str, str | Val]): Mapping of argument names to either a state/config key (str)
+            or a fixed value (Val). Inherited from HasInputsMixin.
+        output_state (str | None): The state key to store the resolved target.
+        allow_end (bool): Whether jumping to \'END\' is allowed.
+        retry_policy (RetryPolicy | None): Configuration for retry behavior using LangGraph\'s RetryPolicy.
+            Inherited from BasePipelineStep.
+        cache_store ("BaseCache" | None): The cache store used for caching step results, if configured.
+            Inherited from BasePipelineStep.
+        is_cache_enabled (bool): Property indicating whether caching is enabled for this step.
+            Inherited from BasePipelineStep.
+    '''
+    target: Incomplete
+    output_state: Incomplete
+    allow_end: Incomplete
+    def __init__(self, name: str, target: Val | str | Callable[[dict[str, Any]], str], input_map: InputMapSpec | None = None, output_state: str | None = None, allow_end: bool = True, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> None:
+        """Initializes a new instance of the GoToStep class.
+
+        Args:
+            name (str): The name of the step.
+            target (Val | str | Callable): The target node specification.
+            input_map (InputMapSpec | None, optional): Unified input map. Defaults to None.
+            output_state (str | None, optional): State key to store resolved target. Defaults to None.
+            allow_end (bool, optional): Whether jumping to 'END' is allowed. Defaults to True.
+            retry_config (RetryConfig | None, optional): Retry configuration. Defaults to None.
+            error_handler (BaseStepErrorHandler | None, optional): Error handler. Defaults to None.
+            cache_store (BaseCache | None, optional): Cache store instance. Defaults to None.
+            cache_config (dict[str, Any] | None, optional): Cache configuration. Defaults to None.
+        """
+    async def execute(self, state: PipelineState, runtime: Runtime, config: RunnableConfig | None = None) -> Command:
+        """Executes the goto step and returns a LangGraph Command.
+
+        Args:
+            state (PipelineState): The current pipeline state.
+            runtime (Runtime): The runtime context containing config.
+            config (RunnableConfig | None, optional): Optional runnable configuration. Defaults to None.
+
+        Returns:
+            Command: A LangGraph Command with goto parameter for routing.
+
+        Raises:
+            ValueError: If the resolved target is invalid.
+            KeyError: If state key is missing for string targets.
+        """
+    async def execute_direct(self, state: PipelineState, runtime: Runtime, config: RunnableConfig | None = None) -> dict[str, Any] | None:
+        """Executes the goto step and returns a state update.
+
+        Args:
+            state (PipelineState): The current pipeline state.
+            runtime (Runtime): The runtime context containing config.
+            config (RunnableConfig | None, optional): Optional runnable configuration. Defaults to None.
+
+        Returns:
+            dict[str, Any] | None: State update with resolved target if output_state
+                is specified, None otherwise.
+
+        Raises:
+            ValueError: If the resolved target is invalid.
+            KeyError: If state key is missing for string targets.
+        """
+    def add_to_graph(self, graph: Any, previous_endpoints: list[str], retry_policy: RetryPolicy | None = None) -> list[str]:
+        """Adds the GoToStep to the graph and creates edges.
+
+        Args:
+            graph (Any): The LangGraph graph to add the step to.
+            previous_endpoints (list[str]): List of source node names to connect from.
+            retry_policy (RetryPolicy | None, optional): Optional retry policy to override
+                the step's default. Defaults to None.
+
+        Returns:
+            list[str]: List of endpoint names after adding this step.
+        """
+    def get_mermaid_diagram(self, indent: int = 0) -> str:
+        """Generates a Mermaid diagram representation of this goto step.
+
+        Args:
+            indent (int, optional): Number of spaces to indent the diagram. Defaults to 0.
+
+        Returns:
+            str: The Mermaid diagram string.
+        """
+    is_excluded: Incomplete
+    def apply_exclusions(self, exclusions: ExclusionSet) -> None:
+        """Applies exclusions to this goto step.
+
+        Args:
+            exclusions (ExclusionSet): The exclusion set to apply.
+        """

gllm_pipeline/steps/parallel_step.pyi

@@ -3,11 +3,12 @@ from gllm_core.utils.retry import RetryConfig
 from gllm_datastore.cache.cache import BaseCache
 from gllm_pipeline.alias import InputMapSpec as InputMapSpec, PipelineSteps as PipelineSteps
 from gllm_pipeline.steps.branching_step import BranchingStep as BranchingStep
+from gllm_pipeline.steps.goto_step import GoToStep as GoToStep
 from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
 from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
 from gllm_pipeline.utils.copy import safe_deepcopy as safe_deepcopy
 from gllm_pipeline.utils.error_handling import ValidationError as ValidationError, create_error_context as create_error_context
-from gllm_pipeline.utils.graph import create_edge as create_edge
+from gllm_pipeline.utils.graph import check_non_parallelizable_steps as check_non_parallelizable_steps, create_edge as create_edge
 from gllm_pipeline.utils.has_inputs_mixin import HasInputsMixin as HasInputsMixin
 from gllm_pipeline.utils.input_map import shallow_dump as shallow_dump
 from gllm_pipeline.utils.mermaid import MERMAID_HEADER as MERMAID_HEADER
@@ -19,6 +20,8 @@ from langgraph.types import RetryPolicy
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
+NON_PARALLELIZABLE_STEPS: Incomplete
+
 class ParallelStep(BranchingStep, HasInputsMixin):
     """A pipeline step that executes multiple branches in parallel.
 

gllm_pipeline/steps/pipeline_step.pyi

@@ -14,7 +14,6 @@ from langchain_core.runnables import RunnableConfig as RunnableConfig
 from langgraph.graph import StateGraph
 from langgraph.runtime import Runtime
 from langgraph.types import RetryPolicy
-from pydantic import BaseModel as BaseModel
 from typing import Any
 
 LANGGRAPH_CONFIG_PREFIX: str
@@ -153,14 +152,14 @@ class BasePipelineStep(ABC):
             list[str]: The exit points (endpoints) of this step.
         """
     @abstractmethod
-    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> dict[str, Any] | None:
+    async def execute(self, state: PipelineState, runtime: Runtime, config: RunnableConfig | None = None) -> dict[str, Any] | None:
         """Executes the operation defined for this pipeline step.
 
         This method should be implemented by subclasses to perform the actual processing or computation for this step.
 
         Args:
             state (PipelineState): The current state of the pipeline, containing all data.
-            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+            runtime (Runtime): Runtime information for this step's execution.
             config (RunnableConfig | None, optional): Runnable configuration containing thread_id and other
                 LangGraph config. This allows steps to access invocation-level configuration like thread_id for
                 tracking and checkpointing. Defaults to None.
@@ -173,7 +172,7 @@ class BasePipelineStep(ABC):
         Raises:
             NotImplementedError: If the subclass does not implement this method.
         """
-    async def execute_direct(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> dict[str, Any] | None:
+    async def execute_direct(self, state: dict[str, Any], runtime: Runtime, config: RunnableConfig | None = None) -> dict[str, Any] | None:
         """Execute this step directly, bypassing graph-based execution.
 
         This method is used when a step needs to be executed directly, such as in parallel execution.
@@ -181,7 +180,7 @@ class BasePipelineStep(ABC):
 
         Args:
             state (dict[str, Any]): The current state of the pipeline.
-            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+            runtime (Runtime): Runtime information for this step's execution.
             config (RunnableConfig | None, optional): The runnable configuration to pass to the step.
 
         Returns:

gllm_pipeline/types.pyi

@@ -1,4 +1,7 @@
+from _typeshed import Incomplete
 from dataclasses import dataclass
+from pydantic import BaseModel
+from typing import Any
 
 @dataclass(frozen=True)
 class Val:
@@ -8,3 +11,31 @@ class Val:
         value (object): The literal value of the input.
     """
     value: object
+
+class PipelineInvocation(BaseModel):
+    '''A model representing the invocation parameters for a pipeline.
+
+    This model is used to validate the structure of data returned by
+    pre_invoke_transform functions. It ensures the data has the correct
+    format for pipeline invocation.
+
+    Examples:
+        ```python
+        invocation = PipelineInvocation(
+            input={"user_query": "What is AI?"},
+            config={"session_id": "abc123"}
+        )
+
+        # With no config
+        invocation = PipelineInvocation(input={"query": "test"})
+        ```
+
+    Attributes:
+        input (dict[str, Any]): The input data to pass to the pipeline.
+            This is a required field and must be a dictionary.
+        config (dict[str, Any] | None): Optional configuration for the
+            pipeline execution. Must be a dictionary if provided.
+    '''
+    model_config: Incomplete
+    input: dict[str, Any]
+    config: dict[str, Any] | None

gllm_pipeline/utils/graph.pyi

@@ -1,4 +1,5 @@
 from langgraph.graph import StateGraph
+from typing import Any
 
 def create_edge(graph: StateGraph, sources: str | list[str], target: str) -> None:
     """Create edges from source nodes to target node in the graph.
@@ -14,3 +15,19 @@ def create_edge(graph: StateGraph, sources: str | list[str], target: str) -> Non
             do nothing.
         target (str): The target node.
     """
+def check_non_parallelizable_steps(branches: dict[str, Any], non_parallelizable_types: tuple[type, ...]) -> list[str]:
+    """Check branches for non-parallelizable step instances.
+
+    This function recursively searches through branches to find any steps that
+    are instances of the specified non-parallelizable types.
+
+    Args:
+        branches (dict[str, Any]): Dictionary mapping branch names to branch contents.
+            Branch contents can be single steps or lists of steps.
+        non_parallelizable_types (tuple[type, ...]): Tuple of step types that cannot
+            be safely executed in parallel.
+
+    Returns:
+        list[str]: List of descriptions of found non-parallelizable steps, including
+            their name, type, location, and branch name.
+    """

gllm_pipeline/utils/schema.pyi

@@ -0,0 +1,25 @@
+from gllm_pipeline.utils.typing_compat import is_typeddict as is_typeddict
+from typing import Any
+
+def is_typeddict_or_basemodel(type_hint: type) -> bool:
+    """Check if a type is a TypedDict or Pydantic BaseModel.
+
+    Args:
+        type_hint (type): The type to check.
+
+    Returns:
+        bool: True if the type is a TypedDict or BaseModel, False otherwise.
+    """
+def filter_output_by_schema(result: Any, schema: type) -> dict[str, Any]:
+    """Filter the output result to match the provided schema.
+
+    Args:
+        result (Any): The result to filter.
+        schema (type): The schema (TypedDict or BaseModel) to filter against.
+
+    Returns:
+        dict[str, Any]: The filtered result as a dictionary.
+
+    Raises:
+        ValueError: If the schema is not a TypedDict or Pydantic BaseModel.
+    """

{gllm_pipeline_binary-0.4.30.dist-info → gllm_pipeline_binary-0.4.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-pipeline-binary
-Version: 0.4.30
+Version: 0.4.32
 Summary: A library containing components related to Gen AI applications pipeline orchestration.
 Author-email: Dimitrij Ray <dimitrij.ray@gdplabs.id>, Henry Wicaksono <henry.wicaksono@gdplabs.id>, Kadek Denaya <kadek.d.r.diana@gdplabs.id>
 Requires-Python: <3.13,>=3.11

{gllm_pipeline_binary-0.4.30.dist-info → gllm_pipeline_binary-0.4.32.dist-info}/RECORD

@@ -1,16 +1,16 @@
-gllm_pipeline.cp312-win_amd64.pyd,sha256=h-n_PK5GuCPrgbTrSf78b3mbELtwZJggFzOk_yUdavs,2197504
+gllm_pipeline.cp312-win_amd64.pyd,sha256=PS6QG5jkGrj-PmLLHnRJjBIs_Hu68h3S92DL8yNWO_g,2306048
 gllm_pipeline.pyi,sha256=MD-D3Elp4GWlKPM1ms2pMGJRhtYf1bI84rYAjJSPEbM,2378
 gllm_pipeline/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_pipeline/alias.pyi,sha256=FbALRYZpDlmQMsKNUvgCi6ji11PrEtNo2kgzbt0iT7g,237
-gllm_pipeline/types.pyi,sha256=CV3cEAxlNsnVatYz5iCxqmEFPEqeKW5vv-qUD3FpF54,241
+gllm_pipeline/types.pyi,sha256=kGIvyPpmCEu--R3mAtQjsUBCVGTHTYMcycMXqS06evs,1311
 gllm_pipeline/exclusions/__init__.pyi,sha256=_LwIlqmH4Iiksn7p09d2vZG4Ek8CdKC8UcDRMw6zs_Y,224
 gllm_pipeline/exclusions/exclusion_manager.pyi,sha256=DzoL-2KeTRmFgJEo8rzYViFYKbzZVTZGJmKvzaoTC0M,2960
 gllm_pipeline/exclusions/exclusion_set.pyi,sha256=11XTt6IfkHpzomcNybA78SfWlp752Z3AGhXfm2rL0Fk,1685
 gllm_pipeline/pipeline/__init__.pyi,sha256=1IKGdMvmLWEiOOmAKFNUPm-gdw13zrnU1gs7tDNzgEU,168
-gllm_pipeline/pipeline/pipeline.pyi,sha256=hORa2VLM05sQaTktOqteO3a80Vbqu7LwKvmkN-vshPg,17051
+gllm_pipeline/pipeline/pipeline.pyi,sha256=_Opo1LtSiELKbMeW_l_myU5MMgMAjwwlxQ8dwAIj014,19090
 gllm_pipeline/pipeline/states.pyi,sha256=NuWs7-Q6gGIHV32o-conwTtKXrbd0FpKE1d8Hg4OAt0,6459
 gllm_pipeline/pipeline/composer/__init__.pyi,sha256=-hcOUQgpTRt1QjQfRurTf-UApFnTrhilx6vN-gYd5J0,666
-gllm_pipeline/pipeline/composer/composer.pyi,sha256=RilABdb4JN_XusRv_0rfG2ziyOPf-YqmbRjCCk0A9z8,28674
+gllm_pipeline/pipeline/composer/composer.pyi,sha256=FW_lQ0ex7zen2OcKY1TmzEQEng_Ma9YMbrlCsqA8pq4,30528
 gllm_pipeline/pipeline/composer/guard_composer.pyi,sha256=xYJyepAu80VSr0JdQSetwi4_lx6v76zXLdxDxFWsTQk,3294
 gllm_pipeline/pipeline/composer/if_else_composer.pyi,sha256=iXpswHcwp7DEmC67rSwGaTUeh5FUnQqgv-AGDHdMBAQ,3155
 gllm_pipeline/pipeline/composer/parallel_composer.pyi,sha256=_DNz90IDM9U5AcPC-101CupeRKkFQMAp5Z_1-FEnPy0,2565
@@ -40,17 +40,18 @@ gllm_pipeline/router/preset/aurelio/router_image_domain_specific.pyi,sha256=6pm2
 gllm_pipeline/router/preset/lm_based/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_pipeline/router/preset/lm_based/router_image_domain_specific.pyi,sha256=UdiuoSXm2MVAL8AspAaSkyXYkE59bYj1y4xRRgKwavE,655
 gllm_pipeline/steps/__init__.pyi,sha256=5HtVA5CODr_9_7_OGEXFXU40edqhHa9YlCV5qVx3xbU,1989
-gllm_pipeline/steps/_func.pyi,sha256=Nt_kWdAVlvTNsOiPejCF8j4AtiBPqxJr4lDieETfzr8,64124
+gllm_pipeline/steps/_func.pyi,sha256=vKoAZXDh8X0k00m2YkPwK4jQY6fbAD2gPnOt7u8Ah8Q,66071
 gllm_pipeline/steps/branching_step.pyi,sha256=ZT4uJVxvUbmTnOOMst95qtPduigTC9ykzOcpE34oHwo,1006
 gllm_pipeline/steps/component_step.pyi,sha256=BEViLhf874KqylPRaKFMIMeZ6uy4xOol0I68N07bdZo,5716
 gllm_pipeline/steps/composite_step.pyi,sha256=2-iLtaAaa77Ur2HqANlcqPIpOAclAoBG4h2a8yNP33g,3452
 gllm_pipeline/steps/conditional_step.pyi,sha256=qKlXfVuAhyyZPO8_A67TyXVgbdUpUWhjnfvafaBQZKE,10401
+gllm_pipeline/steps/goto_step.pyi,sha256=DLCR-aptEF8CS-SyYPYHpgd6icbzmqBGjXXMjRmsLSI,6353
 gllm_pipeline/steps/guard_step.pyi,sha256=R7h4yKrU1M_zeHqaUH9oCqk3s-nLBTcf8J5tyrQOzGM,4751
 gllm_pipeline/steps/log_step.pyi,sha256=lXOd5VAjfi2cs5yFMQrFgZlnV1Wj9EIeuZa6SIjeaRI,3271
 gllm_pipeline/steps/map_reduce_step.pyi,sha256=lZ1dnG6-TNt4iMRWXSfmpJkVVqHlN2GTUXcOsxi4Kls,6205
 gllm_pipeline/steps/no_op_step.pyi,sha256=8iepve5pJB02d-yG78-eIQuBajsl-i2ovBTluFq5pCo,1578
-gllm_pipeline/steps/parallel_step.pyi,sha256=13VK3h_CGB11pQEFrUroy2FM-J86U3sR2JP_R9yaNoo,8524
-gllm_pipeline/steps/pipeline_step.pyi,sha256=5VZIBEoMEXwoeHLifdtmjoLeydnqXwi7wY_C_mJQsDw,11645
+gllm_pipeline/steps/parallel_step.pyi,sha256=YPlj4E_KkM63FTS4n4kKTH80_hQZe9nUcyAw5lRN5SU,8694
+gllm_pipeline/steps/pipeline_step.pyi,sha256=fBxIcmEDr-cj54KSn6ZvPCESetHz9vbefXOgj97b5QY,11488
 gllm_pipeline/steps/state_operator_step.pyi,sha256=rtzfedK5mDszHpFusXHUiNG3-3fO-mBvmPqDxLvk67A,5293
 gllm_pipeline/steps/subgraph_step.pyi,sha256=f99kx8Vo2foDg6CRqzObvRCetcvzvUQIxW9M6SEZRUs,5996
 gllm_pipeline/steps/terminator_step.pyi,sha256=RLBpARftJNOCB10WS_q1L87m5R-xm8k-F7n3l_hGWs8,2684
@@ -64,15 +65,16 @@ gllm_pipeline/utils/__init__.pyi,sha256=34a24yfX5Wwh3Tw7HuxnSQ1AX0L7-qa0rrXiE1Fq
 gllm_pipeline/utils/async_utils.pyi,sha256=IB8slUq3tk9tTX7UM1uj7Z6UBXuXRNbQCJzCNp3pwug,899
 gllm_pipeline/utils/copy.pyi,sha256=IW--DcDVCv87-6-gAlDgo3QybeFoNXEtSASK2P21k0c,260
 gllm_pipeline/utils/error_handling.pyi,sha256=xeVodtVhoWaPhivY6joWJe1vlxHtMW2csm8ShkoHxHU,2477
-gllm_pipeline/utils/graph.pyi,sha256=33HI_9jUJA8FGZi67lUCnXfvGOuRBCp94Hygyra9vM8,682
+gllm_pipeline/utils/graph.pyi,sha256=WUw_jIQ_RhjBbCucCw5Af7HuaDiC89lOLPyXWvO2Uyw,1501
 gllm_pipeline/utils/has_inputs_mixin.pyi,sha256=vaoRFzZgKdXwJNe7KHziezeHgWkUMORcSxuI5gGUbfU,2585
 gllm_pipeline/utils/input_map.pyi,sha256=mPWU9_b3VGhszuTjB3yQggZWJCxjZth4_WQdKeckA0Y,413
 gllm_pipeline/utils/mermaid.pyi,sha256=B096GTXxVAO--kw3UDsbysOsnjGOytYfozX39YaM21A,1174
 gllm_pipeline/utils/retry_converter.pyi,sha256=TeWG-fsBNtk-rVaV2BZtzvM-y_drf4kGHpVyiZH40L8,1113
+gllm_pipeline/utils/schema.pyi,sha256=9348MO93aEB18vybowOYLtNys8Ee59luuKxFQnfH9Vk,837
 gllm_pipeline/utils/step_execution.pyi,sha256=pic3DyYF8zIBeLkZ6H_lpq5HOioMoKtPC08rfNDs65M,985
 gllm_pipeline/utils/typing_compat.pyi,sha256=V4812i25ncSqZ0o_30lUX65tU07bWEs4LIpdLPt2ngg,116
 gllm_pipeline.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gllm_pipeline_binary-0.4.30.dist-info/METADATA,sha256=KIvzFVUk-tYhWzMydqyKUNBo2gGBLNtPqzVgO3ZYKsQ,4661
-gllm_pipeline_binary-0.4.30.dist-info/WHEEL,sha256=x5rgv--I0NI0IT1Lh9tN1VG2cI637p3deednwYLKnxc,96
-gllm_pipeline_binary-0.4.30.dist-info/top_level.txt,sha256=C3yeOtoE6ZhuOnBEq_FFc_Rp954IHJBlB6fBgSdAWYI,14
-gllm_pipeline_binary-0.4.30.dist-info/RECORD,,
+gllm_pipeline_binary-0.4.32.dist-info/METADATA,sha256=2J5E90dvX0WHXUdx3gWnVT_VNUX2ohoPYZq5vWyDNBc,4661
+gllm_pipeline_binary-0.4.32.dist-info/WHEEL,sha256=x5rgv--I0NI0IT1Lh9tN1VG2cI637p3deednwYLKnxc,96
+gllm_pipeline_binary-0.4.32.dist-info/top_level.txt,sha256=C3yeOtoE6ZhuOnBEq_FFc_Rp954IHJBlB6fBgSdAWYI,14
+gllm_pipeline_binary-0.4.32.dist-info/RECORD,,