gllm-pipeline-binary 0.4.21__cp312-cp312-macosx_13_0_arm64.whl

gllm_pipeline/router/preset/preset_loader.pyi

@@ -0,0 +1,24 @@
+from _typeshed import Incomplete
+from typing import Any
+
+PRESET_REGISTRY: Incomplete
+
+def get_preset(router_type: str, modality: str, preset_name: str, **kwargs: Any) -> dict[str, Any]:
+    '''Retrieve and execute a preset function based on router configuration.
+
+    This function looks up a preset function from the `PRESET_REGISTRY` using the
+    combination of router type, input modality, and preset name. If found, it executes
+    the function with the given keyword arguments.
+
+    Args:
+        router_type (str): The type of router (e.g., "router").
+        modality (str): The input modality (e.g., "image", "text").
+        preset_name (str): The name of the preset (e.g., "domain_specific", "generic").
+        **kwargs: Additional keyword arguments passed to the preset function.
+
+    Returns:
+        dict[str, Any]: A dictionary of router components (varies by router type).
+
+    Raises:
+        ValueError: If no matching preset is found in the registry.
+    '''

gllm_pipeline/router/router.pyi

@@ -0,0 +1,46 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC
+from gllm_core.schema import Component
+
+class BaseRouter(Component, ABC, metaclass=abc.ABCMeta):
+    """An abstract base class for the routers used in Gen AI applications.
+
+    This class provides a foundation for building routers in Gen AI applications. It includes initialization for
+    default and valid routes and abstract routing logic that subclasses must implement.
+
+    Attributes:
+        default_route (str): The default route to use.
+        valid_routes (set[str]): A set of valid routes for the router.
+    """
+    default_route: Incomplete
+    valid_routes: Incomplete
+    logger: Incomplete
+    def __init__(self, default_route: str, valid_routes: set[str]) -> None:
+        """Initializes a new instance of the BaseRouter class.
+
+        Args:
+            default_route (str): The default route to use.
+            valid_routes (set[str]): A set of valid routes for the router.
+
+        Raises:
+            ValueError: If the provided default route is not in the set of valid routes.
+        """
+    async def route(self, source: str | bytes, route_filter: set[str] | None = None) -> str:
+        """Routes an input source to the appropriate path.
+
+        This method is a wrapper around the `_select_route` method. It first calls `_select_route` to get the selected
+        route and then checks if the route is in the set of valid routes. If it is not, it returns the default route.
+
+        Args:
+            source (str | bytes): The input source to be routed.
+            route_filter (set[str] | None, optional): An optional set of allowed routes. If provided, only the routes
+                in the set are considered valid. Defaults to None.
+
+        Returns:
+            str: The selected route for the input source.
+
+        Raises:
+            ValueError: If the provided route filter contains invalid routes or if the default route is not included
+                in the route filter.
+        """

gllm_pipeline/router/rule_based_router.pyi

