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

flowerpower/pipeline/pipeline.py

@@ -57,7 +57,7 @@ else:
 
 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
 
 if TYPE_CHECKING:
@@ -90,67 +90,131 @@ class Pipeline(msgspec.Struct):
         if not settings.HAMILTON_AUTOLOAD_EXTENSIONS:
             disable_autoload()
 
+    def _merge_run_config_with_kwargs(self, run_config: RunConfig, kwargs: dict) -> RunConfig:
+        """Merge kwargs into the run_config object.
+        
+        Args:
+            run_config: The base RunConfig object to merge into
+            kwargs: Additional parameters to merge into the run_config
+            
+        Returns:
+            Updated RunConfig object with merged kwargs
+        """
+        from copy import deepcopy
+        
+        # Create a deep copy of the run_config to avoid modifying the original
+        merged_config = deepcopy(run_config)
+        
+        # Handle each possible kwarg
+        for key, value in kwargs.items():
+            if key == 'inputs' and value is not None:
+                if merged_config.inputs is None:
+                    merged_config.inputs = {}
+                merged_config.inputs.update(value)
+            elif key == 'final_vars' and value is not None:
+                if merged_config.final_vars is None:
+                    merged_config.final_vars = []
+                merged_config.final_vars = value
+            elif key == 'config' and value is not None:
+                if merged_config.config is None:
+                    merged_config.config = {}
+                merged_config.config.update(value)
+            elif key == 'cache' and value is not None:
+                merged_config.cache = value
+            elif key == 'executor_cfg' and value is not None:
+                if isinstance(value, str):
+                    merged_config.executor = ExecutorConfig(type=value)
+                elif isinstance(value, dict):
+                    merged_config.executor = ExecutorConfig.from_dict(value)
+                elif isinstance(value, ExecutorConfig):
+                    merged_config.executor = value
+            elif key == 'with_adapter_cfg' and value is not None:
+                if isinstance(value, dict):
+                    merged_config.with_adapter = WithAdapterConfig.from_dict(value)
+                elif isinstance(value, WithAdapterConfig):
+                    merged_config.with_adapter = value
+            elif key == 'pipeline_adapter_cfg' and value is not None:
+                merged_config.pipeline_adapter_cfg = value
+            elif key == 'project_adapter_cfg' and value is not None:
+                merged_config.project_adapter_cfg = value
+            elif key == 'adapter' and value is not None:
+                if merged_config.adapter is None:
+                    merged_config.adapter = {}
+                merged_config.adapter.update(value)
+            elif key == 'reload' and value is not None:
+                merged_config.reload = value
+            elif key == 'log_level' and value is not None:
+                merged_config.log_level = value
+            elif key == 'max_retries' and value is not None:
+                merged_config.max_retries = value
+            elif key == 'retry_delay' and value is not None:
+                merged_config.retry_delay = value
+            elif key == 'jitter_factor' and value is not None:
+                merged_config.jitter_factor = value
+            elif key == 'retry_exceptions' and value is not None:
+                merged_config.retry_exceptions = value
+            elif key == 'on_success' and value is not None:
+                merged_config.on_success = value
+            elif key == 'on_failure' and value is not None:
+                merged_config.on_failure = value
+        
+        return merged_config
+
     def run(
         self,
-        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 = (
-            Exception,
-            HTTPError,
-            UnauthorizedException,
-        ),
-        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 the pipeline with the given parameters.
 
         Args:
-            inputs: Override pipeline input values
-            final_vars: Specify which output variables to return
-            config: Configuration for Hamilton pipeline executor
-            cache: Cache configuration for results
-            executor_cfg: Execution configuration
-            with_adapter_cfg: Adapter settings for pipeline execution
-            pipeline_adapter_cfg: Pipeline-specific adapter configuration
-            project_adapter_cfg: Project-wide adapter configuration
-            adapter: Additional Hamilton adapters
-            reload: Whether to reload the module
-            log_level: Log level for execution
-            max_retries: Maximum number of retry attempts
-            retry_delay: Base delay between retries in seconds
-            jitter_factor: Factor to apply for jitter
-            retry_exceptions: Exceptions to catch for retries
-            on_success: Callback for successful execution
-            on_failure: Callback for failed execution
+            run_config: Run configuration object containing all execution parameters.
+                       If None, uses the pipeline's default configuration.
+            **kwargs: Additional parameters to override or extend the run_config.
 
         Returns:
             The result of executing the pipeline
         """
         start_time = dt.datetime.now()
 
+        # Initialize run_config with pipeline defaults if not provided
+        run_config = run_config or self.config.run
+        
+        # Merge kwargs into the run_config
+        if kwargs:
+            run_config = self._merge_run_config_with_kwargs(run_config, kwargs)
+
         # Reload module if requested
-        if reload:
+        if run_config.reload:
             self._reload_module()
 
-        # Set up configuration with defaults from pipeline config
-        inputs = inputs or self.config.run.inputs or {}
-        final_vars = final_vars or self.config.run.final_vars or []
-        config = {**(self.config.run.config or {}), **(config or {})}
-        cache = cache or self.config.run.cache or {}
-
         # Set up retry configuration
+        retry_config = self._setup_retry_config(
+            run_config.max_retries, run_config.retry_delay, run_config.jitter_factor, run_config.retry_exceptions
+        )
+        max_retries = retry_config["max_retries"]
+        retry_delay = retry_config["retry_delay"]
+        jitter_factor = retry_config["jitter_factor"]
+        retry_exceptions = retry_config["retry_exceptions"]
+
+        # Execute with retry logic
+        return self._execute_with_retry(
+            run_config=run_config,
+            max_retries=max_retries,
+            retry_delay=retry_delay,
+            jitter_factor=jitter_factor,
+            retry_exceptions=retry_exceptions,
+            start_time=start_time,
+        )
+
+    def _setup_retry_config(
+        self,
+        max_retries: int | None,
+        retry_delay: float | None,
+        jitter_factor: float | None,
+        retry_exceptions: tuple | None,
+    ) -> dict:
+        """Set up retry configuration with defaults and validation."""
         max_retries = max_retries or self.config.run.max_retries or 0
         retry_delay = retry_delay or self.config.run.retry_delay or 1.0
         jitter_factor = jitter_factor or self.config.run.jitter_factor or 0.1
@@ -186,25 +250,30 @@ class Pipeline(msgspec.Struct):
         elif not retry_exceptions:
             retry_exceptions = (Exception,)
 
-        # Execute with retry logic
+        return {
+            "max_retries": max_retries,
+            "retry_delay": retry_delay,
+            "jitter_factor": jitter_factor,
+            "retry_exceptions": retry_exceptions,
+        }
+
+    def _execute_with_retry(
+        self,
+        run_config: RunConfig,
+        max_retries: int,
+        retry_delay: float,
+        jitter_factor: float,
+        retry_exceptions: tuple,
+        start_time: dt.datetime,
+    ) -> dict[str, Any]:
+        """Execute pipeline with retry logic."""
         for attempt in range(max_retries + 1):
             try:
                 logger.info(
                     f"🚀 Running pipeline '{self.name}' (attempt {attempt + 1}/{max_retries + 1})"
                 )
 
-                result = self._execute_pipeline(
-                    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,
-                )
+                result = self._execute_pipeline(run_config=run_config)
 
                 end_time = dt.datetime.now()
                 duration = humanize.naturaldelta(end_time - start_time)
@@ -214,8 +283,8 @@ class Pipeline(msgspec.Struct):
                 )
 
                 # Execute success callback if provided
-                if on_success:
-                    self._execute_callback(on_success, result, None)
+                if run_config.on_success:
+                    self._execute_callback(run_config.on_success, result, None)
 
                 return result
 
@@ -239,8 +308,8 @@ class Pipeline(msgspec.Struct):
                     )
 
                     # Execute failure callback if provided
-                    if on_failure:
-                        self._execute_callback(on_failure, None, e)
+                    if run_config.on_failure:
+                        self._execute_callback(run_config.on_failure, None, e)
 
                     raise
             except Exception as e:
@@ -250,39 +319,39 @@ class Pipeline(msgspec.Struct):
                 logger.error(f"❌ Pipeline '{self.name}' failed in {duration}: {e}")
 
                 # Execute failure callback if provided
-                if on_failure:
-                    self._execute_callback(on_failure, None, e)
+                if run_config.on_failure:
+                    self._execute_callback(run_config.on_failure, None, e)
 
                 raise
 
-    def _execute_pipeline(
+    def _setup_execution_context(
         self,
-        inputs: dict,
-        final_vars: list[str],
-        config: dict,
-        cache: dict,
-        executor_cfg: str | dict | ExecutorConfig | None,
-        with_adapter_cfg: dict | WithAdapterConfig | None,
-        pipeline_adapter_cfg: dict | PipelineAdapterConfig | None,
-        project_adapter_cfg: dict | ProjectAdapterConfig | None,
-        adapter: dict[str, Any] | None,
-        log_level: str | None,
-    ) -> dict[str, Any]:
-        """Execute the pipeline with Hamilton."""
+        run_config: RunConfig,
+    ) -> tuple[executors.BaseExecutor, Callable | None, list]:
+        """Set up executor and adapters for pipeline execution."""
         # Get executor and adapters
-        executor, shutdown_func = self._get_executor(executor_cfg)
+        executor, shutdown_func = self._get_executor(run_config.executor)
         adapters = self._get_adapters(
-            with_adapter_cfg=with_adapter_cfg,
-            pipeline_adapter_cfg=pipeline_adapter_cfg,
-            project_adapter_cfg=project_adapter_cfg,
-            adapter=adapter,
+            with_adapter_cfg=run_config.with_adapter,
+            pipeline_adapter_cfg=run_config.pipeline_adapter_cfg,
+            project_adapter_cfg=run_config.project_adapter_cfg,
+            adapter=run_config.adapter,
         )
+        return executor, shutdown_func, adapters
+
+    def _execute_pipeline(
+        self,
+        run_config: RunConfig,
+    ) -> dict[str, Any]:
+        """Execute the pipeline with Hamilton."""
+        # Set up execution context
+        executor, shutdown_func, adapters = self._setup_execution_context(run_config=run_config)
 
         try:
             # Create Hamilton driver
             dr = (
                 driver.Builder()
-                .with_config(config)
+                .with_config(run_config.config)
                 .with_modules(self.module)
                 .with_adapters(*adapters)
                 .build()
@@ -290,8 +359,8 @@ class Pipeline(msgspec.Struct):
 
             # Execute the pipeline
             result = dr.execute(
-                final_vars=final_vars,
-                inputs=inputs,
+                final_vars=run_config.final_vars,
+                inputs=run_config.inputs,
             )
 
             return result
@@ -566,6 +635,9 @@ class Pipeline(msgspec.Struct):
         try:
             importlib.reload(self.module)
             logger.debug(f"Reloaded module for pipeline '{self.name}'")
-        except Exception as e:
+        except (ImportError, ModuleNotFoundError, AttributeError) as e:
             logger.error(f"Failed to reload module for pipeline '{self.name}': {e}")
             raise
+        except Exception as e:
+            logger.error(f"Unexpected error reloading module for pipeline '{self.name}': {e}")
+            raise

flowerpower/pipeline/registry.py

@@ -5,6 +5,7 @@ import datetime as dt
 import os
 import posixpath
 import sys
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict
 
 import rich
@@ -16,7 +17,7 @@ from rich.syntax import Syntax
 from rich.table import Table
 from rich.tree import Tree
 
-from .. import settings
+from ..settings import CONFIG_DIR, LOG_LEVEL, PIPELINES_DIR
 # Import necessary config types and utility functions
 from ..cfg import PipelineConfig, ProjectConfig
 from ..utils.logging import setup_logging
@@ -47,7 +48,15 @@ class HookType(str, Enum):
         return self.value
 
 
-setup_logging(level=settings.LOG_LEVEL)
+@dataclass
+class CachedPipelineData:
+    """Container for cached pipeline data."""
+    pipeline: "Pipeline"
+    config: PipelineConfig
+    module: Any
+
+
+setup_logging(level=LOG_LEVEL)
 
 
 class PipelineRegistry:
@@ -71,16 +80,14 @@ class PipelineRegistry:
         """
         self.project_cfg = project_cfg
         self._fs = fs
-        self._cfg_dir = settings.CONFIG_DIR
-        self._pipelines_dir = settings.PIPELINES_DIR
+        self._cfg_dir = CONFIG_DIR
+        self._pipelines_dir = PIPELINES_DIR
         self._base_dir = base_dir
         self._storage_options = storage_options or {}
         self._console = Console()
 
-        # Cache for loaded pipelines
-        self._pipeline_cache: Dict[str, "Pipeline"] = {}
-        self._config_cache: Dict[str, PipelineConfig] = {}
-        self._module_cache: Dict[str, Any] = {}
+        # Consolidated cache for pipeline data
+        self._pipeline_data_cache: Dict[str, CachedPipelineData] = {}
 
         # Ensure module paths are added
         self._add_modules_path()
@@ -198,9 +205,9 @@ class PipelineRegistry:
             ValueError: If pipeline configuration is invalid
         """
         # Use cache if available and not reloading
-        if not reload and name in self._pipeline_cache:
+        if not reload and name in self._pipeline_data_cache:
             logger.debug(f"Returning cached pipeline '{name}'")
-            return self._pipeline_cache[name]
+            return self._pipeline_data_cache[name].pipeline
 
         logger.debug(f"Creating pipeline instance for '{name}'")
 
@@ -221,8 +228,12 @@ class PipelineRegistry:
             project_context=project_context,
         )
 
-        # Cache the pipeline instance
-        self._pipeline_cache[name] = pipeline
+        # Cache the pipeline data
+        self._pipeline_data_cache[name] = CachedPipelineData(
+            pipeline=pipeline,
+            config=config,
+            module=module,
+        )
 
         logger.debug(f"Successfully created pipeline instance for '{name}'")
         return pipeline
@@ -238,9 +249,9 @@ class PipelineRegistry:
             PipelineConfig instance
         """
         # Use cache if available and not reloading
-        if not reload and name in self._config_cache:
+        if not reload and name in self._pipeline_data_cache:
             logger.debug(f"Returning cached config for pipeline '{name}'")
-            return self._config_cache[name]
+            return self._pipeline_data_cache[name].config
 
         logger.debug(f"Loading configuration for pipeline '{name}'")
 
@@ -252,8 +263,14 @@ class PipelineRegistry:
             storage_options=self._storage_options,
         )
 
