flowyml 1.1.0__py3-none-any.whl

flowyml/core/conditional.py

@@ -0,0 +1,373 @@
+"""Conditional execution for dynamic pipelines."""
+
+from typing import Any
+from collections.abc import Callable
+from functools import wraps
+
+
+class Condition:
+    """Condition for conditional step execution.
+
+    Example:
+        ```python
+        from flowyml import step, Condition
+
+
+        @step
+        def check_quality(data):
+            return {"score": 0.95, "needs_cleaning": False}
+
+
+        @step
+        @Condition(lambda result: result["needs_cleaning"])
+        def clean_data(data, quality_result):
+            return cleaned_data
+        ```
+    """
+
+    def __init__(self, condition_func: Callable[[Any], bool]):
+        """Initialize condition.
+
+        Args:
+            condition_func: Function that takes step inputs and returns bool
+        """
+        self.condition_func = condition_func
+
+    def should_execute(self, *args, **kwargs) -> bool:
+        """Check if condition is met.
+
+        Args:
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+
+        Returns:
+            True if step should execute
+        """
+        try:
+            # Try to evaluate with first argument if available
+            if args:
+                return bool(self.condition_func(args[0]))
+            elif kwargs:
+                # Try with all kwargs
+                return bool(self.condition_func(kwargs))
+            return False
+        except Exception:
+            # If condition evaluation fails, don't execute
+            return False
+
+    def __call__(self, func: Callable) -> Callable:
+        """Decorator to add conditional execution.
+
+        Args:
+            func: Function to wrap
+
+        Returns:
+            Wrapped function
+        """
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if self.should_execute(*args, **kwargs):
+                return func(*args, **kwargs)
+            else:
+                # Return None or a special marker for skipped execution
+                return SkippedExecution(func.__name__)
+
+        # Mark function as conditional
+        wrapper._is_conditional = True
+        wrapper._condition = self
+
+        return wrapper
+
+
+class SkippedExecution:
+    """Marker for skipped conditional execution."""
+
+    def __init__(self, step_name: str):
+        self.step_name = step_name
+        self.skipped = True
+
+    def __repr__(self):
+        return f"<SkippedExecution: {self.step_name}>"
+
+    def __bool__(self):
+        return False
+
+
+def condition(condition_func: Callable[[Any], bool]) -> Condition:
+    """Create a condition decorator.
+
+    Args:
+        condition_func: Function that evaluates to bool
+
+    Returns:
+        Condition decorator
+
+    Example:
+        ```python
+        @step
+        @condition(lambda x: x["quality"] > 0.9)
+        def train_complex_model(data):
+            return complex_model
+        ```
+    """
+    return Condition(condition_func)
+
+
+class ConditionalBranch:
+    """Branch execution based on condition.
+
+    Example:
+        ```python
+        from flowyml import ConditionalBranch
+
+        branch = ConditionalBranch()
+
+
+        @branch.if_condition(lambda x: x > 10)
+        def process_large(data):
+            return process_with_large_model(data)
+
+
+        @branch.else_condition()
+        def process_small(data):
+            return process_with_small_model(data)
+        ```
+    """
+
+    def __init__(self):
+        self.if_func: Callable | None = None
+        self.if_condition_func: Callable | None = None
+        self.else_func: Callable | None = None
+        self.elif_branches: list[tuple[Callable, Callable]] = []
+
+    def if_condition(self, condition_func: Callable[[Any], bool]) -> Callable:
+        """Define if branch.
+
+        Args:
+            condition_func: Condition function
+
+        Returns:
+            Decorator
+        """
+
+        def decorator(func: Callable) -> Callable:
+            self.if_func = func
+            self.if_condition_func = condition_func
+            return func
+
+        return decorator
+
+    def elif_condition(self, condition_func: Callable[[Any], bool]) -> Callable:
+        """Define elif branch.
+
+        Args:
+            condition_func: Condition function
+
+        Returns:
+            Decorator
+        """
+
+        def decorator(func: Callable) -> Callable:
+            self.elif_branches.append((condition_func, func))
+            return func
+
+        return decorator
+
+    def else_condition(self) -> Callable:
+        """Define else branch.
+
+        Returns:
+            Decorator
+        """
+
+        def decorator(func: Callable) -> Callable:
+            self.else_func = func
+            return func
+
+        return decorator
+
+    def execute(self, *args, **kwargs) -> Any:
+        """Execute appropriate branch based on conditions.
+
+        Args:
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+
+        Returns:
+            Result from executed branch
+        """
+        # Try if condition
+        if self.if_func and self.if_condition_func:
+            try:
+                if self.if_condition_func(*args, **kwargs):
+                    return self.if_func(*args, **kwargs)
+            except Exception:
+                pass
+
+        # Try elif conditions
+        for condition_func, func in self.elif_branches:
+            try:
+                if condition_func(*args, **kwargs):
+                    return func(*args, **kwargs)
+            except Exception:
+                pass
+
+        # Execute else
+        if self.else_func:
+            return self.else_func(*args, **kwargs)
+
+        # No branch executed
+        return None
+
+
+class Switch:
+    """Switch-case style conditional execution.
+
+    Example:
+        ```python
+        from flowyml import Switch
+
+        switch = Switch(lambda x: x["type"])
+
+
+        @switch.case("image")
+        def process_image(data):
+            return process_image_data(data)
+
+
+        @switch.case("text")
+        def process_text(data):
+            return process_text_data(data)
+
+
+        @switch.default()
+        def process_other(data):
+            return process_generic(data)
+        ```
+    """
+
+    def __init__(self, selector_func: Callable[[Any], Any]):
+        """Initialize switch.
+
+        Args:
+            selector_func: Function to select case value
+        """
+        self.selector_func = selector_func
+        self.cases: dict[Any, Callable] = {}
+        self.default_func: Callable | None = None
+
+    def case(self, value: Any) -> Callable:
+        """Define a case branch.
+
+        Args:
+            value: Value to match
+
+        Returns:
+            Decorator
+        """
+
+        def decorator(func: Callable) -> Callable:
+            self.cases[value] = func
+            return func
+
+        return decorator
+
+    def default(self) -> Callable:
+        """Define default branch.
+
+        Returns:
+            Decorator
+        """
+
+        def decorator(func: Callable) -> Callable:
+            self.default_func = func
+            return func
+
+        return decorator
+
+    def execute(self, *args, **kwargs) -> Any:
+        """Execute appropriate case based on selector.
+
+        Args:
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+
+        Returns:
+            Result from executed case
+        """
+        # Get selector value
+        try:
+            selector_value = self.selector_func(*args, **kwargs)
+        except Exception:
+            selector_value = None
+
+        # Find matching case
+        if selector_value in self.cases:
+            return self.cases[selector_value](*args, **kwargs)
+
+        # Execute default
+        if self.default_func:
+            return self.default_func(*args, **kwargs)
+
+        return None
+
+
+def when(condition_func: Callable[[Any], bool]) -> Callable:
+    """Simple conditional execution helper.
+
+    Args:
+        condition_func: Condition to evaluate
+
+    Returns:
+        Decorator that executes function only if condition is true
+
+    Example:
+        ```python
+        @step
+        @when(lambda data: len(data) > 1000)
+        def process_large_dataset(data):
+            return expensive_processing(data)
+        ```
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if condition_func(*args, **kwargs):
+                return func(*args, **kwargs)
+            return SkippedExecution(func.__name__)
+
+        return wrapper
+
+    return decorator
+
+
+def unless(condition_func: Callable[[Any], bool]) -> Callable:
+    """Execute unless condition is true.
+
+    Args:
+        condition_func: Condition to evaluate
+
+    Returns:
+        Decorator that executes function only if condition is false
+
+    Example:
+        ```python
+        @step
+        @unless(lambda data: data["cached"])
+        def compute_features(data):
+            return expensive_computation(data)
+        ```
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if not condition_func(*args, **kwargs):
+                return func(*args, **kwargs)
+            return SkippedExecution(func.__name__)
+
+        return wrapper
+
+    return decorator

