testrium 0.1.0__tar.gz

testrium-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: testrium
+Version: 0.1.0
+Summary: A modern, advanced testing framework.
+Home-page: https://github.com/letalboy/testrium
+License: MIT
+Author: Cristian Camargo
+Author-email: ccf@cdone.com.br
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Project-URL: Documentation, https://github.com/letalboy/testrium#readme
+Project-URL: Repository, https://github.com/letalboy/testrium
+Description-Content-Type: text/markdown
+
+<div style="display: flex; align-items: center;">
+  <img src="https://github.com/letalboy/Spectrum/assets/63066865/cf9c60e7-9eba-474c-8cc1-b246e661fd5c" alt="Logo" width="200" height="200" style="margin-right: 20px;">
+  <div>
+    <h1>Spectrum</h1>
+    <p>Spectrum is a versatile library designed to test and analyze systems like Misny. It provides tools for data processing, monitoring, and ensuring system integrity, making it an essential part of your development workflow.</p>
+  </div>
+</div>
+<div>
+    <p>Key points:</p>
+    <ul>
+        <li>Better Organization Of Tests</li>
+        <li>Easy Test Of Async Or Paralelized Dependent Tests</li>
+        <li>Historic Performance Comparation and Evaluation</li>
+        <li>Allow Custom Behavior Though Callbacks Systems</li>
+        <li>Allow Manipulation Of The Test Flows</li>
+        <li>High COnfigurable And Expancible</li>
+    </ul>
+</div>
+
+To use is simple:
+
+1. activate the poetry shell using:
+
+```shell
+poetry shell
+```
+
+2. go the the test folder and run:
+
+```shell
+poetry run spectrum 
+```
+
+This should auto collect the test and run them automatically!
+
+---
+
+Base Idea:
+- Read the folder of test folders
+- Collect each one
+- Run them based in the priority config file in the test toml if present
+- Create a db to store tests results locally or if configured in the toml then send to a remote server
+- Run the tests, save the results
+- Compare the results witht he performance of the old tests to see if the test increase or decrese efficience.
+- Create a way to evaluate the performance in multiple machines comparing the efficience without issues.
+
+TODO:
+- Create a mechanism to add events through a test
+    - Events will allow to indentify if we complete the required step
+    - Cross events, are events were we want to trace the process from one point to another and how much time it takes to
+    this will be able to be done using a structure that generate a event hash for each event so then we can trace it to the 
+    other place.

testrium-0.1.0/README.md

@@ -0,0 +1,52 @@
+<div style="display: flex; align-items: center;">
+  <img src="https://github.com/letalboy/Spectrum/assets/63066865/cf9c60e7-9eba-474c-8cc1-b246e661fd5c" alt="Logo" width="200" height="200" style="margin-right: 20px;">
+  <div>
+    <h1>Spectrum</h1>
+    <p>Spectrum is a versatile library designed to test and analyze systems like Misny. It provides tools for data processing, monitoring, and ensuring system integrity, making it an essential part of your development workflow.</p>
+  </div>
+</div>
+<div>
+    <p>Key points:</p>
+    <ul>
+        <li>Better Organization Of Tests</li>
+        <li>Easy Test Of Async Or Paralelized Dependent Tests</li>
+        <li>Historic Performance Comparation and Evaluation</li>
+        <li>Allow Custom Behavior Though Callbacks Systems</li>
+        <li>Allow Manipulation Of The Test Flows</li>
+        <li>High COnfigurable And Expancible</li>
+    </ul>
+</div>
+
+To use is simple:
+
+1. activate the poetry shell using:
+
+```shell
+poetry shell
+```
+
+2. go the the test folder and run:
+
+```shell
+poetry run spectrum 
+```
+
+This should auto collect the test and run them automatically!
+
+---
+
+Base Idea:
+- Read the folder of test folders
+- Collect each one
+- Run them based in the priority config file in the test toml if present
+- Create a db to store tests results locally or if configured in the toml then send to a remote server
+- Run the tests, save the results
+- Compare the results witht he performance of the old tests to see if the test increase or decrese efficience.
+- Create a way to evaluate the performance in multiple machines comparing the efficience without issues.
+
+TODO:
+- Create a mechanism to add events through a test
+    - Events will allow to indentify if we complete the required step
+    - Cross events, are events were we want to trace the process from one point to another and how much time it takes to
+    this will be able to be done using a structure that generate a event hash for each event so then we can trace it to the 
+    other place.

