Update: Stabilize timing tests

Co-Authored-By: Codex <codex@openai.com>

Author: heikkitoivonen

docs/stdlib/queue.md

@@ -118,6 +118,7 @@ lifo.put('c')  # O(1)
 
 # Pop items (last in, first out) - O(1) amortized
 print(lifo.get())  # O(1) - 'c'
+print(lifo.get())  # O(1) - 'b'
 print(lifo.get())  # O(1) - 'a'
 ```
 

scripts/audit_documentation.py

@@ -137,24 +137,19 @@ def generate_audit_report(workspace_root: Path) -> dict[str, Any]:
         "builtins": {
             "total": len(all_builtins),
             "documented": len(documented["builtins"]),
-            "coverage_percent": round(
-                100 * len(documented["builtins"]) / len(all_builtins), 1
-            ),
+            "coverage_percent": round(100 * len(documented["builtins"]) / len(all_builtins), 1),
             "missing": sorted(missing_builtins),
             "by_category": builtins_by_category,
         },
         "stdlib": {
             "total": len(stdlib_modules),
             "documented": len(documented["stdlib"]),
-            "coverage_percent": round(
-                100 * len(documented["stdlib"]) / len(stdlib_modules), 1
-            ),
+            "coverage_percent": round(100 * len(documented["stdlib"]) / len(stdlib_modules), 1),
             "missing": missing_stdlib,
         },
         "summary": {
             "total_items": len(all_builtins) + len(stdlib_modules),
-            "total_documented": len(documented["builtins"])
-            + len(documented["stdlib"]),
+            "total_documented": len(documented["builtins"]) + len(documented["stdlib"]),
             "overall_coverage_percent": round(
                 100
                 * (len(documented["builtins"]) + len(documented["stdlib"]))
@@ -195,9 +190,7 @@ def print_report(report: dict[str, Any]) -> None:
         for item in report["builtins"]["missing"][:20]:  # Show first 20
             print(f"    - {item}")
         if len(report["builtins"]["missing"]) > 20:
-            print(
-                f"    ... and {len(report['builtins']['missing']) - 20} more"
-            )
+            print(f"    ... and {len(report['builtins']['missing']) - 20} more")
 
     print("\n📚 STDLIB MODULES")
     print(f"  Total: {report['stdlib']['total']}")

scripts/estimate_complexity.py

@@ -12,12 +12,12 @@
     python scripts/estimate_complexity.py my_script my_sorting_function
 """
 
-import sys
-import time
 import importlib
+import inspect
 import math
 import statistics
-import inspect
+import sys
+import time
 import typing
 from pathlib import Path
 
@@ -31,44 +31,45 @@ def measure_execution_time(func, input_size, iterations=5):
     Uses type hints to determine whether to pass 'n' (int) or data of size 'n'.
     """
     input_data = None
-    
+
     # 1. Check type hints
     try:
         sig = inspect.signature(func)
         params = list(sig.parameters.values())
         if params:
             first_param = params[0]
             hint = first_param.annotation
-            
+
             if hint is int:
                 input_data = input_size
-            elif hint in (list, typing.List, typing.Sequence):
+            elif hint in (list, typing.Sequence):
                 # Simple list generation
                 input_data = list(range(input_size))
             # Handle generic aliases like list[int] in newer Python
-            elif hasattr(hint, "__origin__") and hint.__origin__ in (list, typing.List, typing.Sequence):
-                 input_data = list(range(input_size))
+            elif hasattr(hint, "__origin__") and hint.__origin__ in (list, typing.Sequence):
+                input_data = list(range(input_size))
     except (ValueError, TypeError):
         # Signature inspection failed or function is weird
         pass
 
     # 2. Heuristic fallback logic
     if input_data is None:
         return _measure_heuristic(func, input_size, iterations)
-    
+
     # 3. Execution with determined input
     try:
         start_time = time.perf_counter()
         for _ in range(iterations):
             func(input_data)
         end_time = time.perf_counter()
         return (end_time - start_time) / iterations
-    except Exception as e:
-        # If specific input failed, maybe try heuristic as last resort? 
+    except Exception:
+        # If specific input failed, maybe try heuristic as last resort?
         # But for now, just report error to avoid infinite fallback loops.
         # print(f"Error with generated input: {e}")
         return None
 
+
 def _measure_heuristic(func, input_size, iterations):
     """Fallback: Try int first, then list."""
     try:
@@ -89,6 +90,7 @@ def _measure_heuristic(func, input_size, iterations):
     except Exception:
         return None
 
+
 def detect_complexity(n_values, times):
     """
     Estimate complexity by comparing RSquared values for different models.
@@ -99,40 +101,42 @@ def detect_complexity(n_values, times):
 
     # Normalize times
     min_time = min(times)
-    if min_time == 0: min_time = 1e-9
+    if min_time == 0:
+        min_time = 1e-9
     normalized_times = [t / min_time for t in times]
-    
+
     models = {
         "O(1) (Constant)": [1 for _ in n_values],
         "O(log n) (Logarithmic)": [math.log(n) if n > 0 else 0 for n in n_values],
-        "O(n) (Linear)": [n for n in n_values],
+        "O(n) (Linear)": list(n_values),
         "O(n log n) (Linearithmic)": [n * math.log(n) if n > 0 else 0 for n in n_values],
         "O(n^2) (Quadratic)": [n**2 for n in n_values],
     }
 
     best_fit = None
-    best_score = -float('inf')
+    best_score = -float("inf")
 
     for name, theoretical in models.items():
         # Calculate correlation coefficient (Pearson)
         try:
-            if len(set(theoretical)) == 1: # Handle constant case
+            if len(set(theoretical)) == 1:  # Handle constant case
                 # For constant time, we check variance of times
-                score = 1.0 / (statistics.stdev(normalized_times) + 1.0) 
+                score = 1.0 / (statistics.stdev(normalized_times) + 1.0)
             else:
-                 # Correlation between theoretical and actual
-                 # Using covariance / (std_dev_x * std_dev_y)
-                 correlation = statistics.correlation(theoretical, times)
-                 score = correlation
-            
+                # Correlation between theoretical and actual
+                # Using covariance / (std_dev_x * std_dev_y)
+                correlation = statistics.correlation(theoretical, times)
+                score = correlation
+
             if score > best_score:
                 best_score = score
                 best_fit = name
         except statistics.StatisticsError:
             continue
-            
+
     return best_fit, best_score
 
+
 def main():
     if len(sys.argv) < 3:
         print(__doc__)
@@ -149,7 +153,7 @@ def main():
         sys.exit(1)
 
     print(f"Estimating complexity for {module_name}.{func_name}...")
-    
+
     # Input sizes to test
     n_values = [100, 500, 1000, 2000, 5000]
     times = []
@@ -170,6 +174,7 @@ def main():
         print("-" * 35)
         print(f"Estimated Complexity: {complexity}")
         print(f"Fit Score: {score:.3f}")
-    
+
+
 if __name__ == "__main__":
     main()