@@ -0,0 +1,80 @@
+from _typeshed import Incomplete
+from gllm_pipeline.router.router import BaseRouter as BaseRouter
+from pydantic import BaseModel
+
+class RouterSplitRule(BaseModel):
+    '''Configuration class for defining input string splitting rules in rule-based router operations.
+
+    Attributes:
+        splitter (list[str]): A list of string delimiters used to split the input string. Defaults to [" "].
+        beg_index (int | None, optional): Optional beginning index of the portion of the split result to keep.
+            If None, the split result will be kept from the first element. Defaults to None.
+        end_index (int | None, optional): Optional ending index of the portion of the split result to keep.
+            If None, the split result will be kept until the last element. Defaults to None.
+    '''
+    splitter: list[str]
+    beg_index: int | None
+    end_index: int | None
+
+class RouterRule(BaseModel):
+    """Configuration class for defining keyword matching rules in rule-based router operations.
+
+    Attributes:
+        keywords (list[str]): A list of keywords to match against the input string.
+        allow_substring (bool, optional): If True, allows matching if a keyword is a substring of the input.
+            If False, requires an exact match between a keyword and either the full input or any of its split parts.
+            Defaults to True.
+        case_sensitive (bool, optional): If True, keyword matching will be case-sensitive. Defaults to True.
+        alphanumeric_only (bool, optional): If True, only alphanumeric and whitespace characters will be considered
+            during matching. Defaults to True.
+        split_rule (list[RouterSplitRule] | None, optional): A list of `RouterSplitRule` objects that define how to
+            split the input string before matching. If multiple are provided, the splits will be done sequentially.
+            If None, no splitting will be applied. Defaults to None.
+    """
+    keywords: list[str]
+    allow_substring: bool
+    case_sensitive: bool
+    alphanumeric_only: bool
+    split_rule: list[RouterSplitRule] | None
+
+class RouterRuleset(BaseModel):
+    """Configuration class for defining a set of rules in rule-based router operations.
+
+    Attributes:
+        rules (list[RouterRule]): A list of `RouterRule` objects that define individual routing rules.
+        match_all (bool, optional): If True, all rules must be matched for the ruleset to return True. If False,
+            matching any rule will result in the ruleset returning True. Defaults to True.
+    """
+    rules: list[RouterRule]
+    match_all: bool
+
+class RuleBasedRouter(BaseRouter):
+    """A rule-based router that directs the input text to an appropriate route based on a set of rules.
+
+    The `RuleBasedRouter` routes incoming input text to different paths by evaluating a set of rules encapsulated in
+    `RouterRuleset` objects. Each ruleset consists of multiple `RouterRule` objects, and the router determines which
+    route to take based on the input text and the rules defined in the ruleset.
+
+    If `match_all` is True in a `RouterRuleset`, all rules in that ruleset must match the input text for the
+    associated route to be selected. If False, matching any rule in the ruleset will cause that route to be selected.
+    If no match is found, the router defaults to the `default_route`.
+
+    Attributes:
+        ruleset_map (dict[str, RouterRuleset]): A mapping of route names to their corresponding rulesets.
+        default_route (str): The default route to be taken if no ruleset matches the input text.
+        valid_routes (set[str]): A set of valid routes that the router can direct to.
+    """
+    ruleset_map: Incomplete
+    def __init__(self, ruleset_map: dict[str, RouterRuleset], default_route: str, valid_routes: set[str]) -> None:
+        """Initializes a new instance of the RuleBasedRouter class.
+
+        Args:
+            ruleset_map (dict[str, RouterRuleset]): A mapping of route names to their corresponding rulesets.
+            default_route (str): The default route to be taken if no ruleset matches the input text.
+            valid_routes (set[str]): A set of valid routes for the router.
+
+        Raises:
+            ValueError:
+                1. If the `ruleset_map` contains routes that are not in the set of valid routes.
+                2. If the provided default route is not in the set of valid routes.
+        """

gllm_pipeline/router/similarity_based_router.pyi

@@ -0,0 +1,72 @@
+from _typeshed import Incomplete
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_pipeline.router.router import BaseRouter as BaseRouter
+
+class SimilarityBasedRouter(BaseRouter):
+    """A router that utilizes an embedding model to determine the appropriate route for an input text.
+
+    This class routes a given input text to an appropriate path based on semantic similarity between
+    the input text and predefined route examples. It calculates cosine similarity between the input
+    text embedding and the embeddings of route examples, then selects the route with the highest
+    similarity score above a threshold.
+
+    Attributes:
+        em_invoker (BaseEMInvoker): The embedding model invoker to use for vectorization.
+        route_examples (dict[str, list[str]]): A mapping of route names to their example texts.
+        similarity_threshold (float): The minimum similarity score required for a route to be selected.
+        default_route (str): The default route to be used if no route meets the similarity threshold.
+        valid_routes (set[str]): A set of valid routes for the router.
+    """
+    em_invoker: Incomplete
+    route_examples: Incomplete
+    similarity_threshold: Incomplete
+    def __init__(self, em_invoker: BaseEMInvoker, route_examples: dict[str, list[str]], default_route: str, similarity_threshold: float = 0.5) -> None:
+        '''Initializes a new instance of the SimilarityBasedRouter class.
+
+        Args:
+        em_invoker (BaseEMInvoker): The embedding model invoker to use for vectorization.
+        route_examples (dict[str, list[str]]): A mapping of route names to their example texts.
+            The keys define the valid routes, and values are example texts for each route.
+        default_route (str): The default route to be used if no route meets the similarity threshold.
+            Must be one of the keys in route_examples.
+            Examples: "general", "fallback", "customer_service"
+        similarity_threshold (float, optional): The minimum similarity score required for a route to be selected.
+            Must be between 0 and 1. This threshold is compared against normalized cosine similarity scores,
+            which are derived from the standard cosine similarity (ranging from -1 to 1) and converted to
+            a 0-1 range where 0 indicates maximum dissimilarity and 1 indicates maximum similarity.
+        Examples of route_examples:
+                {
+                    "tech_support": [
+                        "I can\'t log in to my account",
+                        "The app keeps crashing",
+                        "Password reset not working",
+                        "Getting error code 500"
+                    ],
+                    "billing": [
+                        "How much do I owe?",
+                        "I want to dispute a charge",
+                        "When is my payment due?",
+                        "Can I get a refund?"
+                    ],
+                    "general": [
+                        "What are your business hours?",
+                        "How do I contact support?",
+                        "Tell me about your services",
+                        "Where are you located?"
+                    ]
+                }
+
+        Raises:
+            ValueError:
+                1. If route_examples is not a dictionary.
+                2. If route_examples is falsy (None, empty dict, etc.).
+                3. If the similarity threshold is not between 0 and 1.
+                4. If the provided default route is not in the route_examples keys.
+                5. If any route has an empty list of examples.
+        '''
+    def clear_cache(self) -> None:
+        """Clears the cached route embeddings.
+
+        This method clears the cached embeddings, forcing them to be regenerated
+        on the next routing operation.
+        """