testrium-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "testrium"
+version = "0.1.0"
+description = "A modern, advanced testing framework."
+authors = ["Cristian Camargo <ccf@cdone.com.br>"]
+readme = "README.md"
+homepage = "https://github.com/letalboy/testrium"
+repository = "https://github.com/letalboy/testrium"
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+toml = "^0.10.2"
+pandas = "^2.2.2"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.2.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+testrium = "testrium.core:main"
+
+[tool.poetry.urls]
+Documentation = "https://github.com/letalboy/testrium#readme"

testrium-0.1.0/testrium/common/sql_pool.py

@@ -0,0 +1,30 @@
+import sqlite3
+from queue import Queue
+from threading import Lock
+
+class SQLiteConnectionPool:
+    def __init__(self, max_connections:int, database_path:str):
+        self.data_base = database_path
+        self.max_connections = max_connections
+        self.connections = Queue(max_connections)
+        self.lock = Lock()
+
+        for i in range(max_connections):
+            connection = sqlite3.connect(self.data_base, check_same_thread=False)
+            self.connections.put(connection)
+
+    def get_connection(self):
+        with self.lock:
+            if self.connections.empty():
+                raise Exception("No available connections in the pool")
+            connection = self.connections.get()
+        return connection
+    
+    def release_connection(self, connection):
+        with self.lock:
+            self.connections.put(connection)
+
+    def close_all_connections(self):
+        while not self.connections.empty():
+            connection = self.connections.get()
+            connection.close()

testrium-0.1.0/testrium/common/validate_configs.py

@@ -0,0 +1 @@
+# TODO >>> This module have the goal to validate the configs toml and ensure it has the correct and desired keywords

testrium-0.1.0/testrium/core.py

