FlowerPower 0.11.6.20__py3-none-any.whl → 0.21.0__py3-none-any.whl

flowerpower/pipeline/manager.py

@@ -2,12 +2,12 @@ import datetime as dt
 import os
 import posixpath
 import sys
+import warnings
 from pathlib import Path
 from types import TracebackType
 from typing import Any, Callable, TypeVar, Union
 from uuid import UUID
 
-import duration_parser
 from loguru import logger
 from munch import Munch
 
@@ -16,21 +16,19 @@ try:
 except ImportError:
     Digraph = Any  # Type alias for when graphviz isn't installed
 
-from .. import settings
+from fsspec_utils import AbstractFileSystem, BaseStorageOptions, filesystem
+
+from ..settings import CONFIG_DIR, PIPELINES_DIR, CACHE_DIR
 from ..cfg import PipelineConfig, ProjectConfig
 from ..cfg.pipeline.adapter import AdapterConfig as PipelineAdapterConfig
-from ..cfg.pipeline.run import ExecutorConfig, WithAdapterConfig
+from ..cfg.pipeline.run import ExecutorConfig, RunConfig, WithAdapterConfig
 from ..cfg.project.adapter import AdapterConfig as ProjectAdapterConfig
-from ..fs import AbstractFileSystem, BaseStorageOptions, get_filesystem
-from ..utils.callback import run_with_callback
 from ..utils.logging import setup_logging
 from .io import PipelineIOManager
-from .job_queue import PipelineJobQueue
 from .registry import HookType, PipelineRegistry
-from .runner import run_pipeline
 from .visualizer import PipelineVisualizer
 
-setup_logging(level=settings.LOG_LEVEL)
+setup_logging()
 
 GraphType = TypeVar("GraphType")  # Type variable for graphviz.Digraph
 
@@ -66,7 +64,6 @@ class PipelineManager:
         >>> # Create manager with custom settings
         >>> manager = PipelineManager(
         ...     base_dir="/path/to/project",
-        ...     job_queue_type="rq",
         ...     log_level="DEBUG"
         ... )
     """
@@ -76,9 +73,9 @@ class PipelineManager:
         base_dir: str | None = None,
         storage_options: dict | Munch | BaseStorageOptions | None = None,
         fs: AbstractFileSystem | None = None,
-        cfg_dir: str | None = settings.CONFIG_DIR,
-        pipelines_dir: str | None = settings.PIPELINES_DIR,
-        job_queue_type: str | None = None,
+        cfg_dir: str | None = CONFIG_DIR,
+        pipelines_dir: str | None = PIPELINES_DIR,
+        
         log_level: str | None = None,
     ) -> None:
         """Initialize the PipelineManager.
@@ -97,8 +94,7 @@ class PipelineManager:
                 Example: "config" or "settings".
             pipelines_dir: Override default pipelines directory name ('pipelines').
                 Example: "flows" or "dags".
-            job_queue_type: Override worker type from project config/settings.
-                Valid values: "rq", "apscheduler", or "huey".
+            
             log_level: Set logging level for the manager.
                 Valid values: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
 
@@ -118,7 +114,7 @@ class PipelineManager:
             ...         "key": "ACCESS_KEY",
             ...         "secret": "SECRET_KEY"
             ...     },
-            ...     job_queue_type="rq",
+            
             ...     log_level="DEBUG"
             ... )
         """
@@ -130,7 +126,7 @@ class PipelineManager:
         if storage_options is not None:
             cached = True
             cache_storage = posixpath.join(
-                posixpath.expanduser(settings.CACHE_DIR),
+                posixpath.expanduser(CACHE_DIR),
                 self._base_dir.split("://")[-1],
             )
             os.makedirs(cache_storage, exist_ok=True)
@@ -138,7 +134,7 @@ class PipelineManager:
             cached = False
             cache_storage = None
         if not fs:
-            fs = get_filesystem(
+            fs = filesystem(
                 self._base_dir,
                 storage_options=storage_options,
                 cached=cached,
@@ -156,17 +152,20 @@ class PipelineManager:
         self._pipelines_dir = pipelines_dir
 
         self._load_project_cfg(
-            reload=True, job_queue_type=job_queue_type
+            reload=True
         )  # Load project config
-        self._job_queue_type = job_queue_type or self.project_cfg.job_queue.type
+        
 
         # Ensure essential directories exist (using paths from loaded project_cfg)
         try:
             self._fs.makedirs(self._cfg_dir, exist_ok=True)
             self._fs.makedirs(self._pipelines_dir, exist_ok=True)
-        except Exception as e:
+        except (OSError, PermissionError) as e:
             logger.error(f"Error creating essential directories: {e}")
-            # Consider raising an error here depending on desired behavior
+            raise RuntimeError(f"Failed to create essential directories: {e}") from e
+        except Exception as e:
+            logger.error(f"Unexpected error creating essential directories: {e}")
+            raise RuntimeError(f"Unexpected filesystem error: {e}") from e
 
         # Ensure pipeline modules can be imported
         self._add_modules_path()
@@ -175,22 +174,12 @@ class PipelineManager:
         self.registry = PipelineRegistry(
             project_cfg=self.project_cfg,
             fs=self._fs,
-            cfg_dir=self._cfg_dir,
-            pipelines_dir=self._pipelines_dir,
-        )
-        pipeline_job_queue = PipelineJobQueue(
-            project_cfg=self.project_cfg,
-            fs=self._fs,
-            cfg_dir=self._cfg_dir,
-            pipelines_dir=self._pipelines_dir,
+            base_dir=self._base_dir,
+            storage_options=self._storage_options,
         )
-        if pipeline_job_queue.job_queue is None:
-            logger.warning(
-                "Job queue backend is unavailable. Some features may not work."
-            )
-            self.jqm = None
-        else:
-            self.jqm = pipeline_job_queue
+
+        # Initialize project context (will be injected by FlowerPowerProject)
+        self._project_context = None
         self.visualizer = PipelineVisualizer(project_cfg=self.project_cfg, fs=self._fs)
         self.io = PipelineIOManager(registry=self.registry)
 
@@ -241,49 +230,6 @@ class PipelineManager:
         # Add cleanup code if needed
         pass
 
-    def _get_run_func(
-        self,
-        name: str,
-        reload: bool = False,
-        on_success: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_failure: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-    ) -> Callable:
-        """Create a PipelineRunner instance and return its run method.
-
-        This internal helper method ensures that each job gets a fresh runner
-        with the correct configuration state.
-
-        Args:
-            name: Name of the pipeline to create runner for
-            reload: Whether to reload pipeline configuration
-
-        Returns:
-            Callable: Bound run method from a fresh PipelineRunner instance
-
-        Example:
-            >>> # Internal usage
-            >>> manager = PipelineManager()
-            >>> run_func = manager._get_run_func_for_job("data_pipeline")
-            >>> result = run_func(inputs={"date": "2025-04-28"})
-        """
-        if (
-            name == self._current_pipeline_name and not reload
-            # and hasattr(self, "_runner")
-        ):
-            # run_pipeline_ = partial(run_pipeline, project_cfg=self.project_cfg, pipeline_cfg=self._pipeline_cfg)
-            run_func = run_with_callback(on_success=on_success, on_failure=on_failure)(
-                run_pipeline
-            )
-            return run_func
-
-        _ = self.load_pipeline(name=name, reload=reload)
-        # run_pipeline_ = partial(run_pipeline, project_cfg=self.project_cfg, pipeline_cfg=pipeline_cfg)
-
-        run_func = run_with_callback(on_success=on_success, on_failure=on_failure)(
-            run_pipeline
-        )
-        return run_func
-
     def _add_modules_path(self) -> None:
         """Add pipeline module paths to Python path.
 