-        # Cache the configuration
-        self._config_cache[name] = config
+        # Cache the configuration (will be stored in consolidated cache when pipeline is created)
+        # For now, we'll create a temporary cache entry if it doesn't exist
+        if name not in self._pipeline_data_cache:
+            self._pipeline_data_cache[name] = CachedPipelineData(
+                pipeline=None,  # type: ignore
+                config=config,
+                module=None,  # type: ignore
+            )
 
         return config
 
@@ -268,9 +285,11 @@ class PipelineRegistry:
             Loaded Python module
         """
         # Use cache if available and not reloading
-        if not reload and name in self._module_cache:
-            logger.debug(f"Returning cached module for pipeline '{name}'")
-            return self._module_cache[name]
+        if not reload and name in self._pipeline_data_cache:
+            cached_data = self._pipeline_data_cache[name]
+            if cached_data.module is not None:
+                logger.debug(f"Returning cached module for pipeline '{name}'")
+                return cached_data.module
 
         logger.debug(f"Loading module for pipeline '{name}'")
 
@@ -281,8 +300,16 @@ class PipelineRegistry:
         # Load the module
         module = load_module(module_name, reload=reload)
 
-        # Cache the module
-        self._module_cache[name] = module
+        # Cache the module (will be stored in consolidated cache when pipeline is created)
+        # For now, we'll update the existing cache entry if it exists
+        if name in self._pipeline_data_cache:
+            self._pipeline_data_cache[name].module = module
+        else:
+            self._pipeline_data_cache[name] = CachedPipelineData(
+                pipeline=None,  # type: ignore
+                config=None,  # type: ignore
+                module=module,
+            )
 
         return module
 
@@ -295,14 +322,10 @@ class PipelineRegistry:
         """
         if name:
             logger.debug(f"Clearing cache for pipeline '{name}'")