@@ -0,0 +1,177 @@
+import os
+import time
+import importlib.util
+import toml
+from colorama import init, Fore, Style
+import shutil
+from .utils import Events_Manager
+
+# Initialize colorama
+init(autoreset=True)
+
+# Loads the config for each test:
+def load_config(config_path):
+    print(f"{Fore.CYAN}Loading config from {config_path}")
+    with open(config_path, 'r') as file:
+        config = toml.load(file)
+    return config
+
+# Loads the test functions:
+def load_test_functions(dir_path):
+    test_functions = {}
+    for filename in os.listdir(dir_path):
+        if filename.startswith('_') or not filename.endswith('.py'):
+            continue
+        module_name = filename[:-3]
+        file_path = os.path.join(dir_path, filename)
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        for attr in dir(module):
+            if attr == "Events_Manager":
+                continue
+            func = getattr(module, attr)
+            if callable(func) and not attr.startswith('_'):
+                test_functions[attr] = func
+    return test_functions
+
+# Run setup of the test group
+def run_setup(setup_path):
+    spec = importlib.util.spec_from_file_location("setup", setup_path)
+    setup_module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(setup_module)
+    setup_module.main()
+
+# Print the nice Pass or Fail banners
+def print_banner(message, color=Fore.GREEN):
+    term_width = shutil.get_terminal_size().columns
+    message_length = len(message)
+    padding_length = (term_width - message_length) // 2
+    banner = "=" * padding_length + message + "=" * padding_length
+
+    # Ensure the banner fits exactly in the terminal width
+    if len(banner) < term_width:
+        banner += "=" * (term_width - len(banner))
+
+    print(color + banner)
+
+def main():
+    base_dir = os.getcwd()
+    print(f"{Fore.GREEN}Current working directory: {base_dir}")
+
+    dir_names = os.listdir(base_dir)
+    valid_test_dirs = []
+    
+    # -> Discover valid test folders with configs inside
+    for dir_name in dir_names:
+        dir_path = os.path.join(base_dir, dir_name)
+        
+        if not os.path.isdir(dir_path):
+            print(f"{Fore.RED} File: {dir_name} is not a folder")
+            continue
+        
+        setup_path = os.path.join(dir_path, 'setup.py')
+        config_path = os.path.join(dir_path, 'config.toml')
+
+        if not (os.path.exists(setup_path) and os.path.exists(config_path)):
+            print(f"{Fore.RED} File: {dir_name} invalid test")
+            continue
+        
+        print(f"{Fore.MAGENTA}Found test directory: {dir_name}")
+        valid_test_dirs.append(dir_name)
+        
+    tests_finded = len(valid_test_dirs)
+    
+    # -> Early retun if not find any test:
+    if tests_finded > 0:
+        print(f"{Fore.GREEN} Find: {tests_finded:.0f} valid test groups!")
+        for test_group in valid_test_dirs:
+            print(f"{Fore.GREEN} - {test_group}")
+    else:
+        print(f"{Fore.RED} No valid test groups finded!")
+        return
+
+    # TODO >>> Find a way to log the milestones completed for each test and with this understand what they relate to
+    
+    # -> Run the valid tests:
+    for dir_name in valid_test_dirs:
+        
+        Events_Manager(Unit="", path=base_dir).drop_events_table()
+        
+        dir_path = os.path.join(base_dir, dir_name)
+        setup_path = os.path.join(dir_path, 'setup.py')
+        
+        #> Load test configs
+        config_path = os.path.join(dir_path, 'config.toml')
+        configs = load_config(config_path)
+        
+        #> Load Units
+        confs = configs['Configs']
+        units = confs['units']
+        
+        #> Load Units Predefinitions
+        total_units = 0
+        units_index = {}
+        for unit in units:
+            un = configs[f"{unit}"]
+            units_index[un["init"]] = {"name":f"{unit}", "events": f"{un['events']}"}
+            total_units += 1
+            
+        print(f"Units loaded: {units_index}")
+        
+        # TODO >>> Use the units order to setup the units one by one
+        # TODO >>> Create a meachanism to verify the events when they are required
+            
+        print(f"{Fore.BLUE}Loading tests for {dir_name}...")
+        test_functions = load_test_functions(dir_path)
+        
+        all_tests_passed = True
+        
+        #> Run each test found in the test group
+        for test_name, test_func in test_functions.items():
+            print(f"{Fore.YELLOW}Running test: {test_name}")
+            start_time = time.time()
+            
+            try:
+                if test_name == 'log_test_time':
+                    test_func(dummy_function)  # Pass a dummy function if required
+                elif test_name == 'verify_condition':
+                    # TODO >>> Use this as a condition to verify if the requirements was completed for the test case
+                    test_func(lambda: True)  # Pass a lambda function if required
+                else:
+                    test_func()
+                elapsed_time = time.time() - start_time
+                print(f"{Fore.GREEN}{test_name}: PASSED in {elapsed_time:.2f} seconds")
+            except Exception as e:
+                all_tests_passed = False
+                elapsed_time = time.time() - start_time
+                print(f"{Fore.RED}{test_name}: FAILED in {elapsed_time:.2f} seconds\nError: {e}")
+        
+        #> Verify Events Completed By The Unit
+        for i in range(total_units):
+            unit = units_index[i]
+            unit_name = unit["name"]
+            if unit_name == "":
+                continue
+            unit_events = Events_Manager(Unit=unit_name, path=base_dir).List_Events()
+            for event in eval(unit["events"]):
+                if event not in unit_events:
+                    print(f"event: [{event}] was not completed!")
+                    all_tests_passed = False
+                    
+        if all_tests_passed:
+            print_banner(" PASS ", Fore.GREEN)
+        else:
+            print_banner(" FAILURE ", Fore.RED)
+
+# Extra validation step that user migh want to define
+def dummy_function():
+    """
+    - This will allow to define a extra step in the verification
+    for example, read a file and validate if the test was a success.
+    see if the code did what it was suposed to do. etc..
+    """
+    pass
+
+if __name__ == "__main__":
+    main()