flowyml/core/context.py

@@ -0,0 +1,155 @@
+"""Context Management - Automatic parameter injection for ML pipelines."""
+
+import inspect
+from typing import Any
+
+
+class Context:
+    """Pipeline context with automatic parameter injection.
+
+    Example:
+        >>> ctx = Context(learning_rate=0.001, epochs=10, batch_size=32, device="cuda")
+    """
+
+    def __init__(self, **kwargs):
+        self._params = kwargs
+        self._parent = None
+        self._metadata = {}
+
+    def __getattr__(self, name: str) -> Any:
+        """Allow dot notation access to parameters."""
+        if name.startswith("_"):
+            return super().__getattribute__(name)
+
+        if name in self._params:
+            return self._params[name]
+
+        if self._parent and name in self._parent._params:
+            return self._parent._params[name]
+
+        raise AttributeError(f"Context has no parameter '{name}'")
+
+    def __getitem__(self, key: str) -> Any:
+        """Allow dict-style access to parameters."""
+        if key in self._params:
+            return self._params[key]
+
+        if self._parent and key in self._parent._params:
+            return self._parent._params[key]
+
+        raise KeyError(f"Context has no parameter '{key}'")
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get parameter with default value."""
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def keys(self) -> set[str]:
+        """Return all parameter keys."""
+        keys = set(self._params.keys())
+        if self._parent:
+            keys.update(self._parent.keys())
+        return keys
+
+    def items(self) -> list[tuple]:
+        """Return all parameter items."""
+        result = {}
+        if self._parent:
+            result.update(dict(self._parent.items()))
+        result.update(self._params)
+        return list(result.items())
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert context to dictionary."""
+        result = {}
+        if self._parent:
+            result.update(self._parent.to_dict())
+        result.update(self._params)
+        return result
+
+    def update(self, data: dict[str, Any]) -> None:
+        """Update context with new data.
+
+        Args:
+            data: Dictionary of key-value pairs to add to context
+        """
+        self._params.update(data)
+
+    def inherit(self, **overrides) -> "Context":
+        """Create child context with inheritance."""
+        child = Context(**overrides)
+        child._parent = self
+        return child
+
+    def inject_params(self, func: callable) -> dict[str, Any]:
+        """Automatically inject parameters based on function signature.
+
+        Args:
+            func: Function to analyze and inject parameters for
+
+        Returns:
+            Dictionary of parameters to inject
+        """
+        sig = inspect.signature(func)
+        injected = {}
+
+        for param_name, param in sig.parameters.items():
+            # Skip self, cls, args, kwargs
+            if param_name in ("self", "cls"):
+                continue
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+
+            # Check if parameter exists in context
+            if param_name in self.keys():
+                injected[param_name] = self[param_name]
+
+        return injected
+
+    def validate_for_step(self, step_func: callable, exclude: list[str] = None) -> list[str]:
+        """Validate that all required parameters are available.
+
+        Args:
+            step_func: Step function to validate
+            exclude: List of parameter names to exclude from validation (e.g. inputs)
+
+        Returns:
+            List of missing required parameters
+        """
+        sig = inspect.signature(step_func)
+        missing = []
+        exclude = exclude or []
+
+        for param_name, param in sig.parameters.items():
+            # Skip optional parameters
+            if param_name in ("self", "cls"):
+                continue
+            if param_name in exclude:
+                continue
+            if param.default != inspect.Parameter.empty:
+                continue
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+
+            # Check if required param is missing
+            if param_name not in self.keys():
+                missing.append(param_name)
+
+        return missing
+
+    def __repr__(self) -> str:
+        params_str = ", ".join(f"{k}={v}" for k, v in list(self._params.items())[:5])
+        if len(self._params) > 5:
+            params_str += "..."
+        return f"Context({params_str})"
+
+
+def context(**kwargs) -> Context:
+    """Create a new context with parameters.
+
+    Example:
+        >>> ctx = context(learning_rate=0.001, epochs=10, batch_size=32)
+    """
+    return Context(**kwargs)