-            self._pipeline_cache.pop(name, None)
-            self._config_cache.pop(name, None)
-            self._module_cache.pop(name, None)
+            self._pipeline_data_cache.pop(name, None)
         else:
             logger.debug("Clearing entire pipeline cache")
-            self._pipeline_cache.clear()
-            self._config_cache.clear()
-            self._module_cache.clear()
+            self._pipeline_data_cache.clear()
 
     # --- Methods moved from PipelineManager ---
     def new(self, name: str, overwrite: bool = False):
@@ -312,7 +335,6 @@ class PipelineRegistry:
         Args:
             name (str): The name of the pipeline.
             overwrite (bool): Whether to overwrite an existing pipeline. Defaults to False.
-            job_queue_type (str | None): The type of worker to use. Defaults to None.
 
         Raises:
             ValueError: If the configuration or pipeline path does not exist, or if the pipeline already exists.
@@ -333,7 +355,7 @@ class PipelineRegistry:
 
         formatted_name = name.replace(".", "/").replace("-", "_")
         pipeline_file = posixpath.join(self._pipelines_dir, f"{formatted_name}.py")
-        cfg_file = posixpath.join(self._cfg_dir, "pipelines", f"{formatted_name}.yml")
+        cfg_file = posixpath.join(self._cfg_dir, PIPELINES_DIR, f"{formatted_name}.yml")
 
         def check_and_handle(path: str):
             if self._fs.exists(path):
