rcbench 0.1.0__tar.gz

rcbench-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Davide Pilati
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rcbench-0.1.0/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: rcbench
+Version: 0.1.0
+Summary: Reservoir computing benchmark toolkit
+Home-page: https://github.com/nanotechdave/RCbench
+Author: Davide Pilati
+Author-email: davide.pilati@polito.it
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Requires-Dist: pandas
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: dev
+Requires-Dist: bump2version; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# RCbench - Reservoir Computing Benchmark Toolkit
+
+![Python](https://img.shields.io/badge/Python-3.9%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
+
+**RCbench (Reservoir Computing Benchmark Toolkit)** is a comprehensive Python package for evaluating and benchmarking reservoir computing systems. It provides standardized tasks, flexible visualization tools, and efficient evaluation methods for both physical and simulated reservoirs.
+
+## 🚀 Features
+
+RCbench provides:
+
+-**Multiple Benchmark Tasks:**
+  -**NLT (Nonlinear Transformation):** Evaluate reservoir performance on standard nonlinear transformations
+  -**NARMA:** Test with Nonlinear Auto-Regressive Moving Average models of different orders
+  -**Memory Capacity:** Measure the short and long-term memory capabilities
+  -**Sin(x):** Assess reservoir ability to transform a random signal into a nonlinear function that use the input as argument
+  -**KernelRank:** Evaluates the nonlinearityof the reservoir
+  -**GeneralizationRank:** Evaluates the generalization capabilities of the reservoir
+
+-**Advanced Visualization:**
+  -Task-specific plotters with customizable configurations
+  -General reservoir properties visualization (input signals, output responses, nonlinearity)
+  -Frequency domain analysis of reservoir behavior
+  -Target vs. prediction comparison with proper time alignment
+  
+-**Efficient Data Handling:**
+  -Automatic measurement loading and parsing
+  -Support for various experimental data formats
+  -Feature selection and dimensionality reduction tools
+---
+
+## 📂 Project Structure
+
+```plaintext
+RCbench/
+├── rcbench/
+|   |── examples/                  # Example scripts
+|   |   ├── example_nlt.py
+|   |   ├── example_NARMA.py
+|   |   ├── example_sinx.py
+|   |   └── example_MC.py
+│   ├── measurements/          # Data handling
+│   │   ├── dataset.py         # ReservoirDataset class
+│   │   ├── loader.py          # Data loading utilities
+│   │   └── parser.py          # Data parsing utilities
+│   ├── tasks/                 # Reservoir computing tasks
+│   │   ├── baseevaluator.py   # Base evaluation methods
+│   │   ├── nlt.py             # Nonlinear Transformation
+│   │   ├── narma.py           # NARMA tasks
+│   │   ├── memorycapacity.py  # Memory Capacity
+│   │   ├── sinx.py            # Sin(x) approximation
+│   │   └── featureselector.py # Feature selection tools
+│   ├── visualization/         # Plotting utilities
+│   │   ├── base_plotter.py    # Base plotting functionality
+│   │   ├── plot_config.py     # Plot configurations
+│   │   ├── nlt_plotter.py     # NLT visualization
+│   │   ├── narma_plotter.py   # NARMA visualization
+│   │   └── sinx_plotter.py    # Sin(x) visualization
+│   └── logger.py              # Logging utilities
+└
+```
+---
+
+## 🔧 Installation
+
+**Install directly from GitHub:**
+
+```bash
+pip install rcbench
+```
+
+
+Or, install locally (development mode):
+
+```bash
+git clone https://github.com/nanotechdave/RCbench.git
+cd RCbench
+pip install -e .
+```
+
+
+## 🚦 Usage Example
+Here's a quick example demonstrating how to perform an NLT evaluation:
+
+```python
+import logging
+from pathlib import Path
+import numpy as np
+import matplotlib.pyplot as plt
+
+from rcbench import ReservoirDataset
+from rcbench import NltEvaluator
+from rcbench.visualization.plot_config import NLTPlotConfig
+from rcbench.logger import get_logger
+
+logger = get_logger(__name__)
+logger.setLevel(logging.INFO)
+
+BASE_DIR = "FILE_PATH"
+
+filenameNLT = "YOUR_FILENAME"
+
+measurement_file_NLT = BASE_DIR / filenameNLT
+
+# Load the data directly using the ReservoirDataset class
+dataset = ReservoirDataset(measurement_file_NLT)
+
+# Get information about the electrodes
+electrodes_info = dataset.summary()
+logger.info(f"Parsed Electrodes: {electrodes_info}")
+
+# Get input and node voltages directly from the dataset
+input_elec = electrodes_info['input_electrodes'][0]
+input_signal = dataset.get_input_voltages()[input_elec]
+time = dataset.time
+
+# Get node voltages (only node electrodes, not input)
+nodes_output = dataset.get_node_voltages()
+electrode_names = electrodes_info['node_electrodes']
+
+# Create NLT plot configuration
+plot_config = NLTPlotConfig(
+    save_dir=None,  # Save plots to this directory
+    
+    # General reservoir property plots
+    plot_input_signal=True,         # Plot the input signal
+    plot_output_responses=True,     # Plot node responses
+    plot_nonlinearity=True,         # Plot nonlinearity of nodes
+    plot_frequency_analysis=True,   # Plot frequency analysis
+    
+    # Target-specific plots
+    plot_target_prediction=True,    # Plot target vs prediction results
+    
+    # Plot styling options
+    nonlinearity_plot_style='scatter',
+    frequency_range=(0, 20)         # Limit frequency range to 0-20 Hz for clearer visualization
+)
+
+# Run NLT evaluation with plot config
+evaluatorNLT = NltEvaluator(
+    input_signal=input_signal,
+    nodes_output=nodes_output,
+    time_array=time,
+    waveform_type='sine',  
+    electrode_names=electrode_names,
+    plot_config=plot_config
+)
+
+
+resultsNLT = {}
+for target_name in evaluatorNLT.targets:
+    try:
+        result = evaluatorNLT.run_evaluation(
+            target_name=target_name,
+            metric='NMSE',
+            feature_selection_method='pca',
+            num_features='all',
+            model="Ridge",
+            regression_alpha=0.01,
+            train_ratio=0.8,
+            plot=False,  # Don't plot during evaluation
+        )
+        resultsNLT[target_name] = result
+        # Print results clearly
+        logger.output(f"NLT Analysis for Target: '{target_name}'")
+        logger.output(f"  - Metric: {result['metric']}")
+        logger.output(f"  - Accuracy: {result['accuracy']:.5f}")
+        logger.output(f"  - Selected Features Indices: {[electrode_names[i] for i in result['selected_features']]}")
+        logger.output(f"  - Model Weights: {result['model'].coef_}\n")
+    except Exception as e:
+        logger.error(f"Error evaluating {target_name}: {str(e)}")
+
+evaluatorNLT.plot_results(existing_results=resultsNLT)
+```
+
+## 📈 Visualization Tools
+RCbench features a unified visualization system with:
+-**Task-Specific Plotters:** Dedicated plotters for each task (NLTPlotter, NarmaPlotter, SinxPlotter)
+-**Customizable Configurations:** Control which plots to generate through configuration objects
+-**Comprehensive Visualization:** For each task, view:
+  -General reservoir properties (input signals, node responses, nonlinearity)
+  -Frequency domain analysis
+  -Target vs. prediction comparisons
+
+
+
+## 📝 Contributions & Issues
+Contributions are welcome! Please open a pull request or an issue on GitHub.
+
+- Issue Tracker: https://github.com/nanotechdave/RCbench/issues
+
+- Pull Requests: https://github.com/nanotechdave/RCbench/pulls
+
+## 📜 License
+
+RCbench is licensed under the MIT License. See the LICENSE file for details.
+

rcbench-0.1.0/README.md

@@ -0,0 +1,198 @@
+# RCbench - Reservoir Computing Benchmark Toolkit
+
+![Python](https://img.shields.io/badge/Python-3.9%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
+
+**RCbench (Reservoir Computing Benchmark Toolkit)** is a comprehensive Python package for evaluating and benchmarking reservoir computing systems. It provides standardized tasks, flexible visualization tools, and efficient evaluation methods for both physical and simulated reservoirs.
+
+## 🚀 Features
+
+RCbench provides:
+
+-**Multiple Benchmark Tasks:**
+  -**NLT (Nonlinear Transformation):** Evaluate reservoir performance on standard nonlinear transformations
+  -**NARMA:** Test with Nonlinear Auto-Regressive Moving Average models of different orders
+  -**Memory Capacity:** Measure the short and long-term memory capabilities
+  -**Sin(x):** Assess reservoir ability to transform a random signal into a nonlinear function that use the input as argument
+  -**KernelRank:** Evaluates the nonlinearityof the reservoir
+  -**GeneralizationRank:** Evaluates the generalization capabilities of the reservoir
+
+-**Advanced Visualization:**
+  -Task-specific plotters with customizable configurations
+  -General reservoir properties visualization (input signals, output responses, nonlinearity)
+  -Frequency domain analysis of reservoir behavior
+  -Target vs. prediction comparison with proper time alignment
+  
+-**Efficient Data Handling:**
+  -Automatic measurement loading and parsing
+  -Support for various experimental data formats
+  -Feature selection and dimensionality reduction tools
+---
+
+## 📂 Project Structure
+
+```plaintext
+RCbench/
+├── rcbench/
+|   |── examples/                  # Example scripts
+|   |   ├── example_nlt.py
+|   |   ├── example_NARMA.py
+|   |   ├── example_sinx.py
+|   |   └── example_MC.py
+│   ├── measurements/          # Data handling
+│   │   ├── dataset.py         # ReservoirDataset class
+│   │   ├── loader.py          # Data loading utilities
+│   │   └── parser.py          # Data parsing utilities
+│   ├── tasks/                 # Reservoir computing tasks
+│   │   ├── baseevaluator.py   # Base evaluation methods
+│   │   ├── nlt.py             # Nonlinear Transformation
+│   │   ├── narma.py           # NARMA tasks
+│   │   ├── memorycapacity.py  # Memory Capacity
+│   │   ├── sinx.py            # Sin(x) approximation
+│   │   └── featureselector.py # Feature selection tools
+│   ├── visualization/         # Plotting utilities
+│   │   ├── base_plotter.py    # Base plotting functionality
+│   │   ├── plot_config.py     # Plot configurations
+│   │   ├── nlt_plotter.py     # NLT visualization
+│   │   ├── narma_plotter.py   # NARMA visualization
+│   │   └── sinx_plotter.py    # Sin(x) visualization
+│   └── logger.py              # Logging utilities
+└
+```
+---
+
+## 🔧 Installation
+
+**Install directly from GitHub:**
+
+```bash
+pip install rcbench
+```
+
+
+Or, install locally (development mode):
+
+```bash
+git clone https://github.com/nanotechdave/RCbench.git
+cd RCbench
+pip install -e .
+```
+
+
+## 🚦 Usage Example
+Here's a quick example demonstrating how to perform an NLT evaluation:
+
+```python
+import logging
+from pathlib import Path
+import numpy as np
+import matplotlib.pyplot as plt
+
+from rcbench import ReservoirDataset
+from rcbench import NltEvaluator
+from rcbench.visualization.plot_config import NLTPlotConfig
+from rcbench.logger import get_logger
+
+logger = get_logger(__name__)
+logger.setLevel(logging.INFO)
+
+BASE_DIR = "FILE_PATH"
+
+filenameNLT = "YOUR_FILENAME"
+
+measurement_file_NLT = BASE_DIR / filenameNLT
+
+# Load the data directly using the ReservoirDataset class
+dataset = ReservoirDataset(measurement_file_NLT)
+
+# Get information about the electrodes
+electrodes_info = dataset.summary()
+logger.info(f"Parsed Electrodes: {electrodes_info}")
+
+# Get input and node voltages directly from the dataset
+input_elec = electrodes_info['input_electrodes'][0]
+input_signal = dataset.get_input_voltages()[input_elec]
+time = dataset.time
+
+# Get node voltages (only node electrodes, not input)
+nodes_output = dataset.get_node_voltages()
+electrode_names = electrodes_info['node_electrodes']
+
+# Create NLT plot configuration
+plot_config = NLTPlotConfig(
+    save_dir=None,  # Save plots to this directory
+    
+    # General reservoir property plots
+    plot_input_signal=True,         # Plot the input signal
+    plot_output_responses=True,     # Plot node responses
+    plot_nonlinearity=True,         # Plot nonlinearity of nodes
+    plot_frequency_analysis=True,   # Plot frequency analysis
+    
+    # Target-specific plots
+    plot_target_prediction=True,    # Plot target vs prediction results
+    
+    # Plot styling options
+    nonlinearity_plot_style='scatter',
+    frequency_range=(0, 20)         # Limit frequency range to 0-20 Hz for clearer visualization
+)
+
+# Run NLT evaluation with plot config
+evaluatorNLT = NltEvaluator(
+    input_signal=input_signal,
+    nodes_output=nodes_output,
+    time_array=time,
+    waveform_type='sine',  
+    electrode_names=electrode_names,
+    plot_config=plot_config
+)
+
+
+resultsNLT = {}
+for target_name in evaluatorNLT.targets:
+    try:
+        result = evaluatorNLT.run_evaluation(
+            target_name=target_name,
+            metric='NMSE',
+            feature_selection_method='pca',
+            num_features='all',
+            model="Ridge",
+            regression_alpha=0.01,
+            train_ratio=0.8,
+            plot=False,  # Don't plot during evaluation
+        )
+        resultsNLT[target_name] = result
+        # Print results clearly
+        logger.output(f"NLT Analysis for Target: '{target_name}'")
+        logger.output(f"  - Metric: {result['metric']}")
+        logger.output(f"  - Accuracy: {result['accuracy']:.5f}")
+        logger.output(f"  - Selected Features Indices: {[electrode_names[i] for i in result['selected_features']]}")
+        logger.output(f"  - Model Weights: {result['model'].coef_}\n")
+    except Exception as e:
+        logger.error(f"Error evaluating {target_name}: {str(e)}")
+
+evaluatorNLT.plot_results(existing_results=resultsNLT)
+```
+
+## 📈 Visualization Tools
+RCbench features a unified visualization system with:
+-**Task-Specific Plotters:** Dedicated plotters for each task (NLTPlotter, NarmaPlotter, SinxPlotter)
+-**Customizable Configurations:** Control which plots to generate through configuration objects
+-**Comprehensive Visualization:** For each task, view:
+  -General reservoir properties (input signals, node responses, nonlinearity)
+  -Frequency domain analysis
+  -Target vs. prediction comparisons
+
+
+
+## 📝 Contributions & Issues
+Contributions are welcome! Please open a pull request or an issue on GitHub.
+
+- Issue Tracker: https://github.com/nanotechdave/RCbench/issues
+
+- Pull Requests: https://github.com/nanotechdave/RCbench/pulls
+
+## 📜 License
+
+RCbench is licensed under the MIT License. See the LICENSE file for details.
+

rcbench-0.1.0/rcbench/__init__.py

@@ -0,0 +1,13 @@
+__version__ = "0.0.10.dev1"
+
+from .utils import utils
+from .tasks.nlt import NltEvaluator
+from .tasks.memorycapacity import MemoryCapacityEvaluator
+from .tasks.sinx import SinxEvaluator
+from .tasks.kernelrank import KernelRankEvaluator
+from .tasks.generalizationrank import GeneralizationRankEvaluator
+from .tasks.narma import NarmaEvaluator
+from .measurements.parser import MeasurementParser
+from .measurements.loader import MeasurementLoader
+from .measurements.dataset import ReservoirDataset
+from .logger import get_logger

rcbench-0.1.0/rcbench/classes/Measurement.py

@@ -0,0 +1,84 @@
+from enum import Enum
+from typing import Optional
+from rcbench.measurements.dataset import ReservoirDataset
+from rcbench.measurements.parser import MeasurementParser
+from rcbench.logger import get_logger
+
+logger = get_logger(__name__)
+
+class MeasurementType(Enum):
+    """Enumeration of possible measurement types."""
+    NLT = "nlt"
+    MEMORY_CAPACITY = "mc"
+    KERNEL_RANK = "kernel"
+    ACTIVATION = "activation"
+    UNKNOWN = "unknown"
+
+class Measurement():
+    """Base class for all measurement types."""
+    def __init__(self, path: str):
+        """
+        Initialize a Measurement object.
+        
+        Args:
+            path (str): Path to the measurement file
+        """
+        self.path = path
+        self.type = self._determine_measurement_type()
+        self.dataset: Optional[ReservoirDataset] = None
+        self.parser: Optional[MeasurementParser] = None
+        self._load_measurement()
+    
+    def _determine_measurement_type(self) -> MeasurementType:
+        """Determine the type of measurement based on the filename."""
+        filename = self.path.lower()
+        if "nlt" in filename or "nonlinear" in filename:
+            return MeasurementType.NLT
+        elif "mc" in filename or "memory" in filename:
+            return MeasurementType.MEMORY_CAPACITY
+        elif "kernel" in filename:
+            return MeasurementType.KERNEL_RANK
+        elif "activation" in filename:
+            return MeasurementType.ACTIVATION
+        return MeasurementType.UNKNOWN
+    
+    def _load_measurement(self):
+        """Load the measurement data using MeasurementLoader and MeasurementParser."""
+        try:
+            from rcbench.measurements.loader import MeasurementLoader
+            loader = MeasurementLoader(self.path)
+            self.dataset = loader.get_dataset()
+            self.parser = MeasurementParser(self.dataset)
+            logger.info(f"Successfully loaded measurement of type {self.type.value}")
+        except Exception as e:
+            logger.error(f"Error loading measurement {self.path}: {str(e)}")
+            raise
+    
+    def get_input_voltages(self):
+        """Get input voltages from the measurement."""
+        if self.parser:
+            return self.parser.get_input_voltages()
+        return None
+    
+    def get_node_voltages(self):
+        """Get node voltages from the measurement."""
+        if self.parser:
+            return self.parser.get_node_voltages()
+        return None
+    
+    def get_time(self):
+        """Get time data from the measurement."""
+        if self.dataset:
+            return self.dataset.time
+        return None
+    
+    def __str__(self):
+        return f"Measurement(type={self.type.value}, path={self.path})"
+
+class MemoryCapacity(Measurement):
+    """Memory Capacity specific measurement class."""
+    def __init__(self, path: str):
+        super().__init__(path)
+        if self.type != MeasurementType.MEMORY_CAPACITY:
+            logger.warning(f"File {path} may not be a memory capacity measurement")
+    

rcbench-0.1.0/rcbench/classes/sample.py

@@ -0,0 +1,85 @@
+from pathlib import Path
+from typing import List, Dict
+from rcbench.classes.Measurement import Measurement, MeasurementType
+from rcbench.logger import get_logger
+
+logger = get_logger(__name__)
+
+class Sample():
+    """ Sample data class. Instance is an object containing all the measurements of a sample. """
+    def __init__(self, name: str, path: str):
+        """
+        Initialize a Sample object.
+        
+        Args:
+            name (str): Name of the sample
+            path (str): Path to the folder containing measurement files
+        """
+        self.name = name
+        self.path = Path(path)
+        self.measurements: Dict[str, Measurement] = {}
+        self._scan_measurements()
+        
+    def _scan_measurements(self):
+        """Scan the folder for measurement files and initialize measurement objects."""
+        if not self.path.exists():
+            raise FileNotFoundError(f"Folder not found: {self.path}")
+            
+        # Find all .txt files that don't contain 'log' in their name
+        measurement_files = [f for f in self.path.glob("*.txt") if "log" not in f.name.lower()]
+        
+        for file_path in measurement_files:
+            try:
+                # Create appropriate measurement object based on file type
+                measurement = Measurement(str(file_path))
+                
+                # Store the measurement object with the filename as key
+                self.measurements[file_path.name] = measurement
+                logger.info(f"Loaded measurement: {file_path.name} (type: {measurement.type.value})")
+                
+            except Exception as e:
+                logger.error(f"Error loading measurement {file_path.name}: {str(e)}")
+                
+    def get_measurement(self, filename: str) -> Measurement:
+        """
+        Get a specific measurement by filename.
+        
+        Args:
+            filename (str): Name of the measurement file
+            
+        Returns:
+            Measurement: The measurement object
+        """
+        if filename not in self.measurements:
+            raise KeyError(f"Measurement {filename} not found")
+        return self.measurements[filename]
+    
+    def get_measurements_by_type(self, measurement_type: MeasurementType) -> List[Measurement]:
+        """
+        Get all measurements of a specific type.
+        
+        Args:
+            measurement_type (MeasurementType): Type of measurements to retrieve
+            
+        Returns:
+            List[Measurement]: List of measurements of the specified type
+        """
+        return [m for m in self.measurements.values() if m.type == measurement_type]
+    
+    def list_measurements(self) -> List[str]:
+        """
+        Get a list of all available measurement filenames.
+        
+        Returns:
+            List[str]: List of measurement filenames
+        """
+        return list(self.measurements.keys())
+    
+    def __str__(self):
+        measurement_types = {}
+        for m in self.measurements.values():
+            measurement_types[m.type.value] = measurement_types.get(m.type.value, 0) + 1
+        
+        type_str = ", ".join(f"{t}: {c}" for t, c in measurement_types.items())
+        objstr = f"Sample NWN_Pad{self.name} with {len(self.measurements)} measurements ({type_str})"
+        return objstr

rcbench-0.1.0/rcbench/logger.py

@@ -0,0 +1,48 @@
+import logging
+import sys
+
+OUTPUT_LEVEL = 25
+logging.addLevelName(OUTPUT_LEVEL, "OUTPUT")
+
+# Define color ANSI codes
+COLOR_RESET = "\033[0m"
+COLORS = {
+    logging.DEBUG: "\033[36m",     # Cyan
+    logging.INFO: "\033[34m",      # Blue
+    OUTPUT_LEVEL: "\033[32m",      # Green 
+    logging.WARNING: "\033[33m",   # Yellow
+    logging.ERROR: "\033[31m",     # Red
+    logging.CRITICAL: "\033[41m",  # Red Background
+}
+
+def output(self, message, *args, **kwargs):
+    if self.isEnabledFor(OUTPUT_LEVEL):
+        self._log(OUTPUT_LEVEL, message, args, **kwargs)
+
+logging.Logger.output = output
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        level_color = COLORS.get(record.levelno, COLOR_RESET)
+        levelname = f"{level_color}[{record.levelname}]{COLOR_RESET}"
+
+        formatter = logging.Formatter(
+            f"%(asctime)s {levelname} %(name)s — %(message)s",
+            datefmt="%H:%M:%S"
+        )
+
+        return formatter.format(record)
+
+def get_logger(name: str = "rcda"):
+    logger = logging.getLogger(name)
+
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(ColoredFormatter())
+        logger.addHandler(handler)
+
+        logger.propagate = False
+        # Keep level unset here to control externally
+        # logger.setLevel(logging.INFO)
+
+    return logger