balancr 0.1.0__py3-none-any.whl

balancr/cli/utils.py

@@ -0,0 +1,101 @@
+"""
+utils.py - Utility functions for the balancr CLI.
+
+This module provides helper functions for logging, file handling,
+and other common tasks used across the CLI application.
+"""
+
+import logging
+import sys
+
+
+# Define a filter to exclude the matplotlib 'findfont' messages
+class FontMessageFilter(logging.Filter):
+    """Filter to remove noisy font-related log messages."""
+
+    def filter(self, record):
+        """Filter out 'findfont' log messages from matplotlib."""
+        return "findfont" not in record.getMessage()
+
+
+def setup_logging(log_level="default"):
+    """
+    Set up logging with colour and the specified verbosity level.
+
+    Args:
+        log_level: "verbose", "default", or "quiet"
+    """
+    # Reset any existing handlers
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
+    level_map = {
+        "verbose": logging.DEBUG,
+        "default": logging.INFO,
+        "quiet": logging.WARNING,
+    }
+
+    # Get the log level, defaulting to INFO
+    log_level_value = level_map.get(log_level, logging.INFO)
+
+    # Root logger level
+    root_logger.setLevel(log_level_value)
+
+    # Coloured logging
+    try:
+        import colorama
+
+        colorama.init()
+
+        # Define colour codes
+        COLORS = {
+            "DEBUG": colorama.Fore.BLUE,
+            "INFO": colorama.Fore.GREEN,
+            "WARNING": colorama.Fore.YELLOW,
+            "ERROR": colorama.Fore.RED,
+            "CRITICAL": colorama.Fore.RED + colorama.Style.BRIGHT,
+        }
+
+        # Create custom formatter with colours
+        class ColoredFormatter(logging.Formatter):
+            def format(self, record):
+                levelname = record.levelname
+                if levelname in COLORS:
+                    levelname_color = (
+                        COLORS[levelname] + levelname + colorama.Style.RESET_ALL
+                    )
+                    record.levelname = levelname_color
+                return super().format(record)
+
+        # Create console handler with the custom formatter
+        console = logging.StreamHandler(sys.stdout)
+        formatter = ColoredFormatter("%(levelname)s: %(message)s")
+        console.setFormatter(formatter)
+
+        # Add filter for font messages
+        console.addFilter(FontMessageFilter())
+
+        root_logger.addHandler(console)
+
+    except ImportError:
+        # Fall back to standard logging if colorama is not available
+        logging.basicConfig(
+            level=log_level_value,
+            format="%(levelname)s: %(message)s",
+            handlers=[logging.StreamHandler(sys.stdout)],
+        )
+
+        # Add filter for font messages to the root logger
+        for handler in root_logger.handlers:
+            handler.addFilter(FontMessageFilter())
+
+    # Set higher levels for some third-party libraries to reduce noise
+    logging.getLogger("matplotlib").setLevel(logging.WARNING)
+    logging.getLogger("PIL").setLevel(logging.WARNING)
+
+    # Log the configured level
+    if log_level == "verbose":
+        logging.debug("Verbose logging enabled")
+    elif log_level == "quiet":
+        logging.warning("Quiet logging mode - only showing warnings and errors")

balancr/data/__init__.py

@@ -0,0 +1,5 @@
+# src/balancr/data/__init__.py
+# flake8: noqa
+
+from .loader import DataLoader
+from .preprocessor import DataPreprocessor

balancr/data/loader.py

@@ -0,0 +1,59 @@
+import pandas as pd
+import numpy as np
+from typing import Tuple, Union, Optional
+from pathlib import Path
+
+
+class DataLoader:
+    """Handles loading data from various file formats"""
+
+    @staticmethod
+    def load_data(
+        file_path: Union[str, Path],
+        target_column: str,
+        feature_columns: Optional[list] = None,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Load data from various file formats (CSV, Excel)
+
+        Args:
+            file_path: Path to the data file
+            target_column: Name of the target column
+            feature_columns: List of feature columns to use (optional)
+
+        Returns:
+            X: Feature matrix
+            y: Target vector
+        """
+        file_path = Path(file_path)
+
+        if file_path.suffix.lower() == ".csv":
+            data = pd.read_csv(file_path)
+        elif file_path.suffix.lower() in [".xlsx", ".xls"]:
+            try:
+                data = pd.read_excel(file_path)
+            except ModuleNotFoundError:
+                raise ModuleNotFoundError(
+                    "The openpyxl package is required to read Excel files. "
+                    "Please install it using: pip install openpyxl"
+                )
+        else:
+            raise ValueError(f"Unsupported file format: {file_path.suffix}")
+
+        # Extract target variable
+        if target_column not in data.columns:
+            raise ValueError(f"Target column '{target_column}' not found in data")
+        y = data[target_column].values
+
+        # Extract features
+        if feature_columns is None:
+            # Use all columns except target
+            feature_columns = [col for col in data.columns if col != target_column]
+        else:
+            # Verify all specified feature columns exist
+            missing_cols = [col for col in feature_columns if col not in data.columns]
+            if missing_cols:
+                raise ValueError(f"Feature columns not found: {missing_cols}")
+
+        X = data[feature_columns].values
+        return X, y