testrium-0.1.0/testrium/tools/benchmark.py

@@ -0,0 +1,113 @@
+import time
+import numpy as np
+import os
+import sqlite3
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+def run_benchmark_multiple_times(benchmark_func, iterations=10, warmup=True):
+    if warmup:
+        benchmark_func()
+    
+    times = []
+    for _ in tqdm(range(iterations), desc=benchmark_func.__name__, leave=False):
+        start_time = time.time()
+        benchmark_func()
+        end_time = time.time()
+        times.append(end_time - start_time)
+    
+    return times  # Return all times for visualization
+
+def cpu_benchmark_single_core():
+    result = 0
+    for i in range(1, 1000000):
+        result += (i ** 0.5) ** 2
+
+def cpu_benchmark_multicore(workers=4):
+    def worker_task(start, end):
+        result = 0
+        for i in range(start, end):
+            result += (i ** 0.5) ** 2
+        return result
+
+    chunk_size = 1000000 // workers
+    with ThreadPoolExecutor(max_workers=workers) as executor:
+        futures = [executor.submit(worker_task, i * chunk_size, (i + 1) * chunk_size) for i in range(workers)]
+        results = [future.result() for future in as_completed(futures)]
+    return sum(results)
+
+def memory_benchmark():
+    array_size = 10000000
+    array = np.arange(array_size, dtype=np.float64)
+    array *= 2
+
+def disk_benchmark():
+    with open('disk_benchmark.tmp', 'wb') as f:
+        f.write(os.urandom(500000000))  # Write 500MB
+    with open('disk_benchmark.tmp', 'rb') as f:
+        f.read()
+    os.remove('disk_benchmark.tmp')
+
+def io_benchmark():
+    with open('io_benchmark.tmp', 'w') as f:
+        for _ in range(100000):
+            f.write('This is a test.\n')
+    os.remove('io_benchmark.tmp')
+
+def peak_disk_write_benchmark(file_size_mb=500):
+    data = os.urandom(file_size_mb * 1024 * 1024)  # Generate large data block
+    file_path = 'peak_disk_write.tmp'
+    
+    start_time = time.time()
+    with open(file_path, 'wb') as f:
+        f.write(data)
+        f.flush()  # Ensure all data is written
+        os.fsync(f.fileno())  # Flush OS buffer to disk
+    end_time = time.time()
+    
+    os.remove(file_path)  # Clean up
+    
+    elapsed_time = end_time - start_time
+    throughput = file_size_mb / elapsed_time  # MB/s
+    return throughput
+
+def run_peak_disk_write_benchmark(iterations=5, file_size_mb=500):
+    throughputs = []
+    for _ in tqdm(range(iterations), desc="Peak Disk Write Benchmark", leave=False):
+        throughput = peak_disk_write_benchmark(file_size_mb)
+        throughputs.append(throughput)
+    return throughputs
+
+def save_benchmark_results(machine_id, benchmark_name, times):
+    conn = sqlite3.connect('test_results.db')
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS benchmark_samples (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            machine_id TEXT,
+            benchmark_name TEXT,
+            time REAL
+        )
+    ''')
+    for time in times:
+        cursor.execute('''
+            INSERT INTO benchmark_samples (machine_id, benchmark_name, time)
+            VALUES (?, ?, ?)
+        ''', (machine_id, benchmark_name, time))
+    conn.commit()
+    conn.close()
+
+# Example usage
+cpu_times = run_benchmark_multiple_times(lambda: cpu_benchmark_multicore(workers=os.cpu_count()), iterations=150)
+memory_times = run_benchmark_multiple_times(memory_benchmark, iterations=150)
+disk_times = run_benchmark_multiple_times(disk_benchmark, iterations=150)
+io_times = run_benchmark_multiple_times(io_benchmark, iterations=150)
+peak_disk_write_throughputs = run_peak_disk_write_benchmark(iterations=150)
+
+save_benchmark_results('machine_A', 'CPU', cpu_times)
+save_benchmark_results('machine_A', 'Memory', memory_times)
+save_benchmark_results('machine_A', 'Disk', disk_times)
+save_benchmark_results('machine_A', 'IO', io_times)
+save_benchmark_results('machine_A', 'PeakDiskWrite', peak_disk_write_throughputs)
+
+print("Benchmarking complete. Results saved to the database.")

testrium-0.1.0/testrium/tools/dashborad.py

@@ -0,0 +1,195 @@
+from dash import Dash, dcc, html
+import dash_bootstrap_components as dbc
+from dash.dependencies import Input, Output
+import plotly.express as px
+import pandas as pd
+import sqlite3
+import numpy as np
+from scipy.stats import gaussian_kde
+
+# Normalization functions
+def z_score_normalization(times):
+    mean = np.mean(times)
+    std = np.std(times)
+    if std == 0:
+        return times - mean  # Avoid division by zero
+    return (times - mean) / std
+
+def min_max_normalization(times):
+    min_time = np.min(times)
+    max_time = np.max(times)
+    if max_time == min_time:
+        return times - min_time  # Avoid division by zero
+    return (times - min_time) / (max_time - min_time)
+
+def exponential_moving_average(times, alpha=0.3):
+    ema_times = []
+    ema = times[0]  # Start with the first value
+    for time in times:
+        ema = alpha * time + (1 - alpha) * ema
+        ema_times.append(ema)
+    return np.array(ema_times)
+
+def log_transformation(times):
+    return np.log(times + 1)  # Adding 1 to avoid log(0)
+
+def select_normalization(times, benchmark_name):
+    # Apply specific normalization methods based on benchmark type
+    if 'Disk' in benchmark_name or 'PeakDiskWrite' in benchmark_name:
+        # Use EMA or log normalization for disk benchmarks
+        normalized_times = exponential_moving_average(times)
+        if np.std(normalized_times) > np.std(log_transformation(times)):
+            normalized_times = log_transformation(times)
+        best_method = 'EMA or log'
+    else:
+        # Use z-score normalization for other benchmarks
+        normalized_times = z_score_normalization(times)
+        best_method = 'z-score'
+    return best_method, normalized_times
+
+def fetch_benchmark_data():
+    conn = sqlite3.connect('test_results.db')
+    df = pd.read_sql_query('SELECT * FROM benchmark_samples', conn)
+    conn.close()
+    return df
+
+def compute_machine_score():
+    df = fetch_benchmark_data()
+    benchmarks = df['benchmark_name'].unique()
+    
+    scores = {}
+    for benchmark in benchmarks:
+        times = df[df['benchmark_name'] == benchmark]['time'].values
+        if len(times) > 0:
+            best_method, normalized_times = select_normalization(times, benchmark)
+            scores[benchmark] = np.mean(normalized_times)
+    
+    # Aggregate scores (simple average for now)
+    composite_score = np.mean(list(scores.values()))
+    
+    # Apply normalization to the composite score for stability
+    composite_score_normalized = min_max_normalization(np.array([composite_score]))[0]  # Using min-max normalization
+
+    # Debug output
+    print("Scores per benchmark:", scores)
+    print("Composite score:", composite_score)
+    print("Normalized composite score:", composite_score_normalized)
+
+    return composite_score_normalized
+
+def analyze_clusters(times, num_clusters=3):
+    if len(times) > 0:
+        min_time = np.min(times)
+        max_time = np.max(times)
+        threshold = (max_time - min_time) / num_clusters
+        clusters = []
+        for i in range(num_clusters):
+            lower_bound = min_time + i * threshold
+            upper_bound = min_time + (i + 1) * threshold
+            cluster = times[(times >= lower_bound) & (times < upper_bound)]
+            clusters.append(cluster)
+        return clusters
+    return [times]
+
+app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+
+app.layout = dbc.Container([
+    dbc.Row([
+        dbc.Col(html.H1("Benchmark Dashboard"), className="mb-2")
+    ]),
+    dbc.Row([
+        dbc.Col([
+            dcc.Dropdown(
+                id='benchmark-dropdown',
+                options=[
+                    {'label': 'CPU', 'value': 'CPU'},
+                    {'label': 'Memory', 'value': 'Memory'},
+                    {'label': 'Disk', 'value': 'Disk'},
+                    {'label': 'IO', 'value': 'IO'},
+                    {'label': 'Peak Disk Write', 'value': 'PeakDiskWrite'},
+                    {'label': 'Machine Score', 'value': 'MachineScore'}
+                ],
+                value='CPU',
+                clearable=False
+            )
+        ], width=4),
+        dbc.Col([
+            dbc.Checkbox(
+                id='cluster-checkbox',
+                label='Show Clusters',
+                value=False
+            )
+        ], width=2)
+    ]),
+    dbc.Row([
+        dbc.Col([
+            dcc.Graph(id='benchmark-graph')
+        ])
+    ])
+])
+
+@app.callback(
+    Output('benchmark-graph', 'figure'),
+    [Input('benchmark-dropdown', 'value'), Input('cluster-checkbox', 'value')]
+)
+def update_graph(benchmark_name, show_clusters):
+    if benchmark_name == 'MachineScore':
+        score = compute_machine_score()
+        fig = px.bar(x=['Machine'], y=[score], labels={'x': 'Machine', 'y': 'Normalized Score'})
+        fig.update_layout(
+            title='Machine Composite Score',
+            yaxis_title='Normalized Score',
+            xaxis_title='Machine'
+        )
+    else:
+        df = fetch_benchmark_data()
+        filtered_df = df[df['benchmark_name'] == benchmark_name]
+        times = filtered_df['time'].values
+
+        if len(times) > 0:  # Ensure times is not empty
+            if show_clusters:
+                clusters = analyze_clusters(times)
+                fig = px.histogram(x=times, nbins=30, histnorm='probability density')  # Initialize with full data
+                for i, cluster in enumerate(clusters, 1):
+                    if len(cluster) > 0:
+                        best_method, normalized_times = select_normalization(cluster, benchmark_name)
+                        kde = gaussian_kde(normalized_times)
+                        x_range = np.linspace(min(normalized_times), max(normalized_times), 1000)
+                        kde_values = kde(x_range)
+                        
+                        # Add histogram and KDE for each cluster
+                        fig.add_trace(px.histogram(x=normalized_times, nbins=30, histnorm='probability density').data[0])
+                        fig.add_scatter(
+                            x=x_range,
+                            y=kde_values,
+                            mode='lines',
+                            name=f'Cluster {i} Density (Normalization: {best_method})'
+                        )
+            else:
+                # Automatically select the best normalization method for the full dataset
+                best_method, normalized_times = select_normalization(times, benchmark_name)
+                kde = gaussian_kde(normalized_times)
+                x_range = np.linspace(min(normalized_times), max(normalized_times), 1000)
+                kde_values = kde(x_range)
+                
+                # Create histogram with full dataset
+                fig = px.histogram(x=normalized_times, nbins=30, histnorm='probability density')
+                fig.add_scatter(
+                    x=x_range,
+                    y=kde_values,
+                    mode='lines',
+                    name='Density'
+                )
+        else:
+            fig = px.histogram()  # Initialize an empty histogram
+
+        fig.update_layout(
+            title=f'{benchmark_name} Benchmark Results' + (' with Clusters' if show_clusters else ''),
+            xaxis_title='Normalized Time' if len(times) > 0 else 'Time (seconds)',
+            yaxis_title='Density'
+        )
+
+    return fig
+
+if __name__ == '__main__':
+    app.run_server(debug=True)

testrium-0.1.0/testrium/utils.py

@@ -0,0 +1,140 @@
+import time
+
+def log_test_time(func):
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        elapsed_time = time.time() - start_time
+        print(f"{func.__name__} took {elapsed_time:.2f} seconds")
+        return result
+    return wrapper
+
+def verify_condition(condition, message="Verification failed"):
+    if not condition:
+        raise AssertionError(message)
+
+
+# TODO >>> Add a Events Manager that can save events locally
+# Events are temporary milestones that we can define to a test 
+# This allows us to log events that we expect the test to complete.
+
+from .common.sql_pool import SQLiteConnectionPool
+import os
+import pandas as pd
+
+THIS_DIR = os.getcwd()
+
+class Events_Manager:
+
+    def __init__(self, Unit:str, path:str):
+        """
+        if unit == "*" select all units data
+        """
+
+        pool = SQLiteConnectionPool(3, os.path.join(THIS_DIR, "Data.db"))
+        self.connection = pool.get_connection()
+
+        self.Unit = Unit
+
+        cur = self.connection.cursor()
+        cur.execute('''CREATE TABLE IF NOT EXISTS Events (
+            ID INTEGER PRIMARY KEY AUTOINCREMENT,
+            Unit TEXT,
+            StepCompleted TEXT,
+            EventType TEXT, 
+            EventKey TEXT,
+            Time NUMBER
+        )''')
+        
+    
+    def drop_events_table(self) -> None:
+        """Drop the Events table from the database."""
+    
+        try:
+            cur = self.connection.cursor()
+            
+            sql_drop_table_query = """DROP TABLE IF EXISTS Events"""
+            cur.execute(sql_drop_table_query)
+            
+            self.connection.commit()
+            print("Events table has been removed.")
+            
+        except Exception as e:
+            print(f"Error occurred while removing the Events table. Error: {e}")
+
+
+    def List_Events(self) -> dict:
+        
+        cur = self.connection.cursor()
+        
+        if self.Unit == "*":
+            sqlite_select_query = """SELECT * FROM Events"""
+            cur.execute(sqlite_select_query)
+        
+        else:
+            sqlite_select_query = """SELECT * FROM Events WHERE Unit = ?"""
+            Data = ((self.Unit, ))
+            cur.execute(sqlite_select_query, Data)
+        
+        df = cur.fetchall()
+        df = pd.DataFrame(df, columns=['ID', 'Unit', 'StepCompleted', 'EventType', 'EventKey', 'Time'])
+        dict_df = df.to_dict()
+        
+        return dict_df
+    
+    def Set_Event (self, step:str, event_type:str="Default", **kwargs):     
+
+        """
+        Set a event
+
+        event_type: str - can be:
+            - Default
+            - Exception
+            - Send
+            - Receive
+        
+        if event_type is Send and Receive it needs a predefined `event_key:str` kwarg,
+        the event key is a str and need to contain at least 16 digits that need to be random,
+        to generate a valid key pair and have 100% sure that this isn't registered you can use the 
+        helper `gen_valid_event_key.py` at Myscelium/tests/Logs/gen_valid_event_key.py
+
+        """
+        
+        if self.Unit == "*":
+            raise ValueError("Can't Set Event To Generalized Unit: '*'")
+
+        if event_type in ["Default", "Exception", "Send", "Receive"]:
+            pass
+        else:
+            raise ValueError("Event type can only be one of those: 'Default, Exception, Send, Receive'")
+
+        events = pd.DataFrame.from_dict(self.List_Events())   
+
+        for i in events.index:
+            if events.loc[i, "StepCompleted"] == step:
+                return
+            else:
+                continue
+
+        cur = self.connection.cursor()
+
+        ts = time.time()
+
+        event_key = ""
+
+        if event_type == "Send" or event_type == "Receive":
+
+            if not ("event_key" in kwargs):
+                raise "You need to to specify a event code to Send an Receive event_types"
+            else:   
+                pass
+
+            event_key = kwargs["event_key"]
+
+        Data = ((self.Unit, step, event_type, event_key, ts))
+
+        sqlite_insert_with_param = """INSERT INTO Events (Unit, StepCompleted, EventType, EventKey, Time) VALUES (?, ?, ?, ?, ?);"""
+        cur.execute(sqlite_insert_with_param, Data)
+        self.connection.commit()
+
+        return