@@ -390,7 +412,7 @@ class PipelineRegistry:
         deleted_files = []
         if cfg:
             pipeline_cfg_path = posixpath.join(
-                self._cfg_dir, "pipelines", f"{name}.yml"
+                self._cfg_dir, PIPELINES_DIR, f"{name}.yml"
             )
             if self._fs.exists(pipeline_cfg_path):
                 self._fs.rm(pipeline_cfg_path)
@@ -436,11 +458,16 @@ class PipelineRegistry:
         """
         try:
             return self._fs.glob(posixpath.join(self._pipelines_dir, "*.py"))
-        except Exception as e:
+        except (OSError, PermissionError) as e:
             logger.error(
                 f"Error accessing pipeline directory {self._pipelines_dir}: {e}"
             )
             return []
+        except Exception as e:
+            logger.error(
+                f"Unexpected error accessing pipeline directory {self._pipelines_dir}: {e}"
+            )
+            return []
 
     def _get_names(self) -> list[str]:
         """
@@ -504,11 +531,16 @@ class PipelineRegistry:
                 except FileNotFoundError:
                     logger.warning(f"Module file not found for pipeline '{name}'")
                     pipeline_summary["module"] = "# Module file not found"
-                except Exception as e:
+                except (OSError, PermissionError, UnicodeDecodeError) as e:
                     logger.error(
                         f"Error reading module file for pipeline '{name}': {e}"
                     )
                     pipeline_summary["module"] = f"# Error reading module file: {e}"