@@ -318,7 +264,7 @@ class PipelineManager:
             sys.path.insert(0, modules_path)
 
     def _load_project_cfg(
-        self, reload: bool = False, job_queue_type: str | None = None
+        self, reload: bool = False
     ) -> ProjectConfig:
         """Load or reload the project configuration.
 
@@ -342,8 +288,8 @@ class PipelineManager:
             >>> # Internal usage
             >>> manager = PipelineManager()
             >>> project_cfg = manager._load_project_cfg(reload=True)
-            >>> print(project_cfg.worker.type)
-            'rq'
+            >>> print(project_cfg.name)
+            'my_project'
         """
         if hasattr(self, "_project_cfg") and not reload:
             return self._project_cfg
@@ -351,7 +297,6 @@ class PipelineManager:
         # Pass overrides to ProjectConfig.load
         self._project_cfg = ProjectConfig.load(
             base_dir=self._base_dir,
-            job_queue_type=job_queue_type,
             fs=self._fs,  # Pass pre-configured fs if provided
             storage_options=self._storage_options,
         )
@@ -426,8 +371,8 @@ class PipelineManager:
         Example:
             >>> manager = PipelineManager()
             >>> cfg = manager.project_cfg
-            >>> print(cfg.worker.type)
-            'rq'
+            >>> print(cfg.name)
+            'my_project'
         """
         if not hasattr(self, "_project_cfg"):
             self._load_project_cfg()
@@ -457,26 +402,82 @@ class PipelineManager:
 
     # --- Core Execution Method ---
 
+    def _merge_run_config_with_kwargs(self, run_config: RunConfig, kwargs: dict) -> RunConfig:
+        """Merge kwargs into a RunConfig object.
+        
+        This helper method updates the RunConfig object with values from kwargs,
+        handling different types of attributes appropriately.
+        
+        Args:
+            run_config: The RunConfig object to update
+            kwargs: Dictionary of additional parameters to merge
+            
+        Returns:
+            RunConfig: Updated RunConfig object
+        """
+        # Handle dictionary-like attributes with update or deep merge
+        if 'inputs' in kwargs and kwargs['inputs'] is not None:
+            if run_config.inputs is None:
+                run_config.inputs = kwargs['inputs']
+            else:
+                run_config.inputs.update(kwargs['inputs'])
+                
+        if 'config' in kwargs and kwargs['config'] is not None:
+            if run_config.config is None:
+                run_config.config = kwargs['config']
+            else:
+                run_config.config.update(kwargs['config'])
+                
+        if 'cache' in kwargs and kwargs['cache'] is not None:
+            run_config.cache = kwargs['cache']
+            
+        if 'adapter' in kwargs and kwargs['adapter'] is not None:
+            if run_config.adapter is None:
+                run_config.adapter = kwargs['adapter']
+            else:
+                run_config.adapter.update(kwargs['adapter'])
+        
+        # Handle executor_cfg - convert string/dict to ExecutorConfig if needed
+        if 'executor_cfg' in kwargs and kwargs['executor_cfg'] is not None:
+            executor_cfg = kwargs['executor_cfg']
+            if isinstance(executor_cfg, str):
+                run_config.executor = ExecutorConfig(type=executor_cfg)
+            elif isinstance(executor_cfg, dict):
+                run_config.executor = ExecutorConfig.from_dict(executor_cfg)
+            elif isinstance(executor_cfg, ExecutorConfig):
+                run_config.executor = executor_cfg
+        
+        # Handle adapter configurations
+        if 'with_adapter_cfg' in kwargs and kwargs['with_adapter_cfg'] is not None:
+            with_adapter_cfg = kwargs['with_adapter_cfg']
+            if isinstance(with_adapter_cfg, dict):
+                run_config.with_adapter = WithAdapterConfig.from_dict(with_adapter_cfg)
+            elif isinstance(with_adapter_cfg, WithAdapterConfig):
+                run_config.with_adapter = with_adapter_cfg
+                
+        if 'pipeline_adapter_cfg' in kwargs and kwargs['pipeline_adapter_cfg'] is not None:
+            run_config.pipeline_adapter_cfg = kwargs['pipeline_adapter_cfg']
+            
+        if 'project_adapter_cfg' in kwargs and kwargs['project_adapter_cfg'] is not None:
+            run_config.project_adapter_cfg = kwargs['project_adapter_cfg']
+        
+        # Handle simple attributes
+        simple_attrs = [
+            'final_vars', 'reload', 'log_level', 'max_retries', 'retry_delay',
+            'jitter_factor', 'retry_exceptions', 'on_success', 'on_failure'
+        ]
+        
+        for attr in simple_attrs:
+            if attr in kwargs and kwargs[attr] is not None:
+                setattr(run_config, attr, kwargs[attr])
+        
+        return run_config
+
     def run(
         self,
         name: str,
-        inputs: dict | None = None,
-        final_vars: list[str] | None = None,
-        config: dict | None = None,
-        cache: dict | None = None,
-        executor_cfg: str | dict | ExecutorConfig | None = None,
-        with_adapter_cfg: dict | WithAdapterConfig | None = None,
-        pipeline_adapter_cfg: dict | PipelineAdapterConfig | None = None,
-        project_adapter_cfg: dict | ProjectAdapterConfig | None = None,
-        adapter: dict[str, Any] | None = None,
-        reload: bool = False,
-        log_level: str | None = None,
-        max_retries: int | None = None,
-        retry_delay: float | None = None,
-        jitter_factor: float | None = None,
-        retry_exceptions: tuple | list | None = None,
-        on_success: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_failure: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
+        run_config: RunConfig | None = None,
+        **kwargs
     ) -> dict[str, Any]:
         """Execute a pipeline synchronously and return its results.
 
