strobengine 0.2.0__tar.gz → 0.2.1__tar.gz

{strobengine-0.2.0 → strobengine-0.2.1}/.github/workflows/publish-test.yml

@@ -6,11 +6,24 @@ on:
 
 jobs:
   build-wheels:
-    name: Build wheels on ${{ matrix.os }}
+    name: Build wheels on ${{ matrix.os }} (${{ matrix.target || 'native' }})
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        include:
+          # Linux
+          - os: ubuntu-latest
+            target: x86_64
+          # Windows
+          - os: windows-latest
+            target: x64
+          # macOS Apple Silicon (ARM64)
+          - os: macos-latest
+            target: aarch64
+          # macOS Intel (x86_64) cross-compiled on macos-latest
+          - os: macos-latest
+            target: x86_64
     steps:
       - uses: actions/checkout@v7
 
@@ -22,6 +35,7 @@ jobs:
       - name: Build wheels via Maturin
         uses: PyO3/maturin-action@v1
         with:
+          target: ${{ matrix.target }}
           args: --release --out dist --find-interpreter
           sccache: 'true'
           sdist: false
@@ -29,7 +43,7 @@ jobs:
       - name: Upload wheel artifacts
         uses: actions/upload-artifact@v7
         with:
-          name: wheels-${{ matrix.os }}
+          name: wheels-${{ matrix.os }}-${{ matrix.target }}
           path: dist/*.whl
 
   build-sdist:
@@ -71,3 +85,4 @@ jobs:
         with:
           repository-url: https://test.pypi.org/legacy/
           packages-dir: dist/
+          skip-existing: true  # Skips 400 errors for already uploaded files

{strobengine-0.2.0 → strobengine-0.2.1}/.github/workflows/publish.yml

@@ -9,11 +9,24 @@ on:
 
 jobs:
   build-wheels:
-    name: Build wheels on ${{ matrix.os }}
+    name: Build wheels on ${{ matrix.os }} (${{ matrix.target || 'native' }})
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        include:
+          # Linux
+          - os: ubuntu-latest
+            target: x86_64
+          # Windows
+          - os: windows-latest
+            target: x64
+          # macOS Apple Silicon (ARM64)
+          - os: macos-latest
+            target: aarch64
+          # macOS Intel (x86_64) cross-compiled on macos-latest
+          - os: macos-latest
+            target: x86_64
     steps:
       - uses: actions/checkout@v7
 
@@ -25,6 +38,7 @@ jobs:
       - name: Build wheels via Maturin
         uses: PyO3/maturin-action@v1
         with:
+          target: ${{ matrix.target }}
           args: --release --out dist --find-interpreter
           sccache: 'true'
           sdist: false
@@ -32,7 +46,7 @@ jobs:
       - name: Upload wheel artifacts
         uses: actions/upload-artifact@v7
         with:
-          name: wheels-${{ matrix.os }}
+          name: wheels-${{ matrix.os }}-${{ matrix.target }}
           path: dist/*.whl
 
   build-sdist:

{strobengine-0.2.0 → strobengine-0.2.1}/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to `strobengine` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2026-08-03
+
+### Bug Fixes
+
+- *(types)* Correct headers type in _strobengine.pyi from dict to list of tuples (#41)
+- Replace build_client panic with proper error propagation (#42)
+- Replace std::process::exit with safe PyKeyboardInterrupt on SIGINT (#43)
+- *(progress)* Guard against zero total_duration in progress bar calculation (#44)
+- Improve worker shutdown and panic handling (#45)
+- *(metrics)* Normalize counter types to AtomicU64 for 32-bit safety (#46)
+- *(cli)* Add type annotation to _output_results summary parameter (#48)
+
+### Documentation
+
+- Add comment explaining SystemExit re-raise pattern (#50)
+
+### Miscellaneous Tasks
+
+- Remove unnecessary clippy allow on run_load_test (#47)
+- Add multi-architecture matrix for macOS wheel builds (#52)
+
+### Refactoring
+
+- Extract magic number 8192 to named constant METRIC_CHANNEL_BUFFER (#49)
+- Extract magic numbers to named constants across Rust and Python (#51)
 ## [0.2.0] - 2026-08-02
 
 ### Bug Fixes
@@ -20,6 +45,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Update roadmap to reflect changes (#34)
 - Add HTTP method, body, and header documentation
 - Add code examples (#37)
+- *(changelog)* Update CHANGELOG.md for v0.2.0 release
 
 ### Features
 
@@ -43,6 +69,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - *(release)* Prepare v0.1.0 changelog and tag
 - Add PyPI publish workflow with tag-based triggering (#26)
+- *(pyproject)* Add license metadata and project URLs, bump version
+- *(release)* Merge v0.2.0 release prep into main (#40)
 
 ### Performance
 

{strobengine-0.2.0 → strobengine-0.2.1}/Cargo.lock

@@ -1273,7 +1273,7 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "strobengine"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "bytes",
  "fastrand",

{strobengine-0.2.0 → strobengine-0.2.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strobengine"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 readme = "README.md"
 

{strobengine-0.2.0 → strobengine-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strobengine
-Version: 0.2.0
+Version: 0.2.1
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.27.0
 License-File: LICENSE

{strobengine-0.2.0 → strobengine-0.2.1}/docs/roadmap.md

@@ -15,12 +15,12 @@ This document outlines the planned trajectory and upcoming feature epics for **s
 
 ### Epic: Fault Injection & Resilience Testing (Chaos)
 
-- [x] Basic chaos testing support. `[Unreleased / main]`
+- [x] Basic chaos testing support. `[v0.2.0]`
 
 ### Epic: Real-Time Telemetry & Progress Bars
 *Target Focus: UX & Observability*
 
-- [x] Interactive CLI progress indicators (live RPS, active virtual users, latency feed). `[Unreleased / main]`
+- [x] Interactive CLI progress indicators (live RPS, active virtual users, latency feed). `[v0.2.0]`
 - [ ] ~~Real-time telemetry dashboard / TUI integration.~~ *(Postponed: Python scripting is primary runner; CLI is for quick drafts only)*
 - [ ] ~~Improved streaming metrics collection to minimize memory overhead during long runs.~~ *(Deferred until $O(1)$ memory metrics are required for multi-hour runs)*
 
@@ -31,7 +31,7 @@ This document outlines the planned trajectory and upcoming feature epics for **s
 
 - [ ] Custom HTTP Headers support (authentication, user-agents, metadata).
 - [ ] Dynamic & static Request Payloads (`POST`/`PUT`/`PATCH` body support with JSON/Form Data).
-- [ ] Support for all standard HTTP methods (`GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`).
+- [x] Support for all standard HTTP methods (`GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`). `[v0.2.0]`
 
 ---
 

{strobengine-0.2.0 → strobengine-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "strobengine"
-version = "0.2.0"
+version = "0.2.1"
 description = "A load testing framework with a Python UI and a bare-metal Rust engine core."
 readme = "README.md"
 license = "Apache-2.0"

{strobengine-0.2.0 → strobengine-0.2.1}/src/lib.rs

@@ -24,6 +24,20 @@ use crate::chaos::ChaosEngine;
 use crate::config::{LoadProfile, TestConfig};
 use crate::metrics::{LiveCounters, RequestMetric};
 
+/// Buffer capacity for the async MPSC channel streaming metrics from workers to the aggregator.
+///
+/// 8,192 (~8k) provides enough head room to prevent worker task backpressure during high RPS bursts
+/// without allocating unnecessary heap memory (8,192 * std::mem::size_of::<RequestMetric>()).
+const METRIC_CHANNEL_BUFFER: usize = 8192;
+
+/// Client network configuration defaults.
+const DEFAULT_CONNECT_TIMEOUT_SECS: u64 = 5;
+const DEFAULT_H2_KEEPALIVE_INTERVAL_SECS: u64 = 10;
+const DEFAULT_H2_KEEPALIVE_TIMEOUT_SECS: u64 = 5;
+
+/// Supervisor loop poll rate in milliseconds.
+const SUPERVISOR_TICK_MS: u64 = 200;
+
 fn parse_method(method_str: &str) -> PyResult<Method> {
     method_str.to_uppercase().parse().map_err(|_| {
         pyo3::exceptions::PyValueError::new_err(format!("Invalid HTTP method: {method_str}"))
@@ -55,17 +69,20 @@ fn parse_headers(headers: Option<Vec<(String, String)>>) -> PyResult<HeaderMap>
     Ok(header_map)
 }
 
-fn build_client(concurrency: usize, timeout_secs: u64, header_map: HeaderMap) -> reqwest::Client {
+fn build_client(
+    concurrency: usize,
+    timeout_secs: u64,
+    header_map: HeaderMap,
+) -> Result<reqwest::Client, reqwest::Error> {
     reqwest::Client::builder()
         .pool_max_idle_per_host(concurrency)
         .timeout(Duration::from_secs(timeout_secs))
-        .connect_timeout(Duration::from_secs(5))
+        .connect_timeout(Duration::from_secs(DEFAULT_CONNECT_TIMEOUT_SECS))
         .tcp_nodelay(true)
-        .http2_keep_alive_interval(Duration::from_secs(10))
-        .http2_keep_alive_timeout(Duration::from_secs(5))
+        .http2_keep_alive_interval(Duration::from_secs(DEFAULT_H2_KEEPALIVE_INTERVAL_SECS))
+        .http2_keep_alive_timeout(Duration::from_secs(DEFAULT_H2_KEEPALIVE_TIMEOUT_SECS))
         .default_headers(header_map)
         .build()
-        .expect("failed to build HTTP client")
 }
 
 #[pyfunction]
@@ -74,7 +91,6 @@ fn init_logging(level: String, log_file: Option<String>) {
 }
 
 #[pyfunction]
-#[allow(clippy::too_many_arguments)]
 fn run_load_test(py: Python<'_>, config: TestConfig) -> PyResult<metrics::TestSummary> {
     py.detach(move || {
         let url = config.url;
@@ -109,9 +125,15 @@ fn run_load_test(py: Python<'_>, config: TestConfig) -> PyResult<metrics::TestSu
             .build()
             .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
 
-        rt.block_on(async move {
-            let client = build_client(concurrency, timeout_secs, header_map);
+        // Build the client OUTSIDE the async closure
+        let client = build_client(concurrency, timeout_secs, header_map)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
 
+        // Track whether cancellation was triggered by user SIGINT
+        let interrupted = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let interrupted_check = Arc::clone(&interrupted);
+
+        let result = rt.block_on(async move {
             tracing::debug!("http client created");
 
             let counters = Arc::new(LiveCounters::new());
@@ -123,20 +145,20 @@ fn run_load_test(py: Python<'_>, config: TestConfig) -> PyResult<metrics::TestSu
 
             // Spawn SIGINT listener with double Ctrl+C safety hatch
             let token_clone = cancel_token.clone();
+            let interrupted_clone = interrupted.clone();
             tokio::spawn(async move {
                 if tokio::signal::ctrl_c().await.is_ok() {
                     tracing::info!("received SIGINT, initiating graceful shutdown");
+                    interrupted_clone.store(true, Ordering::SeqCst);
                     token_clone.cancel();
 
-                    // Second Ctrl+C forces immediate termination
                     if tokio::signal::ctrl_c().await.is_ok() {
-                        tracing::warn!("received second SIGINT, terminating immediately");
-                        std::process::exit(130);
+                        tracing::warn!("received second SIGINT, shutdown already in progress");
                     }
                 }
             });
 
-            let (tx, rx) = tokio::sync::mpsc::channel::<RequestMetric>(8192);
+            let (tx, rx) = tokio::sync::mpsc::channel::<RequestMetric>(METRIC_CHANNEL_BUFFER);
 
             let aggregator = tokio::spawn(async move {
                 let mut latencies = Vec::new();
@@ -184,12 +206,17 @@ fn run_load_test(py: Python<'_>, config: TestConfig) -> PyResult<metrics::TestSu
             drop(tx);
 
             for handle in handles {
-                let _ = handle.await;
+                if let Err(e) = handle.await {
+                    tracing::warn!(error = %e, "worker task panicked");
+                }
             }
 
             // Wait for render task to finish naturally
+            #[allow(clippy::collapsible_if)]
             if let Some(handle) = render_handle {
-                let _ = handle.await;
+                if let Err(e) = handle.await {
+                    tracing::debug!(error = %e, "render task panicked");
+                }
             }
 
             let latencies = aggregator
@@ -201,8 +228,19 @@ fn run_load_test(py: Python<'_>, config: TestConfig) -> PyResult<metrics::TestSu
 
             tracing::info!(total, errors, "constant load test completed");
 
-            Ok(metrics::calculate_summary(total, errors, latencies))
-        })
+            Ok::<metrics::TestSummary, pyo3::PyErr>(metrics::calculate_summary(
+                total, errors, latencies,
+            ))
+        })?;
+
+        // If SIGINT was received, raise KeyboardInterrupt to Python
+        if interrupted_check.load(Ordering::SeqCst) {
+            return Err(pyo3::exceptions::PyKeyboardInterrupt::new_err(
+                "load test interrupted by user",
+            ));
+        }
+
+        Ok(result)
     })
 }
 
@@ -261,9 +299,14 @@ fn run_load_profiles(
             .build()
             .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
 
-        rt.block_on(async move {
-            let client = build_client(max_concurrency, timeout_secs, header_map);
+        let client = build_client(max_concurrency, timeout_secs, header_map)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
+
+        // Track whether cancellation was triggered by user SIGINT
+        let interrupted = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let interrupted_check = Arc::clone(&interrupted);
 
+        let result = rt.block_on(async move {
             tracing::debug!("http client created");
 
             let counters = Arc::new(LiveCounters::new());
@@ -275,19 +318,20 @@ fn run_load_profiles(
 
             // Spawn SIGINT listener with double Ctrl+C safety hatch
             let token_clone = cancel_token.clone();
+            let interrupted_clone = interrupted.clone();
             tokio::spawn(async move {
                 if tokio::signal::ctrl_c().await.is_ok() {
                     tracing::info!("received SIGINT, initiating graceful shutdown");
+                    interrupted_clone.store(true, Ordering::SeqCst);
                     token_clone.cancel();
 
                     if tokio::signal::ctrl_c().await.is_ok() {
-                        tracing::warn!("received second SIGINT, terminating immediately");
-                        std::process::exit(130);
+                        tracing::warn!("received second SIGINT, shutdown already in progress");
                     }
                 }
             });
 
-            let (tx, rx) = tokio::sync::mpsc::channel::<RequestMetric>(8192);
+            let (tx, rx) = tokio::sync::mpsc::channel::<RequestMetric>(METRIC_CHANNEL_BUFFER);
 
             let aggregator = tokio::spawn(async move {
                 let mut latencies = Vec::new();
@@ -323,6 +367,7 @@ fn run_load_profiles(
             let supervisor = tokio::spawn(async move {
                 let mut child_tokens: Vec<CancellationToken> = Vec::new();
                 let mut handles: Vec<tokio::task::JoinHandle<()>> = Vec::new();
+                let mut reaped_handles: Vec<tokio::task::JoinHandle<()>> = Vec::new();
                 let mut current_concurrency = 0usize;
                 let start = Instant::now();
 
@@ -357,22 +402,31 @@ fn run_load_profiles(
                         if let Some(token) = child_tokens.pop() {
                             token.cancel();
                             if let Some(handle) = handles.pop() {
-                                let _ = handle.await;
+                                reaped_handles.push(handle);
                             }
                             current_concurrency -= 1;
                         }
                     }
 
+                    // Join reaped workers concurrently
+                    for handle in reaped_handles.drain(..) {
+                        if let Err(e) = handle.await {
+                            tracing::debug!(error = %e, "cancelled worker panicked during shutdown");
+                        }
+                    }
+
                     tracing::debug!(current_concurrency, target, "supervisor tick");
 
-                    tokio::time::sleep(Duration::from_millis(200)).await;
+                    tokio::time::sleep(Duration::from_millis(SUPERVISOR_TICK_MS)).await;
                 }
 
                 for token in child_tokens {
                     token.cancel();
                 }
                 for handle in handles {
-                    let _ = handle.await;
+                    if let Err(e) = handle.await {
+                        tracing::warn!(error = %e, "worker task panicked");
+                    }
                 }
 
                 drop(tx);
@@ -383,8 +437,11 @@ fn run_load_profiles(
                 .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
 
             // Wait for render task to finish naturally
+            #[allow(clippy::collapsible_if)]
             if let Some(handle) = render_handle {
-                let _ = handle.await;
+                if let Err(e) = handle.await {
+                    tracing::debug!(error = %e, "render task panicked");
+                }
             }
 
             let latencies = aggregator
@@ -396,8 +453,19 @@ fn run_load_profiles(
 
             tracing::info!(total, errors, "profile load test completed");
 
-            Ok(metrics::calculate_summary(total, errors, latencies))
-        })
+            Ok::<metrics::TestSummary, pyo3::PyErr>(metrics::calculate_summary(
+                total, errors, latencies,
+            ))
+        })?;
+
+        // If SIGINT was received, raise KeyboardInterrupt to Python
+        if interrupted_check.load(Ordering::SeqCst) {
+            return Err(pyo3::exceptions::PyKeyboardInterrupt::new_err(
+                "load test interrupted by user",
+            ));
+        }
+
+        Ok(result)
     })
 }
 

{strobengine-0.2.0 → strobengine-0.2.1}/src/metrics.rs

@@ -2,6 +2,9 @@ use std::sync::atomic::{AtomicU64, AtomicUsize};
 
 use pyo3::prelude::*;
 
+/// Conversion factor from microseconds to milliseconds (1 ms = 1,000 us).
+pub const MICROS_PER_MILLI: f64 = 1_000.0;
+
 #[allow(dead_code)]
 pub struct RequestMetric {
     pub status_code: u16,
@@ -10,8 +13,8 @@ pub struct RequestMetric {
 }
 
 pub struct LiveCounters {
-    pub total_requests: AtomicUsize,
-    pub errors: AtomicUsize,
+    pub total_requests: AtomicU64,
+    pub errors: AtomicU64,
     pub active_workers: AtomicUsize,
     pub completed_requests: AtomicU64,
     pub latency_sum_micros: AtomicU64,
@@ -21,8 +24,8 @@ pub struct LiveCounters {
 impl LiveCounters {
     pub fn new() -> Self {
         Self {
-            total_requests: AtomicUsize::new(0),
-            errors: AtomicUsize::new(0),
+            total_requests: AtomicU64::new(0),
+            errors: AtomicU64::new(0),
             active_workers: AtomicUsize::new(0),
             completed_requests: AtomicU64::new(0),
             latency_sum_micros: AtomicU64::new(0),
@@ -46,11 +49,15 @@ pub struct TestSummary {
     pub p99_latency_ms: f64,
 }
 
-pub fn calculate_summary(total: usize, errors: usize, mut latencies: Vec<u128>) -> TestSummary {
+pub fn calculate_summary(
+    total_requests: u64,
+    total_errors: u64,
+    mut latencies: Vec<u128>,
+) -> TestSummary {
     if latencies.is_empty() {
         return TestSummary {
-            total_requests: total,
-            total_errors: errors,
+            total_requests: total_requests as usize,
+            total_errors: total_errors as usize,
             average_latency_ms: 0.0,
             p95_latency_ms: 0.0,
             p99_latency_ms: 0.0,
@@ -61,17 +68,17 @@ pub fn calculate_summary(total: usize, errors: usize, mut latencies: Vec<u128>)
 
     let len = latencies.len();
     let sum: u128 = latencies.iter().sum();
-    let average_latency_ms = sum as f64 / len as f64 / 1000.0;
+    let average_latency_ms = sum as f64 / len as f64 / MICROS_PER_MILLI;
 
     let p95_idx = (len * 95 / 100).min(len - 1);
     let p99_idx = (len * 99 / 100).min(len - 1);
 
     TestSummary {
-        total_requests: total,
-        total_errors: errors,
+        total_requests: total_requests as usize,
+        total_errors: total_errors as usize,
         average_latency_ms,
-        p95_latency_ms: latencies[p95_idx] as f64 / 1000.0,
-        p99_latency_ms: latencies[p99_idx] as f64 / 1000.0,
+        p95_latency_ms: latencies[p95_idx] as f64 / MICROS_PER_MILLI,
+        p99_latency_ms: latencies[p99_idx] as f64 / MICROS_PER_MILLI,
     }
 }
 

{strobengine-0.2.0 → strobengine-0.2.1}/src/progress.rs

@@ -5,10 +5,16 @@ use std::time::{Duration, Instant};
 use indicatif::{ProgressBar, ProgressStyle};
 use tokio_util::sync::CancellationToken;
 
-use crate::metrics::LiveCounters;
+use crate::metrics::{LiveCounters, MICROS_PER_MILLI};
+
+/// Target update rate for the terminal UI tick loop.
+const RENDER_LOOP_SLEEP_MS: u64 = 200;
+
+/// Indicatif progress bar total resolution ticks.
+const PROGRESS_BAR_MAX_TICKS: u64 = 100;
 
 pub fn create_progress_bar(_total_duration: Duration) -> ProgressBar {
-    let pb = ProgressBar::new(100);
+    let pb = ProgressBar::new(PROGRESS_BAR_MAX_TICKS);
     pb.set_style(
         ProgressStyle::with_template(
             "{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/dim}] {pos}% | {msg}",
@@ -33,7 +39,7 @@ pub async fn render_loop(
 
     loop {
         tokio::select! {
-            _ = tokio::time::sleep(Duration::from_millis(200)) => {
+            _ = tokio::time::sleep(Duration::from_millis(RENDER_LOOP_SLEEP_MS)) => {
                 let now = Instant::now();
                 let delta_sec = (now - last_tick).as_secs_f64();
                 last_tick = now;
@@ -48,7 +54,11 @@ pub async fn render_loop(
                 }
 
                 // Progress percentage based on elapsed time
-                let pct = (elapsed.as_secs_f64() / total_duration.as_secs_f64() * 100.0) as u64;
+                let pct = if total_duration.is_zero() {
+                    0
+                } else {
+                    (elapsed.as_secs_f64() / total_duration.as_secs_f64() * 100.0) as u64
+                };
                 pb.set_position(pct.min(99));
 
                 // Sample metrics
@@ -66,7 +76,7 @@ pub async fn render_loop(
 
                 // Average latency across all completed requests
                 let avg_latency_ms = if latency_count > 0 {
-                    latency_sum as f64 / latency_count as f64 / 1000.0
+                    latency_sum as f64 / latency_count as f64 / MICROS_PER_MILLI
                 } else {
                     0.0
                 };

{strobengine-0.2.0 → strobengine-0.2.1}/src/strobengine/_strobengine.pyi

@@ -30,7 +30,7 @@ class TestConfig:
     no_progress: bool
     method: str
     body: str | None
-    headers: dict[str, str] | None
+    headers: list[tuple[str, str]] | None
     def __init__(
         self,
         url: str,
@@ -42,7 +42,7 @@ class TestConfig:
         no_progress: bool = False,
         method: str = "GET",
         body: str | None = None,
-        headers: dict[str, str] | None = None,
+        headers: list[tuple[str, str]] | None = None,
     ) -> None: ...
 
 class TestSummary:
@@ -68,5 +68,5 @@ def run_load_profiles(
     no_progress: bool = False,
     method: str = "GET",
     body: str | None = None,
-    headers: dict[str, str] | None = None,
+    headers: list[tuple[str, str]] | None = None,
 ) -> TestSummary: ...

{strobengine-0.2.0 → strobengine-0.2.1}/src/strobengine/cli.py

@@ -6,7 +6,7 @@ from typing import Annotated
 
 import typer
 
-from strobengine._strobengine import init_logging
+from strobengine._strobengine import TestSummary, init_logging
 from strobengine.engine import RequestOptions, StrobEngine
 from strobengine.reporter import print_summary
 
@@ -114,7 +114,9 @@ def _global_options(
     pass
 
 
-def _output_results(summary, url: str, duration_secs: int, json_output: bool) -> None:
+def _output_results(
+    summary: TestSummary, url: str, duration_secs: int, json_output: bool
+) -> None:
     if json_output:
         print(
             json.dumps(
@@ -394,6 +396,7 @@ def main(argv: list[str] | None = None) -> None:
     try:
         app(args=argv)
     except SystemExit as e:
+        # Re-raise to prevent KeyboardInterrupt handler from catching typer exits
         raise e
     except KeyboardInterrupt:
         typer.echo("\nInterrupted.", err=True)

strobengine-0.2.1/src/strobengine/constants.py

@@ -0,0 +1,14 @@
+"""Default configuration values for strobengine execution."""
+
+DEFAULT_CONCURRENCY: int = 10
+DEFAULT_DURATION_SECS: int = 10
+DEFAULT_TIMEOUT_SECS: int = 10
+DEFAULT_START_CONCURRENCY: int = 10
+DEFAULT_MAX_CONCURRENCY: int = 200
+DEFAULT_RAMP_SECS: int = 60
+DEFAULT_HOLD_SECS: int = 30
+DEFAULT_BASELINE: int = 5
+DEFAULT_PEAK_CONCURRENCY: int = 500
+DEFAULT_PRE_SPIKE_SECS: int = 5
+DEFAULT_SPIKE_SECS: int = 10
+DEFAULT_POST_SPIKE_SECS: int = 5

{strobengine-0.2.0 → strobengine-0.2.1}/src/strobengine/engine.py

@@ -8,13 +8,27 @@ from strobengine._strobengine import (
     run_load_profiles,
     run_load_test,
 )
+from strobengine.constants import (
+    DEFAULT_BASELINE,
+    DEFAULT_CONCURRENCY,
+    DEFAULT_DURATION_SECS,
+    DEFAULT_HOLD_SECS,
+    DEFAULT_MAX_CONCURRENCY,
+    DEFAULT_PEAK_CONCURRENCY,
+    DEFAULT_POST_SPIKE_SECS,
+    DEFAULT_PRE_SPIKE_SECS,
+    DEFAULT_RAMP_SECS,
+    DEFAULT_SPIKE_SECS,
+    DEFAULT_START_CONCURRENCY,
+    DEFAULT_TIMEOUT_SECS,
+)
 
 
 @dataclass
 class RequestOptions:
     """Encapsulates common HTTP and execution parameters with validation."""
 
-    timeout: int = 10
+    timeout: int = DEFAULT_TIMEOUT_SECS
     chaos: bool = False
     no_progress: bool = False
     method: str = "GET"
@@ -30,8 +44,8 @@ class StrobEngine:
     def __init__(
         self,
         url: str,
-        concurrency: int = 10,
-        duration: int = 10,
+        concurrency: int = DEFAULT_CONCURRENCY,
+        duration: int = DEFAULT_DURATION_SECS,
         options: RequestOptions | None = None,
         profile: LoadProfile | None = None,
     ) -> None:
@@ -64,8 +78,8 @@ class StrobEngine:
     def load_test(
         cls,
         url: str,
-        concurrency: int = 10,
-        duration: int = 10,
+        concurrency: int = DEFAULT_CONCURRENCY,
+        duration: int = DEFAULT_DURATION_SECS,
         options: RequestOptions | None = None,
     ) -> "StrobEngine":
         return cls(
@@ -79,10 +93,10 @@ class StrobEngine:
     def stress_test(
         cls,
         url: str,
-        start_concurrency: int = 10,
-        max_concurrency: int = 200,
-        ramp_duration: int = 60,
-        hold_duration: int = 30,
+        start_concurrency: int = DEFAULT_START_CONCURRENCY,
+        max_concurrency: int = DEFAULT_MAX_CONCURRENCY,
+        ramp_duration: int = DEFAULT_RAMP_SECS,
+        hold_duration: int = DEFAULT_HOLD_SECS,
         options: RequestOptions | None = None,
     ) -> "StrobEngine":
         if start_concurrency <= 0:
@@ -112,11 +126,11 @@ class StrobEngine:
     def spike_test(
         cls,
         url: str,
-        baseline: int = 5,
-        peak_concurrency: int = 500,
-        pre_spike_duration: int = 5,
-        spike_duration: int = 10,
-        post_spike_duration: int = 5,
+        baseline: int = DEFAULT_BASELINE,
+        peak_concurrency: int = DEFAULT_PEAK_CONCURRENCY,
+        pre_spike_duration: int = DEFAULT_PRE_SPIKE_SECS,
+        spike_duration: int = DEFAULT_SPIKE_SECS,
+        post_spike_duration: int = DEFAULT_POST_SPIKE_SECS,
         options: RequestOptions | None = None,
     ) -> "StrobEngine":
         if baseline <= 0:

{strobengine-0.2.0 → strobengine-0.2.1}/uv.lock

@@ -155,7 +155,7 @@ wheels = [
 
 [[package]]
 name = "strobengine"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "rich" },