FlowerPower 0.20.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

flowerpower/utils/logging.py

@@ -1,23 +1,35 @@
+import os
 import sys
 
 from loguru import logger
 
-from ..settings import LOG_LEVEL  # Import the setting
+from ..settings import LOG_LEVEL
 
 
-def setup_logging(level: str = LOG_LEVEL, disable: bool = False) -> None:
+def setup_logging(level: str | None = None) -> None:
     """
     Configures the Loguru logger.
 
-    Removes the default handler and adds a new one targeting stderr
-    with the level specified by the FP_LOG_LEVEL setting.
+    Determines the logging level based on the following precedence:
+    1. The 'level' argument passed to the function.
+    2. The 'FP_LOG_LEVEL' environment variable.
+    3. The 'LOG_LEVEL' from ..settings (which defaults to "CRITICAL").
+
+    If the effective logging level is "CRITICAL", logging for the "flowerpower" module
+    is disabled. Otherwise, logging is enabled and configured.
     """
-    logger.remove()  # Remove the default handler added by Loguru
-    logger.add(
-        sys.stderr,
-        level=level.upper(),  # Use the level from the parameter, ensure it's uppercase
-        format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",  # Example format
-    )
-    if disable:
+    # Remove all existing handlers to prevent duplicate logs
+    logger.remove()
+
+    # Determine the effective logging level
+    effective_level = level or os.getenv("FP_LOG_LEVEL") or LOG_LEVEL
+
+    if effective_level.upper() == "CRITICAL":
         logger.disable("flowerpower")
-    # logger.info(f"Log level set to: {FP_LOG_LEVEL.upper()}")
+    else:
+        logger.enable("flowerpower")
+        logger.add(
+            sys.stderr,
+            level=effective_level.upper(),
+            format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+        )

flowerpower/utils/misc.py

@@ -7,6 +7,7 @@ import time
 from typing import Any
 
 import msgspec
+from fsspec_utils import AbstractFileSystem, filesystem
 
 if importlib.util.find_spec("joblib"):
     from joblib import Parallel, delayed