gllm_pipeline/router/utils.pyi

@@ -0,0 +1,26 @@
+from typing import Any
+
+def encode_bytes(value: Any, recursive: bool = False) -> Any:
+    """Encode `bytes` objects into base64 strings for JSON serialization.
+
+    This function converts `bytes` objects into UTF-8 base64-encoded strings. If
+    `recursive` is enabled, it will traverse nested structures (lists and dictionaries)
+    and encode all `bytes` instances found within them. Other data types remain
+    unchanged.
+
+    Behavior:
+        1. If `value` is `bytes`, it is converted to a base64-encoded UTF-8 string.
+        2. If `value` is a list or dict and `recursive` is True, encoding is applied
+          to all nested elements.
+        3. For unsupported types or when `recursive` is False, the original value is
+          returned as-is.
+
+    Args:
+        value (Any): The value to process. Can be `bytes`, list, dict, or any other type.
+        recursive (bool): If True, apply encoding recursively to all elements within
+            lists and dictionaries. Defaults to False.
+
+    Returns:
+        Any: The base64-encoded string if `value` is `bytes`, a recursively processed
+        structure if `recursive` is True, or the original value otherwise.
+    """

gllm_pipeline/steps/__init__.pyi

@@ -0,0 +1,17 @@
+from gllm_pipeline.steps._func import bundle as bundle, guard as guard, if_else as if_else, log as log, map_reduce as map_reduce, no_op as no_op, parallel as parallel, step as step, subgraph as subgraph, switch as switch, terminate as terminate, toggle as toggle, transform as transform
+from gllm_pipeline.steps.component_step import ComponentStep as ComponentStep
+from gllm_pipeline.steps.conditional_step import ConditionalStep as ConditionalStep
+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
+from gllm_pipeline.steps.no_op_step import NoOpStep as NoOpStep
+from gllm_pipeline.steps.parallel_step import ParallelStep as ParallelStep
+from gllm_pipeline.steps.state_operator_step import StateOperatorStep as StateOperatorStep
+from gllm_pipeline.steps.step_error_handler.empty_step_error_handler import EmptyStepErrorHandler as EmptyStepErrorHandler
+from gllm_pipeline.steps.step_error_handler.fallback_step_error_handler import FallbackStepErrorHandler as FallbackStepErrorHandler
+from gllm_pipeline.steps.step_error_handler.keep_step_error_handler import KeepStepErrorHandler as KeepStepErrorHandler
+from gllm_pipeline.steps.step_error_handler.raise_step_error_handler import RaiseStepErrorHandler as RaiseStepErrorHandler
+from gllm_pipeline.steps.subgraph_step import SubgraphStep as SubgraphStep
+from gllm_pipeline.steps.terminator_step import TerminatorStep as TerminatorStep
+
+__all__ = ['ComponentStep', 'ConditionalStep', 'GuardStep', 'LogStep', 'MapReduceStep', 'NoOpStep', 'ParallelStep', 'StateOperatorStep', 'SubgraphStep', 'TerminatorStep', 'EmptyStepErrorHandler', 'FallbackStepErrorHandler', 'KeepStepErrorHandler', 'RaiseStepErrorHandler', 'bundle', 'guard', 'if_else', 'log', 'map_reduce', 'no_op', 'parallel', 'step', 'subgraph', 'switch', 'terminate', 'toggle', 'transform']