flowyml 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

flowyml/cli/rich_utils.py

@@ -0,0 +1,95 @@
+"""Rich utilities for CLI commands."""
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.text import Text
+    from rich import box
+    from rich.tree import Tree
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+    Console = None
+    Table = None
+    Panel = None
+    Text = None
+    box = None
+    Tree = None
+
+
+def get_console() -> Console | None:
+    """Get Rich console instance if available."""
+    return Console() if RICH_AVAILABLE else None
+
+
+def print_rich_table(title: str, headers: list[str], rows: list[list[str]], console: Console | None = None) -> None:
+    """Print a rich table with fallback to simple output."""
+    if not console:
+        console = get_console()
+
+    if RICH_AVAILABLE and console:
+        table = Table(
+            title=f"[bold cyan]{title}[/bold cyan]",
+            box=box.ROUNDED,
+            show_header=True,
+            header_style="bold cyan",
+            border_style="cyan",
+        )
+        for header in headers:
+            table.add_column(header, style="cyan")
+        for row in rows:
+            table.add_row(*row)
+        console.print(table)
+    else:
+        # Fallback to simple output
+        print(f"\n{title}")
+        print("=" * 70)
+        print(" | ".join(headers))
+        print("-" * 70)
+        for row in rows:
+            print(" | ".join(str(cell) for cell in row))
+        print()
+
+
+def print_rich_panel(content: str, title: str = "", style: str = "cyan", console: Console | None = None) -> None:
+    """Print a rich panel with fallback to simple output."""
+    if not console:
+        console = get_console()
+
+    if RICH_AVAILABLE and console:
+        panel = Panel(
+            content,
+            title=title,
+            border_style=style,
+            box=box.ROUNDED,
+        )
+        console.print(panel)
+    else:
+        # Fallback to simple output
+        if title:
+            print(f"\n{title}")
+            print("=" * 70)
+        print(content)
+        print()
+
+
+def print_rich_text(*parts: tuple[str, str], console: Console | None = None) -> None:
+    """Print rich text with styles, fallback to simple output.
+
+    Args:
+        *parts: Tuples of (text, style) to print
+        console: Optional console instance
+    """
+    if not console:
+        console = get_console()
+
+    if RICH_AVAILABLE and console and Text:
+        text_obj = Text()
+        for text, style in parts:
+            text_obj.append(text, style=style)
+        console.print(text_obj)
+    else:
+        # Fallback to simple output
+        print("".join(text for text, _ in parts))

flowyml/core/checkpoint.py

@@ -49,12 +49,17 @@ class PipelineCheckpoint:
         # Update checkpoint metadata
         checkpoint_data = self.load() if self.checkpoint_file.exists() else {}
 
+        # Get existing completed steps (avoid duplicates)
+        completed_steps = checkpoint_data.get("completed_steps", [])
+        if step_name not in completed_steps:
+            completed_steps.append(step_name)
+
         checkpoint_data.update(
             {
                 "run_id": self.run_id,
                 "last_completed_step": step_name,
                 "last_update": datetime.now().isoformat(),
-                "completed_steps": checkpoint_data.get("completed_steps", []) + [step_name],
+                "completed_steps": completed_steps,
                 "step_metadata": checkpoint_data.get("step_metadata", {}),
             },
         )

flowyml/core/conditional.py

@@ -371,3 +371,107 @@ def unless(condition_func: Callable[[Any], bool]) -> Callable:
         return wrapper
 
     return decorator
+
+
+class If:
+    """If-else conditional control flow for pipelines.
+
+    Supports both constructor and fluent API styles.
+
+    Example (constructor style):
+        ```python
+        from flowyml import Pipeline, step, If
+
+
+        @step(outputs=["accuracy"])
+        def evaluate_model():
+            return 0.95
+
+
+        @step
+        def deploy_model():
+            print("Deploying...")
+
+
+        @step
+        def retrain_model():
+            print("Retraining...")
+
+
+        pipeline = Pipeline("conditional_deploy")
+        pipeline.add_step(evaluate_model)
+        pipeline.add_control_flow(
+            If(
+                condition=lambda ctx: ctx.steps["evaluate_model"].outputs["accuracy"] > 0.9,
+                then_step=deploy_model,
+                else_step=retrain_model,
+            )
+        )
+        ```
+
+    Example (fluent style):
+        ```python
+        pipeline.add_control_flow(
+            If(condition=lambda ctx: ctx["accuracy"] > 0.95).then(deploy_to_prod).else_(notify_slack_failure)
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        condition: Callable[[Any], bool],
+        then_step: Callable | None = None,
+        else_step: Callable | None = None,
+    ):
+        """Initialize If condition.
+
+        Args:
+            condition: Function that takes a context object and returns bool
+            then_step: Step to execute if condition is True (optional, can use .then() instead)
+            else_step: Step to execute if condition is False (optional, can use .else_() instead)
+        """
+        self.condition = condition
+        self.then_step = then_step
+        self.else_step = else_step
+
+    def then(self, step: Callable) -> "If":
+        """Set the step to execute if condition is True (fluent API).
+
+        Args:
+            step: Step function to execute
+
+        Returns:
+            Self for method chaining
+        """
+        self.then_step = step
+        return self
+
+    def else_(self, step: Callable) -> "If":
+        """Set the step to execute if condition is False (fluent API).
+
+        Args:
+            step: Step function to execute
+
+        Returns:
+            Self for method chaining
+        """
+        self.else_step = step
+        return self
+
+    def evaluate(self, context: Any) -> Callable | None:
+        """Evaluate condition and return the step to execute.
+
+        Args:
+            context: Context object with step outputs and other data
+
+        Returns:
+            Step function to execute, or None if no step should execute
+        """
+        try:
+            if self.condition(context):
+                return self.then_step
+            else:
+                return self.else_step
+        except Exception:
+            # If condition evaluation fails, return else_step as fallback
+            return self.else_step