@@ -485,33 +486,36 @@ class PipelineManager:
 
         Args:
             name (str): Name of the pipeline to run. Must be a valid identifier.
-            inputs (dict | None): Override pipeline input values. Example: {"data_date": "2025-04-28"}
-            final_vars (list[str] | None): Specify which output variables to return.
-                Example: ["model", "metrics"]
-            config (dict | None): Configuration for Hamilton pipeline executor.
-                Example: {"model": "LogisticRegression"}
-            cache (dict | None): Cache configuration for results. Example: {"recompute": ["node1", "final_node"]}
-            executor_cfg (str | dict | ExecutorConfig | None): Execution configuration, can be:
-                - str: Executor name, e.g. "threadpool", "local"
-                - dict: Raw config, e.g. {"type": "threadpool", "max_workers": 4}
-                - ExecutorConfig: Structured config object
-            with_adapter_cfg (dict | WithAdapterConfig | None): Adapter settings for pipeline execution.
-                Example: {"opentelemetry": True, "tracker": False}
-             pipeline_adapter_cfg (dict | PipelineAdapterConfig | None): Pipeline-specific adapter settings.
-                Example: {"tracker": {"project_id": "123", "tags": {"env": "prod"}}}
-            project_adapter_cfg (dict | ProjectAdapterConfig | None): Project-level adapter settings.
-                Example: {"opentelemetry": {"host": "http://localhost:4317"}}
-            adapter (dict[str, Any] | None): Custom adapter instance for pipeline
-                Example: {"ray_graph_adapter": RayGraphAdapter()}
-            reload (bool): Force reload of pipeline configuration.
-            log_level (str | None): Logging level for the execution. Default None uses project config.
-                Valid values: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
-            max_retries (int): Maximum number of retries for execution.
-            retry_delay (float): Delay between retries in seconds.
-            jitter_factor (float): Random jitter factor to add to retry delay
-            retry_exceptions (tuple): Exceptions that trigger a retry.
-            on_success (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful pipeline execution.
-            on_failure (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on pipeline execution failure.
+            run_config (RunConfig | None): Run configuration object containing all execution parameters.
+                If None, the default configuration from the pipeline will be used.
+            **kwargs: Additional parameters to override the run_config. Supported parameters include:
+                inputs (dict | None): Override pipeline input values. Example: {"data_date": "2025-04-28"}
+                final_vars (list[str] | None): Specify which output variables to return.
+                    Example: ["model", "metrics"]
+                config (dict | None): Configuration for Hamilton pipeline executor.
+                    Example: {"model": "LogisticRegression"}
+                cache (dict | None): Cache configuration for results. Example: {"recompute": ["node1", "final_node"]}
+                executor_cfg (str | dict | ExecutorConfig | None): Execution configuration, can be:
+                    - str: Executor name, e.g. "threadpool", "local"
+                    - dict: Raw config, e.g. {"type": "threadpool", "max_workers": 4}
+                    - ExecutorConfig: Structured config object
+                with_adapter_cfg (dict | WithAdapterConfig | None): Adapter settings for pipeline execution.
+                    Example: {"opentelemetry": True, "tracker": False}
+                pipeline_adapter_cfg (dict | PipelineAdapterConfig | None): Pipeline-specific adapter settings.
+                    Example: {"tracker": {"project_id": "123", "tags": {"env": "prod"}}}
+                project_adapter_cfg (dict | ProjectAdapterConfig | None): Project-level adapter settings.
+                    Example: {"opentelemetry": {"host": "http://localhost:4317"}}
+                adapter (dict[str, Any] | None): Custom adapter instance for pipeline
+                    Example: {"ray_graph_adapter": RayGraphAdapter()}
+                reload (bool): Force reload of pipeline configuration.
+                log_level (str | None): Logging level for the execution. Default None uses project config.
+                    Valid values: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
+                max_retries (int): Maximum number of retries for execution.
+                retry_delay (float): Delay between retries in seconds.
+                jitter_factor (float): Random jitter factor to add to retry delay
+                retry_exceptions (tuple): Exceptions that trigger a retry.
+                on_success (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful pipeline execution.
+                on_failure (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on pipeline execution failure.
 
         Returns:
             dict[str, Any]: Pipeline execution results, mapping output variable names
@@ -530,46 +534,49 @@ class PipelineManager:
             >>> # Basic pipeline run
             >>> results = manager.run("data_pipeline")
             >>>
-            >>> # Complex run with overrides
+            >>> # Run with custom RunConfig
+            >>> from flowerpower.cfg.pipeline.run import RunConfig
+            >>> config = RunConfig(inputs={"date": "2025-04-28"}, final_vars=["result"])
+            >>> results = manager.run("ml_pipeline", run_config=config)
+            >>>
+            >>> # Complex run with kwargs overrides
             >>> results = manager.run(
-            ...     name="ml_pipeline",
-            ...     inputs={
-            ...         "training_date": "2025-04-28",
-            ...         "model_params": {"n_estimators": 100}
-            ...     },
+            ...     "ml_pipeline",
+            ...     inputs={"training_date": "2025-04-28"},
             ...     final_vars=["model", "metrics"],
             ...     executor_cfg={"type": "threadpool", "max_workers": 4},
             ...     with_adapter_cfg={"tracker": True},
             ...     reload=True
             ... )
         """
-        # pipeline_cfg = self._load_pipeline_cfg(name=name, reload=reload)
-        run_func = self._get_run_func(
-            name=name, reload=reload, on_success=on_success, on_failure=on_failure
+        # Initialize run_config - use provided config or load pipeline default
+        if run_config is None:
+            run_config = self.load_pipeline(name=name).run
+        
+        # Merge kwargs into run_config
+        if kwargs:
+            run_config = self._merge_run_config_with_kwargs(run_config, kwargs)
+
+        # Set up logging for this specific run if log_level is provided
+        if run_config.log_level is not None:
+            setup_logging(level=run_config.log_level)
+        else:
+            # Ensure logging is reset to default if no specific level is provided for this run
+            setup_logging()
+            
+        # Use injected project context, fallback to self for backward compatibility
+        project_context = getattr(self, "_project_context", self)
+
+        # Get Pipeline instance from registry
+        pipeline = self.registry.get_pipeline(
+            name=name, project_context=project_context, reload=run_config.reload
         )
 
-        res = run_func(
-            project_cfg=self._project_cfg,
-            pipeline_cfg=self._pipeline_cfg,
-            inputs=inputs,
-            final_vars=final_vars,
-            config=config,
-            cache=cache,
-            executor_cfg=executor_cfg,
-            with_adapter_cfg=with_adapter_cfg,
-            pipeline_adapter_cfg=pipeline_adapter_cfg,
-            project_adapter_cfg=project_adapter_cfg,
-            adapter=adapter,
-            # reload=reload,  # Runner handles module reload if needed
-            log_level=log_level,
-            max_retries=max_retries,
-            retry_delay=retry_delay,
-            jitter_factor=jitter_factor,
-            retry_exceptions=retry_exceptions,
+        # Execute pipeline using its own run method
+        return pipeline.run(
+            run_config=run_config,
         )
 
-        return res
-
     # --- Delegated Methods ---
 
     # Registry Delegations
@@ -1213,571 +1220,3 @@ class PipelineManager:
         return self.visualizer.show_dag(
             name=name, format=format, reload=reload, raw=raw
         )
-
-    def run_job(
-        self,
-        name: str,
-        inputs: dict | None = None,
-        final_vars: list[str] | None = None,
-        config: dict | None = None,
-        cache: bool | dict = False,
-        executor_cfg: str | dict | ExecutorConfig | None = None,
-        with_adapter_cfg: dict | WithAdapterConfig | None = None,
-        pipeline_adapter_cfg: dict | PipelineAdapterConfig | None = None,
-        project_adapter_cfg: dict | ProjectAdapterConfig | None = None,
-        adapter: dict[str, Any] | None = None,
-        reload: bool = False,
-        log_level: str | None = None,
-        max_retries: int | None = None,
-        retry_delay: float | None = None,
-        jitter_factor: float | None = None,
-        retry_exceptions: tuple | list | None = None,
-        on_success: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_failure: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_success_pipeline: Callable
-        | tuple[Callable, tuple | None, dict | None]
-        | None = None,
-        on_failure_pipeline: Callable
-        | tuple[Callable, tuple | None, dict | None]
-        | None = None,
-        **kwargs: Any,
-    ) -> dict[str, Any] | None:
-        """Execute a pipeline job immediately through the job queue.
-
-        Unlike the run() method which executes synchronously, this method runs
-        the pipeline through the configured worker system (RQ, APScheduler, etc.).
-
-        If the job queue is not configured, it logs an error and returns None.
-
-        Args:
-            name (str): Name of the pipeline to run. Must be a valid identifier.
-            inputs (dict | None): Override pipeline input values. Example: {"data_date": "2025-04-28"}
-            final_vars (list[str] | None): Specify which output variables to return.
-                Example: ["model", "metrics"]
-            config (dict | None): Configuration for Hamilton pipeline executor.
-                Example: {"model": "LogisticRegression"}
-            cache (dict | None): Cache configuration for results. Example: {"recompute": ["node1", "final_node"]}
-            executor_cfg (str | dict | ExecutorConfig | None): Execution configuration, can be:
-                - str: Executor name, e.g. "threadpool", "local"
-                - dict: Raw config, e.g. {"type": "threadpool", "max_workers": 4}
-                - ExecutorConfig: Structured config object
-            with_adapter_cfg (dict | WithAdapterConfig | None): Adapter settings for pipeline execution.
-                Example: {"opentelemetry": True, "tracker": False}
-             pipeline_adapter_cfg (dict | PipelineAdapterConfig | None): Pipeline-specific adapter settings.
-                Example: {"tracker": {"project_id": "123", "tags": {"env": "prod"}}}
-            project_adapter_cfg (dict | ProjectAdapterConfig | None): Project-level adapter settings.
-                Example: {"opentelemetry": {"host": "http://localhost:4317"}}
-            adapter (dict[str, Any] | None): Custom adapter instance for pipeline
-                Example: {"ray_graph_adapter": RayGraphAdapter()}
-            reload (bool): Force reload of pipeline configuration.
-            log_level (str | None): Logging level for the execution. Default None uses project config.
-                Valid values: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
-            max_retries (int): Maximum number of retries for execution.
-            retry_delay (float): Delay between retries in seconds.
-            jitter_factor (float): Random jitter factor to add to retry delay
-            retry_exceptions (tuple): Exceptions that trigger a retry.
-            on_success (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful job execution.
-                This runs after the pipeline execution through the job queue was executed successfully.
-            on_failure (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on job execution failure.
-                This runs if the job creation or the pipeline execution through the job queue fails or raises an exception.
-            on_success_pipeline (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful pipeline execution.
-                This runs after the pipeline completes successfully.
-            on_failure_pipeline (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on pipeline execution failure.
-                This runs if the pipeline fails or raises an exception.
-
-            **kwargs: JobQueue-specific arguments
-                For RQ:
-                    - queue_name: Queue to use (str)
-                    - retry: Number of retries (int)
-                    - result_ttl: Time to live for the job result (float or timedelta)
-                    - ttl: Time to live for the job (float or timedelta)
-                    - timeout: Time to wait for the job to complete (float or timedelta)
-                    - repeat: Repeat count (int or dict)
-                    - rq_on_failure: Callback function on failure (callable)
-                    - rq_on_success: Callback function on success (callable)
-                    - rq_on_stopped: Callback function on stop (callable)
-                For APScheduler:
-                    - job_executor: Executor type (str)
-
-        Returns:
-            dict[str, Any] | None: Job execution results if successful, otherwise None.
-
-        Raises:
-            ValueError: If pipeline or configuration is invalid
-            RuntimeError: If job execution fails
-
-        Example:
-            >>> from flowerpower.pipeline import PipelineManager
-            >>>
-            >>> manager = PipelineManager()
-            >>>
-            >>> # Simple job execution
-            >>> result = manager.run_job("data_pipeline")
-            >>>
-            >>> # Complex job with retry logic
-            >>> result = manager.run_job(
-            ...     name="ml_training",
-            ...     inputs={"training_date": "2025-04-28"},
-            ...     executor_cfg={"type": "async"},
-            ...     with_adapter_cfg={"enable_tracking": True},
-            ...     retry=3,
-            ...     queue_name="ml_jobs"
-            ... )
-        """
-        if self.jqm is None:
-            logger.error(
-                "This PipelineManager instance does not have a job queue configured. Skipping job execution."
-            )
-            return None
-
-        kwargs["on_success"] = kwargs.get("rq_on_success", None)
-        kwargs["on_failure"] = kwargs.get("rq_on_failure", None)
-        kwargs["on_stopped"] = kwargs.get("rq_on_stopped", None)
-
-        run_func = self._get_run_func(
-            name=name,
-            reload=reload,
-            on_success=on_success_pipeline,
-            on_failure=on_failure_pipeline,
-        )
-        # run_func = run_with_callback(on_success=on_success_pipeline, on_failure=on_failure_pipeline)(
-        #    run_func_
-        # )
-        run_job = run_with_callback(on_success=on_success, on_failure=on_failure)(
-            self.jqm.run_job
-        )
-
-        return run_job(
-            run_func=run_func,
-            pipeline_cfg=self._pipeline_cfg,
-            name=name,
-            inputs=inputs,
-            final_vars=final_vars,
-            config=config,
-            cache=cache,
-            executor_cfg=executor_cfg,
-            with_adapter_cfg=with_adapter_cfg,
-            pipeline_adapter_cfg=pipeline_adapter_cfg,
-            project_adapter_cfg=project_adapter_cfg,
-            adapter=adapter,
-            log_level=log_level,
-            max_retries=max_retries,
-            retry_delay=retry_delay,
-            jitter_factor=jitter_factor,
-            retry_exceptions=retry_exceptions,
-            **kwargs,
-        )
-
-    def add_job(
-        self,
-        name: str,
-        inputs: dict | None = None,
-        final_vars: list[str] | None = None,
-        config: dict | None = None,
-        cache: bool | dict = False,
-        executor_cfg: str | dict | ExecutorConfig | None = None,
-        with_adapter_cfg: dict | WithAdapterConfig | None = None,
-        pipeline_adapter_cfg: dict | PipelineAdapterConfig | None = None,
-        project_adapter_cfg: dict | ProjectAdapterConfig | None = None,
-        adapter: dict[str, Any] | None = None,
-        reload: bool = False,  # Reload config/module before creating run_func
-        log_level: str | None = None,
-        result_ttl: int | dt.timedelta = 0,
-        run_at: dt.datetime | str | None = None,
-        run_in: dt.datetime | str | None = None,
-        max_retries: int = 3,
-        retry_delay: float = 1.0,
-        jitter_factor: float = 0.1,
-        retry_exceptions: tuple = (Exception,),
-        on_success: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_failure: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_success_pipeline: Callable
-        | tuple[Callable, tuple | None, dict | None]
-        | None = None,
-        on_failure_pipeline: Callable
-        | tuple[Callable, tuple | None, dict | None]
-        | None = None,
-        **kwargs,  # JobQueue specific args
-    ) -> str | UUID | None:
-        """Adds a job to the job queue.
-
-        If the job queue is not configured, it logs an error and returns None.
-
-        Args:
-            name (str): Name of the pipeline to run. Must be a valid identifier.
-            inputs (dict | None): Override pipeline input values. Example: {"data_date": "2025-04-28"}
-            final_vars (list[str] | None): Specify which output variables to return.
-                Example: ["model", "metrics"]
-            config (dict | None): Configuration for Hamilton pipeline executor.
-                Example: {"model": "LogisticRegression"}
-            cache (dict | None): Cache configuration for results. Example: {"recompute": ["node1", "final_node"]}
-            executor_cfg (str | dict | ExecutorConfig | None): Execution configuration, can be:
-                - str: Executor name, e.g. "threadpool", "local"
-                - dict: Raw config, e.g. {"type": "threadpool", "max_workers": 4}
-                - ExecutorConfig: Structured config object
-            with_adapter_cfg (dict | WithAdapterConfig | None): Adapter settings for pipeline execution.
-                Example: {"opentelemetry": True, "tracker": False}
-             pipeline_adapter_cfg (dict | PipelineAdapterConfig | None): Pipeline-specific adapter settings.
-                Example: {"tracker": {"project_id": "123", "tags": {"env": "prod"}}}
-            project_adapter_cfg (dict | ProjectAdapterConfig | None): Project-level adapter settings.
-                Example: {"opentelemetry": {"host": "http://localhost:4317"}}
-            adapter (dict[str, Any] | None): Custom adapter instance for pipeline
-                Example: {"ray_graph_adapter": RayGraphAdapter()}
-            reload (bool): Force reload of pipeline configuration.
-            run_at (dt.datetime | str | None): Future date to run the job.
-                Example: datetime(2025, 4, 28, 12, 0)
-                Example str: "2025-04-28T12:00:00" (ISO format)
-            run_in (dt.datetime | str | None): Time interval to run the job.
-                Example: 3600 (every hour in seconds)
-                Example: datetime.timedelta(days=1)
-                Example str: "1d" (1 day)
-            result_ttl (int | dt.timedelta): Time to live for the job result.
-                Example: 3600 (1 hour in seconds)
-            log_level (str | None): Logging level for the execution. Default None uses project config.
-                Valid values: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
-            max_retries (int): Maximum number of retries for execution.
-            retry_delay (float): Delay between retries in seconds.
-            jitter_factor (float): Random jitter factor to add to retry delay
-            retry_exceptions (tuple): Exceptions that trigger a retry.
-            on_success (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful job creation.
-            on_failure (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on job creation failure.
-            on_success_pipeline (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful pipeline execution.
-            on_failure_pipeline (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on pipeline execution failure.
-            **kwargs: Additional keyword arguments passed to the worker's add_job method.
-                For RQ this includes:
-                    - result_ttl: Time to live for the job result (float or timedelta)
-                    - ttl: Time to live for the job (float or timedelta)
-                    - timeout: Time to wait for the job to complete (float or timedelta)
-                    - queue_name: Name of the queue to use (str)
-                    - retry: Number of retries (int)
-                    - repeat: Repeat count (int or dict)
-                    - rq_on_failure: Callback function on failure (callable)
-                    - rq_on_success: Callback function on success (callable)
-                    - rq_on_stopped: Callback function on stop (callable)
-                For APScheduler, this includes:
-                    - job_executor: Job executor to use (str)
-
-        Returns:
-            str | UUID | None: The ID of the job that was added to the job queue, or None if the job queue is not configured.
-
-        Raises:
-            ValueError: If the job ID is not valid or if the job cannot be scheduled.
-
-        Example:
-            >>> from flowerpower.pipeline import PipelineManager
-            >>> pm = PipelineManager()
-            >>> job_id = pm.add_job("example_pipeline", inputs={"input1": 42})
-
-        """
-        if self.jqm is None:
-            logger.error(
-                "This PipelineManager instance does not have a job queue configured. Skipping job execution."
-            )
-            return None
-
-        kwargs["on_success"] = kwargs.get("rq_on_success", None)
-        kwargs["on_failure"] = kwargs.get("rq_on_failure", None)
-        kwargs["on_stopped"] = kwargs.get("rq_on_stopped", None)
-
-        run_func = self._get_run_func(
-            name=name,
-            reload=reload,
-            on_success=on_success_pipeline,
-            on_failure=on_failure_pipeline,
-        )
-
-        run_in = (
-            duration_parser.parse(run_in) if isinstance(run_in, str) else run_in
-        )  # convert to seconds
-        run_at = (
-            dt.datetime.fromisoformat(run_at) if isinstance(run_at, str) else run_at
-        )
-
-        add_job = run_with_callback(on_success=on_success, on_failure=on_failure)(
-            self.jqm.add_job
-        )
-        return add_job(
-            run_func=run_func,
-            pipeline_cfg=self._pipeline_cfg,
-            name=name,  # Pass name for logging
-            # Pass run parameters
-            inputs=inputs,
-            final_vars=final_vars,
-            config=config,
-            cache=cache,
-            executor_cfg=executor_cfg,
-            with_adapter_cfg=with_adapter_cfg,
-            pipeline_adapter_cfg=pipeline_adapter_cfg,
-            project_adapter_cfg=project_adapter_cfg,
-            adapter=adapter,
-            # reload=reload,  # Note: reload already happened
-            log_level=log_level,
-            result_ttl=result_ttl,
-            run_at=run_at,
-            run_in=run_in,
-            max_retries=max_retries,
-            retry_delay=retry_delay,
-            jitter_factor=jitter_factor,
-            retry_exceptions=retry_exceptions,
-            **kwargs,  # Pass worker args
-        )
-
-    def schedule(
-        self,
-        name: str,
-        inputs: dict | None = None,
-        final_vars: list[str] | None = None,
-        config: dict | None = None,
-        cache: bool | dict = False,
-        executor_cfg: str | dict | ExecutorConfig | None = None,
-        with_adapter_cfg: dict | WithAdapterConfig | None = None,
-        pipeline_adapter_cfg: dict | PipelineAdapterConfig | None = None,
-        project_adapter_cfg: dict | ProjectAdapterConfig | None = None,
-        adapter: dict[str, Any] | None = None,
-        reload: bool = False,
-        log_level: str | None = None,
-        cron: str | dict[str, str | int] | None = None,
-        interval: int | str | dict[str, str | int] | None = None,
-        date: dt.datetime | str | None = None,
-        overwrite: bool = False,
-        schedule_id: str | None = None,
-        max_retries: int | None = None,
-        retry_delay: float | None = None,
-        jitter_factor: float | None = None,
-        retry_exceptions: tuple | list | None = None,
-        on_success: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_failure: Callable | tuple[Callable, tuple | None, dict | None] | None = None,
-        on_success_pipeline: Callable
-        | tuple[Callable, tuple | None, dict | None]
-        | None = None,
-        on_failure_pipeline: Callable
-        | tuple[Callable, tuple | None, dict | None]
-        | None = None,
-        **kwargs: Any,
-    ) -> str | UUID | None:
-        """Schedule a pipeline to run on a recurring or future basis.
-
-        If the job queue is not configured, it logs an error and returns None.
-
-        Args:
-            name (str): The name of the pipeline to run.
-            inputs (dict | None): Inputs for the pipeline run (overrides config).
-            final_vars (list[str] | None): Final variables for the pipeline run (overrides config).
-            config (dict | None): Hamilton driver config (overrides config).
-            cache (bool | dict): Cache settings (overrides config).
-            executor_cfg (str | dict | ExecutorConfig | None): Executor configuration (overrides config).
-            with_adapter_cfg (dict | WithAdapterConfig | None): Adapter configuration (overrides config).
-            pipeline_adapter_cfg (dict | PipelineAdapterConfig | None): Pipeline adapter configuration (overrides config).
-            project_adapter_cfg (dict | ProjectAdapterConfig | None): Project adapter configuration (overrides config).
-            adapter (dict[str, Any] | None): Additional Hamilton adapters (overrides config).
-            reload (bool): Whether to reload module and pipeline config. Defaults to False.
-            log_level (str | None): Log level for the run (overrides config).
-            cron (str | dict[str, str | int] | None): Cron expression or settings
-                Example string: "0 0 * * *" (daily at midnight)
-                Example dict: {"minute": "0", "hour": "*/2"} (every 2 hours)
-            interval (int | str | dict[str, str | int] | None): Time interval for recurring execution
-                Example int: 3600 (every hour in seconds)
-                Example str: "1h" (every hour)
-                Example dict: {"hours": 1, "minutes": 30} (every 90 minutes)
-            date (dt.datetime | str | None): Future date for
-                Example: datetime(2025, 4, 28, 12, 0)
-                Example str: "2025-04-28T12:00:00" (ISO format)
-            overwrite (bool): Whether to overwrite existing schedule with the same ID
-            schedule_id (str | None): Unique identifier for the schedule
-            max_retries (int): Maximum number of retries for execution
-            retry_delay (float): Delay between retries in seconds
-            jitter_factor (float): Random jitter factor to add to retry delay
-            retry_exceptions (tuple): Exceptions that trigger a retry
-            on_success (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful schedule creation.
-            on_failure (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on schedule creation failure.
-            on_success_pipeline (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on successful pipeline execution.
-            on_failure_pipeline (Callable | tuple[Callable, tuple | None, dict | None] | None): Callback to run on pipeline execution failure.
-            **kwargs: JobQueue-specific scheduling options
-                For RQ:
-                    - result_ttl: Result lifetime (int seconds)
-                    - ttl: Job lifetime (int seconds)
-                    - timeout: Job execution timeout (int seconds)
-                    - queue_name: Queue to use (str)
-                    - repeat: Repeat count (int or dict)
-                    - rq_on_failure: Callback function on failure (callable)
-                    - rq_on_success: Callback function on success (callable)
-                    - rq_on_stopped: Callback function on stop (callable)
-                For APScheduler:
-                    - misfire_grace_time: Late execution window
-                    - coalesce: Combine missed executions (bool)
-                    - max_running_jobs: Concurrent instances limit (int)
-
-        Returns:
-            str | UUID | None: Unique identifier for the created schedule, or None if scheduling fails.
-
-        Raises:
-            ValueError: If schedule parameters are invalid
-            RuntimeError: If scheduling fails
-
-        Example:
-            >>> from flowerpower.pipeline import PipelineManager
-            >>> from datetime import datetime, timedelta
-            >>>
-            >>> manager = PipelineManager()
-            >>>
-            >>> # Daily schedule with cron
-            >>> schedule_id = manager.schedule(
-            ...     name="daily_metrics",
-            ...     cron="0 0 * * *",
-            ...     inputs={"date": "{{ execution_date }}"}
-            ... )
-            >>>
-            >>> # Interval-based schedule
-            >>> schedule_id = manager.schedule(
-            ...     name="monitoring",
-            ...     interval={"minutes": 15},
-            ...     with_adapter_cfg={"enable_alerts": True}
-            ... )
-            >>>
-            >>> # Future one-time execution
-            >>> future_date = datetime.now() + timedelta(days=1)
-            >>> schedule_id = manager.schedule(
-            ...     name="batch_process",
-            ...     date=future_date,
-            ...     executor_cfg={"type": "async"}
-            ... )
-        """
-        if self.jqm is None:
-            logger.error(
-                "This PipelineManager instance does not have a job queue configured. Skipping job execution."
-            )
-            return None
-
-        kwargs["on_success"] = kwargs.get("rq_on_success", None)
-        kwargs["on_failure"] = kwargs.get("rq_on_failure", None)
-        kwargs["on_stopped"] = kwargs.get("rq_on_stopped", None)
-
-        # pipeline_cfg = self._load_pipeline_cfg(name=name, reload=reload)
-        run_func = self._get_run_func(
-            name=name,
-            reload=reload,
-            on_success=on_success_pipeline,
-            on_failure=on_failure_pipeline,
-        )
-        interval = (
-            duration_parser.parse(interval) if isinstance(interval, str) else interval
-        )
-        date = dt.datetime.fromisoformat(date) if isinstance(date, str) else date
-
-        schedule = run_with_callback(on_success=on_success, on_failure=on_failure)(
-            self.jqm.schedule
-        )
-        return schedule(
-            run_func=run_func,
-            pipeline_cfg=self._pipeline_cfg,
-            inputs=inputs,
-            final_vars=final_vars,
-            config=config,
-            cache=cache,
-            executor_cfg=executor_cfg,
-            with_adapter_cfg=with_adapter_cfg,
-            pipeline_adapter_cfg=pipeline_adapter_cfg,
-            project_adapter_cfg=project_adapter_cfg,
-            adapter=adapter,
-            reload=reload,
-            log_level=log_level,
-            cron=cron,
-            interval=interval,
-            date=date,
-            overwrite=overwrite,
-            schedule_id=schedule_id,
-            max_retries=max_retries,
-            retry_delay=retry_delay,
-            jitter_factor=jitter_factor,
-            retry_exceptions=retry_exceptions,
-            **kwargs,
-        )
-
-    def schedule_all(self, **kwargs: Any) -> None:
-        """Schedule all pipelines that are enabled in their configuration.
-
-        For each enabled pipeline, applies its configured schedule settings
-        and any provided overrides.
-
-        Args:
-            **kwargs: Overrides for schedule settings that apply to all pipelines.
-                See schedule() method for supported arguments.
-
-        Example:
-            >>> from flowerpower.pipeline import PipelineManager
-            >>>
-            >>> manager = PipelineManager()
-            >>>
-            >>> # Schedule all with default settings
-            >>> manager.schedule_all()
-            >>>
-            >>> # Schedule all with common overrides
-            >>> manager.schedule_all(
-            ...     max_running_jobs=2,
-            ...     coalesce=True,
-            ...     misfire_grace_time=300
-            ... )
-        """
-        scheduled_ids = []
-        errors = []
-        pipeline_names = self.list_pipelines()
-        if not pipeline_names:
-            logger.warning("No pipelines found to schedule.")
-            return
-
-        logger.info(f"Attempting to schedule {len(pipeline_names)} pipelines...")
-        for name in pipeline_names:
-            try:
-                pipeline_cfg = self.load_pipeline(name=name, reload=True)
-
-                if not pipeline_cfg.schedule.enabled:
-                    logger.info(
-                        f"Skipping scheduling for '{name}': Not enabled in config."
-                    )
-                    continue
-
-                logger.info(f"Scheduling [cyan]{name}[/cyan]...")
-                schedule_id = self.schedule(name=name, reload=False, **kwargs)
-                if schedule_id is None:
-                    logger.info(
-                        f"🟡 Skipping adding schedule for [cyan]{name}[/cyan]: Job queue backend not available or scheduling failed."
-                    )
-                    continue
-                scheduled_ids.append(schedule_id)
-            except Exception as e:
-                logger.error(f"Failed to schedule pipeline '{name}': {e}")
-                errors.append(name)
-
-        if errors:
-            logger.error(f"Finished scheduling with errors for: {', '.join(errors)}")
-        else:
-            logger.info(f"Successfully scheduled {len(scheduled_ids)} pipelines.")
-
-    @property
-    def schedules(self) -> list[Any]:
-        """Get list of current pipeline schedules.
-
-        Retrieves all active schedules from the worker system.
-
-        Returns:
-            list[Any]: List of schedule objects. Exact type depends on worker:
-                - RQ: List[rq.job.Job]
-                - APScheduler: List[apscheduler.schedulers.base.Schedule]
-
-        Example:
-            >>> from flowerpower.pipeline import PipelineManager
-            >>>
-            >>> manager = PipelineManager()
-            >>> for schedule in manager.schedules:
-            ...     print(f"{schedule.id}: Next run at {schedule.next_run_time}")
-        """
-        if self.jqm is None:
-            logger.error(
-                "This PipelineManager instance does not have a job queue configured. Skipping schedule retrieval."
-            )
-            return []
-        try:
-            return self.jqm._get_schedules()
-        except Exception as e:
-            logger.error(f"Failed to retrieve schedules: {e}")
-            return []