@@ -228,3 +229,19 @@ def update_nested_dict(
             # Direct update
             result[key] = value
     return result
+
+
+def get_filesystem(fs: AbstractFileSystem | None = None, fs_type: str = "file") -> AbstractFileSystem:
+    """
+    Helper function to get a filesystem instance.
+    
+    Args:
+        fs: An optional filesystem instance to use. If provided, this will be returned directly.
+        fs_type: The type of filesystem to create if fs is None. Defaults to "file".
+        
+    Returns:
+        An AbstractFileSystem instance.
+    """
+    if fs is None:
+        fs = filesystem(fs_type)
+    return fs

flowerpower-0.30.0.dist-info/METADATA

@@ -0,0 +1,451 @@
+Metadata-Version: 2.4
+Name: FlowerPower
+Version: 0.30.0
+Summary: A simple workflow framework for building and managing data processing pipelines
+Author-email: "Volker L." <ligno.blades@gmail.com>
+Project-URL: Homepage, https://github.com/legout/flowerpower
+Project-URL: Bug Tracker, https://github.com/legout/flowerpower/issues
+Keywords: hamilton,workflow,pipeline,scheduler,dask,ray
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: duration-parser>=1.0.1
+Requires-Dist: fsspec>=2024.10.0
+Requires-Dist: fsspec-utils[full]>=0.1.0
+Requires-Dist: humanize>=4.12.2
+Requires-Dist: msgspec>=0.19.0
+Requires-Dist: munch>=4.0.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: rich>=13.9.3
+Requires-Dist: s3fs>=2024.10.0
+Requires-Dist: sf-hamilton-sdk>=0.5.2
+Requires-Dist: sf-hamilton[rich,tqdm,visualization]>=1.69.0
+Requires-Dist: typer>=0.12.3
+Provides-Extra: io
+Requires-Dist: flowerpower-io>=0.1.1; extra == "io"
+Provides-Extra: io-legacy
+Requires-Dist: flowerpower-io[legacy]>=0.1.1; extra == "io-legacy"
+Provides-Extra: opentelemetry
+Requires-Dist: opentelemetry-api>=1.5.0; extra == "opentelemetry"
+Requires-Dist: opentelemetry-sdk>=1.5.0; extra == "opentelemetry"
+Requires-Dist: opentelemetry-exporter-jaeger>=1.21.0; extra == "opentelemetry"
+Provides-Extra: ray
+Requires-Dist: ray>=2.34.0; extra == "ray"
+Provides-Extra: ui
+Requires-Dist: sf-hamilton-ui>=0.0.11; extra == "ui"
+Provides-Extra: openlineage
+Requires-Dist: openlineage-python>=1.32.0; extra == "openlineage"
+Dynamic: license-file
+
+<div align="center">
+  <h1>FlowerPower 🌸 - Build & Orchestrate Data Pipelines</h1>
+  <h3>Simple Workflow Framework - Hamilton = FlowerPower</h3>
+  <img src="./image.png" alt="FlowerPower Logo" width="400" height="300">
+</div>
+
+
+
+[![PyPI version](https://img.shields.io/pypi/v/flowerpower.svg?style=flat-square)](https://pypi.org/project/flowerpower/) <!-- Placeholder -->
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/legout/flowerpower/blob/main/LICENSE)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/legout/flowerpower)
+[![Documentation Status](https://readthedocs.org/projects/flowerpower/badge/?version=latest)](https://legout.github.io/flowerpower/)
+
+
+**FlowerPower** is a Python framework designed for building, configuring, and executing data processing pipelines with ease and flexibility. It promotes a modular, configuration-driven approach, allowing you to focus on your pipeline logic while FlowerPower handles the orchestration.
+
+It leverages the [Hamilton](https://github.com/apache/hamilton) library for defining dataflows in a clean, functional way within your Python pipeline scripts. Pipelines are defined in Python modules and configured using YAML files, making it easy to manage and understand your data workflows.
+FlowerPower provides a unified project interface that makes it easy to work with pipeline execution. It also provides a web UI (Hamilton UI) for monitoring and managing your pipelines.
+FlowerPower is designed to be extensible, allowing you to easily add custom I/O plugins and adapt to different deployment scenarios. This flexibility makes it suitable for a wide range of data processing tasks, from simple ETL jobs to complex data workflows.
+
+
+## ✨ Key Features
+
+*   **Modular Pipeline Design:** Thanks to [Hamilton](https://github.com/apache/hamilton), you can define your data processing logic in Python modules, using functions as nodes in a directed acyclic graph (DAG).
+*   **Configuration-Driven:** Define pipeline parameters, execution logic, and scheduling declaratively using simple YAML files.
+*   **Extensible I/O Plugins:** Connect to various data sources and destinations (CSV, JSON, Parquet, DeltaTable, DuckDB, PostgreSQL, MySQL, MSSQL, Oracle, MQTT, SQLite, and more).
+*   **Unified Project Interface:** Interact with your pipelines via:
+    *   **FlowerPowerProject API:** A unified interface for pipeline execution, supporting both `RunConfig` objects and flexible `**kwargs` overrides.
+    *   **Command Line Interface (CLI):** For running, managing, and inspecting pipelines, with enhanced `run` command capabilities.
+    *   **Web UI:** A graphical interface for monitoring and managing pipelines and schedules. ([Hamilton UI](https://hamilton.dagworks.io/en/latest/hamilton-ui/ui/))
+*   **Filesystem Abstraction:** Simplified file handling with support for local and remote filesystems (e.g., S3, GCS).
+
+## 📦 Installation
+
+We recommend using [uv](https://github.com/astral-sh/uv) for installing FlowerPower and managing your project environments. `uv` is an extremely fast Python package installer and resolver.
+
+```bash
+# Create and activate a virtual environment (recommended)
+uv venv
+source .venv/bin/activate # Or .\.venv\Scripts\activate on Windows
+
+# Install FlowerPower
+uv pip install flowerpower
+
+# Optional: Install additional dependencies for specific features
+uv pip install flowerpower[io] # For I/O plugins (CSV, JSON, Parquet, DeltaTable, DuckDB, PostgreSQL, MySQL, MSSQL, Oracle, SQLite)
+uv pip install flowerpower[ui] # For Hamilton UI
+uv pip install flowerpower[all] # Install all optional dependencies
+```
+
+*(Note: Specify required Python versions if known, e.g., Python 3.8+)*
+
+## 🚀 Getting Started
+
+Let's build a simple "Hello World" pipeline.
+
+### 1. Initialize Your Project:
+
+You can quickly set up the standard FlowerPower project structure using the CLI or Python.
+
+**Using the CLI:**
+
+Navigate to your desired parent directory and run:
+```bash
+flowerpower init --name hello-flowerpower-project
+```
+
+
+**Using Python:**
+
+Alternatively, you can initialize programmatically:
+```python
+from flowerpower import FlowerPowerProject
+
+# Initialize a new project
+project = FlowerPowerProject.init(
+    name='hello-flowerpower-project',
+)
+```
+
+This will create a `hello-flowerpower-project` directory with the necessary `conf/` and `pipelines/` subdirectories and default configuration files.
+
+```
+hello-flowerpower-project/
+├── conf/
+│   ├── project.yml
+│   └── pipelines/
+└── pipelines/
+```
+
+Now, navigate into your new project directory:
+
+```bash
+cd hello-flowerpower-project
+```
+
+**Configure Project (`conf/project.yml`):**
+
+Open `conf/project.yml` and define your project name:
+
+```yaml
+name: hello-flowerpower
+# adapter: ... # Optional adapter configurations (e.g., Hamilton Tracker, MLflow), see `conf/project.yml` for details
+```
+
+### 2. Create Your Pipeline
+
+You can create a new pipeline using the CLI or programmatically.
+
+**Using the CLI:**
+
+```bash
+flowerpower pipeline new hello_world
+```
+
+**Using Python:**
+
+You can create pipelines programmatically using the FlowerPowerProject interface:
+
+```python
+from flowerpower import FlowerPowerProject
+
+# Load the project
+project = FlowerPowerProject.load('.')
+
+# Create a new pipeline
+project.pipeline_manager.new(name='hello_world')
+```
+
+This will create a new file `hello_world.py` in the `pipelines/` directory and a corresponding configuration file `hello_world.yml` in `conf/pipelines/`.
+
+**Implement Pipeline (`pipelines/hello_world.py`):**
+
+Open `pipelines/hello_world.py` and write your pipeline logic using Python and Hamilton. FlowerPower makes configuration easily accessible.
+
+```python
+# FlowerPower pipeline hello_world.py
+# Created on 2025-05-03 22:34:09
+
+####################################################################################################
+# Import necessary libraries
+# NOTE: Remove or comment out imports that are not used in the pipeline
+
+from hamilton.function_modifiers import parameterize
+
+from pathlib import Path
+
+from flowerpower.cfg import Config
+
+####################################################################################################
+# Load pipeline parameters. Do not modify this section.
+
+PARAMS = Config.load(
+    Path(__file__).parents[1], pipeline_name="hello_world"
+).pipeline.h_params
+
+
+####################################################################################################
+# Helper functions.
+# This functions have to start with an underscore (_).
+
+
+####################################################################################################
+# Pipeline functions
+
+@parameterize(**PARAMS.greeting_message) # Inject 'message' from params
+def greeting_message(message: str) -> str:
+  """Provides the greeting part."""
+  return f"{message},"
+
+@parameterize(**PARAMS.target_name) # Inject 'name' from params
+def target_name(name: str) -> str:
+  """Provides the target name."""
+  return f"{name}!"
+
+def full_greeting(greeting_message: str, target_name: str) -> str:
+  """Combines the greeting and target."""
+  print(f"Generating greeting: {greeting_message} {target_name}")
+  return f"{greeting_message} {target_name}"
+
+# You can add more complex Hamilton functions here...
+```
+
+**Configure Pipeline (`conf/pipelines/hello_world.yml`):**
+
+Open `conf/pipelines/hello_world.yml` and specify parameters, run configurations, and scheduling for your pipeline.
+
+```yaml
+# adapter: ... # Pipeline-specific adapter overrides
+
+params: # Parameters accessible in your Python code
+  greeting_message:
+    message: "Hello"
+  target_name:
+    name: "World"
+
+run: # How to execute the pipeline
+  final_vars: # Specify the desired output(s) from your Hamilton DAG
+    - full_greeting
+  # inputs: # Optional: Specify input variables to the pipeline
+    # message: "Hello"
+  # config: ... # Runtime configuration overrides for Hamilton
+  # executor: ... # Execution backend (e.g., threadpool, multiprocessing)
+
+```
+### 3. Run Your Pipeline 🏃‍♀️
+
+FlowerPower allows you to execute your pipelines synchronously, with flexible configuration options.
+
+#### Synchronous Execution:
+
+For quick testing or local runs, you can execute your pipeline synchronously. This is useful for debugging or running pipelines in a local environment.
+
+*   **Via CLI:**
+
+    The `flowerpower pipeline run` command now supports `RunConfig` objects (via file path or JSON string) and direct `**kwargs` for overriding.
+
+    ```bash
+    # Basic pipeline execution
+    flowerpower pipeline run hello_world
+
+    # Run with individual parameters (kwargs)
+    flowerpower pipeline run hello_world --inputs '{"greeting_message": "Hi", "target_name": "FlowerPower"}' --final-vars '["full_greeting"]' --log-level DEBUG
+
+    # Run using a RunConfig from a YAML file
+    # Assuming you have a run_config.yaml like:
+    # inputs:
+    #   greeting_message: "Hola"
+    #   target_name: "Amigo"
+    # log_level: "INFO"
+    flowerpower pipeline run hello_world --run-config ./run_config.yaml
+
+    # Run using a RunConfig provided as a JSON string
+    flowerpower pipeline run hello_world --run-config '{"inputs": {"greeting_message": "Bonjour", "target_name": "Monde"}, "log_level": "INFO"}'
+
+    # Mixing RunConfig with individual parameters (kwargs overrides RunConfig)
+    # This will run with log_level="DEBUG" and inputs={"greeting_message": "Howdy", "target_name": "Partner"}
+    flowerpower pipeline run hello_world --run-config '{"inputs": {"greeting_message": "Original", "target_name": "Value"}, "log_level": "INFO"}' --inputs '{"greeting_message": "Howdy", "target_name": "Partner"}' --log-level DEBUG
+    ```
+
+*   **Via Python:**
+
+    The `run` methods (`FlowerPowerProject.run`, `PipelineManager.run`) now primarily accept a `RunConfig` object, but also allow individual parameters to be passed via `**kwargs` which override `RunConfig` attributes.
+
+    ```python
+    from flowerpower import FlowerPowerProject
+    from flowerpower.cfg.pipeline.run import RunConfig
+    from flowerpower.cfg.pipeline.builder import RunConfigBuilder
+
+    # Load the project
+    project = FlowerPowerProject.load('.')
+
+    # Basic execution
+    result = project.run('hello_world')
+    print(result)
+
+    # Using individual parameters (kwargs)
+    result = project.run(
+        'hello_world',
+        inputs={"greeting_message": "Hi", "target_name": "FlowerPower"},
+        final_vars=["full_greeting"],
+        log_level="DEBUG"
+    )
+    print(result)
+
+    # Using RunConfig directly
+    config = RunConfig(
+        inputs={"greeting_message": "Aloha", "target_name": "World"},
+        final_vars=["full_greeting"],
+        log_level="INFO"
+    )
+    result = project.run('hello_world', run_config=config)
+    print(result)
+
+    # Using RunConfigBuilder (recommended)
+    config = (
+        RunConfigBuilder(pipeline_name='hello_world')
+        .with_inputs({"greeting_message": "Greetings", "target_name": "Earth"})
+        .with_final_vars(["full_greeting"])
+        .with_log_level("DEBUG")
+        .with_retries(max_attempts=3, delay=1.0)
+        .build()
+    )
+    result = project.run('hello_world', run_config=config)
+    print(result)
+
+    # Mixing RunConfig with individual parameters (kwargs overrides RunConfig)
+    base_config = RunConfigBuilder().with_log_level("INFO").build()
+    result = project.run(
+        'hello_world',
+        run_config=base_config,
+        inputs={"greeting_message": "Howdy", "target_name": "Partner"}, # Overrides inputs in base_config
+        log_level="DEBUG" # Overrides log_level in base_config
+    )
+    print(result)
+    ```
+
+
+## ⚙️ Configuration Overview
+
+FlowerPower uses a layered configuration system:
+
+*   **`conf/project.yml`:** Defines global settings for your project, including integrated `adapter`s (like Hamilton Tracker, MLflow, etc.).
+*   **`conf/pipelines/*.yml`:** Each file defines a specific pipeline. It contains:
+    *   `params`: Input parameters for your Hamilton functions.
+    *   `run`: Execution details like target outputs (`final_vars`), Hamilton runtime `config`, and `executor` settings.
+    *   `adapter`: Pipeline-specific overrides for adapter settings.
+
+## 🛠️ Basic Usage
+
+You can interact with FlowerPower pipelines through multiple interfaces:
+
+**Python API (Recommended):**
+```python
+from flowerpower import FlowerPowerProject
+from flowerpower.cfg.pipeline.run import RunConfig
+from flowerpower.cfg.pipeline.builder import RunConfigBuilder
+
+# Load the project
+project = FlowerPowerProject.load('.')
+
+# Run a pipeline using RunConfig
+config = RunConfig(inputs={"greeting_message": "Hello", "target_name": "API"})
+result = project.run('hello_world', run_config=config)
+print(result)
+
+# Run a pipeline using kwargs
+result = project.run('hello_world', inputs={"greeting_message": "Hi", "target_name": "Kwargs"})
+print(result)
+```
+
+**CLI:**
+```bash
+# Run a pipeline using RunConfig from a file
+# flowerpower pipeline run hello_world --run-config ./path/to/run_config.yaml
+
+# Run a pipeline using kwargs
+flowerpower pipeline run hello_world --inputs '{"greeting_message": "CLI", "target_name": "Kwargs"}'
+
+# List all available commands
+flowerpower --help
+```
+
+## 🔧 Direct Module Usage
+
+While the unified `FlowerPowerProject` interface is recommended for most use cases, you can also use the pipeline module directly for more granular control or when you only need specific functionality.
+
+### Pipeline-Only Usage
+
+If you only need pipeline execution, you can use the `PipelineManager` directly:
+
+```python
+from flowerpower.pipeline import PipelineManager
+from flowerpower.cfg.pipeline.run import RunConfig
+from flowerpower.cfg.pipeline.builder import RunConfigBuilder
+
+# Initialize pipeline manager
+pm = PipelineManager(base_dir='.')
+
+# Create a new pipeline
+pm.new(name='my_pipeline')
+
+# Run a pipeline synchronously using RunConfig
+config = RunConfig(inputs={'param': 'value'}, final_vars=['output_var'])
+result = pm.run(name='my_pipeline', run_config=config)
+print(result)
+
+# Run a pipeline synchronously using kwargs
+result = pm.run(name='my_pipeline', inputs={'param': 'new_value'}, final_vars=['output_var'])
+print(result)
+
+# List available pipelines
+pipelines = pm.list()
+print(f"Available pipelines: {pipelines}")
+
+# Get pipeline information
+info = pm.get('my_pipeline')
+print(f"Pipeline config: {info}")
+
+# Delete a pipeline
+pm.delete('old_pipeline')
+```
+
+**When to use Pipeline-only approach:**
+- Simple synchronous workflows
+- Testing and development
+- Lightweight applications with minimal dependencies
+
+**Benefits of FlowerPowerProject vs Direct Usage:**
+
+| Approach | Benefits | Use Cases |
+|----------|----------|-----------|
+| **FlowerPowerProject** | - Unified interface<br>- Automatic dependency injection<br>- Simplified configuration<br>- Best practices built-in | - Most applications<br>- Rapid development<br>- Full feature integration |
+| **Pipeline-only** | - Lightweight<br>- Simple synchronous execution | - Testing<br>- Simple workflows |
+
+## 🖥️ UI
+
+The FlowerPower web UI (Hamilton UI) provides a graphical interface for monitoring and managing your pipelines. It allows you to visualize pipeline runs, schedules, and potentially manage configurations.
+
+```bash
+# Start the web UI
+flowerpower ui
+```
+
+## 📖 Documentation
+
+You can find the full documentation for FlowerPower, including installation instructions, usage examples, and API references, at [https://legout.github.io/flowerpower/](https://legout.github.io/flowerpower/).
+
+
+## 📜 License
+
+This project is licensed under the MIT License - see the `LICENSE` file for details. (Placeholder - update with actual license)

flowerpower-0.30.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+flowerpower/__init__.py,sha256=nHFrD6twJyR-Ti6Yn0lLcyXXcKOi0tFfOD96oAu17Js,431
+flowerpower/flowerpower.py,sha256=-taA0uemnoy1B5ugNxzwQ_Jir8jfmaGNXTk_uewaN88,23755
+flowerpower/cfg/__init__.py,sha256=aWeKlBNgJ4LCtWBzZns5RmQm9GN9SpTbozE-NsS2_9w,8481
+flowerpower/cfg/base.py,sha256=IpvCcUvGTjmjN69D34IFNn692hxTwZzYQJ1utgKANWo,4795
+flowerpower/cfg/pipeline/__init__.py,sha256=HSUlDt9smo-zPqOljEl329CQg8qsd0EJfCH1FOtuMdk,9276
+flowerpower/cfg/pipeline/_schedule.py,sha256=kaDyij3eUj0u6VdmJW4x_AQbSAZ-r7s2Fk7QFkXU5JQ,1029
+flowerpower/cfg/pipeline/adapter.py,sha256=uBKV6BZlsRRqSYNyC1oEWPchsaH7rFPCBobG5BrF3ss,2265
+flowerpower/cfg/pipeline/builder.py,sha256=rZ-cspbV-nwtckvOA49vt7DNJNb-gRLHHWiejmJPsFs,13192
+flowerpower/cfg/pipeline/run.py,sha256=cirZbiHsY8D87idBvbfNv1gEtKpgv3xLfiiFIXJFxrA,6733
+flowerpower/cfg/project/__init__.py,sha256=bMMZ5Zo3YgkgOGt82H1mW8I4WnoCUpa0bSLPpZiB7K4,4560
+flowerpower/cfg/project/adapter.py,sha256=2k2U25NziDEiUacLTjxaSxOVkaQBRt6ECWGRGX0v4J0,1481
+flowerpower/cli/__init__.py,sha256=RkJT3mPlSOi55dNNP8kpm_omF0zEfbmWVP16N-lkijE,4897
+flowerpower/cli/cfg.py,sha256=P7qEcjraitMxbzVWJMqWeitIdpUkW41QkUi7ol0ksW0,1455
+flowerpower/cli/pipeline.py,sha256=I58cWjK7J4dkXdJXIePcPiD7iILnYqoje0ztkR5mNwg,21958
+flowerpower/cli/utils.py,sha256=tsxvKIqUhl4m9IzuaSoc5a3_gb6Fu4LYyV8fVodqIdA,5127
+flowerpower/pipeline/__init__.py,sha256=ltr4LQnM5Boa9w7t-lNVmmcSglIkTPuIoeYnEKWU4Og,122
+flowerpower/pipeline/base.py,sha256=oQSDfEAyY2_kDRlHNnHr6ihZvfGeOjyMJRPKob1i7U8,3560
+flowerpower/pipeline/io.py,sha256=phYJhN4LZ0c6d8_udEQ4C9cGzeV3Ku0hsj0gyE1n2UY,16246
+flowerpower/pipeline/manager.py,sha256=gJMWe_T1WpxO2H9GDrNtf61S4oJuLugMHwX82jqAuEU,47579
+flowerpower/pipeline/pipeline.py,sha256=8Vhc3GGoAJI-5zv8qX4gZ5JwJrTdVoiXHWNpv5OeKGw,26207
+flowerpower/pipeline/registry.py,sha256=iHdEBPiRpZorAUe6sDkqONoP8t6cicdQYGdK8UyxuAQ,28791
+flowerpower/pipeline/visualizer.py,sha256=EVpjv-TUe1zGvdEAWyShJcVXurm02W0jkLbj7z1uAv4,4953
+flowerpower/plugins/io/__init__.py,sha256=ZmSdKoh3TavJagOz0vUItnEqAh3mAM1QpAWj0KufF_k,222
+flowerpower/settings/__init__.py,sha256=XKQa8AI9VrX8ievs-suq3Cm6PBt4cJ78ZHVIjUbXCyA,130
+flowerpower/settings/_backend.py,sha256=Up1RBqAs3jtDUOV-9wEpL68Qmom-dRWMOeHXIh0F3lw,4273
+flowerpower/settings/executor.py,sha256=vNF383g1gMGkq_CXUzateGMNcJZig-vHkVVb0Hi_b74,249
+flowerpower/settings/general.py,sha256=RxY6PGF_L8ApFlLPHulZ2I8_-aHYqOj63fUu9kSQTjI,227
+flowerpower/settings/hamilton.py,sha256=GVzWKz3B-wy07etY1mNUstEa4DFrQ_lM2cjE0qG_6qw,623
+flowerpower/settings/logging.py,sha256=BHahxfuiofByiTU8TYQ2AObPDRz9SYH-MalSEu1DRro,71
+flowerpower/settings/retry.py,sha256=W3AAVSxmTUAeeSbzRGA37RxqtKKyUdi2MkwDzCsXP94,181
+flowerpower/utils/callback.py,sha256=sGYSrEbnl0xfRa1X-mA-om3erpH7pmpsWdyPQ9HpU7E,6736
+flowerpower/utils/logging.py,sha256=WUnpoEmr9H5MGFF68jlshhEJcuMtW49M7VVRstmqIAg,1192
+flowerpower/utils/misc.py,sha256=gY1KVJp4lF4S0THUu1LUrjXaf87TzLO-TcwHxZZh2Zk,8414
+flowerpower/utils/monkey.py,sha256=vJMYANjZI13PNbEQThdX0EFP1_6bGNHgnpF7HwReNyM,58
+flowerpower/utils/open_telemetry.py,sha256=fQWJWbIQFtKIxMBjAWeF12NGnqT0isO3A3j-DSOv_vE,949
+flowerpower/utils/templates.py,sha256=ouyEeSDqa9PjW8c32fGpcINlpC0WToawRFZkMPtwsLE,1591
+flowerpower-0.30.0.dist-info/licenses/LICENSE,sha256=9AkLexxrmr0aBgSHiqxpJk9wgazpP1CTJyiDyr56J9k,1063
+flowerpower-0.30.0.dist-info/METADATA,sha256=3nPehMWbDcryhbkgbieU-_13I_8S3-1aNL54bMdjdDs,17208
+flowerpower-0.30.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flowerpower-0.30.0.dist-info/entry_points.txt,sha256=61X11i5a2IwC9LBiP20XCDl5zMOigGCjMCx17B7bDbQ,52
+flowerpower-0.30.0.dist-info/top_level.txt,sha256=VraH4WtEUfSxs5L-rXwDQhzQb9eLHTUtgvmFZ2dAYnA,12
+flowerpower-0.30.0.dist-info/RECORD,,

flowerpower/cfg/pipeline/schedule.py

@@ -1,74 +0,0 @@
-import datetime as dt
-
-import msgspec
-from munch import munchify
-
-from ..base import BaseConfig
-
-# class ScheduleCronTriggerConfig(BaseConfig):
-#     year: str | int | None = None
-#     month: str | int | None = None
-#     week: str | int | None = None
-#     day: str | int | None = None
-#     day_of_week: str | int | None = None
-#     hour: str | int | None = None
-#     minute: str | int | None = None
-#     second: str | int | None = None
-#     start_time: dt.datetime | None = None
-#     end_time: dt.datetime | None = None
-#     timezone: str | None = None
-#     crontab: str | None = None
-
-
-# class ScheduleIntervalTriggerConfig(BaseConfig):
-#     weeks: int | float | None = None
-#     days: int | float | None = None
-#     hours: int | float | None = None
-#     minutes: int | float | None = None
-#     seconds: int | float | None = None
-#     microseconds: int | float | None = None
-#     start_time: dt.datetime | None = None
-#     end_time: dt.datetime | None = None
-
-
-# class ScheduleCalendarTriggerConfig(BaseConfig):
-#     years: int | float | None = None
-#     months: int | float | None = None
-#     weeks: int | float | None = None
-#     days: int | float | None = None
-#     hour: int | float | None = None
-#     minute: int | float | None = None
-#     second: int | float | None = None
-#     start_date: dt.datetime | None = None
-#     end_date: dt.datetime | None = None
-#     timezone: str | None = None
-
-
-# class ScheduleDateTriggerConfig(BaseConfig):
-#     run_time: dt.datetime | None = None
-
-
-class ScheduleConfig(BaseConfig):
-    cron: str | dict | None = msgspec.field(default=None)
-    interval: str | int | dict | None = msgspec.field(default=None)
-    date: str | None = msgspec.field(default=None)
-
-    def __post_init__(self):
-        if isinstance(self.date, str):
-            try:
-                self.date = dt.datetime.fromisoformat(self.date)
-            except ValueError:
-                raise ValueError(
-                    f"Invalid date format: {self.date}. Expected ISO format."
-                )
-        if isinstance(self.cron, dict):
-            self.cron = munchify(self.cron)
-        if isinstance(self.interval, dict):
-            self.interval = munchify(self.interval)
-
-
-# class ScheduleConfig(BaseConfig):
-#     run: ScheduleRunConfig = msgspec.field(default_factory=ScheduleRunConfig)
-#     trigger: ScheduleTriggerConfig = msgspec.field(
-#         default_factory=ScheduleTriggerConfig
-#     )