simple_function_benchmark 0.1.4__tar.gz

simple_function_benchmark-0.1.4/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: simple_function_benchmark
+Version: 0.1.4
+Summary: Simple benchmarking library for comparing algorithm runtime
+Author-email: ControlAltPete <peter@petertheobald.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Benchmark
+
+A simple, easy-to-use Python benchmarking library for comparing algorithm performance.
+[Github page](https://github.com/PeterTheobald/HackerDojoPythonGroup/tree/main/PyPI)
+
+## Features
+
+- 🚀 **Simple API** - Compare multiple algorithms with just a few lines of code
+- 📊 **Detailed Results** - Get setup time, total time, average time, and performance comparisons
+- 🔄 **Progress Tracking** - Real-time progress updates during long-running benchmarks
+- 🛡️ **Error Handling** - Gracefully handles algorithm failures without stopping the entire benchmark
+- 📈 **Performance Ratios** - Automatically shows how much slower each algorithm is compared to the best
+
+## Installation
+
+```bash
+pip install benchmark
+```
+
+## Quick Start
+
+```python
+import benchmark
+
+# Define your algorithms to compare
+algorithms = [
+    {
+        "title": "Bubble Sort",
+        "algorithm_fn": bubble_sort,
+        "setup_fn": lambda: [3, 1, 4, 1, 5, 9, 2, 6]
+    },
+    {
+        "title": "Python's sorted()",
+        "algorithm_fn": sorted,
+        "setup_fn": lambda: [3, 1, 4, 1, 5, 9, 2, 6]
+    }
+]
+
+# Run the benchmark
+results = benchmark.run(algorithms, REPEAT=1000)
+```
+
+## Usage
+
+### Basic Example
+
+```python
+import benchmark
+
+def algorithm1(data):
+    return sorted(data)
+
+def algorithm2(data):
+    return list(reversed(sorted(data, reverse=True)))
+
+algorithms = [
+    {
+        "title": "Standard sort",
+        "algorithm_fn": algorithm1,
+        "setup_fn": lambda: [5, 2, 8, 1, 9]
+    },
+    {
+        "title": "Reverse then reverse",
+        "algorithm_fn": algorithm2,
+        "setup_fn": lambda: [5, 2, 8, 1, 9]
+    }
+]
+
+results = benchmark.run(algorithms, REPEAT=10000, verbose=True)
+```
+
+### Output Example
+
+```
+[1/2] Running: Standard sort... Done (0.05s)
+[2/2] Running: Reverse then reverse... Done (0.08s)
+
+Benchmark Results:
+Standard sort                       setup: 0.0000s  total: 0.0500s  avg: 5.00us <-- BEST
+Reverse then reverse                setup: 0.0000s  total: 0.0800s  avg: 8.00us (1.60x slower)
+```
+
+## API Reference
+
+### `benchmark.run(algorithms, REPEAT=1000, verbose=True)`
+
+Run a benchmark comparing multiple algorithms.
+
+**Parameters:**
+- `algorithms` (List[Dict]): List of algorithm dictionaries with keys:
+  - `algorithm_fn` (Callable): The function to benchmark
+  - `title` (str): Display name for the algorithm
+  - `setup_fn` (Callable, optional): Function called before timing to prepare test data
+- `REPEAT` (int, default=1000): Number of times to run each algorithm
+- `verbose` (bool, default=True): Whether to print progress and results
+
+**Returns:**
+- List[Dict]: Results for each algorithm containing:
+  - `title`: Algorithm name
+  - `setup_time`: Time spent in setup
+  - `total_time`: Total execution time
+  - `avg_time`: Average time per iteration
+  - `last_result`: Result from the last iteration
+  - `total_perf`: Combined setup + execution time
+  - `error`: Error message if the algorithm failed, None otherwise
+
+## Examples
+
+See the included demo in `benchmark.py` which compares sorting algorithms:
+- Bubble Sort
+- Timsort (Python's built-in `sorted()`)
+- Heap Sort
+- Quicksort
+
+## Requirements
+
+- Python >= 3.7
+
+## License
+
+MIT License
+
+## Author
+
+ControlAltPete (peter@petertheobald.com)

simple_function_benchmark-0.1.4/README.md

@@ -0,0 +1,125 @@
+# Benchmark
+
+A simple, easy-to-use Python benchmarking library for comparing algorithm performance.
+[Github page](https://github.com/PeterTheobald/HackerDojoPythonGroup/tree/main/PyPI)
+
+## Features
+
+- 🚀 **Simple API** - Compare multiple algorithms with just a few lines of code
+- 📊 **Detailed Results** - Get setup time, total time, average time, and performance comparisons
+- 🔄 **Progress Tracking** - Real-time progress updates during long-running benchmarks
+- 🛡️ **Error Handling** - Gracefully handles algorithm failures without stopping the entire benchmark
+- 📈 **Performance Ratios** - Automatically shows how much slower each algorithm is compared to the best
+
+## Installation
+
+```bash
+pip install benchmark
+```
+
+## Quick Start
+
+```python
+import benchmark
+
+# Define your algorithms to compare
+algorithms = [
+    {
+        "title": "Bubble Sort",
+        "algorithm_fn": bubble_sort,
+        "setup_fn": lambda: [3, 1, 4, 1, 5, 9, 2, 6]
+    },
+    {
+        "title": "Python's sorted()",
+        "algorithm_fn": sorted,
+        "setup_fn": lambda: [3, 1, 4, 1, 5, 9, 2, 6]
+    }
+]
+
+# Run the benchmark
+results = benchmark.run(algorithms, REPEAT=1000)
+```
+
+## Usage
+
+### Basic Example
+
+```python
+import benchmark
+
+def algorithm1(data):
+    return sorted(data)
+
+def algorithm2(data):
+    return list(reversed(sorted(data, reverse=True)))
+
+algorithms = [
+    {
+        "title": "Standard sort",
+        "algorithm_fn": algorithm1,
+        "setup_fn": lambda: [5, 2, 8, 1, 9]
+    },
+    {
+        "title": "Reverse then reverse",
+        "algorithm_fn": algorithm2,
+        "setup_fn": lambda: [5, 2, 8, 1, 9]
+    }
+]
+
+results = benchmark.run(algorithms, REPEAT=10000, verbose=True)
+```
+
+### Output Example
+
+```
+[1/2] Running: Standard sort... Done (0.05s)
+[2/2] Running: Reverse then reverse... Done (0.08s)
+
+Benchmark Results:
+Standard sort                       setup: 0.0000s  total: 0.0500s  avg: 5.00us <-- BEST
+Reverse then reverse                setup: 0.0000s  total: 0.0800s  avg: 8.00us (1.60x slower)
+```
+
+## API Reference
+
+### `benchmark.run(algorithms, REPEAT=1000, verbose=True)`
+
+Run a benchmark comparing multiple algorithms.
+
+**Parameters:**
+- `algorithms` (List[Dict]): List of algorithm dictionaries with keys:
+  - `algorithm_fn` (Callable): The function to benchmark
+  - `title` (str): Display name for the algorithm
+  - `setup_fn` (Callable, optional): Function called before timing to prepare test data
+- `REPEAT` (int, default=1000): Number of times to run each algorithm
+- `verbose` (bool, default=True): Whether to print progress and results
+
+**Returns:**
+- List[Dict]: Results for each algorithm containing:
+  - `title`: Algorithm name
+  - `setup_time`: Time spent in setup
+  - `total_time`: Total execution time
+  - `avg_time`: Average time per iteration
+  - `last_result`: Result from the last iteration
+  - `total_perf`: Combined setup + execution time
+  - `error`: Error message if the algorithm failed, None otherwise
+
+## Examples
+
+See the included demo in `benchmark.py` which compares sorting algorithms:
+- Bubble Sort
+- Timsort (Python's built-in `sorted()`)
+- Heap Sort
+- Quicksort
+
+## Requirements
+
+- Python >= 3.7
+
+## License
+
+MIT License
+
+## Author
+
+ControlAltPete (peter@petertheobald.com)

simple_function_benchmark-0.1.4/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "simple_function_benchmark"
+version = "0.1.4"
+description = "Simple benchmarking library for comparing algorithm runtime"
+authors = [{name = "ControlAltPete", email = "peter@petertheobald.com"}]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+]

simple_function_benchmark-0.1.4/setup.cfg

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

simple_function_benchmark-0.1.4/src/benchmark/__init__.py

@@ -0,0 +1,8 @@
+"""
+benchmark - Simple benchmarking library for comparing algorithm runtime
+"""
+
+from .benchmark import run
+
+__version__ = "0.1.0"
+__all__ = ["run"]

simple_function_benchmark-0.1.4/src/benchmark/benchmark.py

@@ -0,0 +1,115 @@
+# benchmark.py
+# Simple benchmarking library for running several different algorithms and comparing
+# their runtime
+# ControlAltPete 2026
+
+# ToDo: Add @decorator support for easy function benchmarking
+#       instead of requiring dicts with 'algorithm_fn' and 'setup_fn' keys
+# ToDo: Add correctness checking support and reporting (optional expected result input)
+# ToDo: Add memory usage tracking
+# ToDo: Add more detailed statistical analysis (min, max, stddev)
+
+import time
+from typing import Any, Dict, List
+
+
+def run(
+    algorithms: List[Dict[str, Any]], REPEAT: int = 1000, verbose: bool = True
+) -> List[Dict[str, Any]]:
+    """
+    Run a benchmark on a list of algorithms.
+    Each algorithm is a dict with keys:
+        'algorithm_fn': function to benchmark (takes setup result as input)
+        'title': string title for reporting
+        'setup_fn': function to call before timing (no args, returns input for algorithm_fn)
+    """
+    results: List[Dict[str, Any]] = []
+    best_idx = None
+    best_total = float("inf")
+    num_algos = len(algorithms)
+
+    for idx, algo in enumerate(algorithms):
+        title = algo.get("title", "Untitled")
+        algorithm_fn = algo["algorithm_fn"]
+        setup_fn = algo.get("setup_fn", lambda: None)
+
+        if verbose:
+            print(f"[{idx+1}/{num_algos}] Running: {title}...", end="", flush=True)
+
+        try:
+            # Setup timing
+            t_setup0 = time.perf_counter()
+            setup_data = setup_fn()
+            t_setup1 = time.perf_counter()
+            setup_time = t_setup1 - t_setup0
+            # Warmup (optional, not timed)
+            algorithm_fn(setup_data)
+            # Timing
+            result = None
+            t0 = time.perf_counter()
+
+            # Show progress every 10% or at key intervals
+            progress_interval = max(1, REPEAT // 10)
+            for i in range(REPEAT):
+                result = algorithm_fn(setup_data)
+                if verbose and (i + 1) % progress_interval == 0:
+                    percent = (i + 1) / REPEAT * 100
+                    print(
+                        f"\r[{idx+1}/{num_algos}] Running: {title}... {percent:.0f}%",
+                        end="",
+                        flush=True,
+                    )
+
+            t1 = time.perf_counter()
+            elapsed = t1 - t0
+            avg = elapsed / REPEAT
+            total_perf = setup_time + elapsed
+
+            if verbose:
+                print(f"\r[{idx+1}/{num_algos}] Running: {title}... Done ({elapsed:.2f}s)")
+
+            results.append(
+                {
+                    "title": title,
+                    "setup_time": setup_time,
+                    "total_time": elapsed,
+                    "avg_time": avg,
+                    "last_result": result,
+                    "total_perf": total_perf,
+                    "error": None,
+                }
+            )
+            if total_perf < best_total:
+                best_total = total_perf
+                best_idx = idx
+        except Exception as e:
+            if verbose:
+                print(f"\r[{idx+1}/{num_algos}] Running: {title}... ERROR: {e}")
+            results.append(
+                {
+                    "title": title,
+                    "setup_time": 0,
+                    "total_time": float('inf'),
+                    "avg_time": float('inf'),
+                    "last_result": None,
+                    "total_perf": float('inf'),
+                    "error": str(e),
+                }
+            )
+    if verbose:
+        print("\nBenchmark Results: ")
+        for i, res in enumerate(results):
+            if res['error']:
+                print(f"{res['title']:40} ERROR: {res['error']}")
+            else:
+                if i == best_idx:
+                    highlight = " <-- BEST"
+                elif best_total > 0:
+                    ratio = res['total_perf'] / best_total
+                    highlight = f" ({ratio:.2f}x slower)"
+                else:
+                    highlight = ""
+                print(
+                    f"{res['title']:40} setup: {res['setup_time']:0.4f}s  total: {res['total_time']:0.4f}s  avg: {res['avg_time']*1e6:0.2f}us{highlight}"
+                )
+    return results

simple_function_benchmark-0.1.4/src/simple_function_benchmark.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: simple_function_benchmark
+Version: 0.1.4
+Summary: Simple benchmarking library for comparing algorithm runtime
+Author-email: ControlAltPete <peter@petertheobald.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Benchmark
+
+A simple, easy-to-use Python benchmarking library for comparing algorithm performance.
+[Github page](https://github.com/PeterTheobald/HackerDojoPythonGroup/tree/main/PyPI)
+
+## Features
+
+- 🚀 **Simple API** - Compare multiple algorithms with just a few lines of code
+- 📊 **Detailed Results** - Get setup time, total time, average time, and performance comparisons
+- 🔄 **Progress Tracking** - Real-time progress updates during long-running benchmarks
+- 🛡️ **Error Handling** - Gracefully handles algorithm failures without stopping the entire benchmark
+- 📈 **Performance Ratios** - Automatically shows how much slower each algorithm is compared to the best
+
+## Installation
+
+```bash
+pip install benchmark
+```
+
+## Quick Start
+
+```python
+import benchmark
+
+# Define your algorithms to compare
+algorithms = [
+    {
+        "title": "Bubble Sort",
+        "algorithm_fn": bubble_sort,
+        "setup_fn": lambda: [3, 1, 4, 1, 5, 9, 2, 6]
+    },
+    {
+        "title": "Python's sorted()",
+        "algorithm_fn": sorted,
+        "setup_fn": lambda: [3, 1, 4, 1, 5, 9, 2, 6]
+    }
+]
+
+# Run the benchmark
+results = benchmark.run(algorithms, REPEAT=1000)
+```
+
+## Usage
+
+### Basic Example
+
+```python
+import benchmark
+
+def algorithm1(data):
+    return sorted(data)
+
+def algorithm2(data):
+    return list(reversed(sorted(data, reverse=True)))
+
+algorithms = [
+    {
+        "title": "Standard sort",
+        "algorithm_fn": algorithm1,
+        "setup_fn": lambda: [5, 2, 8, 1, 9]
+    },
+    {
+        "title": "Reverse then reverse",
+        "algorithm_fn": algorithm2,
+        "setup_fn": lambda: [5, 2, 8, 1, 9]
+    }
+]
+
+results = benchmark.run(algorithms, REPEAT=10000, verbose=True)
+```
+
+### Output Example
+
+```
+[1/2] Running: Standard sort... Done (0.05s)
+[2/2] Running: Reverse then reverse... Done (0.08s)
+
+Benchmark Results:
+Standard sort                       setup: 0.0000s  total: 0.0500s  avg: 5.00us <-- BEST
+Reverse then reverse                setup: 0.0000s  total: 0.0800s  avg: 8.00us (1.60x slower)
+```
+
+## API Reference
+
+### `benchmark.run(algorithms, REPEAT=1000, verbose=True)`
+
+Run a benchmark comparing multiple algorithms.
+
+**Parameters:**
+- `algorithms` (List[Dict]): List of algorithm dictionaries with keys:
+  - `algorithm_fn` (Callable): The function to benchmark
+  - `title` (str): Display name for the algorithm
+  - `setup_fn` (Callable, optional): Function called before timing to prepare test data
+- `REPEAT` (int, default=1000): Number of times to run each algorithm
+- `verbose` (bool, default=True): Whether to print progress and results
+
+**Returns:**
+- List[Dict]: Results for each algorithm containing:
+  - `title`: Algorithm name
+  - `setup_time`: Time spent in setup
+  - `total_time`: Total execution time
+  - `avg_time`: Average time per iteration
+  - `last_result`: Result from the last iteration
+  - `total_perf`: Combined setup + execution time
+  - `error`: Error message if the algorithm failed, None otherwise
+
+## Examples
+
+See the included demo in `benchmark.py` which compares sorting algorithms:
+- Bubble Sort
+- Timsort (Python's built-in `sorted()`)
+- Heap Sort
+- Quicksort
+
+## Requirements
+
+- Python >= 3.7
+
+## License
+
+MIT License
+
+## Author
+
+ControlAltPete (peter@petertheobald.com)

simple_function_benchmark-0.1.4/src/simple_function_benchmark.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+src/benchmark/__init__.py
+src/benchmark/benchmark.py
+src/simple_function_benchmark.egg-info/PKG-INFO
+src/simple_function_benchmark.egg-info/SOURCES.txt
+src/simple_function_benchmark.egg-info/dependency_links.txt
+src/simple_function_benchmark.egg-info/top_level.txt

simple_function_benchmark-0.1.4/src/simple_function_benchmark.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

simple_function_benchmark-0.1.4/src/simple_function_benchmark.egg-info/top_level.txt

@@ -0,0 +1 @@
+benchmark