dsa-profiler-rishad 0.1.1__tar.gz

dsa_profiler_rishad-0.1.1/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: dsa-profiler-rishad
+Version: 0.1.1
+Summary: A local-first profiling tool to benchmark and compare DSA solution efficiency.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.0.0
+
+# 📊 DSA Profiler (`dsa-profiler-rishad`)
+
+A local-first, production-grade profiling framework engineered for developers and students to benchmark Data Structures and Algorithms (DSA) solutions. The tool captures high-precision runtime execution metrics, monitors dynamic peak memory allocation, tracks local performance history via an embedded relational database, and utilizes empirical statistical curve-fitting to programmatically predict algorithmic Big-O complexities.
+
+## ✨ Core Engineering Features
+
+- **⏱️ High-Precision Performance Benchmarking:** Bypasses standard wrapper latencies using hardware-level system counters (`time.perf_counter`). Utilizes customizable multi-iteration tracking and calculates **median execution runtimes** to systematically filter out background operating system process jitter.
+- **🧠 Dynamic Peak Memory Tracking:** Integrates native virtual memory space tracking via `tracemalloc` to capture the exact maximum byte footprint utilized by an algorithm during execution.
+- **💾 Persistent Local Data Storage Engine:** Built with a serverless relational `sqlite3` data layer. Automatically initializes and manages a hidden repository file (`.dsa_profile_history.db`) inside the execution workspace to preserve historical performance states across terminal runs.
+- **📈 Automated Optimization Delta Engine:** Computes exact optimization shifts between successive approaches using structural percentage metrics. Generates beautiful, color-coded tabular comparisons (`rich`) displaying runtime shifts, memory gains, or regression warnings.
+- **🚀 Empirical Asymptotic Analyzer:** Runs solutions over variable scaling input sizes ($N$) and implements a **Pure-Python Ordinary Least Squares (OLS) Linear Regression Engine**. Computes Pearson Correlation Coefficients ($R^2$) across distinct linearized transformation spaces to predict mathematical time complexities ($O(1)$, $O(\log N)$, $O(N)$, $O(N \log N)$, $O(N^2)$).
+
+---
+
+## 🛠️ System Architecture & Mathematical Foundations
+
+### 1. The Optimization Delta Logic
+When consecutive alternative approaches are registered under the same `problem_id`, the system isolates the immediately preceding run from the relational database to calculate the exact structural evolution metric:
+
+$$\Delta \text{Time} = \left( \frac{\text{Time}_{\text{previous}} - \text{Time}_{\text{current}}}{\text{Time}_{\text{previous}}} \right) \times 100$$
+
+A positive result signals a **Speedup Success** (color-coded green), whereas a negative result automatically trips a **Performance Drop** warning (color-coded red).
+
+### 2. Empirical Big-O Curve Fitting
+Instead of reading code text structures statically, the library profiles data points across a scaling range of $N$ and transforms input parameters to find linear relationships. The system manual regression uses the Pearson Correlation Coefficient ($R$) formula:
+
+$$R = \frac{n\sum xy - (\sum x)(\sum y)}{\sqrt{[n\sum x^2 - (\sum x)^2][n\sum y^2 - (\sum y)^2]}}$$
+
+The model evaluating the highest Coefficient of Determination ($R^2$) closest to `1.0` is programmatically crowned as the predicted asymptotic complexity bound.
+
+---
+
+## 📦 Installation
+
+Ensure you have Python >= 3.8 installed, then fetch the package from the index:
+
+```bash
+pip install --index-url [https://test.pypi.org/simple/](https://test.pypi.org/simple/) --extra-index-url [https://pypi.org/simple/](https://pypi.org/simple/) dsa-profiler-rishad
+
+
+🚀 Practical Guide & Usage
+1. Comparative Solution Tracking
+Track execution shifts across different iterations of an optimization cycle:
+
+import time
+from dsa_profiler import profile_dsa
+
+@profile_dsa(problem_id="two-sum", run_name="brute-force", iteration=3)
+def solve_via_brute():
+    time.sleep(0.1)  # Simulate nested loop overhead
+    return "done"
+
+@profile_dsa(problem_id="two-sum", run_name="hash-map-optimized", iteration=3)
+def solve_via_map():
+    time.sleep(0.01) # Simulate high-speed lookup
+    return "done"
+
+if __name__ == "__main__":
+    solve_via_brute()
+    solve_via_map()
+
+
+2. Algorithmic Big-O Estimation
+Empirically isolate the asymptotic complexity profile of an approach over expanding dataset sizes:
+
+import time
+from dsa_profiler import profile_big_o
+
+@profile_big_o(n_range=[100, 500, 1000, 2000])
+def simulate_linear_growth(n):
+    for i in range(n):
+        pass
+    time.sleep(n * 0.00001)
+
+if __name__ == "__main__":
+    simulate_linear_growth()
+
+
+🧱 Project Directory Layout
+dsa_profiler/
+│
+├── src/
+│   └── dsa_profiler/
+│       ├── __init__.py     # Clean package API exports
+│       ├── core.py         # Main execution interceptor decorators
+│       ├── storage.py      # SQLite data access persistence layer
+│       ├── reporter.py     # Analytics engine & UI generator
+│       └── analyzer.py     # Mathematical OLS regression engine
+│
+├── tests/
+│   └── demo.py             # Sandbox execution suite
+│
+├── pyproject.toml          # Package distribution metadata configurations
+└── README.md               # Architecture documentation centerpiece
+
+
+📄 License
+This framework is open-source software licensed under the MIT License.
+
+---
+
+### What to do next:
+1. Save this into `README.md`.
+2. Follow our rebuild sequence to update the package version to `0.1.1` in `pyproject.toml` and compile it:
+   ```cmd
+   rmdir /s /q dist
+   python -m build
+
+
+Upload it to TestPyPI:
+
+python -m twine upload --repository testpypi dist/*

dsa_profiler_rishad-0.1.1/README.md

@@ -0,0 +1,112 @@
+# 📊 DSA Profiler (`dsa-profiler-rishad`)
+
+A local-first, production-grade profiling framework engineered for developers and students to benchmark Data Structures and Algorithms (DSA) solutions. The tool captures high-precision runtime execution metrics, monitors dynamic peak memory allocation, tracks local performance history via an embedded relational database, and utilizes empirical statistical curve-fitting to programmatically predict algorithmic Big-O complexities.
+
+## ✨ Core Engineering Features
+
+- **⏱️ High-Precision Performance Benchmarking:** Bypasses standard wrapper latencies using hardware-level system counters (`time.perf_counter`). Utilizes customizable multi-iteration tracking and calculates **median execution runtimes** to systematically filter out background operating system process jitter.
+- **🧠 Dynamic Peak Memory Tracking:** Integrates native virtual memory space tracking via `tracemalloc` to capture the exact maximum byte footprint utilized by an algorithm during execution.
+- **💾 Persistent Local Data Storage Engine:** Built with a serverless relational `sqlite3` data layer. Automatically initializes and manages a hidden repository file (`.dsa_profile_history.db`) inside the execution workspace to preserve historical performance states across terminal runs.
+- **📈 Automated Optimization Delta Engine:** Computes exact optimization shifts between successive approaches using structural percentage metrics. Generates beautiful, color-coded tabular comparisons (`rich`) displaying runtime shifts, memory gains, or regression warnings.
+- **🚀 Empirical Asymptotic Analyzer:** Runs solutions over variable scaling input sizes ($N$) and implements a **Pure-Python Ordinary Least Squares (OLS) Linear Regression Engine**. Computes Pearson Correlation Coefficients ($R^2$) across distinct linearized transformation spaces to predict mathematical time complexities ($O(1)$, $O(\log N)$, $O(N)$, $O(N \log N)$, $O(N^2)$).
+
+---
+
+## 🛠️ System Architecture & Mathematical Foundations
+
+### 1. The Optimization Delta Logic
+When consecutive alternative approaches are registered under the same `problem_id`, the system isolates the immediately preceding run from the relational database to calculate the exact structural evolution metric:
+
+$$\Delta \text{Time} = \left( \frac{\text{Time}_{\text{previous}} - \text{Time}_{\text{current}}}{\text{Time}_{\text{previous}}} \right) \times 100$$
+
+A positive result signals a **Speedup Success** (color-coded green), whereas a negative result automatically trips a **Performance Drop** warning (color-coded red).
+
+### 2. Empirical Big-O Curve Fitting
+Instead of reading code text structures statically, the library profiles data points across a scaling range of $N$ and transforms input parameters to find linear relationships. The system manual regression uses the Pearson Correlation Coefficient ($R$) formula:
+
+$$R = \frac{n\sum xy - (\sum x)(\sum y)}{\sqrt{[n\sum x^2 - (\sum x)^2][n\sum y^2 - (\sum y)^2]}}$$
+
+The model evaluating the highest Coefficient of Determination ($R^2$) closest to `1.0` is programmatically crowned as the predicted asymptotic complexity bound.
+
+---
+
+## 📦 Installation
+
+Ensure you have Python >= 3.8 installed, then fetch the package from the index:
+
+```bash
+pip install --index-url [https://test.pypi.org/simple/](https://test.pypi.org/simple/) --extra-index-url [https://pypi.org/simple/](https://pypi.org/simple/) dsa-profiler-rishad
+
+
+🚀 Practical Guide & Usage
+1. Comparative Solution Tracking
+Track execution shifts across different iterations of an optimization cycle:
+
+import time
+from dsa_profiler import profile_dsa
+
+@profile_dsa(problem_id="two-sum", run_name="brute-force", iteration=3)
+def solve_via_brute():
+    time.sleep(0.1)  # Simulate nested loop overhead
+    return "done"
+
+@profile_dsa(problem_id="two-sum", run_name="hash-map-optimized", iteration=3)
+def solve_via_map():
+    time.sleep(0.01) # Simulate high-speed lookup
+    return "done"
+
+if __name__ == "__main__":
+    solve_via_brute()
+    solve_via_map()
+
+
+2. Algorithmic Big-O Estimation
+Empirically isolate the asymptotic complexity profile of an approach over expanding dataset sizes:
+
+import time
+from dsa_profiler import profile_big_o
+
+@profile_big_o(n_range=[100, 500, 1000, 2000])
+def simulate_linear_growth(n):
+    for i in range(n):
+        pass
+    time.sleep(n * 0.00001)
+
+if __name__ == "__main__":
+    simulate_linear_growth()
+
+
+🧱 Project Directory Layout
+dsa_profiler/
+│
+├── src/
+│   └── dsa_profiler/
+│       ├── __init__.py     # Clean package API exports
+│       ├── core.py         # Main execution interceptor decorators
+│       ├── storage.py      # SQLite data access persistence layer
+│       ├── reporter.py     # Analytics engine & UI generator
+│       └── analyzer.py     # Mathematical OLS regression engine
+│
+├── tests/
+│   └── demo.py             # Sandbox execution suite
+│
+├── pyproject.toml          # Package distribution metadata configurations
+└── README.md               # Architecture documentation centerpiece
+
+
+📄 License
+This framework is open-source software licensed under the MIT License.
+
+---
+
+### What to do next:
+1. Save this into `README.md`.
+2. Follow our rebuild sequence to update the package version to `0.1.1` in `pyproject.toml` and compile it:
+   ```cmd
+   rmdir /s /q dist
+   python -m build
+
+
+Upload it to TestPyPI:
+
+python -m twine upload --repository testpypi dist/*

dsa_profiler_rishad-0.1.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dsa-profiler-rishad"
+version = "0.1.1"
+description = "A local-first profiling tool to benchmark and compare DSA solution efficiency."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = [
+    "rich>=13.0.0",  
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

dsa_profiler_rishad-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dsa_profiler_rishad-0.1.1/src/dsa_profiler/__init__.py

@@ -0,0 +1,6 @@
+# src/dsa_profiler/__init__.py
+
+from dsa_profiler.core import profile_dsa, profile_big_o
+
+__version__ = "0.1.0"
+__all__ = ["profile_dsa", "profile_big_o"]

dsa_profiler_rishad-0.1.1/src/dsa_profiler/analyzer.py

@@ -0,0 +1,56 @@
+import math
+from typing import List, Tuple
+
+class BigOAnalyzer:
+    @staticmethod
+    def estimate_complexity(data_points: List[Tuple[int, float]]) -> str:
+        
+        if len(data_points) < 3:
+            return "Inconclusive (Need at least 3 data points)"
+
+        
+        models = {
+            "O(1)": lambda n, t: (1.0, t),
+            "O(log N)": lambda n, t: (math.log(n) if n > 1 else 0.0, t),
+            "O(N)": lambda n, t: (float(n), t),
+            "O(N log N)": lambda n, t: (n * math.log(n) if n > 1 else 0.0, t),
+            "O(N^2)": lambda n, t: (float(n ** 2), t)
+        }
+
+        best_fit = "O(1)"
+        highest_r_squared = -1.0
+
+        
+        for complexity, transform in models.items():
+            try:
+                transformed_points = [transform(n, t) for n, t in data_points]
+                r_sq = BigOAnalyzer._calculate_r_squared(transformed_points)
+                
+                if r_sq > highest_r_squared:
+                    highest_r_squared = r_sq
+                    best_fit = complexity
+            except (ValueError, ZeroDivisionError):
+                continue
+
+        return best_fit
+
+    @staticmethod
+    def _calculate_r_squared(points: List[Tuple[float, float]]) -> float:
+        
+        n = len(points)
+        sum_x = sum(p[0] for p in points)
+        sum_y = sum(p[1] for p in points)
+        sum_x_sq = sum(p[0]**2 for p in points)
+        sum_y_sq = sum(p[1]**2 for p in points)
+        sum_xy = sum(p[0] * p[1] for p in points)
+
+        numerator = (n * sum_xy) - (sum_x * sum_y)
+        denominator_x = (n * sum_x_sq) - (sum_x ** 2)
+        denominator_y = (n * sum_y_sq) - (sum_y ** 2)
+
+        if denominator_x == 0 or denominator_y == 0:
+            return 0.0
+
+        
+        r = numerator / math.sqrt(denominator_x * denominator_y)
+        return r ** 2

dsa_profiler_rishad-0.1.1/src/dsa_profiler/core.py

@@ -0,0 +1,102 @@
+import functools
+import time
+import tracemalloc
+from typing import Any,Callable,Dict,List
+from dsa_profiler.storage import StorageEngine
+from dsa_profiler.reporter import ConsoleReporter
+from dsa_profiler.analyzer import BigOAnalyzer
+
+storage=StorageEngine()
+
+def profile_dsa(problem_id:str,run_name:str,iteration:int=5)->Callable:
+    
+    def decorator(func:Callable[...,Any])->Callable[...,Any]:
+        @functools.wraps(func)
+        def wrapper(*args:Any,**kwargs:Any)->Any:
+            
+            tracemalloc.start()
+            execution_times=[]
+            result=None
+            
+            for i in range(iteration):
+                
+                start_time=time.perf_counter()
+                if i==0:
+                    result=func(*args,**kwargs)
+                else:
+                    _=func(*args,**kwargs)
+                    
+                    
+                end_time=time.perf_counter()
+                execution_times.append((end_time-start_time)*1000)
+                
+            _,peak_bytes=tracemalloc.get_traced_memory()
+            tracemalloc.stop()
+            
+            execution_times.sort()
+            median_time_ms=execution_times[len(execution_times)//2]
+            peak_memory_mb=peak_bytes/(1024*1024)
+            
+            storage.save_run(problem_id,run_name,median_time_ms,peak_memory_mb)
+            
+            historical_runs=storage.get_history(problem_id=problem_id)
+            
+            current_run_payload = {
+                "run_name": run_name,
+                "execution_time_ms": median_time_ms,
+                "peak_memory_mb": peak_memory_mb
+            }
+            
+            ConsoleReporter.generate_report(problem_id,current_run_payload,historical_runs)
+            
+            return result
+        return wrapper
+    return decorator
+
+
+def profile_big_o(n_range: List[int]) -> Callable:
+    
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            from rich.console import Console
+            from rich.panel import Panel
+            console = Console()
+            
+            data_points = []
+            result = None
+
+            console.print(f"\n[bold magenta][Big-O Analyzer][/bold magenta] Benchmarking [cyan]{func.__name__}[/cyan] over N = {n_range}...")
+
+            for n in n_range:
+                
+                tracemalloc.start()
+                start_time = time.perf_counter()
+                
+                
+                result = func(n, *args, **kwargs)
+                
+                end_time = time.perf_counter()
+                _, peak_bytes = tracemalloc.get_traced_memory()
+                tracemalloc.stop()
+
+                time_ms = (end_time - start_time) * 1000
+                data_points.append((n, time_ms))
+                
+                console.print(f"  • N = {n:<7} | Time: {time_ms:.4f} ms | Peak Memory: {peak_bytes/(1024*1024):.4f} MB")
+
+            
+            estimated_complexity = BigOAnalyzer.estimate_complexity(data_points)
+
+            console.print(Panel(
+                f"Based on empirical growth trends, the estimated time complexity is:\n\n[bold green]🚀 {estimated_complexity}[/bold green]",
+                title="[bold magenta]Asymptotic Analysis Result[/bold magenta]",
+                border_style="magenta",
+                expand=False
+            ))
+            
+            return result
+        return wrapper
+    return decorator
+            
+            

dsa_profiler_rishad-0.1.1/src/dsa_profiler/reporter.py

@@ -0,0 +1,68 @@
+from typing import List, Dict, Any
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+console = Console()
+
+class ConsoleReporter:
+    @staticmethod
+    def generate_report(problem_id: str, current_run: Dict[str, Any], history: List[Dict[str, Any]]) -> None:
+        """Calculates performance deltas and displays a beautiful terminal analytics dashboard."""
+        
+        
+        table = Table(title=f"Performance Logs for: [bold cyan]{problem_id}[/bold cyan]", title_justify="left")
+        table.add_column("Run Name", style="bold white")
+        table.add_column("Execution Time", justify="right")
+        table.add_column("Peak Memory", justify="right")
+        table.add_column("Timestamp", style="dim", justify="center")
+        
+        
+        for run in history:
+            
+            if run['run_name'] == current_run['run_name'] and run['execution_time_ms'] == current_run['execution_time_ms']:
+                table.add_row(
+                    f"[bold yellow]→ {run['run_name']}[/bold yellow]",
+                    f"[bold yellow]{run['execution_time_ms']:.4f} ms[/bold yellow]",
+                    f"[bold yellow]{run['peak_memory_mb']:.4f} MB[/bold yellow]",
+                    run['timestamp']
+                )
+            else:
+                table.add_row(
+                    run['run_name'],
+                    f"{run['execution_time_ms']:.4f} ms",
+                    f"{run['peak_memory_mb']:.4f} MB",
+                    run['timestamp']
+                )
+
+        
+        console.print("\n")
+        console.print(table)
+        
+        
+        if len(history) > 1:
+            prev_run = history[-2] 
+            
+            
+            time_delta = ((prev_run['execution_time_ms'] - current_run['execution_time_ms']) / prev_run['execution_time_ms']) * 100
+            mem_delta = ((prev_run['peak_memory_mb'] - current_run['peak_memory_mb']) / prev_run['peak_memory_mb']) * 100
+            
+            if time_delta >= 0:
+                time_msg = f"[bold green]🔥 Speedup Success:[/bold green] Your new approach is [bold green]{time_delta:.1f}% FASTER[/bold green] than '{prev_run['run_name']}'!"
+            else:
+                time_msg = f"[bold red]⚠️ Performance Drop:[/bold red] Execution time slowed down by [bold red]{abs(time_delta):.1f}%[/bold red]."
+                
+            if mem_delta >= 0:
+                mem_msg = f"[bold green]📉 Memory Optimization:[/bold green] Saved [bold green]{mem_delta:.1f}%[/bold green] more space."
+            else:
+                mem_msg = f"[bold yellow]⚠️ Memory Overhead:[/bold yellow] This approach consumed [bold yellow]{abs(mem_delta):.1f}% MORE[/bold yellow] RAM."
+                
+            summary_panel = Panel(
+                f"{time_msg}\n{mem_msg}",
+                title="[bold gold1]Optimization Insights[/bold gold1]",
+                border_style="bright_blue",
+                expand=False
+            )
+            console.print(summary_panel)
+        else:
+            console.print(Panel("[bold green]✨ Baseline Recorded![/bold green]\nCreate an alternate solution setup to generate comparative analytics graphs.", title="Insights", expand=False))

dsa_profiler_rishad-0.1.1/src/dsa_profiler/storage.py

@@ -0,0 +1,57 @@
+import os
+import sqlite3
+from typing import Dict,List,Any
+
+class StorageEngine:
+    def __init__(self,db_name:str=".dsa_profile_history.db"):
+        self.db_name=db_name
+        self._initialize_db()
+        
+    def _get_connection(self)->sqlite3.Connection:
+        return sqlite3.connect(self.db_name)
+    
+    def _initialize_db(self)->None:
+        schema="""
+        CREATE TABLE IF NOT EXISTS dsa_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            problem_id TEXT NOT NULL,
+            run_name TEXT NOT NULL,
+            execution_time_ms REAL NOT NULL,
+            peak_memory_mb REAL NOT NULL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        """
+        
+        with self._get_connection() as conn:
+            cursor=conn.cursor()
+            cursor.execute(schema)
+            conn.commit()
+            
+    def save_run(self,problem_id:str,run_name:str,time_ms:float,memory_mb:float)->None:
+        
+        query="""
+        INSERT INTO dsa_runs (problem_id,run_name,execution_time_ms,peak_memory_mb) VALUES (?,?,?,?)
+        """
+        
+        with self._get_connection() as conn:
+            cursor=conn.cursor()
+            cursor.execute(query,(problem_id,run_name,time_ms,memory_mb))
+            conn.commit()
+            
+    def get_history(self,problem_id:str)->List[Dict[str,Any]]:
+        
+        query="""
+        SELECT run_name,execution_time_ms,peak_memory_mb,timestamp FROM dsa_runs WHERE problem_id = ? 
+        ORDER BY timestamp ASC;
+        """
+        with self._get_connection() as conn:
+            conn.row_factory=sqlite3.Row
+            cursor=conn.cursor()
+            cursor.execute(query,(problem_id,))
+            
+            rows=cursor.fetchall()
+            return [dict(row) for row in rows]
+        
+        
+        
+        

dsa_profiler_rishad-0.1.1/src/dsa_profiler_rishad.egg-info/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: dsa-profiler-rishad
+Version: 0.1.1
+Summary: A local-first profiling tool to benchmark and compare DSA solution efficiency.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.0.0
+
+# 📊 DSA Profiler (`dsa-profiler-rishad`)
+
+A local-first, production-grade profiling framework engineered for developers and students to benchmark Data Structures and Algorithms (DSA) solutions. The tool captures high-precision runtime execution metrics, monitors dynamic peak memory allocation, tracks local performance history via an embedded relational database, and utilizes empirical statistical curve-fitting to programmatically predict algorithmic Big-O complexities.
+
+## ✨ Core Engineering Features
+
+- **⏱️ High-Precision Performance Benchmarking:** Bypasses standard wrapper latencies using hardware-level system counters (`time.perf_counter`). Utilizes customizable multi-iteration tracking and calculates **median execution runtimes** to systematically filter out background operating system process jitter.
+- **🧠 Dynamic Peak Memory Tracking:** Integrates native virtual memory space tracking via `tracemalloc` to capture the exact maximum byte footprint utilized by an algorithm during execution.
+- **💾 Persistent Local Data Storage Engine:** Built with a serverless relational `sqlite3` data layer. Automatically initializes and manages a hidden repository file (`.dsa_profile_history.db`) inside the execution workspace to preserve historical performance states across terminal runs.
+- **📈 Automated Optimization Delta Engine:** Computes exact optimization shifts between successive approaches using structural percentage metrics. Generates beautiful, color-coded tabular comparisons (`rich`) displaying runtime shifts, memory gains, or regression warnings.
+- **🚀 Empirical Asymptotic Analyzer:** Runs solutions over variable scaling input sizes ($N$) and implements a **Pure-Python Ordinary Least Squares (OLS) Linear Regression Engine**. Computes Pearson Correlation Coefficients ($R^2$) across distinct linearized transformation spaces to predict mathematical time complexities ($O(1)$, $O(\log N)$, $O(N)$, $O(N \log N)$, $O(N^2)$).
+
+---
+
+## 🛠️ System Architecture & Mathematical Foundations
+
+### 1. The Optimization Delta Logic
+When consecutive alternative approaches are registered under the same `problem_id`, the system isolates the immediately preceding run from the relational database to calculate the exact structural evolution metric:
+
+$$\Delta \text{Time} = \left( \frac{\text{Time}_{\text{previous}} - \text{Time}_{\text{current}}}{\text{Time}_{\text{previous}}} \right) \times 100$$
+
+A positive result signals a **Speedup Success** (color-coded green), whereas a negative result automatically trips a **Performance Drop** warning (color-coded red).
+
+### 2. Empirical Big-O Curve Fitting
+Instead of reading code text structures statically, the library profiles data points across a scaling range of $N$ and transforms input parameters to find linear relationships. The system manual regression uses the Pearson Correlation Coefficient ($R$) formula:
+
+$$R = \frac{n\sum xy - (\sum x)(\sum y)}{\sqrt{[n\sum x^2 - (\sum x)^2][n\sum y^2 - (\sum y)^2]}}$$
+
+The model evaluating the highest Coefficient of Determination ($R^2$) closest to `1.0` is programmatically crowned as the predicted asymptotic complexity bound.
+
+---
+
+## 📦 Installation
+
+Ensure you have Python >= 3.8 installed, then fetch the package from the index:
+
+```bash
+pip install --index-url [https://test.pypi.org/simple/](https://test.pypi.org/simple/) --extra-index-url [https://pypi.org/simple/](https://pypi.org/simple/) dsa-profiler-rishad
+
+
+🚀 Practical Guide & Usage
+1. Comparative Solution Tracking
+Track execution shifts across different iterations of an optimization cycle:
+
+import time
+from dsa_profiler import profile_dsa
+
+@profile_dsa(problem_id="two-sum", run_name="brute-force", iteration=3)
+def solve_via_brute():
+    time.sleep(0.1)  # Simulate nested loop overhead
+    return "done"
+
+@profile_dsa(problem_id="two-sum", run_name="hash-map-optimized", iteration=3)
+def solve_via_map():
+    time.sleep(0.01) # Simulate high-speed lookup
+    return "done"
+
+if __name__ == "__main__":
+    solve_via_brute()
+    solve_via_map()
+
+
+2. Algorithmic Big-O Estimation
+Empirically isolate the asymptotic complexity profile of an approach over expanding dataset sizes:
+
+import time
+from dsa_profiler import profile_big_o
+
+@profile_big_o(n_range=[100, 500, 1000, 2000])
+def simulate_linear_growth(n):
+    for i in range(n):
+        pass
+    time.sleep(n * 0.00001)
+
+if __name__ == "__main__":
+    simulate_linear_growth()
+
+
+🧱 Project Directory Layout
+dsa_profiler/
+│
+├── src/
+│   └── dsa_profiler/
+│       ├── __init__.py     # Clean package API exports
+│       ├── core.py         # Main execution interceptor decorators
+│       ├── storage.py      # SQLite data access persistence layer
+│       ├── reporter.py     # Analytics engine & UI generator
+│       └── analyzer.py     # Mathematical OLS regression engine
+│
+├── tests/
+│   └── demo.py             # Sandbox execution suite
+│
+├── pyproject.toml          # Package distribution metadata configurations
+└── README.md               # Architecture documentation centerpiece
+
+
+📄 License
+This framework is open-source software licensed under the MIT License.
+
+---
+
+### What to do next:
+1. Save this into `README.md`.
+2. Follow our rebuild sequence to update the package version to `0.1.1` in `pyproject.toml` and compile it:
+   ```cmd
+   rmdir /s /q dist
+   python -m build
+
+
+Upload it to TestPyPI:
+
+python -m twine upload --repository testpypi dist/*

dsa_profiler_rishad-0.1.1/src/dsa_profiler_rishad.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/dsa_profiler/__init__.py
+src/dsa_profiler/analyzer.py
+src/dsa_profiler/core.py
+src/dsa_profiler/reporter.py
+src/dsa_profiler/storage.py
+src/dsa_profiler_rishad.egg-info/PKG-INFO
+src/dsa_profiler_rishad.egg-info/SOURCES.txt
+src/dsa_profiler_rishad.egg-info/dependency_links.txt
+src/dsa_profiler_rishad.egg-info/requires.txt
+src/dsa_profiler_rishad.egg-info/top_level.txt

dsa_profiler_rishad-0.1.1/src/dsa_profiler_rishad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dsa_profiler_rishad-0.1.1/src/dsa_profiler_rishad.egg-info/requires.txt

@@ -0,0 +1 @@
+rich>=13.0.0

dsa_profiler_rishad-0.1.1/src/dsa_profiler_rishad.egg-info/top_level.txt

@@ -0,0 +1 @@
+dsa_profiler