+                except Exception as e:
+                    logger.error(
+                        f"Unexpected error reading module file for pipeline '{name}': {e}"
+                    )
+                    pipeline_summary["module"] = f"# Unexpected error reading module file: {e}"
 
             if pipeline_summary:  # Only add if cfg or code was requested and found
                 summary["pipelines"][name] = pipeline_summary
@@ -677,9 +709,12 @@ class PipelineRegistry:
                 size = f"{size_bytes / 1024:.1f} KB" if size_bytes else "0.0 KB"
             except NotImplementedError:
                 size = "N/A"
-            except Exception as e:
+            except (OSError, PermissionError) as e:
                 logger.warning(f"Could not get size for {path}: {e}")
                 size = "Error"
+            except Exception as e:
+                logger.warning(f"Unexpected error getting size for {path}: {e}")
+                size = "Error"
 
             pipeline_info.append({
                 "name": name,

flowerpower/pipeline/visualizer.py

@@ -25,8 +25,8 @@ class PipelineVisualizer:
         self._fs = fs
         # Attributes like fs and base_dir are accessed via self.project_cfg
 
-    def _display_all_function(self, name: str, reload: bool = False):
-        """Internal helper to load module/config and get the Hamilton DAG object.
+    def _get_dag_object(self, name: str, reload: bool = False):
+        """Get the Hamilton DAG object for a pipeline.
 
         Args:
             name (str): The name of the pipeline.
@@ -84,7 +84,7 @@ class PipelineVisualizer:
             >>> visualizer = PipelineVisualizer(project_cfg, fs)
             >>> visualizer.save_dag(name="example_pipeline", format="png")
         """
-        dag = self._display_all_function(name=name, reload=reload)
+        dag = self._get_dag_object(name=name, reload=reload)
 
         # Use project_cfg attributes for path and filesystem access
         graph_dir = posixpath.join(self.project_cfg.base_dir, "graphs")
@@ -133,7 +133,7 @@ class PipelineVisualizer:
             >>> visualizer = PipelineVisualizer(project_cfg, fs)
             >>> visualizer.show_dag(name="example_pipeline", format="png")
         """
-        dag = self._display_all_function(name=name, reload=reload)
+        dag = self._get_dag_object(name=name, reload=reload)
         if raw:
             return dag
         # Use view_img utility to display the rendered graph

flowerpower/plugins/{_io → io}/__init__.py

@@ -1,7 +1,7 @@
 import warnings
 
 warnings.warn(
-    "The flowerpower.plugins._io module is deprecated. "
+    "The flowerpower.plugins.io module is deprecated. "
     "Please use 'flowerpower-io' instead. Install it with 'pip install flowerpower-io'.",
     DeprecationWarning,
     stacklevel=2,

flowerpower/settings/__init__.py

@@ -1,8 +1,6 @@
 # flake8: noqa
-from .backend import *
 from .executor import *
 from .general import *
 from .hamilton import *
-from .job_queue import *
 from .logging import *
 from .retry import *

flowerpower/settings/{backend.py → _backend.py}

@@ -47,14 +47,6 @@ BACKEND_PROPERTIES = {
         "default_password": None,
         "is_sqla_type": False,
     },
-    "redis": {
-        "uri_prefix": "redis://",
-        "default_port": 6379,
-        "default_host": "localhost",
-        "default_database": 0,
-        "default_username": None,
-        "default_password": None,
-    },
     "nats_kv": {
         "uri_prefix": "nats://",
         "default_port": 4222,
@@ -73,17 +65,6 @@ BACKEND_PROPERTIES = {
     },
 }
 
-# # REDIS ENVIRONMENT VARIABLES
-# REDIS_HOST = os.getenv("FP_REDIS_HOST", BACKEND_PROPERTIES["redis"]["default_host"])
-# REDIS_PORT = int(
-#     os.getenv("FP_REDIS_PORT", BACKEND_PROPERTIES["redis"]["default_port"])
-# )
-# REDIS_DB = int(
-#     os.getenv("FP_REDIS_DB", BACKEND_PROPERTIES["redis"]["default_database"])
-# )
-# REDIS_PASSWORD = os.getenv("FP_REDIS_PASSWORD", None)
-# REDIS_USERNAME = os.getenv("FP_REDIS_USERNAME", None)
-# REDIS_SSL = bool(os.getenv("FP_REDIS_SSL", False))
 
 # # POSTGRES ENVIRONMENT VARIABLES
 # POSTGRES_HOST = os.getenv(

flowerpower/settings/logging.py

@@ -1,4 +1,4 @@
 import os
 
 # LOGGING
-LOG_LEVEL = os.getenv("FP_LOG_LEVEL", "INFO")
+LOG_LEVEL = os.getenv("FP_LOG_LEVEL", "CRITICAL")