allaun/Research-Stack
1
0
Fork 0
mirror of https://github.com/allaunthefox/Research-Stack.git synced 2026-07-31 03:05:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Research-Stack/5-Applications/tools-scripts/audio/pipewire_waveprobe_compression_chain.py

1422 lines
52 KiB
Python
Raw Blame History

#!/usr/bin/env python3
from __future__ import annotations
# ==============================================================================
# COPYRIGHT NO ONE EVERYWHERE LLC (WYOMING HOLDING COMPANY)
# PROJECT: SOVEREIGN STACK
# This artifact is entirely proprietary and cryptographically proven.
# Open-Source usage requires explicit permission from Brandon Scott Schneider.
# ==============================================================================
# [WARDEN BOUNDARY ENFORCEMENT INJECTED]
import sys
import os
try:
from io_harness_compat import spawn_isolated_process, fetch_network_resource
except ImportError:
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from io_harness_compat import spawn_isolated_process, fetch_network_resource
"""
PipeWire -> compression -> waveprobe test harness.
Captures a short WAV from PipeWire or loads an existing WAV, chunks the PCM
payload, then runs:
1. ENE compression routing / MI scoring
2. unified_canal_pipeline waveprobe scoring
The goal is not to replace the eventual HDL path. The goal is to measure what
happens when the existing compression logic is inserted into the host-side audio
front end.
"""
import argparse
import hashlib
import importlib.util
import json
import math
import os
from pathlib import Path
# import subprocess (REMOVED BY WARDEN)
import sys
import time
import wave
from datetime import datetime, timezone
from typing import Any, Dict, List, Tuple
import sys
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from math_harness_compat import xp, AnyArray
import zlib
REPO_ROOT = Path(__file__).resolve().parents[1]
if str(REPO_ROOT) not in sys.path:
sys.path.insert(0, str(REPO_ROOT))
from ene_mi_signal import MISignal, extract_mi_features # noqa: E402
from scripts.pipewire_dsp_workloads import ( # noqa: E402
apply_dsp_workload,
available_workloads,
)
def _load_module(module_name: str, path: Path):
spec = importlib.util.spec_from_file_location(module_name, path)
if spec is None or spec.loader is None:
raise RuntimeError(f"Could not load module {module_name} from {path}")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
UCP = _load_module(
"unified_canal_pipeline",
REPO_ROOT / "hutter" / "unified_canal_pipeline.py",
)
METHOD_SPECS: Dict[str, Dict[str, float | str]] = {
"order0": {
"encode_kind": "order0",
"centroid_norm": 0.80,
"transient_norm": 0.85,
"flatness_norm": 0.92,
"zcr_norm": 0.85,
"low_band": 0.18,
"mid_band": 0.34,
"high_band": 0.80,
"complexity": 0.08,
"memory": 0.04,
},
"zlib_fast": {
"encode_kind": "zlib_fast",
"centroid_norm": 0.30,
"transient_norm": 0.30,
"flatness_norm": 0.26,
"zcr_norm": 0.28,
"low_band": 0.72,
"mid_band": 0.42,
"high_band": 0.12,
"complexity": 0.18,
"memory": 0.12,
},
"zlib": {
"encode_kind": "zlib",
"centroid_norm": 0.25,
"transient_norm": 0.25,
"flatness_norm": 0.20,
"zcr_norm": 0.25,
"low_band": 0.75,
"mid_band": 0.45,
"high_band": 0.10,
"complexity": 0.36,
"memory": 0.28,
},
"gzip": {
"encode_kind": "gzip",
"centroid_norm": 0.28,
"transient_norm": 0.28,
"flatness_norm": 0.24,
"zcr_norm": 0.27,
"low_band": 0.70,
"mid_band": 0.48,
"high_band": 0.14,
"complexity": 0.34,
"memory": 0.22,
},
"bz2": {
"encode_kind": "bz2",
"centroid_norm": 0.40,
"transient_norm": 0.38,
"flatness_norm": 0.30,
"zcr_norm": 0.32,
"low_band": 0.60,
"mid_band": 0.62,
"high_band": 0.18,
"complexity": 0.58,
"memory": 0.52,
},
"brotli": {
"encode_kind": "brotli",
"centroid_norm": 0.22,
"transient_norm": 0.20,
"flatness_norm": 0.16,
"zcr_norm": 0.20,
"low_band": 0.78,
"mid_band": 0.55,
"high_band": 0.08,
"complexity": 0.54,
"memory": 0.48,
},
"zstd": {
"encode_kind": "zstd",
"centroid_norm": 0.24,
"transient_norm": 0.24,
"flatness_norm": 0.18,
"zcr_norm": 0.22,
"low_band": 0.74,
"mid_band": 0.58,
"high_band": 0.10,
"complexity": 0.30,
"memory": 0.24,
},
"lzma": {
"encode_kind": "lzma",
"centroid_norm": 0.45,
"transient_norm": 0.45,
"flatness_norm": 0.30,
"zcr_norm": 0.35,
"low_band": 0.55,
"mid_band": 0.70,
"high_band": 0.20,
"complexity": 0.82,
"memory": 0.86,
},
}
METHOD_PROFILES: Dict[str, Tuple[str, ...]] = {
"baseline": ("order0", "zlib", "lzma"),
"expanded": (
"order0",
"zlib_fast",
"zlib",
"gzip",
"bz2",
"brotli",
"zstd",
"lzma",
),
}
def available_method_profiles() -> Tuple[str, ...]:
return tuple(METHOD_PROFILES.keys())
def _select_hybrid_dsp_workload(
dsp_metrics: Dict[str, float],
waveprobe_metrics: Dict[str, float],
) -> str:
"""
Hybrid DSP workload selector using branch prediction principles.
Selects optimal DSP workload based on audio characteristics:
- Spectral-dominant audio → spectral_focus (FFT-based enhancement)
- Transient-dominant audio → transient_edge (edge detection)
- Balanced audio → hybrid (combined spectral + transient)
- Simple audio → raw (no transform, fastest path)
This reduces QUBO solve energy by pre-processing with optimal transforms.
"""
from scripts.pipewire_dsp_workloads import (
WORKLOAD_RAW,
WORKLOAD_SPECTRAL_FOCUS,
WORKLOAD_TRANSIENT_EDGE,
WORKLOAD_HYBRID,
)
# Branch prediction: order conditions by likelihood
spectral_centroid = dsp_metrics.get("spectral_centroid_hz", 0.0)
spectral_flatness = dsp_metrics.get("spectral_flatness", 0.0)
transient_ratio = dsp_metrics.get("transient_ratio", 0.0)
band_energy_high = dsp_metrics.get("band_energy_high", 0.0)
band_energy_mid = dsp_metrics.get("band_energy_mid", 0.0)
wave_heat = waveprobe_metrics.get("heat", 0.0)
# Spectral-dominant: high centroid, low flatness
is_spectral_dominant = spectral_centroid > 2000.0 and spectral_flatness < 0.4
# Transient-dominant: high transient ratio, high band energy
is_transient_dominant = transient_ratio > 3.0 and band_energy_high > 0.4
# Balanced: mid-band dominant, moderate flatness
is_balanced = band_energy_mid > 0.4 and spectral_flatness > 0.3
# Simple: low wave heat, low complexity
is_simple = wave_heat < 0.2 and spectral_centroid < 1000.0
if is_spectral_dominant:
return WORKLOAD_SPECTRAL_FOCUS
elif is_transient_dominant:
return WORKLOAD_TRANSIENT_EDGE
elif is_balanced:
return WORKLOAD_HYBRID
elif is_simple:
return WORKLOAD_RAW
else:
return WORKLOAD_HYBRID # Default to hybrid for unknown patterns
def resolve_method_profile(profile: str) -> List[str]:
if profile not in METHOD_PROFILES:
raise ValueError(
f"Unknown method profile {profile!r}; expected one of {available_method_profiles()}"
)
return list(METHOD_PROFILES[profile])
def _encode_bpb(method: str, data: bytes) -> float:
if not data:
return 0.0
if method == "none":
return 8.0
if method == "order0":
counts = [0] * 256
for b in data:
counts[b] += 1
entropy = 0.0
n = len(data)
for c in counts:
if c > 0:
p = c / n
entropy -= p * math.log2(p)
return entropy
if method == "zlib_fast":
return len(zlib.compress(data, 1)) * 8 / len(data)
if method == "zlib":
return len(zlib.compress(data, 9)) * 8 / len(data)
if method == "gzip":
import gzip
return len(gzip.compress(data, compresslevel=6, mtime=0)) * 8 / len(data)
if method == "bz2":
import bz2
return len(bz2.compress(data, compresslevel=9)) * 8 / len(data)
if method == "brotli":
import brotli
return len(brotli.compress(data, quality=6, lgwin=20)) * 8 / len(data)
if method == "zstd":
import zstandard as zstd
compressor = zstd.ZstdCompressor(level=5)
return len(compressor.compress(data)) * 8 / len(data)
if method == "lzma":
import lzma
return len(lzma.compress(data, preset=6)) * 8 / len(data)
return 8.0
def _clamp01(value: float) -> float:
return max(0.0, min(1.0, float(value)))
def _normalize_qubo_features(
dsp_metrics: Dict[str, float],
waveprobe_metrics: Dict[str, float],
sample_rate_hz: int,
) -> Dict[str, float]:
nyquist = max(sample_rate_hz / 2.0, 1.0)
centroid_norm = _clamp01(dsp_metrics.get("spectral_centroid_hz", 0.0) / nyquist)
transient_norm = _clamp01(dsp_metrics.get("transient_ratio", 0.0) / 4.0)
flatness_norm = _clamp01(dsp_metrics.get("spectral_flatness", 0.0))
zcr_norm = _clamp01(dsp_metrics.get("zero_crossing_rate", 0.0))
low_band = _clamp01(dsp_metrics.get("band_energy_low", 0.0))
mid_band = _clamp01(dsp_metrics.get("band_energy_mid", 0.0))
high_band = _clamp01(dsp_metrics.get("band_energy_high", 0.0))
wave_heat = _clamp01(waveprobe_metrics.get("heat", 0.0))
wave_comp = _clamp01(waveprobe_metrics.get("compression_sensitivity", 0.0) / 32.0)
wave_aniso = _clamp01(waveprobe_metrics.get("anisotropy", 0.0) / 8.0)
return {
"centroid_norm": centroid_norm,
"transient_norm": transient_norm,
"flatness_norm": flatness_norm,
"zcr_norm": zcr_norm,
"low_band": low_band,
"mid_band": mid_band,
"high_band": high_band,
"wave_heat": wave_heat,
"wave_comp": wave_comp,
"wave_aniso": wave_aniso,
}
def _build_qubo_candidates(
methods: List[str],
features: Dict[str, float],
) -> List[Dict[str, float | str]]:
feature_weights = {
"centroid_norm": 0.16,
"transient_norm": 0.18,
"flatness_norm": 0.18,
"zcr_norm": 0.10,
"low_band": 0.12,
"mid_band": 0.10,
"high_band": 0.16,
}
candidates: List[Dict[str, float | str]] = []
wave_pressure = (
0.5 * features["wave_heat"]
+ 0.3 * features["wave_comp"]
+ 0.2 * features["wave_aniso"]
)
for method in methods:
target = METHOD_SPECS[method]
mismatch = 0.0
for key, weight in feature_weights.items():
mismatch += weight * abs(features[key] - float(target[key]))
routing_cost = _clamp01(
0.65 * float(target["complexity"]) + 0.35 * wave_pressure
)
memory_cost = _clamp01(
0.55 * float(target["memory"])
+ 0.25 * features["flatness_norm"]
+ 0.20 * features["mid_band"]
)
candidates.append(
{
"method": method,
"e": _clamp01(mismatch),
"r": routing_cost,
"m": memory_cost,
}
)
return candidates
def _build_one_hot_qubo_matrix(
candidates: List[Dict[str, float | str]],
penalty: float,
lambda_e: float = 0.50,
lambda_r: float = 0.30,
lambda_m: float = 0.20,
) -> Tuple[AnyArray, List[float]]:
n = len(candidates)
q = xp.zeros((n, n), dtype=float)
costs: List[float] = []
for i, candidate in enumerate(candidates):
c_i = (
lambda_e * float(candidate["e"])
+ lambda_r * float(candidate["r"])
+ lambda_m * float(candidate["m"])
)
costs.append(c_i)
q[i, i] = c_i - penalty
for i in range(n):
for j in range(i + 1, n):
q[i, j] = 2.0 * penalty
return q, costs
def _qubo_energy(q: AnyArray, bits: AnyArray) -> float:
return float(bits @ q @ bits)
def _one_hot_bits(n: int, active_index: int) -> AnyArray:
bits = xp.zeros(n, dtype=float)
bits[active_index] = 1.0
return bits
def _solve_qubo_exact(q: AnyArray) -> Dict[str, Any]:
n = int(q.shape[0])
best_bits: List[int] | None = None
best_energy = float("inf")
evaluated_states = 0
for state in range(1, 1 << n):
bits = xp.array([(state >> i) & 1 for i in range(n)], dtype=float)
energy = _qubo_energy(q, bits)
evaluated_states += 1
if energy < best_energy:
best_energy = energy
best_bits = bits.astype(int).tolist()
if best_bits is None:
raise RuntimeError("QUBO solve failed to produce a state")
active = [idx for idx, bit in enumerate(best_bits) if bit]
return {
"solution_bits": best_bits,
"active_indices": active,
"energy": best_energy,
"constraint_satisfied": sum(best_bits) == 1,
"evaluated_states": evaluated_states,
}
# =============================================================================
# ADAPTIVE SCALE PROPOSAL REFINEMENT
# =============================================================================
# Inspired by the wavelength-detection concept from:
# "Resonance MCMC" by Zachary Lafer (github.com/zman007-save/resonance-mcmc)
# Principle: Detect characteristic spatial scales from accepted move history
# and bias proposals toward those scales for faster mode discovery.
#
# Adaptation: Applied to discrete one-hot QUBO instead of continuous space.
# - Track accepted index-space distances
# - Detect median characteristic distance
# - Bias proposals toward that distance and its harmonics
# =============================================================================
from dataclasses import dataclass, field
@dataclass
class AdaptiveProposalState:
"""Track proposal statistics for adaptive scale detection in QUBO annealing."""
# History of accepted jump distances (in index space)
accepted_distances: List[int] = field(default_factory=list)
# History window size for median estimation
window_size: int = 20
# Minimum samples before adaptation activates
min_samples: int = 5
def observe_accepted_move(self, from_index: int, to_index: int):
"""Record an accepted move distance."""
distance = abs(to_index - from_index)
self.accepted_distances.append(distance)
if len(self.accepted_distances) > self.window_size:
self.accepted_distances.pop(0)
def detect_scale(self) -> Optional[int]:
"""Detect characteristic jump scale from history using median.
Returns None if insufficient samples.
"""
if len(self.accepted_distances) < self.min_samples:
return None
return int(xp.median(xp.array(self.accepted_distances)))
def get_scale_multiplier(self, current_index: int, candidate_index: int) -> float:
"""Compute proposal weight multiplier based on scale alignment.
Returns 1.0 for neutral, >1.0 to favor, <1.0 to disfavor.
"""
scale = self.detect_scale()
if scale is None:
return 1.0
distance = abs(candidate_index - current_index)
if distance == 0:
return 0.5 # Disfavor staying in place
# Check alignment with scale and its harmonics
harmonic_boost = 0.0
for harmonic in [1, 2, 3]:
target_dist = scale * harmonic
# Gaussian-like falloff around target
diff = abs(distance - target_dist) / max(target_dist * 0.3, 1.0)
boost = float(xp.exp(-diff ** 2))
harmonic_boost = max(harmonic_boost, boost)
# Return multiplier: 1.0 to 2.0
return 1.0 + harmonic_boost
def _guided_initial_index(unary_costs: List[float]) -> int:
return min(range(len(unary_costs)), key=lambda idx: unary_costs[idx])
def _weighted_candidate_indices(
unary_costs: List[float],
exclude_index: int,
guidance: str,
active_index: int = 0,
adaptive_state: Optional[AdaptiveProposalState] = None,
) -> Tuple[AnyArray, AnyArray]:
indices = xp.array([idx for idx in range(len(unary_costs)) if idx != exclude_index], dtype=int)
if indices.size == 0:
return indices, xp.array([], dtype=float)
# Base weights from guidance strategy
if guidance == "unguided":
base_weights = xp.ones(indices.size, dtype=float)
elif guidance == "adaptive_scale":
# Use adaptive scale bias only (no cost weighting)
base_weights = xp.ones(indices.size, dtype=float)
else:
# Cost-weighted ("dsp_guided" or default)
max_cost = max(unary_costs)
min_cost = min(unary_costs)
spread = max(max_cost - min_cost, 1e-6)
base_weights = xp.array(
[1.0 + (max_cost - unary_costs[idx]) / spread for idx in indices],
dtype=float,
)
# Apply adaptive scale multipliers if state provided
if adaptive_state is not None:
multipliers = xp.array([
adaptive_state.get_scale_multiplier(active_index, int(idx))
for idx in indices
], dtype=float)
base_weights = base_weights * multipliers
# Normalize
weights = base_weights / xp.sum(base_weights)
return indices, weights
def _solve_qubo_anneal(
q: AnyArray,
unary_costs: List[float],
seed: int,
steps: int,
temp_start: float,
temp_end: float,
guidance: str,
) -> Dict[str, Any]:
n = int(q.shape[0])
rng = xp.random.default_rng(seed)
safe_temp_start = max(float(temp_start), 1e-6)
safe_temp_end = max(float(temp_end), 1e-6)
if guidance == "dsp_guided":
initial_index = _guided_initial_index(unary_costs)
else:
initial_index = int(rng.integers(0, n))
current_bits = _one_hot_bits(n, initial_index)
current_energy = _qubo_energy(q, current_bits)
best_bits = current_bits.copy()
best_energy = current_energy
accepted_moves = 0
improved_moves = 0
# Initialize adaptive scale detection if enabled
use_adaptive = guidance in ("adaptive_scale", "dsp_guided_adaptive")
adaptive_state = AdaptiveProposalState(window_size=min(30, steps)) if use_adaptive else None
for step in range(max(1, steps)):
if steps <= 1:
temperature = safe_temp_end
else:
alpha = step / (steps - 1)
temperature = safe_temp_start * (
(safe_temp_end / safe_temp_start) ** alpha
)
proposal_bits = current_bits.copy()
active_indices = xp.flatnonzero(proposal_bits > 0.5)
active_index = int(active_indices[0]) if active_indices.size else initial_index
weighted_indices, weights = _weighted_candidate_indices(
unary_costs,
active_index,
guidance=guidance,
active_index=active_index,
adaptive_state=adaptive_state,
)
if weighted_indices.size:
target_index = int(rng.choice(weighted_indices, p=weights))
proposal_bits[active_index] = 0.0
proposal_bits[target_index] = 1.0
else:
flip_index = int(rng.integers(0, n))
proposal_bits[flip_index] = 1.0 - proposal_bits[flip_index]
proposal_energy = _qubo_energy(q, proposal_bits)
delta = proposal_energy - current_energy
if delta <= 0.0:
accept = True
else:
accept = bool(rng.random() < math.exp(-delta / max(temperature, 1e-9)))
if accept:
accepted_moves += 1
if delta < 0.0:
improved_moves += 1
# Record accepted move for adaptive scale detection
if adaptive_state is not None and weighted_indices.size:
adaptive_state.observe_accepted_move(active_index, target_index)
current_bits = proposal_bits
current_energy = proposal_energy
if int(xp.sum(current_bits)) == 1 and current_energy < best_energy:
best_bits = current_bits.copy()
best_energy = current_energy
best_bits_list = best_bits.astype(int).tolist()
active = [idx for idx, bit in enumerate(best_bits_list) if bit]
# Get final detected scale for diagnostics
final_scale = adaptive_state.detect_scale() if adaptive_state else None
return {
"solution_bits": best_bits_list,
"active_indices": active,
"energy": best_energy,
"constraint_satisfied": sum(best_bits_list) == 1,
"seed": seed,
"steps": max(1, steps),
"accepted_moves": accepted_moves,
"improved_moves": improved_moves,
"accepted_ratio": accepted_moves / max(1, steps),
"initial_index": initial_index,
"initial_energy": _qubo_energy(q, _one_hot_bits(n, initial_index)),
"guidance": guidance,
"adaptive_scale": final_scale,
}
def _candidate_cost_rows(
candidates: List[Dict[str, float | str]],
unary_costs: List[float],
) -> List[Dict[str, float | str]]:
return [
{
"method": str(candidate["method"]),
"e": float(candidate["e"]),
"r": float(candidate["r"]),
"m": float(candidate["m"]),
"unary_cost": unary_costs[idx],
}
for idx, candidate in enumerate(candidates)
]
def _run_qubo_method_search(
methods: List[str],
dsp_metrics: Dict[str, float],
waveprobe_metrics: Dict[str, float],
sample_rate_hz: int,
solver: str,
seed: int,
anneal_steps: int,
anneal_temp_start: float,
anneal_temp_end: float,
anneal_guidance: str,
benchmark_guidance_ablation: bool,
collect_exact_reference: bool,
) -> Dict[str, Any]:
features = _normalize_qubo_features(
dsp_metrics=dsp_metrics,
waveprobe_metrics=waveprobe_metrics,
sample_rate_hz=sample_rate_hz,
)
candidates = _build_qubo_candidates(methods, features)
penalty = 1.25
q, unary_costs = _build_one_hot_qubo_matrix(candidates, penalty=penalty)
candidate_costs = _candidate_cost_rows(candidates, unary_costs)
exact_reference_available = collect_exact_reference or solver == "exact"
exact_solution: Dict[str, Any] | None = None
exact_solve_time_ms: float | None = None
exact_method: str | None = None
if exact_reference_available:
exact_start = time.perf_counter()
exact_solution = _solve_qubo_exact(q)
exact_solve_time_ms = (time.perf_counter() - exact_start) * 1000.0
exact_index = (
exact_solution["active_indices"][0]
if exact_solution["active_indices"]
else _guided_initial_index(unary_costs)
)
exact_method = str(candidates[exact_index]["method"])
if solver == "anneal":
solve_start = time.perf_counter()
solved = _solve_qubo_anneal(
q=q,
unary_costs=unary_costs,
seed=seed,
steps=anneal_steps,
temp_start=anneal_temp_start,
temp_end=anneal_temp_end,
guidance=anneal_guidance,
)
solve_time_ms = (time.perf_counter() - solve_start) * 1000.0
active_index = solved["active_indices"][0] if solved["active_indices"] else _guided_initial_index(unary_costs)
selected_method = str(candidates[active_index]["method"])
initial_index = int(solved["initial_index"])
initial_method = str(candidates[initial_index]["method"])
benchmark = {
"exact_reference_method": exact_method,
"exact_reference_energy": (
exact_solution["energy"] if exact_solution is not None else None
),
"exact_reference_solve_time_ms": exact_solve_time_ms,
"exact_reference_evaluated_states": (
exact_solution["evaluated_states"] if exact_solution is not None else None
),
"exact_match": (
selected_method == exact_method if exact_method is not None else None
),
"energy_gap_vs_exact": (
solved["energy"] - exact_solution["energy"]
if exact_solution is not None
else None
),
}
guidance_benchmark: Dict[str, Any] | None = None
if benchmark_guidance_ablation:
alt_guidance = "unguided" if anneal_guidance == "dsp_guided" else "dsp_guided"
alt_start = time.perf_counter()
alt_solved = _solve_qubo_anneal(
q=q,
unary_costs=unary_costs,
seed=seed,
steps=anneal_steps,
temp_start=anneal_temp_start,
temp_end=anneal_temp_end,
guidance=alt_guidance,
)
alt_solve_time_ms = (time.perf_counter() - alt_start) * 1000.0
alt_index = (
alt_solved["active_indices"][0]
if alt_solved["active_indices"]
else _guided_initial_index(unary_costs)
)
alt_method = str(candidates[alt_index]["method"])
guidance_benchmark = {
"alternative_guidance": alt_guidance,
"selected_method": alt_method,
"energy": alt_solved["energy"],
"exact_match": alt_method == exact_method if exact_method is not None else None,
"energy_gap_vs_exact": (
alt_solved["energy"] - exact_solution["energy"]
if exact_solution is not None
else None
),
"solve_time_ms": alt_solve_time_ms,
"accepted_ratio": alt_solved["accepted_ratio"],
"initial_method": str(candidates[int(alt_solved["initial_index"])]["method"]),
}
solver_stats = {
"steps": solved["steps"],
"accepted_moves": solved["accepted_moves"],
"improved_moves": solved["improved_moves"],
"accepted_ratio": solved["accepted_ratio"],
"initial_method": initial_method,
"initial_energy": solved["initial_energy"],
"seed": solved["seed"],
"guidance": solved["guidance"],
}
solver_name = "simulated_annealing"
else:
solve_start = time.perf_counter()
solved = _solve_qubo_exact(q)
solve_time_ms = (time.perf_counter() - solve_start) * 1000.0
active_index = solved["active_indices"][0] if solved["active_indices"] else _guided_initial_index(unary_costs)
selected_method = str(candidates[active_index]["method"])
benchmark = {
"exact_reference_method": exact_method,
"exact_reference_energy": (
exact_solution["energy"] if exact_solution is not None else solved["energy"]
),
"exact_reference_solve_time_ms": exact_solve_time_ms,
"exact_reference_evaluated_states": (
exact_solution["evaluated_states"] if exact_solution is not None else solved["evaluated_states"]
),
"exact_match": True,
"energy_gap_vs_exact": 0.0,
}
solver_stats = {
"steps": solved["evaluated_states"],
"accepted_moves": solved["evaluated_states"],
"improved_moves": solved["evaluated_states"],
"accepted_ratio": 1.0,
"initial_method": exact_method,
"initial_energy": exact_solution["energy"],
"seed": seed,
"guidance": "n/a",
}
guidance_benchmark = None
solver_name = "exact_one_hot_enumeration"
return {
"triggered": True,
"solver": solver_name,
"selected_method": selected_method,
"selected_index": active_index,
"energy": solved["energy"],
"solution_bits": solved["solution_bits"],
"constraint_satisfied": solved["constraint_satisfied"],
"solve_time_ms": solve_time_ms,
"penalty": penalty,
"features": features,
"candidate_costs": candidate_costs,
"matrix_upper_triangular": [
[float(q[i, j]) for j in range(i, q.shape[1])]
for i in range(q.shape[0])
],
"benchmark": benchmark,
"solver_stats": solver_stats,
"guidance_benchmark": guidance_benchmark,
}
def _capture_with_pipewire(
output_wav: Path,
duration_s: float,
rate: int,
channels: int,
fmt: str,
latency: str,
target: str | None,
) -> None:
output_wav.parent.mkdir(parents=True, exist_ok=True)
sample_count = max(1, int(duration_s * rate))
cmd = [
"pw-record",
"--container",
"wav",
"--rate",
str(rate),
"--channels",
str(channels),
"--format",
fmt,
"--latency",
latency,
"--sample-count",
str(sample_count),
]
if target:
cmd.extend(["--target", target])
cmd.append(str(output_wav))
subprocess.run(cmd, check=True)
def _read_wav_pcm(path: Path) -> Dict[str, Any]:
with wave.open(str(path), "rb") as wf:
params = {
"channels": wf.getnchannels(),
"sample_width_bytes": wf.getsampwidth(),
"sample_rate_hz": wf.getframerate(),
"n_frames": wf.getnframes(),
"duration_s": wf.getnframes() / max(wf.getframerate(), 1),
}
frames = wf.readframes(wf.getnframes())
return {"params": params, "pcm_bytes": frames}
def _build_audio_dag(
pcm_bytes: bytes,
chunk_size: int,
stride: int,
max_states: int,
) -> Dict[str, Any]:
ts = datetime.now(timezone.utc)
chunks = UCP.chunk_corpus(pcm_bytes, chunk_size=chunk_size, stride=stride)
dag: Dict[str, Any] = {}
for offset, chunk_bytes in chunks[:max_states]:
sha = UCP.compute_sha256(chunk_bytes)
state_id = f"audio_capture:{offset:08x}:{sha[:16]}"
dag[state_id] = UCP.CorpusState(
sha256=sha,
timestamp=ts,
release_id="audio_capture",
chunk_offset=offset,
chunk_bytes=chunk_bytes,
)
return dag
def run_chain(
wav_path: Path,
chunk_size: int,
stride: int,
max_states: int,
low_mi_threshold: float,
high_mi_threshold: float,
dsp_workload: str,
method_profile: str = "baseline",
qubo_solver: str = "exact",
qubo_anneal_steps: int = 32,
qubo_anneal_temp_start: float = 0.50,
qubo_anneal_temp_end: float = 0.05,
qubo_anneal_guidance: str = "dsp_guided",
qubo_benchmark_guidance_ablation: bool = False,
qubo_collect_exact_reference: bool = True,
hybrid_dsp_workload: bool = False,
) -> Dict[str, Any]:
wav_data = _read_wav_pcm(wav_path)
pcm_bytes = wav_data["pcm_bytes"]
dag = _build_audio_dag(
pcm_bytes=pcm_bytes,
chunk_size=chunk_size,
stride=stride,
max_states=max_states,
)
if not dag:
raise RuntimeError("No audio chunks available for analysis")
analysis_dag: Dict[str, Any] = {}
dsp_by_state: Dict[str, Dict[str, float]] = {}
for state_id, state in dag.items():
analysis_bytes, dsp_metrics = apply_dsp_workload(
state.chunk_bytes,
sample_width_bytes=wav_data["params"]["sample_width_bytes"],
channels=wav_data["params"]["channels"],
sample_rate_hz=wav_data["params"]["sample_rate_hz"],
workload=dsp_workload,
)
analysis_sha = UCP.compute_sha256(analysis_bytes)
analysis_dag[state_id] = UCP.CorpusState(
sha256=analysis_sha,
timestamp=state.timestamp,
release_id=state.release_id,
chunk_offset=state.chunk_offset,
chunk_bytes=analysis_bytes,
)
dsp_by_state[state_id] = dsp_metrics
mu, sigma = UCP.compute_feature_stats(analysis_dag)
mi_signal = MISignal(
low_mi_threshold=low_mi_threshold,
high_mi_threshold=high_mi_threshold,
)
methods = resolve_method_profile(method_profile)
per_chunk: List[Dict[str, Any]] = []
method_counts: Dict[str, int] = {m: 0 for m in methods + ["none"]}
qubo_method_counts: Dict[str, int] = {m: 0 for m in methods}
dsp_workload_counts: Dict[str, int] = {}
rich_chunks = 0
cheap_chunks = 0
qubo_invocations = 0
qubo_method_overrides = 0
qubo_exact_matches = 0
wave_heat_total = 0.0
wave_compsens_total = 0.0
mi_actual_total = 0.0
yield_total = 0.0
dsp_centroid_total = 0.0
dsp_flatness_total = 0.0
dsp_transient_total = 0.0
dsp_zcr_total = 0.0
dsp_low_total = 0.0
dsp_mid_total = 0.0
dsp_high_total = 0.0
qubo_solve_time_total = 0.0
qubo_exact_solve_time_total = 0.0
qubo_energy_gap_total = 0.0
qubo_accepted_ratio_total = 0.0
qubo_alt_exact_matches = 0
qubo_alt_solve_time_total = 0.0
qubo_alt_energy_gap_total = 0.0
qubo_alt_accepted_ratio_total = 0.0
for idx, (state_id, state) in enumerate(analysis_dag.items()):
raw_state = dag[state_id]
dsp_metrics = dsp_by_state[state_id]
state_seed = int(
hashlib.sha256(f"{state_id}:{dsp_workload}".encode("utf-8")).hexdigest()[:8],
16,
)
wp = UCP.waveprobe(state.chunk_bytes, mu, sigma, seed=state_seed)
# Hybrid DSP workload selection for energy efficiency
if hybrid_dsp_workload:
selected_workload = _select_hybrid_dsp_workload(dsp_metrics, wp)
# Re-apply DSP with selected workload
analysis_bytes, dsp_metrics = apply_dsp_workload(
raw_state.chunk_bytes,
sample_width_bytes=wav_data["params"]["sample_width_bytes"],
channels=wav_data["params"]["channels"],
sample_rate_hz=wav_data["params"]["sample_rate_hz"],
workload=selected_workload,
)
analysis_sha = UCP.compute_sha256(analysis_bytes)
analysis_dag[state_id] = UCP.CorpusState(
sha256=analysis_sha,
timestamp=state.timestamp,
release_id=state.release_id,
chunk_offset=state.chunk_offset,
chunk_bytes=analysis_bytes,
)
dsp_by_state[state_id] = dsp_metrics
else:
selected_workload = dsp_workload
# Track DSP workload selection
dsp_workload_counts[selected_workload] = dsp_workload_counts.get(selected_workload, 0) + 1
z = extract_mi_features(state.chunk_bytes)
route = mi_signal.route(z, state.chunk_bytes, methods, _encode_bpb)
qubo_result: Dict[str, Any] = {"triggered": False}
selected_method = route["method"]
selected_bpb = route["actual_bpb"]
selected_mi = route["mi_actual"]
if route["decision_class"] == "rich":
qubo_result = _run_qubo_method_search(
methods=methods,
dsp_metrics=dsp_metrics,
waveprobe_metrics=wp,
sample_rate_hz=wav_data["params"]["sample_rate_hz"],
solver=qubo_solver,
seed=state_seed,
anneal_steps=qubo_anneal_steps,
anneal_temp_start=qubo_anneal_temp_start,
anneal_temp_end=qubo_anneal_temp_end,
anneal_guidance=qubo_anneal_guidance,
benchmark_guidance_ablation=qubo_benchmark_guidance_ablation,
collect_exact_reference=qubo_collect_exact_reference,
)
qubo_invocations += 1
qubo_method = qubo_result["selected_method"]
qubo_method_counts[qubo_method] = qubo_method_counts.get(qubo_method, 0) + 1
if qubo_method != route["method"]:
qubo_method_overrides += 1
if qubo_result["benchmark"]["exact_match"] is True:
qubo_exact_matches += 1
qubo_solve_time_total += float(qubo_result["solve_time_ms"])
if qubo_result["benchmark"]["exact_reference_solve_time_ms"] is not None:
qubo_exact_solve_time_total += float(
qubo_result["benchmark"]["exact_reference_solve_time_ms"]
)
if qubo_result["benchmark"]["energy_gap_vs_exact"] is not None:
qubo_energy_gap_total += float(
qubo_result["benchmark"]["energy_gap_vs_exact"]
)
qubo_accepted_ratio_total += float(
qubo_result["solver_stats"]["accepted_ratio"]
)
alt_guidance = qubo_result.get("guidance_benchmark")
if alt_guidance:
if alt_guidance["exact_match"] is True:
qubo_alt_exact_matches += 1
qubo_alt_solve_time_total += float(alt_guidance["solve_time_ms"])
if alt_guidance["energy_gap_vs_exact"] is not None:
qubo_alt_energy_gap_total += float(alt_guidance["energy_gap_vs_exact"])
qubo_alt_accepted_ratio_total += float(alt_guidance["accepted_ratio"])
selected_method = qubo_method
selected_bpb = _encode_bpb(selected_method, state.chunk_bytes)
selected_mi = route["baseline_bpb"] - selected_bpb
method = selected_method
method_counts[method] = method_counts.get(method, 0) + 1
if route["decision_class"] == "rich":
rich_chunks += 1
elif route["decision_class"] == "cheap":
cheap_chunks += 1
wave_heat_total += wp["heat"]
wave_compsens_total += wp["compression_sensitivity"]
mi_actual_total += selected_mi
yield_total += route["structure_yield"]
dsp_centroid_total += dsp_metrics.get("spectral_centroid_hz", 0.0)
dsp_flatness_total += dsp_metrics.get("spectral_flatness", 0.0)
dsp_transient_total += dsp_metrics.get("transient_ratio", 0.0)
dsp_zcr_total += dsp_metrics.get("zero_crossing_rate", 0.0)
dsp_low_total += dsp_metrics.get("band_energy_low", 0.0)
dsp_mid_total += dsp_metrics.get("band_energy_mid", 0.0)
dsp_high_total += dsp_metrics.get("band_energy_high", 0.0)
per_chunk.append(
{
"state_id": state_id,
"chunk_index": idx,
"offset": raw_state.chunk_offset,
"raw_sha256_prefix": raw_state.sha256[:16],
"analysis_sha256_prefix": state.sha256[:16],
"decision_class": route["decision_class"],
"method": method,
"mi_actual": selected_mi,
"mi_predicted": route["mi_predicted"],
"mi_surprise": route["mi_surprise"],
"structure_yield": route["structure_yield"],
"baseline_bpb": route["baseline_bpb"],
"actual_bpb": selected_bpb,
"mi_router_method": route["method"],
"qubo_enabled": qubo_result["triggered"],
"qubo_solver": qubo_result.get("solver"),
"qubo_guidance": qubo_result.get("solver_stats", {}).get("guidance"),
"qubo_selected_method": qubo_result.get("selected_method"),
"qubo_energy": qubo_result.get("energy"),
"qubo_solution_bits": qubo_result.get("solution_bits"),
"qubo_constraint_satisfied": qubo_result.get("constraint_satisfied"),
"qubo_solve_time_ms": qubo_result.get("solve_time_ms"),
"qubo_candidate_costs": qubo_result.get("candidate_costs"),
"qubo_features": qubo_result.get("features"),
"qubo_initial_method": qubo_result.get("solver_stats", {}).get("initial_method"),
"qubo_initial_energy": qubo_result.get("solver_stats", {}).get("initial_energy"),
"qubo_steps": qubo_result.get("solver_stats", {}).get("steps"),
"qubo_accepted_moves": qubo_result.get("solver_stats", {}).get("accepted_moves"),
"qubo_improved_moves": qubo_result.get("solver_stats", {}).get("improved_moves"),
"qubo_accepted_ratio": qubo_result.get("solver_stats", {}).get("accepted_ratio"),
"qubo_seed": qubo_result.get("solver_stats", {}).get("seed"),
"qubo_exact_reference_method": qubo_result.get("benchmark", {}).get("exact_reference_method"),
"qubo_exact_reference_energy": qubo_result.get("benchmark", {}).get("exact_reference_energy"),
"qubo_exact_reference_solve_time_ms": qubo_result.get("benchmark", {}).get("exact_reference_solve_time_ms"),
"qubo_exact_match": qubo_result.get("benchmark", {}).get("exact_match"),
"qubo_energy_gap_vs_exact": qubo_result.get("benchmark", {}).get("energy_gap_vs_exact"),
"qubo_guidance_alternative": (
qubo_result.get("guidance_benchmark") or {}
).get("alternative_guidance"),
"qubo_guidance_alternative_method": (
qubo_result.get("guidance_benchmark") or {}
).get("selected_method"),
"qubo_guidance_alternative_exact_match": (
qubo_result.get("guidance_benchmark") or {}
).get("exact_match"),
"qubo_guidance_alternative_energy_gap_vs_exact": (
qubo_result.get("guidance_benchmark") or {}
).get("energy_gap_vs_exact"),
"qubo_guidance_alternative_solve_time_ms": (
qubo_result.get("guidance_benchmark") or {}
).get("solve_time_ms"),
"qubo_guidance_alternative_accepted_ratio": (
qubo_result.get("guidance_benchmark") or {}
).get("accepted_ratio"),
"waveprobe_sensitivity": wp["sensitivity"],
"waveprobe_compression_sensitivity": wp["compression_sensitivity"],
"waveprobe_anisotropy": wp["anisotropy"],
"waveprobe_heat": wp["heat"],
"dsp_workload": dsp_workload,
"dsp_rms_ratio": dsp_metrics.get("rms_ratio", 1.0),
"dsp_zero_crossing_rate": dsp_metrics.get("zero_crossing_rate", 0.0),
"dsp_spectral_centroid_hz": dsp_metrics.get("spectral_centroid_hz", 0.0),
"dsp_spectral_flatness": dsp_metrics.get("spectral_flatness", 0.0),
"dsp_dominant_freq_hz": dsp_metrics.get("dominant_freq_hz", 0.0),
"dsp_transient_ratio": dsp_metrics.get("transient_ratio", 0.0),
"dsp_band_energy_low": dsp_metrics.get("band_energy_low", 0.0),
"dsp_band_energy_mid": dsp_metrics.get("band_energy_mid", 0.0),
"dsp_band_energy_high": dsp_metrics.get("band_energy_high", 0.0),
"dsp_centroid_shift_hz": dsp_metrics.get("centroid_shift_hz", 0.0),
"dsp_transient_shift": dsp_metrics.get("transient_shift", 0.0),
"dsp_workload": selected_workload,
}
)
n = len(per_chunk)
per_chunk_sorted = sorted(
per_chunk,
key=lambda item: (
item["mi_actual"],
item["waveprobe_heat"],
item["waveprobe_compression_sensitivity"],
),
reverse=True,
)
return {
"schema_version": "pipewire.waveprobe.compression.v1",
"captured_wav": str(wav_path),
"wav_params": wav_data["params"],
"chunking": {
"chunk_size_bytes": chunk_size,
"stride_bytes": stride,
"n_chunks": n,
},
"mi_router_config": {
"low_mi_threshold": low_mi_threshold,
"high_mi_threshold": high_mi_threshold,
},
"dsp_frontend": {
"workload": dsp_workload,
},
"qubo_config": {
"method_profile": method_profile,
"n_methods": len(methods),
"solver": qubo_solver,
"anneal_steps": qubo_anneal_steps,
"anneal_temp_start": qubo_anneal_temp_start,
"anneal_temp_end": qubo_anneal_temp_end,
"anneal_guidance": qubo_anneal_guidance,
"benchmark_guidance_ablation": qubo_benchmark_guidance_ablation,
"collect_exact_reference": qubo_collect_exact_reference,
},
"summary": {
"avg_mi_actual": mi_actual_total / n,
"avg_structure_yield": yield_total / n,
"avg_waveprobe_heat": wave_heat_total / n,
"avg_waveprobe_compression_sensitivity": wave_compsens_total / n,
"avg_dsp_spectral_centroid_hz": dsp_centroid_total / n,
"avg_dsp_spectral_flatness": dsp_flatness_total / n,
"avg_dsp_transient_ratio": dsp_transient_total / n,
"avg_dsp_zero_crossing_rate": dsp_zcr_total / n,
"avg_dsp_band_energy_low": dsp_low_total / n,
"avg_dsp_band_energy_mid": dsp_mid_total / n,
"avg_dsp_band_energy_high": dsp_high_total / n,
"rich_chunks": rich_chunks,
"cheap_chunks": cheap_chunks,
"qubo_invocations": qubo_invocations,
"qubo_method_overrides": qubo_method_overrides,
"qubo_exact_matches": qubo_exact_matches,
"qubo_exact_match_rate": (
qubo_exact_matches / qubo_invocations
if qubo_invocations and (qubo_collect_exact_reference or qubo_solver == "exact")
else None
),
"avg_qubo_solve_time_ms": (
qubo_solve_time_total / qubo_invocations if qubo_invocations else 0.0
),
"avg_qubo_exact_reference_solve_time_ms": (
qubo_exact_solve_time_total / qubo_invocations
if qubo_invocations and (qubo_collect_exact_reference or qubo_solver == "exact")
else None
),
"avg_qubo_energy_gap_vs_exact": (
qubo_energy_gap_total / qubo_invocations
if qubo_invocations and (qubo_collect_exact_reference or qubo_solver == "exact")
else None
),
"avg_qubo_accepted_ratio": (
qubo_accepted_ratio_total / qubo_invocations
if qubo_invocations
else 0.0
),
"alt_guidance_exact_matches": qubo_alt_exact_matches,
"alt_guidance_exact_match_rate": (
qubo_alt_exact_matches / qubo_invocations
if qubo_invocations
and qubo_benchmark_guidance_ablation
and (qubo_collect_exact_reference or qubo_solver == "exact")
else None
),
"avg_alt_guidance_solve_time_ms": (
qubo_alt_solve_time_total / qubo_invocations
if qubo_invocations and qubo_benchmark_guidance_ablation
else None
),
"avg_alt_guidance_energy_gap_vs_exact": (
qubo_alt_energy_gap_total / qubo_invocations
if qubo_invocations
and qubo_benchmark_guidance_ablation
and (qubo_collect_exact_reference or qubo_solver == "exact")
else None
),
"avg_alt_guidance_accepted_ratio": (
qubo_alt_accepted_ratio_total / qubo_invocations
if qubo_invocations and qubo_benchmark_guidance_ablation
else None
),
"method_counts": method_counts,
"qubo_method_counts": qubo_method_counts,
"dsp_workload_counts": dsp_workload_counts,
"mi_signal_stats": mi_signal.get_stats(),
},
"top_chunks": per_chunk_sorted[:10],
"chunks": per_chunk,
}
def main() -> int:
parser = argparse.ArgumentParser(
description="PipeWire -> compression -> waveprobe chain harness"
)
parser.add_argument("--input-wav", type=Path, help="Analyze an existing WAV file")
parser.add_argument(
"--capture-seconds",
type=float,
default=2.0,
help="Duration for PipeWire capture when --input-wav is omitted",
)
parser.add_argument("--rate", type=int, default=48000)
parser.add_argument("--channels", type=int, default=1)
parser.add_argument("--format", default="s16")
parser.add_argument("--latency", default="50ms")
parser.add_argument("--target", default=None, help="Optional PipeWire target node")
parser.add_argument("--chunk-size-bytes", type=int, default=4096)
parser.add_argument("--stride-bytes", type=int, default=2048)
parser.add_argument("--max-states", type=int, default=128)
parser.add_argument("--low-mi-threshold", type=float, default=0.5)
parser.add_argument("--high-mi-threshold", type=float, default=3.0)
parser.add_argument(
"--dsp-workload",
default="raw",
choices=list(available_workloads()),
help="DSP-like front-end transform applied before MI routing and waveprobe scoring",
)
parser.add_argument(
"--method-profile",
default="baseline",
choices=list(available_method_profiles()),
help="Compression method profile used for MI routing and QUBO search",
)
parser.add_argument(
"--qubo-solver",
default="exact",
choices=("exact", "anneal"),
help="QUBO solver used on rich chunks",
)
parser.add_argument(
"--qubo-anneal-steps",
type=int,
default=32,
help="Number of simulated annealing steps when --qubo-solver=anneal",
)
parser.add_argument(
"--qubo-anneal-temp-start",
type=float,
default=0.50,
help="Starting temperature for simulated annealing",
)
parser.add_argument(
"--qubo-anneal-temp-end",
type=float,
default=0.05,
help="Ending temperature for simulated annealing",
)
parser.add_argument(
"--qubo-anneal-guidance",
default="dsp_guided",
choices=("dsp_guided", "unguided"),
help="Proposal/init guidance mode for simulated annealing",
)
parser.add_argument(
"--qubo-benchmark-guidance-ablation",
action="store_true",
help="Also run the opposite annealing guidance mode for side-by-side benchmarking",
)
parser.add_argument(
"--skip-exact-reference",
action="store_true",
help="Skip exact-reference benchmarking on rich chunks to reduce end-to-end runtime",
)
parser.add_argument(
"--hybrid-dsp-workload",
action="store_true",
help="Enable hybrid DSP workload selection for energy-efficient QUBO solves",
)
parser.add_argument(
"--out-dir",
type=Path,
default=REPO_ROOT / "out" / "pipewire_waveprobe_chain",
)
args = parser.parse_args()
run_id = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
out_dir = args.out_dir / run_id
out_dir.mkdir(parents=True, exist_ok=True)
if args.input_wav:
wav_path = args.input_wav.resolve()
else:
wav_path = out_dir / "capture.wav"
_capture_with_pipewire(
output_wav=wav_path,
duration_s=args.capture_seconds,
rate=args.rate,
channels=args.channels,
fmt=args.format,
latency=args.latency,
target=args.target,
)
result = run_chain(
wav_path=wav_path,
chunk_size=args.chunk_size_bytes,
stride=args.stride_bytes,
max_states=args.max_states,
low_mi_threshold=args.low_mi_threshold,
high_mi_threshold=args.high_mi_threshold,
dsp_workload=args.dsp_workload,
method_profile=args.method_profile,
qubo_solver=args.qubo_solver,
qubo_anneal_steps=args.qubo_anneal_steps,
qubo_anneal_temp_start=args.qubo_anneal_temp_start,
qubo_anneal_temp_end=args.qubo_anneal_temp_end,
qubo_anneal_guidance=args.qubo_anneal_guidance,
qubo_benchmark_guidance_ablation=args.qubo_benchmark_guidance_ablation,
qubo_collect_exact_reference=not args.skip_exact_reference,
hybrid_dsp_workload=args.hybrid_dsp_workload,
)
result["run_id"] = run_id
result["generated_utc"] = datetime.now(timezone.utc).isoformat()
result["capture_mode"] = "file" if args.input_wav else "pipewire"
json_path = out_dir / "summary.json"
with open(json_path, "w", encoding="utf-8") as fh:
json.dump(result, fh, indent=2)
print(json.dumps(result["summary"], indent=2))
print(f"\n[+] Summary written to {json_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
Reference in a new issue View git blame Copy permalink