From e4896f2c6c0b10ab013d43f97ef9f713da718d74 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Fri, 10 Jul 2026 19:51:52 +0530 Subject: [PATCH 01/37] fix(enterprise): export diff_schema and ContractViolation from freshdata.enterprise Both names are promised by the PEP 562 lazy surface in freshdata/__init__.py (_ENTERPRISE_EXPORTS) but were never re-exported by freshdata.enterprise, so fd.diff_schema / fd.ContractViolation raised AttributeError and the shipped schema_drift_monitoring example crashed. Adds a regression test that resolves every lazy enterprise export. --- src/freshdata/enterprise/__init__.py | 4 ++++ tests/test_api.py | 8 ++++++++ 2 files changed, 12 insertions(+) diff --git a/src/freshdata/enterprise/__init__.py b/src/freshdata/enterprise/__init__.py index d4ca927..baa81bf 100644 --- a/src/freshdata/enterprise/__init__.py +++ b/src/freshdata/enterprise/__init__.py @@ -54,12 +54,14 @@ from .contracts import ( ColumnBaseline, ColumnContract, + ContractViolation, DataContract, DatasetBaseline, DriftFinding, DriftReport, build_baseline, compare_to_baseline, + diff_schema, load_baseline, monitor_contract, save_baseline, @@ -160,6 +162,7 @@ "EntityResolutionConfig", # contracts / drift "ColumnContract", + "ContractViolation", "DataContract", "ColumnBaseline", "DatasetBaseline", @@ -170,6 +173,7 @@ "load_baseline", "compare_to_baseline", "monitor_contract", + "diff_schema", # dirty-join assistant "suggest_join_keys", "JoinKeyReport", diff --git a/tests/test_api.py b/tests/test_api.py index 1901567..ed84de3 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -138,6 +138,14 @@ def test_version_and_exports(): assert getattr(fd, name, None) is not None +def test_every_lazy_enterprise_export_resolves(): + # Every name promised by the PEP 562 lazy surface must actually exist on + # freshdata.enterprise; a listed-but-missing name only fails at attribute + # access time (regression: fd.diff_schema / fd.ContractViolation). + for name in sorted(fd._ENTERPRISE_EXPORTS): + assert getattr(fd, name, None) is not None, f"fd.{name} does not resolve" + + def test_legacy_top_level_helpers_remain_exported(): for name in ( "clean_csv", From d3c35dfec57457c176c2cd20d08bb45d74897125 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Fri, 10 Jul 2026 19:51:53 +0530 Subject: [PATCH 02/37] fix(examples): use suggest_plan for the contract-riding schema diff fd.profile() never accepted contract=/on_missing=; the supported way to have the baseline-free diff ride along is fd.suggest_plan(contract=...), which attaches it at plan.schema_diff. The example now runs end to end. --- examples/schema_drift_monitoring.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/schema_drift_monitoring.py b/examples/schema_drift_monitoring.py index eb3a8aa..9820a97 100644 --- a/examples/schema_drift_monitoring.py +++ b/examples/schema_drift_monitoring.py @@ -97,9 +97,9 @@ def main() -> None: print("\nfindings table:") print(diff.to_frame()[["check_id", "column", "level", "message"]].to_string(index=False)) - # The same diff can ride along with a read-only profile of the incoming data. - prof = fd.profile(incoming, contract=contract_sem, on_missing="fail") - print(f"\nprofile carries schema_diff: passed={prof.schema_diff.passed}") + # The same diff can ride along with a suggested plan for the incoming data. + plan = fd.suggest_plan(incoming, contract=contract_sem, on_missing="fail") + print(f"\nplan carries schema_diff: passed={plan.schema_diff.passed}") if __name__ == "__main__": From 45b81ec4b776e6e4da5512abac89dc9599f2e873 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Fri, 10 Jul 2026 19:52:12 +0530 Subject: [PATCH 03/37] =?UTF-8?q?fix(outliers):=20compute=20fences=20on=20?= =?UTF-8?q?the=20finite=20bulk=20so=20=C2=B1inf=20is=20detected,=20not=20d?= =?UTF-8?q?etection-disabling?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A column containing ±inf made the IQR quantiles NaN/infinite (leaking a numpy RuntimeWarning from quantile interpolation) and made skew/std undefined, so detection_bounds returned None and outlier handling silently skipped exactly the columns that need it most. Fences and skewness are now measured on the finite values; the infinities land outside the fences and are handled like any other outlier. Columns with no finite bulk are still skipped. Covers fd.clean (engine + outliers=clip/flag), fd.profile and fd.suggest_plan. --- src/freshdata/steps/outliers.py | 19 +++++++++++++++++- tests/test_outliers.py | 34 +++++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 1 deletion(-) diff --git a/src/freshdata/steps/outliers.py b/src/freshdata/steps/outliers.py index 83bbecc..f0328c9 100644 --- a/src/freshdata/steps/outliers.py +++ b/src/freshdata/steps/outliers.py @@ -13,6 +13,7 @@ import math +import numpy as np import pandas as pd from pandas.api.types import is_bool_dtype, is_integer_dtype, is_numeric_dtype @@ -23,9 +24,21 @@ _NORMALISH_SKEW = 0.5 +def drop_infinite(s: pd.Series) -> pd.Series: + """*s* without ±inf values. Shape statistics (skew, quantiles, std) are + NaN on infinite data — and numpy leaks RuntimeWarnings computing them — + so every fence/skew helper here measures the finite bulk instead.""" + if not is_numeric_dtype(s) or is_bool_dtype(s): + return s + inf_mask = np.isinf(s.to_numpy(dtype="float64", na_value=np.nan)) + if not inf_mask.any(): + return s + return s[~inf_mask] + + def safe_skew(s: pd.Series) -> float | None: """Sample skewness of a numeric series, or None when undefined.""" - nonnull = s.dropna() + nonnull = drop_infinite(s).dropna() if len(nonnull) < 3: return None try: @@ -70,6 +83,10 @@ def detection_bounds( s: pd.Series, method: str, factor: float ) -> tuple[float, float] | None: """(lower, upper) fences for *s*, or None when undefined (constant data).""" + # Fence on the finite bulk: ±inf would otherwise poison the fences and + # silently disable detection for exactly the columns that need it most, + # while the infinities themselves must land outside the fences. + s = drop_infinite(s) if method == "iqr": q1, q3 = s.quantile(0.25), s.quantile(0.75) spread = q3 - q1 diff --git a/tests/test_outliers.py b/tests/test_outliers.py index 07a7fd5..9b557de 100644 --- a/tests/test_outliers.py +++ b/tests/test_outliers.py @@ -1,3 +1,5 @@ +import warnings + import pandas as pd import freshdata as fd @@ -76,3 +78,35 @@ def test_custom_factor(): df = pd.DataFrame({"v": BASE + [14.0]}) loose = fd.clean(df, outliers="clip", outlier_factor=10.0, **ISOLATE) assert loose["v"].max() == 14.0 # wide fences: nothing clipped + + +def test_infinite_values_do_not_poison_fences_or_leak_warnings(): + # ±inf used to make the IQR quantiles NaN/infinite: detection silently + # returned no fences and numpy's quantile interpolation leaked a + # RuntimeWarning to the caller. Fences must come from the finite bulk, + # with the infinities themselves detected as outliers. + df = pd.DataFrame({"v": BASE + [float("inf"), float("-inf")]}) + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + out = fd.clean(df, outliers="flag", **ISOLATE) + assert "v_outlier" in out.columns + assert out["v_outlier"].sum() == 2 + assert out.loc[out["v"] == float("inf"), "v_outlier"].all() + + +def test_infinite_values_flagged_by_zscore_path_too(): + df = pd.DataFrame({"v": BASE * 5 + [float("inf")]}) + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + out = fd.clean(df, outliers="flag", outlier_method="zscore", **ISOLATE) + assert "v_outlier" in out.columns + assert bool(out["v_outlier"].iloc[-1]) + + +def test_all_infinite_column_is_skipped_not_crashed(): + df = pd.DataFrame({"v": [float("inf"), float("-inf")] * 6}) + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + out, report = fd.clean(df, outliers="clip", return_report=True, **ISOLATE) + # no finite bulk -> no fences -> column left alone + assert not [a for a in report if a.step == "outliers"] From f72438304180dc4321e82793284faaaefa606aa1 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Fri, 10 Jul 2026 19:52:12 +0530 Subject: [PATCH 04/37] fix(cli): report missing input files in one line instead of a traceback freshdata and dbt-gate are documented for scripting/CI; a wrong input path previously dumped a ~29-line traceback. Both entry points now print ': error: ...' to stderr and exit 1. Only FileNotFoundError is caught; everything else still propagates intact. --- src/freshdata/enterprise/cli.py | 11 ++++++++--- src/freshdata/integrations/dbt/cli.py | 20 +++++++++++++------- tests/test_enterprise_cli.py | 9 +++++++++ tests/test_integrations/test_dbt.py | 9 +++++++++ 4 files changed, 39 insertions(+), 10 deletions(-) diff --git a/src/freshdata/enterprise/cli.py b/src/freshdata/enterprise/cli.py index e317480..8359ec1 100644 --- a/src/freshdata/enterprise/cli.py +++ b/src/freshdata/enterprise/cli.py @@ -15,6 +15,7 @@ import argparse import json +import sys from pathlib import Path from typing import Any @@ -827,10 +828,14 @@ def main(argv: list[str] | None = None) -> int: """Entry point: parse *argv* (or ``sys.argv``) and dispatch. Returns an exit code.""" parser = build_parser() args = parser.parse_args(argv) - return int(args.func(args)) + try: + return int(args.func(args)) + except FileNotFoundError as exc: + # A wrong input path is routine CLI misuse, not a crash: report it in + # one line instead of a traceback. Everything else propagates intact. + print(f"freshdata: error: {exc}", file=sys.stderr) + return 1 if __name__ == "__main__": # pragma: no cover - import sys - sys.exit(main()) diff --git a/src/freshdata/integrations/dbt/cli.py b/src/freshdata/integrations/dbt/cli.py index 269c41b..5b1f42f 100644 --- a/src/freshdata/integrations/dbt/cli.py +++ b/src/freshdata/integrations/dbt/cli.py @@ -60,13 +60,19 @@ def _build_parser() -> argparse.ArgumentParser: def main(argv: list[str] | None = None) -> int: """Entry point for the ``dbt-gate`` script. Returns a process exit code.""" args = _build_parser().parse_args(argv) - summary = gate_manifest( - args.manifest, - conn_str=args.conn, - trust_score_threshold=args.threshold, - on_low_score=args.on_low_score, - output_dir=args.output_dir, - ) + try: + summary = gate_manifest( + args.manifest, + conn_str=args.conn, + trust_score_threshold=args.threshold, + on_low_score=args.on_low_score, + output_dir=args.output_dir, + ) + except FileNotFoundError as exc: + # A wrong manifest path is routine CLI misuse, not a crash: report it + # in one line instead of a traceback. Everything else propagates intact. + print(f"dbt-gate: error: {exc}", file=sys.stderr) + return 1 json.dump(summary, sys.stdout, indent=2, default=str) sys.stdout.write("\n") if args.fail and not summary["all_passed"]: diff --git a/tests/test_enterprise_cli.py b/tests/test_enterprise_cli.py index e7aa88a..3503636 100644 --- a/tests/test_enterprise_cli.py +++ b/tests/test_enterprise_cli.py @@ -162,3 +162,12 @@ def test_json_round_trip(tmp_path): def test_main_requires_subcommand(): with pytest.raises(SystemExit): cli.main([]) + + +def test_missing_input_file_prints_one_line_error_not_traceback(capsys): + code = cli.main(["clean", "definitely_not_here.csv", "-o", "out.csv"]) + assert code == 1 + err = capsys.readouterr().err + assert "freshdata: error:" in err + assert "definitely_not_here.csv" in err + assert "Traceback" not in err diff --git a/tests/test_integrations/test_dbt.py b/tests/test_integrations/test_dbt.py index b8f5ce1..dffefef 100644 --- a/tests/test_integrations/test_dbt.py +++ b/tests/test_integrations/test_dbt.py @@ -103,3 +103,12 @@ def test_cli_pass_and_fail_exit_codes(warehouse, tmp_path, capsys): assert "all_passed" in capsys.readouterr().out rc = main(["--manifest", manifest, "--conn", warehouse, "--threshold", "999", "--fail"]) assert rc == 1 + + +def test_cli_missing_manifest_prints_one_line_error(capsys): + code = main(["--manifest", "definitely_not_here.json"]) + assert code == 1 + err = capsys.readouterr().err + assert "dbt-gate: error:" in err + assert "definitely_not_here.json" in err + assert "Traceback" not in err From 6f6c2fed09593f9797d80fa1f5cda154f13f0292 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Fri, 10 Jul 2026 20:02:17 +0530 Subject: [PATCH 05/37] =?UTF-8?q?perf(outliers):=20only=20float=20dtypes?= =?UTF-8?q?=20are=20scanned=20for=20=C2=B1inf?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Integer/bool/non-numeric columns cannot hold infinities, so drop_infinite now passes them through without the O(n) isinf scan added in the previous commit. --- src/freshdata/steps/outliers.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/freshdata/steps/outliers.py b/src/freshdata/steps/outliers.py index f0328c9..f2b269d 100644 --- a/src/freshdata/steps/outliers.py +++ b/src/freshdata/steps/outliers.py @@ -15,7 +15,12 @@ import numpy as np import pandas as pd -from pandas.api.types import is_bool_dtype, is_integer_dtype, is_numeric_dtype +from pandas.api.types import ( + is_bool_dtype, + is_float_dtype, + is_integer_dtype, + is_numeric_dtype, +) from ..config import _DEFAULT_FACTOR, CleanConfig from ..report import CleanReport @@ -27,8 +32,11 @@ def drop_infinite(s: pd.Series) -> pd.Series: """*s* without ±inf values. Shape statistics (skew, quantiles, std) are NaN on infinite data — and numpy leaks RuntimeWarnings computing them — - so every fence/skew helper here measures the finite bulk instead.""" - if not is_numeric_dtype(s) or is_bool_dtype(s): + so every fence/skew helper here measures the finite bulk instead. + + Only float dtypes can hold ±inf, so everything else passes through + without the O(n) scan.""" + if not is_float_dtype(s): return s inf_mask = np.isinf(s.to_numpy(dtype="float64", na_value=np.nan)) if not inf_mask.any(): From 21bec88d8f44eaeb081cb0ac2e70e6cd7215e72e Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 10:11:14 +0530 Subject: [PATCH 06/37] docs: design performance scalability investigation --- ...reshdata-performance-scalability-design.md | 360 ++++++++++++++++++ 1 file changed, 360 insertions(+) create mode 100644 docs/superpowers/specs/2026-07-11-freshdata-performance-scalability-design.md diff --git a/docs/superpowers/specs/2026-07-11-freshdata-performance-scalability-design.md b/docs/superpowers/specs/2026-07-11-freshdata-performance-scalability-design.md new file mode 100644 index 0000000..d175898 --- /dev/null +++ b/docs/superpowers/specs/2026-07-11-freshdata-performance-scalability-design.md @@ -0,0 +1,360 @@ +# FreshData Performance and Scalability Investigation Design + +**Status:** Approved in conversation on 2026-07-11 + +**Baseline:** Git commit `6f6c2fe` on branch +`fix/public-exports-and-inf-outliers-jwd` + +## Objective + +Measure, explain, and reduce FreshData's verified runtime and memory bottlenecks +without changing its public API, cleaning decisions, safety guarantees, audit +trail, context policies, validation behavior, or supported backends. The work +must independently reproduce or disprove each performance hypothesis, retain +only evidence-backed optimizations, and publish the commands and results needed +to reproduce every claim. + +An optimization is a verified win only when it improves the relevant median +runtime or peak-memory measurement by at least 10%, the improvement is greater +than twice the observed run-to-run variability, and it introduces no meaningful +regression in another primary workload. + +## Compatibility Constraints + +- Python support remains `>=3.9`, including the project's tested Python + 3.9-3.13 matrix. +- pandas support remains `>=1.5,<3`; NumPy remains `>=1.21`. +- The default cleaning strategy remains `balanced`, with the current + representation-repair defaults unchanged. +- Public function and class signatures, configuration fields, return types, + warnings, exceptions, index semantics, and audit/report contracts remain + compatible. +- No unrelated runtime dependency is introduced. Profiling additions use the + standard library and already-declared benchmark/development dependencies. + +## Current Architecture and Execution Flow + +The public cleaning path is: + +```text +fd.clean + -> normalize API options and validate contracts/context/memory/profile inputs + -> select the pandas or native execution path + -> initialize CleanReport and preserve-original handling + -> representation repair + column names + strings and sentinels + empty rows and columns + dtype repair + optional constant-column removal + duplicate handling + optional semantic repair + -> decision engine + build per-column contexts + build reusable engine statistics/correlations + automatic missing-value decisions + automatic outlier decisions + -> explicit imputation and outlier overrides + -> optional memory optimization + -> protected-column verification and index handling + -> finalize report + -> wrap or convert the result +``` + +The pandas implementation in `src/freshdata/cleaner.py` is the behavioral +reference. `src/freshdata/engine/context.py` profiles roles and statistics, +`src/freshdata/engine/cache.py` shares artifacts between automatic missing and +outlier processing, and `src/freshdata/steps/` implements representation-level +operations. Native engines in `src/freshdata/execution/backends/` reproduce a +documented subset and fall back to pandas when required. Every path must retain +the existing `CleanReport` contract. + +`return_report=False` does not mean that report construction can be removed: +the pandas result remains a `CleanResult` with an embedded report and +`Cleaner.report_` is always populated. Optimization may defer or avoid only +internal work proven unnecessary while preserving those behaviors exactly. + +## Chosen Approach + +Use an evidence-gated sequence: + +1. Establish an immutable baseline and a reproducible benchmark/profiling + harness. +2. Profile the complete pandas pipeline and separate core cleaning, reporting, + optional ML/semantic work, conversion, and backend costs. +3. Implement one measured optimization at a time behind equivalence tests. +4. Re-run the affected benchmark slice after each change and discard changes + that do not exceed the noise threshold. +5. Expand CI-safe regression checks and scheduled/manual large-data coverage. +6. Evaluate native and out-of-core options from measurements rather than begin + with an architectural rewrite. +7. Correct documentation and assemble the final evidence package. + +This approach was selected over a broad refactor, which would obscure causal +attribution, and a backend-first rewrite, which would add compatibility risk +before the reference pandas bottlenecks are known. + +## Workstream Boundaries + +### 1. Baseline and Profiling Infrastructure + +Create a focused `benchmarks/performance/` package with independent modules for +dataset generation, run configuration, subprocess measurement, profiling, +result validation, comparison, and Markdown rendering. Keep it separate from +production imports. Reuse existing benchmark utilities only where their result +schema and measurement semantics match this investigation. + +The authoritative output is versioned JSON. Generated Markdown is a view of +that JSON. Each result records: + +- Git commit and dirty-state indicator. +- FreshData, Python, pandas, NumPy, and optional-backend versions. +- Operating system, CPU, logical/physical core count, and available RAM. +- Dataset seed, shape, width profile, and column-family counts. +- Full cleaning configuration, backend, output format, and report flag. +- Warm-up count, measured repetitions, and exact command. +- Per-run wall time, median, minimum, maximum, standard deviation, coefficient + of variation, and rows per second. +- Peak RSS increase, Python allocation peak, input bytes, and input-to-peak + ratio. +- Equivalent pandas baseline time, FreshData slowdown ratio, and before/after + FreshData improvement ratio where the comparison is semantically valid. +- Completion, skip, failure, timeout, or memory-exhaustion status. + +The command-line interface accepts configurable row count, column count or +width profile, dataset type, cleaning configuration, repetition count, backend, +report generation, output format, seed, timeout, and JSON/Markdown destination. + +### 2. Pandas Pipeline Optimization + +Treat the following as hypotheses until profiling confirms them: + +- Repeated null, non-null, uniqueness, mode, dtype, role, and shape scans can + be reused through the engine cache. +- The full numeric correlation matrix is built when no consumer can use it. +- Missing and outlier dispatch rescans columns despite exact context data. +- String, sentinel, dtype, or numeric operations perform avoidable copies or + conversions. +- Report finalization repeats full-frame work that can be safely shared. +- A precomputed execution plan can reduce dispatch overhead for repeated + compatible transformations. + +Only exact reuse is allowed. If a cached value could be stale after an earlier +stage changes a column, the current computation remains authoritative. +Correlation work may be skipped only when it is provably unused, including +cases such as balanced mode, explicit imputation, frames above the existing +10,000-row KNN limit, or the absence of an eligible medium-missing numeric +target. When correlations are needed, a targeted calculation is acceptable +only if it produces pandas-equivalent values. + +Batching is permitted only for compatible columns and must retain column order, +dtypes, action ordering, counts, rationales, risks, confidence values, warnings, +and exceptions. Copy reductions must preserve `preserve_original`, pandas +copy-on-write compatibility, protected-column snapshots, and documented input +mutation behavior. + +### 3. Correctness and Regression Coverage + +Add differential tests that compare the optimized implementation with baseline +behavior for values, shape, column order, index values/names, exact dtypes, +input mutation, actions and action order, counts, rationale, risk, confidence, +warnings, recommendations, fallback events, and serialized reports. + +Coverage includes: + +- Normal mixed frames, empty frames, and single-row frames. +- All-null and constant columns. +- Boolean and nullable-boolean columns. +- Nullable integer columns and ordinary integer columns. +- Float32, float64, finite values, NaN, and positive/negative infinity. +- Categorical columns, including missing categories. +- Datetime and timezone-aware columns. +- Mixed object payloads and unhashable values. +- Identifiers, targets, context-protected columns, and PII-sensitive fields. +- Duplicate rows, supported duplicate labels, and duplicate-resolution modes. +- Standard indexes, named indexes, DatetimeIndex, and MultiIndex where + supported. +- Narrow, medium, wide, and large frames. +- Report-enabled and report-disabled calls. +- Conservative, balanced, aggressive, explicit imputation/outlier, semantic, + context-policy, memory/profile replay, and native-fallback paths. +- Existing exception types, validation order, and warning text/categories. + +CI performance tests assert stable structural properties rather than tiny wall +time differences. Examples include proving that correlations are not computed +when unused, exact cached counts are reused, and disabled features do not invoke +their stages. Runtime and peak-memory thresholds belong in scheduled or manual +performance jobs. + +### 4. Backend and Out-of-Core Evaluation + +Measure pandas, Polars, DuckDB, Spark, and FreshCore where their optional +dependencies and runtime requirements are available. For every relevant step, +record whether execution is native, materialized, converted, or delegated to +pandas, including conversion time, peak memory, fallback events, and audit +differences. + +Produce evidence-based recommendations for: + +- A native Polars lazy execution engine. +- DuckDB larger-than-memory processing. +- Chunked pandas execution. +- Rust/FreshCore acceleration of verified hot loops. + +Do not implement a large backend rewrite unless optimized pandas measurements +still miss the scalability targets and the proposed native path can preserve +the public behavior and audit contract. Otherwise provide an implementation +proposal with boundaries, milestones, compatibility requirements, and +benchmark targets. + +### 5. Documentation and Verification + +Publish `docs/performance-investigation.md` as the evidence-backed report and +update `README.md`, benchmark documentation, backend documentation, +limitations, and production-readiness claims where measurements contradict or +qualify phrases such as "fast", "vectorized", "scalable", or "memory +efficient". + +The documentation states measured performance ranges, known scalability and +correlation-cost limits, memory considerations, report/non-report behavior, +recommended large-data configurations, and the status of optional fast or +backend-native paths. + +No benchmark result may be presented without its environment and command. Poor +results and unresolved limitations remain visible. + +## Benchmark Matrix + +The deterministic mixed-schema generator covers numeric, categorical, string, +nullable, datetime, timezone-aware, identifier, target, duplicate, missing, +outlier, and high-cardinality data. + +| Dimension | Values | +|---|---| +| Rows | 10,000; 100,000; 500,000; 1,000,000 | +| Width | narrow: 8; medium: 32; wide: 128 columns | +| Cleaning | default balanced; conservative; representation features disabled; statistical features disabled; explicit imputation/outliers; optional ML/semantic | +| Report flag | `return_report=True`; `return_report=False` | +| Backend | pandas; installed Polars, DuckDB, Spark, FreshCore paths | +| Output | pandas and supported eager/lazy native output formats | +| Repetitions | one warm-up, then five measured runs | + +Equivalent pandas baselines are used only for comparable component workloads; +they must implement the same selected transformation and may not be described +as equivalent to FreshData's full decision and audit pipeline. + +## Profiling Design + +Profiling is development-only and adds no default production overhead: + +- `cProfile` attributes function-level runtime. +- `tracemalloc` snapshots identify allocation-heavy files and lines. +- Stage timers isolate context construction, engine-cache construction, + correlation, missing processing, outlier processing, role inference, dtype + repair, duplicate handling, audit generation, final report generation, + optional ML/semantic work, backend conversion, and materialization. +- Controlled instrumentation counts observed calls to `DataFrame.copy`, + `Series.copy`, and selected conversion methods. +- Scan counters observe null counts, uniqueness calculations, correlations, + dtype conversions, and role inference. + +Copy-call counts are explicitly labelled observations and are not treated as a +complete measure of physical pandas buffer copies. Peak RSS and allocation +measurements run in isolated subprocesses so previous runs and allocator residue +cannot contaminate results. + +## Error Handling + +Benchmark failures are data, not successes. The harness writes a failure record +with the command, environment, exception type/message, and partial measurements. +Unavailable optional backends are marked skipped with the exact missing +requirement. Timeouts and memory exhaustion remain visible. + +Production behavior is stricter: optimizations preserve existing exception +types, messages where asserted, validation order, warnings, and fallback +events. Cached or optimized logic falls back to the current computation when +the required invariant cannot be proven. A change that cannot demonstrate +equivalence is rejected or documented as a future proposal. + +## Change Gate + +Every production optimization follows this sequence: + +```text +write a failing equivalence or structural-performance test + -> verify the expected failure + -> implement the smallest internal change + -> pass focused correctness tests + -> compare against baseline behavior + -> run the relevant benchmark slice + -> retain only if the gain exceeds the noise threshold +``` + +A local gain that causes a regression elsewhere must be narrowed behind a +proven eligibility predicate or removed. + +## CI and Scheduled Workflows + +Pull-request CI remains bounded and deterministic. It validates the benchmark +schema, generator determinism, report rendering, structural performance +properties, and representative small/medium equivalence cases. + +A scheduled and manually dispatchable workflow runs the 100,000 through +1,000,000-row profiles, publishes JSON/Markdown artifacts, and includes enough +metadata to compare runs only on compatible environments. It supplements rather +than replaces the existing CleanBench and performance-regression workflows. + +## Required Deliverables + +`docs/performance-investigation.md` contains these explicit sections: + +1. Executive summary. +2. Reproduction commands. +3. Baseline benchmark table. +4. Profiling findings with functions, files, and lines. +5. Confirmed root causes. +6. Rejected hypotheses. +7. Files and functions changed. +8. Explanation of every optimization. +9. Behavioral compatibility analysis. +10. Tests added or changed. +11. Before-and-after benchmark table. +12. Peak-memory comparison. +13. Remaining bottlenecks. +14. Backend and out-of-core recommendations. +15. Documentation corrections. +16. Risks and trade-offs. +17. Exact verification commands and results. + +Each important change separately states its problem, evidence, implementation, +correctness protection, measured performance impact, and remaining risk. + +## Final Verification + +Run and record all repository-supported gates: + +- Complete pytest suite, including online/large tests where their fixtures are + available. +- Ruff linting and formatting checks. +- mypy type checking. +- Repository-supported security checks. +- Strict MkDocs build. +- Source and wheel build plus `twine check`. +- Existing benchmark and CleanBench suites. +- New complete benchmark matrix and profiler. +- Available Polars, DuckDB, Spark, and FreshCore checks. + +The final completion audit maps every objective requirement to authoritative +evidence. A missing optional service, dependency, fixture, or runtime is +reported explicitly and prevents an unsupported claim; it is never silently +omitted. + +## Non-Goals + +- Changing public signatures or defaults. +- Weakening validation, auditability, safety, context policy, PII, identifier, + or target protections. +- Hiding report work by removing the embedded report contract. +- Adding unrelated runtime dependencies. +- Replacing pandas with a native backend without measured justification. +- Publishing marketing claims that are not supported by recorded results. From f2b5600e873f987407180e3a81de34305e9213ab Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 10:27:58 +0530 Subject: [PATCH 07/37] docs: plan performance baseline and profiling --- ...reshdata-performance-baseline-profiling.md | 1416 +++++++++++++++++ 1 file changed, 1416 insertions(+) create mode 100644 docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md diff --git a/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md b/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md new file mode 100644 index 0000000..02771dd --- /dev/null +++ b/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md @@ -0,0 +1,1416 @@ +# FreshData Performance Baseline and Profiling Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build the deterministic benchmark and profiling system, capture the immutable `6f6c2fe` baseline across the required scale matrix, and produce authoritative evidence that decides which production optimizations deserve separate implementation plans. + +**Architecture:** A development-only `benchmarks/performance/` package generates deterministic mixed frames, executes one benchmark case per subprocess, records schema-validated JSON, profiles functions/allocations/observed pandas operations, and renders Markdown comparisons. This phase does not change the cleaning implementation: it establishes the architecture summary, baseline, confirmed bottlenecks, and rejected hypotheses that gate later TDD optimization plans. + +**Tech Stack:** Python 3.9+, pandas 1.5-2.x, NumPy, psutil from the existing `bench` extra, standard-library `argparse`, `cProfile`, `pstats`, `subprocess`, `statistics`, `threading`, `tracemalloc`, pytest, jsonschema, GitHub Actions, MkDocs. + +## Global Constraints + +- Python support remains `>=3.9`, including the project's tested Python 3.9-3.13 matrix. +- pandas support remains `>=1.5,<3`; NumPy remains `>=1.21`. +- The default cleaning strategy remains `balanced`, with the current representation-repair defaults unchanged. +- Public function and class signatures, configuration fields, return types, warnings, exceptions, index semantics, and audit/report contracts remain compatible. +- No unrelated runtime dependency is introduced. Profiling additions use the standard library and already-declared benchmark/development dependencies. +- Baseline source is commit `6f6c2fe`; the design-only commit `21bec88` is not a production-code change. +- One warm-up and five measured repetitions are the default for reportable results. +- A claimed win must be at least 10%, exceed twice observed run-to-run variability, and introduce no meaningful primary-workload regression. +- Preserve the user's untracked `.venv-qa/`; never stage, edit, or remove it. +- Run this plan in an isolated workspace created by `superpowers:using-git-worktrees` before Task 1. + +## Scope Decomposition and Evidence Gate + +This is Phase 1 of the approved design. It intentionally ends before production optimization because exact optimization code cannot be specified responsibly until profiles identify the functions and lines responsible. The remaining work is split as follows: + +1. **Phase 1 — this plan:** benchmark infrastructure, immutable baseline, profiling, architecture summary, root-cause decisions. +2. **Phase 2 — evidence-derived plans:** one TDD plan per confirmed pandas bottleneck; rejected hypotheses receive no production change. +3. **Phase 3 — scale and backend plan:** before/after matrix, native/materialization evaluation, scheduled workflow, documentation corrections. +4. **Phase 4 — verification plan:** complete compatibility matrix, all repository gates, and the 17-section final report audit. + +Phase 2 plans may be written only after Task 8 produces `confirmed_root_causes` entries with exact files, lines, stage percentages, copy/scan evidence, and affected benchmark cases. + +## File Structure + +- `benchmarks/performance/__init__.py` — supported row/width constants and public benchmark-tool exports. +- `benchmarks/performance/models.py` — immutable case/environment/result data models and JSON conversion. +- `benchmarks/performance/datasets.py` — deterministic mixed-schema DataFrame generator. +- `benchmarks/performance/schema.py` — JSON Schema and semantic result validation. +- `benchmarks/performance/environment.py` — package, Git, hardware, and platform capture. +- `benchmarks/performance/memory.py` — peak-RSS sampler used only by benchmark workers. +- `benchmarks/performance/worker.py` — execute one case in a fresh process and write one result. +- `benchmarks/performance/runner.py` — expand matrices and supervise timeout-safe subprocess workers. +- `benchmarks/performance/instrumentation.py` — cProfile, tracemalloc, copy-call, conversion, and scan observations. +- `benchmarks/performance/baselines.py` — comparable component-level pandas operations. +- `benchmarks/performance/analysis.py` — variability, ratios, stage aggregation, and hypothesis classification. +- `benchmarks/performance/render.py` — deterministic Markdown report generation. +- `benchmarks/performance/cli.py` / `__main__.py` — `run`, `profile`, `analyze`, and `render` commands. +- `tests/performance/` — deterministic unit/contract tests for every module and small end-to-end cases. +- `benchmarks/results/performance/` — ignored raw run directories plus explicitly committed compact evidence snapshots. +- `docs/performance-investigation.md` — architecture, commands, baseline tables, profiles, confirmed causes, and rejected hypotheses; later phases extend it to all 17 deliverables. +- `.github/workflows/performance-large.yml` — manual/scheduled large matrix. +- `Makefile` — local commands for CI-sized and large benchmark profiles. +- `.gitignore` — ignore raw results while allowing named compact evidence snapshots. + +--- + +### Task 1: Deterministic Mixed-Schema Dataset Generator + +**Files:** +- Create: `benchmarks/performance/__init__.py` +- Create: `benchmarks/performance/datasets.py` +- Create: `tests/performance/conftest.py` +- Create: `tests/performance/test_datasets.py` + +**Interfaces:** +- Consumes: NumPy and pandas only. +- Produces: `WIDTHS: dict[str, int]`, `DATASET_TYPES: tuple[str, ...]`, + `DatasetSpec`, and `make_mixed_frame(spec: DatasetSpec) -> pd.DataFrame`. + +- [ ] **Step 1: Write failing generator tests** + +```python +# tests/performance/test_datasets.py +from __future__ import annotations + +import pandas as pd +import pytest + +from benchmarks.performance.datasets import DatasetSpec, WIDTHS, make_mixed_frame + + +@pytest.mark.parametrize("width, n_cols", WIDTHS.items()) +def test_mixed_frame_has_exact_shape_and_required_roles(width: str, n_cols: int) -> None: + df = make_mixed_frame(DatasetSpec(rows=1_000, width=width, seed=42)) + assert df.shape == (1_000, n_cols) + assert {"record_id", "target", "numeric_0", "category_0", "text_0", "event_time_0"} <= set(df.columns) + assert df["record_id"].is_unique + assert df["target"].isna().sum() > 0 + assert df.duplicated().sum() > 0 + assert pd.api.types.is_categorical_dtype(df["category_0"].dtype) + assert isinstance(df["event_time_0"].dtype, pd.DatetimeTZDtype) + + +def test_mixed_frame_is_deterministic_and_seed_sensitive() -> None: + spec = DatasetSpec(rows=2_000, width="medium", seed=7) + assert make_mixed_frame(spec).equals(make_mixed_frame(spec)) + assert not make_mixed_frame(spec).equals( + make_mixed_frame(DatasetSpec(rows=2_000, width="medium", seed=8)) + ) + + +def test_mixed_frame_covers_nullable_outlier_and_high_cardinality_cases() -> None: + df = make_mixed_frame(DatasetSpec(rows=5_000, width="medium", seed=42)) + assert str(df["nullable_int_0"].dtype) == "Int64" + assert df["nullable_int_0"].isna().any() + assert df["numeric_0"].isna().any() + assert df["numeric_0"].max() > 1_000 + assert df["high_cardinality_0"].nunique() > 2_000 + + +@pytest.mark.parametrize( + "dataset_type, expected_prefix", + [ + ("numeric", "numeric_"), ("categorical", "category_"), + ("string", "text_"), ("nullable", "nullable_int_"), + ("datetime", "datetime_"), + ("high_cardinality", "high_cardinality_"), + ], +) +def test_family_profile_dominates_non_role_columns(dataset_type: str, expected_prefix: str) -> None: + df = make_mixed_frame( + DatasetSpec(rows=1_000, width="medium", seed=42, dataset_type=dataset_type) + ) + family_columns = [name for name in df.columns if name.startswith(expected_prefix)] + assert len(family_columns) >= 24 +``` + +- [ ] **Step 2: Run the tests and verify the import failure** + +Run: `python -m pytest tests/performance/test_datasets.py -q --no-cov` + +Expected: FAIL during collection because `benchmarks.performance.datasets` does not exist. + +- [ ] **Step 3: Implement the generator** + +```python +# benchmarks/performance/datasets.py +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np +import pandas as pd + +WIDTHS = {"narrow": 8, "medium": 32, "wide": 128} +DATASET_TYPES = ( + "mixed", "numeric", "categorical", "string", "nullable", "datetime", + "high_cardinality", +) + + +@dataclass(frozen=True) +class DatasetSpec: + rows: int + width: str + seed: int = 42 + dataset_type: str = "mixed" + + def __post_init__(self) -> None: + if self.rows < 1: + raise ValueError("rows must be >= 1") + if self.width not in WIDTHS: + raise ValueError(f"width must be one of {sorted(WIDTHS)}") + if self.dataset_type not in DATASET_TYPES: + raise ValueError(f"dataset_type must be one of {DATASET_TYPES}") + + +def _nullable_int(rng: np.random.Generator, rows: int) -> pd.Series: + values = pd.array(rng.integers(0, 10_000, rows), dtype="Int64") + values[rng.random(rows) < 0.10] = pd.NA + return pd.Series(values) + + +def make_mixed_frame(spec: DatasetSpec) -> pd.DataFrame: + rng = np.random.default_rng(spec.seed) + rows = spec.rows + numeric = rng.normal(100.0, 20.0, rows) + numeric[rng.random(rows) < 0.10] = np.nan + numeric[rng.choice(rows, max(1, rows // 100), replace=False)] *= 20.0 + categories = pd.Categorical( + rng.choice(["alpha", "beta", "gamma", None], rows, p=[0.35, 0.3, 0.25, 0.1]) + ) + frame = pd.DataFrame( + { + "record_id": np.arange(rows, dtype=np.int64), + "target": pd.array(rng.choice([0, 1, None], rows, p=[0.47, 0.48, 0.05]), dtype="Int8"), + "numeric_0": numeric, + "nullable_int_0": _nullable_int(rng, rows), + "category_0": categories, + "text_0": pd.array([f"free form note {i % 97}" if i % 11 else None for i in range(rows)], dtype="string"), + "event_time_0": pd.date_range("2024-01-01", periods=rows, freq="min", tz="UTC"), + "high_cardinality_0": pd.array([f"key-{spec.seed}-{i}" for i in range(rows)], dtype="string"), + } + ) + factories = ( + lambda i: pd.Series(rng.normal(i, 1.0, rows), name=f"numeric_{i}"), + lambda i: _nullable_int(rng, rows).rename(f"nullable_int_{i}"), + lambda i: pd.Series(pd.Categorical(rng.choice(["a", "b", "c", None], rows)), name=f"category_{i}"), + lambda i: pd.Series(pd.array([f"value {i}-{j % 211}" for j in range(rows)], dtype="string"), name=f"text_{i}"), + lambda i: pd.Series(pd.date_range("2020-01-01", periods=rows, freq="h"), name=f"datetime_{i}"), + lambda i: pd.Series(pd.array([f"hc-{i}-{j}" for j in range(rows)], dtype="string"), name=f"high_cardinality_{i}"), + ) + family_index = { + "numeric": 0, "nullable": 1, "categorical": 2, "string": 3, + "datetime": 4, "high_cardinality": 5, + }.get(spec.dataset_type) + if family_index is not None: + frame = frame[["record_id", "target"]].copy() + i = 1 + while frame.shape[1] < WIDTHS[spec.width]: + index = family_index if family_index is not None else (i - 1) % len(factories) + series = factories[index](i) + frame[series.name] = series + i += 1 + if rows >= 100: + duplicate_count = max(1, rows // 100) + frame.iloc[-duplicate_count:] = frame.iloc[:duplicate_count].to_numpy() + return frame +``` + +```python +# benchmarks/performance/__init__.py +from .datasets import DATASET_TYPES, DatasetSpec, WIDTHS, make_mixed_frame + +__all__ = ["DATASET_TYPES", "DatasetSpec", "WIDTHS", "make_mixed_frame"] +``` + +```python +# tests/performance/conftest.py +from __future__ import annotations + +# Performance-tool modules live in the repository and are imported as the +# namespace package ``benchmarks.performance``. No sys.path mutation is needed +# when tests run with ``python -m pytest`` from the repository root. +``` + +- [ ] **Step 4: Run generator tests** + +Run: `python -m pytest tests/performance/test_datasets.py -q --no-cov` + +Expected: PASS for all width, determinism, dtype, defect, and role assertions. + +- [ ] **Step 5: Commit the generator** + +```bash +git add benchmarks/performance/__init__.py benchmarks/performance/datasets.py tests/performance/conftest.py tests/performance/test_datasets.py +git commit -m "bench: add deterministic scalability datasets" +``` + +### Task 2: Typed Cases, Environment Capture, and Result Schema + +**Files:** +- Create: `benchmarks/performance/models.py` +- Create: `benchmarks/performance/environment.py` +- Create: `benchmarks/performance/schema.py` +- Create: `tests/performance/test_models_schema.py` + +**Interfaces:** +- Consumes: `DatasetSpec` from Task 1. +- Produces: `BenchmarkCase`, `EnvironmentInfo`, `BenchmarkResult`, `capture_environment()`, `RESULT_SCHEMA`, and `validate_result(payload)`. + +- [ ] **Step 1: Write failing model/schema tests** + +```python +# tests/performance/test_models_schema.py +from __future__ import annotations + +from dataclasses import replace + +import pytest + +from benchmarks.performance.environment import capture_environment +from benchmarks.performance.models import BenchmarkCase, BenchmarkResult +from benchmarks.performance.schema import validate_result + + +def test_case_id_is_stable_and_configuration_sensitive() -> None: + case = BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}) + assert case.case_id == BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}).case_id + assert case.case_id != replace(case, return_report=True).case_id + + +def test_environment_contains_required_reproduction_fields() -> None: + env = capture_environment() + assert env.python_version + assert env.pandas_version + assert env.numpy_version + assert env.git_commit + assert env.platform + assert env.cpu_count_logical >= 1 + + +def test_result_round_trip_validates() -> None: + case = BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}) + result = BenchmarkResult.completed( + case=case, + environment=capture_environment(), + samples_seconds=[1.0, 1.1, 0.9], + peak_rss_bytes=1_000_000, + peak_python_bytes=500_000, + input_bytes=250_000, + command="python -m benchmarks.performance worker", + ) + payload = result.to_dict() + validate_result(payload) + assert BenchmarkResult.from_dict(payload).case == case + + +def test_completed_result_rejects_empty_samples() -> None: + with pytest.raises(ValueError, match="samples_seconds"): + BenchmarkResult.completed( + case=BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}), + environment=capture_environment(), + samples_seconds=[], + peak_rss_bytes=0, + peak_python_bytes=0, + input_bytes=1, + command="x", + ) +``` + +- [ ] **Step 2: Verify the tests fail because the modules are absent** + +Run: `python -m pytest tests/performance/test_models_schema.py -q --no-cov` + +Expected: FAIL during collection for missing `models`, `environment`, or `schema`. + +- [ ] **Step 3: Implement exact case and result models** + +```python +# benchmarks/performance/models.py +from __future__ import annotations + +import hashlib +import json +import statistics +from dataclasses import asdict, dataclass, field +from typing import Any + + +@dataclass(frozen=True) +class BenchmarkCase: + rows: int + width: str + config_name: str + options: dict[str, Any] + dataset_type: str = "mixed" + return_report: bool = False + backend: str = "pandas" + output_format: str = "pandas" + seed: int = 42 + warmups: int = 1 + repetitions: int = 5 + + @property + def case_id(self) -> str: + raw = json.dumps(asdict(self), sort_keys=True, separators=(",", ":"), default=str) + return hashlib.sha256(raw.encode()).hexdigest()[:16] + + +@dataclass(frozen=True) +class EnvironmentInfo: + git_commit: str + git_dirty: bool + python_version: str + pandas_version: str + numpy_version: str + freshdata_version: str + optional_versions: dict[str, str | None] + platform: str + processor: str + cpu_count_logical: int + cpu_count_physical: int | None + total_ram_bytes: int | None + + +@dataclass(frozen=True) +class BenchmarkResult: + schema_version: int + status: str + case: BenchmarkCase + environment: EnvironmentInfo + samples_seconds: list[float] = field(default_factory=list) + median_seconds: float | None = None + min_seconds: float | None = None + max_seconds: float | None = None + stdev_seconds: float | None = None + coefficient_of_variation: float | None = None + throughput_rows_per_second: float | None = None + peak_rss_bytes: int | None = None + peak_python_bytes: int | None = None + input_bytes: int | None = None + input_to_peak_ratio: float | None = None + command: str = "" + error_type: str | None = None + error_message: str | None = None + output_fingerprint: str | None = None + report_fingerprint: str | None = None + result_type: str | None = None + + @classmethod + def completed(cls, *, case: BenchmarkCase, environment: EnvironmentInfo, + samples_seconds: list[float], peak_rss_bytes: int, + peak_python_bytes: int, input_bytes: int, command: str, + output_fingerprint: str | None = None, + report_fingerprint: str | None = None, + result_type: str | None = None) -> "BenchmarkResult": + if not samples_seconds: + raise ValueError("samples_seconds must not be empty") + median = statistics.median(samples_seconds) + stdev = statistics.stdev(samples_seconds) if len(samples_seconds) > 1 else 0.0 + return cls( + schema_version=1, status="completed", case=case, environment=environment, + samples_seconds=samples_seconds, median_seconds=median, + min_seconds=min(samples_seconds), max_seconds=max(samples_seconds), + stdev_seconds=stdev, + coefficient_of_variation=(stdev / median) if median else 0.0, + throughput_rows_per_second=(case.rows / median) if median else None, + peak_rss_bytes=peak_rss_bytes, peak_python_bytes=peak_python_bytes, + input_bytes=input_bytes, + input_to_peak_ratio=(peak_rss_bytes / input_bytes) if input_bytes else None, + command=command, output_fingerprint=output_fingerprint, + report_fingerprint=report_fingerprint, result_type=result_type, + ) + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + @classmethod + def from_dict(cls, payload: dict[str, Any]) -> "BenchmarkResult": + data = dict(payload) + data["case"] = BenchmarkCase(**data["case"]) + data["environment"] = EnvironmentInfo(**data["environment"]) + return cls(**data) +``` + +- [ ] **Step 4: Implement environment capture and schema validation** + +```python +# benchmarks/performance/environment.py +from __future__ import annotations + +import importlib.metadata +import os +import platform +import subprocess + +import numpy as np +import pandas as pd + +import freshdata + +from .models import EnvironmentInfo + + +def _version(name: str) -> str | None: + try: + return importlib.metadata.version(name) + except importlib.metadata.PackageNotFoundError: + return None + + +def capture_environment() -> EnvironmentInfo: + commit = subprocess.run(["git", "rev-parse", "HEAD"], check=True, capture_output=True, text=True).stdout.strip() + dirty = bool(subprocess.run(["git", "status", "--porcelain"], check=True, capture_output=True, text=True).stdout) + try: + import psutil + physical = psutil.cpu_count(logical=False) + total_ram = int(psutil.virtual_memory().total) + except ImportError: + physical = None + total_ram = None + return EnvironmentInfo( + git_commit=commit, + git_dirty=dirty, + python_version=platform.python_version(), + pandas_version=pd.__version__, + numpy_version=np.__version__, + freshdata_version=freshdata.__version__, + optional_versions={name: _version(name) for name in ("polars", "duckdb", "pyspark", "pyarrow")}, + platform=platform.platform(), processor=platform.processor(), + cpu_count_logical=os.cpu_count() or 1, + cpu_count_physical=physical, total_ram_bytes=total_ram, + ) +``` + +```python +# benchmarks/performance/schema.py +from __future__ import annotations + +from typing import Any + +RESULT_SCHEMA = { + "$schema": "https://json-schema.org/draft/2020-12/schema", + "type": "object", + "required": ["schema_version", "status", "case", "environment", "samples_seconds", "command"], + "properties": { + "schema_version": {"const": 1}, + "status": {"enum": ["completed", "failed", "timeout", "oom", "skipped"]}, + "case": {"type": "object", "required": ["rows", "width", "config_name", "options", "dataset_type", "return_report", "backend", "output_format", "seed", "warmups", "repetitions"]}, + "environment": {"type": "object", "required": ["git_commit", "python_version", "pandas_version", "numpy_version", "freshdata_version", "platform"]}, + "samples_seconds": {"type": "array", "items": {"type": "number", "minimum": 0}}, + "command": {"type": "string"}, + }, +} + + +def validate_result(payload: dict[str, Any]) -> None: + import jsonschema + jsonschema.validate(payload, RESULT_SCHEMA) + if payload["status"] == "completed": + if not payload["samples_seconds"]: + raise ValueError("completed result requires samples_seconds") + for field in ("median_seconds", "min_seconds", "max_seconds", "peak_rss_bytes", "peak_python_bytes", "input_bytes"): + if payload.get(field) is None: + raise ValueError(f"completed result requires {field}") +``` + +- [ ] **Step 5: Run and pass model/schema tests** + +Run: `python -m pytest tests/performance/test_models_schema.py -q --no-cov` + +Expected: PASS. + +- [ ] **Step 6: Commit the data contracts** + +```bash +git add benchmarks/performance/models.py benchmarks/performance/environment.py benchmarks/performance/schema.py tests/performance/test_models_schema.py +git commit -m "bench: define performance result contract" +``` + +### Task 3: Isolated Worker Timing and Peak-Memory Measurement + +**Files:** +- Create: `benchmarks/performance/memory.py` +- Create: `benchmarks/performance/worker.py` +- Create: `tests/performance/test_worker.py` + +**Interfaces:** +- Consumes: `BenchmarkCase`, `BenchmarkResult`, `DatasetSpec`, `capture_environment()`. +- Produces: `PeakRSS`, `execute_case(case: BenchmarkCase, command: str) -> BenchmarkResult`, and `worker_main(case_path, result_path)`. + +- [ ] **Step 1: Write failing worker tests** + +```python +# tests/performance/test_worker.py +from __future__ import annotations + +import pandas as pd + +from benchmarks.performance.models import BenchmarkCase +from benchmarks.performance.worker import execute_case + + +def test_worker_records_warm_samples_memory_and_embedded_report() -> None: + case = BenchmarkCase( + rows=500, width="narrow", config_name="default", options={"verbose": False}, + return_report=False, warmups=1, repetitions=2, + ) + result = execute_case(case, command="unit-test") + assert result.status == "completed" + assert len(result.samples_seconds) == 2 + assert result.peak_rss_bytes is not None and result.peak_rss_bytes >= 0 + assert result.peak_python_bytes is not None and result.peak_python_bytes > 0 + assert result.input_bytes is not None and result.input_bytes > 0 + + +def test_worker_report_flag_does_not_change_cleaned_values() -> None: + base = BenchmarkCase(rows=500, width="narrow", config_name="default", options={"verbose": False}, warmups=0, repetitions=1) + without_report = execute_case(base, command="unit-test") + with_report = execute_case( + BenchmarkCase(**{**base.__dict__, "return_report": True}), command="unit-test" + ) + assert without_report.status == with_report.status == "completed" + assert without_report.output_fingerprint == with_report.output_fingerprint + assert without_report.report_fingerprint == with_report.report_fingerprint + assert without_report.result_type == "CleanResult" + assert with_report.result_type == "tuple[CleanResult,CleanReport]" +``` + +- [ ] **Step 2: Verify the worker tests fail** + +Run: `python -m pytest tests/performance/test_worker.py -q --no-cov` + +Expected: FAIL because `worker.py` and `memory.py` do not exist. + +- [ ] **Step 3: Implement the RSS sampler** + +```python +# benchmarks/performance/memory.py +from __future__ import annotations + +import gc +import threading + + +class PeakRSS: + def __init__(self, interval_seconds: float = 0.01) -> None: + import psutil + self._process = psutil.Process() + self._interval = interval_seconds + self._stop = threading.Event() + self._thread: threading.Thread | None = None + self._baseline = 0 + self._peak = 0 + + def __enter__(self) -> "PeakRSS": + gc.collect() + self._baseline = self._process.memory_info().rss + self._peak = self._baseline + self._thread = threading.Thread(target=self._sample, daemon=True) + self._thread.start() + return self + + def _sample(self) -> None: + while not self._stop.wait(self._interval): + self._peak = max(self._peak, self._process.memory_info().rss) + + def __exit__(self, *_args: object) -> None: + self._peak = max(self._peak, self._process.memory_info().rss) + self._stop.set() + if self._thread is not None: + self._thread.join() + + @property + def increase_bytes(self) -> int: + return max(0, self._peak - self._baseline) +``` + +- [ ] **Step 4: Implement one-case execution** + +```python +# benchmarks/performance/worker.py +from __future__ import annotations + +import gc +import json +import time +import tracemalloc +from pathlib import Path + +import freshdata as fd + +from .datasets import DatasetSpec, make_mixed_frame +from .environment import capture_environment +from .memory import PeakRSS +from .models import BenchmarkCase, BenchmarkResult +from .schema import validate_result + + +def _run_clean(frame, case: BenchmarkCase): + return fd.clean( + frame, config=case.options, return_report=case.return_report, + engine=case.backend, output_format=case.output_format, + ) + + +def _fingerprints(result, return_report: bool) -> tuple[str, str, str]: + import hashlib + import json + import pandas as pd + + if return_report: + cleaned, report = result + result_type = "tuple[CleanResult,CleanReport]" + else: + cleaned, report = result, result.report() + result_type = "CleanResult" + frame_hash = hashlib.sha256() + frame_hash.update(pd.util.hash_pandas_object(cleaned, index=True).values.tobytes()) + frame_hash.update(repr(list(cleaned.columns)).encode()) + frame_hash.update(repr([str(dtype) for dtype in cleaned.dtypes]).encode()) + report_payload = report.to_dict() + report_payload.pop("duration_seconds", None) + report_payload.pop("stage_timings", None) + report_hash = hashlib.sha256( + json.dumps(report_payload, sort_keys=True, default=str).encode() + ).hexdigest() + return frame_hash.hexdigest(), report_hash, result_type + + +def execute_case(case: BenchmarkCase, *, command: str) -> BenchmarkResult: + frame = make_mixed_frame( + DatasetSpec(case.rows, case.width, case.seed, case.dataset_type) + ) + input_bytes = int(frame.memory_usage(index=True, deep=True).sum()) + for _ in range(case.warmups): + _run_clean(frame, case) + samples: list[float] = [] + for _ in range(case.repetitions): + gc.collect() + started = time.perf_counter() + _run_clean(frame, case) + samples.append(time.perf_counter() - started) + gc.collect() + tracemalloc.start() + with PeakRSS() as rss: + measured_result = _run_clean(frame, case) + _current, python_peak = tracemalloc.get_traced_memory() + tracemalloc.stop() + output_fingerprint, report_fingerprint, result_type = _fingerprints( + measured_result, case.return_report + ) + return BenchmarkResult.completed( + case=case, environment=capture_environment(), samples_seconds=samples, + peak_rss_bytes=rss.increase_bytes, peak_python_bytes=python_peak, + input_bytes=input_bytes, command=command, + output_fingerprint=output_fingerprint, + report_fingerprint=report_fingerprint, result_type=result_type, + ) + + +def worker_main(case_path: str, result_path: str, command: str) -> None: + case = BenchmarkCase(**json.loads(Path(case_path).read_text())) + result = execute_case(case, command=command) + payload = result.to_dict() + validate_result(payload) + Path(result_path).write_text(json.dumps(payload, indent=2, sort_keys=True)) +``` + +- [ ] **Step 5: Run worker tests** + +Run: `python -m pytest tests/performance/test_worker.py -q --no-cov` + +Expected: PASS. + +- [ ] **Step 6: Commit worker measurement** + +```bash +git add benchmarks/performance/memory.py benchmarks/performance/worker.py tests/performance/test_worker.py +git commit -m "bench: measure isolated runtime and peak memory" +``` + +### Task 4: Matrix Expansion, Timeout-Safe Subprocess Runner, and CLI + +**Files:** +- Create: `benchmarks/performance/runner.py` +- Create: `benchmarks/performance/cli.py` +- Create: `benchmarks/performance/__main__.py` +- Create: `tests/performance/test_runner_cli.py` + +**Interfaces:** +- Consumes: `BenchmarkCase`, `worker_main`, and JSON result validation. +- Produces: `expand_cases(...)`, `run_case_subprocess(...)`, `run_matrix(...)`, and `python -m benchmarks.performance run`. + +- [ ] **Step 1: Write failing runner/CLI tests** + +```python +# tests/performance/test_runner_cli.py +from __future__ import annotations + +import json + +from benchmarks.performance.cli import main +from benchmarks.performance.runner import expand_cases + + +def test_expand_cases_crosses_required_dimensions() -> None: + cases = expand_cases( + rows=[10_000, 100_000], widths=["narrow", "wide"], + dataset_types=["mixed"], + configs=["default", "conservative"], report_modes=[False, True], + backends=["pandas"], output_formats=["pandas"], seed=42, + warmups=1, repetitions=5, + ) + assert len(cases) == 16 + assert len({case.case_id for case in cases}) == 16 + + +def test_cli_small_matrix_writes_valid_result(tmp_path) -> None: + exit_code = main([ + "run", "--rows", "250", "--widths", "narrow", "--configs", "default", + "--report-modes", "false", "--repetitions", "1", "--warmups", "0", + "--timeout", "60", "--output", str(tmp_path), + ]) + assert exit_code == 0 + payloads = [json.loads(path.read_text()) for path in tmp_path.glob("*.json")] + assert len(payloads) == 1 + assert payloads[0]["status"] == "completed" +``` + +- [ ] **Step 2: Verify runner/CLI tests fail** + +Run: `python -m pytest tests/performance/test_runner_cli.py -q --no-cov` + +Expected: FAIL because `runner.py` and `cli.py` do not exist. + +- [ ] **Step 3: Implement matrix expansion and failure records** + +Implement these exact configuration profiles in `benchmarks/performance/runner.py`: + +```python +CONFIGS = { + "default": {"verbose": False}, + "conservative": {"strategy": "conservative", "verbose": False}, + "representation_off": { + "strategy": "conservative", "column_names": False, + "strip_whitespace": False, "normalize_sentinels": False, + "fix_dtypes": False, "drop_duplicates": False, "verbose": False, + }, + "statistical_off": { + "strategy": "conservative", "impute": None, "outliers": None, + "verbose": False, + }, + "explicit": { + "strategy": "conservative", "impute": "median", "outliers": "flag", + "verbose": False, + }, + "aggressive": {"strategy": "aggressive", "verbose": False}, + "semantic": {"semantic_mode": "assist", "verbose": False}, + "missforest": { + "strategy": "conservative", "impute": "missforest", "verbose": False, + }, +} +``` + +Use `itertools.product` across rows, widths, dataset types, configs, report +modes, backends, and output formats to construct `BenchmarkCase` objects. +`run_case_subprocess` must write the case JSON into a temporary directory, +invoke: + +```python +[ + sys.executable, "-c", + "from benchmarks.performance.worker import worker_main; " + "worker_main(__import__('sys').argv[1], __import__('sys').argv[2], __import__('sys').argv[3])", + str(case_path), str(result_path), command, +] +``` + +with `subprocess.run(..., timeout=timeout_seconds, capture_output=True, text=True)`. On timeout, non-zero exit, missing result, or a result containing `MemoryError`, write a schema-valid `BenchmarkResult` with status `timeout`, `failed`, or `oom`, plus the exception type/message and exact command. Do not raise and lose the remaining matrix. + +- [ ] **Step 4: Implement the CLI parser** + +`benchmarks/performance/cli.py` must parse comma-separated values with these defaults: + +```python +run.add_argument("--rows", default="10000,100000,500000,1000000") +run.add_argument("--widths", default="narrow,medium,wide") +run.add_argument("--dataset-types", default="mixed") +run.add_argument("--configs", default="default,conservative,representation_off,statistical_off,explicit") +run.add_argument("--report-modes", default="false,true") +run.add_argument("--backends", default="pandas") +run.add_argument("--output-formats", default="pandas") +run.add_argument("--seed", type=int, default=42) +run.add_argument("--warmups", type=int, default=1) +run.add_argument("--repetitions", type=int, default=5) +run.add_argument("--timeout", type=int, default=1800) +run.add_argument("--output", required=True) +``` + +The command prints one line per case and ends with counts by status. It returns `0` only when every requested case is completed or explicitly skipped; failures, timeouts, and OOM records return `1` after all cases finish. + +```python +# benchmarks/performance/__main__.py +from .cli import main + +raise SystemExit(main()) +``` + +- [ ] **Step 5: Run runner/CLI tests** + +Run: `python -m pytest tests/performance/test_runner_cli.py -q --no-cov` + +Expected: PASS, with one completed small-case JSON file. + +- [ ] **Step 6: Commit the matrix runner** + +```bash +git add benchmarks/performance/runner.py benchmarks/performance/cli.py benchmarks/performance/__main__.py tests/performance/test_runner_cli.py +git commit -m "bench: add configurable subprocess matrix runner" +``` + +### Task 5: Function, Allocation, Copy, Conversion, and Scan Profiling + +**Files:** +- Create: `benchmarks/performance/instrumentation.py` +- Create: `tests/performance/test_instrumentation.py` +- Modify: `benchmarks/performance/worker.py` +- Modify: `benchmarks/performance/models.py` +- Modify: `benchmarks/performance/schema.py` +- Modify: `benchmarks/performance/cli.py` + +**Interfaces:** +- Consumes: one `BenchmarkCase` and the Task 3 worker execution path. +- Produces: `OperationCounter`, `profile_case(case) -> ProfileResult`, exact function/file/line records, allocation records, stage aggregates, and `python -m benchmarks.performance profile`. + +- [ ] **Step 1: Write failing instrumentation tests** + +```python +# tests/performance/test_instrumentation.py +from __future__ import annotations + +from benchmarks.performance.instrumentation import OperationCounter, profile_case +from benchmarks.performance.models import BenchmarkCase + + +def test_operation_counter_observes_copy_scan_and_conversion_calls() -> None: + import pandas as pd + frame = pd.DataFrame({"a": [1, None, 3], "b": ["1", "2", "3"]}) + with OperationCounter() as counter: + frame.copy(deep=False) + frame["a"].isna() + frame["a"].nunique(dropna=True) + frame["b"].astype("string") + assert counter.counts["dataframe.copy"] == 1 + assert counter.counts["series.isna"] >= 1 + assert counter.counts["series.nunique"] == 1 + assert counter.counts["series.astype"] == 1 + + +def test_profile_case_reports_exact_hot_functions_and_allocations() -> None: + result = profile_case(BenchmarkCase( + rows=500, width="narrow", config_name="default", + options={"verbose": False}, warmups=0, repetitions=1, + )) + assert result.functions + assert all({"file", "line", "function", "self_seconds", "cumulative_seconds", "calls"} <= set(item) for item in result.functions) + assert result.allocations + assert all({"file", "line", "bytes", "count"} <= set(item) for item in result.allocations) + assert result.stages["total"] > 0 + assert result.operations["dataframe.copy"] >= 1 +``` + +- [ ] **Step 2: Verify instrumentation tests fail** + +Run: `python -m pytest tests/performance/test_instrumentation.py -q --no-cov` + +Expected: FAIL because `instrumentation.py` does not exist. + +- [ ] **Step 3: Implement controlled operation counting** + +Create `OperationCounter` as a context manager using `unittest.mock.patch.object` around the original methods. Store originals before patching and route each wrapper directly to its original to avoid recursion. Count these keys: + +```python +METHODS = { + "dataframe.copy": (pd.DataFrame, "copy"), + "series.copy": (pd.Series, "copy"), + "series.isna": (pd.Series, "isna"), + "series.notna": (pd.Series, "notna"), + "series.nunique": (pd.Series, "nunique"), + "series.value_counts": (pd.Series, "value_counts"), + "series.astype": (pd.Series, "astype"), + "dataframe.astype": (pd.DataFrame, "astype"), + "dataframe.corr": (pd.DataFrame, "corr"), + "dataframe.corrwith": (pd.DataFrame, "corrwith"), +} +``` + +Mark these as observed Python method calls, not physical-buffer-copy counts. + +- [ ] **Step 4: Implement cProfile and tracemalloc extraction** + +Add this immutable result contract to `benchmarks/performance/instrumentation.py`: + +```python +from dataclasses import dataclass + + +@dataclass(frozen=True) +class ProfileResult: + functions: list[dict[str, object]] + allocations: list[dict[str, object]] + stages: dict[str, float] + operations: dict[str, int] +``` + +`profile_case(case: BenchmarkCase) -> ProfileResult` must: + +1. Generate the deterministic frame outside the measured profile. +2. Start `tracemalloc`, `cProfile.Profile`, and `OperationCounter`. +3. Execute one `fd.clean` call. +4. Disable profiling and collect the top 100 `pstats.Stats.stats` entries sorted by cumulative time. +5. Collect the top 100 `tracemalloc` line statistics limited to paths containing `/freshdata/` or `/benchmarks/performance/`. +6. Aggregate self time into these stages using normalized path/function rules: + +```python +STAGE_RULES = { + "context": ("engine/context.py",), + "engine_cache": ("engine/cache.py",), + "correlation": ("numeric_corr_matrix", "corr", "corrwith"), + "missing": ("engine/missing.py", "steps/missing.py"), + "outliers": ("engine/outliers.py", "steps/outliers.py"), + "role_inference": ("infer_role", "build_context"), + "dtype_repair": ("steps/dtypes.py",), + "duplicates": ("steps/duplicates.py",), + "audit_events": ("report.py", "CleanReport.add"), + "report_finalization": ("cleaner.py", "memory_bytes"), + "semantic_ml": ("semantic/", "imputation/missforest.py", "sklearn/"), + "backend_conversion": ("adapters/", "execution/backends/"), +} +``` + +Use exclusive self time for percentage totals so nested functions are not double-counted. Preserve cumulative time separately for locating call chains. + +- [ ] **Step 5: Extend result schema and CLI** + +Add optional `profile` to `BenchmarkResult` containing `functions`, +`allocations`, `stages`, and `operations`. Add a `profile` subcommand accepting +the same case selectors as `run` but requiring exactly one row count, width, +config, report mode, backend, and output format. It writes the case's stable +16-character ID followed by `.profile.json` and validates it with the same +schema. + +- [ ] **Step 6: Run instrumentation and focused worker tests** + +Run: `python -m pytest tests/performance/test_instrumentation.py tests/performance/test_worker.py -q --no-cov` + +Expected: PASS. + +- [ ] **Step 7: Commit profiling instrumentation** + +```bash +git add benchmarks/performance/instrumentation.py benchmarks/performance/worker.py benchmarks/performance/models.py benchmarks/performance/schema.py benchmarks/performance/cli.py tests/performance/test_instrumentation.py +git commit -m "bench: profile stages allocations and pandas operations" +``` + +### Task 6: Comparable Pandas Baselines, Analysis, and Markdown Rendering + +**Files:** +- Create: `benchmarks/performance/baselines.py` +- Create: `benchmarks/performance/analysis.py` +- Create: `benchmarks/performance/render.py` +- Create: `tests/performance/test_analysis_render.py` +- Modify: `benchmarks/performance/cli.py` + +**Interfaces:** +- Consumes: completed benchmark/profile JSON files. +- Produces: `measure_pandas_baseline(case, baseline_name)`, a `baseline` CLI + subcommand, component-level pandas baseline samples, slowdown/improvement + ratios, variability-aware comparisons, hypothesis classifications, and + deterministic Markdown. + +- [ ] **Step 1: Write failing comparison/render tests** + +```python +# tests/performance/test_analysis_render.py +from __future__ import annotations + +from benchmarks.performance.analysis import classify_change, classify_hypotheses +from benchmarks.performance.render import render_report + + +def test_change_requires_ten_percent_and_twice_variability() -> None: + assert classify_change(1.0, 0.85, baseline_cv=0.02, candidate_cv=0.02) == "improved" + assert classify_change(1.0, 0.94, baseline_cv=0.01, candidate_cv=0.01) == "noise" + assert classify_change(1.0, 1.12, baseline_cv=0.02, candidate_cv=0.02) == "regressed" + + +def test_hypothesis_classifier_requires_exact_profile_evidence() -> None: + profile = { + "stages": {"correlation": 0.40, "total": 1.0}, + "operations": {"dataframe.corr": 1, "dataframe.copy": 3}, + "functions": [{"file": "src/freshdata/engine/context.py", "line": 207, "function": "numeric_corr_matrix", "self_seconds": 0.4, "cumulative_seconds": 0.4, "calls": 1}], + } + decisions = classify_hypotheses(profile) + assert decisions["unnecessary_correlation"]["status"] == "candidate" + assert decisions["unnecessary_correlation"]["evidence"][0]["line"] == 207 + + +def test_renderer_is_deterministic_and_contains_required_baseline_sections() -> None: + payload = {"environment": {"python_version": "3.12", "pandas_version": "2.3"}, "results": [], "hypotheses": {}} + first = render_report(payload) + assert first == render_report(payload) + for heading in ("Architecture and execution flow", "Reproduction commands", "Baseline benchmark table", "Profiling findings", "Confirmed root causes", "Rejected hypotheses"): + assert f"## {heading}" in first +``` + +- [ ] **Step 2: Verify comparison/render tests fail** + +Run: `python -m pytest tests/performance/test_analysis_render.py -q --no-cov` + +Expected: FAIL because the analysis and render modules do not exist. + +- [ ] **Step 3: Implement semantically comparable pandas baselines** + +Provide named component baselines only: + +```python +BASELINES = { + "representation_off": lambda df: df.copy(deep=False), + "explicit": lambda df: df.assign(**{ + col: df[col].fillna(df[col].median()) + for col in df.select_dtypes(include="number").columns + if df[col].notna().any() + }).drop_duplicates(), + "duplicates": lambda df: df.drop_duplicates(), + "null_counts": lambda df: df.isna().sum(), +} +``` + +Do not define a pandas baseline for FreshData's full balanced decision/audit pipeline. Label every baseline with its exact operation and include it only when the selected case has matching semantics. + +`measure_pandas_baseline` uses the same one-warm-up/five-sample and isolated +PeakRSS/tracemalloc procedure as `execute_case`, but invokes the selected +function from `BASELINES`. Store `baseline_name` in the result payload and set +`backend="pandas-component-baseline"`; never route this sentinel backend +through `fd.clean`. + +- [ ] **Step 4: Implement variability and hypothesis analysis** + +`classify_change` calculates `(baseline - candidate) / baseline` and compares its absolute magnitude with both `0.10` and `2 * max(baseline_cv, candidate_cv)`. Return only `improved`, `regressed`, or `noise`. + +`classify_hypotheses` produces entries for: + +- `unnecessary_correlation` +- `repeated_null_scans` +- `repeated_uniqueness_scans` +- `copy_pressure` +- `dtype_conversion_pressure` +- `report_finalization_overhead` +- `optional_ml_overhead` +- `backend_conversion_overhead` + +Each entry contains `status` (`candidate`, `rejected`, or `insufficient_evidence`), `stage_fraction`, `observed_calls`, and an `evidence` list of exact function/file/line records. A hypothesis is only a candidate when its stage consumes at least 10% of total self time or its peak allocations consume at least 10% of the traced peak, and the relevant operation count is non-zero. + +- [ ] **Step 5: Implement deterministic Markdown rendering** + +`render_report` sorts cases by rows, width, config, report flag, backend, and output format. It renders environment data, exact commands, median/min/max/CV/throughput, peak RSS/Python/input ratios, pandas comparison ratios, stage percentages, top exact functions/lines, confirmed candidates, rejected hypotheses, failures, timeouts, OOMs, and limitations. It must not print an improvement claim for a comparison classified as `noise`. + +- [ ] **Step 6: Add `analyze` and `render` CLI commands** + +Commands: + +```bash +python -m benchmarks.performance analyze --input benchmarks/results/performance/baseline --output benchmarks/results/performance/baseline-summary.json +python -m benchmarks.performance render --input benchmarks/results/performance/baseline-summary.json --output benchmarks/results/performance/baseline-report.md +``` + +Also add: + +```bash +python -m benchmarks.performance baseline --rows 10000,100000 --widths narrow,medium,wide --dataset-types mixed --baselines representation_off,explicit --warmups 1 --repetitions 5 --output benchmarks/results/performance/baseline +``` + +The `baseline` command accepts only names in `BASELINES` and writes the same +schema-versioned result format as `run`. + +- [ ] **Step 7: Run comparison/render tests** + +Run: `python -m pytest tests/performance/test_analysis_render.py -q --no-cov` + +Expected: PASS. + +- [ ] **Step 8: Commit analysis and rendering** + +```bash +git add benchmarks/performance/baselines.py benchmarks/performance/analysis.py benchmarks/performance/render.py benchmarks/performance/cli.py tests/performance/test_analysis_render.py +git commit -m "bench: analyze and render scalability evidence" +``` + +### Task 7: CI-Safe Contracts, Large Workflow, Make Targets, and Documentation Shell + +**Files:** +- Modify: `.gitignore` +- Modify: `Makefile` +- Create: `.github/workflows/performance-large.yml` +- Create: `docs/performance-investigation.md` +- Create: `tests/performance/test_contracts.py` +- Modify: `docs/benchmarks.md` + +**Interfaces:** +- Consumes: Tasks 1-6 CLI and schemas. +- Produces: fast PR contracts, manual/scheduled large runs, reproducible local commands, and committed compact evidence paths. + +- [ ] **Step 1: Write failing fast-contract tests** + +```python +# tests/performance/test_contracts.py +from __future__ import annotations + +import json + +from benchmarks.performance.cli import main +from benchmarks.performance.render import render_report + + +def test_ci_sized_matrix_completes_and_renders(tmp_path) -> None: + raw = tmp_path / "raw" + assert main([ + "run", "--rows", "500", "--widths", "narrow,medium", + "--configs", "default,conservative", "--report-modes", "false,true", + "--warmups", "0", "--repetitions", "1", "--timeout", "120", + "--output", str(raw), + ]) == 0 + results = [json.loads(path.read_text()) for path in raw.glob("*.json")] + assert len(results) == 8 + assert all(item["status"] == "completed" for item in results) + rendered = render_report({"environment": results[0]["environment"], "results": results, "hypotheses": {}}) + assert "500" in rendered + assert "narrow" in rendered and "medium" in rendered + + +def test_report_modes_preserve_behavioral_contract(tmp_path) -> None: + assert main([ + "run", "--rows", "250", "--widths", "narrow", "--configs", "default", + "--report-modes", "false,true", "--warmups", "0", "--repetitions", "1", + "--timeout", "120", "--output", str(tmp_path), + ]) == 0 + results = [json.loads(path.read_text()) for path in tmp_path.glob("*.json")] + assert {item["case"]["return_report"] for item in results} == {False, True} +``` + +- [ ] **Step 2: Verify the fast-contract tests pass against completed tooling** + +Run: `python -m pytest tests/performance -q --no-cov` + +Expected: PASS. If this fails, fix the responsible Task 1-6 module before changing workflow files. + +- [ ] **Step 3: Make compact evidence committable and raw results ignored** + +Replace the broad benchmark result rule with: + +```gitignore +# Benchmark runtime results: raw case files stay local; compact evidence is committed. +benchmarks/results/* +!benchmarks/results/performance/ +benchmarks/results/performance/* +!benchmarks/results/performance/*-summary.json +!benchmarks/results/performance/*-report.md +``` + +- [ ] **Step 4: Add Make targets** + +```make +.PHONY: performance-ci performance-baseline performance-profile performance-report + +performance-ci: + $(PY) -m pytest tests/performance -q --no-cov + +performance-baseline: + $(PY) -m benchmarks.performance run --output benchmarks/results/performance/baseline + +performance-profile: + $(PY) -m benchmarks.performance profile --rows 100000 --width medium --config default --report-mode true --output benchmarks/results/performance/baseline + +performance-report: + $(PY) -m benchmarks.performance analyze --input benchmarks/results/performance/baseline --output benchmarks/results/performance/baseline-summary.json + $(PY) -m benchmarks.performance render --input benchmarks/results/performance/baseline-summary.json --output benchmarks/results/performance/baseline-report.md +``` + +- [ ] **Step 5: Add the manual/scheduled large workflow** + +`.github/workflows/performance-large.yml` must run on `workflow_dispatch` and weekly schedule, install `.[dev,bench,ml]`, execute row counts `100000,500000,1000000`, widths `narrow,medium,wide`, configs `default,conservative,representation_off,statistical_off,explicit`, both report modes, one warm-up, five repetitions, then analyze/render and upload the whole performance results directory. Set `timeout-minutes: 180`; do not add it to required PR checks. + +- [ ] **Step 6: Add the documentation shell with resolved architecture content** + +Create `docs/performance-investigation.md` with these populated sections from the approved design, not empty headings: + +- Executive summary stating that baseline measurement is in progress and no slowdown/improvement is claimed yet. +- Architecture and execution flow copied from the approved design. +- Supported Python/pandas versions and default configuration. +- Reproduction commands for `performance-ci`, `performance-baseline`, `performance-profile`, and `performance-report`. +- Measurement methodology and the 10%/2x-variability rule. +- A statement that baseline, profile, root-cause, rejected-hypothesis, before/after, memory, backend, documentation, risk, and verification sections are generated from authoritative JSON as their phases complete. + +Update `docs/benchmarks.md` with links and commands for the new harness while retaining the existing CleanBench and strategic-report documentation. + +- [ ] **Step 7: Run fast performance contracts and docs build** + +Run: `python -m pytest tests/performance -q --no-cov` + +Expected: PASS. + +Run: `mkdocs build --strict` + +Expected: PASS with no missing navigation or link warnings. + +- [ ] **Step 8: Commit integration and documentation** + +```bash +git add .gitignore Makefile .github/workflows/performance-large.yml docs/performance-investigation.md docs/benchmarks.md tests/performance/test_contracts.py +git commit -m "bench: integrate large performance investigation workflow" +``` + +### Task 8: Capture the Immutable Baseline and Decide the Optimization Plans + +**Files:** +- Create: `benchmarks/results/performance/baseline-summary.json` +- Create: `benchmarks/results/performance/baseline-report.md` +- Modify: `docs/performance-investigation.md` +- Create: `docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md` +- Create only the applicable evidence-named plans from: + `docs/superpowers/plans/2026-07-11-freshdata-optimize-correlation.md`, + `2026-07-11-freshdata-optimize-engine-statistics.md`, + `2026-07-11-freshdata-optimize-copy-pressure.md`, + `2026-07-11-freshdata-optimize-dtype-conversions.md`, + `2026-07-11-freshdata-optimize-reporting.md`, + `2026-07-11-freshdata-optimize-optional-ml.md`, or + `2026-07-11-freshdata-optimize-backend-conversion.md`. + +**Interfaces:** +- Consumes: the clean `6f6c2fe` baseline worktree and Tasks 1-7 tooling. +- Produces: recorded commands/results, exact root causes and rejected hypotheses, and evidence-derived Phase 2 plans. + +- [ ] **Step 1: Verify the baseline identity before running** + +Run: + +```bash +git rev-parse HEAD +git status --short +python -VV +python -c "import pandas, numpy, freshdata; print(pandas.__version__, numpy.__version__, freshdata.__version__)" +``` + +Expected: the benchmarked production sources match `6f6c2fe`; documentation/tooling commits may be present, but `git diff 6f6c2fe -- src/freshdata` must be empty. The only pre-existing untracked item may be `.venv-qa/` outside the isolated execution workspace. + +- [ ] **Step 2: Run the required pandas baseline in bounded batches** + +Run these commands separately so a large-case failure does not erase smaller evidence: + +```bash +python -m benchmarks.performance run --rows 10000 --widths narrow,medium,wide --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 900 --output benchmarks/results/performance/baseline +python -m benchmarks.performance run --rows 100000 --widths narrow,medium,wide --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 1800 --output benchmarks/results/performance/baseline +python -m benchmarks.performance run --rows 500000 --widths narrow,medium,wide --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 3600 --output benchmarks/results/performance/baseline +python -m benchmarks.performance run --rows 1000000 --widths narrow,medium,wide --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 7200 --output benchmarks/results/performance/baseline +python -m benchmarks.performance run --rows 100000 --widths medium --dataset-types numeric,categorical,string,nullable,datetime,high_cardinality --configs default --report-modes false,true --warmups 1 --repetitions 5 --timeout 1800 --output benchmarks/results/performance/baseline +``` + +Expected: every case writes `completed`, `failed`, `timeout`, or `oom` JSON; no case disappears. Report all poor and incomplete outcomes. + +- [ ] **Step 3: Profile the representative bottleneck slices** + +Run: + +```bash +python -m benchmarks.performance profile --rows 10000 --width wide --config default --report-mode true --output benchmarks/results/performance/baseline +python -m benchmarks.performance profile --rows 100000 --width medium --config default --report-mode true --output benchmarks/results/performance/baseline +python -m benchmarks.performance profile --rows 500000 --width medium --config default --report-mode false --output benchmarks/results/performance/baseline +python -m benchmarks.performance profile --rows 1000000 --width narrow --config default --report-mode true --output benchmarks/results/performance/baseline +python -m benchmarks.performance profile --rows 100000 --width medium --config aggressive --report-mode true --output benchmarks/results/performance/baseline +python -m benchmarks.performance profile --rows 100000 --width medium --config semantic --report-mode true --output benchmarks/results/performance/baseline +python -m benchmarks.performance profile --rows 10000 --width medium --config missforest --report-mode true --output benchmarks/results/performance/baseline +``` + +Expected: profile JSON includes exact function/file/line records, allocation records, stage totals, and operation counts for every completed profile. + +- [ ] **Step 4: Measure comparable pandas component baselines** + +Run: + +```bash +python -m benchmarks.performance baseline --rows 10000,100000,500000,1000000 --widths narrow,medium,wide --dataset-types mixed --baselines representation_off,explicit --warmups 1 --repetitions 5 --timeout 3600 --output benchmarks/results/performance/baseline +``` + +Expected: component comparisons are labelled by exact operation; no result claims to replicate the full balanced decision/audit pipeline. + +- [ ] **Step 5: Analyze and render compact evidence** + +Run: + +```bash +python -m benchmarks.performance analyze --input benchmarks/results/performance/baseline --output benchmarks/results/performance/baseline-summary.json +python -m benchmarks.performance render --input benchmarks/results/performance/baseline-summary.json --output benchmarks/results/performance/baseline-report.md +``` + +Expected: the summary includes environment, commands, all statuses, median/min/max/CV, peak RSS/Python memory, ratios, stage shares, exact hot functions/lines, and eight hypothesis decisions. + +- [ ] **Step 6: Update the investigation report from authoritative evidence** + +Copy generated tables and findings without hand-editing numeric values. Populate these sections in `docs/performance-investigation.md`: + +1. Executive summary limited to baseline findings. +2. Reproduction commands. +3. Baseline benchmark table. +4. Profiling findings with exact functions/files/lines. +5. Confirmed root causes. +6. Rejected hypotheses. +12. Baseline peak-memory table. +13. Remaining baseline bottlenecks. +16. Baseline risks and limitations. + +Leave before/after optimization sections explicitly marked `not yet applicable: no production optimization has been implemented`, which is a resolved status rather than an unknown placeholder. + +- [ ] **Step 7: Write the evidence-derived Phase 2 design and plans** + +Create `docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md` containing only hypotheses classified `candidate` by `baseline-summary.json`. For each candidate, include its exact functions/lines, affected cases, measured time/memory fraction, behavioral invariants, proposed smallest change, alternative rejected approaches, and benchmark acceptance case. + +Then run the brainstorming approval gate for that design. After approval, create one detailed TDD plan per independently rejectable root cause. Do not create or execute a production optimization plan for any hypothesis classified `rejected` or `insufficient_evidence`. + +- [ ] **Step 8: Verify and commit baseline evidence** + +Run: + +```bash +python -m pytest tests/performance tests/benchmark -q --no-cov +ruff check benchmarks/performance tests/performance +mypy benchmarks/performance +mkdocs build --strict +git diff --check +``` + +Expected: all commands pass. Raw case files remain ignored; compact summary/report, investigation document, and evidence-derived design/plans are staged. + +```bash +git add benchmarks/results/performance/baseline-summary.json benchmarks/results/performance/baseline-report.md docs/performance-investigation.md docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md docs/superpowers/plans +git commit -m "bench: record FreshData scalability baseline" +``` + +## Phase 1 Completion Gate + +Phase 1 is complete only when: + +- The required 10k, 100k, 500k, and 1M row matrix has a recorded status for every requested width/config/report case. +- Median, minimum, maximum, variability, peak RSS, Python allocations, input ratio, and comparable pandas ratios are recorded. +- Exact functions, files, and lines are recorded for the largest time and allocation costs. +- Context/cache, correlation, missing, outlier, role, dtype, duplicate, audit, report, ML/semantic, conversion, and backend costs are separated where exercised. +- Copy/conversion/scan counts are explicitly labelled observed calls. +- Confirmed root causes and rejected hypotheses are evidence-backed. +- No production cleaning code differs from `6f6c2fe`. +- The Phase 2 design includes only confirmed causes and has been presented for user approval. + +Do not claim the overall FreshData performance goal complete at this gate. The active goal remains open through production optimization, before/after benchmarks, backend recommendations, documentation correction, full compatibility verification, and the final 17-deliverable audit. From a7f4cea6e46e825638e2162d64d19cef87b3d264 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 10:37:17 +0530 Subject: [PATCH 08/37] docs: resolve performance plan preflight conflicts --- ...1-freshdata-performance-baseline-profiling.md | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md b/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md index 02771dd..08f6aee 100644 --- a/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md +++ b/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md @@ -86,7 +86,6 @@ def test_mixed_frame_has_exact_shape_and_required_roles(width: str, n_cols: int) df = make_mixed_frame(DatasetSpec(rows=1_000, width=width, seed=42)) assert df.shape == (1_000, n_cols) assert {"record_id", "target", "numeric_0", "category_0", "text_0", "event_time_0"} <= set(df.columns) - assert df["record_id"].is_unique assert df["target"].isna().sum() > 0 assert df.duplicated().sum() > 0 assert pd.api.types.is_categorical_dtype(df["category_0"].dtype) @@ -216,7 +215,10 @@ def make_mixed_frame(spec: DatasetSpec) -> pd.DataFrame: i += 1 if rows >= 100: duplicate_count = max(1, rows // 100) - frame.iloc[-duplicate_count:] = frame.iloc[:duplicate_count].to_numpy() + frame = pd.concat( + [frame.iloc[:-duplicate_count], frame.iloc[:duplicate_count].copy()], + ignore_index=True, + ) return frame ``` @@ -1080,12 +1082,12 @@ Provide named component baselines only: ```python BASELINES = { - "representation_off": lambda df: df.copy(deep=False), - "explicit": lambda df: df.assign(**{ + "shallow_copy": lambda df: df.copy(deep=False), + "numeric_median_fill": lambda df: df.assign(**{ col: df[col].fillna(df[col].median()) for col in df.select_dtypes(include="number").columns if df[col].notna().any() - }).drop_duplicates(), + }), "duplicates": lambda df: df.drop_duplicates(), "null_counts": lambda df: df.isna().sum(), } @@ -1132,7 +1134,7 @@ python -m benchmarks.performance render --input benchmarks/results/performance/b Also add: ```bash -python -m benchmarks.performance baseline --rows 10000,100000 --widths narrow,medium,wide --dataset-types mixed --baselines representation_off,explicit --warmups 1 --repetitions 5 --output benchmarks/results/performance/baseline +python -m benchmarks.performance baseline --rows 10000,100000 --widths narrow,medium,wide --dataset-types mixed --baselines shallow_copy,numeric_median_fill,duplicates,null_counts --warmups 1 --repetitions 5 --output benchmarks/results/performance/baseline ``` The `baseline` command accepts only names in `BASELINES` and writes the same @@ -1343,7 +1345,7 @@ Expected: profile JSON includes exact function/file/line records, allocation rec Run: ```bash -python -m benchmarks.performance baseline --rows 10000,100000,500000,1000000 --widths narrow,medium,wide --dataset-types mixed --baselines representation_off,explicit --warmups 1 --repetitions 5 --timeout 3600 --output benchmarks/results/performance/baseline +python -m benchmarks.performance baseline --rows 10000,100000,500000,1000000 --widths narrow,medium,wide --dataset-types mixed --baselines shallow_copy,numeric_median_fill,duplicates,null_counts --warmups 1 --repetitions 5 --timeout 3600 --output benchmarks/results/performance/baseline ``` Expected: component comparisons are labelled by exact operation; no result claims to replicate the full balanced decision/audit pipeline. From ee4998b6c423671b711d8ae03931da8d9e54bd58 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 10:47:19 +0530 Subject: [PATCH 09/37] bench: add deterministic scalability datasets --- benchmarks/performance/__init__.py | 3 + benchmarks/performance/datasets.py | 108 +++++++++++++++++++++++++++++ tests/performance/conftest.py | 5 ++ tests/performance/test_datasets.py | 56 +++++++++++++++ 4 files changed, 172 insertions(+) create mode 100644 benchmarks/performance/__init__.py create mode 100644 benchmarks/performance/datasets.py create mode 100644 tests/performance/conftest.py create mode 100644 tests/performance/test_datasets.py diff --git a/benchmarks/performance/__init__.py b/benchmarks/performance/__init__.py new file mode 100644 index 0000000..fe3961b --- /dev/null +++ b/benchmarks/performance/__init__.py @@ -0,0 +1,3 @@ +from .datasets import DATASET_TYPES, WIDTHS, DatasetSpec, make_mixed_frame + +__all__ = ["DATASET_TYPES", "DatasetSpec", "WIDTHS", "make_mixed_frame"] diff --git a/benchmarks/performance/datasets.py b/benchmarks/performance/datasets.py new file mode 100644 index 0000000..ef462c1 --- /dev/null +++ b/benchmarks/performance/datasets.py @@ -0,0 +1,108 @@ +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np +import pandas as pd + +WIDTHS = {"narrow": 8, "medium": 32, "wide": 128} +DATASET_TYPES = ( + "mixed", + "numeric", + "categorical", + "string", + "nullable", + "datetime", + "high_cardinality", +) + + +@dataclass(frozen=True) +class DatasetSpec: + rows: int + width: str + seed: int = 42 + dataset_type: str = "mixed" + + def __post_init__(self) -> None: + if self.rows < 1: + raise ValueError("rows must be >= 1") + if self.width not in WIDTHS: + raise ValueError(f"width must be one of {sorted(WIDTHS)}") + if self.dataset_type not in DATASET_TYPES: + raise ValueError(f"dataset_type must be one of {DATASET_TYPES}") + + +def _nullable_int(rng: np.random.Generator, rows: int) -> pd.Series: + values = pd.array(rng.integers(0, 10_000, rows), dtype="Int64") + values[rng.random(rows) < 0.10] = pd.NA + return pd.Series(values) + + +def make_mixed_frame(spec: DatasetSpec) -> pd.DataFrame: + rng = np.random.default_rng(spec.seed) + rows = spec.rows + numeric = rng.normal(100.0, 20.0, rows) + numeric[rng.random(rows) < 0.10] = np.nan + numeric[rng.choice(rows, max(1, rows // 100), replace=False)] *= 20.0 + categories = pd.Categorical( + rng.choice(["alpha", "beta", "gamma", None], rows, p=[0.35, 0.3, 0.25, 0.1]) + ) + frame = pd.DataFrame( + { + "record_id": np.arange(rows, dtype=np.int64), + "target": pd.array(rng.choice([0, 1, None], rows, p=[0.47, 0.48, 0.05]), dtype="Int8"), + "numeric_0": numeric, + "nullable_int_0": _nullable_int(rng, rows), + "category_0": categories, + "text_0": pd.array( + [f"free form note {i % 97}" if i % 11 else None for i in range(rows)], + dtype="string", + ), + "event_time_0": pd.date_range("2024-01-01", periods=rows, freq="min", tz="UTC"), + "high_cardinality_0": pd.array( + [f"key-{spec.seed}-{i}" for i in range(rows)], dtype="string" + ), + } + ) + factories = ( + lambda i: pd.Series(rng.normal(i, 1.0, rows), name=f"numeric_{i}"), + lambda i: _nullable_int(rng, rows).rename(f"nullable_int_{i}"), + lambda i: pd.Series( + pd.Categorical(rng.choice(["a", "b", "c", None], rows)), name=f"category_{i}" + ), + lambda i: pd.Series( + pd.array([f"value {i}-{j % 211}" for j in range(rows)], dtype="string"), + name=f"text_{i}", + ), + lambda i: pd.Series( + pd.date_range("2020-01-01", periods=rows, freq="h"), name=f"datetime_{i}" + ), + lambda i: pd.Series( + pd.array([f"hc-{i}-{j}" for j in range(rows)], dtype="string"), + name=f"high_cardinality_{i}", + ), + ) + family_index = { + "numeric": 0, + "nullable": 1, + "categorical": 2, + "string": 3, + "datetime": 4, + "high_cardinality": 5, + }.get(spec.dataset_type) + if family_index is not None: + frame = frame[["record_id", "target"]].copy() + i = 1 + while frame.shape[1] < WIDTHS[spec.width]: + index = family_index if family_index is not None else (i - 1) % len(factories) + series = factories[index](i) + frame[series.name] = series + i += 1 + if rows >= 100: + duplicate_count = max(1, rows // 100) + frame = pd.concat( + [frame.iloc[:-duplicate_count], frame.iloc[:duplicate_count].copy()], + ignore_index=True, + ) + return frame diff --git a/tests/performance/conftest.py b/tests/performance/conftest.py new file mode 100644 index 0000000..92f2e0b --- /dev/null +++ b/tests/performance/conftest.py @@ -0,0 +1,5 @@ +from __future__ import annotations + +# Performance-tool modules live in the repository and are imported as the +# namespace package ``benchmarks.performance``. No sys.path mutation is needed +# when tests run with ``python -m pytest`` from the repository root. diff --git a/tests/performance/test_datasets.py b/tests/performance/test_datasets.py new file mode 100644 index 0000000..ff526c4 --- /dev/null +++ b/tests/performance/test_datasets.py @@ -0,0 +1,56 @@ +from __future__ import annotations + +import pandas as pd +import pytest +from benchmarks.performance.datasets import WIDTHS, DatasetSpec, make_mixed_frame + + +@pytest.mark.parametrize("width, n_cols", WIDTHS.items()) +def test_mixed_frame_has_exact_shape_and_required_roles(width: str, n_cols: int) -> None: + df = make_mixed_frame(DatasetSpec(rows=1_000, width=width, seed=42)) + assert df.shape == (1_000, n_cols) + assert {"record_id", "target", "numeric_0", "category_0", "text_0", "event_time_0"} <= set( + df.columns + ) + assert df["target"].isna().sum() > 0 + assert df.duplicated().sum() > 0 + assert pd.api.types.is_categorical_dtype(df["category_0"].dtype) + assert isinstance(df["event_time_0"].dtype, pd.DatetimeTZDtype) + + +def test_mixed_frame_is_deterministic_and_seed_sensitive() -> None: + spec = DatasetSpec(rows=2_000, width="medium", seed=7) + assert make_mixed_frame(spec).equals(make_mixed_frame(spec)) + assert not make_mixed_frame(spec).equals( + make_mixed_frame(DatasetSpec(rows=2_000, width="medium", seed=8)) + ) + + +def test_mixed_frame_covers_nullable_outlier_and_high_cardinality_cases() -> None: + df = make_mixed_frame(DatasetSpec(rows=5_000, width="medium", seed=42)) + assert str(df["nullable_int_0"].dtype) == "Int64" + assert df["nullable_int_0"].isna().any() + assert df["numeric_0"].isna().any() + assert df["numeric_0"].max() > 1_000 + assert df["high_cardinality_0"].nunique() > 2_000 + + +@pytest.mark.parametrize( + "dataset_type, expected_prefix", + [ + ("numeric", "numeric_"), + ("categorical", "category_"), + ("string", "text_"), + ("nullable", "nullable_int_"), + ("datetime", "datetime_"), + ("high_cardinality", "high_cardinality_"), + ], +) +def test_family_profile_dominates_non_role_columns( + dataset_type: str, expected_prefix: str +) -> None: + df = make_mixed_frame( + DatasetSpec(rows=1_000, width="medium", seed=42, dataset_type=dataset_type) + ) + family_columns = [name for name in df.columns if name.startswith(expected_prefix)] + assert len(family_columns) >= 24 From 8d744410bce286c47d287478d37036a563f2d19b Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 10:58:51 +0530 Subject: [PATCH 10/37] bench: define performance result contract --- benchmarks/performance/environment.py | 55 +++++++++++ benchmarks/performance/models.py | 119 ++++++++++++++++++++++++ benchmarks/performance/schema.py | 71 ++++++++++++++ tests/performance/test_models_schema.py | 56 +++++++++++ 4 files changed, 301 insertions(+) create mode 100644 benchmarks/performance/environment.py create mode 100644 benchmarks/performance/models.py create mode 100644 benchmarks/performance/schema.py create mode 100644 tests/performance/test_models_schema.py diff --git a/benchmarks/performance/environment.py b/benchmarks/performance/environment.py new file mode 100644 index 0000000..8506492 --- /dev/null +++ b/benchmarks/performance/environment.py @@ -0,0 +1,55 @@ +from __future__ import annotations + +import importlib.metadata +import os +import platform +import subprocess + +import numpy as np +import pandas as pd + +import freshdata + +from .models import EnvironmentInfo + + +def _version(name: str) -> str | None: + try: + return importlib.metadata.version(name) + except importlib.metadata.PackageNotFoundError: + return None + + +def capture_environment() -> EnvironmentInfo: + commit = subprocess.run( + ["git", "rev-parse", "HEAD"], check=True, capture_output=True, text=True + ).stdout.strip() + dirty = bool( + subprocess.run( + ["git", "status", "--porcelain"], check=True, capture_output=True, text=True + ).stdout + ) + try: + import psutil # noqa: PLC0415 + + physical = psutil.cpu_count(logical=False) + total_ram = int(psutil.virtual_memory().total) + except ImportError: + physical = None + total_ram = None + return EnvironmentInfo( + git_commit=commit, + git_dirty=dirty, + python_version=platform.python_version(), + pandas_version=pd.__version__, + numpy_version=np.__version__, + freshdata_version=freshdata.__version__, + optional_versions={ + name: _version(name) for name in ("polars", "duckdb", "pyspark", "pyarrow") + }, + platform=platform.platform(), + processor=platform.processor(), + cpu_count_logical=os.cpu_count() or 1, + cpu_count_physical=physical, + total_ram_bytes=total_ram, + ) diff --git a/benchmarks/performance/models.py b/benchmarks/performance/models.py new file mode 100644 index 0000000..30ebd14 --- /dev/null +++ b/benchmarks/performance/models.py @@ -0,0 +1,119 @@ +from __future__ import annotations + +import hashlib +import json +import statistics +from dataclasses import asdict, dataclass, field +from typing import Any + + +@dataclass(frozen=True) +class BenchmarkCase: + rows: int + width: str + config_name: str + options: dict[str, Any] + dataset_type: str = "mixed" + return_report: bool = False + backend: str = "pandas" + output_format: str = "pandas" + seed: int = 42 + warmups: int = 1 + repetitions: int = 5 + + @property + def case_id(self) -> str: + raw = json.dumps(asdict(self), sort_keys=True, separators=(",", ":"), default=str) + return hashlib.sha256(raw.encode()).hexdigest()[:16] + + +@dataclass(frozen=True) +class EnvironmentInfo: + git_commit: str + git_dirty: bool + python_version: str + pandas_version: str + numpy_version: str + freshdata_version: str + optional_versions: dict[str, str | None] + platform: str + processor: str + cpu_count_logical: int + cpu_count_physical: int | None + total_ram_bytes: int | None + + +@dataclass(frozen=True) +class BenchmarkResult: + schema_version: int + status: str + case: BenchmarkCase + environment: EnvironmentInfo + samples_seconds: list[float] = field(default_factory=list) + median_seconds: float | None = None + min_seconds: float | None = None + max_seconds: float | None = None + stdev_seconds: float | None = None + coefficient_of_variation: float | None = None + throughput_rows_per_second: float | None = None + peak_rss_bytes: int | None = None + peak_python_bytes: int | None = None + input_bytes: int | None = None + input_to_peak_ratio: float | None = None + command: str = "" + error_type: str | None = None + error_message: str | None = None + output_fingerprint: str | None = None + report_fingerprint: str | None = None + result_type: str | None = None + + @classmethod + def completed( + cls, + *, + case: BenchmarkCase, + environment: EnvironmentInfo, + samples_seconds: list[float], + peak_rss_bytes: int, + peak_python_bytes: int, + input_bytes: int, + command: str, + output_fingerprint: str | None = None, + report_fingerprint: str | None = None, + result_type: str | None = None, + ) -> BenchmarkResult: + if not samples_seconds: + raise ValueError("samples_seconds must not be empty") + median = statistics.median(samples_seconds) + stdev = statistics.stdev(samples_seconds) if len(samples_seconds) > 1 else 0.0 + return cls( + schema_version=1, + status="completed", + case=case, + environment=environment, + samples_seconds=samples_seconds, + median_seconds=median, + min_seconds=min(samples_seconds), + max_seconds=max(samples_seconds), + stdev_seconds=stdev, + coefficient_of_variation=(stdev / median) if median else 0.0, + throughput_rows_per_second=(case.rows / median) if median else None, + peak_rss_bytes=peak_rss_bytes, + peak_python_bytes=peak_python_bytes, + input_bytes=input_bytes, + input_to_peak_ratio=(peak_rss_bytes / input_bytes) if input_bytes else None, + command=command, + output_fingerprint=output_fingerprint, + report_fingerprint=report_fingerprint, + result_type=result_type, + ) + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + @classmethod + def from_dict(cls, payload: dict[str, Any]) -> BenchmarkResult: + data = dict(payload) + data["case"] = BenchmarkCase(**data["case"]) + data["environment"] = EnvironmentInfo(**data["environment"]) + return cls(**data) diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py new file mode 100644 index 0000000..a65b7ff --- /dev/null +++ b/benchmarks/performance/schema.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +from typing import Any + +RESULT_SCHEMA = { + "$schema": "https://json-schema.org/draft/2020-12/schema", + "type": "object", + "required": [ + "schema_version", + "status", + "case", + "environment", + "samples_seconds", + "command", + ], + "properties": { + "schema_version": {"const": 1}, + "status": {"enum": ["completed", "failed", "timeout", "oom", "skipped"]}, + "case": { + "type": "object", + "required": [ + "rows", + "width", + "config_name", + "options", + "dataset_type", + "return_report", + "backend", + "output_format", + "seed", + "warmups", + "repetitions", + ], + }, + "environment": { + "type": "object", + "required": [ + "git_commit", + "python_version", + "pandas_version", + "numpy_version", + "freshdata_version", + "platform", + ], + }, + "samples_seconds": { + "type": "array", + "items": {"type": "number", "minimum": 0}, + }, + "command": {"type": "string"}, + }, +} + + +def validate_result(payload: dict[str, Any]) -> None: + import jsonschema # noqa: PLC0415 + + jsonschema.validate(payload, RESULT_SCHEMA) + if payload["status"] == "completed": + if not payload["samples_seconds"]: + raise ValueError("completed result requires samples_seconds") + for field in ( + "median_seconds", + "min_seconds", + "max_seconds", + "peak_rss_bytes", + "peak_python_bytes", + "input_bytes", + ): + if payload.get(field) is None: + raise ValueError(f"completed result requires {field}") diff --git a/tests/performance/test_models_schema.py b/tests/performance/test_models_schema.py new file mode 100644 index 0000000..8cde446 --- /dev/null +++ b/tests/performance/test_models_schema.py @@ -0,0 +1,56 @@ +from __future__ import annotations + +from dataclasses import replace + +import pytest +from benchmarks.performance.environment import capture_environment +from benchmarks.performance.models import BenchmarkCase, BenchmarkResult +from benchmarks.performance.schema import validate_result + + +def test_case_id_is_stable_and_configuration_sensitive() -> None: + case = BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}) + assert ( + case.case_id + == BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}).case_id + ) + assert case.case_id != replace(case, return_report=True).case_id + + +def test_environment_contains_required_reproduction_fields() -> None: + env = capture_environment() + assert env.python_version + assert env.pandas_version + assert env.numpy_version + assert env.git_commit + assert env.platform + assert env.cpu_count_logical >= 1 + + +def test_result_round_trip_validates() -> None: + case = BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}) + result = BenchmarkResult.completed( + case=case, + environment=capture_environment(), + samples_seconds=[1.0, 1.1, 0.9], + peak_rss_bytes=1_000_000, + peak_python_bytes=500_000, + input_bytes=250_000, + command="python -m benchmarks.performance worker", + ) + payload = result.to_dict() + validate_result(payload) + assert BenchmarkResult.from_dict(payload).case == case + + +def test_completed_result_rejects_empty_samples() -> None: + with pytest.raises(ValueError, match="samples_seconds"): + BenchmarkResult.completed( + case=BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}), + environment=capture_environment(), + samples_seconds=[], + peak_rss_bytes=0, + peak_python_bytes=0, + input_bytes=1, + command="x", + ) From 18eb079e95c8747cc9e7b22a498853afee0bbadb Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 16:31:34 +0530 Subject: [PATCH 11/37] bench: harden performance result contract --- benchmarks/performance/models.py | 70 ++++++++++-- benchmarks/performance/schema.py | 105 +++++++++++++++++- tests/performance/test_datasets.py | 2 +- tests/performance/test_models_schema.py | 138 ++++++++++++++++++++++++ 4 files changed, 305 insertions(+), 10 deletions(-) diff --git a/benchmarks/performance/models.py b/benchmarks/performance/models.py index 30ebd14..2b54096 100644 --- a/benchmarks/performance/models.py +++ b/benchmarks/performance/models.py @@ -2,9 +2,40 @@ import hashlib import json +import math import statistics from dataclasses import asdict, dataclass, field -from typing import Any +from typing import Any, TypeAlias, Union + +JsonValue: TypeAlias = Union[ + None, + bool, + int, + float, + str, + list["JsonValue"], + dict[str, "JsonValue"], +] + + +def _validate_json_value(value: object, path: str) -> None: + if value is None or isinstance(value, (bool, int, str)): + return + if isinstance(value, float): + if not math.isfinite(value): + raise ValueError(f"{path} must contain only finite numbers") + return + if isinstance(value, list): + for index, item in enumerate(value): + _validate_json_value(item, f"{path}[{index}]") + return + if isinstance(value, dict): + for key, item in value.items(): + if not isinstance(key, str): + raise TypeError(f"{path} keys must be strings") + _validate_json_value(item, f"{path}.{key}") + return + raise TypeError(f"{path} contains a non-JSON value: {type(value).__name__}") @dataclass(frozen=True) @@ -12,7 +43,7 @@ class BenchmarkCase: rows: int width: str config_name: str - options: dict[str, Any] + options: dict[str, JsonValue] dataset_type: str = "mixed" return_report: bool = False backend: str = "pandas" @@ -21,9 +52,14 @@ class BenchmarkCase: warmups: int = 1 repetitions: int = 5 + def __post_init__(self) -> None: + if not isinstance(self.options, dict): + raise TypeError("options must be a JSON object") + _validate_json_value(self.options, "options") + @property def case_id(self) -> str: - raw = json.dumps(asdict(self), sort_keys=True, separators=(",", ":"), default=str) + raw = json.dumps(asdict(self), sort_keys=True, separators=(",", ":"), allow_nan=False) return hashlib.sha256(raw.encode()).hexdigest()[:16] @@ -84,8 +120,26 @@ def completed( ) -> BenchmarkResult: if not samples_seconds: raise ValueError("samples_seconds must not be empty") + if not all(math.isfinite(sample) for sample in samples_seconds): + raise ValueError("samples_seconds must contain only finite values") + if any(sample < 0 for sample in samples_seconds): + raise ValueError("samples_seconds must contain only non-negative values") median = statistics.median(samples_seconds) stdev = statistics.stdev(samples_seconds) if len(samples_seconds) > 1 else 0.0 + coefficient_of_variation = (stdev / median) if median else 0.0 + throughput_rows_per_second = (case.rows / median) if median else None + input_to_peak_ratio = (peak_rss_bytes / input_bytes) if input_bytes else None + derived_metrics = ( + median, + min(samples_seconds), + max(samples_seconds), + stdev, + coefficient_of_variation, + throughput_rows_per_second, + input_to_peak_ratio, + ) + if any(metric is not None and not math.isfinite(metric) for metric in derived_metrics): + raise ValueError("completed result metrics must contain only finite values") return cls( schema_version=1, status="completed", @@ -96,12 +150,12 @@ def completed( min_seconds=min(samples_seconds), max_seconds=max(samples_seconds), stdev_seconds=stdev, - coefficient_of_variation=(stdev / median) if median else 0.0, - throughput_rows_per_second=(case.rows / median) if median else None, + coefficient_of_variation=coefficient_of_variation, + throughput_rows_per_second=throughput_rows_per_second, peak_rss_bytes=peak_rss_bytes, peak_python_bytes=peak_python_bytes, input_bytes=input_bytes, - input_to_peak_ratio=(peak_rss_bytes / input_bytes) if input_bytes else None, + input_to_peak_ratio=input_to_peak_ratio, command=command, output_fingerprint=output_fingerprint, report_fingerprint=report_fingerprint, @@ -109,7 +163,9 @@ def completed( ) def to_dict(self) -> dict[str, Any]: - return asdict(self) + payload = asdict(self) + json.dumps(payload, allow_nan=False) + return payload @classmethod def from_dict(cls, payload: dict[str, Any]) -> BenchmarkResult: diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py index a65b7ff..6e2a675 100644 --- a/benchmarks/performance/schema.py +++ b/benchmarks/performance/schema.py @@ -1,9 +1,22 @@ from __future__ import annotations +import json from typing import Any RESULT_SCHEMA = { "$schema": "https://json-schema.org/draft/2020-12/schema", + "$defs": { + "json_value": { + "anyOf": [ + {"type": ["null", "boolean", "number", "string"]}, + {"type": "array", "items": {"$ref": "#/$defs/json_value"}}, + { + "type": "object", + "additionalProperties": {"$ref": "#/$defs/json_value"}, + }, + ] + } + }, "type": "object", "required": [ "schema_version", @@ -11,11 +24,30 @@ "case", "environment", "samples_seconds", + "median_seconds", + "min_seconds", + "max_seconds", + "stdev_seconds", + "coefficient_of_variation", + "throughput_rows_per_second", + "peak_rss_bytes", + "peak_python_bytes", + "input_bytes", + "input_to_peak_ratio", "command", + "error_type", + "error_message", + "output_fingerprint", + "report_fingerprint", + "result_type", ], + "additionalProperties": False, "properties": { - "schema_version": {"const": 1}, - "status": {"enum": ["completed", "failed", "timeout", "oom", "skipped"]}, + "schema_version": {"type": "integer", "const": 1}, + "status": { + "type": "string", + "enum": ["completed", "failed", "timeout", "oom", "skipped"], + }, "case": { "type": "object", "required": [ @@ -31,23 +63,88 @@ "warmups", "repetitions", ], + "additionalProperties": False, + "properties": { + "rows": {"type": "integer", "minimum": 1}, + "width": {"type": "string"}, + "config_name": {"type": "string"}, + "options": { + "type": "object", + "additionalProperties": {"$ref": "#/$defs/json_value"}, + }, + "dataset_type": {"type": "string"}, + "return_report": {"type": "boolean"}, + "backend": {"type": "string"}, + "output_format": {"type": "string"}, + "seed": {"type": "integer"}, + "warmups": {"type": "integer", "minimum": 0}, + "repetitions": {"type": "integer", "minimum": 1}, + }, }, "environment": { "type": "object", "required": [ "git_commit", + "git_dirty", "python_version", "pandas_version", "numpy_version", "freshdata_version", + "optional_versions", "platform", + "processor", + "cpu_count_logical", + "cpu_count_physical", + "total_ram_bytes", ], + "additionalProperties": False, + "properties": { + "git_commit": {"type": "string"}, + "git_dirty": {"type": "boolean"}, + "python_version": {"type": "string"}, + "pandas_version": {"type": "string"}, + "numpy_version": {"type": "string"}, + "freshdata_version": {"type": "string"}, + "optional_versions": { + "type": "object", + "additionalProperties": {"type": ["string", "null"]}, + }, + "platform": {"type": "string"}, + "processor": {"type": "string"}, + "cpu_count_logical": {"type": "integer", "minimum": 1}, + "cpu_count_physical": { + "type": ["integer", "null"], + "minimum": 1, + }, + "total_ram_bytes": {"type": ["integer", "null"], "minimum": 0}, + }, }, "samples_seconds": { "type": "array", "items": {"type": "number", "minimum": 0}, }, + "median_seconds": {"type": ["number", "null"], "minimum": 0}, + "min_seconds": {"type": ["number", "null"], "minimum": 0}, + "max_seconds": {"type": ["number", "null"], "minimum": 0}, + "stdev_seconds": {"type": ["number", "null"], "minimum": 0}, + "coefficient_of_variation": { + "type": ["number", "null"], + "minimum": 0, + }, + "throughput_rows_per_second": { + "type": ["number", "null"], + "minimum": 0, + }, + "peak_rss_bytes": {"type": ["integer", "null"], "minimum": 0}, + "peak_python_bytes": {"type": ["integer", "null"], "minimum": 0}, + "input_bytes": {"type": ["integer", "null"], "minimum": 0}, + "input_to_peak_ratio": {"type": ["number", "null"], "minimum": 0}, "command": {"type": "string"}, + "error_type": {"type": ["string", "null"]}, + "error_message": {"type": ["string", "null"]}, + "output_fingerprint": {"type": ["string", "null"]}, + "report_fingerprint": {"type": ["string", "null"]}, + "result_type": {"type": ["string", "null"]}, }, } @@ -55,6 +152,10 @@ def validate_result(payload: dict[str, Any]) -> None: import jsonschema # noqa: PLC0415 + try: + json.dumps(payload, allow_nan=False) + except ValueError as exc: + raise ValueError("result payload must contain only finite JSON numbers") from exc jsonschema.validate(payload, RESULT_SCHEMA) if payload["status"] == "completed": if not payload["samples_seconds"]: diff --git a/tests/performance/test_datasets.py b/tests/performance/test_datasets.py index ff526c4..2fb9f1e 100644 --- a/tests/performance/test_datasets.py +++ b/tests/performance/test_datasets.py @@ -14,7 +14,7 @@ def test_mixed_frame_has_exact_shape_and_required_roles(width: str, n_cols: int) ) assert df["target"].isna().sum() > 0 assert df.duplicated().sum() > 0 - assert pd.api.types.is_categorical_dtype(df["category_0"].dtype) + assert isinstance(df["category_0"].dtype, pd.CategoricalDtype) assert isinstance(df["event_time_0"].dtype, pd.DatetimeTZDtype) diff --git a/tests/performance/test_models_schema.py b/tests/performance/test_models_schema.py index 8cde446..978613a 100644 --- a/tests/performance/test_models_schema.py +++ b/tests/performance/test_models_schema.py @@ -1,7 +1,10 @@ from __future__ import annotations +import json from dataclasses import replace +from math import inf, nan +import jsonschema import pytest from benchmarks.performance.environment import capture_environment from benchmarks.performance.models import BenchmarkCase, BenchmarkResult @@ -17,6 +20,58 @@ def test_case_id_is_stable_and_configuration_sensitive() -> None: assert case.case_id != replace(case, return_report=True).case_id +def test_case_options_support_nested_json_values() -> None: + options = { + "enabled": True, + "thresholds": [1, 2.5, None], + "nested": {"label": "strict", "values": ["a", "b"]}, + } + case = BenchmarkCase(rows=10_000, width="narrow", config_name="nested", options=options) + result = BenchmarkResult.completed( + case=case, + environment=capture_environment(), + samples_seconds=[1.0], + peak_rss_bytes=1_000_000, + peak_python_bytes=500_000, + input_bytes=250_000, + command="x", + ) + + payload = result.to_dict() + json.dumps(payload, allow_nan=False) + assert BenchmarkResult.from_dict(payload).case == case + + +@pytest.mark.parametrize( + "options", + [ + {"bad": {1, 2}}, + {"bad": (1, 2)}, + {"bad": object()}, + {1: "non-string-key"}, + ], +) +def test_case_options_reject_non_json_values(options: object) -> None: + with pytest.raises(TypeError, match="options"): + BenchmarkCase( + rows=10_000, + width="narrow", + config_name="invalid", + options=options, # type: ignore[arg-type] + ) + + +@pytest.mark.parametrize("value", [nan, inf, -inf]) +def test_case_options_reject_non_finite_numbers(value: float) -> None: + with pytest.raises(ValueError, match="finite"): + BenchmarkCase( + rows=10_000, + width="narrow", + config_name="invalid", + options={"bad": [value]}, + ) + + def test_environment_contains_required_reproduction_fields() -> None: env = capture_environment() assert env.python_version @@ -54,3 +109,86 @@ def test_completed_result_rejects_empty_samples() -> None: input_bytes=1, command="x", ) + + +def _completed_payload() -> dict[str, object]: + return BenchmarkResult.completed( + case=BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}), + environment=capture_environment(), + samples_seconds=[1.0, 1.1, 0.9], + peak_rss_bytes=1_000_000, + peak_python_bytes=500_000, + input_bytes=250_000, + command="x", + ).to_dict() + + +def test_schema_rejects_wrong_case_field_type() -> None: + payload = _completed_payload() + payload["case"]["rows"] = "10000" # type: ignore[index] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +def test_schema_rejects_wrong_metric_type() -> None: + payload = _completed_payload() + payload["median_seconds"] = "fast" + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +def test_schema_requires_every_environment_field() -> None: + payload = _completed_payload() + payload["environment"].pop("git_dirty") # type: ignore[union-attr] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +@pytest.mark.parametrize("location", ["result", "case", "environment"]) +def test_schema_rejects_unknown_fields(location: str) -> None: + payload = _completed_payload() + if location == "result": + payload["unknown"] = True + else: + payload[location]["unknown"] = True # type: ignore[index] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +@pytest.mark.parametrize("sample", [nan, inf, -inf]) +def test_completed_result_rejects_non_finite_samples(sample: float) -> None: + with pytest.raises(ValueError, match="finite"): + BenchmarkResult.completed( + case=BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}), + environment=capture_environment(), + samples_seconds=[sample], + peak_rss_bytes=1_000_000, + peak_python_bytes=500_000, + input_bytes=250_000, + command="x", + ) + + +def test_completed_result_rejects_non_finite_derived_metric() -> None: + with pytest.raises(ValueError, match="finite"): + BenchmarkResult.completed( + case=BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}), + environment=capture_environment(), + samples_seconds=[5e-324], + peak_rss_bytes=1_000_000, + peak_python_bytes=500_000, + input_bytes=250_000, + command="x", + ) + + +def test_validation_rejects_non_strict_json_numbers() -> None: + payload = _completed_payload() + payload["median_seconds"] = nan + + with pytest.raises(ValueError, match="finite JSON"): + validate_result(payload) From ce0607b5a51bf103ea0467e536c491120de542cb Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 16:47:54 +0530 Subject: [PATCH 12/37] bench: align factories with result schema --- benchmarks/performance/models.py | 59 +++++++++++++-- benchmarks/performance/schema.py | 24 +++++-- tests/performance/test_models_schema.py | 96 +++++++++++++++++++++++++ 3 files changed, 170 insertions(+), 9 deletions(-) diff --git a/benchmarks/performance/models.py b/benchmarks/performance/models.py index 2b54096..4d4b951 100644 --- a/benchmarks/performance/models.py +++ b/benchmarks/performance/models.py @@ -5,18 +5,45 @@ import math import statistics from dataclasses import asdict, dataclass, field -from typing import Any, TypeAlias, Union +from typing import Any, Dict, List, Union # noqa: UP035 -JsonValue: TypeAlias = Union[ +JsonValue = Union[ None, bool, int, float, str, - list["JsonValue"], - dict[str, "JsonValue"], + List["JsonValue"], # noqa: UP006 + Dict[str, "JsonValue"], # noqa: UP006 ] +_SUPPORTED_WIDTHS = frozenset(("narrow", "medium", "wide")) +_SUPPORTED_DATASET_TYPES = frozenset( + ( + "mixed", + "numeric", + "categorical", + "string", + "nullable", + "datetime", + "high_cardinality", + ) +) + + +def _validate_integer(name: str, value: object, *, minimum: int | None = None) -> None: + if isinstance(value, bool) or not isinstance(value, int): + raise TypeError(f"{name} must be an integer") + if minimum is not None and value < minimum: + raise ValueError(f"{name} must be >= {minimum}") + + +def _validate_nonempty_string(name: str, value: object) -> None: + if not isinstance(value, str): + raise TypeError(f"{name} must be a string") + if not value: + raise ValueError(f"{name} must not be empty") + def _validate_json_value(value: object, path: str) -> None: if value is None or isinstance(value, (bool, int, str)): @@ -53,9 +80,22 @@ class BenchmarkCase: repetitions: int = 5 def __post_init__(self) -> None: + _validate_integer("rows", self.rows, minimum=1) + if self.width not in _SUPPORTED_WIDTHS: + raise ValueError(f"width must be one of {sorted(_SUPPORTED_WIDTHS)}") + _validate_nonempty_string("config_name", self.config_name) if not isinstance(self.options, dict): raise TypeError("options must be a JSON object") _validate_json_value(self.options, "options") + if self.dataset_type not in _SUPPORTED_DATASET_TYPES: + raise ValueError(f"dataset_type must be one of {sorted(_SUPPORTED_DATASET_TYPES)}") + if not isinstance(self.return_report, bool): + raise TypeError("return_report must be a boolean") + _validate_nonempty_string("backend", self.backend) + _validate_nonempty_string("output_format", self.output_format) + _validate_integer("seed", self.seed) + _validate_integer("warmups", self.warmups, minimum=0) + _validate_integer("repetitions", self.repetitions, minimum=1) @property def case_id(self) -> str: @@ -120,10 +160,21 @@ def completed( ) -> BenchmarkResult: if not samples_seconds: raise ValueError("samples_seconds must not be empty") + if any( + isinstance(sample, bool) or not isinstance(sample, (int, float)) + for sample in samples_seconds + ): + raise TypeError("samples_seconds must contain only numbers") if not all(math.isfinite(sample) for sample in samples_seconds): raise ValueError("samples_seconds must contain only finite values") if any(sample < 0 for sample in samples_seconds): raise ValueError("samples_seconds must contain only non-negative values") + for name, value in ( + ("peak_rss_bytes", peak_rss_bytes), + ("peak_python_bytes", peak_python_bytes), + ("input_bytes", input_bytes), + ): + _validate_integer(name, value, minimum=0) median = statistics.median(samples_seconds) stdev = statistics.stdev(samples_seconds) if len(samples_seconds) > 1 else 0.0 coefficient_of_variation = (stdev / median) if median else 0.0 diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py index 6e2a675..b33ff59 100644 --- a/benchmarks/performance/schema.py +++ b/benchmarks/performance/schema.py @@ -66,16 +66,30 @@ "additionalProperties": False, "properties": { "rows": {"type": "integer", "minimum": 1}, - "width": {"type": "string"}, - "config_name": {"type": "string"}, + "width": { + "type": "string", + "enum": ["narrow", "medium", "wide"], + }, + "config_name": {"type": "string", "minLength": 1}, "options": { "type": "object", "additionalProperties": {"$ref": "#/$defs/json_value"}, }, - "dataset_type": {"type": "string"}, + "dataset_type": { + "type": "string", + "enum": [ + "mixed", + "numeric", + "categorical", + "string", + "nullable", + "datetime", + "high_cardinality", + ], + }, "return_report": {"type": "boolean"}, - "backend": {"type": "string"}, - "output_format": {"type": "string"}, + "backend": {"type": "string", "minLength": 1}, + "output_format": {"type": "string", "minLength": 1}, "seed": {"type": "integer"}, "warmups": {"type": "integer", "minimum": 0}, "repetitions": {"type": "integer", "minimum": 1}, diff --git a/tests/performance/test_models_schema.py b/tests/performance/test_models_schema.py index 978613a..65eceeb 100644 --- a/tests/performance/test_models_schema.py +++ b/tests/performance/test_models_schema.py @@ -10,6 +10,17 @@ from benchmarks.performance.models import BenchmarkCase, BenchmarkResult from benchmarks.performance.schema import validate_result +SUPPORTED_WIDTHS = ("narrow", "medium", "wide") +SUPPORTED_DATASET_TYPES = ( + "mixed", + "numeric", + "categorical", + "string", + "nullable", + "datetime", + "high_cardinality", +) + def test_case_id_is_stable_and_configuration_sensitive() -> None: case = BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}) @@ -72,6 +83,72 @@ def test_case_options_reject_non_finite_numbers(value: float) -> None: ) +@pytest.mark.parametrize( + "field,value,error", + [ + ("rows", 0, ValueError), + ("rows", True, TypeError), + ("width", "extra-wide", ValueError), + ("config_name", "", ValueError), + ("dataset_type", "unsupported", ValueError), + ("return_report", 1, TypeError), + ("backend", "", ValueError), + ("output_format", "", ValueError), + ("seed", True, TypeError), + ("warmups", -1, ValueError), + ("repetitions", 0, ValueError), + ], +) +def test_case_rejects_values_its_schema_rejects( + field: str, value: object, error: type[Exception] +) -> None: + arguments = { + "rows": 10_000, + "width": "narrow", + "config_name": "default", + "options": {}, + "dataset_type": "mixed", + "return_report": False, + "backend": "pandas", + "output_format": "pandas", + "seed": 42, + "warmups": 1, + "repetitions": 5, + } + arguments[field] = value + + with pytest.raises(error, match=field): + BenchmarkCase(**arguments) # type: ignore[arg-type] + + +def test_supported_cases_create_schema_valid_payloads() -> None: + environment = capture_environment() + for width in SUPPORTED_WIDTHS: + for dataset_type in SUPPORTED_DATASET_TYPES: + case = BenchmarkCase( + rows=1, + width=width, + config_name="boundary", + options={}, + dataset_type=dataset_type, + backend="pandas", + output_format="pandas", + warmups=0, + repetitions=1, + ) + payload = BenchmarkResult.completed( + case=case, + environment=environment, + samples_seconds=[0.0], + peak_rss_bytes=0, + peak_python_bytes=0, + input_bytes=0, + command="x", + ).to_dict() + + validate_result(payload) + + def test_environment_contains_required_reproduction_fields() -> None: env = capture_environment() assert env.python_version @@ -186,6 +263,25 @@ def test_completed_result_rejects_non_finite_derived_metric() -> None: ) +@pytest.mark.parametrize("field", ["peak_rss_bytes", "peak_python_bytes", "input_bytes"]) +def test_completed_result_rejects_negative_byte_counts(field: str) -> None: + byte_counts = { + "peak_rss_bytes": 1_000_000, + "peak_python_bytes": 500_000, + "input_bytes": 250_000, + } + byte_counts[field] = -1 + + with pytest.raises(ValueError, match=field): + BenchmarkResult.completed( + case=BenchmarkCase(rows=10_000, width="narrow", config_name="default", options={}), + environment=capture_environment(), + samples_seconds=[1.0], + command="x", + **byte_counts, + ) + + def test_validation_rejects_non_strict_json_numbers() -> None: payload = _completed_payload() payload["median_seconds"] = nan From a866782576506a15b47a951e9533f1b4e512563c Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 16:55:36 +0530 Subject: [PATCH 13/37] bench: measure isolated runtime and peak memory --- benchmarks/performance/memory.py | 40 +++++++++++ benchmarks/performance/worker.py | 110 +++++++++++++++++++++++++++++++ tests/performance/test_worker.py | 74 +++++++++++++++++++++ 3 files changed, 224 insertions(+) create mode 100644 benchmarks/performance/memory.py create mode 100644 benchmarks/performance/worker.py create mode 100644 tests/performance/test_worker.py diff --git a/benchmarks/performance/memory.py b/benchmarks/performance/memory.py new file mode 100644 index 0000000..4430dc6 --- /dev/null +++ b/benchmarks/performance/memory.py @@ -0,0 +1,40 @@ +from __future__ import annotations + +import gc +import threading +from typing import Optional + + +class PeakRSS: + def __init__(self, interval_seconds: float = 0.01) -> None: + import psutil # noqa: PLC0415 + + self._process = psutil.Process() + self._interval = interval_seconds + self._stop = threading.Event() + self._thread: Optional[threading.Thread] = None # noqa: UP045 + self._baseline = 0 + self._peak = 0 + + def __enter__(self) -> PeakRSS: + gc.collect() + self._baseline = self._process.memory_info().rss + self._peak = self._baseline + self._stop.clear() + self._thread = threading.Thread(target=self._sample, daemon=True) + self._thread.start() + return self + + def _sample(self) -> None: + while not self._stop.wait(self._interval): + self._peak = max(self._peak, self._process.memory_info().rss) + + def __exit__(self, *_args: object) -> None: + self._peak = max(self._peak, self._process.memory_info().rss) + self._stop.set() + if self._thread is not None: + self._thread.join() + + @property + def increase_bytes(self) -> int: + return max(0, self._peak - self._baseline) diff --git a/benchmarks/performance/worker.py b/benchmarks/performance/worker.py new file mode 100644 index 0000000..be2ffee --- /dev/null +++ b/benchmarks/performance/worker.py @@ -0,0 +1,110 @@ +from __future__ import annotations + +import gc +import hashlib +import json +import time +import tracemalloc +from pathlib import Path +from typing import Any + +import pandas as pd + +import freshdata as fd + +from .datasets import DatasetSpec, make_mixed_frame +from .environment import capture_environment +from .memory import PeakRSS +from .models import BenchmarkCase, BenchmarkResult +from .schema import validate_result + + +def _run_clean(frame: pd.DataFrame, case: BenchmarkCase) -> Any: + return fd.clean( + frame, + config=case.options, + return_report=case.return_report, + engine=case.backend, + output_format=case.output_format, + ) + + +def _fingerprints(result: Any, return_report: bool) -> tuple[str, str, str]: + if return_report: + cleaned, report = result + result_type = "tuple[CleanResult,CleanReport]" + else: + cleaned, report = result, result.report() + result_type = "CleanResult" + + frame_hash = hashlib.sha256() + frame_hash.update(pd.util.hash_pandas_object(cleaned, index=True).values.tobytes()) + frame_hash.update(repr(list(cleaned.columns)).encode()) + frame_hash.update(repr([str(dtype) for dtype in cleaned.dtypes]).encode()) + + report_payload = report.to_dict() + report_payload.pop("duration_seconds", None) + report_payload.pop("stage_timings", None) + report_hash = hashlib.sha256( + json.dumps(report_payload, sort_keys=True, default=str, allow_nan=False).encode() + ).hexdigest() + return frame_hash.hexdigest(), report_hash, result_type + + +def execute_case(case: BenchmarkCase, *, command: str) -> BenchmarkResult: + frame = make_mixed_frame( + DatasetSpec( + rows=case.rows, + width=case.width, + seed=case.seed, + dataset_type=case.dataset_type, + ) + ) + input_bytes = int(frame.memory_usage(index=True, deep=True).sum()) + + for _ in range(case.warmups): + _run_clean(frame, case) + + samples: list[float] = [] + for _ in range(case.repetitions): + gc.collect() + started = time.perf_counter() + _run_clean(frame, case) + samples.append(time.perf_counter() - started) + + gc.collect() + tracemalloc.start() + try: + with PeakRSS() as rss: + measured_result = _run_clean(frame, case) + _current, python_peak = tracemalloc.get_traced_memory() + finally: + tracemalloc.stop() + + output_fingerprint, report_fingerprint, result_type = _fingerprints( + measured_result, case.return_report + ) + return BenchmarkResult.completed( + case=case, + environment=capture_environment(), + samples_seconds=samples, + peak_rss_bytes=rss.increase_bytes, + peak_python_bytes=python_peak, + input_bytes=input_bytes, + command=command, + output_fingerprint=output_fingerprint, + report_fingerprint=report_fingerprint, + result_type=result_type, + ) + + +def worker_main(case_path: str, result_path: str, command: str) -> None: + case_payload = json.loads(Path(case_path).read_text(encoding="utf-8")) + case = BenchmarkCase(**case_payload) + result = execute_case(case, command=command) + payload = result.to_dict() + validate_result(payload) + Path(result_path).write_text( + json.dumps(payload, indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) diff --git a/tests/performance/test_worker.py b/tests/performance/test_worker.py new file mode 100644 index 0000000..75b3f8c --- /dev/null +++ b/tests/performance/test_worker.py @@ -0,0 +1,74 @@ +from __future__ import annotations + +import json +from dataclasses import asdict, replace + +from benchmarks.performance.models import BenchmarkCase, BenchmarkResult +from benchmarks.performance.schema import validate_result +from benchmarks.performance.worker import execute_case, worker_main + + +def test_worker_records_warm_samples_memory_and_embedded_report() -> None: + case = BenchmarkCase( + rows=500, + width="narrow", + config_name="default", + options={"verbose": False}, + return_report=False, + warmups=1, + repetitions=2, + ) + + result = execute_case(case, command="unit-test") + + assert result.status == "completed" + assert len(result.samples_seconds) == 2 + assert result.peak_rss_bytes is not None and result.peak_rss_bytes >= 0 + assert result.peak_python_bytes is not None and result.peak_python_bytes > 0 + assert result.input_bytes is not None and result.input_bytes > 0 + + +def test_worker_report_flag_does_not_change_cleaned_values() -> None: + base = BenchmarkCase( + rows=500, + width="narrow", + config_name="default", + options={"verbose": False}, + warmups=0, + repetitions=1, + ) + + without_report = execute_case(base, command="unit-test") + with_report = execute_case(replace(base, return_report=True), command="unit-test") + + assert without_report.status == with_report.status == "completed" + assert without_report.output_fingerprint == with_report.output_fingerprint + assert without_report.report_fingerprint == with_report.report_fingerprint + assert without_report.result_type == "CleanResult" + assert with_report.result_type == "tuple[CleanResult,CleanReport]" + + +def test_worker_main_writes_a_strict_schema_valid_result(tmp_path) -> None: + case = BenchmarkCase( + rows=100, + width="narrow", + config_name="default", + options={"verbose": False}, + warmups=0, + repetitions=1, + ) + case_path = tmp_path / "case.json" + result_path = tmp_path / "result.json" + case_path.write_text(json.dumps(asdict(case), allow_nan=False), encoding="utf-8") + + worker_main(str(case_path), str(result_path), "unit-test worker") + + raw_payload = result_path.read_text(encoding="utf-8") + payload = json.loads( + raw_payload, + parse_constant=lambda value: (_ for _ in ()).throw(ValueError(value)), + ) + validate_result(payload) + result = BenchmarkResult.from_dict(payload) + assert result.status == "completed" + assert result.command == "unit-test worker" From 3faff5ceda8dea0c897546ecf9dead5c05699e6f Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 17:01:14 +0530 Subject: [PATCH 14/37] test: harden isolated benchmark workers --- benchmarks/performance/worker.py | 11 +++- tests/performance/test_worker.py | 86 ++++++++++++++++++++++++++++++-- 2 files changed, 91 insertions(+), 6 deletions(-) diff --git a/benchmarks/performance/worker.py b/benchmarks/performance/worker.py index be2ffee..cf752ef 100644 --- a/benchmarks/performance/worker.py +++ b/benchmarks/performance/worker.py @@ -6,7 +6,7 @@ import time import tracemalloc from pathlib import Path -from typing import Any +from typing import Any, NoReturn import pandas as pd @@ -19,6 +19,10 @@ from .schema import validate_result +def _reject_non_standard_json_constant(value: str) -> NoReturn: + raise ValueError(f"case JSON contains non-standard constant: {value}") + + def _run_clean(frame: pd.DataFrame, case: BenchmarkCase) -> Any: return fd.clean( frame, @@ -99,7 +103,10 @@ def execute_case(case: BenchmarkCase, *, command: str) -> BenchmarkResult: def worker_main(case_path: str, result_path: str, command: str) -> None: - case_payload = json.loads(Path(case_path).read_text(encoding="utf-8")) + case_payload = json.loads( + Path(case_path).read_text(encoding="utf-8"), + parse_constant=_reject_non_standard_json_constant, + ) case = BenchmarkCase(**case_payload) result = execute_case(case, command=command) payload = result.to_dict() diff --git a/tests/performance/test_worker.py b/tests/performance/test_worker.py index 75b3f8c..cd3935d 100644 --- a/tests/performance/test_worker.py +++ b/tests/performance/test_worker.py @@ -1,13 +1,20 @@ from __future__ import annotations import json +import subprocess +import sys from dataclasses import asdict, replace +import pytest from benchmarks.performance.models import BenchmarkCase, BenchmarkResult from benchmarks.performance.schema import validate_result from benchmarks.performance.worker import execute_case, worker_main +def _reject_json_constant(value: str) -> None: + raise ValueError(value) + + def test_worker_records_warm_samples_memory_and_embedded_report() -> None: case = BenchmarkCase( rows=500, @@ -64,11 +71,82 @@ def test_worker_main_writes_a_strict_schema_valid_result(tmp_path) -> None: worker_main(str(case_path), str(result_path), "unit-test worker") raw_payload = result_path.read_text(encoding="utf-8") - payload = json.loads( - raw_payload, - parse_constant=lambda value: (_ for _ in ()).throw(ValueError(value)), - ) + payload = json.loads(raw_payload, parse_constant=_reject_json_constant) validate_result(payload) result = BenchmarkResult.from_dict(payload) assert result.status == "completed" assert result.command == "unit-test worker" + + +@pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"]) +def test_worker_main_rejects_non_standard_case_json_constants(tmp_path, constant: str) -> None: + case = BenchmarkCase( + rows=100, + width="narrow", + config_name="invalid-json", + options={"bad": "__NON_FINITE__"}, + warmups=0, + repetitions=1, + ) + case_path = tmp_path / "case.json" + result_path = tmp_path / "result.json" + case_json = json.dumps(asdict(case)).replace('"__NON_FINITE__"', constant) + case_path.write_text(case_json, encoding="utf-8") + + with pytest.raises(ValueError, match="case JSON contains non-standard constant"): + worker_main(str(case_path), str(result_path), "unit-test worker") + + assert not result_path.exists() + + +def test_worker_subprocesses_preserve_report_mode_fingerprints(tmp_path) -> None: + base = BenchmarkCase( + rows=100, + width="narrow", + config_name="default", + options={"verbose": False}, + warmups=0, + repetitions=1, + ) + payloads = [] + worker_script = ( + "from benchmarks.performance.worker import worker_main; " + "worker_main(__import__('sys').argv[1], __import__('sys').argv[2], " + "__import__('sys').argv[3])" + ) + + for index, case in enumerate((base, replace(base, return_report=True))): + case_path = tmp_path / f"case-{index}.json" + result_path = tmp_path / f"result-{index}.json" + case_path.write_text( + json.dumps(asdict(case), allow_nan=False), + encoding="utf-8", + ) + completed = subprocess.run( + [ + sys.executable, + "-c", + worker_script, + str(case_path), + str(result_path), + "unit-test subprocess", + ], + timeout=60, + capture_output=True, + text=True, + check=False, + ) + assert completed.returncode == 0, completed.stderr + payload = json.loads( + result_path.read_text(encoding="utf-8"), + parse_constant=_reject_json_constant, + ) + validate_result(payload) + payloads.append(payload) + + without_report, with_report = payloads + assert without_report["status"] == with_report["status"] == "completed" + assert without_report["output_fingerprint"] == with_report["output_fingerprint"] + assert without_report["report_fingerprint"] == with_report["report_fingerprint"] + assert without_report["result_type"] == "CleanResult" + assert with_report["result_type"] == "tuple[CleanResult,CleanReport]" From 7a03dda2b53c30b27d2cc6ae893284ed5e474b6c Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 21:50:09 +0530 Subject: [PATCH 15/37] bench: add configurable subprocess matrix runner --- benchmarks/performance/__main__.py | 3 + benchmarks/performance/cli.py | 62 +++++++ benchmarks/performance/runner.py | 265 +++++++++++++++++++++++++++ tests/performance/test_runner_cli.py | 223 ++++++++++++++++++++++ 4 files changed, 553 insertions(+) create mode 100644 benchmarks/performance/__main__.py create mode 100644 benchmarks/performance/cli.py create mode 100644 benchmarks/performance/runner.py create mode 100644 tests/performance/test_runner_cli.py diff --git a/benchmarks/performance/__main__.py b/benchmarks/performance/__main__.py new file mode 100644 index 0000000..eb53e2f --- /dev/null +++ b/benchmarks/performance/__main__.py @@ -0,0 +1,3 @@ +from .cli import main + +raise SystemExit(main()) diff --git a/benchmarks/performance/cli.py b/benchmarks/performance/cli.py new file mode 100644 index 0000000..d9d96be --- /dev/null +++ b/benchmarks/performance/cli.py @@ -0,0 +1,62 @@ +from __future__ import annotations + +import argparse +from collections import Counter +from pathlib import Path + +from .runner import expand_cases, run_matrix + + +def _comma_separated(value: str) -> list[str]: + return value.split(",") + + +def _report_modes(value: str) -> list[bool]: + modes = _comma_separated(value) + if any(mode not in {"false", "true"} for mode in modes): + raise argparse.ArgumentTypeError("report modes must be 'false' or 'true'") + return [mode == "true" for mode in modes] + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(prog="python -m benchmarks.performance") + subcommands = parser.add_subparsers(dest="subcommand", required=True) + run = subcommands.add_parser("run") + run.add_argument("--rows", default="10000,100000,500000,1000000") + run.add_argument("--widths", default="narrow,medium,wide") + run.add_argument("--dataset-types", default="mixed") + run.add_argument( + "--configs", + default="default,conservative,representation_off,statistical_off,explicit", + ) + run.add_argument("--report-modes", default="false,true") + run.add_argument("--backends", default="pandas") + run.add_argument("--output-formats", default="pandas") + run.add_argument("--seed", type=int, default=42) + run.add_argument("--warmups", type=int, default=1) + run.add_argument("--repetitions", type=int, default=5) + run.add_argument("--timeout", type=int, default=1800) + run.add_argument("--output", required=True) + return parser + + +def main(argv: list[str] | None = None) -> int: + arguments = _parser().parse_args(argv) + cases = expand_cases( + rows=[int(value) for value in _comma_separated(arguments.rows)], + widths=_comma_separated(arguments.widths), + dataset_types=_comma_separated(arguments.dataset_types), + configs=_comma_separated(arguments.configs), + report_modes=_report_modes(arguments.report_modes), + backends=_comma_separated(arguments.backends), + output_formats=_comma_separated(arguments.output_formats), + seed=arguments.seed, + warmups=arguments.warmups, + repetitions=arguments.repetitions, + ) + results = run_matrix(cases, Path(arguments.output), arguments.timeout) + for result in results: + print(f"{result.case.case_id} {result.status}") + counts = Counter(result.status for result in results) + print(" ".join(f"{status}={counts[status]}" for status in sorted(counts))) + return 0 if all(result.status in {"completed", "skipped"} for result in results) else 1 diff --git a/benchmarks/performance/runner.py b/benchmarks/performance/runner.py new file mode 100644 index 0000000..3b5d92f --- /dev/null +++ b/benchmarks/performance/runner.py @@ -0,0 +1,265 @@ +from __future__ import annotations + +import json +import shlex +import subprocess +import sys +import tempfile +from dataclasses import asdict +from itertools import product +from pathlib import Path +from typing import Any + +from jsonschema.exceptions import ValidationError + +from .environment import capture_environment +from .models import BenchmarkCase, BenchmarkResult +from .schema import validate_result + +CONFIGS = { + "default": {"verbose": False}, + "conservative": {"strategy": "conservative", "verbose": False}, + "representation_off": { + "strategy": "conservative", + "column_names": False, + "strip_whitespace": False, + "normalize_sentinels": False, + "fix_dtypes": False, + "drop_duplicates": False, + "verbose": False, + }, + "statistical_off": { + "strategy": "conservative", + "impute": None, + "outliers": None, + "verbose": False, + }, + "explicit": { + "strategy": "conservative", + "impute": "median", + "outliers": "flag", + "verbose": False, + }, + "aggressive": {"strategy": "aggressive", "verbose": False}, + "semantic": {"semantic_mode": "assist", "verbose": False}, + "missforest": { + "strategy": "conservative", + "impute": "missforest", + "verbose": False, + }, +} + +_WORKER_SCRIPT = ( + "from benchmarks.performance.worker import worker_main; " + "worker_main(__import__('sys').argv[1], __import__('sys').argv[2], " + "__import__('sys').argv[3])" +) + + +def expand_cases( + *, + rows: list[int], + widths: list[str], + dataset_types: list[str], + configs: list[str], + report_modes: list[bool], + backends: list[str], + output_formats: list[str], + seed: int, + warmups: int, + repetitions: int, +) -> list[BenchmarkCase]: + return [ + BenchmarkCase( + rows=row_count, + width=width, + config_name=config_name, + options=dict(CONFIGS[config_name]), + dataset_type=dataset_type, + return_report=return_report, + backend=backend, + output_format=output_format, + seed=seed, + warmups=warmups, + repetitions=repetitions, + ) + for ( + row_count, + width, + dataset_type, + config_name, + return_report, + backend, + output_format, + ) in product( + rows, + widths, + dataset_types, + configs, + report_modes, + backends, + output_formats, + ) + ] + + +def _reject_non_standard_json_constant(value: str) -> None: + raise ValueError(f"result JSON contains non-standard constant: {value}") + + +def _write_result(output_path: Path, result: BenchmarkResult) -> None: + payload = result.to_dict() + validate_result(payload) + output_path.write_text( + json.dumps(payload, indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) + + +def _guard_existing_result(output_path: Path, case: BenchmarkCase) -> None: + if not output_path.exists(): + return + try: + payload = json.loads( + output_path.read_text(encoding="utf-8"), + parse_constant=_reject_non_standard_json_constant, + ) + except (OSError, ValueError) as exc: + raise RuntimeError(f"existing result cannot be verified: {output_path}") from exc + if not isinstance(payload, dict) or payload.get("case") != asdict(case): + raise RuntimeError(f"case ID collision for existing result: {output_path}") + + +def _failure_result( + *, + case: BenchmarkCase, + status: str, + command: str, + error_type: str, + error_message: str, +) -> BenchmarkResult: + return BenchmarkResult( + schema_version=1, + status=status, + case=case, + environment=capture_environment(), + command=command, + error_type=error_type, + error_message=error_message, + ) + + +def _text(value: str | bytes | None) -> str: + if value is None: + return "" + if isinstance(value, bytes): + return value.decode(errors="replace") + return value + + +def _load_result(result_text: str) -> BenchmarkResult: + payload: Any = json.loads( + result_text, + parse_constant=_reject_non_standard_json_constant, + ) + if not isinstance(payload, dict): + raise TypeError("result JSON must be an object") + validate_result(payload) + return BenchmarkResult.from_dict(payload) + + +def run_case_subprocess( + case: BenchmarkCase, output_dir: Path, timeout_seconds: int +) -> BenchmarkResult: + output_dir.mkdir(parents=True, exist_ok=True) + output_path = output_dir / f"{case.case_id}.json" + _guard_existing_result(output_path, case) + with tempfile.TemporaryDirectory(prefix="freshdata-benchmark-") as temporary_dir: + temporary_path = Path(temporary_dir) + case_path = temporary_path / "case.json" + result_path = temporary_path / "result.json" + worker_command = [ + sys.executable, + "-c", + _WORKER_SCRIPT, + str(case_path), + str(result_path), + ] + command = shlex.join(worker_command) + worker_command.append(command) + case_path.write_text( + json.dumps(asdict(case), indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) + try: + completed = subprocess.run( + worker_command, + timeout=timeout_seconds, + capture_output=True, + text=True, + check=False, + ) + except subprocess.TimeoutExpired as exc: + result = _failure_result( + case=case, + status="timeout", + command=command, + error_type="TimeoutExpired", + error_message=str(exc), + ) + _write_result(output_path, result) + return result + + result_text = result_path.read_text(encoding="utf-8") if result_path.exists() else "" + process_output = "\n".join( + part + for part in (_text(completed.stdout), _text(completed.stderr), result_text) + if part + ) + if "MemoryError" in process_output: + result = _failure_result( + case=case, + status="oom", + command=command, + error_type="MemoryError", + error_message=process_output, + ) + elif completed.returncode != 0: + message = _text(completed.stderr) or _text(completed.stdout) + result = _failure_result( + case=case, + status="failed", + command=command, + error_type="ChildProcessError", + error_message=message or f"worker exited with code {completed.returncode}", + ) + elif not result_text: + result = _failure_result( + case=case, + status="failed", + command=command, + error_type="FileNotFoundError", + error_message="worker did not write a result file", + ) + else: + try: + result = _load_result(result_text) + except (TypeError, ValueError, ValidationError) as exc: + result = _failure_result( + case=case, + status="failed", + command=command, + error_type=type(exc).__name__, + error_message=str(exc), + ) + _write_result(output_path, result) + return result + + +def run_matrix( + cases: list[BenchmarkCase], output_dir: Path, timeout_seconds: int +) -> list[BenchmarkResult]: + case_ids = [case.case_id for case in cases] + if len(case_ids) != len(set(case_ids)): + raise ValueError("input matrix contains duplicate case IDs") + return [run_case_subprocess(case, output_dir, timeout_seconds) for case in cases] diff --git a/tests/performance/test_runner_cli.py b/tests/performance/test_runner_cli.py new file mode 100644 index 0000000..1a27180 --- /dev/null +++ b/tests/performance/test_runner_cli.py @@ -0,0 +1,223 @@ +from __future__ import annotations + +import json +import subprocess +import sys +from dataclasses import asdict +from pathlib import Path + +import pytest +from benchmarks.performance.cli import main +from benchmarks.performance.models import BenchmarkCase +from benchmarks.performance.runner import expand_cases, run_case_subprocess, run_matrix +from benchmarks.performance.schema import validate_result + + +def _case(**overrides: object) -> BenchmarkCase: + arguments = { + "rows": 100, + "width": "narrow", + "config_name": "default", + "options": {"verbose": False}, + "warmups": 0, + "repetitions": 1, + } + arguments.update(overrides) + return BenchmarkCase(**arguments) # type: ignore[arg-type] + + +def test_expand_cases_crosses_required_dimensions() -> None: + cases = expand_cases( + rows=[10_000, 100_000], + widths=["narrow", "wide"], + dataset_types=["mixed"], + configs=["default", "conservative"], + report_modes=[False, True], + backends=["pandas"], + output_formats=["pandas"], + seed=42, + warmups=1, + repetitions=5, + ) + assert len(cases) == 16 + assert len({case.case_id for case in cases}) == 16 + + +def test_cli_small_matrix_writes_valid_result(tmp_path) -> None: + exit_code = main( + [ + "run", + "--rows", + "250", + "--widths", + "narrow", + "--configs", + "default", + "--report-modes", + "false", + "--repetitions", + "1", + "--warmups", + "0", + "--timeout", + "60", + "--output", + str(tmp_path), + ] + ) + assert exit_code == 0 + payloads = [json.loads(path.read_text()) for path in tmp_path.glob("*.json")] + assert len(payloads) == 1 + assert payloads[0]["status"] == "completed" + + +def test_timeout_writes_a_schema_valid_result_with_exact_command(tmp_path) -> None: + result = run_case_subprocess(_case(), tmp_path, timeout_seconds=0) + + payload = json.loads((tmp_path / f"{result.case.case_id}.json").read_text()) + validate_result(payload) + assert result.status == "timeout" + assert result.error_type == "TimeoutExpired" + assert result.command == payload["command"] + assert result.command.startswith(str(Path(sys.executable))) + assert "worker_main" in result.command + + +@pytest.mark.parametrize( + "stderr,expected_status,expected_error_type", + [ + ("worker failed", "failed", "ChildProcessError"), + ("Traceback: MemoryError", "oom", "MemoryError"), + ], +) +def test_nonzero_worker_exit_writes_failure_record( + tmp_path, monkeypatch, stderr: str, expected_status: str, expected_error_type: str +) -> None: + def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 1, stdout="", stderr=stderr) + + monkeypatch.setattr(subprocess, "run", fake_run) + + result = run_case_subprocess(_case(), tmp_path, timeout_seconds=60) + + payload = json.loads((tmp_path / f"{result.case.case_id}.json").read_text()) + validate_result(payload) + assert result.status == expected_status + assert result.error_type == expected_error_type + assert result.error_message == stderr + + +def test_missing_worker_result_writes_failure_record(tmp_path, monkeypatch) -> None: + def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 0, stdout="", stderr="") + + monkeypatch.setattr(subprocess, "run", fake_run) + + result = run_case_subprocess(_case(), tmp_path, timeout_seconds=60) + + payload = json.loads((tmp_path / f"{result.case.case_id}.json").read_text()) + validate_result(payload) + assert result.status == "failed" + assert result.error_type == "FileNotFoundError" + + +def test_result_text_containing_memory_error_is_recorded_as_oom(tmp_path, monkeypatch) -> None: + real_run = subprocess.run + + def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]: + if command[0] != sys.executable: + return real_run(command, **kwargs) # type: ignore[call-overload] + Path(command[4]).write_text("MemoryError: allocation failed", encoding="utf-8") + return subprocess.CompletedProcess(command, 0, stdout="", stderr="") + + monkeypatch.setattr(subprocess, "run", fake_run) + + result = run_case_subprocess(_case(), tmp_path, timeout_seconds=60) + + assert result.status == "oom" + assert result.error_type == "MemoryError" + validate_result(json.loads((tmp_path / f"{result.case.case_id}.json").read_text())) + + +def test_matrix_continues_after_failure(tmp_path) -> None: + cases = [_case(backend="unsupported"), _case(rows=101)] + + results = run_matrix(cases, tmp_path, timeout_seconds=60) + + assert [result.status for result in results] == ["failed", "completed"] + assert len(list(tmp_path.glob("*.json"))) == 2 + + +def test_matrix_continues_after_schema_invalid_worker_result(tmp_path, monkeypatch) -> None: + real_run = subprocess.run + calls = 0 + + def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]: + nonlocal calls + calls += 1 + if calls == 1: + Path(command[4]).write_text("{}", encoding="utf-8") + return subprocess.CompletedProcess(command, 0, stdout="", stderr="") + return real_run(command, **kwargs) # type: ignore[call-overload] + + monkeypatch.setattr(subprocess, "run", fake_run) + + results = run_matrix([_case(), _case(rows=101)], tmp_path, timeout_seconds=60) + + assert [result.status for result in results] == ["failed", "completed"] + assert results[0].error_type == "ValidationError" + assert len(list(tmp_path.glob("*.json"))) == 2 + + +def test_matrix_rejects_duplicate_case_ids(tmp_path) -> None: + case = _case() + + with pytest.raises(ValueError, match="duplicate case IDs"): + run_matrix([case, case], tmp_path, timeout_seconds=60) + + +def test_existing_semantically_different_result_is_not_overwritten(tmp_path, monkeypatch) -> None: + case = _case() + output_path = tmp_path / f"{case.case_id}.json" + original = json.dumps({"case": asdict(_case(rows=999))}) + output_path.write_text(original, encoding="utf-8") + + def unexpected_run(command: list[str], **kwargs: object) -> None: + raise AssertionError("worker must not start for a case ID collision") + + monkeypatch.setattr(subprocess, "run", unexpected_run) + + with pytest.raises(RuntimeError, match="case ID collision"): + run_case_subprocess(case, tmp_path, timeout_seconds=60) + + assert output_path.read_text(encoding="utf-8") == original + + +def test_cli_returns_failure_only_after_all_cases_finish(tmp_path, capsys) -> None: + exit_code = main( + [ + "run", + "--rows", + "100,101", + "--widths", + "narrow", + "--configs", + "default", + "--report-modes", + "false", + "--backends", + "unsupported", + "--repetitions", + "1", + "--warmups", + "0", + "--timeout", + "60", + "--output", + str(tmp_path), + ] + ) + + assert exit_code == 1 + assert len(list(tmp_path.glob("*.json"))) == 2 + assert capsys.readouterr().out.count(" failed\n") == 2 From 338c4c64aab9394e92e6a1f3d86701477fddcce1 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 21:56:44 +0530 Subject: [PATCH 16/37] fix: contain benchmark result read failures --- benchmarks/performance/runner.py | 30 ++++++----- tests/performance/test_runner_cli.py | 80 ++++++++++++++++++++++++++++ 2 files changed, 96 insertions(+), 14 deletions(-) diff --git a/benchmarks/performance/runner.py b/benchmarks/performance/runner.py index 3b5d92f..0caed18 100644 --- a/benchmarks/performance/runner.py +++ b/benchmarks/performance/runner.py @@ -210,7 +210,17 @@ def run_case_subprocess( _write_result(output_path, result) return result - result_text = result_path.read_text(encoding="utf-8") if result_path.exists() else "" + result_text = "" + loaded_result: BenchmarkResult | None = None + result_error: Exception | None = None + try: + if not result_path.exists(): + raise FileNotFoundError("worker did not write a result file") + result_text = result_path.read_text(encoding="utf-8") + loaded_result = _load_result(result_text) + except (OSError, TypeError, ValueError, ValidationError) as exc: + result_error = exc + process_output = "\n".join( part for part in (_text(completed.stdout), _text(completed.stderr), result_text) @@ -233,25 +243,17 @@ def run_case_subprocess( error_type="ChildProcessError", error_message=message or f"worker exited with code {completed.returncode}", ) - elif not result_text: + elif result_error is not None: result = _failure_result( case=case, status="failed", command=command, - error_type="FileNotFoundError", - error_message="worker did not write a result file", + error_type=type(result_error).__name__, + error_message=str(result_error), ) else: - try: - result = _load_result(result_text) - except (TypeError, ValueError, ValidationError) as exc: - result = _failure_result( - case=case, - status="failed", - command=command, - error_type=type(exc).__name__, - error_message=str(exc), - ) + assert loaded_result is not None + result = loaded_result _write_result(output_path, result) return result diff --git a/tests/performance/test_runner_cli.py b/tests/performance/test_runner_cli.py index 1a27180..5f1d49d 100644 --- a/tests/performance/test_runner_cli.py +++ b/tests/performance/test_runner_cli.py @@ -1,6 +1,7 @@ from __future__ import annotations import json +import shlex import subprocess import sys from dataclasses import asdict @@ -83,6 +84,46 @@ def test_timeout_writes_a_schema_valid_result_with_exact_command(tmp_path) -> No assert "worker_main" in result.command +def test_worker_subprocess_receives_exact_argv_and_options(tmp_path, monkeypatch) -> None: + captured: dict[str, object] = {} + real_run = subprocess.run + + def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]: + if command[0] != sys.executable: + return real_run(command, **kwargs) # type: ignore[call-overload] + captured["command"] = command + captured["kwargs"] = kwargs + return subprocess.CompletedProcess(command, 0, stdout="", stderr="") + + monkeypatch.setattr(subprocess, "run", fake_run) + + run_case_subprocess(_case(), tmp_path, timeout_seconds=37) + + command = captured["command"] + assert isinstance(command, list) + worker_script = ( + "from benchmarks.performance.worker import worker_main; " + "worker_main(__import__('sys').argv[1], __import__('sys').argv[2], " + "__import__('sys').argv[3])" + ) + assert command == [ + sys.executable, + "-c", + worker_script, + command[3], + command[4], + shlex.join(command[:5]), + ] + assert Path(command[3]).name == "case.json" + assert Path(command[4]).name == "result.json" + assert captured["kwargs"] == { + "timeout": 37, + "capture_output": True, + "text": True, + "check": False, + } + + @pytest.mark.parametrize( "stderr,expected_status,expected_error_type", [ @@ -169,6 +210,45 @@ def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProces assert len(list(tmp_path.glob("*.json"))) == 2 +def test_matrix_continues_after_invalid_utf8_worker_result(tmp_path, monkeypatch) -> None: + real_run = subprocess.run + calls = 0 + + def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]: + nonlocal calls + calls += 1 + if calls == 1: + Path(command[4]).write_bytes(b"\xff") + return subprocess.CompletedProcess(command, 0, stdout="", stderr="") + return real_run(command, **kwargs) # type: ignore[call-overload] + + monkeypatch.setattr(subprocess, "run", fake_run) + + results = run_matrix([_case(), _case(rows=101)], tmp_path, timeout_seconds=60) + + assert [result.status for result in results] == ["failed", "completed"] + assert results[0].error_type == "UnicodeDecodeError" + validate_result(json.loads((tmp_path / f"{results[0].case.case_id}.json").read_text())) + + +def test_matrix_continues_after_worker_result_read_error(tmp_path, monkeypatch) -> None: + real_read_text = Path.read_text + + def fake_read_text(path: Path, *args: object, **kwargs: object) -> str: + if path.name == "result.json": + monkeypatch.setattr(Path, "read_text", real_read_text) + raise PermissionError("result cannot be read") + return real_read_text(path, *args, **kwargs) # type: ignore[arg-type] + + monkeypatch.setattr(Path, "read_text", fake_read_text) + + results = run_matrix([_case(), _case(rows=101)], tmp_path, timeout_seconds=60) + + assert [result.status for result in results] == ["failed", "completed"] + assert results[0].error_type == "PermissionError" + validate_result(json.loads((tmp_path / f"{results[0].case.case_id}.json").read_text())) + + def test_matrix_rejects_duplicate_case_ids(tmp_path) -> None: case = _case() From 5742c481dde013410a49a0433d62931cae8f3bc4 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sat, 11 Jul 2026 22:16:57 +0530 Subject: [PATCH 17/37] bench: profile stages allocations and pandas operations --- benchmarks/performance/cli.py | 77 ++++++-- benchmarks/performance/instrumentation.py | 195 +++++++++++++++++++ benchmarks/performance/models.py | 12 +- benchmarks/performance/schema.py | 56 ++++++ benchmarks/performance/worker.py | 8 + tests/performance/test_instrumentation.py | 219 ++++++++++++++++++++++ 6 files changed, 553 insertions(+), 14 deletions(-) create mode 100644 benchmarks/performance/instrumentation.py create mode 100644 tests/performance/test_instrumentation.py diff --git a/benchmarks/performance/cli.py b/benchmarks/performance/cli.py index d9d96be..1eb6ebf 100644 --- a/benchmarks/performance/cli.py +++ b/benchmarks/performance/cli.py @@ -1,10 +1,15 @@ from __future__ import annotations import argparse +import json +import shlex +import sys from collections import Counter from pathlib import Path from .runner import expand_cases, run_matrix +from .schema import validate_result +from .worker import execute_profile_case def _comma_separated(value: str) -> list[str]: @@ -22,26 +27,54 @@ def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(prog="python -m benchmarks.performance") subcommands = parser.add_subparsers(dest="subcommand", required=True) run = subcommands.add_parser("run") - run.add_argument("--rows", default="10000,100000,500000,1000000") - run.add_argument("--widths", default="narrow,medium,wide") - run.add_argument("--dataset-types", default="mixed") - run.add_argument( - "--configs", - default="default,conservative,representation_off,statistical_off,explicit", + _add_case_arguments( + run, + rows="10000,100000,500000,1000000", + widths="narrow,medium,wide", + configs="default,conservative,representation_off,statistical_off,explicit", + report_modes="false,true", ) - run.add_argument("--report-modes", default="false,true") - run.add_argument("--backends", default="pandas") - run.add_argument("--output-formats", default="pandas") - run.add_argument("--seed", type=int, default=42) - run.add_argument("--warmups", type=int, default=1) - run.add_argument("--repetitions", type=int, default=5) run.add_argument("--timeout", type=int, default=1800) run.add_argument("--output", required=True) + + profile = subcommands.add_parser("profile") + _add_case_arguments( + profile, + rows="10000", + widths="narrow", + configs="default", + report_modes="false", + ) + profile.add_argument("--output", required=True) return parser +def _add_case_arguments( + parser: argparse.ArgumentParser, + *, + rows: str, + widths: str, + configs: str, + report_modes: str, +) -> None: + parser.add_argument("--rows", default=rows) + parser.add_argument("--widths", default=widths) + parser.add_argument("--dataset-types", default="mixed") + parser.add_argument( + "--configs", + default=configs, + ) + parser.add_argument("--report-modes", default=report_modes) + parser.add_argument("--backends", default="pandas") + parser.add_argument("--output-formats", default="pandas") + parser.add_argument("--seed", type=int, default=42) + parser.add_argument("--warmups", type=int, default=1) + parser.add_argument("--repetitions", type=int, default=5) + + def main(argv: list[str] | None = None) -> int: - arguments = _parser().parse_args(argv) + parser = _parser() + arguments = parser.parse_args(argv) cases = expand_cases( rows=[int(value) for value in _comma_separated(arguments.rows)], widths=_comma_separated(arguments.widths), @@ -54,6 +87,24 @@ def main(argv: list[str] | None = None) -> int: warmups=arguments.warmups, repetitions=arguments.repetitions, ) + if arguments.subcommand == "profile": + if len(cases) != 1: + parser.error("profile requires exactly one benchmark case") + output_dir = Path(arguments.output) + output_dir.mkdir(parents=True, exist_ok=True) + raw_arguments = argv if argv is not None else sys.argv[1:] + command = shlex.join([sys.executable, "-m", "benchmarks.performance", *raw_arguments]) + result = execute_profile_case(cases[0], command=command) + payload = result.to_dict() + validate_result(payload) + output_path = output_dir / f"{cases[0].case_id}.profile.json" + output_path.write_text( + json.dumps(payload, indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) + print(f"{result.case.case_id} {result.status}") + return 0 + results = run_matrix(cases, Path(arguments.output), arguments.timeout) for result in results: print(f"{result.case.case_id} {result.status}") diff --git a/benchmarks/performance/instrumentation.py b/benchmarks/performance/instrumentation.py new file mode 100644 index 0000000..15e4203 --- /dev/null +++ b/benchmarks/performance/instrumentation.py @@ -0,0 +1,195 @@ +from __future__ import annotations + +import cProfile +import pstats +import tracemalloc +from collections import Counter +from contextlib import ExitStack +from dataclasses import dataclass +from functools import wraps +from types import TracebackType +from typing import Callable +from unittest.mock import patch + +import pandas as pd + +import freshdata as fd + +from .datasets import DatasetSpec, make_mixed_frame +from .models import BenchmarkCase + + +@dataclass(frozen=True) +class ProfileResult: + functions: list[dict[str, object]] + allocations: list[dict[str, object]] + stages: dict[str, float] + operations: dict[str, int] + + +class OperationCounter: + """Observe Python-level pandas method calls made inside the context.""" + + METHODS = { + "dataframe.copy": (pd.DataFrame, "copy"), + "series.copy": (pd.Series, "copy"), + "series.isna": (pd.Series, "isna"), + "series.notna": (pd.Series, "notna"), + "series.nunique": (pd.Series, "nunique"), + "series.value_counts": (pd.Series, "value_counts"), + "series.astype": (pd.Series, "astype"), + "dataframe.astype": (pd.DataFrame, "astype"), + "dataframe.corr": (pd.DataFrame, "corr"), + "dataframe.corrwith": (pd.DataFrame, "corrwith"), + } + + def __init__(self) -> None: + self.counts: Counter[str] = Counter(dict.fromkeys(self.METHODS, 0)) + self._stack: ExitStack | None = None + + def __enter__(self) -> OperationCounter: + if self._stack is not None: + raise RuntimeError("OperationCounter is already active") + stack = ExitStack() + try: + for key, (owner, method_name) in self.METHODS.items(): + original = getattr(owner, method_name) + + @wraps(original) + def observed( + instance: object, + *args: object, + _key: str = key, + _original: Callable[..., object] = original, + **kwargs: object, + ) -> object: + self.counts[_key] += 1 + return _original(instance, *args, **kwargs) + + stack.enter_context(patch.object(owner, method_name, observed)) + except BaseException: + stack.close() + raise + self._stack = stack + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + assert self._stack is not None + try: + self._stack.__exit__(exc_type, exc_value, traceback) + finally: + self._stack = None + + +STAGE_RULES = { + "context": ("engine/context.py",), + "engine_cache": ("engine/cache.py",), + "correlation": ("numeric_corr_matrix", "corr", "corrwith"), + "missing": ("engine/missing.py", "steps/missing.py"), + "outliers": ("engine/outliers.py", "steps/outliers.py"), + "role_inference": ("infer_role", "build_context"), + "dtype_repair": ("steps/dtypes.py",), + "duplicates": ("steps/duplicates.py",), + "audit_events": ("report.py", "cleanreport.add"), + "report_finalization": ("cleaner.py", "memory_bytes"), + "semantic_ml": ("semantic/", "imputation/missforest.py", "sklearn/"), + "backend_conversion": ("adapters/", "execution/backends/"), +} + + +def _function_records( + stats: pstats.Stats, +) -> tuple[list[dict[str, object]], dict[str, float]]: + records: list[dict[str, object]] = [] + stages = dict.fromkeys(STAGE_RULES, 0.0) + total = 0.0 + for (filename, line, function), ( + _primitive, + calls, + self_time, + cumulative, + _callers, + ) in stats.stats.items(): + record = { + "file": filename, + "line": line, + "function": function, + "self_seconds": self_time, + "cumulative_seconds": cumulative, + "calls": calls, + } + records.append(record) + total += self_time + normalized = f"{filename.replace(chr(92), '/')}:{function}".lower() + for stage, rules in STAGE_RULES.items(): + if any(rule in normalized for rule in rules): + stages[stage] += self_time + break + records.sort(key=lambda item: float(item["cumulative_seconds"]), reverse=True) + stages["total"] = total + return records[:100], stages + + +def _allocation_records(snapshot: tracemalloc.Snapshot) -> list[dict[str, object]]: + records: list[dict[str, object]] = [] + for statistic in snapshot.statistics("lineno"): + frame = statistic.traceback[0] + normalized = frame.filename.replace("\\", "/") + if "/freshdata/" not in normalized and "/benchmarks/performance/" not in normalized: + continue + records.append( + { + "file": frame.filename, + "line": frame.lineno, + "bytes": statistic.size, + "count": statistic.count, + } + ) + if len(records) == 100: + break + return records + + +def profile_case(case: BenchmarkCase) -> ProfileResult: + frame = make_mixed_frame( + DatasetSpec( + rows=case.rows, + width=case.width, + seed=case.seed, + dataset_type=case.dataset_type, + ) + ) + profiler = cProfile.Profile() + was_tracing = tracemalloc.is_tracing() + if not was_tracing: + tracemalloc.start() + try: + with OperationCounter() as counter: + profiler.enable() + try: + fd.clean( + frame, + config=case.options, + return_report=case.return_report, + engine=case.backend, + output_format=case.output_format, + ) + finally: + profiler.disable() + snapshot = tracemalloc.take_snapshot() + finally: + if not was_tracing: + tracemalloc.stop() + + functions, stages = _function_records(pstats.Stats(profiler)) + return ProfileResult( + functions=functions, + allocations=_allocation_records(snapshot), + stages=stages, + operations=dict(counter.counts), + ) diff --git a/benchmarks/performance/models.py b/benchmarks/performance/models.py index 4d4b951..e235adf 100644 --- a/benchmarks/performance/models.py +++ b/benchmarks/performance/models.py @@ -5,7 +5,10 @@ import math import statistics from dataclasses import asdict, dataclass, field -from typing import Any, Dict, List, Union # noqa: UP035 +from typing import TYPE_CHECKING, Any, Dict, List, Union # noqa: UP035 + +if TYPE_CHECKING: + from .instrumentation import ProfileResult JsonValue = Union[ None, @@ -142,6 +145,7 @@ class BenchmarkResult: output_fingerprint: str | None = None report_fingerprint: str | None = None result_type: str | None = None + profile: ProfileResult | None = None @classmethod def completed( @@ -157,6 +161,7 @@ def completed( output_fingerprint: str | None = None, report_fingerprint: str | None = None, result_type: str | None = None, + profile: ProfileResult | None = None, ) -> BenchmarkResult: if not samples_seconds: raise ValueError("samples_seconds must not be empty") @@ -211,6 +216,7 @@ def completed( output_fingerprint=output_fingerprint, report_fingerprint=report_fingerprint, result_type=result_type, + profile=profile, ) def to_dict(self) -> dict[str, Any]: @@ -223,4 +229,8 @@ def from_dict(cls, payload: dict[str, Any]) -> BenchmarkResult: data = dict(payload) data["case"] = BenchmarkCase(**data["case"]) data["environment"] = EnvironmentInfo(**data["environment"]) + if isinstance(data.get("profile"), dict): + from .instrumentation import ProfileResult # noqa: PLC0415 + + data["profile"] = ProfileResult(**data["profile"]) return cls(**data) diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py index b33ff59..cbc94f9 100644 --- a/benchmarks/performance/schema.py +++ b/benchmarks/performance/schema.py @@ -159,6 +159,62 @@ "output_fingerprint": {"type": ["string", "null"]}, "report_fingerprint": {"type": ["string", "null"]}, "result_type": {"type": ["string", "null"]}, + "profile": { + "type": ["object", "null"], + "additionalProperties": False, + "required": ["functions", "allocations", "stages", "operations"], + "properties": { + "functions": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": False, + "required": [ + "file", + "line", + "function", + "self_seconds", + "cumulative_seconds", + "calls", + ], + "properties": { + "file": {"type": "string"}, + "line": {"type": "integer", "minimum": 0}, + "function": {"type": "string"}, + "self_seconds": {"type": "number", "minimum": 0}, + "cumulative_seconds": {"type": "number", "minimum": 0}, + "calls": {"type": "integer", "minimum": 0}, + }, + }, + }, + "allocations": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": False, + "required": ["file", "line", "bytes", "count"], + "properties": { + "file": {"type": "string"}, + "line": {"type": "integer", "minimum": 0}, + "bytes": {"type": "integer", "minimum": 0}, + "count": {"type": "integer", "minimum": 0}, + }, + }, + }, + "stages": { + "type": "object", + "additionalProperties": {"type": "number", "minimum": 0}, + }, + "operations": { + "description": ( + "Observed Python pandas method calls; these are not physical " + "buffer-copy counts." + ), + "type": "object", + "additionalProperties": {"type": "integer", "minimum": 0}, + }, + }, + }, }, } diff --git a/benchmarks/performance/worker.py b/benchmarks/performance/worker.py index cf752ef..51ad60e 100644 --- a/benchmarks/performance/worker.py +++ b/benchmarks/performance/worker.py @@ -5,6 +5,7 @@ import json import time import tracemalloc +from dataclasses import replace from pathlib import Path from typing import Any, NoReturn @@ -102,6 +103,13 @@ def execute_case(case: BenchmarkCase, *, command: str) -> BenchmarkResult: ) +def execute_profile_case(case: BenchmarkCase, *, command: str) -> BenchmarkResult: + from .instrumentation import profile_case # noqa: PLC0415 + + result = execute_case(case, command=command) + return replace(result, profile=profile_case(case)) + + def worker_main(case_path: str, result_path: str, command: str) -> None: case_payload = json.loads( Path(case_path).read_text(encoding="utf-8"), diff --git a/tests/performance/test_instrumentation.py b/tests/performance/test_instrumentation.py new file mode 100644 index 0000000..b280015 --- /dev/null +++ b/tests/performance/test_instrumentation.py @@ -0,0 +1,219 @@ +from __future__ import annotations + +import json +from dataclasses import asdict + +import jsonschema +import pandas as pd +import pytest +from benchmarks.performance.cli import main +from benchmarks.performance.environment import capture_environment +from benchmarks.performance.instrumentation import OperationCounter, profile_case +from benchmarks.performance.models import BenchmarkCase, BenchmarkResult +from benchmarks.performance.schema import validate_result + + +def _case() -> BenchmarkCase: + return BenchmarkCase( + rows=500, + width="narrow", + config_name="default", + options={"verbose": False}, + warmups=0, + repetitions=1, + ) + + +def test_operation_counter_observes_copy_scan_and_conversion_calls() -> None: + frame = pd.DataFrame({"a": [1, None, 3], "b": ["1", "2", "3"]}) + with OperationCounter() as counter: + frame.copy(deep=False) + frame["a"].isna() + frame["a"].nunique(dropna=True) + frame["b"].astype("string") + assert counter.counts["dataframe.copy"] == 1 + assert counter.counts["series.isna"] >= 1 + assert counter.counts["series.nunique"] == 1 + assert counter.counts["series.astype"] == 1 + + +def test_operation_counter_restores_every_method_after_exception() -> None: + originals = { + key: getattr(owner, method) for key, (owner, method) in OperationCounter.METHODS.items() + } + + with pytest.raises(RuntimeError, match="stop"): + with OperationCounter(): + raise RuntimeError("stop") + + assert { + key: getattr(owner, method) for key, (owner, method) in OperationCounter.METHODS.items() + } == originals + + +def test_operation_counter_wrappers_call_saved_originals_without_recursing() -> None: + frame = pd.DataFrame({"a": [1, 2, 3]}) + + with OperationCounter() as counter: + copied = frame.copy() + + assert copied.equals(frame) + assert counter.counts["dataframe.copy"] == 1 + + +def test_operation_counter_retains_zero_observations_for_every_method() -> None: + with OperationCounter() as counter: + pass + + assert counter.counts == dict.fromkeys(OperationCounter.METHODS, 0) + + +def test_profile_case_reports_exact_hot_functions_and_allocations() -> None: + result = profile_case(_case()) + assert result.functions + assert all( + {"file", "line", "function", "self_seconds", "cumulative_seconds", "calls"} <= set(item) + for item in result.functions + ) + assert result.allocations + assert all({"file", "line", "bytes", "count"} <= set(item) for item in result.allocations) + assert result.stages["total"] > 0 + assert result.operations["dataframe.copy"] >= 1 + assert asdict(result)["operations"] == result.operations + + +def _profile_payload() -> dict[str, object]: + result = BenchmarkResult.completed( + case=_case(), + environment=capture_environment(), + samples_seconds=[1.0], + peak_rss_bytes=1000, + peak_python_bytes=500, + input_bytes=250, + command="profile-test", + ) + payload = result.to_dict() + payload["profile"] = { + "functions": [ + { + "file": "/project/freshdata/cleaner.py", + "line": 12, + "function": "clean", + "self_seconds": 0.1, + "cumulative_seconds": 0.2, + "calls": 1, + } + ], + "allocations": [ + { + "file": "/project/freshdata/cleaner.py", + "line": 13, + "bytes": 1024, + "count": 2, + } + ], + "stages": {"total": 0.1, "context": 0.05}, + "operations": {"dataframe.copy": 3}, + } + return payload + + +def test_schema_accepts_strict_profile_records() -> None: + validate_result(_profile_payload()) + + +@pytest.mark.parametrize( + ("path", "value"), + [ + (("functions", 0, "line"), "12"), + (("allocations", 0, "bytes"), -1), + (("stages", "total"), -0.1), + (("operations", "dataframe.copy"), -1), + ], +) +def test_schema_rejects_invalid_profile_records(path: tuple[object, ...], value: object) -> None: + payload = _profile_payload() + target: object = payload["profile"] + for part in path[:-1]: + target = target[part] # type: ignore[index] + target[path[-1]] = value # type: ignore[index] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +def test_cli_profile_writes_one_strict_schema_valid_case(tmp_path) -> None: + exit_code = main( + [ + "profile", + "--rows", + "100", + "--widths", + "narrow", + "--configs", + "default", + "--report-modes", + "false", + "--backends", + "pandas", + "--output-formats", + "pandas", + "--warmups", + "0", + "--repetitions", + "1", + "--output", + str(tmp_path), + ] + ) + + assert exit_code == 0 + paths = list(tmp_path.glob("*.profile.json")) + assert len(paths) == 1 + payload = json.loads(paths[0].read_text()) + validate_result(payload) + serialized_case = BenchmarkCase(**payload["case"]) + assert paths[0].name == f"{serialized_case.case_id}.profile.json" + assert payload["profile"]["functions"] + + +@pytest.mark.parametrize( + ("selector", "values"), + [ + ("--rows", "100,101"), + ("--widths", "narrow,wide"), + ("--configs", "default,conservative"), + ("--report-modes", "false,true"), + ("--backends", "pandas,unsupported"), + ("--output-formats", "pandas,polars"), + ], +) +def test_cli_profile_rejects_multi_case_selectors(tmp_path, selector: str, values: str) -> None: + arguments = [ + "profile", + "--rows", + "100", + "--widths", + "narrow", + "--configs", + "default", + "--report-modes", + "false", + "--backends", + "pandas", + "--output-formats", + "pandas", + "--warmups", + "0", + "--repetitions", + "1", + "--output", + str(tmp_path), + ] + index = arguments.index(selector) + arguments[index + 1] = values + + with pytest.raises(SystemExit): + main(arguments) + + assert not list(tmp_path.glob("*.profile.json")) From b74bd8b6197b0f3cd85013605cae99e0aef2c4bf Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sun, 12 Jul 2026 10:56:39 +0530 Subject: [PATCH 18/37] fix: tighten performance profile instrumentation --- benchmarks/performance/instrumentation.py | 49 ++++++-- benchmarks/performance/schema.py | 60 +++++++++- tests/performance/test_instrumentation.py | 133 +++++++++++++++++++++- 3 files changed, 225 insertions(+), 17 deletions(-) diff --git a/benchmarks/performance/instrumentation.py b/benchmarks/performance/instrumentation.py index 15e4203..bac8dac 100644 --- a/benchmarks/performance/instrumentation.py +++ b/benchmarks/performance/instrumentation.py @@ -89,7 +89,7 @@ def __exit__( STAGE_RULES = { "context": ("engine/context.py",), "engine_cache": ("engine/cache.py",), - "correlation": ("numeric_corr_matrix", "corr", "corrwith"), + "correlation": ("numeric_corr_matrix", "corrwith"), "missing": ("engine/missing.py", "steps/missing.py"), "outliers": ("engine/outliers.py", "steps/outliers.py"), "role_inference": ("infer_role", "build_context"), @@ -101,6 +101,28 @@ def __exit__( "backend_conversion": ("adapters/", "execution/backends/"), } +_EXACT_FUNCTION_STAGES = { + "numeric_corr_matrix": "correlation", + "corrwith": "correlation", + "infer_role": "role_inference", + "build_context": "role_inference", +} + + +def _stage_for(filename: str, function: str) -> str | None: + normalized_function = function.lower() + exact_stage = _EXACT_FUNCTION_STAGES.get(normalized_function) + if exact_stage is not None: + return exact_stage + + normalized_path = filename.replace("\\", "/").lower() + normalized = f"{normalized_path}:{normalized_function}" + exact_rules = _EXACT_FUNCTION_STAGES.keys() + for stage, rules in STAGE_RULES.items(): + if any(rule not in exact_rules and rule in normalized for rule in rules): + return stage + return None + def _function_records( stats: pstats.Stats, @@ -125,19 +147,21 @@ def _function_records( } records.append(record) total += self_time - normalized = f"{filename.replace(chr(92), '/')}:{function}".lower() - for stage, rules in STAGE_RULES.items(): - if any(rule in normalized for rule in rules): - stages[stage] += self_time - break + stage = _stage_for(filename, function) + if stage is not None: + stages[stage] += self_time records.sort(key=lambda item: float(item["cumulative_seconds"]), reverse=True) stages["total"] = total return records[:100], stages -def _allocation_records(snapshot: tracemalloc.Snapshot) -> list[dict[str, object]]: +def _allocation_records( + differences: list[tracemalloc.StatisticDiff], +) -> list[dict[str, object]]: records: list[dict[str, object]] = [] - for statistic in snapshot.statistics("lineno"): + for statistic in differences: + if statistic.size_diff <= 0 or statistic.count_diff <= 0: + continue frame = statistic.traceback[0] normalized = frame.filename.replace("\\", "/") if "/freshdata/" not in normalized and "/benchmarks/performance/" not in normalized: @@ -146,8 +170,8 @@ def _allocation_records(snapshot: tracemalloc.Snapshot) -> list[dict[str, object { "file": frame.filename, "line": frame.lineno, - "bytes": statistic.size, - "count": statistic.count, + "bytes": statistic.size_diff, + "count": statistic.count_diff, } ) if len(records) == 100: @@ -169,6 +193,7 @@ def profile_case(case: BenchmarkCase) -> ProfileResult: if not was_tracing: tracemalloc.start() try: + before = tracemalloc.take_snapshot() with OperationCounter() as counter: profiler.enable() try: @@ -181,7 +206,7 @@ def profile_case(case: BenchmarkCase) -> ProfileResult: ) finally: profiler.disable() - snapshot = tracemalloc.take_snapshot() + after = tracemalloc.take_snapshot() finally: if not was_tracing: tracemalloc.stop() @@ -189,7 +214,7 @@ def profile_case(case: BenchmarkCase) -> ProfileResult: functions, stages = _function_records(pstats.Stats(profiler)) return ProfileResult( functions=functions, - allocations=_allocation_records(snapshot), + allocations=_allocation_records(after.compare_to(before, "lineno")), stages=stages, operations=dict(counter.counts), ) diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py index cbc94f9..d7f958e 100644 --- a/benchmarks/performance/schema.py +++ b/benchmarks/performance/schema.py @@ -166,6 +166,7 @@ "properties": { "functions": { "type": "array", + "maxItems": 100, "items": { "type": "object", "additionalProperties": False, @@ -189,6 +190,7 @@ }, "allocations": { "type": "array", + "maxItems": 100, "items": { "type": "object", "additionalProperties": False, @@ -203,7 +205,37 @@ }, "stages": { "type": "object", - "additionalProperties": {"type": "number", "minimum": 0}, + "required": [ + "context", + "engine_cache", + "correlation", + "missing", + "outliers", + "role_inference", + "dtype_repair", + "duplicates", + "audit_events", + "report_finalization", + "semantic_ml", + "backend_conversion", + "total", + ], + "additionalProperties": False, + "properties": { + "context": {"type": "number", "minimum": 0}, + "engine_cache": {"type": "number", "minimum": 0}, + "correlation": {"type": "number", "minimum": 0}, + "missing": {"type": "number", "minimum": 0}, + "outliers": {"type": "number", "minimum": 0}, + "role_inference": {"type": "number", "minimum": 0}, + "dtype_repair": {"type": "number", "minimum": 0}, + "duplicates": {"type": "number", "minimum": 0}, + "audit_events": {"type": "number", "minimum": 0}, + "report_finalization": {"type": "number", "minimum": 0}, + "semantic_ml": {"type": "number", "minimum": 0}, + "backend_conversion": {"type": "number", "minimum": 0}, + "total": {"type": "number", "minimum": 0}, + }, }, "operations": { "description": ( @@ -211,7 +243,31 @@ "buffer-copy counts." ), "type": "object", - "additionalProperties": {"type": "integer", "minimum": 0}, + "required": [ + "dataframe.copy", + "series.copy", + "series.isna", + "series.notna", + "series.nunique", + "series.value_counts", + "series.astype", + "dataframe.astype", + "dataframe.corr", + "dataframe.corrwith", + ], + "additionalProperties": False, + "properties": { + "dataframe.copy": {"type": "integer", "minimum": 0}, + "series.copy": {"type": "integer", "minimum": 0}, + "series.isna": {"type": "integer", "minimum": 0}, + "series.notna": {"type": "integer", "minimum": 0}, + "series.nunique": {"type": "integer", "minimum": 0}, + "series.value_counts": {"type": "integer", "minimum": 0}, + "series.astype": {"type": "integer", "minimum": 0}, + "dataframe.astype": {"type": "integer", "minimum": 0}, + "dataframe.corr": {"type": "integer", "minimum": 0}, + "dataframe.corrwith": {"type": "integer", "minimum": 0}, + }, }, }, }, diff --git a/tests/performance/test_instrumentation.py b/tests/performance/test_instrumentation.py index b280015..c37bf13 100644 --- a/tests/performance/test_instrumentation.py +++ b/tests/performance/test_instrumentation.py @@ -1,14 +1,22 @@ from __future__ import annotations import json +import tracemalloc from dataclasses import asdict +from types import SimpleNamespace import jsonschema import pandas as pd import pytest +from benchmarks.performance import instrumentation from benchmarks.performance.cli import main from benchmarks.performance.environment import capture_environment -from benchmarks.performance.instrumentation import OperationCounter, profile_case +from benchmarks.performance.instrumentation import ( + STAGE_RULES, + OperationCounter, + _function_records, + profile_case, +) from benchmarks.performance.models import BenchmarkCase, BenchmarkResult from benchmarks.performance.schema import validate_result @@ -82,6 +90,91 @@ def test_profile_case_reports_exact_hot_functions_and_allocations() -> None: assert asdict(result)["operations"] == result.operations +def _synthetic_stats( + *functions: tuple[str, str, float], +) -> SimpleNamespace: + return SimpleNamespace( + stats={ + (file, line, function): (1, 1, self_seconds, self_seconds, {}) + for line, (file, function, self_seconds) in enumerate(functions, start=1) + } + ) + + +def test_specific_context_functions_take_precedence_over_context_path() -> None: + stats = _synthetic_stats( + ("/project/freshdata/engine/context.py", "numeric_corr_matrix", 1.0), + ("/project/freshdata/engine/context.py", "infer_role", 2.0), + ("/project/freshdata/engine/context.py", "build_context", 3.0), + ("/project/freshdata/engine/context.py", "collect_metadata", 4.0), + ) + + _functions, stages = _function_records(stats) # type: ignore[arg-type] + + assert stages["correlation"] == 1.0 + assert stages["role_inference"] == 5.0 + assert stages["context"] == 4.0 + assert sum(value for key, value in stages.items() if key != "total") == stages["total"] + + +def test_correlation_rule_does_not_match_partial_function_names() -> None: + stats = _synthetic_stats( + ("/project/freshdata/engine/context.py", "decorrelate_labels", 1.0), + ) + + _functions, stages = _function_records(stats) # type: ignore[arg-type] + + assert stages["correlation"] == 0.0 + assert stages["context"] == 1.0 + + +def test_profile_case_excludes_allocations_retained_before_baseline() -> None: + tracemalloc.start() + namespace: dict[str, object] = {} + try: + exec( + compile("retained = bytearray(1000000)", "/tmp/freshdata/preexisting.py", "exec"), + namespace, + ) + + result = profile_case(_case()) + + assert tracemalloc.is_tracing() + assert all(item["file"] != "/tmp/freshdata/preexisting.py" for item in result.allocations) + finally: + tracemalloc.stop() + + +def test_profile_case_stops_locally_started_tracer() -> None: + if tracemalloc.is_tracing(): + tracemalloc.stop() + + profile_case(_case()) + + assert not tracemalloc.is_tracing() + + +def test_profile_case_restores_methods_and_tracer_when_clean_raises(monkeypatch) -> None: + originals = { + key: getattr(owner, method) for key, (owner, method) in OperationCounter.METHODS.items() + } + if tracemalloc.is_tracing(): + tracemalloc.stop() + + def fail_clean(*args: object, **kwargs: object) -> None: + raise RuntimeError("profile failure") + + monkeypatch.setattr(instrumentation.fd, "clean", fail_clean) + + with pytest.raises(RuntimeError, match="profile failure"): + profile_case(_case()) + + assert not tracemalloc.is_tracing() + assert { + key: getattr(owner, method) for key, (owner, method) in OperationCounter.METHODS.items() + } == originals + + def _profile_payload() -> dict[str, object]: result = BenchmarkResult.completed( case=_case(), @@ -112,8 +205,8 @@ def _profile_payload() -> dict[str, object]: "count": 2, } ], - "stages": {"total": 0.1, "context": 0.05}, - "operations": {"dataframe.copy": 3}, + "stages": {**dict.fromkeys(STAGE_RULES, 0.0), "total": 0.1}, + "operations": {**dict.fromkeys(OperationCounter.METHODS, 0), "dataframe.copy": 3}, } return payload @@ -142,6 +235,40 @@ def test_schema_rejects_invalid_profile_records(path: tuple[object, ...], value: validate_result(payload) +@pytest.mark.parametrize( + ("section", "key"), + [ + *(("stages", key) for key in (*STAGE_RULES, "total")), + *(("operations", key) for key in OperationCounter.METHODS), + ], +) +def test_schema_requires_every_profile_metric_key(section: str, key: str) -> None: + payload = _profile_payload() + del payload["profile"][section][key] # type: ignore[index] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +@pytest.mark.parametrize("section", ["stages", "operations"]) +def test_schema_rejects_unknown_profile_metric_key(section: str) -> None: + payload = _profile_payload() + payload["profile"][section]["unknown"] = 1 # type: ignore[index] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +@pytest.mark.parametrize("section", ["functions", "allocations"]) +def test_schema_rejects_more_than_100_profile_records(section: str) -> None: + payload = _profile_payload() + records = payload["profile"][section] # type: ignore[index] + payload["profile"][section] = records * 101 # type: ignore[index,operator] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + def test_cli_profile_writes_one_strict_schema_valid_case(tmp_path) -> None: exit_code = main( [ From 7bcf97541a9b7f186e7cc68d11b00e1d11c8ce7d Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sun, 12 Jul 2026 11:01:08 +0530 Subject: [PATCH 19/37] fix: classify pandas corr profile stage --- benchmarks/performance/instrumentation.py | 1 + tests/performance/test_instrumentation.py | 6 ++++++ 2 files changed, 7 insertions(+) diff --git a/benchmarks/performance/instrumentation.py b/benchmarks/performance/instrumentation.py index bac8dac..801ffd4 100644 --- a/benchmarks/performance/instrumentation.py +++ b/benchmarks/performance/instrumentation.py @@ -103,6 +103,7 @@ def __exit__( _EXACT_FUNCTION_STAGES = { "numeric_corr_matrix": "correlation", + "corr": "correlation", "corrwith": "correlation", "infer_role": "role_inference", "build_context": "role_inference", diff --git a/tests/performance/test_instrumentation.py b/tests/performance/test_instrumentation.py index c37bf13..5d9afad 100644 --- a/tests/performance/test_instrumentation.py +++ b/tests/performance/test_instrumentation.py @@ -15,6 +15,7 @@ STAGE_RULES, OperationCounter, _function_records, + _stage_for, profile_case, ) from benchmarks.performance.models import BenchmarkCase, BenchmarkResult @@ -128,6 +129,11 @@ def test_correlation_rule_does_not_match_partial_function_names() -> None: assert stages["context"] == 1.0 +def test_pandas_corr_is_correlation_without_matching_partial_names() -> None: + assert _stage_for("/site-packages/pandas/core/frame.py", "corr") == "correlation" + assert _stage_for("/site-packages/pandas/core/frame.py", "decorrelate_labels") is None + + def test_profile_case_excludes_allocations_retained_before_baseline() -> None: tracemalloc.start() namespace: dict[str, object] = {} From 7ef5e7985c3aa2e393dae52a7406c64c1f34c159 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sun, 12 Jul 2026 11:17:07 +0530 Subject: [PATCH 20/37] bench: analyze and render scalability evidence --- benchmarks/performance/analysis.py | 259 +++++++++++++ benchmarks/performance/baselines.py | 298 +++++++++++++++ benchmarks/performance/cli.py | 58 +++ benchmarks/performance/models.py | 3 + benchmarks/performance/render.py | 185 +++++++++ benchmarks/performance/schema.py | 2 + tests/performance/test_analysis_render.py | 433 ++++++++++++++++++++++ tests/performance/test_models_schema.py | 35 ++ 8 files changed, 1273 insertions(+) create mode 100644 benchmarks/performance/analysis.py create mode 100644 benchmarks/performance/baselines.py create mode 100644 benchmarks/performance/render.py create mode 100644 tests/performance/test_analysis_render.py diff --git a/benchmarks/performance/analysis.py b/benchmarks/performance/analysis.py new file mode 100644 index 0000000..12bcb08 --- /dev/null +++ b/benchmarks/performance/analysis.py @@ -0,0 +1,259 @@ +from __future__ import annotations + +import math +from collections.abc import Iterable +from pathlib import Path +from typing import Any + +from .schema import validate_result + +_HYPOTHESES = { + "unnecessary_correlation": { + "stages": ("correlation",), + "operations": ("dataframe.corr", "dataframe.corrwith"), + "functions": ("numeric_corr_matrix", "corr", "corrwith"), + "paths": ("/engine/context.py",), + }, + "repeated_null_scans": { + "stages": ("missing",), + "operations": ("series.isna", "series.notna"), + "functions": ("isna", "notna"), + "paths": ("/engine/missing.py", "/steps/missing.py"), + }, + "repeated_uniqueness_scans": { + "stages": ("role_inference",), + "operations": ("series.nunique", "series.value_counts"), + "functions": ("infer_role", "build_context", "nunique", "value_counts"), + "paths": (), + }, + "copy_pressure": { + "stages": ("context", "engine_cache"), + "operations": ("dataframe.copy", "series.copy"), + "functions": ("copy",), + "paths": ("/engine/context.py", "/engine/cache.py"), + }, + "dtype_conversion_pressure": { + "stages": ("dtype_repair",), + "operations": ("series.astype", "dataframe.astype"), + "functions": ("astype",), + "paths": ("/steps/dtypes.py",), + }, + "report_finalization_overhead": { + "stages": ("report_finalization", "audit_events"), + "operations": (), + "functions": ("memory_bytes", "cleanreport.add"), + "paths": ("/report.py", "/cleaner.py"), + }, + "optional_ml_overhead": { + "stages": ("semantic_ml",), + "operations": (), + "functions": (), + "paths": ("/semantic/", "/imputation/missforest.py", "/sklearn/"), + }, + "backend_conversion_overhead": { + "stages": ("backend_conversion",), + "operations": (), + "functions": (), + "paths": ("/adapters/", "/execution/backends/"), + }, +} + + +def classify_change( + baseline: float, + candidate: float, + baseline_cv: float, + candidate_cv: float, +) -> str: + if baseline <= 0: + raise ValueError("baseline must be positive") + if candidate < 0: + raise ValueError("candidate must be non-negative") + if baseline_cv < 0 or candidate_cv < 0: + raise ValueError("variation must be non-negative") + change = (baseline - candidate) / baseline + threshold = max(0.10, 2 * max(baseline_cv, candidate_cv)) + if abs(change) < threshold and not math.isclose( + abs(change), threshold, rel_tol=1e-12, abs_tol=1e-12 + ): + return "noise" + return "improved" if change > 0 else "regressed" + + +def _matches( + record: dict[str, object], + functions: tuple[str, ...], + paths: tuple[str, ...], +) -> bool: + path = str(record.get("file", "")).replace("\\", "/").lower() + function = str(record.get("function", "")).lower() + return function in functions or any(term in path for term in paths) + + +def classify_hypotheses( + profile: dict[str, object], *, traced_peak_bytes: int | None = None +) -> dict[str, dict[str, object]]: + stages = profile.get("stages", {}) + operations = profile.get("operations", {}) + functions = profile.get("functions", []) + allocations = profile.get("allocations", []) + if not isinstance(stages, dict) or not isinstance(operations, dict): + raise TypeError("profile stages and operations must be objects") + if not isinstance(functions, list) or not isinstance(allocations, list): + raise TypeError("profile functions and allocations must be arrays") + total = float(stages.get("total", 0.0)) + decisions: dict[str, dict[str, object]] = {} + for name, rule in _HYPOTHESES.items(): + stage_seconds = sum(float(stages.get(stage, 0.0)) for stage in rule["stages"]) + stage_fraction = stage_seconds / total if total > 0 else 0.0 + function_evidence = [ + record + for record in functions + if isinstance(record, dict) and _matches(record, rule["functions"], rule["paths"]) + ] + allocation_evidence = [ + record + for record in allocations + if isinstance(record, dict) and _matches(record, (), rule["paths"]) + ] + operation_calls = sum(int(operations.get(key, 0)) for key in rule["operations"]) + exact_function_calls = sum(int(record.get("calls", 0)) for record in function_evidence) + observed_calls = operation_calls or exact_function_calls + significant_allocations = ( + traced_peak_bytes is not None + and traced_peak_bytes > 0 + and sum(int(record.get("bytes", 0)) for record in allocation_evidence) + / traced_peak_bytes + >= 0.10 + ) + evidence: list[dict[str, object]] = [] + evidence.extend(function_evidence) + evidence.extend(allocation_evidence) + if not evidence or observed_calls == 0: + status = "insufficient_evidence" + elif stage_fraction >= 0.10 or significant_allocations: + status = "candidate" + else: + status = "rejected" + decisions[name] = { + "status": status, + "stage_fraction": stage_fraction, + "observed_calls": observed_calls, + "evidence": evidence, + } + return decisions + + +def _sort_key(result: dict[str, Any]) -> tuple[object, ...]: + case = result.get("case", {}) + return ( + case.get("rows", 0), + case.get("width", ""), + case.get("config_name", ""), + case.get("return_report", False), + case.get("backend", ""), + case.get("output_format", ""), + result.get("baseline_name") or "", + ) + + +def analyze_results(results: Iterable[dict[str, Any]]) -> dict[str, Any]: + ordered = sorted((dict(result) for result in results), key=_sort_key) + for result in ordered: + validate_result(result) + component_baselines = [ + result + for result in ordered + if result.get("case", {}).get("backend") == "pandas-component-baseline" + ] + freshdata_results = [result for result in ordered if result not in component_baselines] + baselines_by_semantics = { + ( + result.get("baseline_name"), + result["case"]["rows"], + result["case"]["width"], + result["case"]["dataset_type"], + result["case"]["seed"], + ): result + for result in component_baselines + if result.get("status") == "completed" + } + hypotheses: dict[str, dict[str, object]] = {} + for result in freshdata_results: + result["comparisons"] = [] + options = result["case"].get("options", {}) + comparable_name = options.get("comparable_baseline") if isinstance(options, dict) else None + baseline = baselines_by_semantics.get( + ( + comparable_name, + result["case"]["rows"], + result["case"]["width"], + result["case"]["dataset_type"], + result["case"]["seed"], + ) + ) + if ( + baseline is not None + and result.get("status") == "completed" + and baseline.get("median_seconds") is not None + and result.get("median_seconds") is not None + ): + baseline_seconds = float(baseline["median_seconds"]) + candidate_seconds = float(result["median_seconds"]) + result["comparisons"].append( + { + "baseline_name": comparable_name, + "baseline_seconds": baseline_seconds, + "candidate_seconds": candidate_seconds, + "ratio": baseline_seconds / candidate_seconds if candidate_seconds else None, + "classification": classify_change( + baseline_seconds, + candidate_seconds, + float(baseline.get("coefficient_of_variation") or 0.0), + float(result.get("coefficient_of_variation") or 0.0), + ), + } + ) + profile = result.get("profile") + if isinstance(profile, dict): + decisions = classify_hypotheses( + profile, traced_peak_bytes=result.get("peak_python_bytes") + ) + hypotheses[_case_label(result)] = decisions + environment = ordered[0]["environment"] if ordered else {} + commands = sorted( + {str(result.get("command", "")) for result in ordered if result.get("command")} + ) + return { + "schema_version": 1, + "environment": environment, + "results": freshdata_results, + "component_baselines": component_baselines, + "hypotheses": hypotheses, + "reproduction_commands": commands, + "limitations": [ + "Component baselines cover only their named pandas operation; no full " + "balanced FreshData pipeline equivalence is claimed.", + "Timing classifications require both a 10% effect and twice the larger " + "observed coefficient of variation.", + ], + } + + +def _case_label(result: dict[str, Any]) -> str: + case = result["case"] + return "/".join( + str(case[key]) + for key in ("rows", "width", "config_name", "return_report", "backend", "output_format") + ) + + +def load_results(input_dir: Path) -> list[dict[str, Any]]: + payloads: list[dict[str, Any]] = [] + for path in sorted(input_dir.glob("*.json")): + payload = __import__("json").loads(path.read_text(encoding="utf-8")) + if not isinstance(payload, dict): + raise TypeError(f"result must be an object: {path}") + validate_result(payload) + payloads.append(payload) + return payloads diff --git a/benchmarks/performance/baselines.py b/benchmarks/performance/baselines.py new file mode 100644 index 0000000..b51e78e --- /dev/null +++ b/benchmarks/performance/baselines.py @@ -0,0 +1,298 @@ +from __future__ import annotations + +import gc +import hashlib +import json +import shlex +import subprocess +import sys +import tempfile +import time +import tracemalloc +from dataclasses import asdict, replace +from itertools import product +from pathlib import Path +from typing import Callable, NoReturn + +import pandas as pd + +from .datasets import DatasetSpec, make_mixed_frame +from .environment import capture_environment +from .memory import PeakRSS +from .models import BenchmarkCase, BenchmarkResult +from .schema import validate_result + +Baseline = Callable[[pd.DataFrame], pd.DataFrame | pd.Series] + + +def _numeric_median_fill(frame: pd.DataFrame) -> pd.DataFrame: + return frame.assign( + **{ + column: frame[column].fillna(frame[column].median()) + for column in frame.select_dtypes(include="number").columns + if frame[column].notna().any() + } + ) + + +BASELINES: dict[str, Baseline] = { + "shallow_copy": lambda frame: frame.copy(deep=False), + "numeric_median_fill": _numeric_median_fill, + "duplicates": lambda frame: frame.drop_duplicates(), + "null_counts": lambda frame: frame.isna().sum(), +} + +_BASELINE_WORKER_SCRIPT = ( + "from benchmarks.performance.baselines import baseline_worker_main; " + "baseline_worker_main(__import__('sys').argv[1], __import__('sys').argv[2], " + "__import__('sys').argv[3], __import__('sys').argv[4])" +) + + +def _component_case(case: BenchmarkCase, baseline_name: str) -> BenchmarkCase: + if baseline_name not in BASELINES: + choices = ", ".join(BASELINES) + raise ValueError(f"unknown pandas baseline {baseline_name!r}; choose from {choices}") + return replace( + case, + config_name=f"pandas_{baseline_name}", + options={}, + return_report=False, + backend="pandas-component-baseline", + output_format="pandas", + ) + + +def _fingerprint(result: pd.DataFrame | pd.Series) -> str: + digest = hashlib.sha256() + digest.update(pd.util.hash_pandas_object(result, index=True).values.tobytes()) + if isinstance(result, pd.DataFrame): + digest.update(repr(list(result.columns)).encode()) + digest.update(repr([str(dtype) for dtype in result.dtypes]).encode()) + else: + digest.update(repr(result.name).encode()) + digest.update(str(result.dtype).encode()) + return digest.hexdigest() + + +def measure_pandas_baseline( + case: BenchmarkCase, baseline_name: str, *, command: str +) -> BenchmarkResult: + measured_case = _component_case(case, baseline_name) + operation = BASELINES[baseline_name] + frame = make_mixed_frame( + DatasetSpec( + rows=measured_case.rows, + width=measured_case.width, + seed=measured_case.seed, + dataset_type=measured_case.dataset_type, + ) + ) + input_bytes = int(frame.memory_usage(index=True, deep=True).sum()) + + for _ in range(measured_case.warmups): + operation(frame) + + samples: list[float] = [] + for _ in range(measured_case.repetitions): + gc.collect() + started = time.perf_counter() + operation(frame) + samples.append(time.perf_counter() - started) + + gc.collect() + tracemalloc.start() + try: + with PeakRSS() as rss: + measured_result = operation(frame) + _current, python_peak = tracemalloc.get_traced_memory() + finally: + tracemalloc.stop() + + return BenchmarkResult.completed( + case=measured_case, + environment=capture_environment(), + samples_seconds=samples, + peak_rss_bytes=rss.increase_bytes, + peak_python_bytes=python_peak, + input_bytes=input_bytes, + command=command, + output_fingerprint=_fingerprint(measured_result), + result_type=type(measured_result).__name__, + baseline_name=baseline_name, + ) + + +def _reject_non_standard_json_constant(value: str) -> NoReturn: + raise ValueError(f"case JSON contains non-standard constant: {value}") + + +def baseline_worker_main( + case_path: str, result_path: str, baseline_name: str, command: str +) -> None: + payload = json.loads( + Path(case_path).read_text(encoding="utf-8"), + parse_constant=_reject_non_standard_json_constant, + ) + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + serialized = result.to_dict() + validate_result(serialized) + Path(result_path).write_text( + json.dumps(serialized, indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) + + +def _failure_result( + case: BenchmarkCase, + baseline_name: str, + status: str, + command: str, + error_type: str, + error_message: str, +) -> BenchmarkResult: + return BenchmarkResult( + schema_version=1, + status=status, + case=_component_case(case, baseline_name), + environment=capture_environment(), + command=command, + error_type=error_type, + error_message=error_message, + baseline_name=baseline_name, + ) + + +def run_baseline_subprocess( + case: BenchmarkCase, + baseline_name: str, + output_dir: Path, + timeout_seconds: int, +) -> BenchmarkResult: + measured_case = _component_case(case, baseline_name) + output_dir.mkdir(parents=True, exist_ok=True) + output_path = output_dir / f"{measured_case.case_id}.json" + with tempfile.TemporaryDirectory(prefix="freshdata-pandas-baseline-") as directory: + case_path = Path(directory) / "case.json" + result_path = Path(directory) / "result.json" + worker_command = [ + sys.executable, + "-c", + _BASELINE_WORKER_SCRIPT, + str(case_path), + str(result_path), + baseline_name, + ] + command = shlex.join(worker_command) + worker_command.append(command) + case_path.write_text( + json.dumps(asdict(measured_case), indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) + try: + completed = subprocess.run( + worker_command, + timeout=timeout_seconds, + capture_output=True, + text=True, + check=False, + ) + except subprocess.TimeoutExpired as exc: + result = _failure_result( + measured_case, + baseline_name, + "timeout", + command, + "TimeoutExpired", + str(exc), + ) + else: + process_output = "\n".join((completed.stdout, completed.stderr)) + if "MemoryError" in process_output: + result = _failure_result( + measured_case, + baseline_name, + "oom", + command, + "MemoryError", + process_output, + ) + elif completed.returncode != 0: + result = _failure_result( + measured_case, + baseline_name, + "failed", + command, + "ChildProcessError", + completed.stderr + or completed.stdout + or f"worker exited with code {completed.returncode}", + ) + else: + try: + payload = json.loads( + result_path.read_text(encoding="utf-8"), + parse_constant=_reject_non_standard_json_constant, + ) + validate_result(payload) + result = BenchmarkResult.from_dict(payload) + except Exception as exc: # converted to a durable benchmark result + result = _failure_result( + measured_case, + baseline_name, + "failed", + command, + type(exc).__name__, + str(exc), + ) + + serialized = result.to_dict() + validate_result(serialized) + output_path.write_text( + json.dumps(serialized, indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) + return result + + +def expand_baseline_cases( + *, + rows: list[int], + widths: list[str], + dataset_types: list[str], + baseline_names: list[str], + seed: int, + warmups: int, + repetitions: int, +) -> list[tuple[BenchmarkCase, str]]: + unknown = sorted(set(baseline_names) - set(BASELINES)) + if unknown: + raise ValueError(f"unknown pandas baseline(s): {', '.join(unknown)}") + return [ + ( + BenchmarkCase( + rows=row_count, + width=width, + config_name=f"pandas_{baseline_name}", + options={}, + dataset_type=dataset_type, + backend="pandas-component-baseline", + seed=seed, + warmups=warmups, + repetitions=repetitions, + ), + baseline_name, + ) + for row_count, width, dataset_type, baseline_name in product( + rows, widths, dataset_types, baseline_names + ) + ] + + +def run_baseline_matrix( + cases: list[tuple[BenchmarkCase, str]], output_dir: Path, timeout_seconds: int +) -> list[BenchmarkResult]: + return [ + run_baseline_subprocess(case, baseline_name, output_dir, timeout_seconds) + for case, baseline_name in cases + ] diff --git a/benchmarks/performance/cli.py b/benchmarks/performance/cli.py index 1eb6ebf..0755870 100644 --- a/benchmarks/performance/cli.py +++ b/benchmarks/performance/cli.py @@ -7,6 +7,9 @@ from collections import Counter from pathlib import Path +from .analysis import analyze_results, load_results +from .baselines import BASELINES, expand_baseline_cases, run_baseline_matrix +from .render import render_report from .runner import expand_cases, run_matrix from .schema import validate_result from .worker import execute_profile_case @@ -46,6 +49,25 @@ def _parser() -> argparse.ArgumentParser: report_modes="false", ) profile.add_argument("--output", required=True) + + baseline = subcommands.add_parser("baseline") + baseline.add_argument("--rows", default="10000,100000") + baseline.add_argument("--widths", default="narrow,medium,wide") + baseline.add_argument("--dataset-types", default="mixed") + baseline.add_argument("--baselines", default=",".join(BASELINES)) + baseline.add_argument("--seed", type=int, default=42) + baseline.add_argument("--warmups", type=int, default=1) + baseline.add_argument("--repetitions", type=int, default=5) + baseline.add_argument("--timeout", type=int, default=1800) + baseline.add_argument("--output", required=True) + + analyze = subcommands.add_parser("analyze") + analyze.add_argument("--input", required=True) + analyze.add_argument("--output", required=True) + + render = subcommands.add_parser("render") + render.add_argument("--input", required=True) + render.add_argument("--output", required=True) return parser @@ -75,6 +97,42 @@ def _add_case_arguments( def main(argv: list[str] | None = None) -> int: parser = _parser() arguments = parser.parse_args(argv) + if arguments.subcommand == "analyze": + summary = analyze_results(load_results(Path(arguments.input))) + Path(arguments.output).parent.mkdir(parents=True, exist_ok=True) + Path(arguments.output).write_text( + json.dumps(summary, indent=2, sort_keys=True, allow_nan=False), + encoding="utf-8", + ) + return 0 + if arguments.subcommand == "render": + payload = json.loads(Path(arguments.input).read_text(encoding="utf-8")) + if not isinstance(payload, dict): + parser.error("render input must be a JSON object") + Path(arguments.output).parent.mkdir(parents=True, exist_ok=True) + Path(arguments.output).write_text(render_report(payload), encoding="utf-8") + return 0 + if arguments.subcommand == "baseline": + baseline_names = _comma_separated(arguments.baselines) + unknown = sorted(set(baseline_names) - set(BASELINES)) + if unknown: + parser.error(f"unknown pandas baseline(s): {', '.join(unknown)}") + cases = expand_baseline_cases( + rows=[int(value) for value in _comma_separated(arguments.rows)], + widths=_comma_separated(arguments.widths), + dataset_types=_comma_separated(arguments.dataset_types), + baseline_names=baseline_names, + seed=arguments.seed, + warmups=arguments.warmups, + repetitions=arguments.repetitions, + ) + results = run_baseline_matrix(cases, Path(arguments.output), arguments.timeout) + for result in results: + print(f"{result.case.case_id} {result.baseline_name} {result.status}") + counts = Counter(result.status for result in results) + print(" ".join(f"{status}={counts[status]}" for status in sorted(counts))) + return 0 if all(result.status == "completed" for result in results) else 1 + cases = expand_cases( rows=[int(value) for value in _comma_separated(arguments.rows)], widths=_comma_separated(arguments.widths), diff --git a/benchmarks/performance/models.py b/benchmarks/performance/models.py index e235adf..6a1d4f4 100644 --- a/benchmarks/performance/models.py +++ b/benchmarks/performance/models.py @@ -146,6 +146,7 @@ class BenchmarkResult: report_fingerprint: str | None = None result_type: str | None = None profile: ProfileResult | None = None + baseline_name: str | None = None @classmethod def completed( @@ -162,6 +163,7 @@ def completed( report_fingerprint: str | None = None, result_type: str | None = None, profile: ProfileResult | None = None, + baseline_name: str | None = None, ) -> BenchmarkResult: if not samples_seconds: raise ValueError("samples_seconds must not be empty") @@ -217,6 +219,7 @@ def completed( report_fingerprint=report_fingerprint, result_type=result_type, profile=profile, + baseline_name=baseline_name, ) def to_dict(self) -> dict[str, Any]: diff --git a/benchmarks/performance/render.py b/benchmarks/performance/render.py new file mode 100644 index 0000000..9018038 --- /dev/null +++ b/benchmarks/performance/render.py @@ -0,0 +1,185 @@ +from __future__ import annotations + +from typing import Any + + +def _number(value: object, digits: int = 3) -> str: + if value is None: + return "—" + return f"{float(value):.{digits}f}" + + +def _ratio(value: object) -> str: + return "∞" if value is None else f"{float(value):.3f}x" + + +def _case_sort_key(result: dict[str, Any]) -> tuple[object, ...]: + case = result.get("case", {}) + return ( + case.get("rows", 0), + case.get("width", ""), + case.get("config_name", ""), + case.get("return_report", False), + case.get("backend", ""), + case.get("output_format", ""), + result.get("baseline_name") or "", + ) + + +def _table(results: list[dict[str, Any]]) -> list[str]: + lines = [ + "| Rows | Width | Config / operation | Report | Backend | Format | Median s | " + "Min s | Max s | CV | Rows/s | Peak RSS/input | Peak Python/input | Comparison |", + "| ---: | :--- | :--- | :---: | :--- | :--- | ---: | ---: | ---: | ---: | " + "---: | ---: | ---: | :--- |", + ] + for result in sorted(results, key=_case_sort_key): + case = result["case"] + input_bytes = result.get("input_bytes") or 0 + python_ratio = result.get("peak_python_bytes", 0) / input_bytes if input_bytes else None + comparisons = result.get("comparisons", []) + comparison = ( + "; ".join( + f"{item['baseline_name']} {_ratio(item['ratio'])} ({item['classification']})" + for item in comparisons + ) + or "—" + ) + lines.append( + "| " + + " | ".join( + ( + str(case["rows"]), + str(case["width"]), + str(result.get("baseline_name") or case["config_name"]), + str(case["return_report"]).lower(), + str(case["backend"]), + str(case["output_format"]), + _number(result.get("median_seconds")), + _number(result.get("min_seconds")), + _number(result.get("max_seconds")), + _number(result.get("coefficient_of_variation")), + _number(result.get("throughput_rows_per_second"), 1), + _number(result.get("input_to_peak_ratio")), + _number(python_ratio), + comparison, + ) + ) + + " |" + ) + if len(lines) == 2: + lines.append( + "| — | — | — | — | — | — | — | — | — | — | — | — | — | No completed results |" + ) + return lines + + +def render_report(payload: dict[str, Any]) -> str: # noqa: PLR0915 + environment = payload.get("environment", {}) + results = list(payload.get("results", [])) + baselines = list(payload.get("component_baselines", [])) + all_results = results + baselines + completed = [item for item in all_results if item.get("status") == "completed"] + failures = [item for item in all_results if item.get("status") != "completed"] + hypotheses = payload.get("hypotheses", {}) + decisions = [ + (case, name, decision) + for case, case_decisions in sorted(hypotheses.items()) + for name, decision in sorted(case_decisions.items()) + ] + lines = [ + "# FreshData performance evidence", + "", + "## Environment", + "", + ] + if environment: + lines.extend(f"- {key}: `{environment[key]}`" for key in sorted(environment)) + else: + lines.append("- No environment metadata was recorded.") + lines.extend( + [ + "", + "## Architecture and execution flow", + "", + "FreshData cases and named pandas component operations run in isolated " + "worker processes. Timing samples and the PeakRSS/tracemalloc measurement " + "are collected separately.", + "", + "## Reproduction commands", + "", + ] + ) + commands = sorted(set(payload.get("reproduction_commands", []))) + lines.extend(f"- `{command}`" for command in commands) + if not commands: + lines.append("- No command was recorded.") + lines.extend(["", "## Baseline benchmark table", ""]) + lines.extend(_table(completed)) + lines.extend(["", "## Profiling findings", ""]) + profile_found = False + for result in sorted(results, key=_case_sort_key): + profile = result.get("profile") + if not isinstance(profile, dict): + continue + profile_found = True + lines.append(f"### {result['case']['rows']} rows / {result['case']['width']}") + lines.append("") + total = float(profile.get("stages", {}).get("total", 0.0)) + for stage, seconds in sorted(profile.get("stages", {}).items()): + if stage == "total": + continue + fraction = float(seconds) / total if total else 0.0 + lines.append(f"- {stage}: {fraction:.1%}") + for function in profile.get("functions", [])[:10]: + lines.append( + f"- `{function['file']}:{function['line']} {function['function']}` — " + f"self {_number(function['self_seconds'])} s, cumulative " + f"{_number(function['cumulative_seconds'])} s, calls " + f"{function['calls']}" + ) + lines.append("") + if not profile_found: + lines.append("No profiling records were supplied.") + lines.extend(["", "## Confirmed root causes", ""]) + candidates = [item for item in decisions if item[2].get("status") == "candidate"] + if candidates: + lines.append( + "No cause is confirmed by profiling alone; these exact-evidence items are " + "performance candidates:" + ) + lines.append("") + for case, name, decision in candidates: + lines.append( + f"- `{name}` in `{case}`: candidate; stage " + f"{float(decision['stage_fraction']):.1%}, observed calls " + f"{decision['observed_calls']}." + ) + if not candidates: + lines.append("No root cause met the exact-evidence and significance thresholds.") + lines.extend(["", "## Rejected hypotheses", ""]) + rejected = [item for item in decisions if item[2].get("status") != "candidate"] + for case, name, decision in rejected: + lines.append( + f"- `{name}` in `{case}`: {decision['status']}; stage " + f"{float(decision['stage_fraction']):.1%}, observed calls " + f"{decision['observed_calls']}." + ) + if not rejected: + lines.append("No rejected or evidence-limited hypotheses were recorded.") + lines.extend(["", "## Failures, timeouts, and OOMs", ""]) + for result in sorted(failures, key=_case_sort_key): + case = result["case"] + lines.append( + f"- {case['rows']} rows / {case['width']} / {case['config_name']}: " + f"{result['status']} ({result.get('error_type') or 'unknown'}: " + f"{result.get('error_message') or 'no message'})." + ) + if not failures: + lines.append("No failures, timeouts, or OOMs were recorded.") + lines.extend(["", "## Limitations", ""]) + limitations = payload.get("limitations", []) + lines.extend(f"- {limitation}" for limitation in limitations) + if not limitations: + lines.append("- No limitations were supplied.") + return "\n".join(lines).rstrip() + "\n" diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py index d7f958e..a36e82c 100644 --- a/benchmarks/performance/schema.py +++ b/benchmarks/performance/schema.py @@ -40,6 +40,7 @@ "output_fingerprint", "report_fingerprint", "result_type", + "baseline_name", ], "additionalProperties": False, "properties": { @@ -159,6 +160,7 @@ "output_fingerprint": {"type": ["string", "null"]}, "report_fingerprint": {"type": ["string", "null"]}, "result_type": {"type": ["string", "null"]}, + "baseline_name": {"type": ["string", "null"], "minLength": 1}, "profile": { "type": ["object", "null"], "additionalProperties": False, diff --git a/tests/performance/test_analysis_render.py b/tests/performance/test_analysis_render.py new file mode 100644 index 0000000..4720ece --- /dev/null +++ b/tests/performance/test_analysis_render.py @@ -0,0 +1,433 @@ +from __future__ import annotations + +import json +from pathlib import Path + +import pytest +from benchmarks.performance.analysis import ( + analyze_results, + classify_change, + classify_hypotheses, +) +from benchmarks.performance.baselines import BASELINES, measure_pandas_baseline +from benchmarks.performance.cli import main +from benchmarks.performance.models import BenchmarkCase +from benchmarks.performance.render import render_report + + +def _case(**overrides: object) -> BenchmarkCase: + arguments = { + "rows": 30, + "width": "narrow", + "config_name": "component_baseline", + "options": {}, + "warmups": 0, + "repetitions": 1, + } + arguments.update(overrides) + return BenchmarkCase(**arguments) # type: ignore[arg-type] + + +@pytest.mark.parametrize( + "baseline,candidate,baseline_cv,candidate_cv,expected", + [ + (1.0, 0.85, 0.02, 0.02, "improved"), + (1.0, 0.94, 0.01, 0.01, "noise"), + (1.0, 1.12, 0.02, 0.02, "regressed"), + (1.0, 0.89, 0.06, 0.01, "noise"), + (1.0, 0.90, 0.01, 0.01, "improved"), + ], +) +def test_change_requires_ten_percent_and_twice_variability( + baseline: float, + candidate: float, + baseline_cv: float, + candidate_cv: float, + expected: str, +) -> None: + assert classify_change(baseline, candidate, baseline_cv, candidate_cv) == expected + + +def test_change_rejects_non_positive_or_negative_inputs() -> None: + with pytest.raises(ValueError, match="baseline must be positive"): + classify_change(0.0, 0.8, 0.0, 0.0) + with pytest.raises(ValueError, match="candidate must be non-negative"): + classify_change(1.0, -0.1, 0.0, 0.0) + with pytest.raises(ValueError, match="variation must be non-negative"): + classify_change(1.0, 0.8, -0.1, 0.0) + + +def _empty_profile() -> dict[str, object]: + return { + "stages": { + "context": 0.0, + "engine_cache": 0.0, + "correlation": 0.0, + "missing": 0.0, + "outliers": 0.0, + "role_inference": 0.0, + "dtype_repair": 0.0, + "duplicates": 0.0, + "audit_events": 0.0, + "report_finalization": 0.0, + "semantic_ml": 0.0, + "backend_conversion": 0.0, + "total": 1.0, + }, + "operations": { + "dataframe.copy": 0, + "series.copy": 0, + "series.isna": 0, + "series.notna": 0, + "series.nunique": 0, + "series.value_counts": 0, + "series.astype": 0, + "dataframe.astype": 0, + "dataframe.corr": 0, + "dataframe.corrwith": 0, + }, + "functions": [], + "allocations": [], + } + + +def test_hypothesis_classifier_requires_exact_profile_evidence() -> None: + profile = _empty_profile() + profile["stages"]["correlation"] = 0.40 # type: ignore[index] + profile["operations"]["dataframe.corr"] = 1 # type: ignore[index] + profile["functions"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": 207, + "function": "numeric_corr_matrix", + "self_seconds": 0.4, + "cumulative_seconds": 0.4, + "calls": 1, + } + ] + + decisions = classify_hypotheses(profile) + + decision = decisions["unnecessary_correlation"] + assert decision["status"] == "candidate" + assert decision["stage_fraction"] == pytest.approx(0.4) + assert decision["observed_calls"] == 1 + assert decision["evidence"] == profile["functions"] + + +def test_hypothesis_classifier_does_not_substitute_unrelated_evidence() -> None: + profile = _empty_profile() + profile["stages"]["correlation"] = 0.40 # type: ignore[index] + profile["operations"]["dataframe.corr"] = 1 # type: ignore[index] + profile["functions"] = [ + { + "file": "src/freshdata/report.py", + "line": 12, + "function": "finalize", + "self_seconds": 0.4, + "cumulative_seconds": 0.4, + "calls": 1, + } + ] + + decision = classify_hypotheses(profile)["unnecessary_correlation"] + + assert decision["status"] == "insufficient_evidence" + assert decision["evidence"] == [] + + +def test_hypothesis_classifier_does_not_accept_partial_function_name_match() -> None: + profile = _empty_profile() + profile["stages"]["correlation"] = 0.40 # type: ignore[index] + profile["operations"]["dataframe.corr"] = 1 # type: ignore[index] + profile["functions"] = [ + { + "file": "src/freshdata/unrelated.py", + "line": 12, + "function": "correlation_label", + "self_seconds": 0.4, + "cumulative_seconds": 0.4, + "calls": 1, + } + ] + + decision = classify_hypotheses(profile)["unnecessary_correlation"] + + assert decision["status"] == "insufficient_evidence" + assert decision["evidence"] == [] + + +def test_hypothesis_classifier_rejects_observed_but_small_work() -> None: + profile = _empty_profile() + profile["stages"]["missing"] = 0.09 # type: ignore[index] + profile["operations"]["series.isna"] = 4 # type: ignore[index] + profile["functions"] = [ + { + "file": "src/freshdata/engine/missing.py", + "line": 8, + "function": "scan_missing", + "self_seconds": 0.09, + "cumulative_seconds": 0.09, + "calls": 4, + } + ] + + decision = classify_hypotheses(profile)["repeated_null_scans"] + + assert decision["status"] == "rejected" + assert decision["observed_calls"] == 4 + + +def test_hypothesis_classifier_can_use_exact_peak_allocation_evidence() -> None: + profile = _empty_profile() + profile["operations"]["dataframe.copy"] = 2 # type: ignore[index] + profile["allocations"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": 44, + "bytes": 120, + "count": 2, + }, + { + "file": "src/freshdata/other.py", + "line": 9, + "bytes": 880, + "count": 1, + }, + ] + + decision = classify_hypotheses(profile, traced_peak_bytes=1_000)["copy_pressure"] + + assert decision["status"] == "candidate" + assert decision["evidence"] == [profile["allocations"][0]] # type: ignore[index] + + +def test_all_required_hypotheses_are_classified() -> None: + assert set(classify_hypotheses(_empty_profile())) == { + "unnecessary_correlation", + "repeated_null_scans", + "repeated_uniqueness_scans", + "copy_pressure", + "dtype_conversion_pressure", + "report_finalization_overhead", + "optional_ml_overhead", + "backend_conversion_overhead", + } + + +def test_component_baseline_names_and_semantics() -> None: + assert tuple(BASELINES) == ( + "shallow_copy", + "numeric_median_fill", + "duplicates", + "null_counts", + ) + + +def test_measure_component_baseline_uses_baseline_backend_and_name() -> None: + result = measure_pandas_baseline(_case(), "null_counts", command="baseline-test") + + assert result.status == "completed" + assert result.case.backend == "pandas-component-baseline" + assert result.baseline_name == "null_counts" + assert result.result_type == "Series" + assert len(result.samples_seconds) == 1 + + +def test_measure_component_baseline_rejects_unknown_name() -> None: + with pytest.raises(ValueError, match="unknown pandas baseline"): + measure_pandas_baseline(_case(), "balanced", command="baseline-test") + + +def _result_payload( + *, + rows: int = 100, + backend: str = "pandas", + baseline_name: str | None = None, + median: float = 1.0, + cv: float = 0.01, + status: str = "completed", +) -> dict[str, object]: + return { + "schema_version": 1, + "status": status, + "case": { + "rows": rows, + "width": "narrow", + "config_name": "default", + "options": {}, + "dataset_type": "mixed", + "return_report": False, + "backend": backend, + "output_format": "pandas", + "seed": 42, + "warmups": 1, + "repetitions": 5, + }, + "environment": { + "git_commit": "abc123", + "git_dirty": False, + "python_version": "3.12", + "pandas_version": "2.3", + "numpy_version": "2.0", + "freshdata_version": "1.1.1", + "optional_versions": {}, + "platform": "test", + "processor": "test", + "cpu_count_logical": 2, + "cpu_count_physical": 1, + "total_ram_bytes": 1000, + }, + "samples_seconds": [median] if status == "completed" else [], + "median_seconds": median if status == "completed" else None, + "min_seconds": median if status == "completed" else None, + "max_seconds": median if status == "completed" else None, + "stdev_seconds": 0.0 if status == "completed" else None, + "coefficient_of_variation": cv if status == "completed" else None, + "throughput_rows_per_second": rows / median if status == "completed" else None, + "peak_rss_bytes": 200 if status == "completed" else None, + "peak_python_bytes": 100 if status == "completed" else None, + "input_bytes": 50 if status == "completed" else None, + "input_to_peak_ratio": 4.0 if status == "completed" else None, + "command": "python -m benchmarks.performance run", + "error_type": None, + "error_message": None, + "output_fingerprint": None, + "report_fingerprint": None, + "result_type": None, + "profile": None, + "baseline_name": baseline_name, + } + + +def test_analysis_matches_only_semantically_scoped_component_baselines() -> None: + freshdata = _result_payload(median=0.94) + baseline = _result_payload( + backend="pandas-component-baseline", + baseline_name="null_counts", + median=1.0, + ) + + summary = analyze_results([freshdata, baseline]) + + assert summary["results"][0]["comparisons"] == [] + assert summary["component_baselines"][0]["baseline_name"] == "null_counts" + assert "full balanced" in summary["limitations"][0] + + +def test_analysis_compares_only_an_explicit_matching_component_operation() -> None: + freshdata = _result_payload(median=0.8) + freshdata["case"]["options"] = {"comparable_baseline": "null_counts"} # type: ignore[index] + baseline = _result_payload( + backend="pandas-component-baseline", + baseline_name="null_counts", + median=1.0, + ) + + comparison = analyze_results([freshdata, baseline])["results"][0]["comparisons"][0] + + assert comparison == { + "baseline_name": "null_counts", + "baseline_seconds": 1.0, + "candidate_seconds": 0.8, + "ratio": 1.25, + "classification": "improved", + } + + +def test_renderer_is_deterministic_and_contains_required_sections() -> None: + payload = { + "schema_version": 1, + "environment": {"python_version": "3.12", "pandas_version": "2.3"}, + "results": [], + "component_baselines": [], + "hypotheses": {}, + "reproduction_commands": [], + "limitations": ["No full-pipeline pandas equivalence is claimed."], + } + first = render_report(payload) + assert first == render_report(payload) + for heading in ( + "Architecture and execution flow", + "Reproduction commands", + "Baseline benchmark table", + "Profiling findings", + "Confirmed root causes", + "Rejected hypotheses", + "Failures, timeouts, and OOMs", + "Limitations", + ): + assert f"## {heading}" in first + + +def test_renderer_labels_noise_without_an_improvement_claim() -> None: + payload = { + "schema_version": 1, + "environment": {}, + "results": [ + { + **_result_payload(), + "comparisons": [ + { + "baseline_name": "null_counts", + "ratio": 1.06, + "classification": "noise", + } + ], + } + ], + "component_baselines": [], + "hypotheses": {}, + "reproduction_commands": [], + "limitations": [], + } + + report = render_report(payload) + + assert "noise" in report + assert "improved" not in report.lower() + + +def test_analyze_and_render_cli_write_deterministic_outputs(tmp_path: Path) -> None: + input_dir = tmp_path / "raw" + input_dir.mkdir() + (input_dir / "case.json").write_text(json.dumps(_result_payload()), encoding="utf-8") + summary_path = tmp_path / "summary.json" + report_path = tmp_path / "report.md" + + assert main(["analyze", "--input", str(input_dir), "--output", str(summary_path)]) == 0 + assert main(["render", "--input", str(summary_path), "--output", str(report_path)]) == 0 + first = report_path.read_text(encoding="utf-8") + assert main(["render", "--input", str(summary_path), "--output", str(report_path)]) == 0 + assert report_path.read_text(encoding="utf-8") == first + + +def test_baseline_cli_writes_strict_component_result(tmp_path: Path) -> None: + assert ( + main( + [ + "baseline", + "--rows", + "30", + "--widths", + "narrow", + "--dataset-types", + "mixed", + "--baselines", + "null_counts", + "--warmups", + "0", + "--repetitions", + "1", + "--timeout", + "60", + "--output", + str(tmp_path), + ] + ) + == 0 + ) + payloads = [json.loads(path.read_text()) for path in tmp_path.glob("*.json")] + assert len(payloads) == 1 + assert payloads[0]["baseline_name"] == "null_counts" + assert payloads[0]["case"]["backend"] == "pandas-component-baseline" diff --git a/tests/performance/test_models_schema.py b/tests/performance/test_models_schema.py index 65eceeb..f616167 100644 --- a/tests/performance/test_models_schema.py +++ b/tests/performance/test_models_schema.py @@ -175,6 +175,41 @@ def test_result_round_trip_validates() -> None: assert BenchmarkResult.from_dict(payload).case == case +def test_component_baseline_name_round_trips_through_strict_schema() -> None: + case = BenchmarkCase( + rows=10_000, + width="narrow", + config_name="component_baseline", + options={}, + backend="pandas-component-baseline", + ) + result = BenchmarkResult.completed( + case=case, + environment=capture_environment(), + samples_seconds=[1.0], + peak_rss_bytes=1_000_000, + peak_python_bytes=500_000, + input_bytes=250_000, + command="baseline-test", + baseline_name="null_counts", + ) + + payload = result.to_dict() + validate_result(payload) + + assert payload["baseline_name"] == "null_counts" + assert BenchmarkResult.from_dict(payload).baseline_name == "null_counts" + + +def test_schema_requires_nullable_baseline_name_on_every_result() -> None: + payload = _completed_payload() + assert payload["baseline_name"] is None + del payload["baseline_name"] + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + def test_completed_result_rejects_empty_samples() -> None: with pytest.raises(ValueError, match="samples_seconds"): BenchmarkResult.completed( From 917bc29816b5f1ec6a642616449d2a7e4f0e3cf0 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sun, 12 Jul 2026 11:28:39 +0530 Subject: [PATCH 21/37] bench: harden performance evidence identity --- benchmarks/performance/analysis.py | 183 +++++++++++++++--- benchmarks/performance/cli.py | 9 +- benchmarks/performance/models.py | 13 ++ benchmarks/performance/render.py | 38 ++-- benchmarks/performance/schema.py | 26 +++ tests/performance/test_analysis_render.py | 222 +++++++++++++++++++++- tests/performance/test_models_schema.py | 54 ++++++ 7 files changed, 503 insertions(+), 42 deletions(-) diff --git a/benchmarks/performance/analysis.py b/benchmarks/performance/analysis.py index 12bcb08..2ec0612 100644 --- a/benchmarks/performance/analysis.py +++ b/benchmarks/performance/analysis.py @@ -1,60 +1,148 @@ from __future__ import annotations +import json import math from collections.abc import Iterable from pathlib import Path from typing import Any +from .models import BenchmarkCase from .schema import validate_result _HYPOTHESES = { "unnecessary_correlation": { "stages": ("correlation",), "operations": ("dataframe.corr", "dataframe.corrwith"), - "functions": ("numeric_corr_matrix", "corr", "corrwith"), - "paths": ("/engine/context.py",), + "evidence": (("/freshdata/engine/context.py", ("numeric_corr_matrix",)),), }, "repeated_null_scans": { "stages": ("missing",), "operations": ("series.isna", "series.notna"), - "functions": ("isna", "notna"), - "paths": ("/engine/missing.py", "/steps/missing.py"), + "evidence": ( + ( + "/freshdata/engine/missing.py", + ( + "auto_missing", + "_handle_column", + "_fill_low", + "_fill_medium", + "_handle_high", + "_handle_extreme", + "_fill_datetime", + "_fill", + "_assign_filled", + "_preserve", + "_drop", + "_maybe_indicator", + "_knn_fill", + "_non_collinear_partners", + ), + ), + ( + "/freshdata/steps/missing.py", + ("impute_missing", "_fill_value", "_strategy_for_column"), + ), + ), }, "repeated_uniqueness_scans": { "stages": ("role_inference",), "operations": ("series.nunique", "series.value_counts"), - "functions": ("infer_role", "build_context", "nunique", "value_counts"), - "paths": (), + "evidence": ( + ( + "/freshdata/engine/context.py", + ( + "infer_role", + "_safe_nunique", + "_mode_ratio", + "_looks_like_text", + "build_context", + "build_contexts", + ), + ), + ), }, "copy_pressure": { "stages": ("context", "engine_cache"), "operations": ("dataframe.copy", "series.copy"), - "functions": ("copy",), - "paths": ("/engine/context.py", "/engine/cache.py"), + "evidence": ( + ("/freshdata/engine/context.py", ("build_context", "build_contexts")), + ("/freshdata/engine/cache.py", ("build_engine_cache",)), + ), }, "dtype_conversion_pressure": { "stages": ("dtype_repair",), "operations": ("series.astype", "dataframe.astype"), - "functions": ("astype",), - "paths": ("/steps/dtypes.py",), + "evidence": ( + ( + "/freshdata/steps/dtypes.py", + ( + "fix_dtypes", + "suggest_conversion", + "_try_boolean", + "_try_numeric", + "_try_datetime", + "_finalize_numeric", + "_to_numeric_or_none", + "_parse_datetime", + ), + ), + ), }, "report_finalization_overhead": { "stages": ("report_finalization", "audit_events"), "operations": (), - "functions": ("memory_bytes", "cleanreport.add"), - "paths": ("/report.py", "/cleaner.py"), + "evidence": ( + ( + "/freshdata/report.py", + ("add", "to_dict", "summary", "brief", "cells_changed", "to_frame"), + ), + ("/freshdata/cleaner.py", ("run_pipeline",)), + ), }, "optional_ml_overhead": { "stages": ("semantic_ml",), "operations": (), - "functions": (), - "paths": ("/semantic/", "/imputation/missforest.py", "/sklearn/"), + "evidence": ( + ( + "/freshdata/imputation/missforest.py", + ("impute", "_fit_predict_column", "_initial_filled_frame", "_features"), + ), + ("/freshdata/semantic/apply.py", ("run_semantic", "resolve_replacements")), + ( + "/freshdata/semantic/profiler.py", + ("profile_proposals", "profile_semantic_issues", "plan_semantic"), + ), + ), }, "backend_conversion_overhead": { "stages": ("backend_conversion",), "operations": (), - "functions": (), - "paths": ("/adapters/", "/execution/backends/"), + "evidence": ( + ( + "/freshdata/adapters/polars.py", + ("to_pandas", "from_pandas", "is_polars_frame"), + ), + ( + "/freshdata/execution/backends/_pandas.py", + ("materialize_to_pandas", "execute"), + ), + ( + "/freshdata/execution/backends/_polars.py", + ("execute", "_fallback", "_to_lazy", "_collect"), + ), + ( + "/freshdata/execution/backends/_duckdb.py", + ("execute", "_fallback", "_as_arrow"), + ), + ( + "/freshdata/execution/backends/_spark.py", + ("execute", "_fallback", "_to_spark"), + ), + ( + "/freshdata/execution/backends/_freshcore.py", + ("execute", "_fallback", "_frame_from_native"), + ), + ), }, } @@ -82,12 +170,22 @@ def classify_change( def _matches( record: dict[str, object], - functions: tuple[str, ...], - paths: tuple[str, ...], + relationships: tuple[tuple[str, tuple[str, ...]], ...], ) -> bool: path = str(record.get("file", "")).replace("\\", "/").lower() function = str(record.get("function", "")).lower() - return function in functions or any(term in path for term in paths) + return any( + path.endswith(path_suffix) and function in functions + for path_suffix, functions in relationships + ) + + +def _matches_allocation( + record: dict[str, object], + relationships: tuple[tuple[str, tuple[str, ...]], ...], +) -> bool: + path = str(record.get("file", "")).replace("\\", "/").lower() + return any(path.endswith(path_suffix) for path_suffix, _functions in relationships) def classify_hypotheses( @@ -109,12 +207,12 @@ def classify_hypotheses( function_evidence = [ record for record in functions - if isinstance(record, dict) and _matches(record, rule["functions"], rule["paths"]) + if isinstance(record, dict) and _matches(record, rule["evidence"]) ] allocation_evidence = [ record for record in allocations - if isinstance(record, dict) and _matches(record, (), rule["paths"]) + if isinstance(record, dict) and _matches_allocation(record, rule["evidence"]) ] operation_calls = sum(int(operations.get(key, 0)) for key in rule["operations"]) exact_function_calls = sum(int(record.get("calls", 0)) for record in function_evidence) @@ -128,7 +226,6 @@ def classify_hypotheses( ) evidence: list[dict[str, object]] = [] evidence.extend(function_evidence) - evidence.extend(allocation_evidence) if not evidence or observed_calls == 0: status = "insufficient_evidence" elif stage_fraction >= 0.10 or significant_allocations: @@ -149,11 +246,14 @@ def _sort_key(result: dict[str, Any]) -> tuple[object, ...]: return ( case.get("rows", 0), case.get("width", ""), + case.get("dataset_type", ""), case.get("config_name", ""), case.get("return_report", False), case.get("backend", ""), case.get("output_format", ""), + case.get("seed", 0), result.get("baseline_name") or "", + case_id_for_result(result), ) @@ -219,7 +319,11 @@ def analyze_results(results: Iterable[dict[str, Any]]) -> dict[str, Any]: decisions = classify_hypotheses( profile, traced_peak_bytes=result.get("peak_python_bytes") ) - hypotheses[_case_label(result)] = decisions + case_id = case_id_for_result(result) + hypotheses[case_id] = { + "label": case_label(result), + "decisions": decisions, + } environment = ordered[0]["environment"] if ordered else {} commands = sorted( {str(result.get("command", "")) for result in ordered if result.get("command")} @@ -240,18 +344,41 @@ def analyze_results(results: Iterable[dict[str, Any]]) -> dict[str, Any]: } -def _case_label(result: dict[str, Any]) -> str: +def case_label(result: dict[str, Any]) -> str: case = result["case"] - return "/".join( - str(case[key]) - for key in ("rows", "width", "config_name", "return_report", "backend", "output_format") + return " ".join( + ( + f"case_id={case_id_for_result(result)}", + f"rows={case['rows']}", + f"width={case['width']}", + f"dataset_type={case['dataset_type']}", + f"config={case['config_name']}", + f"options={json.dumps(case['options'], sort_keys=True, separators=(',', ':'))}", + f"report={str(case['return_report']).lower()}", + f"backend={case['backend']}", + f"output={case['output_format']}", + f"seed={case['seed']}", + f"warmups={case['warmups']}", + f"repetitions={case['repetitions']}", + ) ) +def case_id_for_result(result: dict[str, Any]) -> str: + return BenchmarkCase(**result["case"]).case_id + + +def _reject_non_standard_json_constant(value: str) -> None: + raise ValueError(f"result JSON contains non-standard constant: {value}") + + def load_results(input_dir: Path) -> list[dict[str, Any]]: payloads: list[dict[str, Any]] = [] for path in sorted(input_dir.glob("*.json")): - payload = __import__("json").loads(path.read_text(encoding="utf-8")) + payload = json.loads( + path.read_text(encoding="utf-8"), + parse_constant=_reject_non_standard_json_constant, + ) if not isinstance(payload, dict): raise TypeError(f"result must be an object: {path}") validate_result(payload) diff --git a/benchmarks/performance/cli.py b/benchmarks/performance/cli.py index 0755870..db44610 100644 --- a/benchmarks/performance/cli.py +++ b/benchmarks/performance/cli.py @@ -19,6 +19,10 @@ def _comma_separated(value: str) -> list[str]: return value.split(",") +def _reject_non_standard_json_constant(value: str) -> None: + raise ValueError(f"summary JSON contains non-standard constant: {value}") + + def _report_modes(value: str) -> list[bool]: modes = _comma_separated(value) if any(mode not in {"false", "true"} for mode in modes): @@ -106,7 +110,10 @@ def main(argv: list[str] | None = None) -> int: ) return 0 if arguments.subcommand == "render": - payload = json.loads(Path(arguments.input).read_text(encoding="utf-8")) + payload = json.loads( + Path(arguments.input).read_text(encoding="utf-8"), + parse_constant=_reject_non_standard_json_constant, + ) if not isinstance(payload, dict): parser.error("render input must be a JSON object") Path(arguments.output).parent.mkdir(parents=True, exist_ok=True) diff --git a/benchmarks/performance/models.py b/benchmarks/performance/models.py index 6a1d4f4..cf5c4ed 100644 --- a/benchmarks/performance/models.py +++ b/benchmarks/performance/models.py @@ -32,6 +32,10 @@ "high_cardinality", ) ) +_COMPONENT_BASELINES = frozenset( + ("shallow_copy", "numeric_median_fill", "duplicates", "null_counts") +) +_COMPONENT_BASELINE_BACKEND = "pandas-component-baseline" def _validate_integer(name: str, value: object, *, minimum: int | None = None) -> None: @@ -148,6 +152,15 @@ class BenchmarkResult: profile: ProfileResult | None = None baseline_name: str | None = None + def __post_init__(self) -> None: + if self.case.backend == _COMPONENT_BASELINE_BACKEND: + if self.baseline_name not in _COMPONENT_BASELINES: + raise ValueError( + "baseline_name must identify a supported pandas component baseline" + ) + elif self.baseline_name is not None: + raise ValueError("baseline_name must be null for non-component backends") + @classmethod def completed( cls, diff --git a/benchmarks/performance/render.py b/benchmarks/performance/render.py index 9018038..3f588f7 100644 --- a/benchmarks/performance/render.py +++ b/benchmarks/performance/render.py @@ -2,6 +2,8 @@ from typing import Any +from .analysis import case_id_for_result, case_label + def _number(value: object, digits: int = 3) -> str: if value is None: @@ -18,11 +20,14 @@ def _case_sort_key(result: dict[str, Any]) -> tuple[object, ...]: return ( case.get("rows", 0), case.get("width", ""), + case.get("dataset_type", ""), case.get("config_name", ""), case.get("return_report", False), case.get("backend", ""), case.get("output_format", ""), + case.get("seed", 0), result.get("baseline_name") or "", + case_id_for_result(result), ) @@ -83,9 +88,9 @@ def render_report(payload: dict[str, Any]) -> str: # noqa: PLR0915 failures = [item for item in all_results if item.get("status") != "completed"] hypotheses = payload.get("hypotheses", {}) decisions = [ - (case, name, decision) - for case, case_decisions in sorted(hypotheses.items()) - for name, decision in sorted(case_decisions.items()) + (case_id, case_record["label"], name, decision) + for case_id, case_record in sorted(hypotheses.items()) + for name, decision in sorted(case_record["decisions"].items()) ] lines = [ "# FreshData performance evidence", @@ -123,7 +128,7 @@ def render_report(payload: dict[str, Any]) -> str: # noqa: PLR0915 if not isinstance(profile, dict): continue profile_found = True - lines.append(f"### {result['case']['rows']} rows / {result['case']['width']}") + lines.append(f"### {case_label(result)}") lines.append("") total = float(profile.get("stages", {}).get("total", 0.0)) for stage, seconds in sorted(profile.get("stages", {}).items()): @@ -131,7 +136,18 @@ def render_report(payload: dict[str, Any]) -> str: # noqa: PLR0915 continue fraction = float(seconds) / total if total else 0.0 lines.append(f"- {stage}: {fraction:.1%}") - for function in profile.get("functions", [])[:10]: + functions = sorted( + profile.get("functions", []), + key=lambda item: ( + -float(item["cumulative_seconds"]), + -float(item["self_seconds"]), + str(item["file"]).replace("\\", "/"), + int(item["line"]), + str(item["function"]), + int(item["calls"]), + ), + ) + for function in functions[:10]: lines.append( f"- `{function['file']}:{function['line']} {function['function']}` — " f"self {_number(function['self_seconds'])} s, cumulative " @@ -142,26 +158,26 @@ def render_report(payload: dict[str, Any]) -> str: # noqa: PLR0915 if not profile_found: lines.append("No profiling records were supplied.") lines.extend(["", "## Confirmed root causes", ""]) - candidates = [item for item in decisions if item[2].get("status") == "candidate"] + candidates = [item for item in decisions if item[3].get("status") == "candidate"] if candidates: lines.append( "No cause is confirmed by profiling alone; these exact-evidence items are " "performance candidates:" ) lines.append("") - for case, name, decision in candidates: + for case_id, label, name, decision in candidates: lines.append( - f"- `{name}` in `{case}`: candidate; stage " + f"- `{name}` in `{case_id}` ({label}): candidate; stage " f"{float(decision['stage_fraction']):.1%}, observed calls " f"{decision['observed_calls']}." ) if not candidates: lines.append("No root cause met the exact-evidence and significance thresholds.") lines.extend(["", "## Rejected hypotheses", ""]) - rejected = [item for item in decisions if item[2].get("status") != "candidate"] - for case, name, decision in rejected: + rejected = [item for item in decisions if item[3].get("status") != "candidate"] + for case_id, label, name, decision in rejected: lines.append( - f"- `{name}` in `{case}`: {decision['status']}; stage " + f"- `{name}` in `{case_id}` ({label}): {decision['status']}; stage " f"{float(decision['stage_fraction']):.1%}, observed calls " f"{decision['observed_calls']}." ) diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py index a36e82c..796a760 100644 --- a/benchmarks/performance/schema.py +++ b/benchmarks/performance/schema.py @@ -18,6 +18,32 @@ } }, "type": "object", + "allOf": [ + { + "if": { + "properties": { + "case": { + "properties": {"backend": {"const": "pandas-component-baseline"}}, + "required": ["backend"], + } + }, + "required": ["case"], + }, + "then": { + "properties": { + "baseline_name": { + "enum": [ + "shallow_copy", + "numeric_median_fill", + "duplicates", + "null_counts", + ] + } + } + }, + "else": {"properties": {"baseline_name": {"type": "null"}}}, + } + ], "required": [ "schema_version", "status", diff --git a/tests/performance/test_analysis_render.py b/tests/performance/test_analysis_render.py index 4720ece..5bab456 100644 --- a/tests/performance/test_analysis_render.py +++ b/tests/performance/test_analysis_render.py @@ -8,6 +8,7 @@ analyze_results, classify_change, classify_hypotheses, + load_results, ) from benchmarks.performance.baselines import BASELINES, measure_pandas_baseline from benchmarks.performance.cli import main @@ -165,7 +166,7 @@ def test_hypothesis_classifier_rejects_observed_but_small_work() -> None: { "file": "src/freshdata/engine/missing.py", "line": 8, - "function": "scan_missing", + "function": "auto_missing", "self_seconds": 0.09, "cumulative_seconds": 0.09, "calls": 4, @@ -181,6 +182,16 @@ def test_hypothesis_classifier_rejects_observed_but_small_work() -> None: def test_hypothesis_classifier_can_use_exact_peak_allocation_evidence() -> None: profile = _empty_profile() profile["operations"]["dataframe.copy"] = 2 # type: ignore[index] + profile["functions"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": 231, + "function": "build_context", + "self_seconds": 0.01, + "cumulative_seconds": 0.01, + "calls": 1, + } + ] profile["allocations"] = [ { "file": "src/freshdata/engine/context.py", @@ -199,7 +210,98 @@ def test_hypothesis_classifier_can_use_exact_peak_allocation_evidence() -> None: decision = classify_hypotheses(profile, traced_peak_bytes=1_000)["copy_pressure"] assert decision["status"] == "candidate" - assert decision["evidence"] == [profile["allocations"][0]] # type: ignore[index] + assert decision["evidence"] == profile["functions"] + + +@pytest.mark.parametrize( + "hypothesis,stage,operation,path,function", + [ + ( + "unnecessary_correlation", + "correlation", + "dataframe.corr", + "src/freshdata/engine/context.py", + "numeric_corr_matrix", + ), + ( + "repeated_null_scans", + "missing", + "series.isna", + "src/freshdata/engine/missing.py", + "auto_missing", + ), + ( + "repeated_uniqueness_scans", + "role_inference", + "series.nunique", + "src/freshdata/engine/context.py", + "infer_role", + ), + ( + "copy_pressure", + "context", + "dataframe.copy", + "src/freshdata/engine/context.py", + "build_context", + ), + ( + "dtype_conversion_pressure", + "dtype_repair", + "series.astype", + "src/freshdata/steps/dtypes.py", + "fix_dtypes", + ), + ( + "report_finalization_overhead", + "report_finalization", + None, + "src/freshdata/report.py", + "to_dict", + ), + ( + "optional_ml_overhead", + "semantic_ml", + None, + "src/freshdata/imputation/missforest.py", + "impute", + ), + ( + "backend_conversion_overhead", + "backend_conversion", + None, + "src/freshdata/adapters/polars.py", + "to_pandas", + ), + ], +) +def test_hypothesis_evidence_requires_approved_path_and_exact_function( + hypothesis: str, + stage: str, + operation: str | None, + path: str, + function: str, +) -> None: + profile = _empty_profile() + profile["stages"][stage] = 0.2 # type: ignore[index] + if operation is not None: + profile["operations"][operation] = 1 # type: ignore[index] + record = { + "file": path, + "line": 17, + "function": function, + "self_seconds": 0.2, + "cumulative_seconds": 0.2, + "calls": 1, + } + profile["functions"] = [record] + + assert classify_hypotheses(profile)[hypothesis]["status"] == "candidate" + + profile["functions"] = [{**record, "file": f"{path}.bak"}] + assert classify_hypotheses(profile)[hypothesis]["status"] == "insufficient_evidence" + + profile["functions"] = [{**record, "function": f"unrelated_{function}"}] + assert classify_hypotheses(profile)[hypothesis]["status"] == "insufficient_evidence" def test_all_required_hypotheses_are_classified() -> None: @@ -335,6 +437,25 @@ def test_analysis_compares_only_an_explicit_matching_component_operation() -> No } +def test_analysis_keys_profiles_by_stable_case_id_without_collisions() -> None: + first = _result_payload() + first["profile"] = _empty_profile() + second = _result_payload() + second["case"]["dataset_type"] = "numeric" # type: ignore[index] + second["case"]["seed"] = 99 # type: ignore[index] + second["profile"] = _empty_profile() + first_id = BenchmarkCase(**first["case"]).case_id # type: ignore[arg-type] + second_id = BenchmarkCase(**second["case"]).case_id # type: ignore[arg-type] + + hypotheses = analyze_results([first, second])["hypotheses"] + + assert set(hypotheses) == {first_id, second_id} + assert "dataset_type=mixed" in hypotheses[first_id]["label"] + assert "seed=42" in hypotheses[first_id]["label"] + assert "dataset_type=numeric" in hypotheses[second_id]["label"] + assert "seed=99" in hypotheses[second_id]["label"] + + def test_renderer_is_deterministic_and_contains_required_sections() -> None: payload = { "schema_version": 1, @@ -388,6 +509,75 @@ def test_renderer_labels_noise_without_an_improvement_claim() -> None: assert "improved" not in report.lower() +def test_renderer_profile_heading_contains_full_case_identity() -> None: + result = _result_payload() + result["profile"] = _empty_profile() + case_id = BenchmarkCase(**result["case"]).case_id # type: ignore[arg-type] + payload = { + "schema_version": 1, + "environment": {}, + "results": [result], + "component_baselines": [], + "hypotheses": {}, + "reproduction_commands": [], + "limitations": [], + } + + report = render_report(payload) + + heading = next(line for line in report.splitlines() if line.startswith("### ")) + for value in ( + case_id, + "rows=100", + "width=narrow", + "dataset_type=mixed", + "config=default", + "report=false", + "backend=pandas", + "output=pandas", + "seed=42", + ): + assert value in heading + + +def test_renderer_sorts_profile_functions_independently_of_payload_order() -> None: + result = _result_payload() + profile = _empty_profile() + functions = [ + { + "file": "src/freshdata/z.py", + "line": 2, + "function": "zeta", + "self_seconds": 0.1, + "cumulative_seconds": 0.2, + "calls": 1, + }, + { + "file": "src/freshdata/a.py", + "line": 1, + "function": "alpha", + "self_seconds": 0.2, + "cumulative_seconds": 0.4, + "calls": 2, + }, + ] + profile["functions"] = functions + result["profile"] = profile + payload = { + "schema_version": 1, + "environment": {}, + "results": [result], + "component_baselines": [], + "hypotheses": {}, + "reproduction_commands": [], + "limitations": [], + } + reordered = json.loads(json.dumps(payload)) + reordered["results"][0]["profile"]["functions"].reverse() + + assert render_report(payload) == render_report(reordered) + + def test_analyze_and_render_cli_write_deterministic_outputs(tmp_path: Path) -> None: input_dir = tmp_path / "raw" input_dir.mkdir() @@ -402,6 +592,34 @@ def test_analyze_and_render_cli_write_deterministic_outputs(tmp_path: Path) -> N assert report_path.read_text(encoding="utf-8") == first +@pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"]) +def test_load_results_rejects_non_standard_json_constants(tmp_path: Path, constant: str) -> None: + (tmp_path / "invalid.json").write_text( + '{"schema_version": 1, "median_seconds": ' + constant + "}", + encoding="utf-8", + ) + + with pytest.raises(ValueError, match="non-standard constant"): + load_results(tmp_path) + + +@pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"]) +def test_render_cli_rejects_non_standard_json_constants(tmp_path: Path, constant: str) -> None: + input_path = tmp_path / "summary.json" + input_path.write_text('{"schema_version": 1, "bad": ' + constant + "}", encoding="utf-8") + + with pytest.raises(ValueError, match="non-standard constant"): + main( + [ + "render", + "--input", + str(input_path), + "--output", + str(tmp_path / "report.md"), + ] + ) + + def test_baseline_cli_writes_strict_component_result(tmp_path: Path) -> None: assert ( main( diff --git a/tests/performance/test_models_schema.py b/tests/performance/test_models_schema.py index f616167..402f215 100644 --- a/tests/performance/test_models_schema.py +++ b/tests/performance/test_models_schema.py @@ -210,6 +210,60 @@ def test_schema_requires_nullable_baseline_name_on_every_result() -> None: validate_result(payload) +@pytest.mark.parametrize( + "baseline_name", + ["shallow_copy", "numeric_median_fill", "duplicates", "null_counts"], +) +def test_schema_accepts_only_named_component_baselines(baseline_name: str) -> None: + payload = _completed_payload() + payload["case"]["backend"] = "pandas-component-baseline" # type: ignore[index] + payload["baseline_name"] = baseline_name + + validate_result(payload) + + +@pytest.mark.parametrize("baseline_name", [None, "balanced", "unknown"]) +def test_schema_rejects_missing_or_unknown_component_baseline( + baseline_name: str | None, +) -> None: + payload = _completed_payload() + payload["case"]["backend"] = "pandas-component-baseline" # type: ignore[index] + payload["baseline_name"] = baseline_name + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +@pytest.mark.parametrize("backend", ["pandas", "polars", "unsupported"]) +def test_schema_rejects_baseline_name_for_non_component_backend(backend: str) -> None: + payload = _completed_payload() + payload["case"]["backend"] = backend # type: ignore[index] + payload["baseline_name"] = "null_counts" + + with pytest.raises(jsonschema.ValidationError): + validate_result(payload) + + +def test_result_model_rejects_inconsistent_baseline_identity() -> None: + with pytest.raises(ValueError, match="baseline_name"): + BenchmarkResult.completed( + case=BenchmarkCase( + rows=10, + width="narrow", + config_name="component", + options={}, + backend="pandas-component-baseline", + ), + environment=capture_environment(), + samples_seconds=[1.0], + peak_rss_bytes=1, + peak_python_bytes=1, + input_bytes=1, + command="x", + baseline_name="balanced", + ) + + def test_completed_result_rejects_empty_samples() -> None: with pytest.raises(ValueError, match="samples_seconds"): BenchmarkResult.completed( From 8092337314e1ff40e26cac9db71b4ab2b58a575e Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sun, 12 Jul 2026 15:59:01 +0530 Subject: [PATCH 22/37] bench: require finite exact performance evidence --- .superpowers/sdd/task-6-report.md | 174 ++++++++++++++++++++++ benchmarks/performance/analysis.py | 20 ++- benchmarks/performance/cli.py | 3 +- benchmarks/performance/render.py | 2 + benchmarks/performance/schema.py | 16 ++ tests/performance/test_analysis_render.py | 82 +++++++++- 6 files changed, 287 insertions(+), 10 deletions(-) create mode 100644 .superpowers/sdd/task-6-report.md diff --git a/.superpowers/sdd/task-6-report.md b/.superpowers/sdd/task-6-report.md new file mode 100644 index 0000000..eae3e78 --- /dev/null +++ b/.superpowers/sdd/task-6-report.md @@ -0,0 +1,174 @@ +# Task 6 Report: Comparable Pandas Baselines, Analysis, and Markdown Rendering + +## Status + +Implemented Task 6 against base `7bcf97541a9b7f186e7cc68d11b00e1d11c8ce7d`. + +The implementation adds only named pandas component baselines. It does not claim a +full pandas equivalent of FreshData's balanced decision/audit pipeline. A comparison +is produced only when a FreshData case explicitly declares +`options.comparable_baseline` with the exact component baseline name. + +## RED + +- `tests/performance/test_analysis_render.py` initially failed collection with + `ModuleNotFoundError: No module named 'benchmarks.performance.analysis'`. +- The strict result-model tests initially failed because `BenchmarkResult.completed` + rejected `baseline_name` and ordinary payloads omitted the required nullable field. +- Boundary coverage exposed floating-point behavior at an exact 10% change; the test + expected `improved` while the initial implementation returned `noise`. +- Exact-evidence coverage demonstrated that partial names such as + `correlation_label` were incorrectly accepted as correlation evidence. +- Semantic-comparison coverage demonstrated that explicitly matched component cases + initially produced no comparison. + +## GREEN + +- Added required nullable `baseline_name` to the strict result model/schema; ordinary + FreshData results serialize it as `null`, component results serialize the exact + baseline key, and round trips preserve it. +- Added only the corrected component operations: `shallow_copy`, + `numeric_median_fill`, `duplicates`, and `null_counts`. +- Added an isolated baseline worker path using one warm-up/five repetitions by default + and a separate PeakRSS/tracemalloc measurement. The + `pandas-component-baseline` sentinel is handled only by this path and is never sent + to `fd.clean`. +- Added `classify_change` with the required absolute 10% threshold and twice the + larger observed CV threshold. +- Added all eight hypothesis classifications. Candidate status requires non-zero + relevant observed calls, exact function/path/line evidence, and either a 10% stage + fraction or a 10% traced-peak allocation fraction. +- Added deterministic analysis ordering and Markdown rendering with exact commands, + metric ranges/CV/throughput, memory ratios, scoped comparisons, stage percentages, + exact function locations, candidate/rejected/evidence-limited hypotheses, durable + failures, and limitations. Noise is labeled as noise and never rendered as an + improvement. +- Added `baseline`, `analyze`, and `render` CLI commands. + +## Verification + +- `.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts=''` + - `144 passed in 15.97s` +- `.venv-qa/bin/ruff check benchmarks/performance tests/performance` + - `All checks passed!` +- `.venv-qa/bin/ruff format --check benchmarks/performance tests/performance` + - `21 files already formatted` +- `git diff --check` + - clean + +## Broader-suite observation + +A diagnostic full-repository run with warnings promoted to errors reached one +unrelated existing failure in `tests/test_cleanbench_public_release.py`: the legacy +CleanBench pandas baseline emits a pandas datetime-inference `UserWarning`, which its +harness converts to `status="skipped"` under `-W error`. The Task 6 performance suite +is warning-free, and no production or legacy CleanBench code was changed. + +## Commit + +- `7ef5e79` — `bench: analyze and render scalability evidence` + +## Concerns + +- Component comparisons are intentionally opt-in and semantically scoped. Existing + full FreshData cases do not declare component equivalence, so their comparison list + remains empty rather than presenting a misleading balanced-pipeline claim. +- `.venv-qa/` remains untracked and untouched. + +--- + +## Review Fix Wave + +### RED + +The focused review suite produced 25 expected failures before implementation: + +- `load_results` accepted `NaN`, `Infinity`, and `-Infinity` until downstream + validation, while the render CLI accepted all three outright. +- Hypothesis evidence accepted approved function names from `.bak` files and + unrelated functions from approved files because matching used OR/substring logic. +- Profile hypotheses collided under an incomplete label when cases differed only by + dataset type or seed. +- Component backend payloads accepted null, unknown, and forbidden `balanced` + baseline names; non-component backends accepted non-null baseline names. +- `BenchmarkResult` could construct an inconsistent component-baseline identity. +- Profile headings omitted case identity and function rendering depended on payload + order. + +### GREEN + +- Both JSON input paths now pass `parse_constant` callbacks to `json.loads` and reject + all three non-standard constants before accepting the payload. +- Hypotheses are keyed by `BenchmarkCase.case_id`; each record retains a complete + human label with case ID, rows, width, dataset type, config/options, report flag, + backend/output, seed, warm-ups, and repetitions. +- The strict result schema conditionally requires one of exactly + `shallow_copy`, `numeric_median_fill`, `duplicates`, or `null_counts` for the + `pandas-component-baseline` backend and requires null for every other backend. + `BenchmarkResult` enforces the same invariant at construction time. +- Every hypothesis uses explicit approved path-suffix/exact-function relationships. + Matching requires both conditions, so `.bak` paths and unrelated context functions + cannot qualify. Allocation significance is considered only alongside exact + function evidence for the same hypothesis family. +- Profile headings render the complete case identity. Top functions are sorted by a + canonical metric/location key before the top ten are selected, making equivalent + payloads order-independent. + +### Review Verification + +- `.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts=''` + - `172 passed in 23.12s` +- `.venv-qa/bin/ruff check benchmarks/performance tests/performance` + - `All checks passed!` +- `.venv-qa/bin/ruff format --check benchmarks/performance tests/performance` + - `21 files already formatted` +- Python 3.9 grammar check using `ast.parse(..., feature_version=(3, 9))` + - `Python 3.9 grammar: 21 files parsed` + +### Review Commit + +- `917bc29` — `bench: harden performance evidence identity` + +--- + +## Final Review Fix Wave + +### RED + +A focused regression run produced eight expected failures before implementation: + +- allocation bytes from `context.py:44` incorrectly combined with exact + `build_context` function evidence from `context.py:231`, creating a candidate; +- `classify_change` accepted direct `NaN`, positive infinity, and negative infinity; +- the render CLI accepted JSON `1e999`, which Python parses as positive infinity; +- `render_report` accepted nested direct `NaN`, positive infinity, and negative + infinity values. + +The matching `load_results` overflow case and direct `analyze_results` cases were +also added; their existing strict result validation already rejected the values. + +### GREEN + +- Added recursive finite-float validation and invoked it after JSON parsing, during + strict result validation, and at the public analysis, hypothesis, comparison, and + render entry points. Boolean handling remains delegated to the existing schema and + model semantics. +- Kept strict JSON serialization with `allow_nan=False` on generated JSON output. +- Allocation significance now counts only records whose normalized file and exact + line equal a location from already matched exact function evidence. Same-file bytes + from another line no longer satisfy the 10% threshold. +- Added positive and negative allocation-location coverage and JSON-overflow/direct + programmatic non-finite coverage for load, analysis, render CLI, and renderer paths. + +### Final Review Verification + +- `.venv-qa/bin/python -m pytest tests/performance/test_analysis_render.py tests/performance/test_models_schema.py tests/performance/test_instrumentation.py -q --no-cov -W error -o addopts=''` + - `148 passed in 6.54s` +- `.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts=''` + - `181 passed in 16.52s` +- `.venv-qa/bin/ruff check benchmarks/performance tests/performance` + - `All checks passed!` +- `.venv-qa/bin/ruff format --check benchmarks/performance tests/performance` + - `21 files already formatted` +- Python 3.9 grammar check using `ast.parse(..., feature_version=(3, 9))` + - `Python 3.9 grammar: 21 files parsed` diff --git a/benchmarks/performance/analysis.py b/benchmarks/performance/analysis.py index 2ec0612..516b2e2 100644 --- a/benchmarks/performance/analysis.py +++ b/benchmarks/performance/analysis.py @@ -7,7 +7,7 @@ from typing import Any from .models import BenchmarkCase -from .schema import validate_result +from .schema import validate_finite_numbers, validate_result _HYPOTHESES = { "unnecessary_correlation": { @@ -153,6 +153,7 @@ def classify_change( baseline_cv: float, candidate_cv: float, ) -> str: + validate_finite_numbers([baseline, candidate, baseline_cv, candidate_cv], "comparison inputs") if baseline <= 0: raise ValueError("baseline must be positive") if candidate < 0: @@ -180,17 +181,16 @@ def _matches( ) -def _matches_allocation( - record: dict[str, object], - relationships: tuple[tuple[str, tuple[str, ...]], ...], -) -> bool: +def _source_location(record: dict[str, object]) -> tuple[str, int]: path = str(record.get("file", "")).replace("\\", "/").lower() - return any(path.endswith(path_suffix) for path_suffix, _functions in relationships) + return path, int(record.get("line", -1)) def classify_hypotheses( profile: dict[str, object], *, traced_peak_bytes: int | None = None ) -> dict[str, dict[str, object]]: + validate_finite_numbers(profile, "profile") + validate_finite_numbers(traced_peak_bytes, "traced peak bytes") stages = profile.get("stages", {}) operations = profile.get("operations", {}) functions = profile.get("functions", []) @@ -209,10 +209,11 @@ def classify_hypotheses( for record in functions if isinstance(record, dict) and _matches(record, rule["evidence"]) ] + exact_function_locations = {_source_location(record) for record in function_evidence} allocation_evidence = [ record for record in allocations - if isinstance(record, dict) and _matches_allocation(record, rule["evidence"]) + if isinstance(record, dict) and _source_location(record) in exact_function_locations ] operation_calls = sum(int(operations.get(key, 0)) for key in rule["operations"]) exact_function_calls = sum(int(record.get("calls", 0)) for record in function_evidence) @@ -258,7 +259,9 @@ def _sort_key(result: dict[str, Any]) -> tuple[object, ...]: def analyze_results(results: Iterable[dict[str, Any]]) -> dict[str, Any]: - ordered = sorted((dict(result) for result in results), key=_sort_key) + materialized = [dict(result) for result in results] + validate_finite_numbers(materialized, "analysis results") + ordered = sorted(materialized, key=_sort_key) for result in ordered: validate_result(result) component_baselines = [ @@ -381,6 +384,7 @@ def load_results(input_dir: Path) -> list[dict[str, Any]]: ) if not isinstance(payload, dict): raise TypeError(f"result must be an object: {path}") + validate_finite_numbers(payload, f"result JSON {path}") validate_result(payload) payloads.append(payload) return payloads diff --git a/benchmarks/performance/cli.py b/benchmarks/performance/cli.py index db44610..0f3bb2f 100644 --- a/benchmarks/performance/cli.py +++ b/benchmarks/performance/cli.py @@ -11,7 +11,7 @@ from .baselines import BASELINES, expand_baseline_cases, run_baseline_matrix from .render import render_report from .runner import expand_cases, run_matrix -from .schema import validate_result +from .schema import validate_finite_numbers, validate_result from .worker import execute_profile_case @@ -116,6 +116,7 @@ def main(argv: list[str] | None = None) -> int: ) if not isinstance(payload, dict): parser.error("render input must be a JSON object") + validate_finite_numbers(payload, "summary JSON") Path(arguments.output).parent.mkdir(parents=True, exist_ok=True) Path(arguments.output).write_text(render_report(payload), encoding="utf-8") return 0 diff --git a/benchmarks/performance/render.py b/benchmarks/performance/render.py index 3f588f7..02ac9e0 100644 --- a/benchmarks/performance/render.py +++ b/benchmarks/performance/render.py @@ -3,6 +3,7 @@ from typing import Any from .analysis import case_id_for_result, case_label +from .schema import validate_finite_numbers def _number(value: object, digits: int = 3) -> str: @@ -80,6 +81,7 @@ def _table(results: list[dict[str, Any]]) -> list[str]: def render_report(payload: dict[str, Any]) -> str: # noqa: PLR0915 + validate_finite_numbers(payload, "report payload") environment = payload.get("environment", {}) results = list(payload.get("results", [])) baselines = list(payload.get("component_baselines", [])) diff --git a/benchmarks/performance/schema.py b/benchmarks/performance/schema.py index 796a760..f55df02 100644 --- a/benchmarks/performance/schema.py +++ b/benchmarks/performance/schema.py @@ -1,6 +1,7 @@ from __future__ import annotations import json +import math from typing import Any RESULT_SCHEMA = { @@ -303,9 +304,24 @@ } +def validate_finite_numbers(value: object, path: str = "payload") -> None: + if isinstance(value, float): + if not math.isfinite(value): + raise ValueError(f"{path} must contain only finite JSON numbers") + return + if isinstance(value, list): + for index, item in enumerate(value): + validate_finite_numbers(item, f"{path}[{index}]") + return + if isinstance(value, dict): + for key, item in value.items(): + validate_finite_numbers(item, f"{path}.{key}") + + def validate_result(payload: dict[str, Any]) -> None: import jsonschema # noqa: PLC0415 + validate_finite_numbers(payload, "result payload") try: json.dumps(payload, allow_nan=False) except ValueError as exc: diff --git a/tests/performance/test_analysis_render.py b/tests/performance/test_analysis_render.py index 5bab456..5a26bb1 100644 --- a/tests/performance/test_analysis_render.py +++ b/tests/performance/test_analysis_render.py @@ -195,7 +195,7 @@ def test_hypothesis_classifier_can_use_exact_peak_allocation_evidence() -> None: profile["allocations"] = [ { "file": "src/freshdata/engine/context.py", - "line": 44, + "line": 231, "bytes": 120, "count": 2, }, @@ -213,6 +213,33 @@ def test_hypothesis_classifier_can_use_exact_peak_allocation_evidence() -> None: assert decision["evidence"] == profile["functions"] +def test_hypothesis_classifier_rejects_allocation_from_different_exact_line() -> None: + profile = _empty_profile() + profile["operations"]["dataframe.copy"] = 2 # type: ignore[index] + profile["functions"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": 231, + "function": "build_context", + "self_seconds": 0.01, + "cumulative_seconds": 0.01, + "calls": 1, + } + ] + profile["allocations"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": 44, + "bytes": 120, + "count": 2, + } + ] + + decision = classify_hypotheses(profile, traced_peak_bytes=1_000)["copy_pressure"] + + assert decision["status"] == "rejected" + + @pytest.mark.parametrize( "hypothesis,stage,operation,path,function", [ @@ -603,6 +630,27 @@ def test_load_results_rejects_non_standard_json_constants(tmp_path: Path, consta load_results(tmp_path) +def test_load_results_rejects_json_number_that_overflows_to_infinity(tmp_path: Path) -> None: + payload = json.dumps(_result_payload()).replace( + '"median_seconds": 1.0', '"median_seconds": 1e999' + ) + (tmp_path / "invalid.json").write_text(payload, encoding="utf-8") + + with pytest.raises(ValueError, match="finite"): + load_results(tmp_path) + + +@pytest.mark.parametrize("value", [float("nan"), float("inf"), float("-inf")]) +def test_analysis_public_entry_points_reject_non_finite_numbers(value: float) -> None: + payload = _result_payload() + payload["median_seconds"] = value + + with pytest.raises(ValueError, match="finite"): + analyze_results([payload]) + with pytest.raises(ValueError, match="finite"): + classify_change(value, 1.0, 0.0, 0.0) + + @pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"]) def test_render_cli_rejects_non_standard_json_constants(tmp_path: Path, constant: str) -> None: input_path = tmp_path / "summary.json" @@ -620,6 +668,38 @@ def test_render_cli_rejects_non_standard_json_constants(tmp_path: Path, constant ) +def test_render_cli_rejects_json_number_that_overflows_to_infinity(tmp_path: Path) -> None: + input_path = tmp_path / "summary.json" + input_path.write_text('{"schema_version": 1, "bad": 1e999}', encoding="utf-8") + + with pytest.raises(ValueError, match="finite"): + main( + [ + "render", + "--input", + str(input_path), + "--output", + str(tmp_path / "report.md"), + ] + ) + + +@pytest.mark.parametrize("value", [float("nan"), float("inf"), float("-inf")]) +def test_render_report_rejects_non_finite_numbers(value: float) -> None: + payload = { + "schema_version": 1, + "environment": {"nested": [value]}, + "results": [], + "component_baselines": [], + "hypotheses": {}, + "reproduction_commands": [], + "limitations": [], + } + + with pytest.raises(ValueError, match="finite"): + render_report(payload) + + def test_baseline_cli_writes_strict_component_result(tmp_path: Path) -> None: assert ( main( From f2ea616e9d671ed04e0e7e727223e7fd6a275827 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sun, 12 Jul 2026 16:09:46 +0530 Subject: [PATCH 23/37] bench: integrate large performance investigation workflow --- .github/workflows/performance-large.yml | 77 +++++++++++++ .gitignore | 8 +- .superpowers/sdd/task-7-report.md | 140 ++++++++++++++++++++++++ Makefile | 20 +++- docs/benchmarks.md | 21 ++++ docs/performance-investigation.md | 125 +++++++++++++++++++++ mkdocs.yml | 1 + tests/performance/test_contracts.py | 128 ++++++++++++++++++++++ 8 files changed, 517 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/performance-large.yml create mode 100644 .superpowers/sdd/task-7-report.md create mode 100644 docs/performance-investigation.md create mode 100644 tests/performance/test_contracts.py diff --git a/.github/workflows/performance-large.yml b/.github/workflows/performance-large.yml new file mode 100644 index 0000000..2d83fd1 --- /dev/null +++ b/.github/workflows/performance-large.yml @@ -0,0 +1,77 @@ +name: Large performance investigation + +on: + workflow_dispatch: + schedule: + - cron: "0 4 * * 0" + +permissions: + contents: read + +jobs: + performance-large: + runs-on: ubuntu-latest + timeout-minutes: 180 + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Install benchmark dependencies + run: | + python -m pip install --upgrade pip + pip install -e ".[dev,bench,ml]" + + - name: Run large performance matrix + id: benchmark + continue-on-error: true + run: >- + python -m benchmarks.performance run + --rows 100000,500000,1000000 + --widths narrow,medium,wide + --configs default,conservative,representation_off,statistical_off,explicit + --report-modes false,true + --warmups 1 + --repetitions 5 + --timeout 1800 + --output benchmarks/results/performance/large + + - name: Analyze all completed and failed cases + id: analyze + if: always() + continue-on-error: true + run: >- + python -m benchmarks.performance analyze + --input benchmarks/results/performance/large + --output benchmarks/results/performance/large-summary.json + + - name: Render compact report + id: render + if: always() + continue-on-error: true + run: >- + python -m benchmarks.performance render + --input benchmarks/results/performance/large-summary.json + --output benchmarks/results/performance/large-report.md + + - name: Upload performance evidence + id: upload + if: always() + uses: actions/upload-artifact@v4 + with: + name: performance-large-${{ github.run_id }} + path: benchmarks/results/performance/ + if-no-files-found: error + + - name: Preserve failure status after evidence upload + if: >- + always() && + (steps.benchmark.outcome != 'success' || + steps.analyze.outcome != 'success' || + steps.render.outcome != 'success' || + steps.upload.outcome != 'success') + run: exit 1 diff --git a/.gitignore b/.gitignore index 06efe6b..b80f027 100644 --- a/.gitignore +++ b/.gitignore @@ -23,8 +23,12 @@ src/freshdata/benchmarks/results/ /tmp/freshdata_bench/ /tmp/freshdata_spill/ -# Benchmark Release harness: runtime results and generated fixture files -benchmarks/results/ +# Benchmark runtime results: raw case files stay local; compact evidence is committed. +benchmarks/results/* +!benchmarks/results/performance/ +benchmarks/results/performance/* +!benchmarks/results/performance/*-summary.json +!benchmarks/results/performance/*-report.md benchmarks/generated_fixtures/ # Rust native backend build output diff --git a/.superpowers/sdd/task-7-report.md b/.superpowers/sdd/task-7-report.md new file mode 100644 index 0000000..f8dda44 --- /dev/null +++ b/.superpowers/sdd/task-7-report.md @@ -0,0 +1,140 @@ +# Task 7 Report: CI-Safe Contracts, Large Workflow, Make Targets, and Docs + +## Status + +Complete. Task 7 integrates the existing Tasks 1–6 performance CLI without +changing production sources, public behavior, dependency metadata, or the protected +`.venv-qa/`. The requested commit subject is +`bench: integrate large performance investigation workflow`; the resulting hash is +reported to the parent after commit creation. + +## Scope + +- Added two small end-to-end CLI/report behavioral contracts and three repository + integration contracts in `tests/performance/test_contracts.py`. +- Replaced the broad benchmark-results ignore rule with selective rules that keep + raw case files/directories ignored and expose only direct + `*-summary.json`/`*-report.md` performance evidence. +- Added `performance-ci`, `performance-baseline`, `performance-profile`, and + `performance-report` Make targets using `$(PY)` and the active + `python -m benchmarks.performance` CLI. +- Added a manual and weekly large workflow for the required 90-case matrix. The + benchmark, analysis, and rendering steps retain their outcomes, artifact upload + runs under `always()`, and a final gate restores failure status after evidence is + uploaded. +- Added the resolved investigation architecture, supported versions/defaults, + reproduction commands, evidence methodology, and lifecycle documentation. +- Linked the new page from the existing benchmark documentation and MkDocs nav; + existing CleanBench and strategic-report content remains intact. + +## TDD Record + +### Baseline before Task 7 edits + +Command: + +```text +.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts='' +``` + +Result: `181 passed in 19.15s`, with no warnings. + +### RED + +After adding only `tests/performance/test_contracts.py`, command: + +```text +.venv-qa/bin/python -m pytest tests/performance/test_contracts.py -q --no-cov -W error -o addopts='' +``` + +Result: `2 passed, 3 failed in 10.67s`. + +The two end-to-end runtime contracts passed against the completed Tasks 1–6 +tooling. The intended integration failures were: + +1. `test_performance_artifact_ignore_contract` — the repository still contained + only the broad `benchmarks/results/` rule. +2. `test_make_targets_use_the_performance_cli` — `performance-ci` and the other + Task 7 targets did not exist. +3. `test_large_workflow_is_scheduled_manual_and_preserves_failures` — + `.github/workflows/performance-large.yml` did not exist. + +### GREEN + +After the minimal ignore, Make, and workflow implementation, the focused command +reported `5 passed in 9.59s`. After correcting the Make profile flags to match the +active CLI, the focused command again reported `5 passed in 10.36s`. + +The brief's sample Make recipe used singular `--width`, `--config`, and +`--report-mode` flags. The existing Task 5/6 CLI actually exposes `--widths`, +`--configs`, and `--report-modes`; Task 7 uses those active interfaces and tests +their exact spellings. + +## Workflow and Make Checks + +- `make -n performance-ci performance-baseline performance-profile performance-report PY=.venv-qa/bin/python` + exited 0 and printed all four expected active-CLI commands. +- PyYAML loaded `.github/workflows/performance-large.yml`; the parsed job timeout + is 180 minutes. +- The workflow has only `workflow_dispatch` and one weekly `schedule`; it has no + `pull_request` trigger. +- The workflow installs the existing `.[dev,bench,ml]` extras and passes the exact + requested rows, widths, configs, report modes, warm-up, and repetition counts. +- `git check-ignore` confirmed raw direct and nested case JSON is ignored while + `baseline-summary.json` and `baseline-report.md` are not ignored. + +## Final Verification + +Fresh verification immediately before report/commit: + +```text +.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts='' +186 passed in 26.41s + +.venv-qa/bin/ruff check benchmarks/performance tests/performance +All checks passed! + +.venv-qa/bin/ruff format --check benchmarks/performance tests/performance +22 files already formatted + +/tmp/freshdata-task7-docs/bin/mkdocs build --strict +exit 0; documentation built in 2.53 seconds + +git diff --check +exit 0 +``` + +The strict docs build used a temporary `/tmp` environment containing the project's +already-declared docs extras because `.venv-qa/` intentionally does not contain +MkDocs and had to remain untouched. The build emitted no broken-link warning and +the new page is present in nav. It retained two informational notices for the +pre-existing internal plan/spec pages excluded from public nav, plus Material's +upstream MkDocs 2.0 announcement banner. + +The Make target itself was also exercised: + +```text +make performance-ci PY=.venv-qa/bin/python +186 passed +``` + +## Self-Review + +- `git diff 8092337 -- src/freshdata pyproject.toml` is empty: no production source + or runtime dependency changed. +- The workflow does not suppress benchmark failures: it permits evidence-producing + follow-up steps, uploads the result directory even after failure, then exits 1 if + benchmark, analysis, render, or upload did not succeed. +- New documentation makes no measured performance claim. The only numeric + thresholds and compatibility ranges come from the approved design/project + metadata. +- `mkdocs.yml` is included only to expose the new public documentation page. +- The untracked `.venv-qa/` was neither staged, edited, nor removed. + +## Concerns + +- The large 90-case workflow is intentionally not run locally as part of Task 7; + it is the scheduled/manual evidence job and has the required 180-minute job cap. +- Material for MkDocs prints an upstream announcement banner even though strict + build verification succeeds. This is external tool output, not a project warning + or a documentation defect. diff --git a/Makefile b/Makefile index 8526d8f..6f859d9 100644 --- a/Makefile +++ b/Makefile @@ -5,7 +5,8 @@ PY ?= python # training-* targets are matched by the pattern rule below (pattern rules # cannot be .PHONY; the delegated targets are .PHONY inside training/Makefile). .PHONY: help benchmark benchmark-ci benchmark-report benchmark-fixtures benchmark-test \ - cleanbench-full + cleanbench-full performance-ci performance-baseline performance-profile \ + performance-report help: @echo "Targets:" @@ -15,6 +16,10 @@ help: @echo " benchmark-fixtures Write fixture CSVs to benchmarks/generated_fixtures/" @echo " benchmark-test Run the benchmark test suite" @echo " cleanbench-full Full CleanBench T1-T5 with release gates + site report" + @echo " performance-ci Run the CI-safe performance contract suite" + @echo " performance-baseline Run the performance investigation matrix" + @echo " performance-profile Profile one 100k-row performance case" + @echo " performance-report Analyze and render compact performance evidence" @echo " training-* Phase-5 training pipeline (see training/Makefile)" # Full release-gating CleanBench run. @@ -45,3 +50,16 @@ benchmark-test: # --no-cov: the benchmark suite exercises only a slice of freshdata, so it # must not be measured against the package-wide --cov-fail-under gate. $(PY) -m pytest tests/benchmark -q --no-cov + +performance-ci: + $(PY) -m pytest tests/performance -q --no-cov + +performance-baseline: + $(PY) -m benchmarks.performance run --output benchmarks/results/performance/baseline + +performance-profile: + $(PY) -m benchmarks.performance profile --rows 100000 --widths medium --configs default --report-modes true --output benchmarks/results/performance/baseline + +performance-report: + $(PY) -m benchmarks.performance analyze --input benchmarks/results/performance/baseline --output benchmarks/results/performance/baseline-summary.json + $(PY) -m benchmarks.performance render --input benchmarks/results/performance/baseline-summary.json --output benchmarks/results/performance/baseline-report.md diff --git a/docs/benchmarks.md b/docs/benchmarks.md index 677dfd8..9615c6b 100644 --- a/docs/benchmarks.md +++ b/docs/benchmarks.md @@ -11,6 +11,27 @@ keywords: data cleaning performance, pandas cleaning speed, freshdata benchmarks `freshdata` is built on vectorized pandas/NumPy with one-pass engine caching (correlation matrix, column contexts). No C extension is required. +## Performance and scalability investigation + +The [performance investigation](performance-investigation.md) documents the +deterministic mixed-schema harness, isolated subprocess execution, versioned JSON +evidence, profiling, and variability-aware comparison methodology. Baseline +measurement is in progress, so the investigation does not yet claim a slowdown or +improvement. + +```bash +pip install -e ".[dev,bench,ml]" +make performance-ci +make performance-baseline +make performance-profile +make performance-report +``` + +Raw cases are written under `benchmarks/results/performance/` and remain ignored. +Compact `*-summary.json` and `*-report.md` evidence may be committed after it is +validated. The weekly/manual GitHub Actions workflow runs the large matrix and +uploads the full result directory, including failed, timed-out, or exhausted cases. + ## Typical throughput Measured on a modern laptop (see `tests/fixtures/perf/baselines.json`): diff --git a/docs/performance-investigation.md b/docs/performance-investigation.md new file mode 100644 index 0000000..c7ce25e --- /dev/null +++ b/docs/performance-investigation.md @@ -0,0 +1,125 @@ +--- +title: Performance investigation +description: >- + Reproducible FreshData performance measurement, profiling, analysis, and + evidence-reporting methodology. +keywords: freshdata performance, scalability, profiling, benchmark methodology +--- + +# Performance investigation + +## Executive summary + +Baseline measurement is in progress. No slowdown or improvement is claimed yet. +This page defines the architecture, commands, and evidence rules used to produce +later findings without treating an unmeasured hypothesis as a result. + +## Architecture and execution flow + +The public cleaning path is: + +```text +fd.clean + -> normalize API options and validate contracts/context/memory/profile inputs + -> select the pandas or native execution path + -> initialize CleanReport and preserve-original handling + -> representation repair + column names + strings and sentinels + empty rows and columns + dtype repair + optional constant-column removal + duplicate handling + optional semantic repair + -> decision engine + build per-column contexts + build reusable engine statistics/correlations + automatic missing-value decisions + automatic outlier decisions + -> explicit imputation and outlier overrides + -> optional memory optimization + -> protected-column verification and index handling + -> finalize report + -> wrap or convert the result +``` + +The pandas implementation in `src/freshdata/cleaner.py` is the behavioral +reference. Context profiling lives in `src/freshdata/engine/context.py`, shared +engine artifacts live in `src/freshdata/engine/cache.py`, and representation +operations live in `src/freshdata/steps/`. Native backends reproduce a documented +subset and fall back to pandas when required. Every path must preserve the +`CleanReport` contract. + +`return_report=False` does not remove report construction: the pandas result +remains a `CleanResult` with an embedded report, and `Cleaner.report_` is still +populated. Any future optimization must preserve those behaviors. + +The development-only harness in `benchmarks/performance/` generates deterministic +mixed-schema frames, runs each benchmark case in an isolated subprocess, validates +each result against the versioned JSON contract, analyzes measurements, and renders +Markdown from that authoritative JSON. It does not add production runtime work. + +## Supported environment and defaults + +The investigation preserves the supported Python 3.9–3.13 matrix, pandas +`>=1.5,<3`, and NumPy `>=1.21`. The default cleaning strategy remains `balanced`, +including the existing representation-repair defaults. Profiling uses the standard +library and dependencies already declared by the development and benchmark extras. + +## Reproduction commands + +Install the development, benchmark, and optional ML dependencies before running +the full matrix: + +```bash +pip install -e ".[dev,bench,ml]" +``` + +The Make targets use the active `PY` interpreter; override it when needed, for +example with `make performance-ci PY=.venv/bin/python`. + +```bash +make performance-ci +make performance-baseline +make performance-profile +make performance-report +``` + +`performance-ci` runs the small deterministic contract suite. +`performance-baseline` writes raw case JSON under +`benchmarks/results/performance/baseline/`. `performance-profile` records one +100,000-row medium-width default case with report behavior enabled. +`performance-report` analyzes the raw directory into +`baseline-summary.json` and renders `baseline-report.md` from that summary. + +## Measurement methodology + +Reportable cases use one warm-up followed by five measured repetitions. Each case +records its exact command and environment, dataset seed and shape, configuration, +individual timing samples and summary statistics, throughput, peak RSS, Python +allocation peak, input size, status, and any failure, timeout, or memory-exhaustion +details. Timing and memory measurements run separately so memory sampling does not +silently redefine the timing result. + +Equivalent pandas baselines are limited to named component operations that perform +the same selected transformation. They are not described as equivalent to +FreshData's complete decision and audit pipeline. + +An optimization is a verified win only if the relevant median runtime or peak-memory +measurement improves by at least 10%, the improvement exceeds twice the observed +run-to-run variability, and no other primary workload has a meaningful regression. +CI contracts assert stable behavior and structure rather than fragile wall-clock +thresholds; large runtime and memory measurements run manually and weekly. + +## Evidence lifecycle + +Authoritative, schema-validated JSON is the source for the generated baseline, +profile, root-cause, rejected-hypothesis, before/after, memory, backend, +documentation, risk, and verification sections as their investigation phases +complete. Generated Markdown is a view of that JSON. Raw case files remain local or +in workflow artifacts; only compact `*-summary.json` and `*-report.md` evidence is +eligible to be committed. + +Failures, timeouts, memory exhaustion, poor results, and unresolved limitations +remain visible in the evidence. A result is not published without its environment +and reproduction command. diff --git a/mkdocs.yml b/mkdocs.yml index 9fb89aa..beb2831 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -129,6 +129,7 @@ nav: - Honest limitations: limitations.md - Production-readiness checklist: production-readiness.md - Benchmarks: benchmarks.md + - Performance investigation: performance-investigation.md - Benchmark fixtures: fixtures.md - API Reference: api-reference.md - FAQ: faq.md diff --git a/tests/performance/test_contracts.py b/tests/performance/test_contracts.py new file mode 100644 index 0000000..602edab --- /dev/null +++ b/tests/performance/test_contracts.py @@ -0,0 +1,128 @@ +from __future__ import annotations + +import json +from pathlib import Path + +import yaml +from benchmarks.performance.cli import main +from benchmarks.performance.render import render_report + +ROOT = Path(__file__).parents[2] + + +def test_ci_sized_matrix_completes_and_renders(tmp_path: Path) -> None: + raw = tmp_path / "raw" + assert ( + main( + [ + "run", + "--rows", + "500", + "--widths", + "narrow,medium", + "--configs", + "default,conservative", + "--report-modes", + "false,true", + "--warmups", + "0", + "--repetitions", + "1", + "--timeout", + "120", + "--output", + str(raw), + ] + ) + == 0 + ) + results = [json.loads(path.read_text()) for path in raw.glob("*.json")] + assert len(results) == 8 + assert all(item["status"] == "completed" for item in results) + rendered = render_report( + { + "environment": results[0]["environment"], + "results": results, + "hypotheses": {}, + } + ) + assert "500" in rendered + assert "narrow" in rendered and "medium" in rendered + + +def test_report_modes_preserve_behavioral_contract(tmp_path: Path) -> None: + assert ( + main( + [ + "run", + "--rows", + "250", + "--widths", + "narrow", + "--configs", + "default", + "--report-modes", + "false,true", + "--warmups", + "0", + "--repetitions", + "1", + "--timeout", + "120", + "--output", + str(tmp_path), + ] + ) + == 0 + ) + results = [json.loads(path.read_text()) for path in tmp_path.glob("*.json")] + assert {item["case"]["return_report"] for item in results} == {False, True} + + +def test_performance_artifact_ignore_contract() -> None: + rules = (ROOT / ".gitignore").read_text() + assert "benchmarks/results/*" in rules + assert "!benchmarks/results/performance/" in rules + assert "benchmarks/results/performance/*" in rules + assert "!benchmarks/results/performance/*-summary.json" in rules + assert "!benchmarks/results/performance/*-report.md" in rules + assert "benchmarks/results/" not in rules.splitlines() + + +def test_make_targets_use_the_performance_cli() -> None: + makefile = (ROOT / "Makefile").read_text() + assert "performance-ci:" in makefile + assert "$(PY) -m pytest tests/performance -q --no-cov" in makefile + assert "$(PY) -m benchmarks.performance run --output" in makefile + assert ( + "$(PY) -m benchmarks.performance profile --rows 100000 --widths medium " + "--configs default --report-modes true" in makefile + ) + assert "$(PY) -m benchmarks.performance analyze --input" in makefile + assert "$(PY) -m benchmarks.performance render --input" in makefile + + +def test_large_workflow_is_scheduled_manual_and_preserves_failures() -> None: + workflow_path = ROOT / ".github/workflows/performance-large.yml" + workflow_text = workflow_path.read_text() + workflow = yaml.safe_load(workflow_text) + + # PyYAML 1.1 treats the unquoted GitHub Actions key `on` as a boolean. + triggers = workflow.get("on", workflow.get(True)) + assert set(triggers) == {"schedule", "workflow_dispatch"} + assert len(triggers["schedule"]) == 1 + assert workflow["jobs"]["performance-large"]["timeout-minutes"] == 180 + assert 'pip install -e ".[dev,bench,ml]"' in workflow_text + for expected in ( + "--rows 100000,500000,1000000", + "--widths narrow,medium,wide", + "--configs default,conservative,representation_off,statistical_off,explicit", + "--report-modes false,true", + "--warmups 1", + "--repetitions 5", + ): + assert expected in workflow_text + assert "actions/upload-artifact@" in workflow_text + assert "if: always()" in workflow_text + assert "continue-on-error: true" in workflow_text + assert "exit 1" in workflow_text From 27ee7b653a1318ac66692df2ba9c7813a674e8aa Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Sun, 12 Jul 2026 16:19:09 +0530 Subject: [PATCH 24/37] chore: keep SDD reports local --- .superpowers/sdd/task-6-report.md | 174 ------------------------------ .superpowers/sdd/task-7-report.md | 140 ------------------------ 2 files changed, 314 deletions(-) delete mode 100644 .superpowers/sdd/task-6-report.md delete mode 100644 .superpowers/sdd/task-7-report.md diff --git a/.superpowers/sdd/task-6-report.md b/.superpowers/sdd/task-6-report.md deleted file mode 100644 index eae3e78..0000000 --- a/.superpowers/sdd/task-6-report.md +++ /dev/null @@ -1,174 +0,0 @@ -# Task 6 Report: Comparable Pandas Baselines, Analysis, and Markdown Rendering - -## Status - -Implemented Task 6 against base `7bcf97541a9b7f186e7cc68d11b00e1d11c8ce7d`. - -The implementation adds only named pandas component baselines. It does not claim a -full pandas equivalent of FreshData's balanced decision/audit pipeline. A comparison -is produced only when a FreshData case explicitly declares -`options.comparable_baseline` with the exact component baseline name. - -## RED - -- `tests/performance/test_analysis_render.py` initially failed collection with - `ModuleNotFoundError: No module named 'benchmarks.performance.analysis'`. -- The strict result-model tests initially failed because `BenchmarkResult.completed` - rejected `baseline_name` and ordinary payloads omitted the required nullable field. -- Boundary coverage exposed floating-point behavior at an exact 10% change; the test - expected `improved` while the initial implementation returned `noise`. -- Exact-evidence coverage demonstrated that partial names such as - `correlation_label` were incorrectly accepted as correlation evidence. -- Semantic-comparison coverage demonstrated that explicitly matched component cases - initially produced no comparison. - -## GREEN - -- Added required nullable `baseline_name` to the strict result model/schema; ordinary - FreshData results serialize it as `null`, component results serialize the exact - baseline key, and round trips preserve it. -- Added only the corrected component operations: `shallow_copy`, - `numeric_median_fill`, `duplicates`, and `null_counts`. -- Added an isolated baseline worker path using one warm-up/five repetitions by default - and a separate PeakRSS/tracemalloc measurement. The - `pandas-component-baseline` sentinel is handled only by this path and is never sent - to `fd.clean`. -- Added `classify_change` with the required absolute 10% threshold and twice the - larger observed CV threshold. -- Added all eight hypothesis classifications. Candidate status requires non-zero - relevant observed calls, exact function/path/line evidence, and either a 10% stage - fraction or a 10% traced-peak allocation fraction. -- Added deterministic analysis ordering and Markdown rendering with exact commands, - metric ranges/CV/throughput, memory ratios, scoped comparisons, stage percentages, - exact function locations, candidate/rejected/evidence-limited hypotheses, durable - failures, and limitations. Noise is labeled as noise and never rendered as an - improvement. -- Added `baseline`, `analyze`, and `render` CLI commands. - -## Verification - -- `.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts=''` - - `144 passed in 15.97s` -- `.venv-qa/bin/ruff check benchmarks/performance tests/performance` - - `All checks passed!` -- `.venv-qa/bin/ruff format --check benchmarks/performance tests/performance` - - `21 files already formatted` -- `git diff --check` - - clean - -## Broader-suite observation - -A diagnostic full-repository run with warnings promoted to errors reached one -unrelated existing failure in `tests/test_cleanbench_public_release.py`: the legacy -CleanBench pandas baseline emits a pandas datetime-inference `UserWarning`, which its -harness converts to `status="skipped"` under `-W error`. The Task 6 performance suite -is warning-free, and no production or legacy CleanBench code was changed. - -## Commit - -- `7ef5e79` — `bench: analyze and render scalability evidence` - -## Concerns - -- Component comparisons are intentionally opt-in and semantically scoped. Existing - full FreshData cases do not declare component equivalence, so their comparison list - remains empty rather than presenting a misleading balanced-pipeline claim. -- `.venv-qa/` remains untracked and untouched. - ---- - -## Review Fix Wave - -### RED - -The focused review suite produced 25 expected failures before implementation: - -- `load_results` accepted `NaN`, `Infinity`, and `-Infinity` until downstream - validation, while the render CLI accepted all three outright. -- Hypothesis evidence accepted approved function names from `.bak` files and - unrelated functions from approved files because matching used OR/substring logic. -- Profile hypotheses collided under an incomplete label when cases differed only by - dataset type or seed. -- Component backend payloads accepted null, unknown, and forbidden `balanced` - baseline names; non-component backends accepted non-null baseline names. -- `BenchmarkResult` could construct an inconsistent component-baseline identity. -- Profile headings omitted case identity and function rendering depended on payload - order. - -### GREEN - -- Both JSON input paths now pass `parse_constant` callbacks to `json.loads` and reject - all three non-standard constants before accepting the payload. -- Hypotheses are keyed by `BenchmarkCase.case_id`; each record retains a complete - human label with case ID, rows, width, dataset type, config/options, report flag, - backend/output, seed, warm-ups, and repetitions. -- The strict result schema conditionally requires one of exactly - `shallow_copy`, `numeric_median_fill`, `duplicates`, or `null_counts` for the - `pandas-component-baseline` backend and requires null for every other backend. - `BenchmarkResult` enforces the same invariant at construction time. -- Every hypothesis uses explicit approved path-suffix/exact-function relationships. - Matching requires both conditions, so `.bak` paths and unrelated context functions - cannot qualify. Allocation significance is considered only alongside exact - function evidence for the same hypothesis family. -- Profile headings render the complete case identity. Top functions are sorted by a - canonical metric/location key before the top ten are selected, making equivalent - payloads order-independent. - -### Review Verification - -- `.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts=''` - - `172 passed in 23.12s` -- `.venv-qa/bin/ruff check benchmarks/performance tests/performance` - - `All checks passed!` -- `.venv-qa/bin/ruff format --check benchmarks/performance tests/performance` - - `21 files already formatted` -- Python 3.9 grammar check using `ast.parse(..., feature_version=(3, 9))` - - `Python 3.9 grammar: 21 files parsed` - -### Review Commit - -- `917bc29` — `bench: harden performance evidence identity` - ---- - -## Final Review Fix Wave - -### RED - -A focused regression run produced eight expected failures before implementation: - -- allocation bytes from `context.py:44` incorrectly combined with exact - `build_context` function evidence from `context.py:231`, creating a candidate; -- `classify_change` accepted direct `NaN`, positive infinity, and negative infinity; -- the render CLI accepted JSON `1e999`, which Python parses as positive infinity; -- `render_report` accepted nested direct `NaN`, positive infinity, and negative - infinity values. - -The matching `load_results` overflow case and direct `analyze_results` cases were -also added; their existing strict result validation already rejected the values. - -### GREEN - -- Added recursive finite-float validation and invoked it after JSON parsing, during - strict result validation, and at the public analysis, hypothesis, comparison, and - render entry points. Boolean handling remains delegated to the existing schema and - model semantics. -- Kept strict JSON serialization with `allow_nan=False` on generated JSON output. -- Allocation significance now counts only records whose normalized file and exact - line equal a location from already matched exact function evidence. Same-file bytes - from another line no longer satisfy the 10% threshold. -- Added positive and negative allocation-location coverage and JSON-overflow/direct - programmatic non-finite coverage for load, analysis, render CLI, and renderer paths. - -### Final Review Verification - -- `.venv-qa/bin/python -m pytest tests/performance/test_analysis_render.py tests/performance/test_models_schema.py tests/performance/test_instrumentation.py -q --no-cov -W error -o addopts=''` - - `148 passed in 6.54s` -- `.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts=''` - - `181 passed in 16.52s` -- `.venv-qa/bin/ruff check benchmarks/performance tests/performance` - - `All checks passed!` -- `.venv-qa/bin/ruff format --check benchmarks/performance tests/performance` - - `21 files already formatted` -- Python 3.9 grammar check using `ast.parse(..., feature_version=(3, 9))` - - `Python 3.9 grammar: 21 files parsed` diff --git a/.superpowers/sdd/task-7-report.md b/.superpowers/sdd/task-7-report.md deleted file mode 100644 index f8dda44..0000000 --- a/.superpowers/sdd/task-7-report.md +++ /dev/null @@ -1,140 +0,0 @@ -# Task 7 Report: CI-Safe Contracts, Large Workflow, Make Targets, and Docs - -## Status - -Complete. Task 7 integrates the existing Tasks 1–6 performance CLI without -changing production sources, public behavior, dependency metadata, or the protected -`.venv-qa/`. The requested commit subject is -`bench: integrate large performance investigation workflow`; the resulting hash is -reported to the parent after commit creation. - -## Scope - -- Added two small end-to-end CLI/report behavioral contracts and three repository - integration contracts in `tests/performance/test_contracts.py`. -- Replaced the broad benchmark-results ignore rule with selective rules that keep - raw case files/directories ignored and expose only direct - `*-summary.json`/`*-report.md` performance evidence. -- Added `performance-ci`, `performance-baseline`, `performance-profile`, and - `performance-report` Make targets using `$(PY)` and the active - `python -m benchmarks.performance` CLI. -- Added a manual and weekly large workflow for the required 90-case matrix. The - benchmark, analysis, and rendering steps retain their outcomes, artifact upload - runs under `always()`, and a final gate restores failure status after evidence is - uploaded. -- Added the resolved investigation architecture, supported versions/defaults, - reproduction commands, evidence methodology, and lifecycle documentation. -- Linked the new page from the existing benchmark documentation and MkDocs nav; - existing CleanBench and strategic-report content remains intact. - -## TDD Record - -### Baseline before Task 7 edits - -Command: - -```text -.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts='' -``` - -Result: `181 passed in 19.15s`, with no warnings. - -### RED - -After adding only `tests/performance/test_contracts.py`, command: - -```text -.venv-qa/bin/python -m pytest tests/performance/test_contracts.py -q --no-cov -W error -o addopts='' -``` - -Result: `2 passed, 3 failed in 10.67s`. - -The two end-to-end runtime contracts passed against the completed Tasks 1–6 -tooling. The intended integration failures were: - -1. `test_performance_artifact_ignore_contract` — the repository still contained - only the broad `benchmarks/results/` rule. -2. `test_make_targets_use_the_performance_cli` — `performance-ci` and the other - Task 7 targets did not exist. -3. `test_large_workflow_is_scheduled_manual_and_preserves_failures` — - `.github/workflows/performance-large.yml` did not exist. - -### GREEN - -After the minimal ignore, Make, and workflow implementation, the focused command -reported `5 passed in 9.59s`. After correcting the Make profile flags to match the -active CLI, the focused command again reported `5 passed in 10.36s`. - -The brief's sample Make recipe used singular `--width`, `--config`, and -`--report-mode` flags. The existing Task 5/6 CLI actually exposes `--widths`, -`--configs`, and `--report-modes`; Task 7 uses those active interfaces and tests -their exact spellings. - -## Workflow and Make Checks - -- `make -n performance-ci performance-baseline performance-profile performance-report PY=.venv-qa/bin/python` - exited 0 and printed all four expected active-CLI commands. -- PyYAML loaded `.github/workflows/performance-large.yml`; the parsed job timeout - is 180 minutes. -- The workflow has only `workflow_dispatch` and one weekly `schedule`; it has no - `pull_request` trigger. -- The workflow installs the existing `.[dev,bench,ml]` extras and passes the exact - requested rows, widths, configs, report modes, warm-up, and repetition counts. -- `git check-ignore` confirmed raw direct and nested case JSON is ignored while - `baseline-summary.json` and `baseline-report.md` are not ignored. - -## Final Verification - -Fresh verification immediately before report/commit: - -```text -.venv-qa/bin/python -m pytest tests/performance --no-cov -W error -o addopts='' -186 passed in 26.41s - -.venv-qa/bin/ruff check benchmarks/performance tests/performance -All checks passed! - -.venv-qa/bin/ruff format --check benchmarks/performance tests/performance -22 files already formatted - -/tmp/freshdata-task7-docs/bin/mkdocs build --strict -exit 0; documentation built in 2.53 seconds - -git diff --check -exit 0 -``` - -The strict docs build used a temporary `/tmp` environment containing the project's -already-declared docs extras because `.venv-qa/` intentionally does not contain -MkDocs and had to remain untouched. The build emitted no broken-link warning and -the new page is present in nav. It retained two informational notices for the -pre-existing internal plan/spec pages excluded from public nav, plus Material's -upstream MkDocs 2.0 announcement banner. - -The Make target itself was also exercised: - -```text -make performance-ci PY=.venv-qa/bin/python -186 passed -``` - -## Self-Review - -- `git diff 8092337 -- src/freshdata pyproject.toml` is empty: no production source - or runtime dependency changed. -- The workflow does not suppress benchmark failures: it permits evidence-producing - follow-up steps, uploads the result directory even after failure, then exits 1 if - benchmark, analysis, render, or upload did not succeed. -- New documentation makes no measured performance claim. The only numeric - thresholds and compatibility ranges come from the approved design/project - metadata. -- `mkdocs.yml` is included only to expose the new public documentation page. -- The untracked `.venv-qa/` was neither staged, edited, nor removed. - -## Concerns - -- The large 90-case workflow is intentionally not run locally as part of Task 7; - it is the scheduled/manual evidence job and has the required 180-minute job cap. -- Material for MkDocs prints an upstream announcement banner even though strict - build verification succeeds. This is external tool output, not a project warning - or a documentation defect. From 2f92d20f116cb7a7575d18ad48f77c986ac547ba Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 21:45:34 +0530 Subject: [PATCH 25/37] fix: merge performance profile companions --- benchmarks/performance/analysis.py | 52 +- .../results/performance/baseline-report.md | 942 + .../results/performance/baseline-summary.json | 21632 ++++++++++++++++ tests/performance/test_analysis_render.py | 39 + 4 files changed, 22664 insertions(+), 1 deletion(-) create mode 100644 benchmarks/results/performance/baseline-report.md create mode 100644 benchmarks/results/performance/baseline-summary.json diff --git a/benchmarks/performance/analysis.py b/benchmarks/performance/analysis.py index 516b2e2..05d58c2 100644 --- a/benchmarks/performance/analysis.py +++ b/benchmarks/performance/analysis.py @@ -146,6 +146,16 @@ }, } +_PROFILE_COMPANION_STABLE_FIELDS = ( + "schema_version", + "case", + "status", + "result_type", + "input_bytes", + "output_fingerprint", + "report_fingerprint", +) + def classify_change( baseline: float, @@ -258,6 +268,44 @@ def _sort_key(result: dict[str, Any]) -> tuple[object, ...]: ) +def _reconcile_freshdata_results( + results: Iterable[dict[str, Any]], +) -> list[dict[str, Any]]: + artifacts_by_case: dict[str, list[dict[str, Any]]] = {} + for result in results: + artifacts_by_case.setdefault(case_id_for_result(result), []).append(result) + + reconciled: list[dict[str, Any]] = [] + for case_id, artifacts in artifacts_by_case.items(): + plain_artifacts = [ + artifact for artifact in artifacts if artifact.get("profile") is None + ] + profile_artifacts = [ + artifact for artifact in artifacts if isinstance(artifact.get("profile"), dict) + ] + if len(plain_artifacts) > 1 or len(profile_artifacts) > 1: + raise ValueError( + f"ambiguous FreshData artifacts for case {case_id}: " + f"{len(plain_artifacts)} plain and " + f"{len(profile_artifacts)} profile results" + ) + if plain_artifacts and profile_artifacts: + plain = plain_artifacts[0] + profile = profile_artifacts[0] + for field in _PROFILE_COMPANION_STABLE_FIELDS: + if plain[field] != profile[field]: + raise ValueError( + "incompatible FreshData profile companion for " + f"case {case_id}: {field} differs" + ) + merged = dict(plain) + merged["profile"] = profile["profile"] + reconciled.append(merged) + else: + reconciled.extend(artifacts) + return reconciled + + def analyze_results(results: Iterable[dict[str, Any]]) -> dict[str, Any]: materialized = [dict(result) for result in results] validate_finite_numbers(materialized, "analysis results") @@ -269,7 +317,9 @@ def analyze_results(results: Iterable[dict[str, Any]]) -> dict[str, Any]: for result in ordered if result.get("case", {}).get("backend") == "pandas-component-baseline" ] - freshdata_results = [result for result in ordered if result not in component_baselines] + freshdata_results = _reconcile_freshdata_results( + result for result in ordered if result not in component_baselines + ) baselines_by_semantics = { ( result.get("baseline_name"), diff --git a/benchmarks/results/performance/baseline-report.md b/benchmarks/results/performance/baseline-report.md new file mode 100644 index 0000000..f325da4 --- /dev/null +++ b/benchmarks/results/performance/baseline-report.md @@ -0,0 +1,942 @@ +# FreshData performance evidence + +## Environment + +- cpu_count_logical: `8` +- cpu_count_physical: `8` +- freshdata_version: `1.1.1` +- git_commit: `27ee7b653a1318ac66692df2ba9c7813a674e8aa` +- git_dirty: `True` +- numpy_version: `2.4.6` +- optional_versions: `{'duckdb': '1.5.4', 'polars': '1.42.1', 'pyarrow': '25.0.0', 'pyspark': None}` +- pandas_version: `2.3.3` +- platform: `macOS-15.5-arm64-arm-64bit` +- processor: `arm` +- python_version: `3.12.13` +- total_ram_bytes: `17179869184` + +## Architecture and execution flow + +FreshData cases and named pandas component operations run in isolated worker processes. Timing samples and the PeakRSS/tracemalloc measurement are collected separately. + +## Reproduction commands + +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1a2bhs8o/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1a2bhs8o/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1cpbsxvm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1cpbsxvm/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-2yve61ar/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-2yve61ar/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3t2jaloi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3t2jaloi/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3to9120_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3to9120_/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-517rp2_i/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-517rp2_i/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-5n5kleje/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-5n5kleje/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7fgowvwz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7fgowvwz/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7w9lzkx2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7w9lzkx2/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-8_r4t4do/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-8_r4t4do/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-970pn38n/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-970pn38n/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-akjg6pa2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-akjg6pa2/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-atwivd68/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-atwivd68/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ayxya50_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ayxya50_/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-dndszzwe/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-dndszzwe/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e39yu2z0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e39yu2z0/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e_xkbaob/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e_xkbaob/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-fw9xjqui/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-fw9xjqui/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-g3nkw1m6/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-g3nkw1m6/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-gkg7v_u6/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-gkg7v_u6/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hqxwyk63/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hqxwyk63/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hxuyzbdy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hxuyzbdy/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hyt47z_w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hyt47z_w/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i35q0qkn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i35q0qkn/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i66bg7ug/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i66bg7ug/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-j31qg_8b/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-j31qg_8b/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jcyb2ewy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jcyb2ewy/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jml6nw8z/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jml6nw8z/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-kqx67jyy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-kqx67jyy/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-myqv3fk8/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-myqv3fk8/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-nz0pqreo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-nz0pqreo/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-o6r_idke/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-o6r_idke/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ogfxbv51/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ogfxbv51/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-pe41zuia/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-pe41zuia/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-r2pbpey9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-r2pbpey9/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2p6tyz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2p6tyz/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2qezvs/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2qezvs/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-spnaa01k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-spnaa01k/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sv6h_ar5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sv6h_ar5/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-th5lkqzb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-th5lkqzb/result.json duplicates` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-tmuuhh49/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-tmuuhh49/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-u0matknq/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-u0matknq/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vusdqa6w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vusdqa6w/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vuurrf4s/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vuurrf4s/result.json null_counts` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-wthn21sp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-wthn21sp/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-xu2f98r1/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-xu2f98r1/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ytg1ke0e/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ytg1ke0e/result.json shallow_copy` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3], __import__('"'"'sys'"'"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-zdipbdz9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-zdipbdz9/result.json numeric_median_fill` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0_oplliu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0_oplliu/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0o7maroj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0o7maroj/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0wcjge2n/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0wcjge2n/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0y608fx9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0y608fx9/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-2t3k0qat/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-2t3k0qat/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-35wc2941/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-35wc2941/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3uzf4yau/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3uzf4yau/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3wt9l572/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3wt9l572/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-45k6rlhy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-45k6rlhy/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-48bqvd6_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-48bqvd6_/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-505l5i2k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-505l5i2k/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5b5z35kz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5b5z35kz/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5z51_7m7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5z51_7m7/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6f1913hf/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6f1913hf/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6h0tex80/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6h0tex80/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6m37255r/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6m37255r/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6va8ihwu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6va8ihwu/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6vsbnir1/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6vsbnir1/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6x8nokur/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6x8nokur/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-73qnu4tr/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-73qnu4tr/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7a2ovh8q/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7a2ovh8q/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7ijnb2t2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7ijnb2t2/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7kbxkur4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7kbxkur4/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7t8hq6r0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7t8hq6r0/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7vsj5k8x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7vsj5k8x/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7wohf2mk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7wohf2mk/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-8z80spay/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-8z80spay/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-94i3izmm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-94i3izmm/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9eov5p_h/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9eov5p_h/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nhcsu3f/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nhcsu3f/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nq36ybo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nq36ybo/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_2qwkrp5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_2qwkrp5/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_62x0b18/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_62x0b18/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_l79249g/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_l79249g/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_w7r0q85/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_w7r0q85/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-a77oq7oj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-a77oq7oj/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-acfhxjob/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-acfhxjob/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bfpv5cj2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bfpv5cj2/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bguwaenp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bguwaenp/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bhzt0s5x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bhzt0s5x/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bk_t2v0m/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bk_t2v0m/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bkaat7mk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bkaat7mk/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-blvv_jiv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-blvv_jiv/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bn1sfum9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bn1sfum9/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bvxcn7xl/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bvxcn7xl/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cpv66lch/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cpv66lch/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cyfb1k82/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cyfb1k82/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-d7saj_vi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-d7saj_vi/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-df48de9a/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-df48de9a/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-do203r6b/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-do203r6b/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-dq31_bs5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-dq31_bs5/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eazaesl3/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eazaesl3/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ed961_m8/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ed961_m8/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eudiegfa/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eudiegfa/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f264f2_9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f264f2_9/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f2ooeoz0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f2ooeoz0/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fj5psnoh/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fj5psnoh/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fro3mtal/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fro3mtal/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fxn1gzrg/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fxn1gzrg/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g4j166wv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g4j166wv/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g9qfvced/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g9qfvced/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g_nftmdn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g_nftmdn/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gc406ib9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gc406ib9/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gxeu66kc/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gxeu66kc/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gz_af_1p/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gz_af_1p/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h0g7u45k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h0g7u45k/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h_rnavez/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h_rnavez/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-hlfudhnw/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-hlfudhnw/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i04nrmrp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i04nrmrp/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i83j742j/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i83j742j/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i8zs7mdh/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i8zs7mdh/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-izm1t_jk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-izm1t_jk/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-j_rz02un/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-j_rz02un/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jaqic_qn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jaqic_qn/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jsn72n1l/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jsn72n1l/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ksnjrpyp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ksnjrpyp/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-kyndmnei/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-kyndmnei/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-l8w0yh4p/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-l8w0yh4p/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lq544524/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lq544524/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lx898arq/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lx898arq/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m0sb5i34/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m0sb5i34/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m305bi9o/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m305bi9o/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mamv5ri_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mamv5ri_/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mk0c_vdo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mk0c_vdo/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mov5obdy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mov5obdy/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ng_asva7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ng_asva7/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-nsu1dvvk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-nsu1dvvk/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o26qohu4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o26qohu4/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o7uyipn7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o7uyipn7/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-obnnpt74/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-obnnpt74/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-oc0p3e55/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-oc0p3e55/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofl_se46/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofl_se46/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofttul9h/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofttul9h/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-olcq_0u3/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-olcq_0u3/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-p3db69s_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-p3db69s_/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-pergwrsg/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-pergwrsg/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q5jo5ykm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q5jo5ykm/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q6_eotbv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q6_eotbv/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qldc62vn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qldc62vn/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qpv00l7x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qpv00l7x/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-quma73mv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-quma73mv/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qwq4ttn2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qwq4ttn2/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r1t8ppnu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r1t8ppnu/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r75lh8th/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r75lh8th/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-rqpltcr2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-rqpltcr2/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ru43bw23/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ru43bw23/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s12d6qgk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s12d6qgk/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s4rpqe6x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s4rpqe6x/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-se9sgn4u/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-se9sgn4u/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-t9v9c099/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-t9v9c099/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-tw8lly9j/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-tw8lly9j/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-u32hxje4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-u32hxje4/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uby8hrir/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uby8hrir/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uv5wrp3w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uv5wrp3w/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-vrmo8_xr/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-vrmo8_xr/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w5oxtzfm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w5oxtzfm/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w61z76il/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w61z76il/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wbkq_rwi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wbkq_rwi/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-woqbb2i9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-woqbb2i9/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wvyexwm2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wvyexwm2/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wyy78nbb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wyy78nbb/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xhlz9fkb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xhlz9fkb/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xt8z79vb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xt8z79vb/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y1kajzsz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y1kajzsz/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y7aivnpb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y7aivnpb/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y9l2tty4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y9l2tty4/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-yybzjsbu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-yybzjsbu/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z32pfetj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z32pfetj/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z7x9dr_r/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z7x9dr_r/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zqojqylx/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zqojqylx/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zsncy0_k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zsncy0_k/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('"'"'sys'"'"').argv[1], __import__('"'"'sys'"'"').argv[2], __import__('"'"'sys'"'"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zxw4_spm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zxw4_spm/result.json` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 10000 --widths wide --configs default --report-modes true --output benchmarks/results/performance/baseline` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs aggressive --report-modes true --output benchmarks/results/performance/baseline` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs default --report-modes true --output benchmarks/results/performance/baseline` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs semantic --report-modes true --output benchmarks/results/performance/baseline` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 1000000 --widths narrow --configs default --report-modes true --output benchmarks/results/performance/baseline` +- `/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 500000 --widths medium --configs default --report-modes false --output benchmarks/results/performance/baseline` + +## Baseline benchmark table + +| Rows | Width | Config / operation | Report | Backend | Format | Median s | Min s | Max s | CV | Rows/s | Peak RSS/input | Peak Python/input | Comparison | +| ---: | :--- | :--- | :---: | :--- | :--- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | :--- | +| 10000 | medium | conservative | false | pandas | pandas | 0.306 | 0.306 | 0.307 | 0.001 | 32659.8 | 1.686 | 1.429 | — | +| 10000 | medium | conservative | true | pandas | pandas | 0.301 | 0.301 | 0.301 | 0.001 | 33197.3 | 2.461 | 1.429 | — | +| 10000 | medium | default | false | pandas | pandas | 0.428 | 0.428 | 0.432 | 0.004 | 23359.8 | 0.810 | 1.429 | — | +| 10000 | medium | default | true | pandas | pandas | 0.427 | 0.426 | 0.430 | 0.004 | 23438.4 | 1.040 | 1.430 | — | +| 10000 | medium | explicit | false | pandas | pandas | 0.331 | 0.328 | 0.342 | 0.020 | 30231.9 | 0.365 | 1.429 | — | +| 10000 | medium | explicit | true | pandas | pandas | 0.333 | 0.331 | 0.348 | 0.023 | 30022.1 | 0.808 | 1.430 | — | +| 10000 | medium | duplicates | false | pandas-component-baseline | pandas | 0.019 | 0.019 | 0.019 | 0.014 | 530246.1 | 0.190 | 0.659 | — | +| 10000 | medium | null_counts | false | pandas-component-baseline | pandas | 0.004 | 0.004 | 0.004 | 0.025 | 2651230.1 | 0.051 | 0.137 | — | +| 10000 | medium | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.197 | 132522296.9 | 0.004 | 0.081 | — | +| 10000 | medium | representation_off | false | pandas | pandas | 0.046 | 0.044 | 0.058 | 0.124 | 215696.2 | 0.051 | 0.149 | — | +| 10000 | medium | representation_off | true | pandas | pandas | 0.045 | 0.044 | 0.047 | 0.021 | 220997.5 | 0.053 | 0.149 | — | +| 10000 | medium | statistical_off | false | pandas | pandas | 0.311 | 0.307 | 0.328 | 0.027 | 32112.4 | 0.332 | 1.429 | — | +| 10000 | medium | statistical_off | true | pandas | pandas | 0.305 | 0.302 | 0.307 | 0.007 | 32790.8 | 1.773 | 1.429 | — | +| 10000 | narrow | conservative | false | pandas | pandas | 0.071 | 0.071 | 0.071 | 0.004 | 140676.2 | 2.342 | 2.233 | — | +| 10000 | narrow | conservative | true | pandas | pandas | 0.071 | 0.071 | 0.072 | 0.005 | 140136.2 | 1.650 | 2.233 | — | +| 10000 | narrow | default | false | pandas | pandas | 0.102 | 0.102 | 0.103 | 0.002 | 97739.7 | 2.933 | 2.233 | — | +| 10000 | narrow | default | true | pandas | pandas | 0.102 | 0.101 | 0.103 | 0.007 | 97700.7 | 1.802 | 2.233 | — | +| 10000 | narrow | explicit | false | pandas | pandas | 0.077 | 0.077 | 0.079 | 0.013 | 129628.8 | 1.008 | 2.233 | — | +| 10000 | narrow | explicit | true | pandas | pandas | 0.077 | 0.077 | 0.077 | 0.001 | 129772.8 | 2.882 | 2.233 | — | +| 10000 | narrow | duplicates | false | pandas-component-baseline | pandas | 0.005 | 0.004 | 0.005 | 0.090 | 2170295.7 | 0.061 | 1.434 | — | +| 10000 | narrow | null_counts | false | pandas-component-baseline | pandas | 0.001 | 0.001 | 0.001 | 0.056 | 10384216.0 | 0.051 | 0.458 | — | +| 10000 | narrow | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.085 | 197367122.2 | 0.031 | 0.375 | — | +| 10000 | narrow | representation_off | false | pandas | pandas | 0.010 | 0.009 | 0.010 | 0.014 | 1050020.3 | 0.132 | 0.478 | — | +| 10000 | narrow | representation_off | true | pandas | pandas | 0.010 | 0.010 | 0.010 | 0.011 | 1028127.8 | 0.112 | 0.478 | — | +| 10000 | narrow | statistical_off | false | pandas | pandas | 0.071 | 0.071 | 0.072 | 0.003 | 139984.1 | 1.955 | 2.233 | — | +| 10000 | narrow | statistical_off | true | pandas | pandas | 0.077 | 0.077 | 0.079 | 0.011 | 129739.8 | 0.876 | 2.233 | — | +| 10000 | wide | conservative | false | pandas | pandas | 1.244 | 1.242 | 1.254 | 0.004 | 8037.4 | 1.771 | 1.222 | — | +| 10000 | wide | conservative | true | pandas | pandas | 1.252 | 1.247 | 1.268 | 0.008 | 7985.3 | 0.101 | 1.223 | — | +| 10000 | wide | default | false | pandas | pandas | 1.855 | 1.845 | 1.867 | 0.005 | 5391.5 | 0.061 | 1.223 | — | +| 10000 | wide | default | true | pandas | pandas | 1.865 | 1.843 | 1.882 | 0.008 | 5362.0 | 1.158 | 1.223 | — | +| 10000 | wide | explicit | false | pandas | pandas | 1.319 | 1.314 | 1.322 | 0.002 | 7582.1 | 1.272 | 1.222 | — | +| 10000 | wide | explicit | true | pandas | pandas | 1.329 | 1.323 | 1.338 | 0.005 | 7525.3 | 0.577 | 1.223 | — | +| 10000 | wide | duplicates | false | pandas-component-baseline | pandas | 0.082 | 0.079 | 0.141 | 0.331 | 122453.0 | 0.048 | 0.493 | — | +| 10000 | wide | null_counts | false | pandas-component-baseline | pandas | 0.015 | 0.015 | 0.015 | 0.013 | 665581.4 | 0.030 | 0.069 | — | +| 10000 | wide | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.213 | 62794348.5 | 0.002 | 0.020 | — | +| 10000 | wide | representation_off | false | pandas | pandas | 0.181 | 0.180 | 0.183 | 0.005 | 55178.7 | 0.058 | 0.080 | — | +| 10000 | wide | representation_off | true | pandas | pandas | 0.182 | 0.181 | 0.182 | 0.003 | 54988.2 | 0.057 | 0.080 | — | +| 10000 | wide | statistical_off | false | pandas | pandas | 1.241 | 1.239 | 1.247 | 0.003 | 8058.1 | 0.209 | 1.222 | — | +| 10000 | wide | statistical_off | true | pandas | pandas | 1.253 | 1.247 | 1.296 | 0.016 | 7983.3 | 0.090 | 1.223 | — | +| 100000 | medium | default | false | pandas | pandas | 0.703 | 0.702 | 0.734 | 0.020 | 142223.8 | 4.615 | 13.956 | — | +| 100000 | medium | default | true | pandas | pandas | 0.692 | 0.683 | 0.713 | 0.016 | 144449.4 | 10.199 | 13.955 | — | +| 100000 | medium | default | false | pandas | pandas | 0.548 | 0.547 | 0.564 | 0.013 | 182445.3 | 0.084 | 2.068 | — | +| 100000 | medium | default | true | pandas | pandas | 0.550 | 0.550 | 0.567 | 0.014 | 181838.5 | 1.144 | 2.068 | — | +| 100000 | medium | default | false | pandas | pandas | 7.134 | 7.076 | 7.384 | 0.018 | 14017.2 | 0.062 | 0.402 | — | +| 100000 | medium | default | true | pandas | pandas | 6.888 | 6.834 | 6.947 | 0.007 | 14518.7 | 0.051 | 0.402 | — | +| 100000 | medium | aggressive | true | pandas | pandas | 2.814 | 2.810 | 2.844 | 0.005 | 35534.9 | 0.297 | 1.324 | — | +| 100000 | medium | conservative | false | pandas | pandas | 1.906 | 1.881 | 2.228 | 0.077 | 52455.9 | 0.402 | 1.332 | — | +| 100000 | medium | conservative | true | pandas | pandas | 1.912 | 1.893 | 2.092 | 0.044 | 52306.7 | 0.209 | 1.332 | — | +| 100000 | medium | default | false | pandas | pandas | 2.766 | 2.740 | 2.782 | 0.006 | 36151.7 | 0.436 | 1.332 | — | +| 100000 | medium | default | true | pandas | pandas | 3.707 | 2.931 | 4.235 | 0.135 | 26976.0 | 0.408 | 1.332 | — | +| 100000 | medium | explicit | false | pandas | pandas | 2.000 | 1.978 | 2.018 | 0.008 | 50001.7 | 0.353 | 1.332 | — | +| 100000 | medium | explicit | true | pandas | pandas | 2.180 | 2.000 | 3.327 | 0.249 | 45880.6 | 0.201 | 1.332 | — | +| 100000 | medium | duplicates | false | pandas-component-baseline | pandas | 0.246 | 0.223 | 0.269 | 0.075 | 405835.5 | 0.023 | 0.555 | — | +| 100000 | medium | null_counts | false | pandas-component-baseline | pandas | 0.036 | 0.036 | 0.036 | 0.004 | 2806275.8 | 0.001 | 0.052 | — | +| 100000 | medium | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.613 | 656995690.0 | 0.000 | 0.008 | — | +| 100000 | medium | representation_off | false | pandas | pandas | 0.405 | 0.400 | 0.409 | 0.010 | 246643.4 | 0.043 | 0.056 | — | +| 100000 | medium | representation_off | true | pandas | pandas | 0.412 | 0.411 | 0.415 | 0.003 | 242509.9 | 0.033 | 0.056 | — | +| 100000 | medium | semantic | true | pandas | pandas | 4.147 | 4.133 | 4.198 | 0.008 | 24112.4 | 0.205 | 1.332 | — | +| 100000 | medium | statistical_off | false | pandas | pandas | 1.908 | 1.890 | 2.272 | 0.085 | 52411.9 | 0.257 | 1.332 | — | +| 100000 | medium | statistical_off | true | pandas | pandas | 1.931 | 1.881 | 2.256 | 0.080 | 51781.5 | 0.200 | 1.332 | — | +| 100000 | medium | default | false | pandas | pandas | 1.481 | 1.444 | 1.584 | 0.035 | 67510.6 | 1.203 | 3.055 | — | +| 100000 | medium | default | true | pandas | pandas | 1.561 | 1.508 | 1.632 | 0.035 | 64059.3 | 0.101 | 3.055 | — | +| 100000 | medium | default | false | pandas | pandas | 1.112 | 1.105 | 1.122 | 0.007 | 89925.3 | 0.152 | 3.183 | — | +| 100000 | medium | default | true | pandas | pandas | 1.115 | 1.108 | 1.124 | 0.006 | 89665.9 | 0.031 | 3.183 | — | +| 100000 | medium | default | false | pandas | pandas | 5.241 | 5.202 | 5.265 | 0.005 | 19081.8 | 0.063 | 0.398 | — | +| 100000 | medium | default | true | pandas | pandas | 6.392 | 6.249 | 6.513 | 0.019 | 15645.7 | 0.056 | 0.398 | — | +| 100000 | narrow | conservative | false | pandas | pandas | 0.467 | 0.467 | 0.470 | 0.003 | 213928.2 | 2.007 | 1.868 | — | +| 100000 | narrow | conservative | true | pandas | pandas | 0.477 | 0.471 | 0.481 | 0.009 | 209503.1 | 1.202 | 1.868 | — | +| 100000 | narrow | default | false | pandas | pandas | 0.671 | 0.666 | 0.675 | 0.005 | 148961.6 | 1.297 | 1.868 | — | +| 100000 | narrow | default | true | pandas | pandas | 0.670 | 0.665 | 0.670 | 0.004 | 149284.4 | 1.709 | 1.868 | — | +| 100000 | narrow | explicit | false | pandas | pandas | 0.505 | 0.501 | 0.507 | 0.005 | 197974.5 | 1.871 | 1.868 | — | +| 100000 | narrow | explicit | true | pandas | pandas | 0.501 | 0.494 | 0.502 | 0.008 | 199726.3 | 2.063 | 1.868 | — | +| 100000 | narrow | duplicates | false | pandas-component-baseline | pandas | 0.061 | 0.052 | 0.075 | 0.132 | 1646529.8 | 0.006 | 0.973 | — | +| 100000 | narrow | null_counts | false | pandas-component-baseline | pandas | 0.009 | 0.007 | 0.009 | 0.088 | 11236428.5 | 0.005 | 0.090 | — | +| 100000 | narrow | numeric_median_fill | false | pandas-component-baseline | pandas | 0.016 | 0.014 | 0.017 | 0.086 | 6329497.7 | 0.262 | 0.581 | — | +| 100000 | narrow | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.821 | 1584158415.9 | 0.003 | 0.037 | — | +| 100000 | narrow | representation_off | false | pandas | pandas | 0.083 | 0.083 | 0.088 | 0.026 | 1204377.9 | 0.079 | 0.105 | — | +| 100000 | narrow | representation_off | true | pandas | pandas | 0.083 | 0.083 | 0.083 | 0.003 | 1202504.2 | 0.014 | 0.105 | — | +| 100000 | narrow | statistical_off | false | pandas | pandas | 0.473 | 0.470 | 0.473 | 0.003 | 211589.5 | 0.963 | 1.868 | — | +| 100000 | narrow | statistical_off | true | pandas | pandas | 0.469 | 0.467 | 0.473 | 0.005 | 213185.3 | 0.807 | 1.868 | — | +| 100000 | wide | conservative | false | pandas | pandas | 8.714 | 8.670 | 8.860 | 0.009 | 11476.1 | 0.278 | 1.182 | — | +| 100000 | wide | conservative | true | pandas | pandas | 7.734 | 7.666 | 7.745 | 0.004 | 12929.9 | 0.056 | 1.182 | — | +| 100000 | wide | default | false | pandas | pandas | 13.121 | 13.022 | 13.372 | 0.010 | 7621.3 | 0.054 | 1.182 | — | +| 100000 | wide | default | true | pandas | pandas | 12.393 | 11.614 | 13.080 | 0.050 | 8069.3 | 0.270 | 1.182 | — | +| 100000 | wide | explicit | false | pandas | pandas | 8.066 | 8.032 | 8.125 | 0.005 | 12398.2 | 0.492 | 1.182 | — | +| 100000 | wide | explicit | true | pandas | pandas | 7.975 | 7.944 | 8.028 | 0.005 | 12539.2 | 0.415 | 1.182 | — | +| 100000 | wide | duplicates | false | pandas-component-baseline | pandas | 0.993 | 0.980 | 1.126 | 0.063 | 100671.2 | 0.003 | 0.465 | — | +| 100000 | wide | null_counts | false | pandas-component-baseline | pandas | 0.171 | 0.164 | 0.203 | 0.092 | 586268.0 | 0.018 | 0.044 | — | +| 100000 | wide | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.110 | 523560209.5 | 0.000 | 0.002 | — | +| 100000 | wide | representation_off | false | pandas | pandas | 1.687 | 1.682 | 1.697 | 0.004 | 59261.1 | 0.002 | 0.045 | — | +| 100000 | wide | representation_off | true | pandas | pandas | 1.710 | 1.699 | 1.726 | 0.006 | 58469.8 | 0.003 | 0.045 | — | +| 100000 | wide | statistical_off | false | pandas | pandas | 7.653 | 7.600 | 7.695 | 0.006 | 13066.8 | 0.058 | 1.182 | — | +| 100000 | wide | statistical_off | true | pandas | pandas | 7.658 | 7.646 | 7.939 | 0.020 | 13057.9 | 0.142 | 1.182 | — | +| 500000 | medium | conservative | false | pandas | pandas | 9.956 | 9.922 | 10.239 | 0.013 | 50222.8 | 0.167 | 1.316 | — | +| 500000 | medium | conservative | true | pandas | pandas | 9.827 | 9.785 | 9.937 | 0.006 | 50879.3 | 0.169 | 1.316 | — | +| 500000 | medium | default | false | pandas | pandas | 20.539 | 19.755 | 20.979 | 0.023 | 24343.8 | 0.158 | 1.316 | — | +| 500000 | medium | default | true | pandas | pandas | 19.412 | 18.143 | 23.753 | 0.131 | 25757.6 | 0.203 | 1.316 | — | +| 500000 | medium | explicit | false | pandas | pandas | 8.363 | 8.292 | 10.263 | 0.103 | 59784.2 | 0.163 | 1.316 | — | +| 500000 | medium | explicit | true | pandas | pandas | 8.495 | 8.386 | 8.552 | 0.008 | 58856.5 | 0.163 | 1.316 | — | +| 500000 | medium | duplicates | false | pandas-component-baseline | pandas | 2.028 | 1.402 | 2.856 | 0.333 | 246536.8 | 0.000 | 0.559 | — | +| 500000 | medium | null_counts | false | pandas-component-baseline | pandas | 0.179 | 0.165 | 0.306 | 0.338 | 2786726.9 | 0.000 | 0.045 | — | +| 500000 | medium | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.152 | 5695279749.2 | 0.000 | 0.002 | — | +| 500000 | medium | representation_off | false | pandas | pandas | 0.834 | 0.833 | 0.863 | 0.016 | 599344.3 | 0.001 | 0.048 | — | +| 500000 | medium | representation_off | true | pandas | pandas | 0.828 | 0.827 | 0.830 | 0.002 | 604101.6 | 0.001 | 0.048 | — | +| 500000 | medium | statistical_off | false | pandas | pandas | 9.960 | 9.821 | 10.470 | 0.025 | 50201.2 | 0.239 | 1.316 | — | +| 500000 | medium | statistical_off | true | pandas | pandas | 10.277 | 10.094 | 10.650 | 0.025 | 48654.7 | 0.190 | 1.316 | — | +| 500000 | narrow | conservative | false | pandas | pandas | 2.057 | 2.056 | 2.066 | 0.002 | 243017.2 | 0.886 | 1.827 | — | +| 500000 | narrow | conservative | true | pandas | pandas | 2.057 | 2.051 | 2.062 | 0.002 | 243071.6 | 0.862 | 1.827 | — | +| 500000 | narrow | default | false | pandas | pandas | 3.186 | 3.149 | 3.214 | 0.008 | 156918.3 | 0.953 | 1.827 | — | +| 500000 | narrow | default | true | pandas | pandas | 3.660 | 3.630 | 3.795 | 0.018 | 136609.5 | 1.025 | 1.827 | — | +| 500000 | narrow | explicit | false | pandas | pandas | 2.167 | 2.153 | 2.180 | 0.005 | 230747.3 | 1.921 | 1.827 | — | +| 500000 | narrow | explicit | true | pandas | pandas | 2.171 | 2.162 | 2.230 | 0.013 | 230312.5 | 1.281 | 1.827 | — | +| 500000 | narrow | duplicates | false | pandas-component-baseline | pandas | 0.438 | 0.314 | 0.560 | 0.259 | 1141796.9 | 0.189 | 1.004 | — | +| 500000 | narrow | null_counts | false | pandas-component-baseline | pandas | 0.034 | 0.034 | 0.035 | 0.010 | 14522429.9 | 0.000 | 0.057 | — | +| 500000 | narrow | numeric_median_fill | false | pandas-component-baseline | pandas | 0.061 | 0.060 | 0.064 | 0.030 | 8247394.4 | 0.007 | 0.548 | — | +| 500000 | narrow | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.071 | 7159836184.3 | 0.000 | 0.007 | — | +| 500000 | narrow | representation_off | false | pandas | pandas | 0.231 | 0.231 | 0.231 | 0.000 | 2163479.7 | 0.056 | 0.075 | — | +| 500000 | narrow | representation_off | true | pandas | pandas | 0.163 | 0.163 | 0.164 | 0.002 | 3062243.9 | 0.108 | 0.075 | — | +| 500000 | narrow | statistical_off | false | pandas | pandas | 2.057 | 2.030 | 2.065 | 0.007 | 243067.0 | 0.873 | 1.827 | — | +| 500000 | narrow | statistical_off | true | pandas | pandas | 2.049 | 2.039 | 2.134 | 0.019 | 244003.2 | 0.971 | 1.827 | — | +| 500000 | wide | conservative | false | pandas | pandas | 30.908 | 30.745 | 31.115 | 0.004 | 16177.3 | 0.310 | 1.172 | — | +| 500000 | wide | conservative | true | pandas | pandas | 30.906 | 30.861 | 30.935 | 0.001 | 16178.2 | 0.369 | 1.172 | — | +| 500000 | wide | default | false | pandas | pandas | 52.681 | 52.298 | 54.534 | 0.018 | 9491.1 | 0.318 | 1.172 | — | +| 500000 | wide | default | true | pandas | pandas | 69.694 | 54.972 | 70.916 | 0.096 | 7174.2 | 0.352 | 1.172 | — | +| 500000 | wide | explicit | false | pandas | pandas | 32.221 | 32.133 | 32.415 | 0.004 | 15518.0 | 0.542 | 1.172 | — | +| 500000 | wide | explicit | true | pandas | pandas | 33.529 | 32.020 | 36.898 | 0.055 | 14912.3 | 0.173 | 1.172 | — | +| 500000 | wide | duplicates | false | pandas-component-baseline | pandas | 4.743 | 4.591 | 5.050 | 0.037 | 105418.0 | 0.000 | 0.464 | — | +| 500000 | wide | null_counts | false | pandas-component-baseline | pandas | 0.678 | 0.655 | 0.718 | 0.038 | 737053.2 | 0.001 | 0.042 | — | +| 500000 | wide | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.097 | 2761149521.5 | 0.000 | 0.000 | — | +| 500000 | wide | representation_off | false | pandas | pandas | 3.499 | 3.489 | 3.505 | 0.002 | 142887.5 | 0.001 | 0.043 | — | +| 500000 | wide | representation_off | true | pandas | pandas | 3.542 | 3.524 | 3.672 | 0.018 | 141179.7 | 0.000 | 0.043 | — | +| 500000 | wide | statistical_off | false | pandas | pandas | 30.767 | 30.633 | 30.926 | 0.004 | 16251.2 | 0.341 | 1.172 | — | +| 500000 | wide | statistical_off | true | pandas | pandas | 30.559 | 30.448 | 30.594 | 0.002 | 16361.7 | 0.371 | 1.172 | — | +| 1000000 | medium | conservative | false | pandas | pandas | 15.863 | 15.793 | 15.908 | 0.003 | 63041.3 | 0.192 | 1.314 | — | +| 1000000 | medium | conservative | true | pandas | pandas | 15.932 | 15.816 | 16.166 | 0.009 | 62765.2 | 0.087 | 1.314 | — | +| 1000000 | medium | default | false | pandas | pandas | 27.221 | 26.601 | 27.344 | 0.011 | 36735.9 | 0.283 | 1.314 | — | +| 1000000 | medium | default | true | pandas | pandas | 26.805 | 26.580 | 26.889 | 0.005 | 37307.0 | 0.344 | 1.314 | — | +| 1000000 | medium | explicit | false | pandas | pandas | 16.990 | 16.890 | 17.078 | 0.005 | 58859.3 | 0.155 | 1.314 | — | +| 1000000 | medium | explicit | true | pandas | pandas | 17.032 | 16.976 | 17.573 | 0.015 | 58712.8 | 0.197 | 1.314 | — | +| 1000000 | medium | duplicates | false | pandas-component-baseline | pandas | 2.671 | 2.417 | 2.840 | 0.064 | 374394.7 | 0.163 | 0.569 | — | +| 1000000 | medium | null_counts | false | pandas-component-baseline | pandas | 0.370 | 0.356 | 0.477 | 0.145 | 2700703.0 | 0.000 | 0.044 | — | +| 1000000 | medium | numeric_median_fill | false | pandas-component-baseline | pandas | 0.432 | 0.425 | 0.434 | 0.008 | 2315979.5 | 0.000 | 0.570 | — | +| 1000000 | medium | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.203 | 13392976714.8 | 0.000 | 0.001 | — | +| 1000000 | medium | representation_off | false | pandas | pandas | 1.587 | 1.584 | 1.637 | 0.014 | 629979.9 | 0.000 | 0.048 | — | +| 1000000 | medium | representation_off | true | pandas | pandas | 1.579 | 1.573 | 1.584 | 0.003 | 633259.2 | 0.000 | 0.048 | — | +| 1000000 | medium | statistical_off | false | pandas | pandas | 15.760 | 15.642 | 15.905 | 0.006 | 63453.4 | 0.120 | 1.314 | — | +| 1000000 | medium | statistical_off | true | pandas | pandas | 15.801 | 15.787 | 15.979 | 0.005 | 63285.8 | 0.377 | 1.314 | — | +| 1000000 | narrow | conservative | false | pandas | pandas | 4.203 | 4.200 | 4.259 | 0.006 | 237950.8 | 1.034 | 1.822 | — | +| 1000000 | narrow | conservative | true | pandas | pandas | 4.287 | 4.273 | 4.303 | 0.003 | 233270.1 | 1.120 | 1.822 | — | +| 1000000 | narrow | default | false | pandas | pandas | 8.903 | 8.241 | 10.087 | 0.094 | 112323.8 | 0.966 | 1.822 | — | +| 1000000 | narrow | default | true | pandas | pandas | 6.910 | 6.882 | 7.062 | 0.012 | 144724.3 | 0.961 | 1.822 | — | +| 1000000 | narrow | explicit | false | pandas | pandas | 4.980 | 4.879 | 5.141 | 0.020 | 200800.4 | 0.994 | 1.822 | — | +| 1000000 | narrow | explicit | true | pandas | pandas | 5.722 | 5.472 | 6.330 | 0.059 | 174772.8 | 0.991 | 1.822 | — | +| 1000000 | narrow | duplicates | false | pandas-component-baseline | pandas | 0.593 | 0.573 | 0.682 | 0.076 | 1686888.2 | 0.000 | 1.051 | — | +| 1000000 | narrow | null_counts | false | pandas-component-baseline | pandas | 0.060 | 0.060 | 0.071 | 0.083 | 16712847.6 | 0.032 | 0.053 | — | +| 1000000 | narrow | numeric_median_fill | false | pandas-component-baseline | pandas | 0.128 | 0.109 | 0.133 | 0.092 | 7831962.6 | 0.000 | 0.544 | — | +| 1000000 | narrow | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.226 | 15635260626.3 | 0.000 | 0.004 | — | +| 1000000 | narrow | representation_off | false | pandas | pandas | 0.316 | 0.315 | 0.318 | 0.003 | 3162296.2 | 0.001 | 0.071 | — | +| 1000000 | narrow | representation_off | true | pandas | pandas | 0.313 | 0.313 | 0.315 | 0.003 | 3189867.3 | 0.000 | 0.071 | — | +| 1000000 | narrow | statistical_off | false | pandas | pandas | 4.274 | 4.251 | 4.300 | 0.004 | 233993.7 | 0.980 | 1.822 | — | +| 1000000 | narrow | statistical_off | true | pandas | pandas | 4.331 | 4.292 | 4.646 | 0.039 | 230905.6 | 0.978 | 1.822 | — | +| 1000000 | wide | conservative | false | pandas | pandas | 67.080 | 65.213 | 67.988 | 0.017 | 14907.5 | 0.647 | 1.171 | — | +| 1000000 | wide | conservative | true | pandas | pandas | 64.627 | 64.291 | 65.270 | 0.006 | 15473.3 | 0.475 | 1.171 | — | +| 1000000 | wide | default | false | pandas | pandas | 112.110 | 109.789 | 113.332 | 0.013 | 8919.8 | 0.449 | 1.171 | — | +| 1000000 | wide | default | true | pandas | pandas | 110.060 | 109.935 | 110.329 | 0.001 | 9085.9 | 0.326 | 1.171 | — | +| 1000000 | wide | explicit | false | pandas | pandas | 65.768 | 65.534 | 66.738 | 0.008 | 15204.9 | 0.651 | 1.171 | — | +| 1000000 | wide | explicit | true | pandas | pandas | 65.115 | 64.894 | 66.087 | 0.007 | 15357.4 | 0.546 | 1.171 | — | +| 1000000 | wide | duplicates | false | pandas-component-baseline | pandas | 13.899 | 13.198 | 17.881 | 0.135 | 71945.6 | 0.124 | 0.466 | — | +| 1000000 | wide | null_counts | false | pandas-component-baseline | pandas | 1.264 | 1.246 | 1.266 | 0.007 | 791195.9 | 0.013 | 0.041 | — | +| 1000000 | wide | numeric_median_fill | false | pandas-component-baseline | pandas | 2.921 | 2.759 | 4.580 | 0.258 | 342326.2 | 0.158 | 0.564 | — | +| 1000000 | wide | shallow_copy | false | pandas-component-baseline | pandas | 0.000 | 0.000 | 0.000 | 0.375 | 4426404390.3 | 0.000 | 0.000 | — | +| 1000000 | wide | representation_off | false | pandas | pandas | 6.676 | 6.619 | 6.704 | 0.006 | 149796.8 | 0.001 | 0.042 | — | +| 1000000 | wide | representation_off | true | pandas | pandas | 6.899 | 6.862 | 7.027 | 0.010 | 144950.1 | 0.000 | 0.042 | — | +| 1000000 | wide | statistical_off | false | pandas | pandas | 65.252 | 64.263 | 66.477 | 0.013 | 15325.3 | 0.372 | 1.171 | — | +| 1000000 | wide | statistical_off | true | pandas | pandas | 68.690 | 68.404 | 69.548 | 0.007 | 14558.1 | 0.401 | 1.171 | — | + +## Profiling findings + +### case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5 + +- audit_events: 0.0% +- backend_conversion: 0.0% +- context: 0.2% +- correlation: 0.2% +- dtype_repair: 2.5% +- duplicates: 0.1% +- engine_cache: 0.0% +- missing: 0.0% +- outliers: 0.0% +- report_finalization: 0.0% +- role_inference: 0.1% +- semantic_ml: 0.0% +- `/Users/wilson/freshdata-qa/src/freshdata/api.py:138 clean` — self 0.000 s, cumulative 18.448 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:189 clean` — self 0.000 s, cumulative 18.444 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:45 run_pipeline` — self 0.002 s, cumulative 18.444 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:332 fix_dtypes` — self 0.002 s, cumulative 11.889 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:297 suggest_conversion` — self 0.002 s, cumulative 11.884 s, calls 42 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:133 _try_numeric` — self 0.002 s, cumulative 10.877 s, calls 42 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:124 _to_numeric_or_none` — self 0.000 s, cumulative 8.525 s, calls 42 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/tools/numeric.py:47 to_numeric` — self 8.505 s, cumulative 8.524 s, calls 42 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py:132 wrapper` — self 0.001 s, cumulative 2.324 s, calls 210 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py:431 _str_map` — self 0.050 s, cumulative 2.239 s, calls 210 + +### case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5 + +- audit_events: 0.0% +- backend_conversion: 0.0% +- context: 0.0% +- correlation: 0.2% +- dtype_repair: 1.8% +- duplicates: 0.3% +- engine_cache: 0.0% +- missing: 0.0% +- outliers: 0.0% +- report_finalization: 0.0% +- role_inference: 0.1% +- semantic_ml: 0.0% +- `/Users/wilson/freshdata-qa/src/freshdata/api.py:138 clean` — self 0.000 s, cumulative 15.656 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:189 clean` — self 0.000 s, cumulative 15.655 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:45 run_pipeline` — self 0.002 s, cumulative 15.655 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:332 fix_dtypes` — self 0.003 s, cumulative 4.873 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:297 suggest_conversion` — self 0.003 s, cumulative 4.869 s, calls 10 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py:83 drop_duplicate_rows` — self 0.003 s, cumulative 3.694 s, calls 1 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py:132 wrapper` — self 0.000 s, cumulative 3.660 s, calls 50 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py:431 _str_map` — self 0.012 s, cumulative 3.635 s, calls 50 +- `/Users/wilson/freshdata-qa/src/freshdata/_util.py:34 memory_bytes` — self 0.000 s, cumulative 3.352 s, calls 2 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py:3677 memory_usage` — self 0.000 s, cumulative 3.351 s, calls 2 + +### case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5 + +- audit_events: 0.0% +- backend_conversion: 0.0% +- context: 0.1% +- correlation: 0.2% +- dtype_repair: 1.6% +- duplicates: 0.2% +- engine_cache: 0.0% +- missing: 0.0% +- outliers: 0.0% +- report_finalization: 0.0% +- role_inference: 0.1% +- semantic_ml: 0.0% +- `/Users/wilson/freshdata-qa/src/freshdata/api.py:138 clean` — self 0.000 s, cumulative 16.007 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:189 clean` — self 0.000 s, cumulative 16.006 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:45 run_pipeline` — self 0.001 s, cumulative 16.006 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:332 fix_dtypes` — self 0.003 s, cumulative 4.828 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:297 suggest_conversion` — self 0.003 s, cumulative 4.825 s, calls 10 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py:132 wrapper` — self 0.000 s, cumulative 3.771 s, calls 50 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py:431 _str_map` — self 0.012 s, cumulative 3.745 s, calls 50 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py:83 drop_duplicate_rows` — self 0.003 s, cumulative 3.697 s, calls 1 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py:486 _str_map_str_or_object` — self 1.147 s, cumulative 3.452 s, calls 40 +- `/Users/wilson/freshdata-qa/src/freshdata/_util.py:34 memory_bytes` — self 0.000 s, cumulative 3.319 s, calls 2 + +### case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5 + +- audit_events: 0.0% +- backend_conversion: 0.0% +- context: 0.1% +- correlation: 0.1% +- dtype_repair: 1.2% +- duplicates: 0.2% +- engine_cache: 0.0% +- missing: 0.0% +- outliers: 0.0% +- report_finalization: 0.0% +- role_inference: 0.1% +- semantic_ml: 13.1% +- `/Users/wilson/freshdata-qa/src/freshdata/api.py:138 clean` — self 0.000 s, cumulative 22.017 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:189 clean` — self 0.000 s, cumulative 22.016 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:45 run_pipeline` — self 0.001 s, cumulative 22.016 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/semantic/apply.py:192 run_semantic` — self 0.000 s, cumulative 6.300 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py:224 build_semantic_context` — self 0.017 s, cumulative 6.184 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py:68 _build_info` — self 0.321 s, cumulative 5.200 s, calls 32 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:332 fix_dtypes` — self 0.003 s, cumulative 4.842 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:297 suggest_conversion` — self 0.003 s, cumulative 4.838 s, calls 10 +- `~:0 ` — self 0.006 s, cumulative 4.240 s, calls 222 +- `/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py:43 _share` — self 0.000 s, cumulative 4.232 s, calls 192 + +### case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5 + +- audit_events: 0.0% +- backend_conversion: 0.0% +- context: 0.0% +- correlation: 0.3% +- dtype_repair: 2.0% +- duplicates: 0.4% +- engine_cache: 0.0% +- missing: 0.0% +- outliers: 0.0% +- report_finalization: 0.0% +- role_inference: 0.1% +- semantic_ml: 0.0% +- `/Users/wilson/freshdata-qa/src/freshdata/api.py:138 clean` — self 0.000 s, cumulative 49.320 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:189 clean` — self 0.000 s, cumulative 49.319 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:45 run_pipeline` — self 0.002 s, cumulative 49.319 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py:83 drop_duplicate_rows` — self 0.010 s, cumulative 18.036 s, calls 1 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py:132 wrapper` — self 0.000 s, cumulative 17.410 s, calls 50 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py:431 _str_map` — self 0.013 s, cumulative 17.383 s, calls 50 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py:486 _str_map_str_or_object` — self 5.671 s, cumulative 16.647 s, calls 40 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py:70 _filter_rows` — self 0.196 s, cumulative 16.228 s, calls 1 +- `/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py:58 observed` — self 0.011 s, cumulative 16.063 s, calls 396 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py:332 fix_dtypes` — self 0.013 s, cumulative 13.256 s, calls 1 + +### case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5 + +- audit_events: 0.0% +- backend_conversion: 0.0% +- context: 0.0% +- correlation: 0.1% +- dtype_repair: 1.4% +- duplicates: 0.9% +- engine_cache: 0.0% +- missing: 0.0% +- outliers: 0.0% +- report_finalization: 0.0% +- role_inference: 0.1% +- semantic_ml: 0.0% +- `/Users/wilson/freshdata-qa/src/freshdata/api.py:138 clean` — self 0.000 s, cumulative 31.423 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:189 clean` — self 0.000 s, cumulative 31.422 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/cleaner.py:45 run_pipeline` — self 0.008 s, cumulative 31.422 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py:83 drop_duplicate_rows` — self 0.009 s, cumulative 17.997 s, calls 1 +- `/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py:70 _filter_rows` — self 0.267 s, cumulative 16.875 s, calls 1 +- `/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py:58 observed` — self 0.005 s, cumulative 10.112 s, calls 99 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py:317 apply` — self 0.003 s, cumulative 8.208 s, calls 114 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py:6485 astype` — self 0.000 s, cumulative 7.929 s, calls 18 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py:440 astype` — self 0.000 s, cumulative 7.925 s, calls 18 +- `/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py:749 astype` — self 0.000 s, cumulative 7.925 s, calls 18 + + +## Confirmed root causes + +No cause is confirmed by profiling alone; these exact-evidence items are performance candidates: + +- `optional_ml_overhead` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): candidate; stage 13.1%, observed calls 1. + +## Rejected hypotheses + +- `backend_conversion_overhead` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `copy_pressure` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.2%, observed calls 101. +- `dtype_conversion_pressure` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 2.5%, observed calls 326. +- `optional_ml_overhead` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `repeated_null_scans` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 1567. +- `repeated_uniqueness_scans` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 256. +- `report_finalization_overhead` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 1. +- `unnecessary_correlation` in `2e88248a20ec642b` (case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.2%, observed calls 1. +- `backend_conversion_overhead` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `copy_pressure` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 17. +- `dtype_conversion_pressure` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 1.4%, observed calls 18. +- `optional_ml_overhead` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `repeated_null_scans` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 47. +- `repeated_uniqueness_scans` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 16. +- `report_finalization_overhead` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 1. +- `unnecessary_correlation` in `52f1c76054406372` (case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.1%, observed calls 1. +- `backend_conversion_overhead` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `copy_pressure` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 61. +- `dtype_conversion_pressure` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 1.2%, observed calls 108. +- `repeated_null_scans` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 330. +- `repeated_uniqueness_scans` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 139. +- `report_finalization_overhead` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 1. +- `unnecessary_correlation` in `9ea9cb03dfc114c5` (case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={"semantic_mode":"assist","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.1%, observed calls 1. +- `backend_conversion_overhead` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `copy_pressure` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 41. +- `dtype_conversion_pressure` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 1.8%, observed calls 73. +- `optional_ml_overhead` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `repeated_null_scans` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 227. +- `repeated_uniqueness_scans` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 64. +- `report_finalization_overhead` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 1. +- `unnecessary_correlation` in `a877f296485e3003` (case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={"strategy":"aggressive","verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.2%, observed calls 1. +- `backend_conversion_overhead` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `copy_pressure` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 31. +- `dtype_conversion_pressure` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 2.0%, observed calls 78. +- `optional_ml_overhead` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `repeated_null_scans` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 222. +- `repeated_uniqueness_scans` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 64. +- `report_finalization_overhead` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 1. +- `unnecessary_correlation` in `c4cf49ffc913ad42` (case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={"verbose":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.3%, observed calls 1. +- `backend_conversion_overhead` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `copy_pressure` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 31. +- `dtype_conversion_pressure` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 1.6%, observed calls 78. +- `optional_ml_overhead` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.0%, observed calls 0. +- `repeated_null_scans` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 222. +- `repeated_uniqueness_scans` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.1%, observed calls 64. +- `report_finalization_overhead` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): rejected; stage 0.0%, observed calls 1. +- `unnecessary_correlation` in `eb41d9a6034039f8` (case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={"verbose":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5): insufficient_evidence; stage 0.2%, observed calls 1. + +## Failures, timeouts, and OOMs + +- 10000 rows / medium / pandas_numeric_median_fill: failed (ChildProcessError: Traceback (most recent call last): + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2401, in fillna + new_values = self.values.fillna( + ^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '5082.5' for dtype 'Int64' + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "", line 1, in + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 137, in baseline_worker_main + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 94, in measure_pandas_baseline + operation(frame) + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 31, in _numeric_median_fill + column: frame[column].fillna(frame[column].median()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", line 7372, in fillna + new_data = self._mgr.fillna( + ^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", line 186, in fillna + return self.apply_with_block( + ^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", line 363, in apply + applied = getattr(b, f)(**kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2407, in fillna + new_values = self.values.fillna(value=value, method=None, limit=limit) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '5082.5' for dtype 'Int64' +). +- 10000 rows / narrow / pandas_numeric_median_fill: failed (ChildProcessError: Traceback (most recent call last): + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2401, in fillna + new_values = self.values.fillna( + ^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '5082.5' for dtype 'Int64' + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "", line 1, in + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 137, in baseline_worker_main + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 94, in measure_pandas_baseline + operation(frame) + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 31, in _numeric_median_fill + column: frame[column].fillna(frame[column].median()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", line 7372, in fillna + new_data = self._mgr.fillna( + ^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", line 186, in fillna + return self.apply_with_block( + ^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", line 363, in apply + applied = getattr(b, f)(**kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2407, in fillna + new_values = self.values.fillna(value=value, method=None, limit=limit) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '5082.5' for dtype 'Int64' +). +- 10000 rows / wide / pandas_numeric_median_fill: failed (ChildProcessError: Traceback (most recent call last): + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2401, in fillna + new_values = self.values.fillna( + ^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '5082.5' for dtype 'Int64' + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "", line 1, in + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 137, in baseline_worker_main + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 94, in measure_pandas_baseline + operation(frame) + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 31, in _numeric_median_fill + column: frame[column].fillna(frame[column].median()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", line 7372, in fillna + new_data = self._mgr.fillna( + ^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", line 186, in fillna + return self.apply_with_block( + ^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", line 363, in apply + applied = getattr(b, f)(**kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2407, in fillna + new_values = self.values.fillna(value=value, method=None, limit=limit) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '5082.5' for dtype 'Int64' +). +- 100000 rows / medium / pandas_numeric_median_fill: failed (ChildProcessError: Traceback (most recent call last): + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2401, in fillna + new_values = self.values.fillna( + ^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4989.5' for dtype 'Int64' + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "", line 1, in + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 137, in baseline_worker_main + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 94, in measure_pandas_baseline + operation(frame) + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 31, in _numeric_median_fill + column: frame[column].fillna(frame[column].median()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", line 7372, in fillna + new_data = self._mgr.fillna( + ^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", line 186, in fillna + return self.apply_with_block( + ^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", line 363, in apply + applied = getattr(b, f)(**kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2407, in fillna + new_values = self.values.fillna(value=value, method=None, limit=limit) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4989.5' for dtype 'Int64' +). +- 100000 rows / wide / pandas_numeric_median_fill: failed (ChildProcessError: Traceback (most recent call last): + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2401, in fillna + new_values = self.values.fillna( + ^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4989.5' for dtype 'Int64' + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "", line 1, in + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 137, in baseline_worker_main + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 94, in measure_pandas_baseline + operation(frame) + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 31, in _numeric_median_fill + column: frame[column].fillna(frame[column].median()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", line 7372, in fillna + new_data = self._mgr.fillna( + ^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", line 186, in fillna + return self.apply_with_block( + ^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", line 363, in apply + applied = getattr(b, f)(**kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2407, in fillna + new_values = self.values.fillna(value=value, method=None, limit=limit) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4989.5' for dtype 'Int64' +). +- 500000 rows / medium / pandas_numeric_median_fill: failed (ChildProcessError: Traceback (most recent call last): + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2401, in fillna + new_values = self.values.fillna( + ^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4995.5' for dtype 'Int64' + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "", line 1, in + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 137, in baseline_worker_main + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 94, in measure_pandas_baseline + operation(frame) + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 31, in _numeric_median_fill + column: frame[column].fillna(frame[column].median()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", line 7372, in fillna + new_data = self._mgr.fillna( + ^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", line 186, in fillna + return self.apply_with_block( + ^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", line 363, in apply + applied = getattr(b, f)(**kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2407, in fillna + new_values = self.values.fillna(value=value, method=None, limit=limit) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4995.5' for dtype 'Int64' +). +- 500000 rows / wide / pandas_numeric_median_fill: failed (ChildProcessError: Traceback (most recent call last): + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2401, in fillna + new_values = self.values.fillna( + ^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4995.5' for dtype 'Int64' + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "", line 1, in + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 137, in baseline_worker_main + result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 94, in measure_pandas_baseline + operation(frame) + File "/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py", line 31, in _numeric_median_fill + column: frame[column].fillna(frame[column].median()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", line 7372, in fillna + new_data = self._mgr.fillna( + ^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", line 186, in fillna + return self.apply_with_block( + ^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", line 363, in apply + applied = getattr(b, f)(**kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", line 2407, in fillna + new_values = self.values.fillna(value=value, method=None, limit=limit) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 267, in fillna + new_values[mask] = value + ~~~~~~~~~~^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 315, in __setitem__ + value = self._validate_setitem_value(value) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", line 306, in _validate_setitem_value + raise TypeError(f"Invalid value '{value!s}' for dtype '{self.dtype}'") +TypeError: Invalid value '4995.5' for dtype 'Int64' +). + +## Limitations + +- Component baselines cover only their named pandas operation; no full balanced FreshData pipeline equivalence is claimed. +- Timing classifications require both a 10% effect and twice the larger observed coefficient of variation. diff --git a/benchmarks/results/performance/baseline-summary.json b/benchmarks/results/performance/baseline-summary.json new file mode 100644 index 0000000..ed659ef --- /dev/null +++ b/benchmarks/results/performance/baseline-summary.json @@ -0,0 +1,21632 @@ +{ + "component_baselines": [ + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.014412187068611125, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-kqx67jyy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-kqx67jyy/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.1903142887668263, + "max_seconds": 0.019302832999983366, + "median_seconds": 0.018859165999970173, + "min_seconds": 0.018641999999999825, + "output_fingerprint": "a0f6cdf92bc2ecb84b46804b8a4bacd5f20f7dd0c7292a497e141536d50bf427", + "peak_python_bytes": 4876536, + "peak_rss_bytes": 1409024, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.018641999999999825, + 0.019302832999983366, + 0.018748917000039, + 0.018859165999970173, + 0.019119332999935068 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0002718018283495607, + "throughput_rows_per_second": 530246.1413201313 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.024700056402647417, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7fgowvwz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7fgowvwz/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.0508980074608954, + "max_seconds": 0.003936374999966574, + "median_seconds": 0.003771834000076524, + "min_seconds": 0.0036948749999510255, + "output_fingerprint": "51976530eca8ad3d898dbdde4297c3056446179e19a0ef768abf88deab99ff44", + "peak_python_bytes": 1016578, + "peak_rss_bytes": 376832, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.0038405000000238942, + 0.003771834000076524, + 0.0037485420000393788, + 0.003936374999966574, + 0.0036948749999510255 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 9.316451254331336e-05, + "throughput_rows_per_second": 2651230.144220853 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": null, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vusdqa6w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vusdqa6w/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": "Traceback (most recent call last):\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2401, in fillna\n new_values = self.values.fillna(\n ^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '5082.5' for dtype 'Int64'\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 137, in baseline_worker_main\n result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 94, in measure_pandas_baseline\n operation(frame)\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 31, in _numeric_median_fill\n column: frame[column].fillna(frame[column].median())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py\", line 7372, in fillna\n new_data = self._mgr.fillna(\n ^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py\", line 186, in fillna\n return self.apply_with_block(\n ^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py\", line 363, in apply\n applied = getattr(b, f)(**kwargs)\n ^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2407, in fillna\n new_values = self.values.fillna(value=value, method=None, limit=limit)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '5082.5' for dtype 'Int64'\n", + "error_type": "ChildProcessError", + "input_bytes": null, + "input_to_peak_ratio": null, + "max_seconds": null, + "median_seconds": null, + "min_seconds": null, + "output_fingerprint": null, + "peak_python_bytes": null, + "peak_rss_bytes": null, + "profile": null, + "report_fingerprint": null, + "result_type": null, + "samples_seconds": [], + "schema_version": 1, + "status": "failed", + "stdev_seconds": null, + "throughput_rows_per_second": null + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.19660012388010098, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ytg1ke0e/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ytg1ke0e/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.004425913692251774, + "max_seconds": 9.94999999193169e-05, + "median_seconds": 7.545899995875516e-05, + "min_seconds": 6.062499994641257e-05, + "output_fingerprint": "ddd1c217f341ed560aedc99b8a50235c581321a6678bd28e899762f3c97317d9", + "peak_python_bytes": 602918, + "peak_rss_bytes": 32768, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 7.545899995875516e-05, + 6.062499994641257e-05, + 9.94999999193169e-05, + 6.645799999205337e-05, + 7.679199995891395e-05 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.4835248739759798e-05, + "throughput_rows_per_second": 132522296.94888431 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.08971734641083413, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hyt47z_w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hyt47z_w/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 0.06109492820861173, + "max_seconds": 0.005426833000001352, + "median_seconds": 0.004607666999959292, + "min_seconds": 0.004421249999950305, + "output_fingerprint": "687faf97bb6aa868aaaad04a992658d3f3606638b97b461cb4473b6d992f7024", + "peak_python_bytes": 2307615, + "peak_rss_bytes": 98304, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.004421249999950305, + 0.004433625000046959, + 0.004607666999959292, + 0.005426833000001352, + 0.004711999999926775 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0004133876563811167, + "throughput_rows_per_second": 2170295.7266851855 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.05626935104367517, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i66bg7ug/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i66bg7ug/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 0.05091244017384311, + "max_seconds": 0.0010811250000415384, + "median_seconds": 0.0009629999999560823, + "min_seconds": 0.0009560410001085984, + "output_fingerprint": "468fd5399340a064e6b6f30288684d688886505b1c784dc193d123090d01797c", + "peak_python_bytes": 736564, + "peak_rss_bytes": 81920, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.0009560410001085984, + 0.0010214579999683338, + 0.0009618329999057096, + 0.0010811250000415384, + 0.0009629999999560823 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 5.418738505258797e-05, + "throughput_rows_per_second": 10384215.9921662 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": null, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hqxwyk63/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hqxwyk63/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": "Traceback (most recent call last):\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2401, in fillna\n new_values = self.values.fillna(\n ^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '5082.5' for dtype 'Int64'\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 137, in baseline_worker_main\n result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 94, in measure_pandas_baseline\n operation(frame)\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 31, in _numeric_median_fill\n column: frame[column].fillna(frame[column].median())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py\", line 7372, in fillna\n new_data = self._mgr.fillna(\n ^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py\", line 186, in fillna\n return self.apply_with_block(\n ^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py\", line 363, in apply\n applied = getattr(b, f)(**kwargs)\n ^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2407, in fillna\n new_values = self.values.fillna(value=value, method=None, limit=limit)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '5082.5' for dtype 'Int64'\n", + "error_type": "ChildProcessError", + "input_bytes": null, + "input_to_peak_ratio": null, + "max_seconds": null, + "median_seconds": null, + "min_seconds": null, + "output_fingerprint": null, + "peak_python_bytes": null, + "peak_rss_bytes": null, + "profile": null, + "report_fingerprint": null, + "result_type": null, + "samples_seconds": [], + "schema_version": 1, + "status": "failed", + "stdev_seconds": null, + "throughput_rows_per_second": null + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.08478337673432136, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2qezvs/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2qezvs/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 0.030547464104305866, + "max_seconds": 5.4042000101617305e-05, + "median_seconds": 5.0667000095927506e-05, + "min_seconds": 4.279199993106886e-05, + "output_fingerprint": "2fed66746680e84ac879c30fd08563829a1517230b535aded771b02da2e7cd9a", + "peak_python_bytes": 602916, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 5.4042000101617305e-05, + 4.279199993106886e-05, + 5.1957999971818936e-05, + 5.0667000095927506e-05, + 4.858299996612914e-05 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 4.295719357130918e-06, + "throughput_rows_per_second": 197367122.21104592 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.3310376751270282, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-2yve61ar/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-2yve61ar/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.04849829047676716, + "max_seconds": 0.1405880419999903, + "median_seconds": 0.08166400000004614, + "min_seconds": 0.07861237500003426, + "output_fingerprint": "214772a4b6542e14c42e27e5c98fbd6f0d5eb4aa28d7c5de2b39c0c57a8c0c92", + "peak_python_bytes": 15152527, + "peak_rss_bytes": 1490944, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.07861237500003426, + 0.08192670799996904, + 0.08166400000004614, + 0.1405880419999903, + 0.07875366700000086 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.027033860701588905, + "throughput_rows_per_second": 122452.97805635714 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.012686144094133791, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-fw9xjqui/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-fw9xjqui/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.029845101831856714, + "max_seconds": 0.01526670800001284, + "median_seconds": 0.015024458999960189, + "min_seconds": 0.01481645900003059, + "output_fingerprint": "8ca889e921ac49ce9ce46b15abd02c654404185bc0e08cd34c456a778153ccdf", + "peak_python_bytes": 2130604, + "peak_rss_bytes": 917504, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.015127167000059671, + 0.01481645900003059, + 0.015024458999960189, + 0.01526670800001284, + 0.014842165999993995 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00019060245180990023, + "throughput_rows_per_second": 665581.3696870215 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": null, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-myqv3fk8/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-myqv3fk8/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": "Traceback (most recent call last):\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2401, in fillna\n new_values = self.values.fillna(\n ^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '5082.5' for dtype 'Int64'\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 137, in baseline_worker_main\n result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 94, in measure_pandas_baseline\n operation(frame)\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 31, in _numeric_median_fill\n column: frame[column].fillna(frame[column].median())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py\", line 7372, in fillna\n new_data = self._mgr.fillna(\n ^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py\", line 186, in fillna\n return self.apply_with_block(\n ^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py\", line 363, in apply\n applied = getattr(b, f)(**kwargs)\n ^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2407, in fillna\n new_values = self.values.fillna(value=value, method=None, limit=limit)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '5082.5' for dtype 'Int64'\n", + "error_type": "ChildProcessError", + "input_bytes": null, + "input_to_peak_ratio": null, + "max_seconds": null, + "median_seconds": null, + "min_seconds": null, + "output_fingerprint": null, + "peak_python_bytes": null, + "peak_rss_bytes": null, + "profile": null, + "report_fingerprint": null, + "result_type": null, + "samples_seconds": [], + "schema_version": 1, + "status": "failed", + "stdev_seconds": null, + "throughput_rows_per_second": null + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.2130661631603092, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-tmuuhh49/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-tmuuhh49/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.001598844740992324, + "max_seconds": 0.00022662500009573705, + "median_seconds": 0.0001592499999105712, + "min_seconds": 0.0001382499999635911, + "output_fingerprint": "93803f837ff5a5887b2b22d477e1c54098bef3a5d84de64006ca62af3f4b57b6", + "peak_python_bytes": 627692, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.00015541700008725456, + 0.0001610419999451551, + 0.0001382499999635911, + 0.0001592499999105712, + 0.00022662500009573705 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 3.393078646422499e-05, + "throughput_rows_per_second": 62794348.54389716 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.07512757269323476, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i35q0qkn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i35q0qkn/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.022863559922629704, + "max_seconds": 0.26930816699996285, + "median_seconds": 0.2464052499999525, + "min_seconds": 0.22273129100005917, + "output_fingerprint": "2c1a8aa93526335f73567718c764615e8d441132a5f0faac9b5302ceee688dc2", + "peak_python_bytes": 41353290, + "peak_rss_bytes": 1703936, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.22273129100005917, + 0.26930816699996285, + 0.2464052499999525, + 0.261589625000056, + 0.23843695799996567 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.018511828331366116, + "throughput_rows_per_second": 405835.50878083677 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.004496067281244758, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ayxya50_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ayxya50_/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.0006595257669989338, + "max_seconds": 0.03589462499996898, + "median_seconds": 0.03563441599999351, + "min_seconds": 0.035517459000061535, + "output_fingerprint": "aa9af747f9ff2a0d4c40eb236de6bf9ff107668a365fe6904542844ec2851603", + "peak_python_bytes": 3896699, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.035517459000061535, + 0.03589462499996898, + 0.03583420900008605, + 0.0356040409999423, + 0.03563441599999351 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0001602147318638355, + "throughput_rows_per_second": 2806275.820544336 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": null, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7w9lzkx2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7w9lzkx2/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": "Traceback (most recent call last):\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2401, in fillna\n new_values = self.values.fillna(\n ^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4989.5' for dtype 'Int64'\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 137, in baseline_worker_main\n result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 94, in measure_pandas_baseline\n operation(frame)\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 31, in _numeric_median_fill\n column: frame[column].fillna(frame[column].median())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py\", line 7372, in fillna\n new_data = self._mgr.fillna(\n ^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py\", line 186, in fillna\n return self.apply_with_block(\n ^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py\", line 363, in apply\n applied = getattr(b, f)(**kwargs)\n ^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2407, in fillna\n new_values = self.values.fillna(value=value, method=None, limit=limit)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4989.5' for dtype 'Int64'\n", + "error_type": "ChildProcessError", + "input_bytes": null, + "input_to_peak_ratio": null, + "max_seconds": null, + "median_seconds": null, + "min_seconds": null, + "output_fingerprint": null, + "peak_python_bytes": null, + "peak_rss_bytes": null, + "profile": null, + "report_fingerprint": null, + "result_type": null, + "samples_seconds": [], + "schema_version": 1, + "status": "failed", + "stdev_seconds": null, + "throughput_rows_per_second": null + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.612654320539145, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1a2bhs8o/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1a2bhs8o/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.0004396838446659559, + "max_seconds": 0.00032454100005452347, + "median_seconds": 0.00015220800003135082, + "min_seconds": 0.00013566600000558537, + "output_fingerprint": "575001f2c17305b56d84cd95a0ea7378b9b8154e1f3a9b142f0f6bdbebc38107", + "peak_python_bytes": 602918, + "peak_rss_bytes": 32768, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.00032454100005452347, + 0.00030545799995707057, + 0.00015220800003135082, + 0.00014883299991197418, + 0.00013566600000558537 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 9.32508888398294e-05, + "throughput_rows_per_second": 656995689.9729491 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.13181610994384532, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-gkg7v_u6/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-gkg7v_u6/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.00607306320565984, + "max_seconds": 0.07464766600003259, + "median_seconds": 0.06073379199995088, + "min_seconds": 0.052355249999891385, + "output_fingerprint": "c87410ddde6ca1aeea6eb2b11970d8c06bcfaa9089fa34c3e057ecd6ef289cf0", + "peak_python_bytes": 15743399, + "peak_rss_bytes": 98304, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.07464766600003259, + 0.062037082999950144, + 0.06073379199995088, + 0.052355249999891385, + 0.06065399999999954 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00800569220357216, + "throughput_rows_per_second": 1646529.826428109 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.08849146878022408, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1cpbsxvm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1cpbsxvm/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.005060886004716533, + "max_seconds": 0.00920504099997288, + "median_seconds": 0.00889962500002639, + "min_seconds": 0.007281333000037193, + "output_fingerprint": "3545c2a682bd2e02786e53c4db83abba3650c7b8da3840738badca468b3da994", + "peak_python_bytes": 1456519, + "peak_rss_bytes": 81920, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.008984208000015315, + 0.00920504099997288, + 0.00889962500002639, + 0.007281333000037193, + 0.008176083999956063 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0007875408878455371, + "throughput_rows_per_second": 11236428.501167575 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0862060231978112, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-zdipbdz9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-zdipbdz9/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.2621538950443164, + "max_seconds": 0.017110375000015665, + "median_seconds": 0.01579904200002602, + "min_seconds": 0.01367575000006127, + "output_fingerprint": "107bdb9a1f31a47e93d9a624136f7c0dcab6a0fa936ba11f14a69dfc4ecadd51", + "peak_python_bytes": 9397584, + "peak_rss_bytes": 4243456, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.014351499999975204, + 0.01367575000006127, + 0.01579904200002602, + 0.015916875000016262, + 0.017110375000015665 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0013619725811574365, + "throughput_rows_per_second": 6329497.699913407 + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.821081966841856, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jcyb2ewy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jcyb2ewy/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.00303653160282992, + "max_seconds": 0.00017762499999207648, + "median_seconds": 6.31249999969441e-05, + "min_seconds": 5.7999999967250915e-05, + "output_fingerprint": "d89cb5caa99da1fd524b345029afc07b6a27fbdba2c870f3b2cf5b6b9a8eba9a", + "peak_python_bytes": 602963, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 5.7999999967250915e-05, + 0.00017762499999207648, + 6.31249999969441e-05, + 6.974999996600673e-05, + 5.804199997783144e-05 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 5.183079915438301e-05, + "throughput_rows_per_second": 1584158415.9182737 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.06340022419317158, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-atwivd68/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-atwivd68/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.003388144716278536, + "max_seconds": 1.1264900420000004, + "median_seconds": 0.9933327080000254, + "min_seconds": 0.9797433329999876, + "output_fingerprint": "717d397e6f12c8b3f4d202befbb1220783d4390866e60656246b31ee7edf1097", + "peak_python_bytes": 143788906, + "peak_rss_bytes": 1048576, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.9828594159999966, + 0.9797433329999876, + 1.1264900420000004, + 0.9933327080000254, + 1.0525212090000196 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.06297751638561185, + "throughput_rows_per_second": 100671.20431515826 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0915844131263023, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e39yu2z0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e39yu2z0/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.01768188023807861, + "max_seconds": 0.20250654200003737, + "median_seconds": 0.17057045900003232, + "min_seconds": 0.16398645899994335, + "output_fingerprint": "63b7290183dcbb950d4a62f6d906706e149f81814868aa81695c4a63bee23d80", + "peak_python_bytes": 13650681, + "peak_rss_bytes": 5472256, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.16650895899999796, + 0.16398645899994335, + 0.17057045900003232, + 0.1793753749999496, + 0.20250654200003737 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.015621595384201969, + "throughput_rows_per_second": 586267.989112822 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": null, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-o6r_idke/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-o6r_idke/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": "Traceback (most recent call last):\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2401, in fillna\n new_values = self.values.fillna(\n ^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4989.5' for dtype 'Int64'\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 137, in baseline_worker_main\n result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 94, in measure_pandas_baseline\n operation(frame)\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 31, in _numeric_median_fill\n column: frame[column].fillna(frame[column].median())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py\", line 7372, in fillna\n new_data = self._mgr.fillna(\n ^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py\", line 186, in fillna\n return self.apply_with_block(\n ^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py\", line 363, in apply\n applied = getattr(b, f)(**kwargs)\n ^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2407, in fillna\n new_values = self.values.fillna(value=value, method=None, limit=limit)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4989.5' for dtype 'Int64'\n", + "error_type": "ChildProcessError", + "input_bytes": null, + "input_to_peak_ratio": null, + "max_seconds": null, + "median_seconds": null, + "min_seconds": null, + "output_fingerprint": null, + "peak_python_bytes": null, + "peak_rss_bytes": null, + "profile": null, + "report_fingerprint": null, + "result_type": null, + "samples_seconds": [], + "schema_version": 1, + "status": "failed", + "stdev_seconds": null, + "throughput_rows_per_second": null + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.11021253186985237, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-spnaa01k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-spnaa01k/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.0001588192835755564, + "max_seconds": 0.00023054199994021474, + "median_seconds": 0.0001909999999725187, + "min_seconds": 0.0001733750000312284, + "output_fingerprint": "69e094d9ff94ed432868dc6689efada583524c268dc18126540c022129b72bcb", + "peak_python_bytes": 627555, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.0001909999999725187, + 0.00019712499999968713, + 0.00018954200004372979, + 0.00023054199994021474, + 0.0001733750000312284 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 2.105059358411302e-05, + "throughput_rows_per_second": 523560209.4994142 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.332820939828672, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-dndszzwe/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-dndszzwe/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.00026225162107191137, + "max_seconds": 2.8559054590000414, + "median_seconds": 2.028094916999976, + "min_seconds": 1.4024539999999206, + "output_fingerprint": "0ecc5b0b8d231b513bdbea1cd8b6b1bdf36eaf0b52567385490245c2fc4a4995", + "peak_python_bytes": 209694126, + "peak_rss_bytes": 98304, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 1.4024539999999206, + 2.731014250000044, + 2.8559054590000414, + 2.028094916999976, + 1.4990002500001083 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.6749924563376845, + "throughput_rows_per_second": 246536.7847475385 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.33784017267327454, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vuurrf4s/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vuurrf4s/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.0001748344140479409, + "max_seconds": 0.3063977499999737, + "median_seconds": 0.17942195800003446, + "min_seconds": 0.16522291700005098, + "output_fingerprint": "87af0998cce75ff39bf9403c73ee0f4a63263b8e1d85895910243ba74c7814d3", + "peak_python_bytes": 16696649, + "peak_rss_bytes": 65536, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.16522291700005098, + 0.1664242499999773, + 0.17942195800003446, + 0.2337931250000338, + 0.3063977499999737 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.06061594527210866, + "throughput_rows_per_second": 2786726.91778285 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": null, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e_xkbaob/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e_xkbaob/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": "Traceback (most recent call last):\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2401, in fillna\n new_values = self.values.fillna(\n ^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4995.5' for dtype 'Int64'\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 137, in baseline_worker_main\n result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 94, in measure_pandas_baseline\n operation(frame)\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 31, in _numeric_median_fill\n column: frame[column].fillna(frame[column].median())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py\", line 7372, in fillna\n new_data = self._mgr.fillna(\n ^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py\", line 186, in fillna\n return self.apply_with_block(\n ^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py\", line 363, in apply\n applied = getattr(b, f)(**kwargs)\n ^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2407, in fillna\n new_values = self.values.fillna(value=value, method=None, limit=limit)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4995.5' for dtype 'Int64'\n", + "error_type": "ChildProcessError", + "input_bytes": null, + "input_to_peak_ratio": null, + "max_seconds": null, + "median_seconds": null, + "min_seconds": null, + "output_fingerprint": null, + "peak_python_bytes": null, + "peak_rss_bytes": null, + "profile": null, + "report_fingerprint": null, + "result_type": null, + "samples_seconds": [], + "schema_version": 1, + "status": "failed", + "stdev_seconds": null, + "throughput_rows_per_second": null + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.15191845779982574, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-pe41zuia/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-pe41zuia/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 8.741720702397046e-05, + "max_seconds": 0.00010291700004927407, + "median_seconds": 8.779200004482846e-05, + "min_seconds": 7.149999999001011e-05, + "output_fingerprint": "a5a7275f2b3ce25f64a27b67abd4ce09b2744313366538e90d56e5a96056a8c8", + "peak_python_bytes": 603008, + "peak_rss_bytes": 32768, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 9.208300002683245e-05, + 7.270799994785193e-05, + 7.149999999001011e-05, + 0.00010291700004927407, + 8.779200004482846e-05 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.3337225253972572e-05, + "throughput_rows_per_second": 5695279749.2332945 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.2586752513169728, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-th5lkqzb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-th5lkqzb/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.18865101507238713, + "max_seconds": 0.5604929579999407, + "median_seconds": 0.4379062499999691, + "min_seconds": 0.314114625000002, + "output_fingerprint": "5999f68f548b1b042cd5005c362a4928af9fcdc72fcdb2472ba200f59e2e8634", + "peak_python_bytes": 81684069, + "peak_rss_bytes": 15351808, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.4379062499999691, + 0.314114625000002, + 0.5604929579999407, + 0.5290564169999925, + 0.32489495799995893 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.1132755092720151, + "throughput_rows_per_second": 1141796.9028759815 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.010089954062314594, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2p6tyz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2p6tyz/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.00040267025629111446, + "max_seconds": 0.03497287499999402, + "median_seconds": 0.034429499999987456, + "min_seconds": 0.034121583999990435, + "output_fingerprint": "0166ddef14ac99599128167b76c9090fcd69acda3560c9c150aeadf826f1f589", + "peak_python_bytes": 4656681, + "peak_rss_bytes": 32768, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.034429499999987456, + 0.03427308400000584, + 0.03497287499999402, + 0.03474454100000912, + 0.034121583999990435 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00034739207338833374, + "throughput_rows_per_second": 14522429.892974982 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.030393234438426002, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-j31qg_8b/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-j31qg_8b/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.007449399741385618, + "max_seconds": 0.06438545800006068, + "median_seconds": 0.060625208000033126, + "min_seconds": 0.05976620900003127, + "output_fingerprint": "6e61db44eaf56dedf14423a3ce45d8fc5bbbe97b13029f1dcb2a7c3c126864f0", + "peak_python_bytes": 44597724, + "peak_rss_bytes": 606208, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.06438545800006068, + 0.060625208000033126, + 0.05976620900003127, + 0.061535208000009334, + 0.06020570900000166 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0018425961596233464, + "throughput_rows_per_second": 8247394.384192905 + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.07071988298469084, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-5n5kleje/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-5n5kleje/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.00040267025629111446, + "max_seconds": 7.970900003329007e-05, + "median_seconds": 6.983399998716777e-05, + "min_seconds": 6.758299991815875e-05, + "output_fingerprint": "3f6a1d501dd40c89788dd25d4763d02a79ecba7f99ab54e5ac21f5f25f375f28", + "peak_python_bytes": 602873, + "peak_rss_bytes": 32768, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 7.004199994753435e-05, + 6.758299991815875e-05, + 6.820900000548136e-05, + 7.970900003329007e-05, + 6.983399998716777e-05 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 4.938652307445407e-06, + "throughput_rows_per_second": 7159836184.263778 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0365780385745458, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-517rp2_i/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-517rp2_i/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 9.472202243687051e-05, + "max_seconds": 5.050082166999914, + "median_seconds": 4.743021916000089, + "min_seconds": 4.590766500000086, + "output_fingerprint": "abf767090a8d73e23928a19133988b52651a9bc7caa3d6b3211b92d5d815bdfc", + "peak_python_bytes": 721729752, + "peak_rss_bytes": 147456, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 4.590766500000086, + 4.743021916000089, + 4.767043917000024, + 4.6740089999999554, + 5.050082166999914 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.17349043860336738, + "throughput_rows_per_second": 105418.0243851082 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.037810059961326144, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-nz0pqreo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-nz0pqreo/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.0005051841196633094, + "max_seconds": 0.7183194159999857, + "median_seconds": 0.6783770420000792, + "min_seconds": 0.6552982919999977, + "output_fingerprint": "b6e45eca50ac423f2ea47441b72db04d976ad9b770fcd16a996aaad4745fcaa5", + "peak_python_bytes": 64850640, + "peak_rss_bytes": 786432, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.6702113329999975, + 0.6552982919999977, + 0.704420834000075, + 0.7183194159999857, + 0.6783770420000792 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.02564947663441006, + "throughput_rows_per_second": 737053.2447941268 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": null, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3to9120_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3to9120_/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": "Traceback (most recent call last):\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2401, in fillna\n new_values = self.values.fillna(\n ^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4995.5' for dtype 'Int64'\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 137, in baseline_worker_main\n result = measure_pandas_baseline(BenchmarkCase(**payload), baseline_name, command=command)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 94, in measure_pandas_baseline\n operation(frame)\n File \"/Users/wilson/freshdata-qa/benchmarks/performance/baselines.py\", line 31, in _numeric_median_fill\n column: frame[column].fillna(frame[column].median())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py\", line 7372, in fillna\n new_data = self._mgr.fillna(\n ^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py\", line 186, in fillna\n return self.apply_with_block(\n ^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py\", line 363, in apply\n applied = getattr(b, f)(**kwargs)\n ^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py\", line 2407, in fillna\n new_values = self.values.fillna(value=value, method=None, limit=limit)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 267, in fillna\n new_values[mask] = value\n ~~~~~~~~~~^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 315, in __setitem__\n value = self._validate_setitem_value(value)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py\", line 306, in _validate_setitem_value\n raise TypeError(f\"Invalid value '{value!s}' for dtype '{self.dtype}'\")\nTypeError: Invalid value '4995.5' for dtype 'Int64'\n", + "error_type": "ChildProcessError", + "input_bytes": null, + "input_to_peak_ratio": null, + "max_seconds": null, + "median_seconds": null, + "min_seconds": null, + "output_fingerprint": null, + "peak_python_bytes": null, + "peak_rss_bytes": null, + "profile": null, + "report_fingerprint": null, + "result_type": null, + "samples_seconds": [], + "schema_version": 1, + "status": "failed", + "stdev_seconds": null, + "throughput_rows_per_second": null + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.09697497103932032, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-akjg6pa2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-akjg6pa2/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 4.209867663860912e-05, + "max_seconds": 0.00019283300002825854, + "median_seconds": 0.00018108400001892733, + "min_seconds": 0.00015225000004193134, + "output_fingerprint": "621900c9e8eda60a10bb1cc0d178de2c21c374cc0308d6d3537329d0ea7a3212", + "peak_python_bytes": 627790, + "peak_rss_bytes": 65536, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.00019283300002825854, + 0.00015225000004193134, + 0.00018841700000393757, + 0.00018108400001892733, + 0.00016154100001131155 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.7560615657519758e-05, + "throughput_rows_per_second": 2761149521.480301 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.06356238229277841, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ogfxbv51/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ogfxbv51/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.16258388585149006, + "max_seconds": 2.840339374999985, + "median_seconds": 2.67097795899997, + "min_seconds": 2.4171610839999857, + "output_fingerprint": "73bf553ee17143400c41731fc6de66e673a874cde9862747616c2938f7996df6", + "peak_python_bytes": 427185039, + "peak_rss_bytes": 121978880, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 2.5158792090001043, + 2.4171610839999857, + 2.840339374999985, + 2.735974875000011, + 2.67097795899997 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.1697737221255411, + "throughput_rows_per_second": 374394.70312005345 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.1445327584119569, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-u0matknq/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-u0matknq/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 6.551399026923709e-05, + "max_seconds": 0.4773851669999658, + "median_seconds": 0.3702739579999843, + "min_seconds": 0.35575891700000284, + "output_fingerprint": "c663a4a281a87807dd8dd5478f8a3cd32147db438e5718e33501f8fbbfd20808", + "peak_python_bytes": 32696869, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.3560226249999232, + 0.35575891700000284, + 0.4270091250000405, + 0.3702739579999843, + 0.4773851669999658 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0535167165178508, + "throughput_rows_per_second": 2700703.0291880327 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.008088392068210505, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-8_r4t4do/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-8_r4t4do/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.0001747039740512989, + "max_seconds": 0.4338914590000513, + "median_seconds": 0.43178275000002486, + "min_seconds": 0.42544779199999994, + "output_fingerprint": "db5388049bc3ba2ccbf07ab5b3f68c0656edf210e8fcd3e4ae47724a35d4e96e", + "peak_python_bytes": 427666512, + "peak_rss_bytes": 131072, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.42544779199999994, + 0.43178275000002486, + 0.4338914590000513, + 0.43239008399996237, + 0.4278957500000615 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00349242817029032, + "throughput_rows_per_second": 2315979.505897219 + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.2026497087426276, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-wthn21sp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-wthn21sp/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 4.367599351282473e-05, + "max_seconds": 9.500000010120857e-05, + "median_seconds": 7.466600004590873e-05, + "min_seconds": 6.191700003910228e-05, + "output_fingerprint": "ed29dd716f0f735cf6ba1755d9f0cc07fbf6fbe84eaca605935d78ca9b4b83ce", + "peak_python_bytes": 602918, + "peak_rss_bytes": 32768, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 7.466600004590873e-05, + 6.65000000026339e-05, + 6.191700003910228e-05, + 9.299999999257125e-05, + 9.500000010120857e-05 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.5131043162280424e-05, + "throughput_rows_per_second": 13392976714.771723 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.07585747524870609, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sv6h_ar5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sv6h_ar5/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.00040239376644310817, + "max_seconds": 0.682246125000006, + "median_seconds": 0.592807500000049, + "min_seconds": 0.5728363339999305, + "output_fingerprint": "6cbd71f01de1253036139c7e9101128d2451ff6a9c10451481057161573f2dbe", + "peak_python_bytes": 171175974, + "peak_rss_bytes": 65536, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.5743721660001029, + 0.6040270419999842, + 0.5728363339999305, + 0.682246125000006, + 0.592807500000049 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.04496888025850105, + "throughput_rows_per_second": 1686888.2394367773 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.08279767355119892, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3t2jaloi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3t2jaloi/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.03168850910739477, + "max_seconds": 0.07066800000006879, + "median_seconds": 0.059834207999983846, + "min_seconds": 0.059553458999971554, + "output_fingerprint": "e74ab3d50d0e2c738196f13598d43e6597ee97f4ac632b7688b75958a483aeab", + "peak_python_bytes": 8656502, + "peak_rss_bytes": 5160960, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 0.07066800000006879, + 0.06560720800007402, + 0.059553458999971554, + 0.059834207999983846, + 0.05972775000009278 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0049541332211771975, + "throughput_rows_per_second": 16712847.607179325 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.09191299168138871, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-g3nkw1m6/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-g3nkw1m6/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.0003017953248323311, + "max_seconds": 0.13327591600000233, + "median_seconds": 0.12768191700001807, + "min_seconds": 0.10887100000002192, + "output_fingerprint": "754572e0b4009843fc861143b7487c2832059cace489df5de568665f4f17b93f", + "peak_python_bytes": 88597588, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.1322035829999777, + 0.13327591600000233, + 0.12768191700001807, + 0.11118099999998776, + 0.10887100000002192 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.011735626975086426, + "throughput_rows_per_second": 7831962.610647978 + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.22567008552058926, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-970pn38n/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-970pn38n/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.00020119688322155408, + "max_seconds": 8.670800002619217e-05, + "median_seconds": 6.395800005520869e-05, + "min_seconds": 5.1374999998188287e-05, + "output_fingerprint": "822c93490c683c70dcb67f7aa3f1d5f1fab19073a43dc2b076a9634617e7e221", + "peak_python_bytes": 603008, + "peak_rss_bytes": 32768, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 6.395800005520869e-05, + 8.670800002619217e-05, + 5.6165999922086485e-05, + 7.562499990854121e-05, + 5.1374999998188287e-05 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.4433407342184798e-05, + "throughput_rows_per_second": 15635260626.298473 + }, + { + "baseline_name": "duplicates", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_duplicates", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.1350899003824274, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jml6nw8z/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jml6nw8z/result.json duplicates", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.12360834459444364, + "max_seconds": 17.881217624999863, + "median_seconds": 13.899389416999838, + "min_seconds": 13.19825149999997, + "output_fingerprint": "b44319e4bd6e5d86705065ccefbf88405556be8d7d187c923cf060d619927e31", + "peak_python_bytes": 1451220807, + "peak_rss_bytes": 385138688, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 17.881217624999863, + 13.899389416999838, + 15.070519832999935, + 13.718553833999977, + 13.19825149999997 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.8776671317190738, + "throughput_rows_per_second": 71945.60638591334 + }, + { + "baseline_name": "null_counts", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_null_counts", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.007022150166560072, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-r2pbpey9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-r2pbpey9/result.json null_counts", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.013335209167120818, + "max_seconds": 1.266367333000062, + "median_seconds": 1.2639094589999331, + "min_seconds": 1.245932625000023, + "output_fingerprint": "0e6dd060c302160e288e0f6a30880fb1aeb81c923ddee7b64644307f050272ea", + "peak_python_bytes": 128850779, + "peak_rss_bytes": 41549824, + "profile": null, + "report_fingerprint": null, + "result_type": "Series", + "samples_seconds": [ + 1.2537888330000442, + 1.266367333000062, + 1.2639094589999331, + 1.245932625000023, + 1.2652294170000005 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00887536201803323, + "throughput_rows_per_second": 791195.9142953553 + }, + { + "baseline_name": "numeric_median_fill", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_numeric_median_fill", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.25829369756092935, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hxuyzbdy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hxuyzbdy/result.json numeric_median_fill", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.15829776686396102, + "max_seconds": 4.580147458000056, + "median_seconds": 2.921190208000098, + "min_seconds": 2.7593469169999025, + "output_fingerprint": "00093b61a22aea8cd50b515f0e0f09f8d5484758f81b9ee3c6749737c65fd546", + "peak_python_bytes": 1755903943, + "peak_rss_bytes": 493223936, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 4.580147458000056, + 3.173507041999983, + 2.921190208000098, + 2.7593469169999025, + 2.8580945419998898 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.7545250201031257, + "throughput_rows_per_second": 342326.21938186587 + }, + { + "baseline_name": "shallow_copy", + "case": { + "backend": "pandas-component-baseline", + "config_name": "pandas_shallow_copy", + "dataset_type": "mixed", + "options": {}, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.37475220662764014, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-xu2f98r1/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-xu2f98r1/result.json shallow_copy", + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 2.6291816181231896e-05, + "max_seconds": 0.0004027500001484441, + "median_seconds": 0.00022591699985241576, + "min_seconds": 0.00019387500015000114, + "output_fingerprint": "174b2d9a20e71cffb4a15dd8a058aa17c1e6eaf6b6e6f2bc7136a334272f2df3", + "peak_python_bytes": 627651, + "peak_rss_bytes": 81920, + "profile": null, + "report_fingerprint": null, + "result_type": "DataFrame", + "samples_seconds": [ + 0.0004027500001484441, + 0.00022591699985241576, + 0.00019387500015000114, + 0.0002629579998938425, + 0.0002074579999771231 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 8.466289420938905e-05, + "throughput_rows_per_second": 4426404390.343656 + } + ], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "hypotheses": { + "2e88248a20ec642b": { + "decisions": { + "backend_conversion_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 1.1520447887568634e-07, + "status": "insufficient_evidence" + }, + "copy_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 1.3768729590000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 2.4583e-05 + }, + { + "calls": 1, + "cumulative_seconds": 1.308761792, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.00037163100000000003 + }, + { + "calls": 128, + "cumulative_seconds": 1.3082805400000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.011201704000000002 + } + ], + "observed_calls": 101, + "stage_fraction": 0.0016137073021779168, + "status": "rejected" + }, + "dtype_conversion_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 11.888526209, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.0024269160000000003 + }, + { + "calls": 42, + "cumulative_seconds": 11.883506043, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.0015574170000000002 + }, + { + "calls": 42, + "cumulative_seconds": 10.877374458, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.001528709 + }, + { + "calls": 42, + "cumulative_seconds": 8.524509371, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 7.2784e-05 + }, + { + "calls": 42, + "cumulative_seconds": 0.933374374, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 0.00019061700000000002 + } + ], + "observed_calls": 326, + "stage_fraction": 0.025482363088487742, + "status": "rejected" + }, + "optional_ml_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 0.0, + "status": "insufficient_evidence" + }, + "repeated_null_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 0.999587125, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.001588924 + }, + { + "calls": 45, + "cumulative_seconds": 0.9305209520000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.002291698 + } + ], + "observed_calls": 1567, + "stage_fraction": 0.00035752937471387385, + "status": "rejected" + }, + "repeated_uniqueness_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 1.308761792, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.00037163100000000003 + }, + { + "calls": 128, + "cumulative_seconds": 1.3082805400000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.011201704000000002 + }, + { + "calls": 128, + "cumulative_seconds": 0.48392783300000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.00169819 + } + ], + "observed_calls": 256, + "stage_fraction": 0.0008001633610570086, + "status": "rejected" + }, + "report_finalization_overhead": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 18.443811083, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.0017712530000000002 + } + ], + "observed_calls": 1, + "stage_fraction": 0.0001472292638759755, + "status": "rejected" + }, + "unnecessary_correlation": { + "evidence": [], + "observed_calls": 1, + "stage_fraction": 0.0019485644354490558, + "status": "insufficient_evidence" + } + }, + "label": "case_id=2e88248a20ec642b rows=10000 width=wide dataset_type=mixed config=default options={\"verbose\":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5" + }, + "52f1c76054406372": { + "decisions": { + "backend_conversion_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 7.55818167954529e-08, + "status": "insufficient_evidence" + }, + "copy_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 2.581877416, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.8458000000000002e-05 + }, + { + "calls": 1, + "cumulative_seconds": 2.5188029170000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0015725420000000001 + }, + { + "calls": 8, + "cumulative_seconds": 2.5172146250000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.018499083 + } + ], + "observed_calls": 17, + "stage_fraction": 0.0004761560895780321, + "status": "rejected" + }, + "dtype_conversion_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 4.664807167, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.004510709 + }, + { + "calls": 2, + "cumulative_seconds": 4.659690542, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.005136291 + }, + { + "calls": 2, + "cumulative_seconds": 3.871873792, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 1.9582e-05 + }, + { + "calls": 2, + "cumulative_seconds": 0.577625041, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.00010362400000000001 + }, + { + "calls": 2, + "cumulative_seconds": 0.423110083, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 2.0458e-05 + } + ], + "observed_calls": 18, + "stage_fraction": 0.01352245820459485, + "status": "rejected" + }, + "optional_ml_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 0.0, + "status": "insufficient_evidence" + }, + "repeated_null_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 0.258406375, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.000275083 + }, + { + "calls": 5, + "cumulative_seconds": 0.19623300100000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.002901416 + } + ], + "observed_calls": 47, + "stage_fraction": 0.0002047114890909968, + "status": "rejected" + }, + "repeated_uniqueness_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 2.5188029170000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0015725420000000001 + }, + { + "calls": 8, + "cumulative_seconds": 2.5172146250000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.018499083 + }, + { + "calls": 8, + "cumulative_seconds": 1.3884667080000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000161623 + }, + { + "calls": 8, + "cumulative_seconds": 0.484397291, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 3.2957e-05 + } + ], + "observed_calls": 16, + "stage_fraction": 0.0008052287225391212, + "status": "rejected" + }, + "report_finalization_overhead": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 31.422031416000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.008333542000000001 + } + ], + "observed_calls": 1, + "stage_fraction": 0.00033800325313794845, + "status": "rejected" + }, + "unnecessary_correlation": { + "evidence": [], + "observed_calls": 1, + "stage_fraction": 0.0012810108491996108, + "status": "insufficient_evidence" + } + }, + "label": "case_id=52f1c76054406372 rows=1000000 width=narrow dataset_type=mixed config=default options={\"verbose\":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5" + }, + "9ea9cb03dfc114c5": { + "decisions": { + "backend_conversion_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 9.084687987422194e-08, + "status": "insufficient_evidence" + }, + "copy_pressure": { + "evidence": [ + { + "calls": 2, + "cumulative_seconds": 1.9195117920000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.000636707 + }, + { + "calls": 64, + "cumulative_seconds": 1.9188081670000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.008543853 + }, + { + "calls": 1, + "cumulative_seconds": 0.9941378750000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 2.1084e-05 + } + ], + "observed_calls": 61, + "stage_fraction": 0.0006409944170694993, + "status": "rejected" + }, + "dtype_conversion_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 4.841690791, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.002720586 + }, + { + "calls": 10, + "cumulative_seconds": 4.837934914, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.002535915 + }, + { + "calls": 10, + "cumulative_seconds": 2.7092296680000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.00041245800000000004 + }, + { + "calls": 10, + "cumulative_seconds": 2.0969137520000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 3.0377e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.0223464150000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 5.971e-05 + } + ], + "observed_calls": 108, + "stage_fraction": 0.011939176035279178, + "status": "rejected" + }, + "optional_ml_overhead": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 6.300034834000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/apply.py", + "function": "run_semantic", + "line": 192, + "self_seconds": 7.050200000000001e-05 + } + ], + "observed_calls": 1, + "stage_fraction": 0.13104697297973694, + "status": "candidate" + }, + "repeated_null_scans": { + "evidence": [], + "observed_calls": 330, + "stage_fraction": 0.00012192450731663478, + "status": "insufficient_evidence" + }, + "repeated_uniqueness_scans": { + "evidence": [ + { + "calls": 2, + "cumulative_seconds": 1.9195117920000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.000636707 + }, + { + "calls": 64, + "cumulative_seconds": 1.9188081670000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.008543853 + }, + { + "calls": 64, + "cumulative_seconds": 0.9219006670000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000992616 + }, + { + "calls": 64, + "cumulative_seconds": 0.28631674500000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 0.000175285 + } + ], + "observed_calls": 139, + "stage_fraction": 0.000604484100787168, + "status": "rejected" + }, + "report_finalization_overhead": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 22.015759208000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.001232128 + } + ], + "observed_calls": 1, + "stage_fraction": 7.311288757117476e-05, + "status": "rejected" + }, + "unnecessary_correlation": { + "evidence": [], + "observed_calls": 1, + "stage_fraction": 0.0012821504961617347, + "status": "insufficient_evidence" + } + }, + "label": "case_id=9ea9cb03dfc114c5 rows=100000 width=medium dataset_type=mixed config=semantic options={\"semantic_mode\":\"assist\",\"verbose\":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5" + }, + "a877f296485e3003": { + "decisions": { + "backend_conversion_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 1.6492473648632034e-07, + "status": "insufficient_evidence" + }, + "copy_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 1.029299875, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.7916000000000003e-05 + }, + { + "calls": 1, + "cumulative_seconds": 0.9873299170000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.00029224400000000004 + }, + { + "calls": 32, + "cumulative_seconds": 0.987001839, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.006624975000000001 + } + ], + "observed_calls": 41, + "stage_fraction": 0.00047627319268917786, + "status": "rejected" + }, + "dtype_conversion_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 4.873163041000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.003231334 + }, + { + "calls": 10, + "cumulative_seconds": 4.868864123000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.0031959090000000002 + }, + { + "calls": 10, + "cumulative_seconds": 2.709190708, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.000393706 + }, + { + "calls": 10, + "cumulative_seconds": 2.096985043, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 3.2458e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.053126042, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 6.0085000000000005e-05 + } + ], + "observed_calls": 73, + "stage_fraction": 0.017891346420442676, + "status": "rejected" + }, + "optional_ml_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 0.0, + "status": "insufficient_evidence" + }, + "repeated_null_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 0.188849125, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.000502995 + }, + { + "calls": 13, + "cumulative_seconds": 0.14569658300000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.0015346300000000002 + } + ], + "observed_calls": 227, + "stage_fraction": 0.0001929970089548085, + "status": "rejected" + }, + "repeated_uniqueness_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 0.9873299170000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.00029224400000000004 + }, + { + "calls": 32, + "cumulative_seconds": 0.987001839, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.006624975000000001 + }, + { + "calls": 32, + "cumulative_seconds": 0.47562941400000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.00051553 + }, + { + "calls": 32, + "cumulative_seconds": 0.14638804, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 9.628900000000001e-05 + } + ], + "observed_calls": 64, + "stage_fraction": 0.0006257108448964613, + "status": "rejected" + }, + "report_finalization_overhead": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 15.65455575, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.002155752 + } + ], + "observed_calls": 1, + "stage_fraction": 0.0001617365535381245, + "status": "rejected" + }, + "unnecessary_correlation": { + "evidence": [], + "observed_calls": 1, + "stage_fraction": 0.0017948286398277971, + "status": "insufficient_evidence" + } + }, + "label": "case_id=a877f296485e3003 rows=100000 width=medium dataset_type=mixed config=aggressive options={\"strategy\":\"aggressive\",\"verbose\":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5" + }, + "c4cf49ffc913ad42": { + "decisions": { + "backend_conversion_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 4.732416486004289e-08, + "status": "insufficient_evidence" + }, + "copy_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 4.703654292, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.8916e-05 + }, + { + "calls": 1, + "cumulative_seconds": 4.5299393750000005, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0030278740000000003 + }, + { + "calls": 32, + "cumulative_seconds": 4.526873751, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.023565909000000003 + } + ], + "observed_calls": 31, + "stage_fraction": 0.00039725603111632807, + "status": "rejected" + }, + "dtype_conversion_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 13.255702167, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.012875084 + }, + { + "calls": 10, + "cumulative_seconds": 13.241731042000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.011268752 + }, + { + "calls": 10, + "cumulative_seconds": 9.978590542000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 8.249900000000001e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.7705007910000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.000450373 + }, + { + "calls": 10, + "cumulative_seconds": 2.096425625, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 4.2249e-05 + } + ], + "observed_calls": 78, + "stage_fraction": 0.020418207504606007, + "status": "rejected" + }, + "optional_ml_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 0.0, + "status": "insufficient_evidence" + }, + "repeated_null_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 0.494854917, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.0005906230000000001 + } + ], + "observed_calls": 222, + "stage_fraction": 0.000111383585899618, + "status": "rejected" + }, + "repeated_uniqueness_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 4.5299393750000005, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0030278740000000003 + }, + { + "calls": 32, + "cumulative_seconds": 4.526873751, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.023565909000000003 + }, + { + "calls": 32, + "cumulative_seconds": 2.712853918, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000633964 + }, + { + "calls": 32, + "cumulative_seconds": 0.671840666, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 0.000139624 + } + ], + "observed_calls": 64, + "stage_fraction": 0.0007386737651040997, + "status": "rejected" + }, + "report_finalization_overhead": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 49.31862554200001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.002237212 + } + ], + "observed_calls": 1, + "stage_fraction": 0.00014627327575270513, + "status": "rejected" + }, + "unnecessary_correlation": { + "evidence": [], + "observed_calls": 1, + "stage_fraction": 0.002842356982202819, + "status": "insufficient_evidence" + } + }, + "label": "case_id=c4cf49ffc913ad42 rows=500000 width=medium dataset_type=mixed config=default options={\"verbose\":false} report=false backend=pandas output=pandas seed=42 warmups=1 repetitions=5" + }, + "eb41d9a6034039f8": { + "decisions": { + "backend_conversion_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 1.6911516848059833e-07, + "status": "insufficient_evidence" + }, + "copy_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 1.0707703750000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.7666e-05 + }, + { + "calls": 1, + "cumulative_seconds": 1.028715958, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0008081200000000001 + }, + { + "calls": 32, + "cumulative_seconds": 1.0278724160000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.0048046270000000006 + } + ], + "observed_calls": 31, + "stage_fraction": 0.0005231116371775818, + "status": "rejected" + }, + "dtype_conversion_pressure": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 4.828396791, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.0025325 + }, + { + "calls": 10, + "cumulative_seconds": 4.824715293000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.0034783390000000004 + }, + { + "calls": 10, + "cumulative_seconds": 2.699901707, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.00039857900000000003 + }, + { + "calls": 10, + "cumulative_seconds": 2.090339374, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 3.3126e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.016756622, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 6.0038000000000004e-05 + } + ], + "observed_calls": 78, + "stage_fraction": 0.01642253711247382, + "status": "rejected" + }, + "optional_ml_overhead": { + "evidence": [], + "observed_calls": 0, + "stage_fraction": 0.0, + "status": "insufficient_evidence" + }, + "repeated_null_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 0.18687779100000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.000509831 + }, + { + "calls": 13, + "cumulative_seconds": 0.14357012700000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.0007045850000000001 + } + ], + "observed_calls": 222, + "stage_fraction": 0.0001330654621450308, + "status": "rejected" + }, + "repeated_uniqueness_scans": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 1.028715958, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0008081200000000001 + }, + { + "calls": 32, + "cumulative_seconds": 1.0278724160000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.0048046270000000006 + }, + { + "calls": 32, + "cumulative_seconds": 0.521228871, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000522992 + }, + { + "calls": 32, + "cumulative_seconds": 0.143798998, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 9.5123e-05 + } + ], + "observed_calls": 64, + "stage_fraction": 0.0005075874019812694, + "status": "rejected" + }, + "report_finalization_overhead": { + "evidence": [ + { + "calls": 1, + "cumulative_seconds": 16.005701208, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.0012433720000000002 + } + ], + "observed_calls": 1, + "stage_fraction": 0.00010028979298514207, + "status": "rejected" + }, + "unnecessary_correlation": { + "evidence": [], + "observed_calls": 1, + "stage_fraction": 0.0017475776760885891, + "status": "insufficient_evidence" + } + }, + "label": "case_id=eb41d9a6034039f8 rows=100000 width=medium dataset_type=mixed config=default options={\"verbose\":false} report=true backend=pandas output=pandas seed=42 warmups=1 repetitions=5" + } + }, + "limitations": [ + "Component baselines cover only their named pandas operation; no full balanced FreshData pipeline equivalence is claimed.", + "Timing classifications require both a 10% effect and twice the larger observed coefficient of variation." + ], + "reproduction_commands": [ + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1a2bhs8o/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1a2bhs8o/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1cpbsxvm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-1cpbsxvm/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-2yve61ar/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-2yve61ar/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3t2jaloi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3t2jaloi/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3to9120_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-3to9120_/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-517rp2_i/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-517rp2_i/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-5n5kleje/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-5n5kleje/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7fgowvwz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7fgowvwz/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7w9lzkx2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-7w9lzkx2/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-8_r4t4do/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-8_r4t4do/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-970pn38n/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-970pn38n/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-akjg6pa2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-akjg6pa2/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-atwivd68/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-atwivd68/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ayxya50_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ayxya50_/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-dndszzwe/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-dndszzwe/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e39yu2z0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e39yu2z0/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e_xkbaob/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-e_xkbaob/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-fw9xjqui/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-fw9xjqui/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-g3nkw1m6/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-g3nkw1m6/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-gkg7v_u6/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-gkg7v_u6/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hqxwyk63/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hqxwyk63/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hxuyzbdy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hxuyzbdy/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hyt47z_w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-hyt47z_w/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i35q0qkn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i35q0qkn/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i66bg7ug/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-i66bg7ug/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-j31qg_8b/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-j31qg_8b/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jcyb2ewy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jcyb2ewy/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jml6nw8z/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-jml6nw8z/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-kqx67jyy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-kqx67jyy/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-myqv3fk8/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-myqv3fk8/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-nz0pqreo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-nz0pqreo/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-o6r_idke/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-o6r_idke/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ogfxbv51/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ogfxbv51/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-pe41zuia/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-pe41zuia/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-r2pbpey9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-r2pbpey9/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2p6tyz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2p6tyz/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2qezvs/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sm2qezvs/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-spnaa01k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-spnaa01k/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sv6h_ar5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-sv6h_ar5/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-th5lkqzb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-th5lkqzb/result.json duplicates", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-tmuuhh49/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-tmuuhh49/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-u0matknq/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-u0matknq/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vusdqa6w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vusdqa6w/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vuurrf4s/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-vuurrf4s/result.json null_counts", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-wthn21sp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-wthn21sp/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-xu2f98r1/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-xu2f98r1/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ytg1ke0e/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-ytg1ke0e/result.json shallow_copy", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.baselines import baseline_worker_main; baseline_worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3], __import__('\"'\"'sys'\"'\"').argv[4])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-zdipbdz9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-pandas-baseline-zdipbdz9/result.json numeric_median_fill", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0_oplliu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0_oplliu/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0o7maroj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0o7maroj/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0wcjge2n/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0wcjge2n/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0y608fx9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0y608fx9/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-2t3k0qat/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-2t3k0qat/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-35wc2941/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-35wc2941/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3uzf4yau/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3uzf4yau/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3wt9l572/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3wt9l572/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-45k6rlhy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-45k6rlhy/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-48bqvd6_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-48bqvd6_/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-505l5i2k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-505l5i2k/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5b5z35kz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5b5z35kz/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5z51_7m7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5z51_7m7/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6f1913hf/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6f1913hf/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6h0tex80/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6h0tex80/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6m37255r/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6m37255r/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6va8ihwu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6va8ihwu/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6vsbnir1/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6vsbnir1/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6x8nokur/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6x8nokur/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-73qnu4tr/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-73qnu4tr/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7a2ovh8q/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7a2ovh8q/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7ijnb2t2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7ijnb2t2/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7kbxkur4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7kbxkur4/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7t8hq6r0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7t8hq6r0/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7vsj5k8x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7vsj5k8x/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7wohf2mk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7wohf2mk/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-8z80spay/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-8z80spay/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-94i3izmm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-94i3izmm/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9eov5p_h/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9eov5p_h/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nhcsu3f/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nhcsu3f/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nq36ybo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nq36ybo/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_2qwkrp5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_2qwkrp5/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_62x0b18/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_62x0b18/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_l79249g/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_l79249g/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_w7r0q85/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_w7r0q85/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-a77oq7oj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-a77oq7oj/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-acfhxjob/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-acfhxjob/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bfpv5cj2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bfpv5cj2/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bguwaenp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bguwaenp/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bhzt0s5x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bhzt0s5x/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bk_t2v0m/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bk_t2v0m/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bkaat7mk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bkaat7mk/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-blvv_jiv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-blvv_jiv/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bn1sfum9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bn1sfum9/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bvxcn7xl/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bvxcn7xl/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cpv66lch/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cpv66lch/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cyfb1k82/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cyfb1k82/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-d7saj_vi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-d7saj_vi/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-df48de9a/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-df48de9a/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-do203r6b/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-do203r6b/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-dq31_bs5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-dq31_bs5/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eazaesl3/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eazaesl3/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ed961_m8/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ed961_m8/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eudiegfa/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eudiegfa/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f264f2_9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f264f2_9/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f2ooeoz0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f2ooeoz0/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fj5psnoh/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fj5psnoh/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fro3mtal/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fro3mtal/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fxn1gzrg/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fxn1gzrg/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g4j166wv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g4j166wv/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g9qfvced/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g9qfvced/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g_nftmdn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g_nftmdn/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gc406ib9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gc406ib9/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gxeu66kc/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gxeu66kc/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gz_af_1p/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gz_af_1p/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h0g7u45k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h0g7u45k/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h_rnavez/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h_rnavez/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-hlfudhnw/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-hlfudhnw/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i04nrmrp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i04nrmrp/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i83j742j/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i83j742j/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i8zs7mdh/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i8zs7mdh/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-izm1t_jk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-izm1t_jk/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-j_rz02un/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-j_rz02un/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jaqic_qn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jaqic_qn/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jsn72n1l/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jsn72n1l/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ksnjrpyp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ksnjrpyp/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-kyndmnei/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-kyndmnei/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-l8w0yh4p/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-l8w0yh4p/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lq544524/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lq544524/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lx898arq/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lx898arq/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m0sb5i34/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m0sb5i34/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m305bi9o/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m305bi9o/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mamv5ri_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mamv5ri_/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mk0c_vdo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mk0c_vdo/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mov5obdy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mov5obdy/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ng_asva7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ng_asva7/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-nsu1dvvk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-nsu1dvvk/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o26qohu4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o26qohu4/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o7uyipn7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o7uyipn7/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-obnnpt74/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-obnnpt74/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-oc0p3e55/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-oc0p3e55/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofl_se46/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofl_se46/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofttul9h/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofttul9h/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-olcq_0u3/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-olcq_0u3/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-p3db69s_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-p3db69s_/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-pergwrsg/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-pergwrsg/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q5jo5ykm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q5jo5ykm/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q6_eotbv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q6_eotbv/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qldc62vn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qldc62vn/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qpv00l7x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qpv00l7x/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-quma73mv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-quma73mv/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qwq4ttn2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qwq4ttn2/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r1t8ppnu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r1t8ppnu/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r75lh8th/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r75lh8th/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-rqpltcr2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-rqpltcr2/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ru43bw23/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ru43bw23/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s12d6qgk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s12d6qgk/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s4rpqe6x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s4rpqe6x/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-se9sgn4u/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-se9sgn4u/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-t9v9c099/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-t9v9c099/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-tw8lly9j/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-tw8lly9j/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-u32hxje4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-u32hxje4/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uby8hrir/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uby8hrir/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uv5wrp3w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uv5wrp3w/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-vrmo8_xr/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-vrmo8_xr/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w5oxtzfm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w5oxtzfm/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w61z76il/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w61z76il/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wbkq_rwi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wbkq_rwi/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-woqbb2i9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-woqbb2i9/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wvyexwm2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wvyexwm2/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wyy78nbb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wyy78nbb/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xhlz9fkb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xhlz9fkb/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xt8z79vb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xt8z79vb/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y1kajzsz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y1kajzsz/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y7aivnpb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y7aivnpb/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y9l2tty4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y9l2tty4/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-yybzjsbu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-yybzjsbu/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z32pfetj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z32pfetj/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z7x9dr_r/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z7x9dr_r/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zqojqylx/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zqojqylx/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zsncy0_k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zsncy0_k/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zxw4_spm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zxw4_spm/result.json", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 10000 --widths wide --configs default --report-modes true --output benchmarks/results/performance/baseline", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs aggressive --report-modes true --output benchmarks/results/performance/baseline", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs default --report-modes true --output benchmarks/results/performance/baseline", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs semantic --report-modes true --output benchmarks/results/performance/baseline", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 1000000 --widths narrow --configs default --report-modes true --output benchmarks/results/performance/baseline", + "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 500000 --widths medium --configs default --report-modes false --output benchmarks/results/performance/baseline" + ], + "results": [ + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.0009635397713053978, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mamv5ri_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mamv5ri_/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 1.686273116747926, + "max_seconds": 0.3067769170011161, + "median_seconds": 0.30618637499719625, + "min_seconds": 0.3059989159992256, + "output_fingerprint": "a0f6cdf92bc2ecb84b46804b8a4bacd5f20f7dd0c7292a497e141536d50bf427", + "peak_python_bytes": 10583281, + "peak_rss_bytes": 12484608, + "profile": null, + "report_fingerprint": "8eb9617a6473f64d788b243cbe9e809ca1937dccf89237e5d32d11bb3176bbe9", + "result_type": "CleanResult", + "samples_seconds": [ + 0.30618637499719625, + 0.30618487500032643, + 0.3059989159992256, + 0.3063624999995227, + 0.3067769170011161 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00029502274974162727, + "throughput_rows_per_second": 32659.84647452575 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.001032098517962162, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gxeu66kc/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gxeu66kc/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 2.4608080128919863, + "max_seconds": 0.3014592500003346, + "median_seconds": 0.30122929099889006, + "min_seconds": 0.30075399999986985, + "output_fingerprint": "a0f6cdf92bc2ecb84b46804b8a4bacd5f20f7dd0c7292a497e141536d50bf427", + "peak_python_bytes": 10582726, + "peak_rss_bytes": 18219008, + "profile": null, + "report_fingerprint": "8eb9617a6473f64d788b243cbe9e809ca1937dccf89237e5d32d11bb3176bbe9", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.30122929099889006, + 0.3014592500003346, + 0.30075399999986985, + 0.30125341700113495, + 0.30078750000029686 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00031089830480674727, + "throughput_rows_per_second": 33197.302848071464 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.004191775084646684, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bk_t2v0m/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bk_t2v0m/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.8099422056820746, + "max_seconds": 0.4316409160019248, + "median_seconds": 0.4280856250006764, + "min_seconds": 0.42761412500112783, + "output_fingerprint": "c34c64734011dfceb2e926827e9f5dc8c8e26df427404a351389c7ff6244e457", + "peak_python_bytes": 10582786, + "peak_rss_bytes": 5996544, + "profile": null, + "report_fingerprint": "88964b561fd7fb8d553b081ff02acf10ae4dec8e15a2dedd15cefbbbe7b05c4e", + "result_type": "CleanResult", + "samples_seconds": [ + 0.4280739999994694, + 0.42761412500112783, + 0.4280856250006764, + 0.4316409160019248, + 0.4305774159984139 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0017944386569732386, + "throughput_rows_per_second": 23359.812654265603 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.004127162919924458, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lq544524/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lq544524/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 1.0400897176791668, + "max_seconds": 0.4302953750011511, + "median_seconds": 0.4266494170005899, + "min_seconds": 0.42594499999904656, + "output_fingerprint": "c34c64734011dfceb2e926827e9f5dc8c8e26df427404a351389c7ff6244e457", + "peak_python_bytes": 10583751, + "peak_rss_bytes": 7700480, + "profile": null, + "report_fingerprint": "88964b561fd7fb8d553b081ff02acf10ae4dec8e15a2dedd15cefbbbe7b05c4e", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.42672516600214294, + 0.4263528750016121, + 0.4266494170005899, + 0.4302953750011511, + 0.42594499999904656 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0017608516536522223, + "throughput_rows_per_second": 23438.447590767886 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.02049749597457202, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7a2ovh8q/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7a2ovh8q/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.3651378796107714, + "max_seconds": 0.34178774999963935, + "median_seconds": 0.3307767500009504, + "min_seconds": 0.3280607910019171, + "output_fingerprint": "eb00757609b724cd902b52e3488dd904a65c1677a1990f6b129fd3aa76223e41", + "peak_python_bytes": 10583178, + "peak_rss_bytes": 2703360, + "profile": null, + "report_fingerprint": "f90f8b77ea207e2682d9053a054d44b0207c6d2c52ca166ba16008461df933d7", + "result_type": "CleanResult", + "samples_seconds": [ + 0.32878666699980386, + 0.3280607910019171, + 0.3307767500009504, + 0.3411021249994519, + 0.34178774999963935 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.006780095101626497, + "throughput_rows_per_second": 30231.870891685307 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.02277087655548165, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jaqic_qn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jaqic_qn/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.8077292488359488, + "max_seconds": 0.34799216600004, + "median_seconds": 0.3330876670006546, + "min_seconds": 0.33075466599984793, + "output_fingerprint": "eb00757609b724cd902b52e3488dd904a65c1677a1990f6b129fd3aa76223e41", + "peak_python_bytes": 10584681, + "peak_rss_bytes": 5980160, + "profile": null, + "report_fingerprint": "f90f8b77ea207e2682d9053a054d44b0207c6d2c52ca166ba16008461df933d7", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.33075466599984793, + 0.3330876670006546, + 0.34799216600004, + 0.33093470799940405, + 0.34128525000051013 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.007584698147425285, + "throughput_rows_per_second": 30022.12627698505 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.12374469744905636, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofl_se46/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofl_se46/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.0508980074608954, + "max_seconds": 0.05776033300207928, + "median_seconds": 0.04636150000078487, + "min_seconds": 0.04441387499900884, + "output_fingerprint": "ddd1c217f341ed560aedc99b8a50235c581321a6678bd28e899762f3c97317d9", + "peak_python_bytes": 1106840, + "peak_rss_bytes": 376832, + "profile": null, + "report_fingerprint": "4b0b65cdb5b7740823ccf095ac8e2b63f9875c07071527d6ebb55ef978833473", + "result_type": "CleanResult", + "samples_seconds": [ + 0.045437791999574983, + 0.04441387499900884, + 0.04636150000078487, + 0.05776033300207928, + 0.0528597090014955 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00573698979088155, + "throughput_rows_per_second": 215696.21344932122 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.020716852798775855, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-quma73mv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-quma73mv/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.05311096430702129, + "max_seconds": 0.04657920799945714, + "median_seconds": 0.04524937499809312, + "min_seconds": 0.044188792002387345, + "output_fingerprint": "ddd1c217f341ed560aedc99b8a50235c581321a6678bd28e899762f3c97317d9", + "peak_python_bytes": 1106703, + "peak_rss_bytes": 393216, + "profile": null, + "report_fingerprint": "4b0b65cdb5b7740823ccf095ac8e2b63f9875c07071527d6ebb55ef978833473", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.04657920799945714, + 0.04525279199879151, + 0.044188792002387345, + 0.04442287499841768, + 0.04524937499809312 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0009374246410721036, + "throughput_rows_per_second": 220997.52759947328 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.026847738983821156, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mk0c_vdo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mk0c_vdo/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 0.33194352691888307, + "max_seconds": 0.3277699169993866, + "median_seconds": 0.31140620799851604, + "min_seconds": 0.3073215000003984, + "output_fingerprint": "a0f6cdf92bc2ecb84b46804b8a4bacd5f20f7dd0c7292a497e141536d50bf427", + "peak_python_bytes": 10582981, + "peak_rss_bytes": 2457600, + "profile": null, + "report_fingerprint": "8eb9617a6473f64d788b243cbe9e809ca1937dccf89237e5d32d11bb3176bbe9", + "result_type": "CleanResult", + "samples_seconds": [ + 0.3073215000003984, + 0.31140620799851604, + 0.3277699169993866, + 0.3122022499992454, + 0.307851749999827 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.008360552590285678, + "throughput_rows_per_second": 32112.39770803687 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.0065815058559978495, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wvyexwm2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wvyexwm2/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 7403669, + "input_to_peak_ratio": 1.7725784337468355, + "max_seconds": 0.3067362499969022, + "median_seconds": 0.3049633750015346, + "min_seconds": 0.30152375000034226, + "output_fingerprint": "a0f6cdf92bc2ecb84b46804b8a4bacd5f20f7dd0c7292a497e141536d50bf427", + "peak_python_bytes": 10583181, + "peak_rss_bytes": 13123584, + "profile": null, + "report_fingerprint": "8eb9617a6473f64d788b243cbe9e809ca1937dccf89237e5d32d11bb3176bbe9", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.30152375000034226, + 0.3049633750015346, + 0.3067362499969022, + 0.30605445800028974, + 0.3046182910002244 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.002007118238437468, + "throughput_rows_per_second": 32790.82283224889 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0038436604055101823, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-45k6rlhy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-45k6rlhy/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 2.3419722479967833, + "max_seconds": 0.07113658299931558, + "median_seconds": 0.07108520799738471, + "min_seconds": 0.07060166700102855, + "output_fingerprint": "687faf97bb6aa868aaaad04a992658d3f3606638b97b461cb4473b6d992f7024", + "peak_python_bytes": 3593122, + "peak_rss_bytes": 3768320, + "profile": null, + "report_fingerprint": "b53d9d0058700ac439a5aba82889f1847b28f07d23152cb5860ba9e13b9a44cf", + "result_type": "CleanResult", + "samples_seconds": [ + 0.07063729199944646, + 0.07112779199815122, + 0.07108520799738471, + 0.07113658299931558, + 0.07060166700102855 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0002732273993970034, + "throughput_rows_per_second": 140676.2430851705 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.004629384698391226, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h_rnavez/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h_rnavez/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 1.6495630616325168, + "max_seconds": 0.07172583300052793, + "median_seconds": 0.07135916699917288, + "min_seconds": 0.07093974999952479, + "output_fingerprint": "687faf97bb6aa868aaaad04a992658d3f3606638b97b461cb4473b6d992f7024", + "peak_python_bytes": 3593269, + "peak_rss_bytes": 2654208, + "profile": null, + "report_fingerprint": "b53d9d0058700ac439a5aba82889f1847b28f07d23152cb5860ba9e13b9a44cf", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.07172583300052793, + 0.07144704199890839, + 0.07098266600223724, + 0.07135916699917288, + 0.07093974999952479 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0003303490357959151, + "throughput_rows_per_second": 140136.16498796726 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0024055466378965474, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-nsu1dvvk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-nsu1dvvk/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 2.932556554013363, + "max_seconds": 0.10283658399930573, + "median_seconds": 0.10231258400017396, + "min_seconds": 0.10226737500124727, + "output_fingerprint": "2f943a744c489e318e7aa085ab5dc6a75b69ffc1367b4eb8e2e17e145797eaca", + "peak_python_bytes": 3593276, + "peak_rss_bytes": 4718592, + "profile": null, + "report_fingerprint": "c4b20cc455d0a2195c1efdbf6fd5b58c654cee7da4db183a48493bd3c6d2e06f", + "result_type": "CleanResult", + "samples_seconds": [ + 0.10283658399930573, + 0.10226741699807462, + 0.10231258400017396, + 0.1025363330008986, + 0.10226737500124727 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0002461176924561265, + "throughput_rows_per_second": 97739.68762222835 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.007459426619520643, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7wohf2mk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7wohf2mk/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 1.8023003821540462, + "max_seconds": 0.10319674999846029, + "median_seconds": 0.10235345799810602, + "min_seconds": 0.1014439160026086, + "output_fingerprint": "2f943a744c489e318e7aa085ab5dc6a75b69ffc1367b4eb8e2e17e145797eaca", + "peak_python_bytes": 3593221, + "peak_rss_bytes": 2899968, + "profile": null, + "report_fingerprint": "c4b20cc455d0a2195c1efdbf6fd5b58c654cee7da4db183a48493bd3c6d2e06f", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.10319674999846029, + 0.10261624999839114, + 0.10235345799810602, + 0.1014439160026086, + 0.1014447920024395 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0007634981091910601, + "throughput_rows_per_second": 97700.65609493176 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.013011268807240737, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q6_eotbv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q6_eotbv/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 1.0080663154420937, + "max_seconds": 0.07886875000258442, + "median_seconds": 0.07714337499783142, + "min_seconds": 0.07654558300055214, + "output_fingerprint": "ca4a7a20229ed1482cf8b3755acb4a686082df293ac30582222a53503ebd78d5", + "peak_python_bytes": 3593116, + "peak_rss_bytes": 1622016, + "profile": null, + "report_fingerprint": "8178975f9f0511518b92606ed62e6f67e73675a118c62dd6da0f798fae93a55d", + "result_type": "CleanResult", + "samples_seconds": [ + 0.07886875000258442, + 0.07835170799808111, + 0.07714337499783142, + 0.07686154199836892, + 0.07654558300055214 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.001003733188794559, + "throughput_rows_per_second": 129628.7594402126 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0013334943510799958, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bn1sfum9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bn1sfum9/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 2.88164411383952, + "max_seconds": 0.077195624999149, + "median_seconds": 0.0770577500006766, + "min_seconds": 0.07694637500026147, + "output_fingerprint": "ca4a7a20229ed1482cf8b3755acb4a686082df293ac30582222a53503ebd78d5", + "peak_python_bytes": 3593656, + "peak_rss_bytes": 4636672, + "profile": null, + "report_fingerprint": "8178975f9f0511518b92606ed62e6f67e73675a118c62dd6da0f798fae93a55d", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.07694879199698335, + 0.077195624999149, + 0.07706562500243308, + 0.07694637500026147, + 0.0770577500006766 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00010275607433283679, + "throughput_rows_per_second": 129772.80026878795 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.01392767292388913, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s12d6qgk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s12d6qgk/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 0.13237234445199209, + "max_seconds": 0.00969908399929409, + "median_seconds": 0.00952362499810988, + "min_seconds": 0.00938391700037755, + "output_fingerprint": "2fed66746680e84ac879c30fd08563829a1517230b535aded771b02da2e7cd9a", + "peak_python_bytes": 769142, + "peak_rss_bytes": 212992, + "profile": null, + "report_fingerprint": "a2e6e1719edb27c57ee39e44a5bb1d15e11cc008cdea4e85d92a2e733ad0f2ba", + "result_type": "CleanResult", + "samples_seconds": [ + 0.00969908399929409, + 0.009458625001570908, + 0.00938391700037755, + 0.009657999999035383, + 0.00952362499810988 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00013264193402344866, + "throughput_rows_per_second": 1050020.3443525615 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.010899399256429224, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-j_rz02un/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-j_rz02un/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 0.11200736838245484, + "max_seconds": 0.009891042001981987, + "median_seconds": 0.009726416999910725, + "min_seconds": 0.009637208000640385, + "output_fingerprint": "2fed66746680e84ac879c30fd08563829a1517230b535aded771b02da2e7cd9a", + "peak_python_bytes": 769187, + "peak_rss_bytes": 180224, + "profile": null, + "report_fingerprint": "a2e6e1719edb27c57ee39e44a5bb1d15e11cc008cdea4e85d92a2e733ad0f2ba", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.009891042001981987, + 0.009726416999910725, + 0.009649874999013264, + 0.009797165999771096, + 0.009637208000640385 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00010601210221654752, + "throughput_rows_per_second": 1028127.8296099978 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0031589046457805134, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f264f2_9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f264f2_9/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 1.9550377026755754, + "max_seconds": 0.07174612499875366, + "median_seconds": 0.07143666699994355, + "min_seconds": 0.0711789159977343, + "output_fingerprint": "687faf97bb6aa868aaaad04a992658d3f3606638b97b461cb4473b6d992f7024", + "peak_python_bytes": 3593039, + "peak_rss_bytes": 3145728, + "profile": null, + "report_fingerprint": "b53d9d0058700ac439a5aba82889f1847b28f07d23152cb5860ba9e13b9a44cf", + "result_type": "CleanResult", + "samples_seconds": [ + 0.0711789159977343, + 0.0716784579999512, + 0.07143450000148732, + 0.07174612499875366, + 0.07143666699994355 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0002256616192651972, + "throughput_rows_per_second": 139984.13447827712 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.010999966255078686, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r1t8ppnu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r1t8ppnu/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1609037, + "input_to_peak_ratio": 0.8756939709901015, + "max_seconds": 0.07854412500091712, + "median_seconds": 0.07707733300048858, + "min_seconds": 0.07668025000020862, + "output_fingerprint": "687faf97bb6aa868aaaad04a992658d3f3606638b97b461cb4473b6d992f7024", + "peak_python_bytes": 3593081, + "peak_rss_bytes": 1409024, + "profile": null, + "report_fingerprint": "b53d9d0058700ac439a5aba82889f1847b28f07d23152cb5860ba9e13b9a44cf", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.07807499999762513, + 0.07854412500091712, + 0.07670016699921689, + 0.07668025000020862, + 0.07707733300048858 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0008478480620368372, + "throughput_rows_per_second": 129739.82895771202 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.00383759705360402, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mov5obdy/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-mov5obdy/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 1.7709870247724975, + "max_seconds": 1.254088583002158, + "median_seconds": 1.2441839999992226, + "min_seconds": 1.2422579589983798, + "output_fingerprint": "214772a4b6542e14c42e27e5c98fbd6f0d5eb4aa28d7c5de2b39c0c57a8c0c92", + "peak_python_bytes": 37581451, + "peak_rss_bytes": 54444032, + "profile": null, + "report_fingerprint": "25d7790fe4cc5f0a54cfaf180d65a21741d9159de000972f62532d35cc267e63", + "result_type": "CleanResult", + "samples_seconds": [ + 1.2441839999992226, + 1.2434867080010008, + 1.2422579589983798, + 1.2476427920009883, + 1.254088583002158 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.004774676852538281, + "throughput_rows_per_second": 8037.396397965453 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.007529357137550132, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g4j166wv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g4j166wv/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.10072721868251641, + "max_seconds": 1.2675768750013958, + "median_seconds": 1.252297708997503, + "min_seconds": 1.2474811669999326, + "output_fingerprint": "214772a4b6542e14c42e27e5c98fbd6f0d5eb4aa28d7c5de2b39c0c57a8c0c92", + "peak_python_bytes": 37583519, + "peak_rss_bytes": 3096576, + "profile": null, + "report_fingerprint": "25d7790fe4cc5f0a54cfaf180d65a21741d9159de000972f62532d35cc267e63", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.2474811669999326, + 1.265699957999459, + 1.2494793749974633, + 1.2675768750013958, + 1.252297708997503 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.009428996693578027, + "throughput_rows_per_second": 7985.3216436890725 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.004691768145839231, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o26qohu4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o26qohu4/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.061289048404705754, + "max_seconds": 1.8673234579982818, + "median_seconds": 1.8547586669992597, + "min_seconds": 1.8451443329977337, + "output_fingerprint": "4241256457e2f63d648ee0d8933b8cfbb5c2082ed5908b95e4cca9692423be07", + "peak_python_bytes": 37583796, + "peak_rss_bytes": 1884160, + "profile": null, + "report_fingerprint": "071e9188d8877322ffd72bb8c45fe3a44a3267bccac6669de2c4f8459a9c99aa", + "result_type": "CleanResult", + "samples_seconds": [ + 1.8451443329977337, + 1.8473720000001776, + 1.8547586669992597, + 1.8555711250010063, + 1.8673234579982818 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00870209763204636, + "throughput_rows_per_second": 5391.5370112159135 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.007597031861914729, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-dq31_bs5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-dq31_bs5/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 1.1575635924784426, + "max_seconds": 1.8819159170016064, + "median_seconds": 1.8649732090016187, + "min_seconds": 1.842743208999309, + "output_fingerprint": "4241256457e2f63d648ee0d8933b8cfbb5c2082ed5908b95e4cca9692423be07", + "peak_python_bytes": 37584972, + "peak_rss_bytes": 35586048, + "profile": { + "allocations": [ + { + "bytes": 1496, + "count": 23, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 58 + }, + { + "bytes": 957, + "count": 15, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 199 + }, + { + "bytes": 894, + "count": 15, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 209 + }, + { + "bytes": 516, + "count": 8, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 119 + }, + { + "bytes": 485, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 24 + }, + { + "bytes": 480, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 104 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 93 + }, + { + "bytes": 432, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 154 + }, + { + "bytes": 431, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 309 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 74 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 187 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 101 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 424 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 184 + }, + { + "bytes": 312, + "count": 2, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 198 + }, + { + "bytes": 299, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 362 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 90 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 32 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 152 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 75 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 70 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 63 + }, + { + "bytes": 279, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 280 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 35 + }, + { + "bytes": 267, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 126 + }, + { + "bytes": 265, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 444 + }, + { + "bytes": 264, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 25 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 464 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 185 + }, + { + "bytes": 254, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 124 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 355 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 116 + }, + { + "bytes": 221, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 110 + }, + { + "bytes": 220, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 78 + }, + { + "bytes": 218, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 452 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 94 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 55 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 30 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 39 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 11 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 132 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 123 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 116 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 59 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/missing.py", + "line": 48 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/memory.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 70 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 332 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 297 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 257 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 195 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 179 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 133 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 101 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 62 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 29 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 18 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/result.py", + "line": 25 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 223 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 61 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/utils.py", + "line": 6 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 263 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 163 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 68 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 159 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 86 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 73 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 53 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 525 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 499 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 432 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 272 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 152 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 142 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 282 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 231 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 219 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 210 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 199 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 168 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 118 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 109 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 92 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 79 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "line": 21 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 438 + } + ], + "functions": [ + { + "calls": 1, + "cumulative_seconds": 18.447509583000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "function": "clean", + "line": 138, + "self_seconds": 7.287400000000001e-05 + }, + { + "calls": 1, + "cumulative_seconds": 18.44411925, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "clean", + "line": 189, + "self_seconds": 0.00030816700000000003 + }, + { + "calls": 1, + "cumulative_seconds": 18.443811083, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.0017712530000000002 + }, + { + "calls": 1, + "cumulative_seconds": 11.888526209, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.0024269160000000003 + }, + { + "calls": 42, + "cumulative_seconds": 11.883506043, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.0015574170000000002 + }, + { + "calls": 42, + "cumulative_seconds": 10.877374458, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.001528709 + }, + { + "calls": 42, + "cumulative_seconds": 8.524509371, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 7.2784e-05 + }, + { + "calls": 42, + "cumulative_seconds": 8.524436587, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/tools/numeric.py", + "function": "to_numeric", + "line": 47, + "self_seconds": 8.505467767 + }, + { + "calls": 210, + "cumulative_seconds": 2.324131835, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "wrapper", + "line": 132, + "self_seconds": 0.000672411 + }, + { + "calls": 210, + "cumulative_seconds": 2.239212362, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map", + "line": 431, + "self_seconds": 0.05009024 + }, + { + "calls": 2251, + "cumulative_seconds": 2.108261886, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "function": "observed", + "line": 58, + "self_seconds": 0.009023362 + }, + { + "calls": 1370, + "cumulative_seconds": 1.547030136, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.041703238000000004 + }, + { + "calls": 42, + "cumulative_seconds": 1.540215295, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_leading_zero_ids", + "line": 72, + "self_seconds": 0.000101834 + }, + { + "calls": 419132, + "cumulative_seconds": 1.499753539, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "", + "line": 74, + "self_seconds": 0.404063453 + }, + { + "calls": 168, + "cumulative_seconds": 1.4423760460000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map_str_or_object", + "line": 486, + "self_seconds": 0.478327492 + }, + { + "calls": 2, + "cumulative_seconds": 1.416051833, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "function": "memory_bytes", + "line": 34, + "self_seconds": 4.35e-05 + }, + { + "calls": 2, + "cumulative_seconds": 1.4157557920000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "memory_usage", + "line": 3677, + "self_seconds": 0.000372831 + }, + { + "calls": 277, + "cumulative_seconds": 1.3994247930000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "memory_usage", + "line": 5451, + "self_seconds": 0.000169752 + }, + { + "calls": 320, + "cumulative_seconds": 1.399282458, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "_memory_usage", + "line": 1139, + "self_seconds": 0.001300507 + }, + { + "calls": 84, + "cumulative_seconds": 1.392242076, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "memory_usage", + "line": 1025, + "self_seconds": 1.392242076 + }, + { + "calls": 1, + "cumulative_seconds": 1.3768729590000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 2.4583e-05 + }, + { + "calls": 1, + "cumulative_seconds": 1.315927416, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "drop_duplicate_rows", + "line": 83, + "self_seconds": 0.00158204 + }, + { + "calls": 1, + "cumulative_seconds": 1.308761792, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.00037163100000000003 + }, + { + "calls": 128, + "cumulative_seconds": 1.3082805400000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.011201704000000002 + }, + { + "calls": 1, + "cumulative_seconds": 1.118378125, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "_filter_rows", + "line": 70, + "self_seconds": 0.011012328 + }, + { + "calls": 2206, + "cumulative_seconds": 1.111354726, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "apply", + "line": 317, + "self_seconds": 0.049430064 + }, + { + "calls": 84, + "cumulative_seconds": 1.097898336, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "strip", + "line": 2141, + "self_seconds": 0.000259796 + }, + { + "calls": 84, + "cumulative_seconds": 1.06526575, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_strip", + "line": 487, + "self_seconds": 0.000274756 + }, + { + "calls": 1, + "cumulative_seconds": 1.049690583, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "clean_strings", + "line": 94, + "self_seconds": 0.0012887530000000001 + }, + { + "calls": 42, + "cumulative_seconds": 1.042668041, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "normalize_text", + "line": 55, + "self_seconds": 0.055910257000000005 + }, + { + "calls": 1, + "cumulative_seconds": 0.999587125, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.001588924 + }, + { + "calls": 326, + "cumulative_seconds": 0.988995916, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "astype", + "line": 6485, + "self_seconds": 0.006330619 + }, + { + "calls": 326, + "cumulative_seconds": 0.9345927030000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "astype", + "line": 440, + "self_seconds": 0.000890327 + }, + { + "calls": 42, + "cumulative_seconds": 0.933374374, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 0.00019061700000000002 + }, + { + "calls": 838180, + "cumulative_seconds": 0.9309116340000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 488, + "self_seconds": 0.48816598600000005 + }, + { + "calls": 45, + "cumulative_seconds": 0.9305209520000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.002291698 + }, + { + "calls": 326, + "cumulative_seconds": 0.9228264920000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "astype", + "line": 749, + "self_seconds": 0.002465512 + }, + { + "calls": 42, + "cumulative_seconds": 0.9221320850000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_relative_date_word", + "line": 195, + "self_seconds": 0.057774626 + }, + { + "calls": 326, + "cumulative_seconds": 0.91575417, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array_safe", + "line": 191, + "self_seconds": 0.001544915 + }, + { + "calls": 326, + "cumulative_seconds": 0.887482784, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array", + "line": 157, + "self_seconds": 0.0044967 + }, + { + "calls": 169, + "cumulative_seconds": 0.872552376, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "_astype_nansafe", + "line": 56, + "self_seconds": 0.0004990820000000001 + }, + { + "calls": 45, + "cumulative_seconds": 0.8565206280000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "function": "rank_missing_models", + "line": 73, + "self_seconds": 0.0037044530000000003 + }, + { + "calls": 106, + "cumulative_seconds": 0.8453367930000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", + "function": "_from_sequence", + "line": 151, + "self_seconds": 0.00039134300000000005 + }, + { + "calls": 106, + "cumulative_seconds": 0.8430883290000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_array", + "line": 266, + "self_seconds": 0.00017137100000000002 + }, + { + "calls": 106, + "cumulative_seconds": 0.8429169580000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_data_and_mask", + "line": 135, + "self_seconds": 0.832296692 + }, + { + "calls": 42, + "cumulative_seconds": 0.7541757520000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "contains", + "line": 1205, + "self_seconds": 0.000330962 + }, + { + "calls": 22, + "cumulative_seconds": 0.7418493340000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "function": "_partner_info", + "line": 53, + "self_seconds": 0.01057684 + }, + { + "calls": 42, + "cumulative_seconds": 0.735975624, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_contains", + "line": 133, + "self_seconds": 0.00039700300000000005 + }, + { + "calls": 5962, + "cumulative_seconds": 0.730429473, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "isna", + "line": 101, + "self_seconds": 0.002736203 + }, + { + "calls": 5962, + "cumulative_seconds": 0.728025228, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna", + "line": 184, + "self_seconds": 0.027893635000000003 + }, + { + "calls": 2893, + "cumulative_seconds": 0.6801897050000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__init__", + "line": 392, + "self_seconds": 0.268753006 + }, + { + "calls": 419090, + "cumulative_seconds": 0.671775032, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 147, + "self_seconds": 0.252318957 + }, + { + "calls": 419485, + "cumulative_seconds": 0.623810323, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.623810323 + }, + { + "calls": 2709, + "cumulative_seconds": 0.5901014480000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "notna", + "line": 380, + "self_seconds": 0.002916632 + }, + { + "calls": 42, + "cumulative_seconds": 0.547881046, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "_strip_series", + "line": 30, + "self_seconds": 7.504400000000001e-05 + }, + { + "calls": 45, + "cumulative_seconds": 0.538143001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "missingness_is_informative", + "line": 168, + "self_seconds": 0.01723658 + }, + { + "calls": 1265, + "cumulative_seconds": 0.5073249550000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "notna", + "line": 5805, + "self_seconds": 0.002726582 + }, + { + "calls": 1265, + "cumulative_seconds": 0.504598373, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "notna", + "line": 8787, + "self_seconds": 0.006209381000000001 + }, + { + "calls": 128, + "cumulative_seconds": 0.48392783300000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.00169819 + }, + { + "calls": 84, + "cumulative_seconds": 0.47138533600000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "casefold", + "line": 3249, + "self_seconds": 0.00020954100000000002 + }, + { + "calls": 428456, + "cumulative_seconds": 0.445714418, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "__iter__", + "line": 489, + "self_seconds": 0.261932838 + }, + { + "calls": 838436, + "cumulative_seconds": 0.44291749100000005, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.44291749100000005 + }, + { + "calls": 84, + "cumulative_seconds": 0.43923496, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_casefold", + "line": 471, + "self_seconds": 0.000171924 + }, + { + "calls": 420728, + "cumulative_seconds": 0.424847627, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.424847627 + }, + { + "calls": 128, + "cumulative_seconds": 0.40607849900000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "value_counts", + "line": 927, + "self_seconds": 0.000361329 + }, + { + "calls": 213, + "cumulative_seconds": 0.40571717, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_internal", + "line": 862, + "self_seconds": 0.009365946 + }, + { + "calls": 13783, + "cumulative_seconds": 0.39227900800000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "__getitem__", + "line": 4073, + "self_seconds": 0.056802572 + }, + { + "calls": 869122, + "cumulative_seconds": 0.332446945, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.29782930100000005 + }, + { + "calls": 14315, + "cumulative_seconds": 0.29813019500000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "_get_item_cache", + "line": 4637, + "self_seconds": 0.039295704 + }, + { + "calls": 1, + "cumulative_seconds": 0.284378958, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "function": "auto_outliers", + "line": 68, + "self_seconds": 0.0016132850000000001 + }, + { + "calls": 4153, + "cumulative_seconds": 0.275357666, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_array", + "line": 261, + "self_seconds": 0.024353318000000002 + }, + { + "calls": 3575, + "cumulative_seconds": 0.251682833, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "_ixs", + "line": 3994, + "self_seconds": 0.022053412 + }, + { + "calls": 44, + "cumulative_seconds": 0.24089358400000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "function": "_handle_column", + "line": 163, + "self_seconds": 0.002217244 + }, + { + "calls": 498, + "cumulative_seconds": 0.24044827600000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "remove_na_arraylike", + "line": 718, + "self_seconds": 0.00249118 + }, + { + "calls": 462, + "cumulative_seconds": 0.23859507100000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "dropna", + "line": 5839, + "self_seconds": 0.002097438 + }, + { + "calls": 864, + "cumulative_seconds": 0.237020053, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_string_dtype", + "line": 305, + "self_seconds": 0.237020053 + }, + { + "calls": 800, + "cumulative_seconds": 0.23369787500000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numpy_.py", + "function": "isna", + "line": 237, + "self_seconds": 0.000443873 + }, + { + "calls": 2533, + "cumulative_seconds": 0.231469113, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__getitem__", + "line": 1107, + "self_seconds": 0.021287740000000003 + }, + { + "calls": 3682, + "cumulative_seconds": 0.229199869, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/construction.py", + "function": "sanitize_array", + "line": 517, + "self_seconds": 0.10884316200000001 + }, + { + "calls": 66, + "cumulative_seconds": 0.22646491900000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "function": "detection_bounds", + "line": 90, + "self_seconds": 0.0020173680000000003 + }, + { + "calls": 132, + "cumulative_seconds": 0.221832505, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "quantile", + "line": 2849, + "self_seconds": 0.0015242 + }, + { + "calls": 42, + "cumulative_seconds": 0.21370846100000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "value_counts", + "line": 1014, + "self_seconds": 0.002649256 + }, + { + "calls": 429330, + "cumulative_seconds": 0.201094494, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/_mixins.py", + "function": "__getitem__", + "line": 278, + "self_seconds": 0.168706259 + }, + { + "calls": 44, + "cumulative_seconds": 0.19991745700000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "function": "_detect", + "line": 124, + "self_seconds": 0.000840903 + }, + { + "calls": 2, + "cumulative_seconds": 0.195686834, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "duplicated", + "line": 6850, + "self_seconds": 0.0020767380000000003 + }, + { + "calls": 264, + "cumulative_seconds": 0.174820256, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "quantile", + "line": 12075, + "self_seconds": 0.0054227880000000004 + }, + { + "calls": 9488, + "cumulative_seconds": 0.167760751, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/common.py", + "function": "is_numeric_dtype", + "line": 1083, + "self_seconds": 0.020722196000000002 + }, + { + "calls": 2331, + "cumulative_seconds": 0.16616467000000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "_reduce", + "line": 6439, + "self_seconds": 0.014045411 + }, + { + "calls": 9056, + "cumulative_seconds": 0.15823677800000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "__finalize__", + "line": 6258, + "self_seconds": 0.139306924 + }, + { + "calls": 256, + "cumulative_seconds": 0.152425012, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "f", + "line": 6947, + "self_seconds": 0.0005262740000000001 + }, + { + "calls": 256, + "cumulative_seconds": 0.150718873, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize", + "line": 610, + "self_seconds": 0.007537192000000001 + }, + { + "calls": 471, + "cumulative_seconds": 0.14753421800000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/ops/common.py", + "function": "new_method", + "line": 62, + "self_seconds": 0.0005604140000000001 + }, + { + "calls": 727, + "cumulative_seconds": 0.13897534, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/indexes/base.py", + "function": "__new__", + "line": 475, + "self_seconds": 0.032900555000000005 + }, + { + "calls": 1614, + "cumulative_seconds": 0.138759357, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "__invert__", + "line": 1568, + "self_seconds": 0.0069722890000000004 + }, + { + "calls": 149, + "cumulative_seconds": 0.134253368, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_arraylike", + "line": 963, + "self_seconds": 0.124493955 + }, + { + "calls": 256, + "cumulative_seconds": 0.133209083, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize_array", + "line": 548, + "self_seconds": 0.11405111700000001 + }, + { + "calls": 14607, + "cumulative_seconds": 0.131351449, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/common.py", + "function": "_is_dtype_type", + "line": 1444, + "self_seconds": 0.060800492000000005 + }, + { + "calls": 3440, + "cumulative_seconds": 0.130649748, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "_box_col_values", + "line": 4619, + "self_seconds": 0.008856389000000001 + }, + { + "calls": 641, + "cumulative_seconds": 0.128958359, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "_get_rows_with_mask", + "line": 1228, + "self_seconds": 0.001892606 + }, + { + "calls": 132, + "cumulative_seconds": 0.11760382800000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "quantile", + "line": 1539, + "self_seconds": 0.002137368 + } + ], + "operations": { + "dataframe.astype": 0, + "dataframe.copy": 2, + "dataframe.corr": 1, + "dataframe.corrwith": 0, + "series.astype": 326, + "series.copy": 99, + "series.isna": 302, + "series.notna": 1265, + "series.nunique": 128, + "series.value_counts": 128 + }, + "stages": { + "audit_events": 0.000557293, + "backend_conversion": 2.125e-06, + "context": 0.029740996000000002, + "correlation": 0.03594217400000001, + "dtype_repair": 0.4700339960000001, + "duplicates": 0.012594743, + "engine_cache": 2.4583e-05, + "missing": 0.0065947950000000005, + "outliers": 0.007558219000000001, + "report_finalization": 0.0021584190000000004, + "role_inference": 0.014759384000000002, + "semantic_ml": 0.0, + "total": 18.445463412000006 + } + }, + "report_fingerprint": "071e9188d8877322ffd72bb8c45fe3a44a3267bccac6669de2c4f8459a9c99aa", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.8819159170016064, + 1.842743208999309, + 1.8639159170015773, + 1.8649732090016187, + 1.8695793750011944 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.014168260890402653, + "throughput_rows_per_second": 5362.007320927322 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.002409189351340888, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-df48de9a/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-df48de9a/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 1.271614517335895, + "max_seconds": 1.322102250000171, + "median_seconds": 1.3189022500009742, + "min_seconds": 1.31356091699854, + "output_fingerprint": "f84c65db4601fd8cacf1db75345161f80af77f91dfcc34183a2c3640892f4d79", + "peak_python_bytes": 37582012, + "peak_rss_bytes": 39092224, + "profile": null, + "report_fingerprint": "b8fef42218db6b309cbd6b76176cd93f2368efc554a1a1a0575fcfcc5588bc53", + "result_type": "CleanResult", + "samples_seconds": [ + 1.322102250000171, + 1.3170905000006314, + 1.31356091699854, + 1.319587333000527, + 1.3189022500009742 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.003177485256161885, + "throughput_rows_per_second": 7582.063037645598 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0048229589435619565, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7t8hq6r0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7t8hq6r0/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.5766500032512315, + "max_seconds": 1.3375802090013167, + "median_seconds": 1.3288593329998548, + "min_seconds": 1.3231531250021362, + "output_fingerprint": "f84c65db4601fd8cacf1db75345161f80af77f91dfcc34183a2c3640892f4d79", + "peak_python_bytes": 37582867, + "peak_rss_bytes": 17727488, + "profile": null, + "report_fingerprint": "b8fef42218db6b309cbd6b76176cd93f2368efc554a1a1a0575fcfcc5588bc53", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.3232842920006078, + 1.3231531250021362, + 1.333947041999636, + 1.3375802090013167, + 1.3288593329998548 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.006409034004827426, + "throughput_rows_per_second": 7525.250981550726 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.004710241640675547, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xhlz9fkb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xhlz9fkb/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.05755841067572366, + "max_seconds": 0.1825133749989618, + "median_seconds": 0.18122950000179117, + "min_seconds": 0.18040058300175588, + "output_fingerprint": "93803f837ff5a5887b2b22d477e1c54098bef3a5d84de64006ca62af3f4b57b6", + "peak_python_bytes": 2469902, + "peak_rss_bytes": 1769472, + "profile": null, + "report_fingerprint": "8a3347ff4bb9cc72f3bd4919ac0e288be91c629bfb4aebfe6e960cab67d2a09a", + "result_type": "CleanResult", + "samples_seconds": [ + 0.1825133749989618, + 0.18206262500098092, + 0.1809391249989858, + 0.18040058300175588, + 0.18122950000179117 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0008536347374272458, + "throughput_rows_per_second": 55178.654688674666 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0026953707782055663, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6x8nokur/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6x8nokur/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.05702546242872622, + "max_seconds": 0.18233124999824213, + "median_seconds": 0.18185704200004693, + "min_seconds": 0.18102041599922813, + "output_fingerprint": "93803f837ff5a5887b2b22d477e1c54098bef3a5d84de64006ca62af3f4b57b6", + "peak_python_bytes": 2469902, + "peak_rss_bytes": 1753088, + "profile": null, + "report_fingerprint": "8a3347ff4bb9cc72f3bd4919ac0e288be91c629bfb4aebfe6e960cab67d2a09a", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.18102041599922813, + 0.18166208299953723, + 0.18185704200004693, + 0.18202575000032084, + 0.18233124999824213 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0004901721568178289, + "throughput_rows_per_second": 54988.24730690065 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0026028396247467335, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g_nftmdn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g_nftmdn/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.208915712822997, + "max_seconds": 1.2471103339994443, + "median_seconds": 1.2409888340007456, + "min_seconds": 1.2385880420006288, + "output_fingerprint": "214772a4b6542e14c42e27e5c98fbd6f0d5eb4aa28d7c5de2b39c0c57a8c0c92", + "peak_python_bytes": 37580620, + "peak_rss_bytes": 6422528, + "profile": null, + "report_fingerprint": "25d7790fe4cc5f0a54cfaf180d65a21741d9159de000972f62532d35cc267e63", + "result_type": "CleanResult", + "samples_seconds": [ + 1.241531749998103, + 1.2409888340007456, + 1.2402015830011806, + 1.2385880420006288, + 1.2471103339994443 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.003230094911005387, + "throughput_rows_per_second": 8058.090230966568 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 10000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.016040450250656146, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i04nrmrp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i04nrmrp/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 30742197, + "input_to_peak_ratio": 0.08953530549557015, + "max_seconds": 1.2959120419982355, + "median_seconds": 1.2526210410032945, + "min_seconds": 1.2469993749982677, + "output_fingerprint": "214772a4b6542e14c42e27e5c98fbd6f0d5eb4aa28d7c5de2b39c0c57a8c0c92", + "peak_python_bytes": 37582519, + "peak_rss_bytes": 2752512, + "profile": null, + "report_fingerprint": "25d7790fe4cc5f0a54cfaf180d65a21741d9159de000972f62532d35cc267e63", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.2526210410032945, + 1.2469993749982677, + 1.2508673330012243, + 1.2959120419982355, + 1.2556265839994012 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.02009260549113846, + "throughput_rows_per_second": 7983.260437642369 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "categorical", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.019561045566747596, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5z51_7m7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5z51_7m7/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 4007872, + "input_to_peak_ratio": 4.615301087459879, + "max_seconds": 0.7335019999991346, + "median_seconds": 0.7031170830014162, + "min_seconds": 0.7020546669991745, + "output_fingerprint": "93ccc58269a36591dd9e3f7ee5d4ab34820f2f6482320df4b59eb2bf98ae19ff", + "peak_python_bytes": 55932109, + "peak_rss_bytes": 18497536, + "profile": null, + "report_fingerprint": "53deec41df8d88ec57aa63c8ec00433270698ca1e15abd55296f452bbfea772a", + "result_type": "CleanResult", + "samples_seconds": [ + 0.7335019999991346, + 0.7031170830014162, + 0.7021033749988419, + 0.7020546669991745, + 0.7039088749988878 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.013753705299349352, + "throughput_rows_per_second": 142223.82362426343 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "categorical", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.01636904227236863, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-oc0p3e55/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-oc0p3e55/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 4007872, + "input_to_peak_ratio": 10.199447487344905, + "max_seconds": 0.7128574999987904, + "median_seconds": 0.6922838329992373, + "min_seconds": 0.682556083000236, + "output_fingerprint": "93ccc58269a36591dd9e3f7ee5d4ab34820f2f6482320df4b59eb2bf98ae19ff", + "peak_python_bytes": 55931450, + "peak_rss_bytes": 40878080, + "profile": null, + "report_fingerprint": "53deec41df8d88ec57aa63c8ec00433270698ca1e15abd55296f452bbfea772a", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.682556083000236, + 0.6922838329992373, + 0.689575500000501, + 0.6968117500000517, + 0.7128574999987904 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.011332023326841903, + "throughput_rows_per_second": 144449.42266925678 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "datetime", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.013145320719353972, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w5oxtzfm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w5oxtzfm/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 25000132, + "input_to_peak_ratio": 0.0838856370838362, + "max_seconds": 0.5640965839993441, + "median_seconds": 0.5481095830000413, + "min_seconds": 0.5470652080002765, + "output_fingerprint": "362a50e0e5c1af5893b1d927f58cd5aa16759fc680e54f0ce84a1d8f8368de6c", + "peak_python_bytes": 51688234, + "peak_rss_bytes": 2097152, + "profile": null, + "report_fingerprint": "305da8d5f7da742a51898adaa82f48d579e53d3b477cbe07bef796b765c7df4b", + "result_type": "CleanResult", + "samples_seconds": [ + 0.5472772079992865, + 0.5481095830000413, + 0.5470652080002765, + 0.5513643749982293, + 0.5640965839993441 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.007205076257886909, + "throughput_rows_per_second": 182445.26843091607 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "datetime", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.014360532521259203, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bhzt0s5x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bhzt0s5x/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 25000132, + "input_to_peak_ratio": 1.1442525183467032, + "max_seconds": 0.5674192919977941, + "median_seconds": 0.5499384169997938, + "min_seconds": 0.549568750000617, + "output_fingerprint": "362a50e0e5c1af5893b1d927f58cd5aa16759fc680e54f0ce84a1d8f8368de6c", + "peak_python_bytes": 51688200, + "peak_rss_bytes": 28606464, + "profile": null, + "report_fingerprint": "305da8d5f7da742a51898adaa82f48d579e53d3b477cbe07bef796b765c7df4b", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.549568750000617, + 0.5497160409977369, + 0.5499384169997938, + 0.558493250002357, + 0.5674192919977941 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.007897408522015344, + "throughput_rows_per_second": 181838.54211450278 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "high_cardinality", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.017982634310690217, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jsn72n1l/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-jsn72n1l/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 179703532, + "input_to_peak_ratio": 0.061723706131719215, + "max_seconds": 7.38445879199935, + "median_seconds": 7.134097707999899, + "min_seconds": 7.075513207997574, + "output_fingerprint": "cc7b2b290ffb707f57dc7cf23543c4cccc69bff079f91bf4cbe23c12b7c025c0", + "peak_python_bytes": 72255369, + "peak_rss_bytes": 11091968, + "profile": null, + "report_fingerprint": "f94f1024d90728fd01d8b97fc4ef034e5814d8d89aa694bb6a99e5fcada0051a", + "result_type": "CleanResult", + "samples_seconds": [ + 7.075513207997574, + 7.080423957999301, + 7.213450500003091, + 7.134097707999899, + 7.38445879199935 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.12828987021969543, + "throughput_rows_per_second": 14017.189572251567 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "high_cardinality", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.006538406438391809, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-8z80spay/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-8z80spay/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 179703532, + "input_to_peak_ratio": 0.05133005399137063, + "max_seconds": 6.947271332999662, + "median_seconds": 6.887654082998779, + "min_seconds": 6.834175457999663, + "output_fingerprint": "cc7b2b290ffb707f57dc7cf23543c4cccc69bff079f91bf4cbe23c12b7c025c0", + "peak_python_bytes": 72254323, + "peak_rss_bytes": 9224192, + "profile": null, + "report_fingerprint": "f94f1024d90728fd01d8b97fc4ef034e5814d8d89aa694bb6a99e5fcada0051a", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 6.834175457999663, + 6.87897987499673, + 6.947271332999662, + 6.887654082998779, + 6.932083084000624 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.045034281801694845, + "throughput_rows_per_second": 14518.731457033558 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "aggressive", + "dataset_type": "mixed", + "options": { + "strategy": "aggressive", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.005076537377871827, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs aggressive --report-modes true --output benchmarks/results/performance/baseline", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.2967865951495202, + "max_seconds": 2.843991833999098, + "median_seconds": 2.8141387499999837, + "min_seconds": 2.810073500000726, + "output_fingerprint": "11e939ca08d4e4a122b7305f45a0e47a7fa090ed8e352f54f430c01000898273", + "peak_python_bytes": 98674645, + "peak_rss_bytes": 22118400, + "profile": { + "allocations": [ + { + "bytes": 1496, + "count": 23, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 58 + }, + { + "bytes": 541, + "count": 8, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 199 + }, + { + "bytes": 495, + "count": 8, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 209 + }, + { + "bytes": 487, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 24 + }, + { + "bytes": 480, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 104 + }, + { + "bytes": 475, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 309 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 93 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 424 + }, + { + "bytes": 471, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 119 + }, + { + "bytes": 432, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 154 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 74 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 187 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 101 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 184 + }, + { + "bytes": 323, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 280 + }, + { + "bytes": 312, + "count": 2, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 198 + }, + { + "bytes": 299, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 362 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 90 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 32 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 152 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 75 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 70 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 63 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 110 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 35 + }, + { + "bytes": 267, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 126 + }, + { + "bytes": 264, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 25 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 185 + }, + { + "bytes": 254, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 124 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 355 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 116 + }, + { + "bytes": 240, + "count": 2, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 67 + }, + { + "bytes": 220, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 78 + }, + { + "bytes": 219, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 444 + }, + { + "bytes": 218, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 452 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 94 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 55 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 30 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 39 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 11 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 132 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 116 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 59 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/missing.py", + "line": 48 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/memory.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 70 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 332 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 297 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 257 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 195 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 179 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 133 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 101 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 62 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 29 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 18 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/result.py", + "line": 25 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 223 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 61 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/utils.py", + "line": 6 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 263 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 163 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 68 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 159 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 86 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 73 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 53 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 548 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 525 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 499 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 464 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 432 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 272 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 152 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 142 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 282 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 231 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 219 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 210 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 199 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 168 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 118 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 109 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 92 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 79 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "line": 21 + } + ], + "functions": [ + { + "calls": 1, + "cumulative_seconds": 15.656137541000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "function": "clean", + "line": 138, + "self_seconds": 7.833200000000001e-05 + }, + { + "calls": 1, + "cumulative_seconds": 15.654646667000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "clean", + "line": 189, + "self_seconds": 9.091700000000001e-05 + }, + { + "calls": 1, + "cumulative_seconds": 15.65455575, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.002155752 + }, + { + "calls": 1, + "cumulative_seconds": 4.873163041000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.003231334 + }, + { + "calls": 10, + "cumulative_seconds": 4.868864123000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.0031959090000000002 + }, + { + "calls": 1, + "cumulative_seconds": 3.694439, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "drop_duplicate_rows", + "line": 83, + "self_seconds": 0.0031395000000000004 + }, + { + "calls": 50, + "cumulative_seconds": 3.660260039, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "wrapper", + "line": 132, + "self_seconds": 0.000175495 + }, + { + "calls": 50, + "cumulative_seconds": 3.6351989230000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map", + "line": 431, + "self_seconds": 0.01220904 + }, + { + "calls": 2, + "cumulative_seconds": 3.351624999, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "function": "memory_bytes", + "line": 34, + "self_seconds": 4.3248e-05 + }, + { + "calls": 2, + "cumulative_seconds": 3.351336084, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "memory_usage", + "line": 3677, + "self_seconds": 0.000220458 + }, + { + "calls": 40, + "cumulative_seconds": 3.3425798760000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map_str_or_object", + "line": 486, + "self_seconds": 1.119445468 + }, + { + "calls": 64, + "cumulative_seconds": 3.341869958, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "memory_usage", + "line": 5451, + "self_seconds": 0.00010895900000000001 + }, + { + "calls": 75, + "cumulative_seconds": 3.341795791, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "_memory_usage", + "line": 1139, + "self_seconds": 0.00039540200000000005 + }, + { + "calls": 20, + "cumulative_seconds": 3.339806207, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "memory_usage", + "line": 1025, + "self_seconds": 3.339806207 + }, + { + "calls": 1, + "cumulative_seconds": 3.308793, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "_filter_rows", + "line": 70, + "self_seconds": 0.037568382000000004 + }, + { + "calls": 406, + "cumulative_seconds": 3.208384053, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "function": "observed", + "line": 58, + "self_seconds": 0.0047750200000000005 + }, + { + "calls": 10, + "cumulative_seconds": 2.709190708, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.000393706 + }, + { + "calls": 425, + "cumulative_seconds": 2.521135262, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "apply", + "line": 317, + "self_seconds": 0.010360407 + }, + { + "calls": 20, + "cumulative_seconds": 2.4623925420000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "strip", + "line": 2141, + "self_seconds": 0.000101131 + }, + { + "calls": 20, + "cumulative_seconds": 2.453537664, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_strip", + "line": 487, + "self_seconds": 9.662100000000001e-05 + }, + { + "calls": 73, + "cumulative_seconds": 2.3809116610000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "astype", + "line": 6485, + "self_seconds": 0.001656714 + }, + { + "calls": 73, + "cumulative_seconds": 2.368100203, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "astype", + "line": 440, + "self_seconds": 0.000199108 + }, + { + "calls": 73, + "cumulative_seconds": 2.365325996, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "astype", + "line": 749, + "self_seconds": 0.0006349070000000001 + }, + { + "calls": 73, + "cumulative_seconds": 2.3634629630000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array_safe", + "line": 191, + "self_seconds": 0.00038292800000000004 + }, + { + "calls": 73, + "cumulative_seconds": 2.357004749, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array", + "line": 157, + "self_seconds": 0.0037637910000000003 + }, + { + "calls": 41, + "cumulative_seconds": 2.349810961, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "_astype_nansafe", + "line": 56, + "self_seconds": 0.00015533500000000002 + }, + { + "calls": 26, + "cumulative_seconds": 2.3047704970000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", + "function": "_from_sequence", + "line": 151, + "self_seconds": 0.00012332600000000002 + }, + { + "calls": 26, + "cumulative_seconds": 2.3041143770000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_array", + "line": 266, + "self_seconds": 5.383400000000001e-05 + }, + { + "calls": 26, + "cumulative_seconds": 2.3040605430000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_data_and_mask", + "line": 135, + "self_seconds": 2.296258457 + }, + { + "calls": 1, + "cumulative_seconds": 2.248981708, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "clean_strings", + "line": 94, + "self_seconds": 0.0038150870000000004 + }, + { + "calls": 10, + "cumulative_seconds": 2.243204956, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "normalize_text", + "line": 55, + "self_seconds": 0.18429724900000002 + }, + { + "calls": 1981818, + "cumulative_seconds": 2.173583529, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 488, + "self_seconds": 1.145624221 + }, + { + "calls": 10, + "cumulative_seconds": 2.096985043, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 3.2458e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.096952585, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/tools/numeric.py", + "function": "to_numeric", + "line": 47, + "self_seconds": 2.09218946 + }, + { + "calls": 10, + "cumulative_seconds": 2.053126042, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 6.0085000000000005e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.003233042, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_relative_date_word", + "line": 195, + "self_seconds": 0.17640391200000002 + }, + { + "calls": 10, + "cumulative_seconds": 1.2191575840000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "_strip_series", + "line": 30, + "self_seconds": 3.0294e-05 + }, + { + "calls": 1, + "cumulative_seconds": 1.029299875, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.7916000000000003e-05 + }, + { + "calls": 1981882, + "cumulative_seconds": 1.028003055, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 1.028003055 + }, + { + "calls": 20, + "cumulative_seconds": 1.0159222940000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "casefold", + "line": 3249, + "self_seconds": 6.821500000000001e-05 + }, + { + "calls": 20, + "cumulative_seconds": 1.006766207, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_casefold", + "line": 471, + "self_seconds": 0.0022279960000000003 + }, + { + "calls": 1, + "cumulative_seconds": 0.9873299170000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.00029224400000000004 + }, + { + "calls": 32, + "cumulative_seconds": 0.987001839, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.006624975000000001 + }, + { + "calls": 55, + "cumulative_seconds": 0.673674462, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "to_numpy", + "line": 545, + "self_seconds": 0.0006347060000000001 + }, + { + "calls": 2040, + "cumulative_seconds": 0.645908366, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.003820046 + }, + { + "calls": 6, + "cumulative_seconds": 0.6383114590000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "to_numpy", + "line": 539, + "self_seconds": 0.001980252 + }, + { + "calls": 22, + "cumulative_seconds": 0.631025083, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__array__", + "line": 640, + "self_seconds": 7.5584e-05 + }, + { + "calls": 22, + "cumulative_seconds": 0.630926917, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py", + "function": "__array__", + "line": 356, + "self_seconds": 0.097922253 + }, + { + "calls": 1221, + "cumulative_seconds": 0.6123327310000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "isna", + "line": 101, + "self_seconds": 0.00060722 + }, + { + "calls": 1221, + "cumulative_seconds": 0.6118094040000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna", + "line": 184, + "self_seconds": 0.0052530170000000004 + }, + { + "calls": 856, + "cumulative_seconds": 0.5360777480000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_array", + "line": 261, + "self_seconds": 0.007070420000000001 + }, + { + "calls": 208, + "cumulative_seconds": 0.524457207, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_string_dtype", + "line": 305, + "self_seconds": 0.524457207 + }, + { + "calls": 100001, + "cumulative_seconds": 0.521770539, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__iter__", + "line": 647, + "self_seconds": 0.521709288 + }, + { + "calls": 192, + "cumulative_seconds": 0.49852737, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numpy_.py", + "function": "isna", + "line": 237, + "self_seconds": 0.000117984 + }, + { + "calls": 32, + "cumulative_seconds": 0.47562941400000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.00051553 + }, + { + "calls": 32, + "cumulative_seconds": 0.42827245500000005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "value_counts", + "line": 927, + "self_seconds": 0.001943285 + }, + { + "calls": 53, + "cumulative_seconds": 0.42632917000000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_internal", + "line": 862, + "self_seconds": 0.004509605 + }, + { + "calls": 2, + "cumulative_seconds": 0.38199545900000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "duplicated", + "line": 6850, + "self_seconds": 0.006431867000000001 + }, + { + "calls": 351, + "cumulative_seconds": 0.371214826, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.010037366 + }, + { + "calls": 10, + "cumulative_seconds": 0.36937024900000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_leading_zero_ids", + "line": 72, + "self_seconds": 2.8916000000000002e-05 + }, + { + "calls": 100010, + "cumulative_seconds": 0.35964645500000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "", + "line": 74, + "self_seconds": 0.09616972700000001 + }, + { + "calls": 64, + "cumulative_seconds": 0.30653304800000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "f", + "line": 6947, + "self_seconds": 0.000159726 + }, + { + "calls": 64, + "cumulative_seconds": 0.306030115, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize", + "line": 610, + "self_seconds": 0.0059123840000000006 + }, + { + "calls": 37, + "cumulative_seconds": 0.299538666, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_arraylike", + "line": 963, + "self_seconds": 0.297029043 + }, + { + "calls": 10, + "cumulative_seconds": 0.29238462600000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "value_counts", + "line": 1014, + "self_seconds": 0.004183087 + }, + { + "calls": 64, + "cumulative_seconds": 0.28892300000000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize_array", + "line": 548, + "self_seconds": 0.271428006 + }, + { + "calls": 20, + "cumulative_seconds": 0.23548983, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "isin", + "line": 5505, + "self_seconds": 0.000265614 + }, + { + "calls": 352, + "cumulative_seconds": 0.23113048500000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "notna", + "line": 380, + "self_seconds": 0.000690773 + }, + { + "calls": 799, + "cumulative_seconds": 0.22721691600000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/construction.py", + "function": "sanitize_array", + "line": 517, + "self_seconds": 0.024621 + }, + { + "calls": 40, + "cumulative_seconds": 0.225482751, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "isin", + "line": 457, + "self_seconds": 0.22215557900000002 + }, + { + "calls": 30, + "cumulative_seconds": 0.22486066600000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "factorize", + "line": 1428, + "self_seconds": 0.0019101690000000002 + }, + { + "calls": 20, + "cumulative_seconds": 0.223491252, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "isin", + "line": 825, + "self_seconds": 0.000297166 + }, + { + "calls": 3, + "cumulative_seconds": 0.21597812500000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "__init__", + "line": 698, + "self_seconds": 0.000159748 + }, + { + "calls": 1, + "cumulative_seconds": 0.214970708, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "dict_to_mgr", + "line": 423, + "self_seconds": 0.000255878 + }, + { + "calls": 1, + "cumulative_seconds": 0.21207166700000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "arrays_to_mgr", + "line": 96, + "self_seconds": 0.005157416000000001 + }, + { + "calls": 12, + "cumulative_seconds": 0.19743616800000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "missingness_is_informative", + "line": 168, + "self_seconds": 0.004007557 + }, + { + "calls": 1, + "cumulative_seconds": 0.188849125, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.000502995 + }, + { + "calls": 42, + "cumulative_seconds": 0.184260462, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "unique", + "line": 2356, + "self_seconds": 0.00010729500000000001 + }, + { + "calls": 42, + "cumulative_seconds": 0.184153167, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "unique", + "line": 1023, + "self_seconds": 8.891500000000001e-05 + }, + { + "calls": 109, + "cumulative_seconds": 0.183118879, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/cast.py", + "function": "maybe_infer_to_datetimelike", + "line": 1166, + "self_seconds": 0.092691376 + }, + { + "calls": 42, + "cumulative_seconds": 0.182346541, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique_with_mask", + "line": 427, + "self_seconds": 0.165558958 + }, + { + "calls": 10, + "cumulative_seconds": 0.181769708, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "contains", + "line": 1205, + "self_seconds": 9.083100000000001e-05 + }, + { + "calls": 36, + "cumulative_seconds": 0.178958959, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique", + "line": 307, + "self_seconds": 0.0015303760000000002 + }, + { + "calls": 10, + "cumulative_seconds": 0.17741979200000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_contains", + "line": 133, + "self_seconds": 9.9914e-05 + }, + { + "calls": 1, + "cumulative_seconds": 0.17607091600000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "_homogenize", + "line": 596, + "self_seconds": 0.00035879900000000003 + }, + { + "calls": 30, + "cumulative_seconds": 0.16209183400000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/_mixins.py", + "function": "unique", + "line": 223, + "self_seconds": 9.275e-05 + }, + { + "calls": 100000, + "cumulative_seconds": 0.16184473100000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 147, + "self_seconds": 0.060307142 + }, + { + "calls": 126, + "cumulative_seconds": 0.158363585, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "remove_na_arraylike", + "line": 718, + "self_seconds": 0.004161898000000001 + }, + { + "calls": 591, + "cumulative_seconds": 0.15213725, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__init__", + "line": 392, + "self_seconds": 0.057689636 + }, + { + "calls": 100091, + "cumulative_seconds": 0.149628656, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.149628656 + }, + { + "calls": 32, + "cumulative_seconds": 0.14638804, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 9.628900000000001e-05 + }, + { + "calls": 13, + "cumulative_seconds": 0.14569658300000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.0015346300000000002 + }, + { + "calls": 120, + "cumulative_seconds": 0.143458168, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "dropna", + "line": 5839, + "self_seconds": 0.000588868 + }, + { + "calls": 32, + "cumulative_seconds": 0.143120625, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "nunique", + "line": 1032, + "self_seconds": 0.0014773750000000002 + }, + { + "calls": 145, + "cumulative_seconds": 0.142871038, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "notna", + "line": 5805, + "self_seconds": 0.000374922 + }, + { + "calls": 31, + "cumulative_seconds": 0.142597205, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "sample", + "line": 5998, + "self_seconds": 0.00040437000000000003 + }, + { + "calls": 145, + "cumulative_seconds": 0.142496116, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "notna", + "line": 8787, + "self_seconds": 0.002429454 + }, + { + "calls": 299, + "cumulative_seconds": 0.141344626, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__getitem__", + "line": 1107, + "self_seconds": 0.004130488 + }, + { + "calls": 1, + "cumulative_seconds": 0.130268292, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "function": "auto_outliers", + "line": 68, + "self_seconds": 0.001407328 + }, + { + "calls": 370, + "cumulative_seconds": 0.12384866200000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "apply", + "line": 389, + "self_seconds": 0.00083297 + } + ], + "operations": { + "dataframe.astype": 0, + "dataframe.copy": 2, + "dataframe.corr": 1, + "dataframe.corrwith": 0, + "series.astype": 73, + "series.copy": 39, + "series.isna": 82, + "series.notna": 145, + "series.nunique": 32, + "series.value_counts": 32 + }, + "stages": { + "audit_events": 0.00020208700000000002, + "backend_conversion": 2.582e-06, + "context": 0.007438439000000001, + "correlation": 0.028099166000000002, + "dtype_repair": 0.28010022900000003, + "duplicates": 0.040708465000000006, + "engine_cache": 1.7916000000000003e-05, + "missing": 0.003021489, + "outliers": 0.003146528, + "report_finalization": 0.00233, + "role_inference": 0.009795895, + "semantic_ml": 0.0, + "total": 15.655626045000009 + } + }, + "report_fingerprint": "48d7ea24cd727aff41bc52a7bf46c26ada321e3707b3f567fcbf0f8be431dff8", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 2.815334957998857, + 2.810323083000185, + 2.8141387499999837, + 2.843991833999098, + 2.810073500000726 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.014286080550892418, + "throughput_rows_per_second": 35534.85058261629 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.07704786400812878, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-505l5i2k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-505l5i2k/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.40231071786934963, + "max_seconds": 2.2282906670006923, + "median_seconds": 1.9063625409980887, + "min_seconds": 1.8809836670006916, + "output_fingerprint": "2c1a8aa93526335f73567718c764615e8d441132a5f0faac9b5302ceee688dc2", + "peak_python_bytes": 99242163, + "peak_rss_bytes": 29982720, + "profile": null, + "report_fingerprint": "faebe9a7f90c9de6a7caf477a8004a014d4f8ee7c360b22fca08bc25e4b9ac0f", + "result_type": "CleanResult", + "samples_seconds": [ + 1.8809836670006916, + 1.9032530000004044, + 1.9063625409980887, + 1.9132812919997377, + 2.2282906670006923 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.14688116180901156, + "throughput_rows_per_second": 52455.919506079015 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.04409865491504091, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wyy78nbb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wyy78nbb/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.209289510060995, + "max_seconds": 2.0915084589978505, + "median_seconds": 1.911802416001592, + "min_seconds": 1.8930058330006432, + "output_fingerprint": "2c1a8aa93526335f73567718c764615e8d441132a5f0faac9b5302ceee688dc2", + "peak_python_bytes": 99242568, + "peak_rss_bytes": 15597568, + "profile": null, + "report_fingerprint": "faebe9a7f90c9de6a7caf477a8004a014d4f8ee7c360b22fca08bc25e4b9ac0f", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.911802416001592, + 1.9741377909995208, + 2.0915084589978505, + 1.8938099169972702, + 1.8930058330006432 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0843079150089957, + "throughput_rows_per_second": 52306.66054347989 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.005913771116302398, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7ijnb2t2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7ijnb2t2/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.4363862158309612, + "max_seconds": 2.7821130419979454, + "median_seconds": 2.7661234579973097, + "min_seconds": 2.739529875001608, + "output_fingerprint": "41d9766a0316de1d223eb5f610c067fc99b43e00b25c14c7a1d948c12e211b88", + "peak_python_bytes": 99242260, + "peak_rss_bytes": 32522240, + "profile": null, + "report_fingerprint": "5b96b8f8c86d2679badb55655c430480302131a789d96a9a20c6b700608dc644", + "result_type": "CleanResult", + "samples_seconds": [ + 2.7821130419979454, + 2.739529875001608, + 2.7721869590022834, + 2.7661234579973097, + 2.755250000001979 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.016358221010031, + "throughput_rows_per_second": 36151.67635084539 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.13480751584290457, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uv5wrp3w/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uv5wrp3w/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.40802660785000705, + "max_seconds": 4.235295832997508, + "median_seconds": 3.706996832999721, + "min_seconds": 2.931050040999253, + "output_fingerprint": "41d9766a0316de1d223eb5f610c067fc99b43e00b25c14c7a1d948c12e211b88", + "peak_python_bytes": 99242953, + "peak_rss_bytes": 30408704, + "profile": { + "allocations": [ + { + "bytes": 1432, + "count": 22, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 58 + }, + { + "bytes": 1064, + "count": 17, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 199 + }, + { + "bytes": 611, + "count": 10, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 209 + }, + { + "bytes": 531, + "count": 8, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 24 + }, + { + "bytes": 480, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 104 + }, + { + "bytes": 475, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 309 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 93 + }, + { + "bytes": 432, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 154 + }, + { + "bytes": 425, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 119 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 74 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 187 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 101 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 424 + }, + { + "bytes": 360, + "count": 3, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 67 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 184 + }, + { + "bytes": 323, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 280 + }, + { + "bytes": 312, + "count": 2, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 198 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 90 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 32 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 152 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 75 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 70 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 63 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 110 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 35 + }, + { + "bytes": 265, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 452 + }, + { + "bytes": 265, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 444 + }, + { + "bytes": 264, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 25 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 464 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 185 + }, + { + "bytes": 259, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 194 + }, + { + "bytes": 254, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 124 + }, + { + "bytes": 251, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 362 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 355 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 116 + }, + { + "bytes": 220, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 78 + }, + { + "bytes": 220, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 126 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 94 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 55 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 30 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 39 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 11 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 132 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 123 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 116 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 59 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/missing.py", + "line": 48 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/memory.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 70 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 332 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 297 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 257 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 195 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 179 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 133 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 101 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 62 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 29 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 18 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/result.py", + "line": 25 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 223 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 61 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/utils.py", + "line": 6 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 263 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 163 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 68 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 159 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 86 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 73 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 53 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 525 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 499 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 432 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 272 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 152 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 142 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 282 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 231 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 219 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 210 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 199 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 168 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 118 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 109 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 92 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 79 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 72 + } + ], + "functions": [ + { + "calls": 1, + "cumulative_seconds": 16.007341750000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "function": "clean", + "line": 138, + "self_seconds": 7.354200000000001e-05 + }, + { + "calls": 1, + "cumulative_seconds": 16.005794625, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "clean", + "line": 189, + "self_seconds": 9.3417e-05 + }, + { + "calls": 1, + "cumulative_seconds": 16.005701208, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.0012433720000000002 + }, + { + "calls": 1, + "cumulative_seconds": 4.828396791, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.0025325 + }, + { + "calls": 10, + "cumulative_seconds": 4.824715293000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.0034783390000000004 + }, + { + "calls": 50, + "cumulative_seconds": 3.7708460830000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "wrapper", + "line": 132, + "self_seconds": 0.00018441800000000002 + }, + { + "calls": 50, + "cumulative_seconds": 3.7454792070000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map", + "line": 431, + "self_seconds": 0.012253139000000001 + }, + { + "calls": 1, + "cumulative_seconds": 3.6972045000000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "drop_duplicate_rows", + "line": 83, + "self_seconds": 0.00332971 + }, + { + "calls": 40, + "cumulative_seconds": 3.452418041, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map_str_or_object", + "line": 486, + "self_seconds": 1.146573199 + }, + { + "calls": 2, + "cumulative_seconds": 3.318744875, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "function": "memory_bytes", + "line": 34, + "self_seconds": 4.4167000000000006e-05 + }, + { + "calls": 2, + "cumulative_seconds": 3.318451542, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "memory_usage", + "line": 3677, + "self_seconds": 0.00022379300000000002 + }, + { + "calls": 1, + "cumulative_seconds": 3.314036375, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "_filter_rows", + "line": 70, + "self_seconds": 0.036335632 + }, + { + "calls": 69, + "cumulative_seconds": 3.310466497, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "memory_usage", + "line": 5451, + "self_seconds": 7.4582e-05 + }, + { + "calls": 80, + "cumulative_seconds": 3.3104205810000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "_memory_usage", + "line": 1139, + "self_seconds": 0.00041872800000000005 + }, + { + "calls": 20, + "cumulative_seconds": 3.3082552510000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "memory_usage", + "line": 1025, + "self_seconds": 3.3082552510000003 + }, + { + "calls": 396, + "cumulative_seconds": 3.280482371, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "function": "observed", + "line": 58, + "self_seconds": 0.0035473680000000004 + }, + { + "calls": 10, + "cumulative_seconds": 2.699901707, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.00039857900000000003 + }, + { + "calls": 1, + "cumulative_seconds": 2.609203792, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "clean_strings", + "line": 94, + "self_seconds": 0.005247166 + }, + { + "calls": 10, + "cumulative_seconds": 2.6018854580000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "normalize_text", + "line": 55, + "self_seconds": 0.16996133400000002 + }, + { + "calls": 395, + "cumulative_seconds": 2.589355158, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "apply", + "line": 317, + "self_seconds": 0.010000006 + }, + { + "calls": 20, + "cumulative_seconds": 2.551476, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "strip", + "line": 2141, + "self_seconds": 0.00010704300000000001 + }, + { + "calls": 20, + "cumulative_seconds": 2.541925414, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_strip", + "line": 487, + "self_seconds": 0.00017033100000000002 + }, + { + "calls": 78, + "cumulative_seconds": 2.410825753, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "astype", + "line": 6485, + "self_seconds": 0.001983079 + }, + { + "calls": 78, + "cumulative_seconds": 2.396945004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "astype", + "line": 440, + "self_seconds": 0.00022175300000000002 + }, + { + "calls": 78, + "cumulative_seconds": 2.3939041690000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "astype", + "line": 749, + "self_seconds": 0.000683573 + }, + { + "calls": 78, + "cumulative_seconds": 2.3918651260000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array_safe", + "line": 191, + "self_seconds": 0.000423222 + }, + { + "calls": 78, + "cumulative_seconds": 2.385191125, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array", + "line": 157, + "self_seconds": 0.004084624 + }, + { + "calls": 41, + "cumulative_seconds": 2.376754204, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "_astype_nansafe", + "line": 56, + "self_seconds": 0.000159702 + }, + { + "calls": 26, + "cumulative_seconds": 2.3353909180000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", + "function": "_from_sequence", + "line": 151, + "self_seconds": 0.00011887400000000001 + }, + { + "calls": 26, + "cumulative_seconds": 2.3347246260000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_array", + "line": 266, + "self_seconds": 5.5332000000000005e-05 + }, + { + "calls": 26, + "cumulative_seconds": 2.3346692940000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_data_and_mask", + "line": 135, + "self_seconds": 2.3271617200000003 + }, + { + "calls": 1981818, + "cumulative_seconds": 2.254188005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 488, + "self_seconds": 1.173714468 + }, + { + "calls": 10, + "cumulative_seconds": 2.090339374, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 3.3126e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.090306248, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/tools/numeric.py", + "function": "to_numeric", + "line": 47, + "self_seconds": 2.0854137070000003 + }, + { + "calls": 10, + "cumulative_seconds": 2.016756622, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 6.0038000000000004e-05 + }, + { + "calls": 10, + "cumulative_seconds": 1.966834167, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_relative_date_word", + "line": 195, + "self_seconds": 0.15963670800000002 + }, + { + "calls": 10, + "cumulative_seconds": 1.3286040000000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "_strip_series", + "line": 30, + "self_seconds": 3.6543e-05 + }, + { + "calls": 1981882, + "cumulative_seconds": 1.080518282, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 1.080518282 + }, + { + "calls": 1, + "cumulative_seconds": 1.0707703750000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.7666e-05 + }, + { + "calls": 20, + "cumulative_seconds": 1.038995332, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "casefold", + "line": 3249, + "self_seconds": 9.9287e-05 + }, + { + "calls": 20, + "cumulative_seconds": 1.028971708, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_casefold", + "line": 471, + "self_seconds": 0.000829084 + }, + { + "calls": 1, + "cumulative_seconds": 1.028715958, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0008081200000000001 + }, + { + "calls": 32, + "cumulative_seconds": 1.0278724160000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.0048046270000000006 + }, + { + "calls": 1176, + "cumulative_seconds": 0.666045591, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "isna", + "line": 101, + "self_seconds": 0.0009589300000000001 + }, + { + "calls": 1176, + "cumulative_seconds": 0.665497505, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna", + "line": 184, + "self_seconds": 0.005294244 + }, + { + "calls": 55, + "cumulative_seconds": 0.64907725, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "to_numpy", + "line": 545, + "self_seconds": 0.000624214 + }, + { + "calls": 2015, + "cumulative_seconds": 0.6215939970000001, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.003987827 + }, + { + "calls": 6, + "cumulative_seconds": 0.61370725, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "to_numpy", + "line": 539, + "self_seconds": 0.001990541 + }, + { + "calls": 22, + "cumulative_seconds": 0.606274914, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__array__", + "line": 640, + "self_seconds": 8e-05 + }, + { + "calls": 22, + "cumulative_seconds": 0.6061711230000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py", + "function": "__array__", + "line": 356, + "self_seconds": 0.09723162 + }, + { + "calls": 856, + "cumulative_seconds": 0.58925075, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_array", + "line": 261, + "self_seconds": 0.007341996000000001 + }, + { + "calls": 208, + "cumulative_seconds": 0.574524503, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_string_dtype", + "line": 305, + "self_seconds": 0.574524503 + }, + { + "calls": 192, + "cumulative_seconds": 0.548626501, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numpy_.py", + "function": "isna", + "line": 237, + "self_seconds": 0.00014207800000000002 + }, + { + "calls": 32, + "cumulative_seconds": 0.521228871, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000522992 + }, + { + "calls": 100001, + "cumulative_seconds": 0.49797938100000005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__iter__", + "line": 647, + "self_seconds": 0.497909089 + }, + { + "calls": 20, + "cumulative_seconds": 0.471089419, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "isin", + "line": 5505, + "self_seconds": 0.00029358600000000003 + }, + { + "calls": 32, + "cumulative_seconds": 0.46427675100000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "value_counts", + "line": 927, + "self_seconds": 0.001388501 + }, + { + "calls": 53, + "cumulative_seconds": 0.46288825, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_internal", + "line": 862, + "self_seconds": 0.0039435930000000004 + }, + { + "calls": 40, + "cumulative_seconds": 0.46030066700000005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "isin", + "line": 457, + "self_seconds": 0.45656603900000003 + }, + { + "calls": 20, + "cumulative_seconds": 0.458113082, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "isin", + "line": 825, + "self_seconds": 0.00032840900000000005 + }, + { + "calls": 2, + "cumulative_seconds": 0.379471041, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "duplicated", + "line": 6850, + "self_seconds": 0.006612655 + }, + { + "calls": 361, + "cumulative_seconds": 0.36937046700000004, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.010212222 + }, + { + "calls": 10, + "cumulative_seconds": 0.36745558300000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_leading_zero_ids", + "line": 72, + "self_seconds": 3.0957e-05 + }, + { + "calls": 100010, + "cumulative_seconds": 0.35758649000000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "", + "line": 74, + "self_seconds": 0.09610880200000001 + }, + { + "calls": 37, + "cumulative_seconds": 0.339325669, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_arraylike", + "line": 963, + "self_seconds": 0.336895671 + }, + { + "calls": 10, + "cumulative_seconds": 0.32878208400000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "value_counts", + "line": 1014, + "self_seconds": 0.0037350400000000002 + }, + { + "calls": 64, + "cumulative_seconds": 0.30632416900000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "f", + "line": 6947, + "self_seconds": 0.00015783500000000002 + }, + { + "calls": 64, + "cumulative_seconds": 0.305809788, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize", + "line": 610, + "self_seconds": 0.006408700000000001 + }, + { + "calls": 64, + "cumulative_seconds": 0.289509618, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize_array", + "line": 548, + "self_seconds": 0.272013287 + }, + { + "calls": 342, + "cumulative_seconds": 0.24344542200000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "notna", + "line": 380, + "self_seconds": 0.0006978770000000001 + }, + { + "calls": 30, + "cumulative_seconds": 0.223469461, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "factorize", + "line": 1428, + "self_seconds": 0.001636291 + }, + { + "calls": 779, + "cumulative_seconds": 0.223144752, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/construction.py", + "function": "sanitize_array", + "line": 517, + "self_seconds": 0.024471955 + }, + { + "calls": 3, + "cumulative_seconds": 0.215025459, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "__init__", + "line": 698, + "self_seconds": 0.000148918 + }, + { + "calls": 1, + "cumulative_seconds": 0.21394275000000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "dict_to_mgr", + "line": 423, + "self_seconds": 0.000250455 + }, + { + "calls": 1, + "cumulative_seconds": 0.21103179200000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "arrays_to_mgr", + "line": 96, + "self_seconds": 0.00469446 + }, + { + "calls": 12, + "cumulative_seconds": 0.19756933200000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "missingness_is_informative", + "line": 168, + "self_seconds": 0.004025967 + }, + { + "calls": 1, + "cumulative_seconds": 0.18687779100000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.000509831 + }, + { + "calls": 42, + "cumulative_seconds": 0.18317983300000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "unique", + "line": 2356, + "self_seconds": 0.000115086 + }, + { + "calls": 42, + "cumulative_seconds": 0.183064747, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "unique", + "line": 1023, + "self_seconds": 9.15e-05 + }, + { + "calls": 42, + "cumulative_seconds": 0.181934209, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique_with_mask", + "line": 427, + "self_seconds": 0.16528662200000002 + }, + { + "calls": 10, + "cumulative_seconds": 0.180190333, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "contains", + "line": 1205, + "self_seconds": 8.5043e-05 + }, + { + "calls": 114, + "cumulative_seconds": 0.17957246200000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/cast.py", + "function": "maybe_infer_to_datetimelike", + "line": 1166, + "self_seconds": 0.09086184500000001 + }, + { + "calls": 36, + "cumulative_seconds": 0.17796608400000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique", + "line": 307, + "self_seconds": 0.0008476260000000001 + }, + { + "calls": 10, + "cumulative_seconds": 0.17578912600000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_contains", + "line": 133, + "self_seconds": 0.00010275200000000001 + }, + { + "calls": 1, + "cumulative_seconds": 0.17515766600000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "_homogenize", + "line": 596, + "self_seconds": 0.000309543 + }, + { + "calls": 375, + "cumulative_seconds": 0.167978666, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "apply", + "line": 389, + "self_seconds": 0.000935507 + }, + { + "calls": 4, + "cumulative_seconds": 0.16422775, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "isna", + "line": 6510, + "self_seconds": 3.875e-05 + }, + { + "calls": 4, + "cumulative_seconds": 0.16404316700000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", + "function": "isna", + "line": 176, + "self_seconds": 1.5625e-05 + }, + { + "calls": 30, + "cumulative_seconds": 0.16087679000000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/_mixins.py", + "function": "unique", + "line": 223, + "self_seconds": 9.1747e-05 + }, + { + "calls": 100000, + "cumulative_seconds": 0.16027032000000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 147, + "self_seconds": 0.059280114 + }, + { + "calls": 126, + "cumulative_seconds": 0.158444083, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "remove_na_arraylike", + "line": 718, + "self_seconds": 0.0034671220000000004 + }, + { + "calls": 145, + "cumulative_seconds": 0.154287837, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "notna", + "line": 5805, + "self_seconds": 0.000552249 + }, + { + "calls": 145, + "cumulative_seconds": 0.153735588, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "notna", + "line": 8787, + "self_seconds": 0.0011970400000000001 + }, + { + "calls": 566, + "cumulative_seconds": 0.150144928, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__init__", + "line": 392, + "self_seconds": 0.055463072 + }, + { + "calls": 100091, + "cumulative_seconds": 0.14741389500000002, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.14741389500000002 + }, + { + "calls": 32, + "cumulative_seconds": 0.143798998, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 9.5123e-05 + }, + { + "calls": 13, + "cumulative_seconds": 0.14357012700000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.0007045850000000001 + }, + { + "calls": 120, + "cumulative_seconds": 0.142821952, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "dropna", + "line": 5839, + "self_seconds": 0.000592866 + }, + { + "calls": 31, + "cumulative_seconds": 0.14241829, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "sample", + "line": 5998, + "self_seconds": 0.000408122 + }, + { + "calls": 32, + "cumulative_seconds": 0.14180241400000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "nunique", + "line": 1032, + "self_seconds": 0.001515117 + } + ], + "operations": { + "dataframe.astype": 0, + "dataframe.copy": 2, + "dataframe.corr": 1, + "dataframe.corrwith": 0, + "series.astype": 78, + "series.copy": 29, + "series.isna": 77, + "series.notna": 145, + "series.nunique": 32, + "series.value_counts": 32 + }, + "stages": { + "audit_events": 0.00018807600000000002, + "backend_conversion": 2.707e-06, + "context": 0.0083557, + "correlation": 0.027973202000000003, + "dtype_repair": 0.26287297800000003, + "duplicates": 0.039665633, + "engine_cache": 1.7666e-05, + "missing": 0.0021299580000000004, + "outliers": 0.0030579169999999994, + "report_finalization": 0.0014172470000000002, + "role_inference": 0.008124872000000002, + "semantic_ml": 0.0, + "total": 16.006843291 + } + }, + "report_fingerprint": "5b96b8f8c86d2679badb55655c430480302131a789d96a9a20c6b700608dc644", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 4.235295832997508, + 3.706996832999721, + 2.931050040999253, + 3.3239678329991875, + 3.8460982919968956 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.4997310342942069, + "throughput_rows_per_second": 26976.014414093654 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.008088027447490324, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m0sb5i34/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m0sb5i34/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.35328596918909555, + "max_seconds": 2.018167000001995, + "median_seconds": 1.9999317080000765, + "min_seconds": 1.9779002089999267, + "output_fingerprint": "4071a1abf33e6629bd2ad948224d5c3ef9aa87d49a60f9da0ce3a5fd674baa1b", + "peak_python_bytes": 99242359, + "peak_rss_bytes": 26329088, + "profile": null, + "report_fingerprint": "766181b7dfca3b0b9f7b01a44ecb06c5962db96686da9fa9db0ffd7716f3e5ff", + "result_type": "CleanResult", + "samples_seconds": [ + 1.9779002089999267, + 1.9863895420021436, + 1.9999317080000765, + 2.018167000001995, + 2.007866957999795 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.016175502547410823, + "throughput_rows_per_second": 50001.70735829754 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.24930237130619276, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zsncy0_k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zsncy0_k/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.2013752008570078, + "max_seconds": 3.327331417000096, + "median_seconds": 2.179572625002038, + "min_seconds": 1.9999477499986824, + "output_fingerprint": "4071a1abf33e6629bd2ad948224d5c3ef9aa87d49a60f9da0ce3a5fd674baa1b", + "peak_python_bytes": 99241210, + "peak_rss_bytes": 15007744, + "profile": null, + "report_fingerprint": "766181b7dfca3b0b9f7b01a44ecb06c5962db96686da9fa9db0ffd7716f3e5ff", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.9999477499986824, + 2.5724376250000205, + 2.179572625002038, + 2.1012884580013633, + 3.327331417000096 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.5433726238470713, + "throughput_rows_per_second": 45880.554220993894 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.009526434055027714, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wbkq_rwi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-wbkq_rwi/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.04330885869959666, + "max_seconds": 0.4090374580009666, + "median_seconds": 0.40544370799761964, + "min_seconds": 0.4004477919988858, + "output_fingerprint": "575001f2c17305b56d84cd95a0ea7378b9b8154e1f3a9b142f0f6bdbebc38107", + "peak_python_bytes": 4145364, + "peak_rss_bytes": 3227648, + "profile": null, + "report_fingerprint": "517a82707a3d6d544066ddd6ad7f0270ec66d3c99682bf53507b98175f0d9421", + "result_type": "CleanResult", + "samples_seconds": [ + 0.4090374580009666, + 0.4074908749971655, + 0.40544370799761964, + 0.4008995829972264, + 0.4004477919988858 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0038624327472652356, + "throughput_rows_per_second": 246643.36386886807 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.0032747361996070417, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-73qnu4tr/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-73qnu4tr/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.03297628834994669, + "max_seconds": 0.414822708000429, + "median_seconds": 0.41235429100197507, + "min_seconds": 0.4111883330006094, + "output_fingerprint": "575001f2c17305b56d84cd95a0ea7378b9b8154e1f3a9b142f0f6bdbebc38107", + "peak_python_bytes": 4145411, + "peak_rss_bytes": 2457600, + "profile": null, + "report_fingerprint": "517a82707a3d6d544066ddd6ad7f0270ec66d3c99682bf53507b98175f0d9421", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.41207987499728915, + 0.4111883330006094, + 0.41235429100197507, + 0.4128054999964661, + 0.414822708000429 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.001350351523807464, + "throughput_rows_per_second": 242509.90515222025 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "semantic", + "dataset_type": "mixed", + "options": { + "semantic_mode": "assist", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.007656005966839124, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs semantic --report-modes true --output benchmarks/results/performance/baseline", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.20489267161433544, + "max_seconds": 4.1976765420004085, + "median_seconds": 4.147246458000154, + "min_seconds": 4.132623542000147, + "output_fingerprint": "41d9766a0316de1d223eb5f610c067fc99b43e00b25c14c7a1d948c12e211b88", + "peak_python_bytes": 99236550, + "peak_rss_bytes": 15269888, + "profile": { + "allocations": [ + { + "bytes": 1560, + "count": 24, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 58 + }, + { + "bytes": 998, + "count": 16, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 199 + }, + { + "bytes": 952, + "count": 17, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "line": 565 + }, + { + "bytes": 785, + "count": 13, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 209 + }, + { + "bytes": 531, + "count": 8, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 24 + }, + { + "bytes": 516, + "count": 8, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 119 + }, + { + "bytes": 475, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 309 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 187 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 93 + }, + { + "bytes": 434, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 104 + }, + { + "bytes": 432, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 154 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 74 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 101 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 424 + }, + { + "bytes": 366, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "line": 96 + }, + { + "bytes": 360, + "count": 3, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 67 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 184 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "line": 125 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "line": 46 + }, + { + "bytes": 323, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 46 + }, + { + "bytes": 323, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 280 + }, + { + "bytes": 312, + "count": 2, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 198 + }, + { + "bytes": 284, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "line": 323 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 90 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 32 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/types.py", + "line": 111 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 45 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/router.py", + "line": 28 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/memory.py", + "line": 149 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/memory.py", + "line": 68 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/memory.py", + "line": 51 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "line": 567 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "line": 347 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "line": 136 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "line": 107 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/plugins.py", + "line": 390 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/plugins.py", + "line": 260 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 152 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 282 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 419 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 75 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 70 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 63 + }, + { + "bytes": 273, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 78 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 35 + }, + { + "bytes": 267, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 126 + }, + { + "bytes": 265, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 452 + }, + { + "bytes": 264, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 25 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 464 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 185 + }, + { + "bytes": 259, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 194 + }, + { + "bytes": 254, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 124 + }, + { + "bytes": 251, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 362 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 355 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 116 + }, + { + "bytes": 221, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 110 + }, + { + "bytes": 219, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 444 + }, + { + "bytes": 217, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 96 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 94 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 55 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 30 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 39 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 11 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 132 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 123 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 116 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 59 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/missing.py", + "line": 48 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/memory.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 70 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 332 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 297 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 257 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 195 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 179 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 133 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 101 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 62 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 29 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 18 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/types.py", + "line": 184 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/types.py", + "line": 181 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/types.py", + "line": 165 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 266 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 238 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 213 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 60 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 49 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/scoring.py", + "line": 39 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/router.py", + "line": 15 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/profiler.py", + "line": 37 + } + ], + "functions": [ + { + "calls": 1, + "cumulative_seconds": 22.017368166, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "function": "clean", + "line": 138, + "self_seconds": 7.1418e-05 + }, + { + "calls": 1, + "cumulative_seconds": 22.015860583000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "clean", + "line": 189, + "self_seconds": 0.00010137500000000001 + }, + { + "calls": 1, + "cumulative_seconds": 22.015759208000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.001232128 + }, + { + "calls": 1, + "cumulative_seconds": 6.300034834000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/apply.py", + "function": "run_semantic", + "line": 192, + "self_seconds": 7.050200000000001e-05 + }, + { + "calls": 1, + "cumulative_seconds": 6.184277584, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "function": "build_semantic_context", + "line": 224, + "self_seconds": 0.016825461 + }, + { + "calls": 32, + "cumulative_seconds": 5.199613295000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "function": "_build_info", + "line": 68, + "self_seconds": 0.32090255 + }, + { + "calls": 1, + "cumulative_seconds": 4.841690791, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.002720586 + }, + { + "calls": 10, + "cumulative_seconds": 4.837934914, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.002535915 + }, + { + "calls": 222, + "cumulative_seconds": 4.240089994, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.0056377960000000005 + }, + { + "calls": 192, + "cumulative_seconds": 4.232225615, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "function": "_share", + "line": 43, + "self_seconds": 0.00042520100000000005 + }, + { + "calls": 50132, + "cumulative_seconds": 4.227006950000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "function": "", + "line": 46, + "self_seconds": 0.123334149 + }, + { + "calls": 639, + "cumulative_seconds": 3.9418460300000002, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "function": "observed", + "line": 58, + "self_seconds": 0.005489941 + }, + { + "calls": 1, + "cumulative_seconds": 3.6622402500000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "drop_duplicate_rows", + "line": 83, + "self_seconds": 0.002560206 + }, + { + "calls": 50, + "cumulative_seconds": 3.6418861660000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "wrapper", + "line": 132, + "self_seconds": 0.00017033 + }, + { + "calls": 50, + "cumulative_seconds": 3.617712705, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map", + "line": 431, + "self_seconds": 0.012532272 + }, + { + "calls": 2, + "cumulative_seconds": 3.4019304170000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "function": "memory_bytes", + "line": 34, + "self_seconds": 4.3794e-05 + }, + { + "calls": 2, + "cumulative_seconds": 3.4016359990000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "memory_usage", + "line": 3677, + "self_seconds": 0.000236077 + }, + { + "calls": 69, + "cumulative_seconds": 3.39386571, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "memory_usage", + "line": 5451, + "self_seconds": 9.0915e-05 + }, + { + "calls": 80, + "cumulative_seconds": 3.3938038780000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "_memory_usage", + "line": 1139, + "self_seconds": 0.00044511400000000003 + }, + { + "calls": 20, + "cumulative_seconds": 3.3915962910000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "memory_usage", + "line": 1025, + "self_seconds": 3.3915962910000004 + }, + { + "calls": 40, + "cumulative_seconds": 3.323956126, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map_str_or_object", + "line": 486, + "self_seconds": 1.113277969 + }, + { + "calls": 1, + "cumulative_seconds": 3.2839802500000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "_filter_rows", + "line": 70, + "self_seconds": 0.035611541000000003 + }, + { + "calls": 10, + "cumulative_seconds": 2.7092296680000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.00041245800000000004 + }, + { + "calls": 652, + "cumulative_seconds": 2.5204887350000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "apply", + "line": 317, + "self_seconds": 0.014809716 + }, + { + "calls": 20, + "cumulative_seconds": 2.4476709590000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "strip", + "line": 2141, + "self_seconds": 0.00010362500000000001 + }, + { + "calls": 20, + "cumulative_seconds": 2.4387574180000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_strip", + "line": 487, + "self_seconds": 9.725300000000001e-05 + }, + { + "calls": 108, + "cumulative_seconds": 2.379947628, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "astype", + "line": 6485, + "self_seconds": 0.002398138 + }, + { + "calls": 1, + "cumulative_seconds": 2.376738375, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "clean_strings", + "line": 94, + "self_seconds": 0.0036025030000000004 + }, + { + "calls": 10, + "cumulative_seconds": 2.371167207, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "normalize_text", + "line": 55, + "self_seconds": 0.161557417 + }, + { + "calls": 108, + "cumulative_seconds": 2.359856287, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "astype", + "line": 440, + "self_seconds": 0.00030867700000000004 + }, + { + "calls": 108, + "cumulative_seconds": 2.355738541, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "astype", + "line": 749, + "self_seconds": 0.0009197620000000001 + }, + { + "calls": 108, + "cumulative_seconds": 2.3530287060000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array_safe", + "line": 191, + "self_seconds": 0.000568262 + }, + { + "calls": 108, + "cumulative_seconds": 2.342650833, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array", + "line": 157, + "self_seconds": 0.004159091 + }, + { + "calls": 71, + "cumulative_seconds": 2.3350235820000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "_astype_nansafe", + "line": 56, + "self_seconds": 0.00025576200000000004 + }, + { + "calls": 56, + "cumulative_seconds": 2.297788413, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", + "function": "_from_sequence", + "line": 151, + "self_seconds": 0.00022199400000000002 + }, + { + "calls": 56, + "cumulative_seconds": 2.2964812940000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_array", + "line": 266, + "self_seconds": 0.000125625 + }, + { + "calls": 56, + "cumulative_seconds": 2.296355669, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_data_and_mask", + "line": 135, + "self_seconds": 2.286891604 + }, + { + "calls": 1981818, + "cumulative_seconds": 2.161074065, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 488, + "self_seconds": 1.134753573 + }, + { + "calls": 10, + "cumulative_seconds": 2.0969137520000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 3.0377e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.096883375, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/tools/numeric.py", + "function": "to_numeric", + "line": 47, + "self_seconds": 2.092131078 + }, + { + "calls": 10, + "cumulative_seconds": 2.0223464150000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 5.971e-05 + }, + { + "calls": 10, + "cumulative_seconds": 1.972535667, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_relative_date_word", + "line": 195, + "self_seconds": 0.160582587 + }, + { + "calls": 2, + "cumulative_seconds": 1.9195117920000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.000636707 + }, + { + "calls": 64, + "cumulative_seconds": 1.9188081670000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.008543853 + }, + { + "calls": 2432165, + "cumulative_seconds": 1.287945176, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 1.287945176 + }, + { + "calls": 10, + "cumulative_seconds": 1.217133585, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "_strip_series", + "line": 30, + "self_seconds": 3.0378000000000003e-05 + }, + { + "calls": 20, + "cumulative_seconds": 1.010763877, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "casefold", + "line": 3249, + "self_seconds": 8.2668e-05 + }, + { + "calls": 20, + "cumulative_seconds": 1.001866041, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_casefold", + "line": 471, + "self_seconds": 0.0013445430000000001 + }, + { + "calls": 1, + "cumulative_seconds": 0.9941378750000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 2.1084e-05 + }, + { + "calls": 64, + "cumulative_seconds": 0.9219006670000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000992616 + }, + { + "calls": 75, + "cumulative_seconds": 0.911929961, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "value_counts", + "line": 927, + "self_seconds": 0.000859797 + }, + { + "calls": 127, + "cumulative_seconds": 0.9110701640000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_internal", + "line": 862, + "self_seconds": 0.008377474000000001 + }, + { + "calls": 50956, + "cumulative_seconds": 0.8522209820000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "function": "looks_like_date_value", + "line": 180, + "self_seconds": 0.38726867800000003 + }, + { + "calls": 192602, + "cumulative_seconds": 0.851710331, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "function": "is_plain_number", + "line": 146, + "self_seconds": 0.718468278 + }, + { + "calls": 192602, + "cumulative_seconds": 0.8415128690000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "function": "", + "line": 96, + "self_seconds": 0.327692425 + }, + { + "calls": 1734, + "cumulative_seconds": 0.819329312, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "isna", + "line": 101, + "self_seconds": 0.000897034 + }, + { + "calls": 1734, + "cumulative_seconds": 0.818545582, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna", + "line": 184, + "self_seconds": 0.008278824 + }, + { + "calls": 50956, + "cumulative_seconds": 0.767035105, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "function": "", + "line": 97, + "self_seconds": 0.047553731 + }, + { + "calls": 50956, + "cumulative_seconds": 0.719481374, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "function": "parse_currency", + "line": 100, + "self_seconds": 0.27177564200000004 + }, + { + "calls": 1268, + "cumulative_seconds": 0.6974261540000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_array", + "line": 261, + "self_seconds": 0.010792371 + }, + { + "calls": 269, + "cumulative_seconds": 0.6795684620000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_string_dtype", + "line": 305, + "self_seconds": 0.6795684620000001 + }, + { + "calls": 75, + "cumulative_seconds": 0.672880871, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "to_numpy", + "line": 545, + "self_seconds": 0.0007820380000000001 + }, + { + "calls": 405905, + "cumulative_seconds": 0.65990894, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.65990894 + }, + { + "calls": 3365, + "cumulative_seconds": 0.656956502, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.006366222 + }, + { + "calls": 253, + "cumulative_seconds": 0.6545883410000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numpy_.py", + "function": "isna", + "line": 237, + "self_seconds": 0.000161587 + }, + { + "calls": 6, + "cumulative_seconds": 0.637395999, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "to_numpy", + "line": 539, + "self_seconds": 0.0019406660000000002 + }, + { + "calls": 85, + "cumulative_seconds": 0.635827624, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_arraylike", + "line": 963, + "self_seconds": 0.630650253 + }, + { + "calls": 35, + "cumulative_seconds": 0.63022, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__array__", + "line": 640, + "self_seconds": 0.000126747 + }, + { + "calls": 50956, + "cumulative_seconds": 0.630131585, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/context.py", + "function": "", + "line": 95, + "self_seconds": 0.040659137000000005 + }, + { + "calls": 35, + "cumulative_seconds": 0.6300572950000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py", + "function": "__array__", + "line": 356, + "self_seconds": 0.09786674000000001 + }, + { + "calls": 25, + "cumulative_seconds": 0.629761833, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "value_counts", + "line": 1014, + "self_seconds": 0.006621625000000001 + }, + { + "calls": 50956, + "cumulative_seconds": 0.589472448, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "function": "parse_number_words", + "line": 61, + "self_seconds": 0.21770080100000003 + }, + { + "calls": 110002, + "cumulative_seconds": 0.5720737260000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__iter__", + "line": 647, + "self_seconds": 0.572000554 + }, + { + "calls": 192604, + "cumulative_seconds": 0.513828652, + "file": "/Users/wilson/freshdata-qa/src/freshdata/semantic/experts.py", + "function": "parse_boolean", + "line": 136, + "self_seconds": 0.23641804800000002 + }, + { + "calls": 51536, + "cumulative_seconds": 0.49532768200000005, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.063227353 + }, + { + "calls": 553, + "cumulative_seconds": 0.40757215300000005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "notna", + "line": 380, + "self_seconds": 0.0012785020000000002 + }, + { + "calls": 20, + "cumulative_seconds": 0.3918725, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "isin", + "line": 5505, + "self_seconds": 0.000257296 + }, + { + "calls": 1143968, + "cumulative_seconds": 0.390199377, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.37755868800000003 + }, + { + "calls": 24, + "cumulative_seconds": 0.38685437500000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "missingness_is_informative", + "line": 168, + "self_seconds": 0.0072084340000000005 + }, + { + "calls": 40, + "cumulative_seconds": 0.381347247, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "isin", + "line": 457, + "self_seconds": 0.378076205 + }, + { + "calls": 20, + "cumulative_seconds": 0.379437791, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "isin", + "line": 825, + "self_seconds": 0.000291446 + }, + { + "calls": 2, + "cumulative_seconds": 0.37536429200000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "duplicated", + "line": 6850, + "self_seconds": 0.006282467000000001 + }, + { + "calls": 10, + "cumulative_seconds": 0.368003001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_leading_zero_ids", + "line": 72, + "self_seconds": 3.1837e-05 + }, + { + "calls": 100010, + "cumulative_seconds": 0.35824469600000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "", + "line": 74, + "self_seconds": 0.095876049 + }, + { + "calls": 74, + "cumulative_seconds": 0.331898001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "sample", + "line": 5998, + "self_seconds": 0.0008629870000000001 + }, + { + "calls": 262, + "cumulative_seconds": 0.328564662, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "remove_na_arraylike", + "line": 718, + "self_seconds": 0.0034636800000000002 + }, + { + "calls": 128, + "cumulative_seconds": 0.31821291500000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique_with_mask", + "line": 427, + "self_seconds": 0.287743405 + }, + { + "calls": 96, + "cumulative_seconds": 0.31487004500000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "unique", + "line": 2356, + "self_seconds": 0.000246836 + }, + { + "calls": 96, + "cumulative_seconds": 0.314623209, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "unique", + "line": 1023, + "self_seconds": 0.000176539 + }, + { + "calls": 110, + "cumulative_seconds": 0.30978875100000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique", + "line": 307, + "self_seconds": 0.001282876 + }, + { + "calls": 64, + "cumulative_seconds": 0.302189539, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "f", + "line": 6947, + "self_seconds": 0.000159285 + }, + { + "calls": 64, + "cumulative_seconds": 0.301689209, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize", + "line": 610, + "self_seconds": 0.004825673 + }, + { + "calls": 250, + "cumulative_seconds": 0.298303337, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "dropna", + "line": 5839, + "self_seconds": 0.0012115300000000002 + }, + { + "calls": 475, + "cumulative_seconds": 0.29367550400000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__getitem__", + "line": 1107, + "self_seconds": 0.007598058 + }, + { + "calls": 50956, + "cumulative_seconds": 0.29149721500000003, + "file": "/Users/wilson/.local/share/uv/python/cpython-3.12.13-macos-aarch64-none/lib/python3.12/re/__init__.py", + "function": "split", + "line": 199, + "self_seconds": 0.044267203000000005 + }, + { + "calls": 64, + "cumulative_seconds": 0.286983419, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize_array", + "line": 548, + "self_seconds": 0.26930192000000003 + }, + { + "calls": 294911, + "cumulative_seconds": 0.286887535, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.286887535 + }, + { + "calls": 64, + "cumulative_seconds": 0.28631674500000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 0.000175285 + }, + { + "calls": 64, + "cumulative_seconds": 0.283056705, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "nunique", + "line": 1032, + "self_seconds": 0.002320789 + }, + { + "calls": 66, + "cumulative_seconds": 0.26911391900000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/_mixins.py", + "function": "unique", + "line": 223, + "self_seconds": 0.00018979600000000002 + } + ], + "operations": { + "dataframe.astype": 0, + "dataframe.copy": 2, + "dataframe.corr": 1, + "dataframe.corrwith": 0, + "series.astype": 108, + "series.copy": 59, + "series.isna": 121, + "series.notna": 209, + "series.nunique": 64, + "series.value_counts": 75 + }, + "stages": { + "audit_events": 0.00019499600000000001, + "backend_conversion": 2.0000000000000003e-06, + "context": 0.014090450000000001, + "correlation": 0.028226627, + "dtype_repair": 0.262841741, + "duplicates": 0.038172039000000005, + "engine_cache": 2.1084e-05, + "missing": 0.0026841760000000004, + "outliers": 0.002835919, + "report_finalization": 0.0014145890000000002, + "role_inference": 0.013307757, + "semantic_ml": 2.8850076779999996, + "total": 22.015065379999978 + } + }, + "report_fingerprint": "80c2e8b074179d61bb7436b41cd9ea3efa8b917877d2528ecb4e438a9b49cafa", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 4.196305540999674, + 4.1976765420004085, + 4.139537583001584, + 4.132623542000147, + 4.147246458000154 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0317513436284016, + "throughput_rows_per_second": 24112.384207863317 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.0847620504076558, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-kyndmnei/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-kyndmnei/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.25655552336258525, + "max_seconds": 2.2722922079992713, + "median_seconds": 1.907962375000352, + "min_seconds": 1.8902306250020047, + "output_fingerprint": "2c1a8aa93526335f73567718c764615e8d441132a5f0faac9b5302ceee688dc2", + "peak_python_bytes": 99243155, + "peak_rss_bytes": 19120128, + "profile": null, + "report_fingerprint": "faebe9a7f90c9de6a7caf477a8004a014d4f8ee7c360b22fca08bc25e4b9ac0f", + "result_type": "CleanResult", + "samples_seconds": [ + 1.907962375000352, + 1.8902306250020047, + 1.899321000000782, + 1.9849159170007624, + 2.2722922079992713 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.16172280300569053, + "throughput_rows_per_second": 52411.935009977096 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.07966895102678448, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_2qwkrp5/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_2qwkrp5/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 74526277, + "input_to_peak_ratio": 0.19961646547834397, + "max_seconds": 2.2563243330005207, + "median_seconds": 1.9311902500012366, + "min_seconds": 1.8814793749988894, + "output_fingerprint": "2c1a8aa93526335f73567718c764615e8d441132a5f0faac9b5302ceee688dc2", + "peak_python_bytes": 99241808, + "peak_rss_bytes": 14876672, + "profile": null, + "report_fingerprint": "faebe9a7f90c9de6a7caf477a8004a014d4f8ee7c360b22fca08bc25e4b9ac0f", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.8981483749994368, + 1.8814793749988894, + 1.9311902500012366, + 1.9806825000014214, + 2.2563243330005207 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.1538559014507522, + "throughput_rows_per_second": 51781.53731872661 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "nullable", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.035403868395932236, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3wt9l572/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3wt9l572/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 28000132, + "input_to_peak_ratio": 1.2030480427735126, + "max_seconds": 1.5839122079996741, + "median_seconds": 1.48124870799802, + "min_seconds": 1.4440434170028311, + "output_fingerprint": "3adb72561ca974ca90e87e6a9c18538ea45ac6e8f081ad48ea6748af284a4f64", + "peak_python_bytes": 85534942, + "peak_rss_bytes": 33685504, + "profile": null, + "report_fingerprint": "7ea0386a093d35705ea051a00940249444cf694f883b9031022710dccc4fdba3", + "result_type": "CleanResult", + "samples_seconds": [ + 1.4440434170028311, + 1.48124870799802, + 1.4891850000021805, + 1.4783752500006813, + 1.5839122079996741 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.052441934319606566, + "throughput_rows_per_second": 67510.60740849852 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "nullable", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.03514981915666, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7vsj5k8x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7vsj5k8x/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 28000132, + "input_to_peak_ratio": 0.10064409696354289, + "max_seconds": 1.6324488749996817, + "median_seconds": 1.5610541670030216, + "min_seconds": 1.5083517500024755, + "output_fingerprint": "3adb72561ca974ca90e87e6a9c18538ea45ac6e8f081ad48ea6748af284a4f64", + "peak_python_bytes": 85531958, + "peak_rss_bytes": 2818048, + "profile": null, + "report_fingerprint": "7ea0386a093d35705ea051a00940249444cf694f883b9031022710dccc4fdba3", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.5083517500024755, + 1.5231765839998843, + 1.5610541670030216, + 1.6324488749996817, + 1.6156902090006042 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.05487077166390673, + "throughput_rows_per_second": 64059.27616975923 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "numeric", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.006620175274227855, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g9qfvced/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-g9qfvced/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 25000132, + "input_to_peak_ratio": 0.15204271721445312, + "max_seconds": 1.12197095800002, + "median_seconds": 1.1120339170010993, + "min_seconds": 1.1049215420025575, + "output_fingerprint": "141b1979385f2e5bc1248055c74f7c38086170ec32946f1e5c66a1bb1cf6145f", + "peak_python_bytes": 79581971, + "peak_rss_bytes": 3801088, + "profile": null, + "report_fingerprint": "024b8e02cbc62bdbcdac8054e3f65f8bb6402e4322f02093e03c9f89eed7e733", + "result_type": "CleanResult", + "samples_seconds": [ + 1.1049215420025575, + 1.1120339170010993, + 1.1182710840002983, + 1.1064664170007745, + 1.12197095800002 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.007361859441433428, + "throughput_rows_per_second": 89925.31475089994 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "numeric", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.006316291498006147, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7kbxkur4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-7kbxkur4/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 25000132, + "input_to_peak_ratio": 0.030801757366721104, + "max_seconds": 1.1243908329997794, + "median_seconds": 1.1152514169989445, + "min_seconds": 1.1078520419978304, + "output_fingerprint": "141b1979385f2e5bc1248055c74f7c38086170ec32946f1e5c66a1bb1cf6145f", + "peak_python_bytes": 79582222, + "peak_rss_bytes": 770048, + "profile": null, + "report_fingerprint": "024b8e02cbc62bdbcdac8054e3f65f8bb6402e4322f02093e03c9f89eed7e733", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.1078520419978304, + 1.1145895410008961, + 1.1241854590007279, + 1.1243908329997794, + 1.1152514169989445 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.007044253043329741, + "throughput_rows_per_second": 89665.88024527446 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "string", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.004840691709661202, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gc406ib9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gc406ib9/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 181534402, + "input_to_peak_ratio": 0.06299650024462031, + "max_seconds": 5.265374208000139, + "median_seconds": 5.240585457999259, + "min_seconds": 5.202170083000965, + "output_fingerprint": "0282386c2676861387e325779adb657240580751aaf29f330f7f7d02db66629c", + "peak_python_bytes": 72255611, + "peak_rss_bytes": 11436032, + "profile": null, + "report_fingerprint": "d52c458ff2cfa8e96889b2a0685fa8321e6cc3eb2f17c10563cfee2610e490ee", + "result_type": "CleanResult", + "samples_seconds": [ + 5.240585457999259, + 5.254305292000936, + 5.221383167001477, + 5.202170083000965, + 5.265374208000139 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.025368058580308064, + "throughput_rows_per_second": 19081.837478169437 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "string", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.019127034094258623, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-do203r6b/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-do203r6b/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 181534402, + "input_to_peak_ratio": 0.056317788184302386, + "max_seconds": 6.512762542002747, + "median_seconds": 6.391551666998566, + "min_seconds": 6.248878250000416, + "output_fingerprint": "0282386c2676861387e325779adb657240580751aaf29f330f7f7d02db66629c", + "peak_python_bytes": 72255428, + "peak_rss_bytes": 10223616, + "profile": null, + "report_fingerprint": "d52c458ff2cfa8e96889b2a0685fa8321e6cc3eb2f17c10563cfee2610e490ee", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 6.248878250000416, + 6.2548988749986165, + 6.391551666998566, + 6.512762542002747, + 6.476069167001697 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.12225142664989712, + "throughput_rows_per_second": 15645.653076126879 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0027514762383349244, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-vrmo8_xr/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-vrmo8_xr/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 2.007147389470577, + "max_seconds": 0.47011025000028894, + "median_seconds": 0.4674464999989141, + "min_seconds": 0.4669450830006099, + "output_fingerprint": "c87410ddde6ca1aeea6eb2b11970d8c06bcfaa9089fa34c3e057ecd6ef289cf0", + "peak_python_bytes": 30237437, + "peak_rss_bytes": 32489472, + "profile": null, + "report_fingerprint": "2f83c01cc1474d09518454800d90918c8521fe7a023f1cdced0d7b56df7f823e", + "result_type": "CleanResult", + "samples_seconds": [ + 0.47011025000028894, + 0.46714212499864516, + 0.4669450830006099, + 0.4674464999989141, + 0.4676865830006136 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0012861679374398384, + "throughput_rows_per_second": 213928.22494174694 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.00866844454533827, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0o7maroj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0o7maroj/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 1.2024665147206484, + "max_seconds": 0.4809479169998667, + "median_seconds": 0.4773198750008305, + "min_seconds": 0.4711247499981255, + "output_fingerprint": "c87410ddde6ca1aeea6eb2b11970d8c06bcfaa9089fa34c3e057ecd6ef289cf0", + "peak_python_bytes": 30237329, + "peak_rss_bytes": 19464192, + "profile": null, + "report_fingerprint": "2f83c01cc1474d09518454800d90918c8521fe7a023f1cdced0d7b56df7f823e", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.4773198750008305, + 0.47863316599978134, + 0.4711247499981255, + 0.4725897500029532, + 0.4809479169998667 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0041376208668324945, + "throughput_rows_per_second": 209503.11360872205 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.005423731768929832, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6h0tex80/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6h0tex80/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 1.2965989944083758, + "max_seconds": 0.6751881249983853, + "median_seconds": 0.671313957998791, + "min_seconds": 0.6658267080019868, + "output_fingerprint": "33cba463959526ce80a93c5077186fed751a0228fa504502ca9224c270ef61d3", + "peak_python_bytes": 30237390, + "peak_rss_bytes": 20987904, + "profile": null, + "report_fingerprint": "e42b93e4219f9bab05d5eb7c677b04296e75cbcd8acc0b3275950d901d146f30", + "result_type": "CleanResult", + "samples_seconds": [ + 0.6712919589990634, + 0.6741795410016493, + 0.6751881249983853, + 0.671313957998791, + 0.6658267080019868 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00364102684092407, + "throughput_rows_per_second": 148961.59808460306 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.003870768747192894, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5b5z35kz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-5b5z35kz/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 1.7085551151923015, + "max_seconds": 0.6704924999976356, + "median_seconds": 0.6698622910007543, + "min_seconds": 0.6652802500029793, + "output_fingerprint": "33cba463959526ce80a93c5077186fed751a0228fa504502ca9224c270ef61d3", + "peak_python_bytes": 30237037, + "peak_rss_bytes": 27656192, + "profile": null, + "report_fingerprint": "e42b93e4219f9bab05d5eb7c677b04296e75cbcd8acc0b3275950d901d146f30", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.6699140420023468, + 0.6654777500007185, + 0.6652802500029793, + 0.6704924999976356, + 0.6698622910007543 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0025928820209287517, + "throughput_rows_per_second": 149284.414637825 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.005293887570812425, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-p3db69s_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-p3db69s_/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 1.8705034673432306, + "max_seconds": 0.5072498750014347, + "median_seconds": 0.5051155840010324, + "min_seconds": 0.5008217920003517, + "output_fingerprint": "d2d3e55bc7020bffe00fbea92f485f42f330b027d6c62b218d08d84df5c00c08", + "peak_python_bytes": 30237724, + "peak_rss_bytes": 30277632, + "profile": null, + "report_fingerprint": "6f12e63c3c197db93ef2383f1a07b5777795ab84ca986bc3fffd09fc637c573e", + "result_type": "CleanResult", + "samples_seconds": [ + 0.5072498750014347, + 0.5051155840010324, + 0.5016803329999675, + 0.505146125000465, + 0.5008217920003517 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0026740251119667245, + "throughput_rows_per_second": 197974.48973539413 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.007503142040851069, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zxw4_spm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zxw4_spm/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 2.062817135522459, + "max_seconds": 0.5021142919977137, + "median_seconds": 0.5006852919977973, + "min_seconds": 0.49356724999961443, + "output_fingerprint": "d2d3e55bc7020bffe00fbea92f485f42f330b027d6c62b218d08d84df5c00c08", + "peak_python_bytes": 30237382, + "peak_rss_bytes": 33390592, + "profile": null, + "report_fingerprint": "6f12e63c3c197db93ef2383f1a07b5777795ab84ca986bc3fffd09fc637c573e", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.5021142919977137, + 0.5006852919977973, + 0.501970249999431, + 0.49663874999896507, + 0.49356724999961443 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0037567128636244664, + "throughput_rows_per_second": 199726.2583867551 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.025933440436215018, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-t9v9c099/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-t9v9c099/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.07894982167357792, + "max_seconds": 0.08781437499783351, + "median_seconds": 0.08303041599720018, + "min_seconds": 0.08268891699844971, + "output_fingerprint": "d89cb5caa99da1fd524b345029afc07b6a27fbdba2c870f3b2cf5b6b9a8eba9a", + "peak_python_bytes": 1706414, + "peak_rss_bytes": 1277952, + "profile": null, + "report_fingerprint": "a0c364a6205bf393b25ad9b32c6d0bcca26cd7d3f566aa98e93671c214eede62", + "result_type": "CleanResult", + "samples_seconds": [ + 0.08371850000185077, + 0.08268891699844971, + 0.08781437499783351, + 0.08303041599720018, + 0.0828767089988105 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0021532643476575453, + "throughput_rows_per_second": 1204377.9234271455 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0026352637480900093, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0wcjge2n/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0wcjge2n/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.014170480813206293, + "max_seconds": 0.08342704200185835, + "median_seconds": 0.08315979200051515, + "min_seconds": 0.08282887500172365, + "output_fingerprint": "d89cb5caa99da1fd524b345029afc07b6a27fbdba2c870f3b2cf5b6b9a8eba9a", + "peak_python_bytes": 1706322, + "peak_rss_bytes": 229376, + "profile": null, + "report_fingerprint": "a0c364a6205bf393b25ad9b32c6d0bcca26cd7d3f566aa98e93671c214eede62", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.08314791600059834, + 0.08315979200051515, + 0.08282887500172365, + 0.0832657079990895, + 0.08342704200185835 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00021914798515766315, + "throughput_rows_per_second": 1202504.2102002916 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.002782532165178023, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ru43bw23/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ru43bw23/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.9625805180970847, + "max_seconds": 0.4733874999983527, + "median_seconds": 0.4726132089999737, + "min_seconds": 0.4701138329983223, + "output_fingerprint": "c87410ddde6ca1aeea6eb2b11970d8c06bcfaa9089fa34c3e057ecd6ef289cf0", + "peak_python_bytes": 30237539, + "peak_rss_bytes": 15581184, + "profile": null, + "report_fingerprint": "2f83c01cc1474d09518454800d90918c8521fe7a023f1cdced0d7b56df7f823e", + "result_type": "CleanResult", + "samples_seconds": [ + 0.4701138329983223, + 0.47320883399879676, + 0.4726132089999737, + 0.4725408750018687, + 0.4733874999983527 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0013150614557304304, + "throughput_rows_per_second": 211589.5156878816 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.004792318971178411, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bkaat7mk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bkaat7mk/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 16186889, + "input_to_peak_ratio": 0.8067052291518154, + "max_seconds": 0.472932792003121, + "median_seconds": 0.469075500001054, + "min_seconds": 0.46724458300013794, + "output_fingerprint": "c87410ddde6ca1aeea6eb2b11970d8c06bcfaa9089fa34c3e057ecd6ef289cf0", + "peak_python_bytes": 30237292, + "peak_rss_bytes": 13058048, + "profile": null, + "report_fingerprint": "2f83c01cc1474d09518454800d90918c8521fe7a023f1cdced0d7b56df7f823e", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.46724458300013794, + 0.46763895800177124, + 0.472932792003121, + 0.469075500001054, + 0.4691389170002367 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00224795941757005, + "throughput_rows_per_second": 213185.29746229615 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.008672703178497061, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eazaesl3/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eazaesl3/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.27777492697364814, + "max_seconds": 8.860477624999476, + "median_seconds": 8.713747707999573, + "min_seconds": 8.670245875000546, + "output_fingerprint": "717d397e6f12c8b3f4d202befbb1220783d4390866e60656246b31ee7edf1097", + "peak_python_bytes": 365748967, + "peak_rss_bytes": 85966848, + "profile": null, + "report_fingerprint": "2460e7137c328e0f2cc50d5d8c47d88ab760f4811294d2eb495fb2e79a0b5c8c", + "result_type": "CleanResult", + "samples_seconds": [ + 8.688427875000343, + 8.713747707999573, + 8.670245875000546, + 8.860477624999476, + 8.752544707997004 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.07557174744378937, + "throughput_rows_per_second": 11476.118353552507 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.004132202667571682, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fj5psnoh/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fj5psnoh/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.0559573275797877, + "max_seconds": 7.7447995000002265, + "median_seconds": 7.73402866700053, + "min_seconds": 7.665851292000298, + "output_fingerprint": "717d397e6f12c8b3f4d202befbb1220783d4390866e60656246b31ee7edf1097", + "peak_python_bytes": 365747472, + "peak_rss_bytes": 17317888, + "profile": null, + "report_fingerprint": "2460e7137c328e0f2cc50d5d8c47d88ab760f4811294d2eb495fb2e79a0b5c8c", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 7.709627166001155, + 7.665851292000298, + 7.7447995000002265, + 7.735907750000479, + 7.73402866700053 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.031958573888855445, + "throughput_rows_per_second": 12929.87190837279 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.010326788933571996, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i83j742j/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i83j742j/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.05405149617688102, + "max_seconds": 13.371584374999657, + "median_seconds": 13.121143207998102, + "min_seconds": 13.021956583001156, + "output_fingerprint": "df4834dd7d5767cfadb07823b437e0066f69ac5d65c72c7882f45a11f6603d9f", + "peak_python_bytes": 365746812, + "peak_rss_bytes": 16728064, + "profile": null, + "report_fingerprint": "d96aafff7dab94fa6e6a57a07e585534ef1b76d208b455ac33acb173d36c642c", + "result_type": "CleanResult", + "samples_seconds": [ + 13.021956583001156, + 13.371584374999657, + 13.068178792000253, + 13.121143207998102, + 13.1705012909988 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.13549927647616816, + "throughput_rows_per_second": 7621.287140517159 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.05011083499509269, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eudiegfa/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-eudiegfa/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.269569263988911, + "max_seconds": 13.079680832997838, + "median_seconds": 12.392670375000307, + "min_seconds": 11.614476584003569, + "output_fingerprint": "df4834dd7d5767cfadb07823b437e0066f69ac5d65c72c7882f45a11f6603d9f", + "peak_python_bytes": 365751115, + "peak_rss_bytes": 83427328, + "profile": null, + "report_fingerprint": "d96aafff7dab94fa6e6a57a07e585534ef1b76d208b455ac33acb173d36c642c", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 11.619644958002027, + 11.614476584003569, + 12.392670375000307, + 12.4368489160006, + 13.079680832997838 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.6210070603102138, + "throughput_rows_per_second": 8069.285874151036 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.004830608058975526, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3uzf4yau/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-3uzf4yau/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.49191626099469, + "max_seconds": 8.125112999998237, + "median_seconds": 8.065699833001418, + "min_seconds": 8.032096083999932, + "output_fingerprint": "ceb3cdb09b542e13bc283c5cb33e1b6413c14ed79a7325476f35dc46c9e38306", + "peak_python_bytes": 365749618, + "peak_rss_bytes": 152240128, + "profile": null, + "report_fingerprint": "925829282ef78498b9502fc27b170a044d9d28597182ac4f3485a2627a1d70ee", + "result_type": "CleanResult", + "samples_seconds": [ + 8.065699833001418, + 8.089005666999583, + 8.125112999998237, + 8.035068832999968, + 8.032096083999932 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0389622346145742, + "throughput_rows_per_second": 12398.180203885406 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.004617392372655126, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-izm1t_jk/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-izm1t_jk/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.41478302893816144, + "max_seconds": 8.028345207996608, + "median_seconds": 7.975000458001887, + "min_seconds": 7.944215416999214, + "output_fingerprint": "ceb3cdb09b542e13bc283c5cb33e1b6413c14ed79a7325476f35dc46c9e38306", + "peak_python_bytes": 365749713, + "peak_rss_bytes": 128368640, + "profile": null, + "report_fingerprint": "925829282ef78498b9502fc27b170a044d9d28597182ac4f3485a2627a1d70ee", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 7.975000458001887, + 8.028345207996608, + 8.008253582996986, + 7.944215416999214, + 7.948587250000855 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.03682370628669905, + "throughput_rows_per_second": 12539.184232856422 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0037696334415226857, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-blvv_jiv/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-blvv_jiv/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.002064650686482233, + "max_seconds": 1.696691875000397, + "median_seconds": 1.6874468749992957, + "min_seconds": 1.6820166659999813, + "output_fingerprint": "69e094d9ff94ed432868dc6689efada583524c268dc18126540c022129b72bcb", + "peak_python_bytes": 13989929, + "peak_rss_bytes": 638976, + "profile": null, + "report_fingerprint": "9d2255d3fed3ada0da7a59d535c9dffba7822121b3454710c9d1b43c2ff922e8", + "result_type": "CleanResult", + "samples_seconds": [ + 1.6874468749992957, + 1.692177457996877, + 1.6822712089997367, + 1.696691875000397, + 1.6820166659999813 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.006361056170790296, + "throughput_rows_per_second": 59261.124887289705 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.006466195738142221, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_l79249g/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_l79249g/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.0034940242386622402, + "max_seconds": 1.7263701250012673, + "median_seconds": 1.7102836660014873, + "min_seconds": 1.6990656669986492, + "output_fingerprint": "69e094d9ff94ed432868dc6689efada583524c268dc18126540c022129b72bcb", + "peak_python_bytes": 13990064, + "peak_rss_bytes": 1081344, + "profile": null, + "report_fingerprint": "9d2255d3fed3ada0da7a59d535c9dffba7822121b3454710c9d1b43c2ff922e8", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.6990656669986492, + 1.7030990410021332, + 1.7102836660014873, + 1.7179442499982542, + 1.7263701250012673 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.011059028952113071, + "throughput_rows_per_second": 58469.83280486586 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.005943928034187714, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-acfhxjob/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-acfhxjob/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.058074918027461786, + "max_seconds": 7.694962666999345, + "median_seconds": 7.652957540998614, + "min_seconds": 7.5997409999981755, + "output_fingerprint": "717d397e6f12c8b3f4d202befbb1220783d4390866e60656246b31ee7edf1097", + "peak_python_bytes": 365747533, + "peak_rss_bytes": 17973248, + "profile": null, + "report_fingerprint": "2460e7137c328e0f2cc50d5d8c47d88ab760f4811294d2eb495fb2e79a0b5c8c", + "result_type": "CleanResult", + "samples_seconds": [ + 7.694962666999345, + 7.685732541998732, + 7.5997409999981755, + 7.600012375001825, + 7.652957540998614 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.04548862887238993, + "throughput_rows_per_second": 13066.843695953823 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 100000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.020245036186760743, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-hlfudhnw/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-hlfudhnw/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 309483829, + "input_to_peak_ratio": 0.1416668009493963, + "max_seconds": 7.938532916999975, + "median_seconds": 7.658192708997376, + "min_seconds": 7.645834791001107, + "output_fingerprint": "717d397e6f12c8b3f4d202befbb1220783d4390866e60656246b31ee7edf1097", + "peak_python_bytes": 365749373, + "peak_rss_bytes": 43843584, + "profile": null, + "report_fingerprint": "2460e7137c328e0f2cc50d5d8c47d88ab760f4811294d2eb495fb2e79a0b5c8c", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 7.938532916999975, + 7.928764000000228, + 7.658192708997376, + 7.645834791001107, + 7.648315083002672 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.15504038851883917, + "throughput_rows_per_second": 13057.91115474452 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.013073737202584885, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-pergwrsg/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-pergwrsg/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.16727282564036747, + "max_seconds": 10.238534292000054, + "median_seconds": 9.955645624999988, + "min_seconds": 9.92209287500009, + "output_fingerprint": "0ecc5b0b8d231b513bdbea1cd8b6b1bdf36eaf0b52567385490245c2fc4a4995", + "peak_python_bytes": 493275386, + "peak_rss_bytes": 62701568, + "profile": null, + "report_fingerprint": "8168b7c9c6b54cea1182ce61b55d4c966d5c9aea47e9e5964013dc1e6d4112f4", + "result_type": "CleanResult", + "samples_seconds": [ + 10.238534292000054, + 9.955645624999988, + 10.031597917, + 9.92209287500009, + 9.94146595799998 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.1301574945833138, + "throughput_rows_per_second": 50222.75991267021 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.005853820949706254, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qpv00l7x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qpv00l7x/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.16928342140191877, + "max_seconds": 9.937385000000063, + "median_seconds": 9.827179957999988, + "min_seconds": 9.785204125000064, + "output_fingerprint": "0ecc5b0b8d231b513bdbea1cd8b6b1bdf36eaf0b52567385490245c2fc4a4995", + "peak_python_bytes": 493275579, + "peak_rss_bytes": 63455232, + "profile": null, + "report_fingerprint": "8168b7c9c6b54cea1182ce61b55d4c966d5c9aea47e9e5964013dc1e6d4112f4", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 9.827179957999988, + 9.937385000000063, + 9.785204125000064, + 9.851792292000027, + 9.817238875000044 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.05752655191467375, + "throughput_rows_per_second": 50879.296210808294 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.022992845465006836, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r75lh8th/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-r75lh8th/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.15791918448880263, + "max_seconds": 20.978991207999968, + "median_seconds": 20.53909945800001, + "min_seconds": 19.75522295799999, + "output_fingerprint": "40cdd77056b0b9018871b0b44470924fb23294a497f926360a049273d718d6a1", + "peak_python_bytes": 493276134, + "peak_rss_bytes": 59195392, + "profile": { + "allocations": [ + { + "bytes": 1432, + "count": 22, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 58 + }, + { + "bytes": 1065, + "count": 17, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 199 + }, + { + "bytes": 531, + "count": 8, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 24 + }, + { + "bytes": 516, + "count": 8, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 119 + }, + { + "bytes": 495, + "count": 8, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 209 + }, + { + "bytes": 480, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 104 + }, + { + "bytes": 475, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 309 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 93 + }, + { + "bytes": 432, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 154 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 74 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 187 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 101 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 424 + }, + { + "bytes": 360, + "count": 3, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 67 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 184 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 75 + }, + { + "bytes": 312, + "count": 2, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 198 + }, + { + "bytes": 299, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 362 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 90 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 32 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 152 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 70 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 63 + }, + { + "bytes": 279, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 280 + }, + { + "bytes": 273, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 78 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 110 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 35 + }, + { + "bytes": 265, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 444 + }, + { + "bytes": 264, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 25 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 464 + }, + { + "bytes": 259, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 194 + }, + { + "bytes": 254, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 124 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 355 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 116 + }, + { + "bytes": 220, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 126 + }, + { + "bytes": 218, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 452 + }, + { + "bytes": 217, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 185 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 94 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 55 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 30 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 39 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 11 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 132 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 123 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 116 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 59 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/missing.py", + "line": 48 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/memory.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 70 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 332 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 297 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 257 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 195 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 179 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 133 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 101 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 62 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 29 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 18 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/result.py", + "line": 25 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 223 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 61 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/utils.py", + "line": 6 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 263 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 163 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 68 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 159 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 86 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 73 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 53 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 525 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 499 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 432 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 272 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 152 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 142 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 282 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 231 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 219 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 210 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 199 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 168 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 118 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 109 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 92 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 79 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 72 + } + ], + "functions": [ + { + "calls": 1, + "cumulative_seconds": 49.320249083, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "function": "clean", + "line": 138, + "self_seconds": 6.966700000000001e-05 + }, + { + "calls": 1, + "cumulative_seconds": 49.31871825, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "clean", + "line": 189, + "self_seconds": 9.270800000000001e-05 + }, + { + "calls": 1, + "cumulative_seconds": 49.31862554200001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.002237212 + }, + { + "calls": 1, + "cumulative_seconds": 18.035868375, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "drop_duplicate_rows", + "line": 83, + "self_seconds": 0.01036125 + }, + { + "calls": 50, + "cumulative_seconds": 17.409678047, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "wrapper", + "line": 132, + "self_seconds": 0.000190213 + }, + { + "calls": 50, + "cumulative_seconds": 17.382764249, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map", + "line": 431, + "self_seconds": 0.012622194000000002 + }, + { + "calls": 40, + "cumulative_seconds": 16.647219296, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map_str_or_object", + "line": 486, + "self_seconds": 5.671468521 + }, + { + "calls": 1, + "cumulative_seconds": 16.228058167, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "_filter_rows", + "line": 70, + "self_seconds": 0.196458333 + }, + { + "calls": 396, + "cumulative_seconds": 16.063375342, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "function": "observed", + "line": 58, + "self_seconds": 0.011010212 + }, + { + "calls": 1, + "cumulative_seconds": 13.255702167, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.012875084 + }, + { + "calls": 10, + "cumulative_seconds": 13.241731042000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.011268752 + }, + { + "calls": 395, + "cumulative_seconds": 12.524052916, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "apply", + "line": 317, + "self_seconds": 0.010300682 + }, + { + "calls": 20, + "cumulative_seconds": 12.206771375, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "strip", + "line": 2141, + "self_seconds": 0.00011470100000000001 + }, + { + "calls": 20, + "cumulative_seconds": 12.197287168, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_strip", + "line": 487, + "self_seconds": 0.000747377 + }, + { + "calls": 78, + "cumulative_seconds": 11.893313038, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "astype", + "line": 6485, + "self_seconds": 0.0019122260000000002 + }, + { + "calls": 78, + "cumulative_seconds": 11.878515368, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "astype", + "line": 440, + "self_seconds": 0.00024823900000000003 + }, + { + "calls": 78, + "cumulative_seconds": 11.875209461, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "astype", + "line": 749, + "self_seconds": 0.000798001 + }, + { + "calls": 78, + "cumulative_seconds": 11.872711373000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array_safe", + "line": 191, + "self_seconds": 0.00047215600000000005 + }, + { + "calls": 78, + "cumulative_seconds": 11.865921585, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array", + "line": 157, + "self_seconds": 0.017356969 + }, + { + "calls": 41, + "cumulative_seconds": 11.839967584, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "_astype_nansafe", + "line": 56, + "self_seconds": 0.00018162200000000002 + }, + { + "calls": 26, + "cumulative_seconds": 11.650625417, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", + "function": "_from_sequence", + "line": 151, + "self_seconds": 0.000149004 + }, + { + "calls": 26, + "cumulative_seconds": 11.649836663, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_array", + "line": 266, + "self_seconds": 6.9954e-05 + }, + { + "calls": 26, + "cumulative_seconds": 11.649766709000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_data_and_mask", + "line": 135, + "self_seconds": 11.616318503 + }, + { + "calls": 1, + "cumulative_seconds": 11.025271666, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "clean_strings", + "line": 94, + "self_seconds": 0.013249414000000001 + }, + { + "calls": 10, + "cumulative_seconds": 11.009892418000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "normalize_text", + "line": 55, + "self_seconds": 0.907737749 + }, + { + "calls": 9909090, + "cumulative_seconds": 10.745545156, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 488, + "self_seconds": 5.5733656730000005 + }, + { + "calls": 10, + "cumulative_seconds": 9.978590542000001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 8.249900000000001e-05 + }, + { + "calls": 10, + "cumulative_seconds": 9.866028666, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_relative_date_word", + "line": 195, + "self_seconds": 0.886624001 + }, + { + "calls": 10, + "cumulative_seconds": 6.084012878, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "_strip_series", + "line": 30, + "self_seconds": 4.6878e-05 + }, + { + "calls": 9909154, + "cumulative_seconds": 5.172223152, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 5.172223152 + }, + { + "calls": 20, + "cumulative_seconds": 5.022663917, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "casefold", + "line": 3249, + "self_seconds": 0.00010504000000000001 + }, + { + "calls": 20, + "cumulative_seconds": 5.012875876000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_casefold", + "line": 471, + "self_seconds": 0.002037624 + }, + { + "calls": 1, + "cumulative_seconds": 4.703654292, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.8916e-05 + }, + { + "calls": 1, + "cumulative_seconds": 4.5299393750000005, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0030278740000000003 + }, + { + "calls": 32, + "cumulative_seconds": 4.526873751, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.023565909000000003 + }, + { + "calls": 55, + "cumulative_seconds": 3.0854002890000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "to_numpy", + "line": 545, + "self_seconds": 0.00155246 + }, + { + "calls": 6, + "cumulative_seconds": 2.915014669, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "to_numpy", + "line": 539, + "self_seconds": 0.011464876 + }, + { + "calls": 2055, + "cumulative_seconds": 2.9014158830000003, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.004455461 + }, + { + "calls": 22, + "cumulative_seconds": 2.8746556680000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__array__", + "line": 640, + "self_seconds": 0.00010379200000000001 + }, + { + "calls": 22, + "cumulative_seconds": 2.874527332, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py", + "function": "__array__", + "line": 356, + "self_seconds": 0.489315192 + }, + { + "calls": 10, + "cumulative_seconds": 2.7705007910000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.000450373 + }, + { + "calls": 1196, + "cumulative_seconds": 2.713398658, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "isna", + "line": 101, + "self_seconds": 0.0006714430000000001 + }, + { + "calls": 32, + "cumulative_seconds": 2.712853918, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000633964 + }, + { + "calls": 1196, + "cumulative_seconds": 2.7128342250000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna", + "line": 184, + "self_seconds": 0.006206119 + }, + { + "calls": 856, + "cumulative_seconds": 2.633024284, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_array", + "line": 261, + "self_seconds": 0.019048709 + }, + { + "calls": 208, + "cumulative_seconds": 2.6022901710000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_string_dtype", + "line": 305, + "self_seconds": 2.6022901710000004 + }, + { + "calls": 32, + "cumulative_seconds": 2.545509259, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "value_counts", + "line": 927, + "self_seconds": 0.005398632 + }, + { + "calls": 53, + "cumulative_seconds": 2.5401106270000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_internal", + "line": 862, + "self_seconds": 0.010464503 + }, + { + "calls": 192, + "cumulative_seconds": 2.465957173, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numpy_.py", + "function": "isna", + "line": 237, + "self_seconds": 0.000173837 + }, + { + "calls": 500001, + "cumulative_seconds": 2.32700868, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__iter__", + "line": 647, + "self_seconds": 2.326781844 + }, + { + "calls": 37, + "cumulative_seconds": 2.132885789, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_arraylike", + "line": 963, + "self_seconds": 2.128095586 + }, + { + "calls": 10, + "cumulative_seconds": 2.096425625, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 4.2249e-05 + }, + { + "calls": 10, + "cumulative_seconds": 2.096383376, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/tools/numeric.py", + "function": "to_numeric", + "line": 47, + "self_seconds": 2.091409456 + }, + { + "calls": 10, + "cumulative_seconds": 1.8545773360000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "value_counts", + "line": 1014, + "self_seconds": 0.021569335000000002 + }, + { + "calls": 2, + "cumulative_seconds": 1.796637625, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "duplicated", + "line": 6850, + "self_seconds": 0.029912042000000003 + }, + { + "calls": 64, + "cumulative_seconds": 1.487106709, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "f", + "line": 6947, + "self_seconds": 0.000267662 + }, + { + "calls": 64, + "cumulative_seconds": 1.486297629, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize", + "line": 610, + "self_seconds": 0.031436674000000005 + }, + { + "calls": 64, + "cumulative_seconds": 1.411166211, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize_array", + "line": 548, + "self_seconds": 1.338888762 + }, + { + "calls": 20, + "cumulative_seconds": 1.122679873, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "isin", + "line": 5505, + "self_seconds": 0.00041158000000000004 + }, + { + "calls": 30, + "cumulative_seconds": 1.110972042, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "factorize", + "line": 1428, + "self_seconds": 0.005093831 + }, + { + "calls": 40, + "cumulative_seconds": 1.095731707, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "isin", + "line": 457, + "self_seconds": 1.092146797 + }, + { + "calls": 20, + "cumulative_seconds": 1.093599457, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "isin", + "line": 825, + "self_seconds": 0.00033520200000000005 + }, + { + "calls": 3, + "cumulative_seconds": 1.035124376, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "__init__", + "line": 698, + "self_seconds": 0.000163962 + }, + { + "calls": 1, + "cumulative_seconds": 1.033991541, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "dict_to_mgr", + "line": 423, + "self_seconds": 0.00025709100000000004 + }, + { + "calls": 1, + "cumulative_seconds": 1.030811375, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "arrays_to_mgr", + "line": 96, + "self_seconds": 0.023742335 + }, + { + "calls": 2, + "cumulative_seconds": 0.944991958, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "function": "memory_bytes", + "line": 34, + "self_seconds": 0.004641407 + }, + { + "calls": 781, + "cumulative_seconds": 0.920640703, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/construction.py", + "function": "sanitize_array", + "line": 517, + "self_seconds": 0.025548898 + }, + { + "calls": 114, + "cumulative_seconds": 0.875397588, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/cast.py", + "function": "maybe_infer_to_datetimelike", + "line": 1166, + "self_seconds": 0.425818586 + }, + { + "calls": 42, + "cumulative_seconds": 0.8722860840000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "unique", + "line": 2356, + "self_seconds": 0.000137209 + }, + { + "calls": 42, + "cumulative_seconds": 0.872148875, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "unique", + "line": 1023, + "self_seconds": 0.000107497 + }, + { + "calls": 42, + "cumulative_seconds": 0.8594932510000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique_with_mask", + "line": 427, + "self_seconds": 0.7874160010000001 + }, + { + "calls": 1, + "cumulative_seconds": 0.8576353750000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "_homogenize", + "line": 596, + "self_seconds": 0.000313554 + }, + { + "calls": 342, + "cumulative_seconds": 0.857563128, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "notna", + "line": 380, + "self_seconds": 0.001502955 + }, + { + "calls": 36, + "cumulative_seconds": 0.851345082, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique", + "line": 307, + "self_seconds": 0.010484707000000001 + }, + { + "calls": 30, + "cumulative_seconds": 0.783089959, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/_mixins.py", + "function": "unique", + "line": 223, + "self_seconds": 0.000166627 + }, + { + "calls": 109, + "cumulative_seconds": 0.696813884, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "memory_usage", + "line": 5451, + "self_seconds": 0.000186342 + }, + { + "calls": 160, + "cumulative_seconds": 0.695466381, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "_memory_usage", + "line": 1139, + "self_seconds": 0.0004248 + }, + { + "calls": 60, + "cumulative_seconds": 0.69317108, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "memory_usage", + "line": 1025, + "self_seconds": 0.69317108 + }, + { + "calls": 32, + "cumulative_seconds": 0.671840666, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 0.000139624 + }, + { + "calls": 32, + "cumulative_seconds": 0.66332738, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "nunique", + "line": 1032, + "self_seconds": 0.007613254000000001 + }, + { + "calls": 12, + "cumulative_seconds": 0.609079626, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "missingness_is_informative", + "line": 168, + "self_seconds": 0.013052722000000001 + }, + { + "calls": 375, + "cumulative_seconds": 0.583604627, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "apply", + "line": 389, + "self_seconds": 0.0009499860000000001 + }, + { + "calls": 126, + "cumulative_seconds": 0.57908609, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "remove_na_arraylike", + "line": 718, + "self_seconds": 0.013389929 + }, + { + "calls": 4, + "cumulative_seconds": 0.5748578750000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "isna", + "line": 6510, + "self_seconds": 4.4918000000000006e-05 + }, + { + "calls": 4, + "cumulative_seconds": 0.5746737900000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", + "function": "isna", + "line": 176, + "self_seconds": 1.6247000000000002e-05 + }, + { + "calls": 51, + "cumulative_seconds": 0.565671417, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "sample", + "line": 5998, + "self_seconds": 0.0007694580000000001 + }, + { + "calls": 299, + "cumulative_seconds": 0.512347204, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__getitem__", + "line": 1107, + "self_seconds": 0.004214837 + }, + { + "calls": 120, + "cumulative_seconds": 0.49489607900000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "dropna", + "line": 5839, + "self_seconds": 0.0006939880000000001 + }, + { + "calls": 1, + "cumulative_seconds": 0.494854917, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.0005906230000000001 + }, + { + "calls": 145, + "cumulative_seconds": 0.486380957, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "notna", + "line": 5805, + "self_seconds": 0.00046374500000000005 + }, + { + "calls": 167, + "cumulative_seconds": 0.486161116, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "_get_rows_with_mask", + "line": 1228, + "self_seconds": 0.0006442440000000001 + }, + { + "calls": 145, + "cumulative_seconds": 0.48591721200000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "notna", + "line": 8787, + "self_seconds": 0.0035024950000000004 + }, + { + "calls": 167, + "cumulative_seconds": 0.47964833300000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "get_rows_with_mask", + "line": 1973, + "self_seconds": 0.11586616500000001 + }, + { + "calls": 11, + "cumulative_seconds": 0.449837042, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "_from_sequence_not_strict", + "line": 331, + "self_seconds": 0.00035679200000000004 + }, + { + "calls": 11, + "cumulative_seconds": 0.44849875100000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "_sequence_to_dt64", + "line": 2201, + "self_seconds": 0.006553627 + }, + { + "calls": 1, + "cumulative_seconds": 0.44786129100000005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/indexes/datetimes.py", + "function": "__new__", + "line": 320, + "self_seconds": 3.5917e-05 + }, + { + "calls": 1, + "cumulative_seconds": 0.44138083300000003, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "objects_to_datetime64", + "line": 2371, + "self_seconds": 0.44137816700000004 + }, + { + "calls": 127, + "cumulative_seconds": 0.438576334, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/ops/common.py", + "function": "new_method", + "line": 62, + "self_seconds": 0.00019557800000000002 + }, + { + "calls": 51, + "cumulative_seconds": 0.39621816600000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/sample.py", + "function": "sample", + "line": 117, + "self_seconds": 0.394263713 + }, + { + "calls": 10, + "cumulative_seconds": 0.392408959, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "ne", + "line": 6295, + "self_seconds": 2.4712e-05 + } + ], + "operations": { + "dataframe.astype": 0, + "dataframe.copy": 2, + "dataframe.corr": 1, + "dataframe.corrwith": 0, + "series.astype": 78, + "series.copy": 29, + "series.isna": 77, + "series.notna": 145, + "series.nunique": 32, + "series.value_counts": 32 + }, + "stages": { + "audit_events": 0.00020511900000000003, + "backend_conversion": 2.334e-06, + "context": 0.019573518, + "correlation": 0.140183376, + "dtype_repair": 1.0070139950000003, + "duplicates": 0.20682025, + "engine_cache": 1.8916e-05, + "missing": 0.005493373, + "outliers": 0.004022832999999999, + "report_finalization": 0.007008993000000001, + "role_inference": 0.036430956, + "semantic_ml": 0.0, + "total": 49.31941233199999 + } + }, + "report_fingerprint": "8caf2c9094b8c15ad8467da1cb3204e0435b29cdfe5380aff37edc96e7627f3d", + "result_type": "CleanResult", + "samples_seconds": [ + 19.75522295799999, + 20.750808249999977, + 20.978991207999968, + 20.272375834, + 20.53909945800001 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.47225233982819986, + "throughput_rows_per_second": 24343.81317556984 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.13054280309473704, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofttul9h/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ofttul9h/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.20298275470965937, + "max_seconds": 23.753260917000034, + "median_seconds": 19.411759749999987, + "min_seconds": 18.14284304199998, + "output_fingerprint": "40cdd77056b0b9018871b0b44470924fb23294a497f926360a049273d718d6a1", + "peak_python_bytes": 493276233, + "peak_rss_bytes": 76087296, + "profile": null, + "report_fingerprint": "8caf2c9094b8c15ad8467da1cb3204e0435b29cdfe5380aff37edc96e7627f3d", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 23.753260917000034, + 23.037869, + 19.056461958, + 18.14284304199998, + 19.411759749999987 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 2.5340655307665902, + "throughput_rows_per_second": 25757.5823335646 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.10273257513779269, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fxn1gzrg/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fxn1gzrg/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.162727130875121, + "max_seconds": 10.262564291999979, + "median_seconds": 8.363414832999979, + "min_seconds": 8.292244499999924, + "output_fingerprint": "08d92cc0df2176914a4c49b6a0ac8c94ac24c09ac95bb388b1384b21c9757dd3", + "peak_python_bytes": 493276323, + "peak_rss_bytes": 60997632, + "profile": null, + "report_fingerprint": "f2b0d00e61996dbc9676b8b0fc0bc37f54aa5852a8df6a813858941246032c37", + "result_type": "CleanResult", + "samples_seconds": [ + 10.262564291999979, + 8.292244499999924, + 8.341469666000194, + 8.373350332999962, + 8.363414832999979 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.8591951427397002, + "throughput_rows_per_second": 59784.19222099601 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.008212867320084109, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bguwaenp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bguwaenp/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.1630330910997049, + "max_seconds": 8.552026082999873, + "median_seconds": 8.49524504100009, + "min_seconds": 8.38571012500006, + "output_fingerprint": "08d92cc0df2176914a4c49b6a0ac8c94ac24c09ac95bb388b1384b21c9757dd3", + "peak_python_bytes": 493276191, + "peak_rss_bytes": 61112320, + "profile": null, + "report_fingerprint": "f2b0d00e61996dbc9676b8b0fc0bc37f54aa5852a8df6a813858941246032c37", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 8.49524504100009, + 8.549083458000041, + 8.552026082999873, + 8.38571012500006, + 8.454416833999858 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.06977032037333622, + "throughput_rows_per_second": 58856.45412073226 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.015725406578523473, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-94i3izmm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-94i3izmm/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.0006993376561917636, + "max_seconds": 0.8630100000000311, + "median_seconds": 0.8342449589999887, + "min_seconds": 0.8328852910000251, + "output_fingerprint": "a5a7275f2b3ce25f64a27b67abd4ce09b2744313366538e90d56e5a96056a8c8", + "peak_python_bytes": 18148537, + "peak_rss_bytes": 262144, + "profile": null, + "report_fingerprint": "846df8e54698f3ed59e36c04363d45fc94c6c74cd9464a145c22967a727a6bc9", + "result_type": "CleanResult", + "samples_seconds": [ + 0.8630100000000311, + 0.8328852910000251, + 0.8342449589999887, + 0.8329507500000091, + 0.8348658749999913 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.013118841166358468, + "throughput_rows_per_second": 599344.346772381 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.0016815300489540484, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-a77oq7oj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-a77oq7oj/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.0009615892772636749, + "max_seconds": 0.8299753339999825, + "median_seconds": 0.827675333000002, + "min_seconds": 0.8269629169999462, + "output_fingerprint": "a5a7275f2b3ce25f64a27b67abd4ce09b2744313366538e90d56e5a96056a8c8", + "peak_python_bytes": 18148582, + "peak_rss_bytes": 360448, + "profile": null, + "report_fingerprint": "846df8e54698f3ed59e36c04363d45fc94c6c74cd9464a145c22967a727a6bc9", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.827675333000002, + 0.8275388329999487, + 0.8297910420000107, + 0.8269629169999462, + 0.8299753339999825 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0013917609432175515, + "throughput_rows_per_second": 604101.608522866 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.024930786324872094, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q5jo5ykm/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-q5jo5ykm/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.2393046042281191, + "max_seconds": 10.469888165999919, + "median_seconds": 9.959917333000021, + "min_seconds": 9.821419207999952, + "output_fingerprint": "0ecc5b0b8d231b513bdbea1cd8b6b1bdf36eaf0b52567385490245c2fc4a4995", + "peak_python_bytes": 493275733, + "peak_rss_bytes": 89702400, + "profile": null, + "report_fingerprint": "8168b7c9c6b54cea1182ce61b55d4c966d5c9aea47e9e5964013dc1e6d4112f4", + "result_type": "CleanResult", + "samples_seconds": [ + 10.041610290999984, + 9.959917333000021, + 10.469888165999919, + 9.821419207999952, + 9.950516833000052 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.24830857084241348, + "throughput_rows_per_second": 50201.219877936004 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.02478164411229906, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-u32hxje4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-u32hxje4/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 374846110, + "input_to_peak_ratio": 0.19017613388064772, + "max_seconds": 10.65000262500007, + "median_seconds": 10.276501374999953, + "min_seconds": 10.094373749999932, + "output_fingerprint": "0ecc5b0b8d231b513bdbea1cd8b6b1bdf36eaf0b52567385490245c2fc4a4995", + "peak_python_bytes": 493275821, + "peak_rss_bytes": 71286784, + "profile": null, + "report_fingerprint": "8168b7c9c6b54cea1182ce61b55d4c966d5c9aea47e9e5964013dc1e6d4112f4", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 10.276501374999953, + 10.173614041999826, + 10.611117708000165, + 10.65000262500007, + 10.094373749999932 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.2546685997948008, + "throughput_rows_per_second": 48654.691101036544 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0019094963819934487, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qwq4ttn2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qwq4ttn2/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.8856732287123062, + "max_seconds": 2.065569124999456, + "median_seconds": 2.0574672919974546, + "min_seconds": 2.05577487499977, + "output_fingerprint": "5999f68f548b1b042cd5005c362a4928af9fcdc72fcdb2472ba200f59e2e8634", + "peak_python_bytes": 148653536, + "peak_rss_bytes": 72073216, + "profile": null, + "report_fingerprint": "99eb305ade7a784f0ed97e328d4a54b5c0dabfef37cb77d6407759d761db8f84", + "result_type": "CleanResult", + "samples_seconds": [ + 2.065569124999456, + 2.0585723750009493, + 2.05577487499977, + 2.0565774999995483, + 2.0574672919974546 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.003928726350138998, + "throughput_rows_per_second": 243017.2289711513 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0019278840171279886, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y1kajzsz/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y1kajzsz/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.8615130133348394, + "max_seconds": 2.0617799169995124, + "median_seconds": 2.057006666000234, + "min_seconds": 2.0506625000016356, + "output_fingerprint": "5999f68f548b1b042cd5005c362a4928af9fcdc72fcdb2472ba200f59e2e8634", + "peak_python_bytes": 148653429, + "peak_rss_bytes": 70107136, + "profile": null, + "report_fingerprint": "99eb305ade7a784f0ed97e328d4a54b5c0dabfef37cb77d6407759d761db8f84", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 2.0562771250006335, + 2.0506625000016356, + 2.057006666000234, + 2.0617799169995124, + 2.057343000000401 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.003965670274507582, + "throughput_rows_per_second": 243071.64787765598 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.007503108369113908, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z7x9dr_r/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z7x9dr_r/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.9527178263847769, + "max_seconds": 3.2138330830021005, + "median_seconds": 3.1863711250007327, + "min_seconds": 3.1488842500002647, + "output_fingerprint": "1ca557c564f5978cffcf5e6f658a4bccb8a3da2e5d729352166bf825b11bac67", + "peak_python_bytes": 148653279, + "peak_rss_bytes": 77529088, + "profile": null, + "report_fingerprint": "80f661ec8620f197bea6ed819f9e6d6fbb91ce005cfaa7425e61d44566b50f23", + "result_type": "CleanResult", + "samples_seconds": [ + 3.1863711250007327, + 3.1488842500002647, + 3.181944583000586, + 3.1968783750016883, + 3.2138330830021005 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.023907687855095897, + "throughput_rows_per_second": 156918.3187974957 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.018442734117816342, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xt8z79vb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-xt8z79vb/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 1.0245944671327407, + "max_seconds": 3.7949318749997474, + "median_seconds": 3.6600671659980435, + "min_seconds": 3.629740207998111, + "output_fingerprint": "1ca557c564f5978cffcf5e6f658a4bccb8a3da2e5d729352166bf825b11bac67", + "peak_python_bytes": 148653362, + "peak_rss_bytes": 83378176, + "profile": null, + "report_fingerprint": "80f661ec8620f197bea6ed819f9e6d6fbb91ce005cfaa7425e61d44566b50f23", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 3.7292954999975336, + 3.629740207998111, + 3.7949318749997474, + 3.6551122080018104, + 3.6600671659980435 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.06750164559585149, + "throughput_rows_per_second": 136609.51488677334 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0049032880714252845, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i8zs7mdh/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-i8zs7mdh/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 1.920737122508616, + "max_seconds": 2.1802946669995436, + "median_seconds": 2.1668727079995733, + "min_seconds": 2.1526735830011603, + "output_fingerprint": "d71a3ace20906e609955e257343b333b7cf61ea43a6bf5286b233665e64df138", + "peak_python_bytes": 148653479, + "peak_rss_bytes": 156303360, + "profile": null, + "report_fingerprint": "0445cdc181d584feb020fac4faf9201079dc4b38e4e325ae958700e4f58a2995", + "result_type": "CleanResult", + "samples_seconds": [ + 2.1802946669995436, + 2.1526735830011603, + 2.1636460830013675, + 2.1747724580018257, + 2.1668727079995733 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.010624801101431311, + "throughput_rows_per_second": 230747.2876252122 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.013083823850452682, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-obnnpt74/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-obnnpt74/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 1.2810954203901808, + "max_seconds": 2.230016458001046, + "median_seconds": 2.170963791999384, + "min_seconds": 2.161829957996815, + "output_fingerprint": "d71a3ace20906e609955e257343b333b7cf61ea43a6bf5286b233665e64df138", + "peak_python_bytes": 148653494, + "peak_rss_bytes": 104251392, + "profile": null, + "report_fingerprint": "0445cdc181d584feb020fac4faf9201079dc4b38e4e325ae958700e4f58a2995", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 2.162775208002131, + 2.161829957996815, + 2.175815082999179, + 2.230016458001046, + 2.170963791999384 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.028404507840230735, + "throughput_rows_per_second": 230312.45469990865 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0004003099013376801, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ksnjrpyp/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ksnjrpyp/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.05576983049631935, + "max_seconds": 0.2312797500017041, + "median_seconds": 0.23110916600126075, + "min_seconds": 0.23104537499966682, + "output_fingerprint": "3f6a1d501dd40c89788dd25d4763d02a79ecba7f99ab54e5ac21f5f25f375f28", + "peak_python_bytes": 6106881, + "peak_rss_bytes": 4538368, + "profile": null, + "report_fingerprint": "4ca09bcebe496de363c49f1832c1ef3ac3ad15ee21f20a77c6f5e2bad80444aa", + "result_type": "CleanResult", + "samples_seconds": [ + 0.2311215000008815, + 0.23110916600126075, + 0.2312797500017041, + 0.23104537499966682, + 0.23106424999787123 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 9.251528744019822e-05, + "throughput_rows_per_second": 2163479.7470441842 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0015807086286533795, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6f1913hf/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6f1913hf/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.10791562868601867, + "max_seconds": 0.16374579099647235, + "median_seconds": 0.16327895900030853, + "min_seconds": 0.1630799999984447, + "output_fingerprint": "3f6a1d501dd40c89788dd25d4763d02a79ecba7f99ab54e5ac21f5f25f375f28", + "peak_python_bytes": 6106949, + "peak_rss_bytes": 8781824, + "profile": null, + "report_fingerprint": "4ca09bcebe496de363c49f1832c1ef3ac3ad15ee21f20a77c6f5e2bad80444aa", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.1630799999984447, + 0.16317820800031768, + 0.16374579099647235, + 0.16327895900030853, + 0.16340566600047168 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.00025809645936932906, + "throughput_rows_per_second": 3062243.9232911523 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.006517904147596182, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-2t3k0qat/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-2t3k0qat/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.8733917858954273, + "max_seconds": 2.064510666001297, + "median_seconds": 2.057045957997616, + "min_seconds": 2.0303290000010747, + "output_fingerprint": "5999f68f548b1b042cd5005c362a4928af9fcdc72fcdb2472ba200f59e2e8634", + "peak_python_bytes": 148653534, + "peak_rss_bytes": 71073792, + "profile": null, + "report_fingerprint": "99eb305ade7a784f0ed97e328d4a54b5c0dabfef37cb77d6407759d761db8f84", + "result_type": "CleanResult", + "samples_seconds": [ + 2.064510666001297, + 2.06046854199667, + 2.052321415998449, + 2.057045957997616, + 2.0303290000010747 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.013407628381428623, + "throughput_rows_per_second": 243067.0049232704 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.01909614274994729, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-48bqvd6_/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-48bqvd6_/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 81376758, + "input_to_peak_ratio": 0.9710393230460226, + "max_seconds": 2.1338490420021117, + "median_seconds": 2.049153332998685, + "min_seconds": 2.039369957998133, + "output_fingerprint": "5999f68f548b1b042cd5005c362a4928af9fcdc72fcdb2472ba200f59e2e8634", + "peak_python_bytes": 148653139, + "peak_rss_bytes": 79020032, + "profile": null, + "report_fingerprint": "99eb305ade7a784f0ed97e328d4a54b5c0dabfef37cb77d6407759d761db8f84", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 2.039369957998133, + 2.1338490420021117, + 2.046719292000489, + 2.049153332998685, + 2.05299045799984 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.03913092456347316, + "throughput_rows_per_second": 244003.21437552513 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.004305997926680626, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uby8hrir/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-uby8hrir/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.30950947064705425, + "max_seconds": 31.11488329199983, + "median_seconds": 30.907504000000245, + "min_seconds": 30.74539866699979, + "output_fingerprint": "abf767090a8d73e23928a19133988b52651a9bc7caa3d6b3211b92d5d815bdfc", + "peak_python_bytes": 1824235179, + "peak_rss_bytes": 481820672, + "profile": null, + "report_fingerprint": "3888c801d2609e0aa0685147e485a3c6ab1030e47c3bf35244349b7b62328355", + "result_type": "CleanResult", + "samples_seconds": [ + 31.11488329199983, + 30.96781662500007, + 30.90401550000024, + 30.907504000000245, + 30.74539866699979 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.13308764814287422, + "throughput_rows_per_second": 16177.301149908322 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0009156172280939928, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bvxcn7xl/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bvxcn7xl/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.36900542540656855, + "max_seconds": 30.934777709000173, + "median_seconds": 30.90577645800022, + "min_seconds": 30.86089516600032, + "output_fingerprint": "abf767090a8d73e23928a19133988b52651a9bc7caa3d6b3211b92d5d815bdfc", + "peak_python_bytes": 1824236775, + "peak_rss_bytes": 574439424, + "profile": null, + "report_fingerprint": "3888c801d2609e0aa0685147e485a3c6ab1030e47c3bf35244349b7b62328355", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 30.86089516600032, + 30.89630308300002, + 30.90577645800022, + 30.9223135000002, + 30.934777709000173 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.02829786137256674, + "throughput_rows_per_second": 16178.205413459878 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.017867809271841922, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-se9sgn4u/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-se9sgn4u/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.31820284737292703, + "max_seconds": 54.53364629199996, + "median_seconds": 52.680886999999984, + "min_seconds": 52.29800599999999, + "output_fingerprint": "9cdf4b077e4cdece81d954f6622bf50b9af41ee0e5d6f9cad136d1d35f48093d", + "peak_python_bytes": 1824235340, + "peak_rss_bytes": 495353856, + "profile": null, + "report_fingerprint": "d978631e3a9edb9593ae7e062adf8df6b4bb65c106b3ef12150333fef154f03c", + "result_type": "CleanResult", + "samples_seconds": [ + 52.29800599999999, + 53.649490000000014, + 54.53364629199996, + 52.680886999999984, + 52.48959849999983 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.9412920411874562, + "throughput_rows_per_second": 9491.108226784416 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.09621056250927294, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o7uyipn7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-o7uyipn7/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.35185021467633537, + "max_seconds": 70.9163496250003, + "median_seconds": 69.69378691700012, + "min_seconds": 54.97180979100017, + "output_fingerprint": "9cdf4b077e4cdece81d954f6622bf50b9af41ee0e5d6f9cad136d1d35f48093d", + "peak_python_bytes": 1824234574, + "peak_rss_bytes": 547733504, + "profile": null, + "report_fingerprint": "d978631e3a9edb9593ae7e062adf8df6b4bb65c106b3ef12150333fef154f03c", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 54.97180979100017, + 70.9163496250003, + 69.819032375, + 69.69378691700012, + 63.54106812500004 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 6.705278442685989, + "throughput_rows_per_second": 7174.240662162053 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.004254755015180116, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-d7saj_vi/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-d7saj_vi/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.5416205242940256, + "max_seconds": 32.41522974999998, + "median_seconds": 32.220604042000105, + "min_seconds": 32.133236542000304, + "output_fingerprint": "1a811b50d68e320b75f6f09b7636f9bd4c9610b8d4b7c5a1f5468b985264f7d7", + "peak_python_bytes": 1824236919, + "peak_rss_bytes": 843153408, + "profile": null, + "report_fingerprint": "46f0a1ba4057bc3b0fceecc8b8883f17ec98bec2b9fd613e1b199520103901ee", + "result_type": "CleanResult", + "samples_seconds": [ + 32.133236542000304, + 32.158495292000225, + 32.41522974999998, + 32.41325912499997, + 32.220604042000105 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.13709077663983266, + "throughput_rows_per_second": 15518.020684784231 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.05458932077274333, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_62x0b18/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_62x0b18/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.1726677222332553, + "max_seconds": 36.89823916600017, + "median_seconds": 33.52937162499984, + "min_seconds": 32.020333250000476, + "output_fingerprint": "1a811b50d68e320b75f6f09b7636f9bd4c9610b8d4b7c5a1f5468b985264f7d7", + "peak_python_bytes": 1824235637, + "peak_rss_bytes": 268795904, + "profile": null, + "report_fingerprint": "46f0a1ba4057bc3b0fceecc8b8883f17ec98bec2b9fd613e1b199520103901ee", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 32.020333250000476, + 33.04810433399962, + 33.52937162499984, + 36.89823916600017, + 34.02269412500027 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.8303456229456345, + "throughput_rows_per_second": 14912.29855399959 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0022580756838269634, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ng_asva7/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ng_asva7/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.0007683008486546164, + "max_seconds": 3.5053232919999573, + "median_seconds": 3.499255707999964, + "min_seconds": 3.488780291999774, + "output_fingerprint": "621900c9e8eda60a10bb1cc0d178de2c21c374cc0308d6d3537329d0ea7a3212", + "peak_python_bytes": 66289236, + "peak_rss_bytes": 1196032, + "profile": null, + "report_fingerprint": "bb94051fb9d89fced7c4a1e391fa54744e37572c799950c0ada511af903f187d", + "result_type": "CleanResult", + "samples_seconds": [ + 3.488780291999774, + 3.499255707999964, + 3.5041678749998937, + 3.489436666000074, + 3.5053232919999573 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.007901584225727424, + "throughput_rows_per_second": 142887.52858412286 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.018240020360769875, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h0g7u45k/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-h0g7u45k/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.00037888808974748204, + "max_seconds": 3.672049582999989, + "median_seconds": 3.54158629199992, + "min_seconds": 3.524389415999849, + "output_fingerprint": "621900c9e8eda60a10bb1cc0d178de2c21c374cc0308d6d3537329d0ea7a3212", + "peak_python_bytes": 66289189, + "peak_rss_bytes": 589824, + "profile": null, + "report_fingerprint": "bb94051fb9d89fced7c4a1e391fa54744e37572c799950c0ada511af903f187d", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 3.609450250000009, + 3.54158629199992, + 3.524389415999849, + 3.672049582999989, + 3.525917541999661 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.06459860607550202, + "throughput_rows_per_second": 141179.674523094 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0038272609380478467, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ed961_m8/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-ed961_m8/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.34089403408113733, + "max_seconds": 30.926200166999934, + "median_seconds": 30.76691170899994, + "min_seconds": 30.633359584000118, + "output_fingerprint": "abf767090a8d73e23928a19133988b52651a9bc7caa3d6b3211b92d5d815bdfc", + "peak_python_bytes": 1824238425, + "peak_rss_bytes": 530677760, + "profile": null, + "report_fingerprint": "3888c801d2609e0aa0685147e485a3c6ab1030e47c3bf35244349b7b62328355", + "result_type": "CleanResult", + "samples_seconds": [ + 30.926200166999934, + 30.76691170899994, + 30.882352750000337, + 30.732293417000164, + 30.633359584000118 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.1177529993682224, + "throughput_rows_per_second": 16251.224846000385 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 500000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0019292794781800415, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s4rpqe6x/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-s4rpqe6x/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 1556723518, + "input_to_peak_ratio": 0.3706788478029533, + "max_seconds": 30.593777291999686, + "median_seconds": 30.559215709, + "min_seconds": 30.447966166000242, + "output_fingerprint": "abf767090a8d73e23928a19133988b52651a9bc7caa3d6b3211b92d5d815bdfc", + "peak_python_bytes": 1824236414, + "peak_rss_bytes": 577044480, + "profile": null, + "report_fingerprint": "3888c801d2609e0aa0685147e485a3c6ab1030e47c3bf35244349b7b62328355", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 30.447966166000242, + 30.575030999999854, + 30.508481332999963, + 30.559215709, + 30.593777291999686 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.058957267736650845, + "throughput_rows_per_second": 16361.676450117302 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.0033001087155472594, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m305bi9o/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-m305bi9o/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.19226172344345446, + "max_seconds": 15.907747582999946, + "median_seconds": 15.862613875000534, + "min_seconds": 15.792819875000532, + "output_fingerprint": "73bf553ee17143400c41731fc6de66e673a874cde9862747616c2938f7996df6", + "peak_python_bytes": 985815388, + "peak_rss_bytes": 144244736, + "profile": null, + "report_fingerprint": "3e41deba2fb9addceb686b0c8802722fc45fe5d6aa7d3bb5f3abd9a1616aaa43", + "result_type": "CleanResult", + "samples_seconds": [ + 15.887675458000558, + 15.907747582999946, + 15.862613875000534, + 15.797281957999985, + 15.792819875000532 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.052348350300250146, + "throughput_rows_per_second": 63041.31260334081 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.009286716227318652, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w61z76il/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-w61z76il/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.0870680930678161, + "max_seconds": 16.166176333000294, + "median_seconds": 15.932390250000026, + "min_seconds": 15.815876249999747, + "output_fingerprint": "73bf553ee17143400c41731fc6de66e673a874cde9862747616c2938f7996df6", + "peak_python_bytes": 985815781, + "peak_rss_bytes": 65323008, + "profile": null, + "report_fingerprint": "3e41deba2fb9addceb686b0c8802722fc45fe5d6aa7d3bb5f3abd9a1616aaa43", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 15.932390250000026, + 15.815876249999747, + 15.919901415999448, + 16.124136749999707, + 16.166176333000294 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.1479595870746487, + "throughput_rows_per_second": 62765.22130758117 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.011226173560128635, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cyfb1k82/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cyfb1k82/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.28260551602473244, + "max_seconds": 27.34421362499961, + "median_seconds": 27.22134087500035, + "min_seconds": 26.60074537499986, + "output_fingerprint": "4f64b1f7431b78fadc2857fc68aae4521c84cc50a991fd875d36805057b6fa1b", + "peak_python_bytes": 985815826, + "peak_rss_bytes": 212025344, + "profile": null, + "report_fingerprint": "c7b2009334a4d7a1b50459b866bb1c73b7c9c116cd2aeee73494655e0f2b9c08", + "result_type": "CleanResult", + "samples_seconds": [ + 27.34421362499961, + 26.60074537499986, + 27.211928667000393, + 27.31110979099958, + 27.22134087500035 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.3055914972021778, + "throughput_rows_per_second": 36735.883239256014 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.005452174533398623, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z32pfetj/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-z32pfetj/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.3437082309491742, + "max_seconds": 26.888619542000015, + "median_seconds": 26.80459854199944, + "min_seconds": 26.579930166999475, + "output_fingerprint": "4f64b1f7431b78fadc2857fc68aae4521c84cc50a991fd875d36805057b6fa1b", + "peak_python_bytes": 985815743, + "peak_rss_bytes": 257867776, + "profile": null, + "report_fingerprint": "c7b2009334a4d7a1b50459b866bb1c73b7c9c116cd2aeee73494655e0f2b9c08", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 26.579930166999475, + 26.875228666000112, + 26.613409540999783, + 26.80459854199944, + 26.888619542000015 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.1461433495486632, + "throughput_rows_per_second": 37307.031419744104 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.004631714054738453, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-tw8lly9j/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-tw8lly9j/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.15483139700296367, + "max_seconds": 17.07825000000048, + "median_seconds": 16.989657542000714, + "min_seconds": 16.88950974999989, + "output_fingerprint": "80e9a3887b329cdd13b5f7a63896d113b52221cf6d2d7434f44d53d842df8934", + "peak_python_bytes": 985815834, + "peak_rss_bytes": 116162560, + "profile": null, + "report_fingerprint": "e901215788f69728ca579ce0d82766583a26ae9326a57474f375dfb5e23a6642", + "result_type": "CleanResult", + "samples_seconds": [ + 17.07825000000048, + 16.88950974999989, + 16.989657542000714, + 17.074442666999857, + 16.971854542000074 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.07869123562247786, + "throughput_rows_per_second": 58859.33824904156 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.014712741564479442, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-rqpltcr2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-rqpltcr2/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.1970879207266216, + "max_seconds": 17.573468333000164, + "median_seconds": 17.032049957999334, + "min_seconds": 16.976472000000285, + "output_fingerprint": "80e9a3887b329cdd13b5f7a63896d113b52221cf6d2d7434f44d53d842df8934", + "peak_python_bytes": 985815673, + "peak_rss_bytes": 147865600, + "profile": null, + "report_fingerprint": "e901215788f69728ca579ce0d82766583a26ae9326a57474f375dfb5e23a6642", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 17.573468333000164, + 17.032049957999334, + 16.976472000000285, + 16.986775416000455, + 17.099916957999994 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.2505881493453471, + "throughput_rows_per_second": 58712.83858760269 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.013999549250107088, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0_oplliu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0_oplliu/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.00032756995134618547, + "max_seconds": 1.6367367909997483, + "median_seconds": 1.5873522500005492, + "min_seconds": 1.5841950829999405, + "output_fingerprint": "ed29dd716f0f735cf6ba1755d9f0cc07fbf6fbe84eaca605935d78ca9b4b83ce", + "peak_python_bytes": 35648475, + "peak_rss_bytes": 245760, + "profile": null, + "report_fingerprint": "a823d907b7998672a2a1080c387070630f9e250fb67724d21b5de3c07bdf5d22", + "result_type": "CleanResult", + "samples_seconds": [ + 1.5873522500005492, + 1.6367367909997483, + 1.5841950829999405, + 1.5863164580005105, + 1.5919415830003345 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.02222221600115099, + "throughput_rows_per_second": 629979.8926165594 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.0027842336724980387, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qldc62vn/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-qldc62vn/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.0003057319545897731, + "max_seconds": 1.5840877499995258, + "median_seconds": 1.579132333000416, + "min_seconds": 1.5730328750005356, + "output_fingerprint": "ed29dd716f0f735cf6ba1755d9f0cc07fbf6fbe84eaca605935d78ca9b4b83ce", + "peak_python_bytes": 35648426, + "peak_rss_bytes": 229376, + "profile": null, + "report_fingerprint": "a823d907b7998672a2a1080c387070630f9e250fb67724d21b5de3c07bdf5d22", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 1.5840877499995258, + 1.5730328750005356, + 1.5829308340007628, + 1.579132333000416, + 1.5778932089997397 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0043966734148701446, + "throughput_rows_per_second": 633259.1506754593 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.006028043877013027, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6vsbnir1/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6vsbnir1/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.11967222222513976, + "max_seconds": 15.90484487499998, + "median_seconds": 15.759591041999556, + "min_seconds": 15.642079165999348, + "output_fingerprint": "73bf553ee17143400c41731fc6de66e673a874cde9862747616c2938f7996df6", + "peak_python_bytes": 985815334, + "peak_rss_bytes": 89784320, + "profile": null, + "report_fingerprint": "3e41deba2fb9addceb686b0c8802722fc45fe5d6aa7d3bb5f3abd9a1616aaa43", + "result_type": "CleanResult", + "samples_seconds": [ + 15.792274666000594, + 15.642079165999348, + 15.759591041999556, + 15.90484487499998, + 15.73870262499986 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.09499950628495477, + "throughput_rows_per_second": 63453.423209713015 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "medium" + }, + "coefficient_of_variation": 0.005447019351557088, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f2ooeoz0/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-f2ooeoz0/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 750251966, + "input_to_peak_ratio": 0.376901986018921, + "max_seconds": 15.979074124999897, + "median_seconds": 15.801337957999749, + "min_seconds": 15.78683487499984, + "output_fingerprint": "73bf553ee17143400c41731fc6de66e673a874cde9862747616c2938f7996df6", + "peak_python_bytes": 985815831, + "peak_rss_bytes": 282771456, + "profile": null, + "report_fingerprint": "3e41deba2fb9addceb686b0c8802722fc45fe5d6aa7d3bb5f3abd9a1616aaa43", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 15.78683487499984, + 15.915178582999943, + 15.799326999999721, + 15.801337957999749, + 15.979074124999897 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0860701936377182, + "throughput_rows_per_second": 63285.780144568686 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.006157684942719494, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-yybzjsbu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-yybzjsbu/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 1.033749585992345, + "max_seconds": 4.259041833000083, + "median_seconds": 4.202549083000122, + "min_seconds": 4.199759208000614, + "output_fingerprint": "6cbd71f01de1253036139c7e9101128d2451ff6a9c10451481057161573f2dbe", + "peak_python_bytes": 296673367, + "peak_rss_bytes": 168361984, + "profile": null, + "report_fingerprint": "e872d9fbfd8da625e89a0e0c1b6c08c7c550010f82be0a65c822d5d0d447e25e", + "result_type": "CleanResult", + "samples_seconds": [ + 4.202282082999773, + 4.199759208000614, + 4.259041833000083, + 4.202549083000122, + 4.231449957999757 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.025877973209429465, + "throughput_rows_per_second": 237950.81990716895 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.00251464739838065, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fro3mtal/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-fro3mtal/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 1.1204654426608347, + "max_seconds": 4.303362375000688, + "median_seconds": 4.286876375000247, + "min_seconds": 4.273029625000163, + "output_fingerprint": "6cbd71f01de1253036139c7e9101128d2451ff6a9c10451481057161573f2dbe", + "peak_python_bytes": 296673307, + "peak_rss_bytes": 182484992, + "profile": null, + "report_fingerprint": "e872d9fbfd8da625e89a0e0c1b6c08c7c550010f82be0a65c822d5d0d447e25e", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 4.273029625000163, + 4.2856362089996765, + 4.286876375000247, + 4.287799249999807, + 4.303362375000688 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.010779982523573844, + "throughput_rows_per_second": 233270.08117884956 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.09416955877595584, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bfpv5cj2/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-bfpv5cj2/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.9661474332299027, + "max_seconds": 10.086765375000141, + "median_seconds": 8.90282974999991, + "min_seconds": 8.241208875000666, + "output_fingerprint": "28d010ee2a14da92280f4bbda5b3e885bf0a4f7fc38a4b810f6695a768aa4186", + "peak_python_bytes": 296672976, + "peak_rss_bytes": 157351936, + "profile": null, + "report_fingerprint": "7700a2235da9f0d687b6e4a58835b4a7dd3de23a665d8f17ccb712e8441eff78", + "result_type": "CleanResult", + "samples_seconds": [ + 8.241208875000666, + 10.086765375000141, + 10.042707542000244, + 8.90282974999991, + 8.644352540999535 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.8383755494149447, + "throughput_rows_per_second": 112323.83726084509 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.012128431649700563, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-35wc2941/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-35wc2941/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.9605139204996992, + "max_seconds": 7.0617389580002055, + "median_seconds": 6.909691541000029, + "min_seconds": 6.881813083000452, + "output_fingerprint": "28d010ee2a14da92280f4bbda5b3e885bf0a4f7fc38a4b810f6695a768aa4186", + "peak_python_bytes": 296673458, + "peak_rss_bytes": 156434432, + "profile": { + "allocations": [ + { + "bytes": 1432, + "count": 22, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 58 + }, + { + "bytes": 997, + "count": 16, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 199 + }, + { + "bytes": 894, + "count": 15, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 209 + }, + { + "bytes": 840, + "count": 7, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 67 + }, + { + "bytes": 544, + "count": 8, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 154 + }, + { + "bytes": 487, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 24 + }, + { + "bytes": 480, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 104 + }, + { + "bytes": 472, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 93 + }, + { + "bytes": 470, + "count": 7, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 119 + }, + { + "bytes": 431, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 309 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 74 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 187 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 101 + }, + { + "bytes": 408, + "count": 6, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 424 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 184 + }, + { + "bytes": 344, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 75 + }, + { + "bytes": 312, + "count": 2, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "line": 198 + }, + { + "bytes": 305, + "count": 5, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 124 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 90 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 32 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 152 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 70 + }, + { + "bytes": 280, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "line": 63 + }, + { + "bytes": 279, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 280 + }, + { + "bytes": 273, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 78 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 110 + }, + { + "bytes": 270, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 35 + }, + { + "bytes": 267, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 126 + }, + { + "bytes": 265, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 452 + }, + { + "bytes": 265, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 444 + }, + { + "bytes": 264, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 25 + }, + { + "bytes": 261, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 464 + }, + { + "bytes": 259, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 194 + }, + { + "bytes": 251, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 362 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/config.py", + "line": 355 + }, + { + "bytes": 248, + "count": 4, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "line": 116 + }, + { + "bytes": 217, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "line": 185 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 94 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 55 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 30 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 39 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/prune.py", + "line": 11 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 132 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 123 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 116 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 59 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/missing.py", + "line": 48 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/memory.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 70 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "line": 26 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 332 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 297 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 257 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 195 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 179 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 133 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 101 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 72 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 62 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 47 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 29 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/columns.py", + "line": 18 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/result.py", + "line": 25 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/report.py", + "line": 223 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/guard.py", + "line": 61 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/utils.py", + "line": 6 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 263 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 163 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 124 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/outliers.py", + "line": 68 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 159 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 86 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 73 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 53 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/model_select.py", + "line": 43 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 525 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 499 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 432 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 272 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 152 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 142 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 83 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "line": 56 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 282 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 231 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 219 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 210 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 199 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 168 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 118 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 109 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 92 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 79 + }, + { + "bytes": 216, + "count": 3, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "line": 72 + } + ], + "functions": [ + { + "calls": 1, + "cumulative_seconds": 31.423151750000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/api.py", + "function": "clean", + "line": 138, + "self_seconds": 7.2043e-05 + }, + { + "calls": 1, + "cumulative_seconds": 31.422087875000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "clean", + "line": 189, + "self_seconds": 5.6459e-05 + }, + { + "calls": 1, + "cumulative_seconds": 31.422031416000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/cleaner.py", + "function": "run_pipeline", + "line": 45, + "self_seconds": 0.008333542000000001 + }, + { + "calls": 1, + "cumulative_seconds": 17.996924333000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "drop_duplicate_rows", + "line": 83, + "self_seconds": 0.009138001 + }, + { + "calls": 1, + "cumulative_seconds": 16.874983750000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/duplicates.py", + "function": "_filter_rows", + "line": 70, + "self_seconds": 0.26744025 + }, + { + "calls": 99, + "cumulative_seconds": 10.111921752, + "file": "/Users/wilson/freshdata-qa/benchmarks/performance/instrumentation.py", + "function": "observed", + "line": 58, + "self_seconds": 0.0045572600000000005 + }, + { + "calls": 114, + "cumulative_seconds": 8.208285005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "apply", + "line": 317, + "self_seconds": 0.0029991970000000003 + }, + { + "calls": 18, + "cumulative_seconds": 7.928752956, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "astype", + "line": 6485, + "self_seconds": 0.00047658000000000005 + }, + { + "calls": 18, + "cumulative_seconds": 7.92533754, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "astype", + "line": 440, + "self_seconds": 5.6289e-05 + }, + { + "calls": 18, + "cumulative_seconds": 7.924564084000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "astype", + "line": 749, + "self_seconds": 0.00018962700000000002 + }, + { + "calls": 18, + "cumulative_seconds": 7.923960291, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array_safe", + "line": 191, + "self_seconds": 0.000112168 + }, + { + "calls": 18, + "cumulative_seconds": 7.922414043000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "astype_array", + "line": 157, + "self_seconds": 0.007876296 + }, + { + "calls": 9, + "cumulative_seconds": 7.9113580820000005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/astype.py", + "function": "_astype_nansafe", + "line": 56, + "self_seconds": 4.7662000000000005e-05 + }, + { + "calls": 6, + "cumulative_seconds": 7.776774874000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/masked.py", + "function": "_from_sequence", + "line": 151, + "self_seconds": 3.8083e-05 + }, + { + "calls": 6, + "cumulative_seconds": 7.776590166, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_array", + "line": 266, + "self_seconds": 2.2333e-05 + }, + { + "calls": 6, + "cumulative_seconds": 7.7765678330000005, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numeric.py", + "function": "_coerce_to_data_and_mask", + "line": 135, + "self_seconds": 7.7583246710000004 + }, + { + "calls": 15, + "cumulative_seconds": 6.841222375, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "to_numpy", + "line": 545, + "self_seconds": 0.0013209200000000002 + }, + { + "calls": 2, + "cumulative_seconds": 6.769518666000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "to_numpy", + "line": 539, + "self_seconds": 0.00883254 + }, + { + "calls": 653, + "cumulative_seconds": 6.753314452000001, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 0.0014597920000000001 + }, + { + "calls": 2, + "cumulative_seconds": 6.743895458000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__array__", + "line": 640, + "self_seconds": 1.5126e-05 + }, + { + "calls": 2, + "cumulative_seconds": 6.743873874, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py", + "function": "__array__", + "line": 356, + "self_seconds": 1.013817263 + }, + { + "calls": 10, + "cumulative_seconds": 6.672769291000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "wrapper", + "line": 132, + "self_seconds": 4.1748e-05 + }, + { + "calls": 10, + "cumulative_seconds": 6.667685373, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map", + "line": 431, + "self_seconds": 0.002655877 + }, + { + "calls": 8, + "cumulative_seconds": 6.414853085000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "_str_map_str_or_object", + "line": 486, + "self_seconds": 2.168132505 + }, + { + "calls": 1000001, + "cumulative_seconds": 5.617966778, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "__iter__", + "line": 647, + "self_seconds": 5.617473808000001 + }, + { + "calls": 1, + "cumulative_seconds": 5.319424584, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "clean_strings", + "line": 94, + "self_seconds": 0.004413375000000001 + }, + { + "calls": 2, + "cumulative_seconds": 5.314062001, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "normalize_text", + "line": 55, + "self_seconds": 0.39329804100000004 + }, + { + "calls": 4, + "cumulative_seconds": 4.698837417, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "strip", + "line": 2141, + "self_seconds": 4.1085000000000004e-05 + }, + { + "calls": 4, + "cumulative_seconds": 4.696794292, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_strip", + "line": 487, + "self_seconds": 4.4627000000000005e-05 + }, + { + "calls": 1, + "cumulative_seconds": 4.664807167, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "fix_dtypes", + "line": 332, + "self_seconds": 0.004510709 + }, + { + "calls": 2, + "cumulative_seconds": 4.659690542, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "suggest_conversion", + "line": 297, + "self_seconds": 0.005136291 + }, + { + "calls": 3818180, + "cumulative_seconds": 4.154282252000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "", + "line": 488, + "self_seconds": 2.172110265 + }, + { + "calls": 2, + "cumulative_seconds": 3.871873792, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_datetime", + "line": 257, + "self_seconds": 1.9582e-05 + }, + { + "calls": 2, + "cumulative_seconds": 3.833706293, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_has_relative_date_word", + "line": 195, + "self_seconds": 0.395641002 + }, + { + "calls": 1, + "cumulative_seconds": 2.581877416, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/cache.py", + "function": "build_engine_cache", + "line": 21, + "self_seconds": 1.8458000000000002e-05 + }, + { + "calls": 1, + "cumulative_seconds": 2.5188029170000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_contexts", + "line": 282, + "self_seconds": 0.0015725420000000001 + }, + { + "calls": 8, + "cumulative_seconds": 2.5172146250000003, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "build_context", + "line": 231, + "self_seconds": 0.018499083 + }, + { + "calls": 2, + "cumulative_seconds": 2.3500962920000004, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/strings.py", + "function": "_strip_series", + "line": 30, + "self_seconds": 1.0208000000000001e-05 + }, + { + "calls": 3818196, + "cumulative_seconds": 1.9821835710000002, + "file": "~", + "function": "", + "line": 0, + "self_seconds": 1.9821835710000002 + }, + { + "calls": 4, + "cumulative_seconds": 1.9367197090000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/accessor.py", + "function": "casefold", + "line": 3249, + "self_seconds": 1.8708e-05 + }, + { + "calls": 4, + "cumulative_seconds": 1.9347782070000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/strings/object_array.py", + "function": "_str_casefold", + "line": 471, + "self_seconds": 2.7874e-05 + }, + { + "calls": 3, + "cumulative_seconds": 1.8303740000000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "__init__", + "line": 698, + "self_seconds": 0.00016929300000000002 + }, + { + "calls": 1, + "cumulative_seconds": 1.8296785000000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "dict_to_mgr", + "line": 423, + "self_seconds": 0.00012179000000000001 + }, + { + "calls": 1, + "cumulative_seconds": 1.8271043340000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "arrays_to_mgr", + "line": 96, + "self_seconds": 0.006447085 + }, + { + "calls": 216, + "cumulative_seconds": 1.7939842890000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/construction.py", + "function": "sanitize_array", + "line": 517, + "self_seconds": 0.007478654 + }, + { + "calls": 38, + "cumulative_seconds": 1.7801391260000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/cast.py", + "function": "maybe_infer_to_datetimelike", + "line": 1166, + "self_seconds": 0.8316054150000001 + }, + { + "calls": 1, + "cumulative_seconds": 1.7720340410000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/construction.py", + "function": "_homogenize", + "line": 596, + "self_seconds": 9.312300000000001e-05 + }, + { + "calls": 4, + "cumulative_seconds": 1.4423284170000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "isin", + "line": 5505, + "self_seconds": 9.833400000000001e-05 + }, + { + "calls": 8, + "cumulative_seconds": 1.440946126, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "isin", + "line": 457, + "self_seconds": 1.4402185410000001 + }, + { + "calls": 4, + "cumulative_seconds": 1.4405064170000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "isin", + "line": 825, + "self_seconds": 7.179300000000001e-05 + }, + { + "calls": 8, + "cumulative_seconds": 1.3884667080000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_mode_ratio", + "line": 79, + "self_seconds": 0.000161623 + }, + { + "calls": 8, + "cumulative_seconds": 1.324052709, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "value_counts", + "line": 927, + "self_seconds": 0.0013580010000000002 + }, + { + "calls": 13, + "cumulative_seconds": 1.322694708, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_internal", + "line": 862, + "self_seconds": 0.0054910340000000005 + }, + { + "calls": 9, + "cumulative_seconds": 1.127940626, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "value_counts_arraylike", + "line": 963, + "self_seconds": 1.126715833 + }, + { + "calls": 2, + "cumulative_seconds": 1.1113017090000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "duplicated", + "line": 6850, + "self_seconds": 0.038694875000000004 + }, + { + "calls": 304, + "cumulative_seconds": 1.089611541, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "isna", + "line": 101, + "self_seconds": 0.00018392400000000002 + }, + { + "calls": 304, + "cumulative_seconds": 1.089455451, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna", + "line": 184, + "self_seconds": 0.001673622 + }, + { + "calls": 209, + "cumulative_seconds": 1.0691897110000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_array", + "line": 261, + "self_seconds": 0.009256654000000001 + }, + { + "calls": 44, + "cumulative_seconds": 1.053965457, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "_isna_string_dtype", + "line": 305, + "self_seconds": 1.053965457 + }, + { + "calls": 40, + "cumulative_seconds": 1.0005963310000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/numpy_.py", + "function": "isna", + "line": 237, + "self_seconds": 4.2416e-05 + }, + { + "calls": 2, + "cumulative_seconds": 0.9619626250000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/string_.py", + "function": "value_counts", + "line": 1014, + "self_seconds": 0.011990917 + }, + { + "calls": 2, + "cumulative_seconds": 0.947733166, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "_from_sequence_not_strict", + "line": 331, + "self_seconds": 0.000134832 + }, + { + "calls": 1, + "cumulative_seconds": 0.9475380000000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/indexes/datetimes.py", + "function": "__new__", + "line": 320, + "self_seconds": 3.7749e-05 + }, + { + "calls": 2, + "cumulative_seconds": 0.947387834, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "_sequence_to_dt64", + "line": 2201, + "self_seconds": 0.013595165000000001 + }, + { + "calls": 1, + "cumulative_seconds": 0.9336683750000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py", + "function": "objects_to_datetime64", + "line": 2371, + "self_seconds": 0.9336645830000001 + }, + { + "calls": 16, + "cumulative_seconds": 0.908280959, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "f", + "line": 6947, + "self_seconds": 7.0207e-05 + }, + { + "calls": 16, + "cumulative_seconds": 0.908066251, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize", + "line": 610, + "self_seconds": 0.012432292000000001 + }, + { + "calls": 16, + "cumulative_seconds": 0.8768398770000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "factorize_array", + "line": 548, + "self_seconds": 0.8584337070000001 + }, + { + "calls": 6, + "cumulative_seconds": 0.680792666, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/base.py", + "function": "factorize", + "line": 1428, + "self_seconds": 0.0027582080000000003 + }, + { + "calls": 2, + "cumulative_seconds": 0.577625041, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_try_numeric", + "line": 133, + "self_seconds": 0.00010362400000000001 + }, + { + "calls": 10, + "cumulative_seconds": 0.5754759150000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "unique", + "line": 2356, + "self_seconds": 3.5541000000000004e-05 + }, + { + "calls": 10, + "cumulative_seconds": 0.575440374, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "unique", + "line": 1023, + "self_seconds": 3.1083e-05 + }, + { + "calls": 10, + "cumulative_seconds": 0.5694039980000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique_with_mask", + "line": 427, + "self_seconds": 0.546591618 + }, + { + "calls": 8, + "cumulative_seconds": 0.5627719170000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/algorithms.py", + "function": "unique", + "line": 307, + "self_seconds": 0.00496521 + }, + { + "calls": 6, + "cumulative_seconds": 0.5215819150000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/arrays/_mixins.py", + "function": "unique", + "line": 223, + "self_seconds": 3.7123000000000004e-05 + }, + { + "calls": 8, + "cumulative_seconds": 0.484397291, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "_safe_nunique", + "line": 72, + "self_seconds": 3.2957e-05 + }, + { + "calls": 8, + "cumulative_seconds": 0.48079649900000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/base.py", + "function": "nunique", + "line": 1032, + "self_seconds": 0.002445042 + }, + { + "calls": 2, + "cumulative_seconds": 0.423110083, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/dtypes.py", + "function": "_to_numeric_or_none", + "line": 124, + "self_seconds": 2.0458e-05 + }, + { + "calls": 2, + "cumulative_seconds": 0.423089625, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/tools/numeric.py", + "function": "to_numeric", + "line": 47, + "self_seconds": 0.422030043 + }, + { + "calls": 5, + "cumulative_seconds": 0.418105084, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/context.py", + "function": "missingness_is_informative", + "line": 168, + "self_seconds": 0.012619486000000001 + }, + { + "calls": 70, + "cumulative_seconds": 0.32439274700000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "notna", + "line": 380, + "self_seconds": 0.001065708 + }, + { + "calls": 73, + "cumulative_seconds": 0.305314543, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "__getitem__", + "line": 1107, + "self_seconds": 0.0014317520000000001 + }, + { + "calls": 61, + "cumulative_seconds": 0.29547262500000004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "_get_rows_with_mask", + "line": 1228, + "self_seconds": 0.00029366600000000004 + }, + { + "calls": 61, + "cumulative_seconds": 0.292749334, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/managers.py", + "function": "get_rows_with_mask", + "line": 1973, + "self_seconds": 0.061336335000000006 + }, + { + "calls": 38, + "cumulative_seconds": 0.282586334, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/dtypes/missing.py", + "function": "remove_na_arraylike", + "line": 718, + "self_seconds": 0.010512298000000002 + }, + { + "calls": 1, + "cumulative_seconds": 0.258406375, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "auto_missing", + "line": 56, + "self_seconds": 0.000275083 + }, + { + "calls": 42, + "cumulative_seconds": 0.24997654300000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "dropna", + "line": 5839, + "self_seconds": 0.000249175 + }, + { + "calls": 96, + "cumulative_seconds": 0.23037775200000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/blocks.py", + "function": "apply", + "line": 389, + "self_seconds": 0.000276043 + }, + { + "calls": 2, + "cumulative_seconds": 0.226244667, + "file": "/Users/wilson/freshdata-qa/src/freshdata/_util.py", + "function": "memory_bytes", + "line": 34, + "self_seconds": 0.002110293 + }, + { + "calls": 4, + "cumulative_seconds": 0.22505095800000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/frame.py", + "function": "isna", + "line": 6510, + "self_seconds": 3.9667000000000005e-05 + }, + { + "calls": 4, + "cumulative_seconds": 0.224864541, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/internals/base.py", + "function": "isna", + "line": 176, + "self_seconds": 1.5916e-05 + }, + { + "calls": 11, + "cumulative_seconds": 0.21008141700000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "sample", + "line": 5998, + "self_seconds": 0.000189958 + }, + { + "calls": 5, + "cumulative_seconds": 0.19623300100000002, + "file": "/Users/wilson/freshdata-qa/src/freshdata/engine/missing.py", + "function": "_handle_column", + "line": 152, + "self_seconds": 0.002901416 + }, + { + "calls": 25, + "cumulative_seconds": 0.177824, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "notna", + "line": 5805, + "self_seconds": 9.099600000000001e-05 + }, + { + "calls": 25, + "cumulative_seconds": 0.177733004, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/generic.py", + "function": "notna", + "line": 8787, + "self_seconds": 0.0018771710000000002 + }, + { + "calls": 35, + "cumulative_seconds": 0.174085751, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/ops/common.py", + "function": "new_method", + "line": 62, + "self_seconds": 6.3376e-05 + }, + { + "calls": 11, + "cumulative_seconds": 0.17314970600000001, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/sample.py", + "function": "sample", + "line": 117, + "self_seconds": 0.172718754 + }, + { + "calls": 131, + "cumulative_seconds": 0.16736462400000002, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/series.py", + "function": "_reduce", + "line": 6439, + "self_seconds": 0.001015337 + }, + { + "calls": 6, + "cumulative_seconds": 0.163068334, + "file": "/Users/wilson/freshdata-qa/src/freshdata/steps/outliers.py", + "function": "detection_bounds", + "line": 90, + "self_seconds": 0.000237666 + }, + { + "calls": 2, + "cumulative_seconds": 0.162371667, + "file": "/Users/wilson/freshdata-qa/.venv-qa/lib/python3.12/site-packages/pandas/core/sorting.py", + "function": "get_group_index", + "line": 122, + "self_seconds": 0.039169539 + } + ], + "operations": { + "dataframe.astype": 0, + "dataframe.copy": 2, + "dataframe.corr": 1, + "dataframe.corrwith": 0, + "series.astype": 18, + "series.copy": 15, + "series.isna": 22, + "series.notna": 25, + "series.nunique": 8, + "series.value_counts": 8 + }, + "stages": { + "audit_events": 8.458100000000001e-05, + "backend_conversion": 2.375e-06, + "context": 0.014943748000000001, + "correlation": 0.040253078000000005, + "dtype_repair": 0.424914875, + "duplicates": 0.276578626, + "engine_cache": 1.8458000000000002e-05, + "missing": 0.0064326290000000005, + "outliers": 0.002529329, + "report_finalization": 0.010536462000000002, + "role_inference": 0.025302623, + "semantic_ml": 0.0, + "total": 31.422901707000026 + } + }, + "report_fingerprint": "7700a2235da9f0d687b6e4a58835b4a7dd3de23a665d8f17ccb712e8441eff78", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 7.0617389580002055, + 6.886956500000451, + 6.909691541000029, + 6.881813083000452, + 7.023452207999981 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.08380372157553301, + "throughput_rows_per_second": 144724.26070922284 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.01961505084590251, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-olcq_0u3/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-olcq_0u3/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.9941137999976987, + "max_seconds": 5.140843582999878, + "median_seconds": 4.980070999999953, + "min_seconds": 4.879412082999806, + "output_fingerprint": "e466eabbfcf9c59e75182464b1a2f7cca321c53a3d3a43ffc56b61cbc1efe667", + "peak_python_bytes": 296673121, + "peak_rss_bytes": 161906688, + "profile": null, + "report_fingerprint": "a1a863654a941ec78565276ec000fbb3fd532b923e75b4053691a4bf98790845", + "result_type": "CleanResult", + "samples_seconds": [ + 4.879412082999806, + 5.140843582999878, + 4.932944541999859, + 4.980070999999953, + 4.986879500000214 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.09768434588120363, + "throughput_rows_per_second": 200800.3500351721 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.059434232100101764, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9eov5p_h/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9eov5p_h/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.9910958467493755, + "max_seconds": 6.330436209000254, + "median_seconds": 5.721714166000311, + "min_seconds": 5.47198570799992, + "output_fingerprint": "e466eabbfcf9c59e75182464b1a2f7cca321c53a3d3a43ffc56b61cbc1efe667", + "peak_python_bytes": 296673509, + "peak_rss_bytes": 161415168, + "profile": null, + "report_fingerprint": "a1a863654a941ec78565276ec000fbb3fd532b923e75b4053691a4bf98790845", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 5.54302537500007, + 5.47198570799992, + 6.330436209000254, + 5.721714166000311, + 5.852446874999259 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.3400656877525027, + "throughput_rows_per_second": 174772.79902275105 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0034826767949102566, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y9l2tty4/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y9l2tty4/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.0006035906496646622, + "max_seconds": 0.3176431659994705, + "median_seconds": 0.3162259170003381, + "min_seconds": 0.31488658400030545, + "output_fingerprint": "822c93490c683c70dcb67f7aa3f1d5f1fab19073a43dc2b076a9634617e7e221", + "peak_python_bytes": 11606924, + "peak_rss_bytes": 98304, + "profile": null, + "report_fingerprint": "208cac92cc0cf8d1a389e88fa73daec4dce8a4799296e459f5499364ca9a5496", + "result_type": "CleanResult", + "samples_seconds": [ + 0.31488658400030545, + 0.3151115000000573, + 0.3176431659994705, + 0.31627462500000547, + 0.3162259170003381 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0011013126630862943, + "throughput_rows_per_second": 3162296.1504414924 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.0026248222168827025, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-woqbb2i9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-woqbb2i9/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.0003017953248323311, + "max_seconds": 0.31469716700030403, + "median_seconds": 0.31349266699999134, + "min_seconds": 0.31284608299938554, + "output_fingerprint": "822c93490c683c70dcb67f7aa3f1d5f1fab19073a43dc2b076a9634617e7e221", + "peak_python_bytes": 11606742, + "peak_rss_bytes": 49152, + "profile": null, + "report_fingerprint": "208cac92cc0cf8d1a389e88fa73daec4dce8a4799296e459f5499364ca9a5496", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 0.31349266699999134, + 0.31469716700030403, + 0.31451724999988073, + 0.3131673329999103, + 0.31284608299938554 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.0008228625171713881, + "throughput_rows_per_second": 3189867.2768636965 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.004423668532847696, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cpv66lch/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-cpv66lch/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.979527025964136, + "max_seconds": 4.299894957999641, + "median_seconds": 4.273620083000424, + "min_seconds": 4.25050070799989, + "output_fingerprint": "6cbd71f01de1253036139c7e9101128d2451ff6a9c10451481057161573f2dbe", + "peak_python_bytes": 296673261, + "peak_rss_bytes": 159531008, + "profile": null, + "report_fingerprint": "e872d9fbfd8da625e89a0e0c1b6c08c7c550010f82be0a65c822d5d0d447e25e", + "result_type": "CleanResult", + "samples_seconds": [ + 4.273620083000424, + 4.289081917000658, + 4.25050070799989, + 4.299894957999641, + 4.2701876669998455 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.018905078682514932, + "throughput_rows_per_second": 233993.65890706875 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "narrow" + }, + "coefficient_of_variation": 0.03929893377711418, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_w7r0q85/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-_w7r0q85/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 162865346, + "input_to_peak_ratio": 0.9776156555735313, + "max_seconds": 4.646158249999644, + "median_seconds": 4.3307746249993215, + "min_seconds": 4.292065166999237, + "output_fingerprint": "6cbd71f01de1253036139c7e9101128d2451ff6a9c10451481057161573f2dbe", + "peak_python_bytes": 296672878, + "peak_rss_bytes": 159219712, + "profile": null, + "report_fingerprint": "e872d9fbfd8da625e89a0e0c1b6c08c7c550010f82be0a65c822d5d0d447e25e", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 4.292065166999237, + 4.3307746249993215, + 4.646158249999644, + 4.601915166999788, + 4.324515582999993 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.17019482519145485, + "throughput_rows_per_second": 230905.5738498876 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0171365502684261, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6va8ihwu/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6va8ihwu/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.6466682524303435, + "max_seconds": 67.98776041600104, + "median_seconds": 67.08010408299924, + "min_seconds": 65.21292891599842, + "output_fingerprint": "b44319e4bd6e5d86705065ccefbf88405556be8d7d187c923cf060d619927e31", + "peak_python_bytes": 3647337637, + "peak_rss_bytes": 2014887936, + "profile": null, + "report_fingerprint": "1f593e4931805e342200abfed2696f3eefc8d3998f69b65bd1971735c56ba2ad", + "result_type": "CleanResult", + "samples_seconds": [ + 65.21292891599842, + 67.98776041600104, + 67.08010408299924, + 65.61610633299824, + 67.08709220899982 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.1495215756295714, + "throughput_rows_per_second": 14907.549916182072 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "conservative", + "dataset_type": "mixed", + "options": { + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0055815361716641376, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nq36ybo/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nq36ybo/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.47482494186981183, + "max_seconds": 65.27017683399936, + "median_seconds": 64.62739191699984, + "min_seconds": 64.29142070800117, + "output_fingerprint": "b44319e4bd6e5d86705065ccefbf88405556be8d7d187c923cf060d619927e31", + "peak_python_bytes": 3647336077, + "peak_rss_bytes": 1479458816, + "profile": null, + "report_fingerprint": "1f593e4931805e342200abfed2696f3eefc8d3998f69b65bd1971735c56ba2ad", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 64.29142070800117, + 64.62739191699984, + 64.68394462500146, + 65.27017683399936, + 64.5441735000004 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.36072012566504913, + "throughput_rows_per_second": 15473.315112023825 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.013212076089862057, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0y608fx9/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-0y608fx9/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.44945859761815926, + "max_seconds": 113.33153520799988, + "median_seconds": 112.11013312500017, + "min_seconds": 109.78866708300029, + "output_fingerprint": "4838f6440d7704c8b4159ef6c9880507524c92ccdf26c21a40f7e2840056e325", + "peak_python_bytes": 3647334382, + "peak_rss_bytes": 1400422400, + "profile": null, + "report_fingerprint": "758f6029453870b2ae164dcda6454ca2d9bad9cd03530238e0cbdf4210a54840", + "result_type": "CleanResult", + "samples_seconds": [ + 112.11013312500017, + 113.33153520799988, + 109.78866708300029, + 110.9462236670006, + 113.05310670899962 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 1.481207609292067, + "throughput_rows_per_second": 8919.800308193582 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "default", + "dataset_type": "mixed", + "options": { + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.0013616335395043747, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gz_af_1p/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-gz_af_1p/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.3261289462752367, + "max_seconds": 110.32932337500097, + "median_seconds": 110.0600397090002, + "min_seconds": 109.93545945900041, + "output_fingerprint": "4838f6440d7704c8b4159ef6c9880507524c92ccdf26c21a40f7e2840056e325", + "peak_python_bytes": 3647336285, + "peak_rss_bytes": 1016152064, + "profile": null, + "report_fingerprint": "758f6029453870b2ae164dcda6454ca2d9bad9cd03530238e0cbdf4210a54840", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 110.00789425000039, + 110.0600397090002, + 109.93545945900041, + 110.32932337500097, + 110.12226995799938 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.14986144142695795, + "throughput_rows_per_second": 9085.949838324697 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.007518150728361921, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y7aivnpb/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-y7aivnpb/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.6509275266517031, + "max_seconds": 66.73773900000015, + "median_seconds": 65.76844970800084, + "min_seconds": 65.53403979200084, + "output_fingerprint": "aa6c746650eed05154402ec51ab16730fab08e1bc21a5aa468af5570c27fd2e3", + "peak_python_bytes": 3647334979, + "peak_rss_bytes": 2028158976, + "profile": null, + "report_fingerprint": "063e31cacb3803e83b7321eac9a1cc4423cb6855e69435a2fe028cd3cbe97099", + "result_type": "CleanResult", + "samples_seconds": [ + 66.73773900000015, + 65.98912500000006, + 65.76844970800084, + 65.55587516699961, + 65.53403979200084 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.4944571180754409, + "throughput_rows_per_second": 15204.858932205427 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "explicit", + "dataset_type": "mixed", + "options": { + "impute": "median", + "outliers": "flag", + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.00726108403185602, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lx898arq/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-lx898arq/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.5464228156945425, + "max_seconds": 66.08698316699883, + "median_seconds": 65.11512295799912, + "min_seconds": 64.89373916699878, + "output_fingerprint": "aa6c746650eed05154402ec51ab16730fab08e1bc21a5aa468af5570c27fd2e3", + "peak_python_bytes": 3647336069, + "peak_rss_bytes": 1702543360, + "profile": null, + "report_fingerprint": "063e31cacb3803e83b7321eac9a1cc4423cb6855e69435a2fe028cd3cbe97099", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 66.08698316699883, + 65.34931333299937, + 65.11512295799912, + 65.02923641699999, + 64.89373916699878 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.47280637954266874, + "throughput_rows_per_second": 15357.415521506808 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.00601406402534799, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zqojqylx/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-zqojqylx/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.0010569310104855223, + "max_seconds": 6.70368845899975, + "median_seconds": 6.6757091250001395, + "min_seconds": 6.619279333999657, + "output_fingerprint": "174b2d9a20e71cffb4a15dd8a058aa17c1e6eaf6b6e6f2bc7136a334272f2df3", + "peak_python_bytes": 131789189, + "peak_rss_bytes": 3293184, + "profile": null, + "report_fingerprint": "9b33ee4dc3984dd9ca3c42c9d560b8090968d4e10bd7480f481756c4b40b523e", + "result_type": "CleanResult", + "samples_seconds": [ + 6.69319029199869, + 6.620468958000856, + 6.70368845899975, + 6.619279333999657, + 6.6757091250001395 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.040148142092350646, + "throughput_rows_per_second": 149796.82027412768 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "representation_off", + "dataset_type": "mixed", + "options": { + "column_names": false, + "drop_duplicates": false, + "fix_dtypes": false, + "normalize_sentinels": false, + "strategy": "conservative", + "strip_whitespace": false, + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.009881185116531544, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nhcsu3f/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-9nhcsu3f/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 7.88754485436957e-05, + "max_seconds": 7.0269274590009445, + "median_seconds": 6.898923708000439, + "min_seconds": 6.862010957998791, + "output_fingerprint": "174b2d9a20e71cffb4a15dd8a058aa17c1e6eaf6b6e6f2bc7136a334272f2df3", + "peak_python_bytes": 131789836, + "peak_rss_bytes": 245760, + "profile": null, + "report_fingerprint": "9b33ee4dc3984dd9ca3c42c9d560b8090968d4e10bd7480f481756c4b40b523e", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 6.938221082999007, + 6.862010957998791, + 7.0269274590009445, + 6.864935958999922, + 6.898923708000439 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.06816954226358055, + "throughput_rows_per_second": 144950.14618589493 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": false, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.012629543105048041, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-l8w0yh4p/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-l8w0yh4p/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.3721396245923925, + "max_seconds": 66.47659279199979, + "median_seconds": 65.25178762500036, + "min_seconds": 64.26287587499974, + "output_fingerprint": "b44319e4bd6e5d86705065ccefbf88405556be8d7d187c923cf060d619927e31", + "peak_python_bytes": 3647334874, + "peak_rss_bytes": 1159512064, + "profile": null, + "report_fingerprint": "1f593e4931805e342200abfed2696f3eefc8d3998f69b65bd1971735c56ba2ad", + "result_type": "CleanResult", + "samples_seconds": [ + 64.26287587499974, + 65.13513537499966, + 65.81594062499971, + 66.47659279199979, + 65.25178762500036 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.8241002644913824, + "throughput_rows_per_second": 15325.250639062388 + }, + { + "baseline_name": null, + "case": { + "backend": "pandas", + "config_name": "statistical_off", + "dataset_type": "mixed", + "options": { + "impute": null, + "outliers": null, + "strategy": "conservative", + "verbose": false + }, + "output_format": "pandas", + "repetitions": 5, + "return_report": true, + "rows": 1000000, + "seed": 42, + "warmups": 1, + "width": "wide" + }, + "coefficient_of_variation": 0.006743030387562807, + "command": "/Users/wilson/freshdata-qa/.venv-qa/bin/python -c 'from benchmarks.performance.worker import worker_main; worker_main(__import__('\"'\"'sys'\"'\"').argv[1], __import__('\"'\"'sys'\"'\"').argv[2], __import__('\"'\"'sys'\"'\"').argv[3])' /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6m37255r/case.json /var/folders/5n/6lzstmkn3g906qtsthx5l4b40000gn/T/freshdata-benchmark-6m37255r/result.json", + "comparisons": [], + "environment": { + "cpu_count_logical": 8, + "cpu_count_physical": 8, + "freshdata_version": "1.1.1", + "git_commit": "27ee7b653a1318ac66692df2ba9c7813a674e8aa", + "git_dirty": true, + "numpy_version": "2.4.6", + "optional_versions": { + "duckdb": "1.5.4", + "polars": "1.42.1", + "pyarrow": "25.0.0", + "pyspark": null + }, + "pandas_version": "2.3.3", + "platform": "macOS-15.5-arm64-arm-64bit", + "processor": "arm", + "python_version": "3.12.13", + "total_ram_bytes": 17179869184 + }, + "error_message": null, + "error_type": null, + "input_bytes": 3115798446, + "input_to_peak_ratio": 0.40071357041815536, + "max_seconds": 69.54790866700023, + "median_seconds": 68.6904214999995, + "min_seconds": 68.40353266700004, + "output_fingerprint": "b44319e4bd6e5d86705065ccefbf88405556be8d7d187c923cf060d619927e31", + "peak_python_bytes": 3647336545, + "peak_rss_bytes": 1248542720, + "profile": null, + "report_fingerprint": "1f593e4931805e342200abfed2696f3eefc8d3998f69b65bd1971735c56ba2ad", + "result_type": "tuple[CleanResult,CleanReport]", + "samples_seconds": [ + 68.46643754100114, + 69.54790866700023, + 68.6904214999995, + 68.93686362500011, + 68.40353266700004 + ], + "schema_version": 1, + "status": "completed", + "stdev_seconds": 0.46318159950899424, + "throughput_rows_per_second": 14558.070516425747 + } + ], + "schema_version": 1 +} \ No newline at end of file diff --git a/tests/performance/test_analysis_render.py b/tests/performance/test_analysis_render.py index 5a26bb1..7e5e62e 100644 --- a/tests/performance/test_analysis_render.py +++ b/tests/performance/test_analysis_render.py @@ -483,6 +483,45 @@ def test_analysis_keys_profiles_by_stable_case_id_without_collisions() -> None: assert "seed=99" in hypotheses[second_id]["label"] +def test_analysis_merges_profile_companion_into_plain_timing_result() -> None: + plain = _result_payload(median=1.25) + plain["command"] = "plain benchmark command" + profile = _result_payload(median=9.5) + profile["command"] = "profile benchmark command" + profile["profile"] = _empty_profile() + + summary = analyze_results([profile, plain]) + + assert len(summary["results"]) == 1 + assert summary["results"][0]["median_seconds"] == 1.25 + assert summary["results"][0]["profile"] == profile["profile"] + assert summary["results"][0]["command"] == "plain benchmark command" + assert summary["reproduction_commands"] == [ + "plain benchmark command", + "profile benchmark command", + ] + + +def test_analysis_rejects_ambiguous_duplicate_plain_artifacts() -> None: + first = _result_payload() + second = _result_payload() + second["command"] = "duplicate plain benchmark command" + + with pytest.raises(ValueError, match="ambiguous.*plain"): + analyze_results([first, second]) + + +def test_analysis_rejects_conflicting_profile_companion_fingerprint() -> None: + plain = _result_payload() + plain["output_fingerprint"] = "plain-fingerprint" + profile = _result_payload() + profile["output_fingerprint"] = "profile-fingerprint" + profile["profile"] = _empty_profile() + + with pytest.raises(ValueError, match="incompatible.*output_fingerprint"): + analyze_results([plain, profile]) + + def test_renderer_is_deterministic_and_contains_required_sections() -> None: payload = { "schema_version": 1, From 0951d5fb5cfe48fb20b99396abad1cd598c98081 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 22:12:39 +0530 Subject: [PATCH 26/37] docs: record FreshData performance baseline --- docs/performance-investigation.md | 423 +++++++++++++++++++++++------- 1 file changed, 330 insertions(+), 93 deletions(-) diff --git a/docs/performance-investigation.md b/docs/performance-investigation.md index c7ce25e..c1f618e 100644 --- a/docs/performance-investigation.md +++ b/docs/performance-investigation.md @@ -8,118 +8,355 @@ keywords: freshdata performance, scalability, profiling, benchmark methodology # Performance investigation -## Executive summary +## 1. Executive summary -Baseline measurement is in progress. No slowdown or improvement is claimed yet. -This page defines the architecture, commands, and evidence rules used to produce -later findings without treating an unmeasured hypothesis as a result. +Phase 1 baseline capture is complete; no production optimization has been +implemented. All **132/132 FreshData timing cases completed** with no FreshData +timing failure, timeout, or OOM. Coverage is 10k, 100k, 500k, and 1M rows; +narrow, medium, and wide mixed frames; five approved configurations +(`default`, `conservative`, `representation_off`, `statistical_off`, and +`explicit`); report on/off; plus 12 family cases at 100k/medium across six +dataset families and both report modes. -## Architecture and execution flow +The largest measured baseline runtime is 1M/wide/default/report=false at an +exact median of `112.11013312500017` seconds. The highest measured peak-RSS +delta is 1M/wide/explicit/report=false at `2,028,158,976` bytes. Six profiles +completed; the MissForest profile is missing/incomplete after an interrupted +approximately two-hour CPU-bound run. The 48/48 **named pandas component +operations** produced 41 completed results and seven failed +`numeric_median_fill` operations because fractional medians could not fill +nullable `Int64` columns; there were no component timeouts or OOMs. These +components are not full-pipeline FreshData equivalents. -The public cleaning path is: +The authoritative evidence is +[`benchmarks/results/performance/baseline-summary.json`](https://github.com/FreshCode-Org/freshdata/blob/main/benchmarks/results/performance/baseline-summary.json), +with every generated row and profiler summary in the +[`baseline-report.md`](https://github.com/FreshCode-Org/freshdata/blob/main/benchmarks/results/performance/baseline-report.md) +view. Production `src/freshdata` is byte-for-byte unchanged relative to +`6f6c2fe` according to `git diff`. + +### Architecture and execution flow ```text fd.clean - -> normalize API options and validate contracts/context/memory/profile inputs - -> select the pandas or native execution path - -> initialize CleanReport and preserve-original handling - -> representation repair - column names - strings and sentinels - empty rows and columns - dtype repair - optional constant-column removal - duplicate handling - optional semantic repair - -> decision engine - build per-column contexts - build reusable engine statistics/correlations - automatic missing-value decisions - automatic outlier decisions - -> explicit imputation and outlier overrides - -> optional memory optimization - -> protected-column verification and index handling - -> finalize report - -> wrap or convert the result + -> validate and normalize API inputs + -> select pandas or native path and initialize CleanReport + -> representation repair (columns, strings, sentinels, rows/columns, + dtypes, constants, duplicates, optional semantic repair) + -> build column contexts and shared engine artifacts + -> automatic and explicit missing-value/outlier decisions + -> optional memory optimization and protected-column checks + -> finalize report and wrap/convert the result ``` -The pandas implementation in `src/freshdata/cleaner.py` is the behavioral -reference. Context profiling lives in `src/freshdata/engine/context.py`, shared -engine artifacts live in `src/freshdata/engine/cache.py`, and representation -operations live in `src/freshdata/steps/`. Native backends reproduce a documented -subset and fall back to pandas when required. Every path must preserve the -`CleanReport` contract. +The pandas path in `src/freshdata/cleaner.py` remains the behavioral reference; +context and shared artifacts live in `src/freshdata/engine/context.py` and +`src/freshdata/engine/cache.py`, and representation operations live under +`src/freshdata/steps/`. Native paths implement documented subsets and fall back +to pandas as required. `return_report=False` still constructs the embedded +report and populates `Cleaner.report_`; future changes must preserve that +contract. -`return_report=False` does not remove report construction: the pandas result -remains a `CleanResult` with an embedded report, and `Cleaner.report_` is still -populated. Any future optimization must preserve those behaviors. +### Supported environment and provenance -The development-only harness in `benchmarks/performance/` generates deterministic -mixed-schema frames, runs each benchmark case in an isolated subprocess, validates -each result against the versioned JSON contract, analyzes measurements, and renders -Markdown from that authoritative JSON. It does not add production runtime work. +The supported Python 3.9–3.13, pandas `>=1.5,<3`, and NumPy `>=1.21` ranges are +unchanged. Measurements were captured on one macOS 15.5 arm64 host with 8 +logical/8 physical CPUs and 17,179,869,184 bytes RAM, using Python 3.12.13, +pandas 2.3.3, NumPy 2.4.6, and FreshData 1.1.1. Evidence records tooling commit +`27ee7b653a1318ac66692df2ba9c7813a674e8aa` and `git_dirty=true` because +`.venv-qa/` was untracked; the production-source identity gate against +`6f6c2fe` remained clean. -## Supported environment and defaults +## 2. Reproduction commands -The investigation preserves the supported Python 3.9–3.13 matrix, pandas -`>=1.5,<3`, and NumPy `>=1.21`. The default cleaning strategy remains `balanced`, -including the existing representation-repair defaults. Profiling uses the standard -library and dependencies already declared by the development and benchmark extras. +Install the development, benchmark, and optional ML dependencies first: -## Reproduction commands +```bash +pip install -e ".[dev,bench,ml]" +``` -Install the development, benchmark, and optional ML dependencies before running -the full matrix: +The timing evidence was captured with these selectors (500k and 1M widths were +run as separate commands with the shown width substituted): ```bash -pip install -e ".[dev,bench,ml]" +.venv-qa/bin/python -m benchmarks.performance run --rows 10000 --widths narrow,medium,wide --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 900 --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance run --rows 100000 --widths narrow,medium,wide --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 1800 --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance run --rows 100000 --widths medium --dataset-types numeric,categorical,string,nullable,datetime,high_cardinality --configs default --report-modes false,true --warmups 1 --repetitions 5 --timeout 1800 --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance run --rows 500000 --widths narrow --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 3600 --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance run --rows 1000000 --widths narrow --configs default,conservative,representation_off,statistical_off,explicit --report-modes false,true --warmups 1 --repetitions 5 --timeout 7200 --output benchmarks/results/performance/baseline +``` + +Repeat the last two commands with `--widths medium` and `--widths wide`. The six +completed profiles used the following selectors; the same form with +`--rows 10000 --widths medium --configs missforest --report-modes true` was the +interrupted seventh command. + +```bash +.venv-qa/bin/python -m benchmarks.performance profile --rows 10000 --widths wide --configs default --report-modes true --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs default --report-modes true --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance profile --rows 500000 --widths medium --configs default --report-modes false --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance profile --rows 1000000 --widths narrow --configs default --report-modes true --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs aggressive --report-modes true --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs semantic --report-modes true --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance profile --rows 10000 --widths medium --configs missforest --report-modes true --output benchmarks/results/performance/baseline ``` -The Make targets use the active `PY` interpreter; override it when needed, for -example with `make performance-ci PY=.venv/bin/python`. +The last command is the incomplete MissForest attempt described in section 4; +the other six commands produced completed profile artifacts. ```bash -make performance-ci -make performance-baseline -make performance-profile -make performance-report +.venv-qa/bin/python -m benchmarks.performance baseline --rows 10000,100000,500000,1000000 --widths narrow,medium,wide --dataset-types mixed --baselines shallow_copy,numeric_median_fill,duplicates,null_counts --warmups 1 --repetitions 5 --timeout 3600 --output benchmarks/results/performance/baseline +.venv-qa/bin/python -m benchmarks.performance analyze --input benchmarks/results/performance/baseline --output benchmarks/results/performance/baseline-summary.json +.venv-qa/bin/python -m benchmarks.performance render --input benchmarks/results/performance/baseline-summary.json --output benchmarks/results/performance/baseline-report.md ``` -`performance-ci` runs the small deterministic contract suite. -`performance-baseline` writes raw case JSON under -`benchmarks/results/performance/baseline/`. `performance-profile` records one -100,000-row medium-width default case with report behavior enabled. -`performance-report` analyzes the raw directory into -`baseline-summary.json` and renders `baseline-report.md` from that summary. - -## Measurement methodology - -Reportable cases use one warm-up followed by five measured repetitions. Each case -records its exact command and environment, dataset seed and shape, configuration, -individual timing samples and summary statistics, throughput, peak RSS, Python -allocation peak, input size, status, and any failure, timeout, or memory-exhaustion -details. Timing and memory measurements run separately so memory sampling does not -silently redefine the timing result. - -Equivalent pandas baselines are limited to named component operations that perform -the same selected transformation. They are not described as equivalent to -FreshData's complete decision and audit pipeline. - -An optimization is a verified win only if the relevant median runtime or peak-memory -measurement improves by at least 10%, the improvement exceeds twice the observed -run-to-run variability, and no other primary workload has a meaningful regression. -CI contracts assert stable behavior and structure rather than fragile wall-clock -thresholds; large runtime and memory measurements run manually and weekly. - -## Evidence lifecycle - -Authoritative, schema-validated JSON is the source for the generated baseline, -profile, root-cause, rejected-hypothesis, before/after, memory, backend, -documentation, risk, and verification sections as their investigation phases -complete. Generated Markdown is a view of that JSON. Raw case files remain local or -in workflow artifacts; only compact `*-summary.json` and `*-report.md` evidence is -eligible to be committed. - -Failures, timeouts, memory exhaustion, poor results, and unresolved limitations -remain visible in the evidence. A result is not published without its environment -and reproduction command. +### Measurement methodology and evidence lifecycle + +Reportable cases use one warm-up and five measured repetitions. Timing and +memory are measured separately in isolated workers. JSON records the exact case, +samples, median, variability, throughput, peak RSS, Python allocation peak, +fingerprints, environment, status, and errors. The JSON summary is authoritative; +generated Markdown is its view. Function and allocation rankings are capped at +the top 100 and are therefore not exhaustive. + +The analyzer reconciles four same-ID plain/profile companion pairs by retaining +the plain timing record and attaching its profile. The regenerated summary has +134 unique FreshData cases: 132 timing cases and two profile-only cases. This +prevents separately measured profile timings from becoming duplicate benchmark +rows while preserving all 186 raw reproduction commands. + +A later optimization qualifies only if the relevant median runtime or peak +memory improves by at least 10%, exceeds twice the larger observed coefficient +of variation, preserves behavioral equivalence, and causes no meaningful primary +workload regression. Failures and incomplete evidence remain visible rather than +being discarded. + +## 3. Baseline benchmark table + +This compact mixed-frame slice shows default scaling and the largest configuration +contrast. Medians and CV coefficients are rounded to six decimal places from the +authoritative JSON; peak-RSS byte counts are exact. See the +[full generated report](https://github.com/FreshCode-Org/freshdata/blob/main/benchmarks/results/performance/baseline-report.md) +for every generated row: all 134 reconciled FreshData cases (including all 132 +timing cases), 41 completed named component rows, and seven failed components. + +| Rows | Width | Config | Report | Median (s) | CV | Peak RSS (bytes) | +| ---: | :--- | :--- | :---: | ---: | ---: | ---: | +| 10,000 | medium | default | false | 0.428086 | 0.004192 | 5,996,544 | +| 100,000 | medium | default | false | 2.766123 | 0.005914 | 32,522,240 | +| 500,000 | medium | default | false | 20.539099 | 0.022993 | 59,195,392 | +| 1,000,000 | narrow | default | false | 8.902830 | 0.094170 | 157,351,936 | +| 1,000,000 | medium | default | false | 27.221341 | 0.011226 | 212,025,344 | +| 1,000,000 | wide | default | false | 112.110133 | 0.013212 | 1,400,422,400 | +| 1,000,000 | wide | default | true | 110.060040 | 0.001362 | 1,016,152,064 | +| 1,000,000 | wide | conservative | false | 67.080104 | 0.017137 | 2,014,887,936 | +| 1,000,000 | wide | representation_off | false | 6.675709 | 0.006014 | 3,293,184 | +| 1,000,000 | wide | statistical_off | false | 65.251788 | 0.012630 | 1,159,512,064 | +| 1,000,000 | wide | explicit | false | 65.768450 | 0.007518 | 2,028,158,976 | + +The exact largest median is `112.11013312500017` seconds, not the rounded table +display. Configuration contrasts describe different behavior and are not +optimization before/after comparisons. + +## 4. Profiling findings with functions, files, and lines + +Six profile artifacts completed. Representative cumulative hot paths are: + +| Profile | Profiler total (s) | Exact FreshData evidence | +| :--- | ---: | :--- | +| 10k/wide/default/report=true | 18.445463412 | `src/freshdata/steps/dtypes.py:332 fix_dtypes`: 1 call, 11.888526209 s cumulative; `:297 suggest_conversion`: 42 calls, 11.883506043 s | +| 100k/medium/default/report=true | 16.006843291 | `src/freshdata/steps/dtypes.py:332 fix_dtypes`: 1 call, 4.828396791 s cumulative | +| 500k/medium/default/report=false | 49.319412332 | `src/freshdata/steps/duplicates.py:83 drop_duplicate_rows`: 1 call, 18.035868375 s cumulative; `:70 _filter_rows`: 0.196458333 s self | +| 1M/narrow/default/report=true | 31.422901707 | `src/freshdata/steps/duplicates.py:83 drop_duplicate_rows`: 1 call, 17.996924333 s cumulative; `:70 _filter_rows`: 0.26744025 s self | +| 100k/medium/aggressive/report=true | 15.655626045 | `src/freshdata/steps/dtypes.py:332 fix_dtypes`: 1 call, 4.873163041 s cumulative | +| 100k/medium/semantic/report=true | 22.015065380 | `src/freshdata/semantic/apply.py:192 run_semantic`: 1 call, 6.300034834 s cumulative; `src/freshdata/semantic/experts.py:146 is_plain_number`: 0.718468278 s self | + +Engine-context evidence in the 10k/wide/default profile includes +`src/freshdata/engine/cache.py:21 build_engine_cache` at 1.376872959 seconds +cumulative, `src/freshdata/engine/context.py:282 build_contexts` at 1.308761792 +seconds, `src/freshdata/engine/context.py:231 build_context` at 1.308280540 +seconds over 128 calls, and `src/freshdata/engine/context.py:79 _mode_ratio` at +0.483927833 seconds. Representative FreshData allocation entries include +`src/freshdata/semantic/experts.py:565` (952 bytes/17 allocations), +`src/freshdata/engine/model_select.py:154` (544/8), +`src/freshdata/steps/outliers.py:119` (516/8), and +`src/freshdata/engine/context.py:104` (480/7). These line rankings are top-100 +snapshots, not exhaustive allocation totals or peak-RSS measurements. + +The missing 10k/medium/MissForest command ran CPU-bound for approximately two +hours, was last observed at 100% CPU and roughly 650 MiB RSS, and was interrupted +under the quick-finish directive before producing JSON. No MissForest function, +allocation, stage, operation-count, or semantic conclusion is inferred. + +## 5. Confirmed root causes + +No cause is confirmed by profiling alone. The only `candidate` decision is the +case-specific semantic `optional_ml_overhead` result for 100k/medium/semantic/ +report=true: stage fraction `0.13104697297973694` +(`13.104697297973694%`), one observed call, and +`src/freshdata/semantic/apply.py:192 run_semantic` at `6.300034834000001` +seconds cumulative. + +Here, `candidate` means an optimization-plan candidate, not a confirmed +production root cause. It still requires a targeted acceptance benchmark and an +output/report equivalence gate before any causal or improvement claim. + +A separate evidence-tooling cause was confirmed and fixed before this report: +the analyzer previously emitted four plain/profile companion pairs twice because +it had no reconciliation step. The regenerated compact evidence now contains one +canonical row per case. This was a benchmark-reporting defect, not a FreshData +runtime cause or production optimization. + +## 6. Rejected hypotheses + +Every other decision is `rejected` or `insufficient_evidence` across the six +completed profiles: + +| Hypothesis | Result across six profiles | +| :--- | :--- | +| `copy_pressure` | rejected: 6 | +| `dtype_conversion_pressure` | rejected: 6 | +| `repeated_uniqueness_scans` | rejected: 6 | +| `report_finalization_overhead` | rejected: 6 | +| `backend_conversion_overhead` | insufficient evidence: 6 | +| `unnecessary_correlation` | insufficient evidence: 6 | +| `repeated_null_scans` | rejected: 5; insufficient evidence: 1 | +| `optional_ml_overhead` | candidate: 1; insufficient evidence: 5 | + +Correlation remains insufficient: `dataframe.corr=1` was observed in each +completed profile, but the required exact correlation function did not appear in +the capped function evidence. Operation counts alone do not establish a hot path. + +## 7. Files and functions changed + +not yet applicable: no production optimization has been implemented + +The Phase 1 work changes this evidence document only; production +`src/freshdata` remains unchanged relative to `6f6c2fe`. + +## 8. Explanation of every optimization + +not yet applicable: no production optimization has been implemented + +Optimization selection and rationale are pending later-phase work, not unknown +Phase 1 evidence. + +## 9. Behavioral compatibility analysis + +not yet applicable: no production optimization has been implemented + +Behavioral comparison is pending a concrete change. Existing output and report +fingerprints establish the future equivalence gate but do not constitute a +before/after result. + +## 10. Tests added or changed + +not yet applicable: no production optimization has been implemented + +No optimization-specific test was added or changed in this evidence-only task. + +## 11. Before-and-after benchmark table + +not yet applicable: no production optimization has been implemented + +The table in section 3 is baseline-only. A later phase must rerun the same cases +before presenting an optimization comparison. + +## 12. Peak-memory comparison + +No optimization before/after memory comparison exists. This baseline-only 1M/ +wide mixed-frame contrast reports exact peak-RSS deltas from separate workers: + +| Config | Report=false (bytes) | Report=true (bytes) | +| :--- | ---: | ---: | +| default | 1,400,422,400 | 1,016,152,064 | +| conservative | 2,014,887,936 | 1,479,458,816 | +| representation_off | 3,293,184 | 245,760 | +| statistical_off | 1,159,512,064 | 1,248,542,720 | +| explicit | **2,028,158,976** | 1,702,543,360 | + +Peak RSS is a process delta, not total resident size. The very low +`representation_off` deltas and report-mode reversals require cautious +interpretation. + +For named component-operation context only, the largest component peak RSS was +1M/wide `numeric_median_fill` at 493,223,936 bytes (470.375 MiB). It is not a +full-pipeline equivalent and is not an optimization comparison. + +## 13. Remaining bottlenecks + +- Wide/default runtime scales to the largest measured median, while wide + statistics-enabled configurations also carry the largest RSS deltas. +- Dtype repair and duplicate handling appear as high cumulative paths in + representative profiles, but their defined hypothesis decisions do not confirm + production root causes. +- The 1M/wide `duplicates` component was the slowest completed named operation + at a 13.8993894-second median; this supports investigation of duplicate handling + but is not a full-pipeline FreshData measurement. +- Semantic assist has the sole case-specific optimization-plan candidate. +- Engine-context and correlation work is observed, but the evidence threshold for + a correlation cause is not met. +- MissForest remains unprofiled, so its internal bottleneck is unknown rather + than merely pending classification. + +## 14. Backend and out-of-core recommendations + +not yet applicable: no production optimization has been implemented + +Backend and out-of-core recommendations are pending evidence-driven Phase 2 +design; Phase 1 does not justify one. + +## 15. Documentation corrections + +not yet applicable: no production optimization has been implemented + +This page now records the completed baseline instead of describing it as in +progress, but no optimization-specific user-documentation correction is claimed. + +## 16. Risks and trade-offs + +- Report=true is not consistently slower: examples include 1M/wide/default + (`110.0600397090002` versus `112.11013312500017` seconds) and several other + report-mode inversions. These pairs must not be read as isolated report-cost + estimates. +- `representation_off` has unusually low RSS deltas, including 245,760 bytes for + 1M/wide/report=true; this may reflect the selected path or RSS-delta accounting, + not a stable total-memory footprint. +- Eleven completed component measurements have CV above 20%; the highest is + 82.11% for 100k/narrow `shallow_copy`. Sub-millisecond components are especially + noisy. +- The seven failed named components are 10k/all widths, 100k/medium and wide, and + 500k/medium and wide `numeric_median_fill` cases. Fractional medians (`5082.5`, + `4989.5`, or `4995.5`) are invalid for nullable `Int64`; failed cases have no + timing or memory metric. +- The absent MissForest JSON, top-100 profiler caps, one-host environment, + unavailable durable shell timing/exit details for completed profile commands, + and dirty provenance flag limit generalization. + +## 17. Exact verification commands and results + +```bash +.venv-qa/bin/python -m pytest tests/performance -q --no-cov +.venv-qa/bin/mkdocs build --strict +git diff --check +git diff 6f6c2fe -- src/freshdata +``` + +Results from the final documentation verification run: + +| Command | Exit | Result | +| :--- | ---: | :--- | +| Performance tests | 0 | All tests completed through `[100%]`; no failures | +| Strict MkDocs build | 0 | Documentation built successfully | +| Diff whitespace check | 0 | No output | +| Production-source identity diff | 0 | No output; `src/freshdata` remains byte-for-byte unchanged from `6f6c2fe` | + +The documentation build also printed Material for MkDocs' upstream MkDocs 2.0 +notice and INFO that two `docs/superpowers/` pages are not in `nav`; neither was +a strict-build error. + +### Optimization-specific acceptance verification + +not yet applicable: no production optimization has been implemented + +Acceptance and equivalence results are pending a later production change. From da0728dd78e10a9ca622cc04eef961d690ac205f Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 22:49:54 +0530 Subject: [PATCH 27/37] docs: design measured semantic optimization --- ...onfirmed-performance-bottlenecks-design.md | 232 ++++++++++++++++++ 1 file changed, 232 insertions(+) create mode 100644 docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md diff --git a/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md b/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md new file mode 100644 index 0000000..0013ac4 --- /dev/null +++ b/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md @@ -0,0 +1,232 @@ +# FreshData Evidence-Gated Semantic Optimization Design + +**Status:** Approved in conversation on 2026-07-11 +**Scope:** Phase 2 design only; no production change is authorized by this document alone + +This design follows the +[approved performance investigation design](./2026-07-11-freshdata-performance-scalability-design.md) +and the completed [performance investigation](../../performance-investigation.md). +It addresses the investigation's sole optimization candidate without treating +that candidate as a confirmed root cause or promising a performance gain. + +## Decision + +Measure exact repeated semantic predicate/parser arguments first. Only if that +measurement demonstrates a material cacheable opportunity may implementation +add exact, request-local result reuse inside semantic-context construction. The +change is accepted only if it preserves the complete behavioral contract and +passes the end-to-end performance and memory gates below. Otherwise it is +rejected or reverted; the scope does not expand to another optimization. + +## Measured Evidence + +The only Phase 2 candidate is baseline case `9ea9cb03dfc114c5`: + +- 100,000 rows, medium width, mixed data, pandas input/output; +- `semantic_mode="assist"`, `verbose=False`, `return_report=True`, seed 42; +- one warm-up and five measured repetitions; +- profile total `22.015065380` seconds; +- semantic-stage fraction `0.13104697297973694` + (`13.104697297973694%`); +- `run_semantic`: one call, `6.300034834000001` seconds cumulative; +- `build_semantic_context`: one call, approximately `6.184` seconds cumulative; +- `_build_info`: 32 calls, approximately `5.200` seconds cumulative; +- `_share`: 192 calls, approximately `4.232` seconds cumulative. + +The capped self-time samples include `is_plain_number` at approximately +`0.718468278` seconds over 192,602 calls, `looks_like_date_value` at +approximately `0.387268678` seconds over 50,956 calls, and the boolean +predicate lambda in `semantic/context.py` at approximately `0.327692425` +seconds over 192,602 calls. + +### Evidence limits + +These measurements identify a candidate and hot functions, not a cause. The +profiler lists are capped and non-exhaustive. `_build_info` already applies +`pd.unique` within every bounded column sample, so reuse across columns or +context builds cannot be assumed. Exact repetition must be measured. + +Every other investigated hypothesis was rejected or had insufficient evidence. +The required MissForest profile was interrupted after approximately two +CPU-bound hours and produced no JSON, so no MissForest conclusion is available. + +## Compatibility Contract + +The optimized and current paths must be indistinguishable across: + +- public signatures, configuration fields, return types, and deterministic output; +- values, shape, row/column order, index values, names, and types; +- exact dtypes and input-mutation behavior; +- warning and exception type, message, and ordering; +- actions and action ordering, counts, rationales, risks, confidence, + recommendations, and serialized reports; +- protected identifier, target, preserve, and PII behavior and privacy policy; +- semantic modes `off`, `assist`, `review`, and `auto`; +- memory/profile replay and native/fallback behavior. + +Sampling, `pd.unique`, thresholds, classification, proposal resolution, +replacement order, and audit/report construction remain unchanged. + +## Current Data Flow + +```text +run_semantic + -> build_semantic_context + -> build_contexts + -> for each column, _build_info + -> bounded non-null sample + -> pd.unique within that sample + -> semantic predicates/parsers + -> SemanticColumnInfo + -> SemanticContext + -> gather proposals + -> resolve and apply replacements + -> append audit/report records +``` + +The only proposed boundary is the single `build_semantic_context` invocation. +The cache must not reach proposal gathering, replacement resolution, or report +construction. + +## Proposed Design + +### 1. RED discovery gate + +Add development-only instrumentation around the named pure predicate/parser +calls made by `_build_info`. On the representative workload, record per +operation: + +- total calls and the exact argument sequence; +- cache-eligible and bypassed calls; +- unique keys, repeated keys, theoretical hits, and hit rate; +- repeated-evaluation time sufficient to judge whether a 10% end-to-end win is + feasible. + +The prospective key is `(predicate identity, exact input type, exact input +value)`. Measurement must use the same eligibility and key rules as the proposed +implementation. Call count alone is not sufficient: repeated eligible work must +be material enough to make the final acceptance threshold plausible. Record the +predeclared calculation and result. If it does not establish that opportunity, +stop with no production change. + +After discovery passes, add a failing focused test proving that the current path +re-evaluates a repeated eligible key within one context build. The test must also +capture the uncached dataframe/context and complete report/audit fingerprint for +later differential comparison. + +Instrumentation belongs in focused tests or benchmark tooling and adds no +default production overhead. + +### 2. Minimal GREEN change + +Create one private cache when `build_semantic_context` starts and share it only +with that invocation's `_build_info` calls. Destroy it when the build returns or +raises. Do not add a public parameter or configuration switch. + +Evaluate only explicitly named, pure deterministic operations through the +request-local helper. Use the underlying parser/predicate identity, not an +ephemeral lambda identity. For transformations such as `parse_boolean(str(v))`, +perform the existing `str(v)` conversion in its existing order, then key the +parser by the exact string it receives. + +Include both `type(value)` and `value` in every key so `1`, `True`, and +numeric-equivalent values of different Python types cannot collide. Restrict +eligibility to input types whose immutable, stable hashing/equality behavior is +explicitly proven. Bypass non-hashable values and user-defined or otherwise +unsafe values without invoking their custom hashing merely to test eligibility. + +Call the original operation on a miss. Store a result only after successful +return and only when its result contract is immutable. The current candidate +results are `None`, booleans, integers, floats, and the immutable `(float, str)` +unit tuple. They remain internal to context scoring, so object identity is not +exposed. Mutable results are never cached. + +Do not cache exceptions. Do not catch, translate, reorder, or suppress a parser +exception. A bypass calls the original operation at the same logical point. A +miss that raises propagates the same exception, and a second context build starts +with an empty cache. + +### 3. Refactor and verification gate + +Keep cache policy, lookup, and result eligibility in one small private unit; +keep `_build_info` responsible for unchanged sampling and scoring. Refactoring +must not generalize the cache beyond semantic-context construction. + +Run differential tests against the captured uncached reference and the full +compatibility matrix. Re-run the representative benchmark and profiler only +after correctness passes. + +## Test Design + +The later implementation plan must use strict TDD: + +1. RED: prove measured repetition, then fail on avoidable underlying calls while + capturing the complete reference behavior. +2. GREEN: add only the request-local exact-result cache needed to pass. +3. REFACTOR: isolate the private helper without changing behavior or scope. +4. VERIFY: run differential, regression, performance, memory, and profile gates. + +Focused cache tests cover a hit within one build, no reuse across builds, +predicate/type/value key separation, safe bypass, immutable result reuse, and +unchanged exception propagation. Broader differential coverage includes: + +- normal and repeated inputs; mixed Python types and unhashable values; +- nullable and object dtypes and supported duplicate labels; +- protected columns, semantic hints, policies, and all semantic modes; +- report enabled/disabled, empty, single-row, and all-null inputs; +- native/pandas parity and native fallback; +- memory and profile replay. + +Differential fingerprints compare the complete dataframe surface—values, shape, +ordering, index, and exact dtypes—and the complete report/audit surface, +including ordered actions, counts, rationales, risks, confidence, +recommendations, metadata, warnings, and serialization. + +## Performance Acceptance Gate + +Measure before and after in the same recorded environment using the primary +case: 100k rows, medium width, semantic assist, `verbose=False`, report enabled, +pandas input/output, seed 42, one warm-up, and five measured repetitions. + +Acceptance requires all of the following: + +- at least 10% median wall-time improvement; +- improvement greater than twice the larger before/after coefficient of + variation, using the repository's comparison semantics; +- exact dataframe and report/audit fingerprint equality on every measured run; +- no material peak-RSS or Python-allocation-peak regression; +- no meaningful regression in the 100k/medium/report=true default and aggressive + controls under the repository's precise comparison semantics; +- a new semantic profile showing time removed from the targeted functions rather + than shifted to another stage. + +The evidence record includes environment, commit, dirty state, exact commands, +individual repetitions, medians, coefficients of variation, peak RSS, Python +allocation peak, fingerprints, profile deltas, and accepted/rejected outcome. + +## Failure, Rollout, and Rejection + +There is no feature flag or staged public API. This is an internal optimization +that may land only after every compatibility and acceptance gate passes. + +Reject or revert the production change if repetition is not material, any +behavior differs, the runtime threshold is missed, memory or controls regress, +or profiling shows displaced rather than removed work. Preserve the negative +measurement as evidence and do not broaden the implementation to recover a win. + +## Rejected Alternatives + +- Module, global, persistent `functools.lru_cache`, or cross-request caching: + rejected for state leakage, unbounded retention, and semantic risk. +- Vectorizing or rewriting parsers/classifiers: rejected as excessive behavioral + risk before exact reuse is measured. +- MissForest optimization: rejected because no completed profile exists. +- Backend rewrites and correlation, copy, dtype, reporting, uniqueness, or + null-scan work: outside the sole measured Phase 2 candidate. + +## Non-Goals + +This phase does not change semantic decisions, sampling, configuration, public +interfaces, backend architecture, dependencies, reports, or documentation +claims. It does not create a general memoization framework or optimize any +unmeasured subsystem. From f6bbb8ec52dd0627016f9ccd9d3ce89f5099148c Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 22:58:41 +0530 Subject: [PATCH 28/37] docs: clarify semantic cache discovery --- ...onfirmed-performance-bottlenecks-design.md | 44 ++++++++++++++++--- 1 file changed, 37 insertions(+), 7 deletions(-) diff --git a/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md b/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md index 0013ac4..745cc00 100644 --- a/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md +++ b/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md @@ -80,8 +80,10 @@ run_semantic -> SemanticColumnInfo -> SemanticContext -> gather proposals - -> resolve and apply replacements - -> append audit/report records + -> calibrate proposals and decide + -> build replacement map + -> record every decision + -> apply replacements ``` The only proposed boundary is the single `build_semantic_context` invocation. @@ -102,6 +104,14 @@ operation: - repeated-evaluation time sufficient to judge whether a 10% end-to-end win is feasible. +Reset the discovery counters and simulated cache at every +`build_semantic_context` entry. Compute unique keys and theoretical hits only +within that one build, then emit and aggregate the completed per-build metrics. +Aggregation may sum per-build counts but must not deduplicate across builds or +carry simulated entries forward. Repetition between warm-up, measured, memory, +or profile runs—or between any other context builds—never counts as a cacheable +hit. + The prospective key is `(predicate identity, exact input type, exact input value)`. Measurement must use the same eligibility and key rules as the proposed implementation. Call count alone is not sufficient: repeated eligible work must @@ -117,11 +127,32 @@ later differential comparison. Instrumentation belongs in focused tests or benchmark tooling and adds no default production overhead. +#### Candidate universe and exact input eligibility + +Discovery instruments exactly these seven operations and input types: + +- `is_plain_number`: exact built-in `str`, `int`, `float`, or `bool`; +- `parse_number_words`: exact built-in `str`; +- `parse_boolean`: the actual post-`str(v)` argument, exact built-in `str`; +- `parse_currency`: exact built-in `str`; +- `parse_unit`: exact built-in `str`; +- the email-shape predicate `bool(_EMAIL_VALUE.match(v.strip()))`: exact built-in + `str`; +- `looks_like_date_value`: exact built-in `str`. + +All non-allowlisted exact types bypass before any hashing or equality operation. +Subclasses, NumPy scalars, and user-defined values are never cached. Discovery +measures all seven operations; production may enable only the subset that +discovery proves material and that the implementation plan names explicitly. No +other operation is eligible. + ### 2. Minimal GREEN change Create one private cache when `build_semantic_context` starts and share it only with that invocation's `_build_info` calls. Destroy it when the build returns or -raises. Do not add a public parameter or configuration switch. +raises. Do not add a public parameter or configuration switch. Do not add a size +cap: the one-build lifetime and the memory acceptance gate are the controlling +bounds, and the evidence does not justify another policy. Evaluate only explicitly named, pure deterministic operations through the request-local helper. Use the underlying parser/predicate identity, not an @@ -130,10 +161,9 @@ perform the existing `str(v)` conversion in its existing order, then key the parser by the exact string it receives. Include both `type(value)` and `value` in every key so `1`, `True`, and -numeric-equivalent values of different Python types cannot collide. Restrict -eligibility to input types whose immutable, stable hashing/equality behavior is -explicitly proven. Bypass non-hashable values and user-defined or otherwise -unsafe values without invoking their custom hashing merely to test eligibility. +numeric-equivalent values of different Python types cannot collide. Apply the +exact operation/type allowlist above before hashing or equality; every other +value bypasses directly. Call the original operation on a miss. Store a result only after successful return and only when its result contract is immutable. The current candidate From c35a0748cad2a8b9ba00af918fa9d45da9241ae0 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 23:24:11 +0530 Subject: [PATCH 29/37] docs: plan semantic performance optimization --- ...hdata-semantic-performance-optimization.md | 432 ++++++++++++++++++ 1 file changed, 432 insertions(+) create mode 100644 docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md diff --git a/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md b/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md new file mode 100644 index 0000000..d01cde8 --- /dev/null +++ b/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md @@ -0,0 +1,432 @@ +# FreshData Semantic Performance Optimization Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox syntax for tracking. + +**Goal:** Either ship a verified request-local semantic-context reuse optimization, or publish a measured rejection without expanding scope. + +**Architecture:** A benchmark-only probe measures only the seven approved context operations and resets for every context build. If within-build repetition is material, build_semantic_context owns one private memo shared only with its _build_info calls. Separately, analyzer field validators remove the six known mypy errors without changing the JSON contract. + +**Tech Stack:** Python 3.9+, pandas 1.5–<3, pytest, unittest.mock, cProfile/tracemalloc harness, Ruff, mypy, MkDocs. + +## Global Constraints + +- Preserve Python >=3.9, pandas >=1.5,<3, NumPy >=1.21, public APIs/configuration, and add no dependency. +- Preserve dataframe values/order/index/dtypes, input mutation, warnings/errors, report/audit serialization and ordering, policies/protected columns, semantic modes, memory/profile replay, and native/fallback behavior. +- Scope is only case 9ea9cb03dfc114c5 and its semantic-context candidate. Do not optimize MissForest, correlation, backend conversion, copy, dtype, reporting, uniqueness, or null scanning. +- The operation universe is exactly is_plain_number, parse_number_words, post-str(v) parse_boolean, parse_currency, parse_unit, email-shape matching, and looks_like_date_value. +- Cache exact built-in str/int/float/bool only for is_plain_number and exact built-in str only for every other operation. Bypass every other value before hashing/equality. +- Cache lifetime is one build_semantic_context call. No global/lru cache, public switch, cross-request state, dependency, or speculative size cap. +- Cache only successful immutable results; never cache/suppress/reorder exceptions. +- Accept only a >=10% median primary-case win exceeding 2x the larger CV, exact output/report fingerprints, no material memory regression, no meaningful default/aggressive control regression, and a confirming profile. + +--- + +## File Structure + +| Path | Responsibility | +| --- | --- | +| benchmarks/performance/semantic_probe.py | Development-only single-build instrumentation; never imported by production FreshData. | +| tests/performance/test_semantic_probe.py | Probe reset, keying, conversion, and bypass tests. | +| src/freshdata/semantic/context.py | Conditional private one-build memo and unchanged context scoring. | +| tests/test_semantic_cleaning.py | Memo lifetime, key separation, bypass, exception, and public behavior tests. | +| benchmarks/performance/analysis.py | Runtime-checked typed analyzer helpers. | +| tests/performance/test_analysis_render.py | Analyzer malformed-record regressions. | +| docs/performance-investigation.md | Actual Phase 2 evidence and accepted/rejected result. | + +### Task 1: Add the development-only semantic repetition probe + +**Files:** + +- Create: benchmarks/performance/semantic_probe.py +- Create: tests/performance/test_semantic_probe.py + +**Interfaces:** + +- Consumes: freshdata.semantic.context.build_semantic_context, the seven context operation references, pandas.DataFrame, CleanConfig. +- Produces: SemanticProbeBuild containing per-operation total_calls, eligible_calls, bypassed_calls, unique_keys, theoretical_hits, hit_rate, and in-memory eligible value sequence; probe_context_build(df, config, *, stats=None). +- Does not modify production code, the benchmark schema, or the CLI. + +- [ ] **Step 1: Write failing probe tests** + +~~~python +def test_probe_counts_only_within_one_context_build() -> None: + frame = pd.DataFrame({ + "left": ["yes", "no", "2024-01-01"], + "right": ["yes", "no", "2024-01-01"], + }) + config = CleanConfig(semantic_mode="assist", verbose=False) + + _context, first = probe_context_build(frame, config) + _context, second = probe_context_build(frame, config) + + assert first.by_operation["parse_boolean"].theoretical_hits >= 1 + assert second.total_theoretical_hits == first.total_theoretical_hits + + +def test_probe_uses_exact_types_and_bypasses_unsafe_values() -> None: + frame = pd.DataFrame({"ints": [1], "bools": [True], "text": ["1"]}) + _context, result = probe_context_build( + frame, CleanConfig(semantic_mode="assist", verbose=False) + ) + + numeric = result.by_operation["is_plain_number"] + assert {type(value) for value in numeric.eligible_values} == {int, bool, str} + assert numeric.unique_keys == 3 +~~~ + +Also add direct-helper tests proving a list is bypassed without hashing and that parse_boolean records the post-str(v) string. + +- [ ] **Step 2: Verify RED** + +Run: .venv-qa/bin/python -m pytest tests/performance/test_semantic_probe.py -q --no-cov + +Expected: FAIL because the module does not exist. + +- [ ] **Step 3: Implement the minimal probe** + +~~~python +@dataclass(frozen=True) +class OperationProbe: + total_calls: int + eligible_calls: int + bypassed_calls: int + unique_keys: int + theoretical_hits: int + eligible_values: tuple[object, ...] + + @property + def hit_rate(self) -> float: + return self.theoretical_hits / self.eligible_calls if self.eligible_calls else 0.0 + + +def _eligible(operation: str, value: object) -> bool: + return type(value) in _ALLOWED_TYPES[operation] + + +def probe_context_build( + df: pd.DataFrame, + config: CleanConfig, + *, + stats: dict[object, tuple[int, int, int | None]] | None = None, +) -> tuple[SemanticContext, SemanticProbeBuild]: + with _patched_context_operations() as probe: + context = semantic_context.build_semantic_context(df, config, stats=stats) + return context, probe.finish_build() +~~~ + +Patch the six imported callable references in freshdata.semantic.context plus an _EMAIL_VALUE proxy whose match method records the already-stripped value then delegates. Eligible keys are (operation, type(value), value). A new probe is created for every function call, all raw keys remain in memory only, and bypassed values are never hashed. + +- [ ] **Step 4: Verify GREEN** + +Run: .venv-qa/bin/python -m pytest tests/performance/test_semantic_probe.py -q --no-cov && .venv-qa/bin/ruff check benchmarks/performance/semantic_probe.py tests/performance/test_semantic_probe.py + +Expected: PASS. + +- [ ] **Step 5: Commit** + +~~~bash +git add benchmarks/performance/semantic_probe.py tests/performance/test_semantic_probe.py +git commit -m "test: add semantic context repetition probe" +~~~ + +### Task 2: Record the hard discovery decision + +**Files:** + +- Modify: docs/performance-investigation.md +- Create locally only: .superpowers/sdd/task-9-semantic-discovery.md + +**Interfaces:** + +- Consumes: Task 1 and make_mixed_frame(DatasetSpec(rows=100000, width="medium", seed=42, dataset_type="mixed")) with CleanConfig(semantic_mode="assist", verbose=False). +- Produces: a committed entry with the command, environment, per-operation metrics, and accepted_for_implementation or rejected_no_material_within_build_reuse. +- Decision boundary: only hits within one build count; warm-up, measurement, memory, profiling, and all cross-build repetitions never count. + +- [ ] **Step 1: Add a focused discovery fixture test** + +~~~python +def test_probe_reports_reuse_for_repeated_context_values() -> None: + frame = pd.DataFrame({ + "one": ["yes", "no", "2024-01-01"], + "two": ["yes", "no", "2024-01-01"], + }) + _context, result = probe_context_build( + frame, CleanConfig(semantic_mode="assist", verbose=False) + ) + assert result.total_theoretical_hits > 0 + assert result.by_operation["looks_like_date_value"].theoretical_hits > 0 +~~~ + +- [ ] **Step 2: Run the test and single-build primary measurement** + +Run: .venv-qa/bin/python -m pytest tests/performance/test_semantic_probe.py::test_probe_reports_reuse_for_repeated_context_values -q --no-cov + +Then, serially: + +~~~bash +PYTHONPATH=src .venv-qa/bin/python -c 'from benchmarks.performance.datasets import DatasetSpec, make_mixed_frame; from benchmarks.performance.semantic_probe import probe_context_build; from freshdata.config import CleanConfig; frame = make_mixed_frame(DatasetSpec(rows=100000, width="medium", seed=42, dataset_type="mixed")); _, result = probe_context_build(frame, CleanConfig(semantic_mode="assist", verbose=False)); print(result.to_json())' +~~~ + +Expected: valid JSON for one context build. + +- [ ] **Step 3: Make the explicit branch decision** + +Advance only if repeated eligible calls occur in measured hot operations and their timed repeat work makes a 10% end-to-end win plausible. Otherwise skip Task 3, record rejection, do not change src/freshdata/semantic/context.py, and continue to Tasks 4 and 5. + +- [ ] **Step 4: Document and commit actual evidence** + +Add the exact command, commit/dirty state, each per-operation metric, decision, and reason to docs/performance-investigation.md. A rejected result must say no production optimization was implemented; an accepted result must say it only passed discovery. + +Run: .venv-qa/bin/mkdocs build --strict && git diff --check + +~~~bash +git add docs/performance-investigation.md +git commit -m "docs: record semantic discovery decision" +~~~ + +### Task 3: Conditionally add request-local reuse + +**Files:** + +- Modify: src/freshdata/semantic/context.py:43-253 +- Modify: tests/test_semantic_cleaning.py:349-550 + +**Interfaces:** + +- Consumes: Task 2's explicitly accepted operation subset. +- Produces: private _SemanticContextMemo.call(operation, value, fn), constructed once in build_semantic_context and passed to _build_info. +- Guarantees: operation/type/value key separation; pre-hash bypass; successful immutable results only; no cross-build state or cached exceptions. + +- [ ] **Step 1: Write failing cache and equivalence tests** + +~~~python +def test_context_reuses_repeated_values_only_within_one_build(monkeypatch) -> None: + calls = 0 + original = semantic_context.is_plain_number + + def observed(value: object) -> bool: + nonlocal calls + calls += 1 + return original(value) + + monkeypatch.setattr(semantic_context, "is_plain_number", observed) + frame = pd.DataFrame({"left": ["12", "yes"], "right": ["12", "yes"]}) + config = CleanConfig(semantic_mode="assist", verbose=False) + + build_semantic_context(frame, config) + assert calls == 2 + build_semantic_context(frame, config) + assert calls == 4 + + +def test_context_memo_distinguishes_bool_int_and_str() -> None: + memo = semantic_context._SemanticContextMemo() + calls: list[object] = [] + + def observed(value: object) -> bool: + calls.append(value) + return semantic_context.is_plain_number(value) + + assert memo.call("is_plain_number", 1, observed) is True + assert memo.call("is_plain_number", True, observed) is False + assert memo.call("is_plain_number", "1", observed) is True + assert calls == [1, True, "1"] +~~~ + +Add failing tests for list bypass with two underlying calls, two identical raised exceptions, and a repeated semantic fixture with exact cleaned dataframe/report action fingerprint. Parameterize public cleaning assertions over off, assist, review, and auto and retain protected-column expectations. + +- [ ] **Step 2: Verify RED** + +Run: .venv-qa/bin/python -m pytest tests/test_semantic_cleaning.py -q --no-cov -k "context_memo or repeated_values or protected or semantic" + +Expected: FAIL because _SemanticContextMemo does not exist. + +- [ ] **Step 3: Implement the minimal private memo** + +~~~python +_MISSING = object() + +class _SemanticContextMemo: + def __init__(self) -> None: + self._values: dict[tuple[str, type[object], object], object] = {} + + def call(self, operation: str, value: object, fn: Callable[[Any], T]) -> T: + if type(value) not in _ALLOWED_TYPES[operation]: + return fn(value) + key = (operation, type(value), value) + cached = self._values.get(key, _MISSING) + if cached is not _MISSING: + return cast(T, cached) + result = fn(value) + self._values[key] = result + return result +~~~ + +Introduce _email_shape(value: str) returning exactly bool(_EMAIL_VALUE.match(value.strip())). Preserve post-str(v) Boolean conversion by memo.call("parse_boolean", str(v), parse_boolean). Instantiate the memo only inside build_semantic_context, pass it to _build_info, and enable only Task 2's proven operation subset. + +- [ ] **Step 4: Verify behavior** + +Run: .venv-qa/bin/python -m pytest tests/test_semantic_cleaning.py tests/test_semantic_backends.py tests/test_execution/test_native_semantic.py tests/learning/test_replay.py -q --no-cov + +Expected: PASS. Any changed report ordering, exception, policy result, or native parity is a stop-and-revert condition. + +- [ ] **Step 5: Commit** + +~~~bash +git add src/freshdata/semantic/context.py tests/test_semantic_cleaning.py +git commit -m "perf: reuse semantic context predicate results" +~~~ + +### Task 4: Fix the six inherited analyzer mypy errors + +**Files:** + +- Modify: benchmarks/performance/analysis.py:12-252 +- Modify: tests/performance/test_analysis_render.py + +**Interfaces:** + +- Consumes: schema-validated dict[str, object] profiles. +- Produces: HypothesisRule and checked numeric/record helpers while retaining output ordering, thresholds, and JSON semantics. + +- [ ] **Step 1: Write failing malformed-profile tests** + +~~~python +def test_hypothesis_classifier_rejects_non_integer_profile_line() -> None: + profile = _empty_profile() + profile["functions"] = [{ + "file": "src/freshdata/engine/context.py", + "line": "bad", + "function": "build_context", + "self_seconds": 0.0, + "cumulative_seconds": 0.0, + "calls": 1, + }] + with pytest.raises(TypeError, match="profile function line must be an integer"): + classify_hypotheses(profile) +~~~ + +Add matching assertions for non-finite stage values and non-integer operation/call counts. Existing valid-profile classifier tests remain unchanged. + +- [ ] **Step 2: Verify RED** + +Run: .venv-qa/bin/python -m pytest tests/performance/test_analysis_render.py -q --no-cov + +Expected: FAIL because malformed fields currently fall through to int/float conversion. + +- [ ] **Step 3: Add checked types and helpers** + +~~~python +class HypothesisRule(TypedDict): + stages: tuple[str, ...] + operations: tuple[str, ...] + evidence: tuple[tuple[str, tuple[str, ...]], ...] + + +def _integer_field(value: object, label: str) -> int: + if isinstance(value, bool) or not isinstance(value, int): + raise TypeError(f"{label} must be an integer") + return value + + +def _finite_number_field(value: object, label: str) -> float: + if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value): + raise TypeError(f"{label} must be a finite number") + return float(value) +~~~ + +Annotate _HYPOTHESES as dict[str, HypothesisRule]. Check and narrow function/allocation arrays before using them. Use the helpers for lines, stage values, operations, calls, and allocation bytes; do not use a cast to evade validation. + +- [ ] **Step 4: Verify GREEN** + +Run: .venv-qa/bin/python -m pytest tests/performance/test_analysis_render.py -q --no-cov && .venv-qa/bin/mypy benchmarks/performance/analysis.py && .venv-qa/bin/ruff check benchmarks/performance/analysis.py tests/performance/test_analysis_render.py + +Expected: PASS and mypy reports Success: no issues found. + +- [ ] **Step 5: Commit** + +~~~bash +git add benchmarks/performance/analysis.py tests/performance/test_analysis_render.py +git commit -m "fix: validate performance analysis record fields" +~~~ + +### Task 5: Run acceptance, publish the Phase 2 outcome, and verify completion + +**Files:** + +- Modify: docs/performance-investigation.md +- Modify only if regenerated: benchmarks/results/performance/baseline-summary.json +- Modify only if regenerated: benchmarks/results/performance/baseline-report.md + +**Interfaces:** + +- Consumes: Task 2 decision, Task 3 if accepted, primary/control benchmark JSON, and a confirming profile. +- Produces: evidence-backed accepted or rejected Phase 2 result, never an unsupported performance claim. + +- [ ] **Step 1: Capture clean serial benchmark evidence** + +Before Task 3, run: + +~~~bash +.venv-qa/bin/python -m benchmarks.performance run --rows 100000 --widths medium --configs semantic --report-modes true --backends pandas --output-formats pandas --seed 42 --warmups 1 --repetitions 5 --output /private/tmp/freshdata-semantic-before +~~~ + +After Task 3, run serially: + +~~~bash +.venv-qa/bin/python -m benchmarks.performance run --rows 100000 --widths medium --configs semantic,default,aggressive --report-modes true --backends pandas --output-formats pandas --seed 42 --warmups 1 --repetitions 5 --output /private/tmp/freshdata-semantic-after +~~~ + +If Task 2 rejects, skip before/after runs and retain the discovery evidence. + +- [ ] **Step 2: Apply the acceptance gate** + +For an accepted implementation, require equal output_fingerprint, report_fingerprint, and result_type; classify timing with classify_change(before_median, after_median, before_cv, after_cv); inspect raw samples, RSS, Python allocation peak, and both controls. Revert Task 3 if any required gate fails. + +- [ ] **Step 3: Capture a confirming profile** + +~~~bash +.venv-qa/bin/python -m benchmarks.performance profile --rows 100000 --widths medium --configs semantic --report-modes true --backends pandas --output-formats pandas --seed 42 --warmups 1 --repetitions 5 --output /private/tmp/freshdata-semantic-profile-after +~~~ + +Confirm targeted context-operation work decreases without merely shifting to another stage. + +- [ ] **Step 4: Publish actual, not projected, evidence** + +Update docs/performance-investigation.md with command, environment, dirty state, metrics, fingerprints, profile delta, and accepted/rejected conclusion. If rejected, retain the no-production-optimization statement and explain why. Regenerate compact result/report artifacts only when their schema stays valid and no duplicate case rows are introduced. + +- [ ] **Step 5: Final verification and commit** + +Run serially: + +~~~bash +.venv-qa/bin/python -m pytest tests/test_semantic_cleaning.py tests/test_semantic_backends.py tests/test_execution/test_native_semantic.py tests/learning/test_replay.py tests/performance -q --no-cov +.venv-qa/bin/ruff check src tests benchmarks/performance +.venv-qa/bin/mypy src/freshdata +.venv-qa/bin/mypy benchmarks/performance/analysis.py +.venv-qa/bin/mkdocs build --strict +git diff --check +.venv-qa/bin/python -m pytest +~~~ + +Commit intended documentation/compact artifacts only: + +~~~bash +git add docs/performance-investigation.md benchmarks/results/performance/baseline-summary.json benchmarks/results/performance/baseline-report.md +git commit -m "docs: publish semantic optimization outcome" +~~~ + +Omit unchanged paths. Never commit raw /private/tmp results, .venv-qa, or .superpowers/sdd reports. + +## Review Gates + +After each task, create an exact base..HEAD review package, use a fresh read-only reviewer, fix every Critical or Important finding, then re-review the correction range. The final review checks the accepted/rejected evidence chain, production diff, static checks, links, and intended worktree. + +## Plan Self-Review + +- Tasks 1–2 implement the mandatory per-build discovery gate. +- Task 3 is the sole conditional production optimization. +- Task 4 resolves exactly the six inherited analysis.py mypy errors, not unrelated benchmark typing debt. +- Task 5 enforces equivalence, timing, memory, controls, profile, documentation, and complete verification. +- Every code task includes paths, interfaces, RED, GREEN, commands, and a commit. + From 0bae1018c4a653de5cb705cf51885ed98e6b8e2e Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 23:25:29 +0530 Subject: [PATCH 30/37] docs: clarify conditional semantic plan --- ...hdata-semantic-performance-optimization.md | 34 ++++++++++++------- 1 file changed, 21 insertions(+), 13 deletions(-) diff --git a/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md b/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md index d01cde8..5865511 100644 --- a/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md +++ b/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md @@ -64,7 +64,11 @@ def test_probe_counts_only_within_one_context_build() -> None: def test_probe_uses_exact_types_and_bypasses_unsafe_values() -> None: - frame = pd.DataFrame({"ints": [1], "bools": [True], "text": ["1"]}) + frame = pd.DataFrame({ + "ints": pd.Series([1], dtype=object), + "bools": pd.Series([True], dtype=object), + "text": pd.Series(["1"], dtype=object), + }) _context, result = probe_context_build( frame, CleanConfig(semantic_mode="assist", verbose=False) ) @@ -200,23 +204,22 @@ git commit -m "docs: record semantic discovery decision" - [ ] **Step 1: Write failing cache and equivalence tests** ~~~python -def test_context_reuses_repeated_values_only_within_one_build(monkeypatch) -> None: +def test_context_memo_reuses_only_within_one_memo() -> None: + memo = semantic_context._SemanticContextMemo() calls = 0 - original = semantic_context.is_plain_number def observed(value: object) -> bool: nonlocal calls calls += 1 - return original(value) - - monkeypatch.setattr(semantic_context, "is_plain_number", observed) - frame = pd.DataFrame({"left": ["12", "yes"], "right": ["12", "yes"]}) - config = CleanConfig(semantic_mode="assist", verbose=False) + return semantic_context.is_plain_number(value) - build_semantic_context(frame, config) + assert memo.call("is_plain_number", "12", observed) is True + assert memo.call("is_plain_number", "12", observed) is True + assert calls == 1 + assert semantic_context._SemanticContextMemo().call( + "is_plain_number", "12", observed + ) is True assert calls == 2 - build_semantic_context(frame, config) - assert calls == 4 def test_context_memo_distinguishes_bool_int_and_str() -> None: @@ -233,7 +236,13 @@ def test_context_memo_distinguishes_bool_int_and_str() -> None: assert calls == [1, True, "1"] ~~~ -Add failing tests for list bypass with two underlying calls, two identical raised exceptions, and a repeated semantic fixture with exact cleaned dataframe/report action fingerprint. Parameterize public cleaning assertions over off, assist, review, and auto and retain protected-column expectations. +Add failing tests for list bypass with two underlying calls, two identical raised +exceptions, and a repeated semantic fixture for the exact operation selected by +Task 2. That fixture must prove the selected call site invokes its underlying +operation once per repeated key within one build and again in a second build, +then assert the exact cleaned dataframe/report action fingerprint. Parameterize +public cleaning assertions over off, assist, review, and auto and retain +protected-column expectations. - [ ] **Step 2: Verify RED** @@ -429,4 +438,3 @@ After each task, create an exact base..HEAD review package, use a fresh read-onl - Task 4 resolves exactly the six inherited analysis.py mypy errors, not unrelated benchmark typing debt. - Task 5 enforces equivalence, timing, memory, controls, profile, documentation, and complete verification. - Every code task includes paths, interfaces, RED, GREEN, commands, and a commit. - From e30b54875e44292b177b039a0e49194be5a5ee11 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 23:37:01 +0530 Subject: [PATCH 31/37] test: add semantic context repetition probe --- benchmarks/performance/semantic_probe.py | 217 +++++++++++++++++++++++ tests/performance/test_semantic_probe.py | 62 +++++++ 2 files changed, 279 insertions(+) create mode 100644 benchmarks/performance/semantic_probe.py create mode 100644 tests/performance/test_semantic_probe.py diff --git a/benchmarks/performance/semantic_probe.py b/benchmarks/performance/semantic_probe.py new file mode 100644 index 0000000..d1628ae --- /dev/null +++ b/benchmarks/performance/semantic_probe.py @@ -0,0 +1,217 @@ +"""Development-only instrumentation for semantic context repetition. + +The probe wraps the pure value-shape helpers used by +``freshdata.semantic.context``. It deliberately keeps all observations in +memory and creates a fresh collector for each context build, making the +result useful for estimating the benefit of a per-build memoization layer +without changing production behavior. +""" + +from __future__ import annotations + +from collections.abc import Iterator, Mapping +from contextlib import ExitStack, contextmanager +from dataclasses import dataclass +from typing import Any, Callable +from unittest.mock import patch + +import pandas as pd + +from freshdata.config import CleanConfig +from freshdata.semantic import context as semantic_context +from freshdata.semantic.types import SemanticContext + +# ``column_name_is_identifier`` is intentionally not included: the repetition +# candidates are the six value parsers plus the email-value regex check. +_OPERATIONS = ( + "is_plain_number", + "parse_number_words", + "parse_boolean", + "parse_currency", + "parse_unit", + "email_value", + "looks_like_date_value", +) +_CALLABLE_OPERATIONS = ( + "is_plain_number", + "parse_number_words", + "parse_boolean", + "parse_currency", + "parse_unit", + "looks_like_date_value", +) + +# Exact-type gating keeps key construction safe and mirrors the values each +# helper is designed to inspect. In particular, bool is observable by +# ``is_plain_number`` even though the helper itself excludes it semantically. +_ALLOWED_TYPES: Mapping[str, tuple[type[object], ...]] = { + "is_plain_number": (int, float, bool, str), + "parse_number_words": (str,), + "parse_boolean": (str,), + "parse_currency": (str,), + "parse_unit": (str,), + "looks_like_date_value": (str,), + "email_value": (str,), +} + + +@dataclass(frozen=True) +class OperationProbe: + """Immutable observations for one semantic helper during one build.""" + + total_calls: int + eligible_calls: int + bypassed_calls: int + unique_keys: int + theoretical_hits: int + eligible_values: tuple[object, ...] + + @property + def hit_rate(self) -> float: + return self.theoretical_hits / self.eligible_calls if self.eligible_calls else 0.0 + + +@dataclass(frozen=True) +class SemanticProbeBuild: + """Per-operation probe results for one ``build_semantic_context`` call.""" + + by_operation: Mapping[str, OperationProbe] + + @property + def total_theoretical_hits(self) -> int: + return sum(item.theoretical_hits for item in self.by_operation.values()) + + @property + def total_calls(self) -> int: + return sum(item.total_calls for item in self.by_operation.values()) + + @property + def total_eligible_calls(self) -> int: + return sum(item.eligible_calls for item in self.by_operation.values()) + + @property + def total_bypassed_calls(self) -> int: + return sum(item.bypassed_calls for item in self.by_operation.values()) + + +@dataclass +class _MutableOperationProbe: + total_calls: int = 0 + eligible_calls: int = 0 + bypassed_calls: int = 0 + theoretical_hits: int = 0 + + def __post_init__(self) -> None: + self.seen_keys: set[tuple[str, type[object], object]] = set() + self.eligible_values: list[object] = [] + + +def _eligible(operation: str, value: object) -> bool: + """Return whether *value* may safely participate in a repetition key.""" + + return type(value) in _ALLOWED_TYPES[operation] + + +class _ProbeCollector: + """Mutable collector used only while one context build is running.""" + + def __init__(self) -> None: + self._operations = {name: _MutableOperationProbe() for name in _OPERATIONS} + + def record(self, operation: str, value: object) -> None: + state = self._operations[operation] + state.total_calls += 1 + if not _eligible(operation, value): + state.bypassed_calls += 1 + return + + state.eligible_calls += 1 + state.eligible_values.append(value) + # Every allowed exact type is hash-safe. Unsafe values are returned + # above before this key expression is evaluated. + key = (operation, type(value), value) + if key in state.seen_keys: + state.theoretical_hits += 1 + else: + state.seen_keys.add(key) + + def finish_build(self) -> SemanticProbeBuild: + return SemanticProbeBuild( + by_operation={ + name: OperationProbe( + total_calls=state.total_calls, + eligible_calls=state.eligible_calls, + bypassed_calls=state.bypassed_calls, + unique_keys=len(state.seen_keys), + theoretical_hits=state.theoretical_hits, + eligible_values=tuple(state.eligible_values), + ) + for name, state in self._operations.items() + } + ) + + +class _EmailValueProxy: + """Regex proxy that records the already-stripped email candidate.""" + + def __init__(self, delegate: Any, probe: _ProbeCollector) -> None: + self._delegate = delegate + self._probe = probe + + def match(self, value: object, *args: object, **kwargs: object) -> Any: + self._probe.record("email_value", value) + return self._delegate.match(value, *args, **kwargs) + + +@contextmanager +def _patched_context_operations( + probe: _ProbeCollector | None = None, +) -> Iterator[_ProbeCollector]: + """Temporarily wrap context helper references with *probe* recorders.""" + + if probe is None: + probe = _ProbeCollector() + with ExitStack() as stack: + for operation in _CALLABLE_OPERATIONS: + original = getattr(semantic_context, operation) + + def wrapped( + value: object, + *args: object, + _operation: str = operation, + _original: Callable[..., Any] = original, + **kwargs: object, + ) -> Any: + probe.record(_operation, value) + return _original(value, *args, **kwargs) + + stack.enter_context(patch.object(semantic_context, operation, wrapped)) + + stack.enter_context( + patch.object( + semantic_context, + "_EMAIL_VALUE", + _EmailValueProxy(semantic_context._EMAIL_VALUE, probe), + ) + ) + yield probe + + +def probe_context_build( + df: pd.DataFrame, + config: CleanConfig, + *, + stats: dict[object, tuple[int, int, int | None]] | None = None, +) -> tuple[SemanticContext, SemanticProbeBuild]: + """Build semantic context and collect helper repetition observations.""" + + with _patched_context_operations() as probe: + context = semantic_context.build_semantic_context(df, config, stats=stats) + return context, probe.finish_build() + + +__all__ = [ + "OperationProbe", + "SemanticProbeBuild", + "probe_context_build", +] diff --git a/tests/performance/test_semantic_probe.py b/tests/performance/test_semantic_probe.py new file mode 100644 index 0000000..056b529 --- /dev/null +++ b/tests/performance/test_semantic_probe.py @@ -0,0 +1,62 @@ +from __future__ import annotations + +import pandas as pd +from benchmarks.performance.semantic_probe import ( + _ProbeCollector, + probe_context_build, +) + +from freshdata.config import CleanConfig + + +def test_probe_counts_only_within_one_context_build() -> None: + frame = pd.DataFrame( + { + "left": ["yes", "no", "2024-01-01"], + "right": ["yes", "no", "2024-01-01"], + } + ) + config = CleanConfig(semantic_mode="assist", verbose=False) + + _context, first = probe_context_build(frame, config) + _context, second = probe_context_build(frame, config) + + assert first.by_operation["parse_boolean"].theoretical_hits >= 1 + assert second.total_theoretical_hits == first.total_theoretical_hits + + +def test_probe_uses_exact_types_and_bypasses_unsafe_values() -> None: + frame = pd.DataFrame( + { + "ints": pd.Series([1], dtype=object), + "bools": pd.Series([True], dtype=object), + "text": pd.Series(["1"], dtype=object), + } + ) + _context, result = probe_context_build( + frame, CleanConfig(semantic_mode="assist", verbose=False) + ) + + numeric = result.by_operation["is_plain_number"] + assert {type(value) for value in numeric.eligible_values} == {int, bool, str} + assert numeric.unique_keys == 3 + + +def test_direct_probe_bypasses_unhashable_list_without_hashing() -> None: + collector = _ProbeCollector() + value = [1, 2, 3] + collector.record("is_plain_number", value) + + result = collector.finish_build() + numeric = result.by_operation["is_plain_number"] + assert numeric.bypassed_calls == 1 + assert numeric.eligible_calls == 0 + assert numeric.unique_keys == 0 + + +def test_parse_boolean_probe_keeps_post_stringification_value() -> None: + collector = _ProbeCollector() + collector.record("parse_boolean", str(1)) + result = collector.finish_build() + + assert result.by_operation["parse_boolean"].eligible_values == ("1",) From 306a01df6a6c23329895f89083caab67c92707b4 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 23:42:03 +0530 Subject: [PATCH 32/37] fix: exercise semantic probe parse boolean call site --- tests/performance/test_semantic_probe.py | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/tests/performance/test_semantic_probe.py b/tests/performance/test_semantic_probe.py index 056b529..689073e 100644 --- a/tests/performance/test_semantic_probe.py +++ b/tests/performance/test_semantic_probe.py @@ -2,11 +2,13 @@ import pandas as pd from benchmarks.performance.semantic_probe import ( + _patched_context_operations, _ProbeCollector, probe_context_build, ) from freshdata.config import CleanConfig +from freshdata.semantic import context as semantic_context def test_probe_counts_only_within_one_context_build() -> None: @@ -21,6 +23,15 @@ def test_probe_counts_only_within_one_context_build() -> None: _context, first = probe_context_build(frame, config) _context, second = probe_context_build(frame, config) + assert set(first.by_operation) == { + "is_plain_number", + "parse_number_words", + "parse_boolean", + "parse_currency", + "parse_unit", + "email_value", + "looks_like_date_value", + } assert first.by_operation["parse_boolean"].theoretical_hits >= 1 assert second.total_theoretical_hits == first.total_theoretical_hits @@ -55,8 +66,10 @@ def test_direct_probe_bypasses_unhashable_list_without_hashing() -> None: def test_parse_boolean_probe_keeps_post_stringification_value() -> None: - collector = _ProbeCollector() - collector.record("parse_boolean", str(1)) - result = collector.finish_build() + probe = _ProbeCollector() + value = 1 + with _patched_context_operations(probe): + semantic_context.parse_boolean(str(value)) + result = probe.finish_build() - assert result.by_operation["parse_boolean"].eligible_values == ("1",) + assert result.by_operation["parse_boolean"].eligible_values == (str(value),) From 0317f73224623da64ca60fcbf589e496cdfbea51 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 23:48:13 +0530 Subject: [PATCH 33/37] docs: record semantic discovery decision --- docs/performance-investigation.md | 64 ++++++++++++++++++++++-- tests/performance/test_semantic_probe.py | 14 ++++++ 2 files changed, 75 insertions(+), 3 deletions(-) diff --git a/docs/performance-investigation.md b/docs/performance-investigation.md index c1f618e..47c64d1 100644 --- a/docs/performance-investigation.md +++ b/docs/performance-investigation.md @@ -251,14 +251,72 @@ before/after result. ## 10. Tests added or changed -not yet applicable: no production optimization has been implemented - -No optimization-specific test was added or changed in this evidence-only task. +No production optimization was implemented. Task 9.2 added the focused +development-only repetition-discovery fixture in +`tests/performance/test_semantic_probe.py`; it validates within-build reuse +signals without changing FreshData behavior. ## 11. Before-and-after benchmark table not yet applicable: no production optimization has been implemented +### Task 9.2 semantic repetition discovery + +The development-only semantic repetition probe was run against the +representative `DatasetSpec(rows=100000, width="medium", seed=42, +dataset_type="mixed")` frame with `CleanConfig(semantic_mode="assist", +verbose=False)`. The probe commit was `306a01df6a6c23329895f89083caab67c92707b4`. +At measurement start, the worktree was dirty only because of the untracked +`.venv-qa/` directory and the focused test edit (`M +tests/performance/test_semantic_probe.py`, `?? .venv-qa/`); no production +source was modified. The host was macOS 15.5 arm64 (Darwin 24.5.0), Python +3.12.13, pandas 2.3.3, NumPy 2.4.6, and pytest 9.1.1. + +The focused fixture verification was: + +```text +.venv-qa/bin/python -m pytest tests/performance/test_semantic_probe.py::test_probe_reports_reuse_for_repeated_context_values -q --no-cov +.[100%] +``` + +The exact command in the brief (`print(result.to_json())`) cannot run because +`SemanticProbeBuild` intentionally has no `to_json()` API. It failed with +`AttributeError: 'SemanticProbeBuild' object has no attribute 'to_json'`. The +following serialization-only equivalent was run without changing the probe or +production API and produced valid JSON: + +```bash +PYTHONPATH=src .venv-qa/bin/python -c 'import json; from benchmarks.performance.datasets import DatasetSpec, make_mixed_frame; from benchmarks.performance.semantic_probe import probe_context_build; from freshdata.config import CleanConfig; frame = make_mixed_frame(DatasetSpec(rows=100000, width="medium", seed=42, dataset_type="mixed")); _, result = probe_context_build(frame, CleanConfig(semantic_mode="assist", verbose=False)); print(json.dumps({"total_calls": result.total_calls, "total_eligible_calls": result.total_eligible_calls, "total_bypassed_calls": result.total_bypassed_calls, "total_theoretical_hits": result.total_theoretical_hits, "by_operation": {name: {"total_calls": item.total_calls, "eligible_calls": item.eligible_calls, "bypassed_calls": item.bypassed_calls, "unique_keys": item.unique_keys, "theoretical_hits": item.theoretical_hits, "hit_rate": item.hit_rate} for name, item in result.by_operation.items()}}, sort_keys=True))' +``` + +The successful single-build JSON reported `639307` total calls, +`497842` eligible calls, `141465` bypassed calls, and `52725` theoretical +within-build hits: + +| Operation | Total calls | Eligible | Bypassed | Unique keys | Theoretical hits | Hit rate | +| :--- | ---: | ---: | ---: | ---: | ---: | ---: | +| `is_plain_number` | 192,376 | 50,911 | 141,465 | 50,902 | 9 | 0.000177 | +| `parse_number_words` | 50,911 | 50,911 | 0 | 50,902 | 9 | 0.000177 | +| `parse_boolean` | 192,376 | 192,376 | 0 | 139,705 | 52,671 | 0.273792 | +| `parse_currency` | 50,911 | 50,911 | 0 | 50,902 | 9 | 0.000177 | +| `parse_unit` | 50,911 | 50,911 | 0 | 50,902 | 9 | 0.000177 | +| `email_value` | 50,911 | 50,911 | 0 | 50,902 | 9 | 0.000177 | +| `looks_like_date_value` | 50,911 | 50,911 | 0 | 50,902 | 9 | 0.000177 | + +Only calls within this one build count. The repeated `parse_boolean` values are +real eligible hits, but they are not by themselves evidence of a worthwhile +optimization. A temporary timing wrapper around the same single build measured +1.575182417 seconds total and only 0.394354 seconds across all seven helper +operations. Per-operation helper time/call multiplied by each operation's +within-build hit count estimates 0.016639853 seconds of removable repeat work +(1.06% of context-build time, and far below the 10% end-to-end threshold). + +Decision: **`rejected_no_material_within_build_reuse`**. The measured repeat +work does not make a 10% end-to-end improvement plausible, so Task 3 is +skipped. No production optimization was implemented; `src/freshdata` remains +unchanged. Warm-up, measurement, memory, profiling, and cross-build +repetitions were not counted toward this decision. + The table in section 3 is baseline-only. A later phase must rerun the same cases before presenting an optimization comparison. diff --git a/tests/performance/test_semantic_probe.py b/tests/performance/test_semantic_probe.py index 689073e..c7adb54 100644 --- a/tests/performance/test_semantic_probe.py +++ b/tests/performance/test_semantic_probe.py @@ -73,3 +73,17 @@ def test_parse_boolean_probe_keeps_post_stringification_value() -> None: result = probe.finish_build() assert result.by_operation["parse_boolean"].eligible_values == (str(value),) + + +def test_probe_reports_reuse_for_repeated_context_values() -> None: + frame = pd.DataFrame( + { + "one": ["yes", "no", "2024-01-01"], + "two": ["yes", "no", "2024-01-01"], + } + ) + _context, result = probe_context_build( + frame, CleanConfig(semantic_mode="assist", verbose=False) + ) + assert result.total_theoretical_hits > 0 + assert result.by_operation["looks_like_date_value"].theoretical_hits > 0 From b5d154a0a04a3007a60cf13c5f989d20acc13ac8 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Mon, 13 Jul 2026 23:54:22 +0530 Subject: [PATCH 34/37] fix: validate performance analysis record fields --- benchmarks/performance/analysis.py | 94 +++++++++++++++++++---- tests/performance/test_analysis_render.py | 69 +++++++++++++++++ 2 files changed, 146 insertions(+), 17 deletions(-) diff --git a/benchmarks/performance/analysis.py b/benchmarks/performance/analysis.py index 05d58c2..531818a 100644 --- a/benchmarks/performance/analysis.py +++ b/benchmarks/performance/analysis.py @@ -4,12 +4,19 @@ import math from collections.abc import Iterable from pathlib import Path -from typing import Any +from typing import Any, TypedDict from .models import BenchmarkCase from .schema import validate_finite_numbers, validate_result -_HYPOTHESES = { + +class HypothesisRule(TypedDict): + stages: tuple[str, ...] + operations: tuple[str, ...] + evidence: tuple[tuple[str, tuple[str, ...]], ...] + + +_HYPOTHESES: dict[str, HypothesisRule] = { "unnecessary_correlation": { "stages": ("correlation",), "operations": ("dataframe.corr", "dataframe.corrwith"), @@ -191,15 +198,41 @@ def _matches( ) -def _source_location(record: dict[str, object]) -> tuple[str, int]: +def _integer_field(value: object, label: str) -> int: + if isinstance(value, bool) or not isinstance(value, int): + raise TypeError(f"{label} must be an integer") + return value + + +def _finite_number_field(value: object, label: str) -> float: + if ( + isinstance(value, bool) + or not isinstance(value, (int, float)) + or not math.isfinite(value) + ): + raise TypeError(f"{label} must be a finite number") + return float(value) + + +def _record_array(value: object, label: str) -> list[dict[str, object]]: + if not isinstance(value, list): + raise TypeError(f"{label} must be an array") + records: list[dict[str, object]] = [] + for record in value: + if not isinstance(record, dict): + raise TypeError(f"{label} must contain objects") + records.append(record) + return records + + +def _source_location(record: dict[str, object], line_label: str) -> tuple[str, int]: path = str(record.get("file", "")).replace("\\", "/").lower() - return path, int(record.get("line", -1)) + return path, _integer_field(record.get("line", -1), line_label) def classify_hypotheses( profile: dict[str, object], *, traced_peak_bytes: int | None = None ) -> dict[str, dict[str, object]]: - validate_finite_numbers(profile, "profile") validate_finite_numbers(traced_peak_bytes, "traced peak bytes") stages = profile.get("stages", {}) operations = profile.get("operations", {}) @@ -207,31 +240,58 @@ def classify_hypotheses( allocations = profile.get("allocations", []) if not isinstance(stages, dict) or not isinstance(operations, dict): raise TypeError("profile stages and operations must be objects") - if not isinstance(functions, list) or not isinstance(allocations, list): - raise TypeError("profile functions and allocations must be arrays") - total = float(stages.get("total", 0.0)) + function_records = _record_array(functions, "profile functions") + allocation_records = _record_array(allocations, "profile allocations") + for stage, value in stages.items(): + _finite_number_field(value, f"profile stage {stage}") + for operation, value in operations.items(): + _integer_field(value, f"profile operation {operation}") + for record in function_records: + _integer_field(record.get("line", -1), "profile function line") + _integer_field(record.get("calls", 0), "profile function calls") + for record in allocation_records: + _integer_field(record.get("line", -1), "profile allocation line") + _integer_field(record.get("bytes", 0), "profile allocation bytes") + validate_finite_numbers(profile, "profile") + total = _finite_number_field(stages.get("total", 0.0), "profile stage total") decisions: dict[str, dict[str, object]] = {} for name, rule in _HYPOTHESES.items(): - stage_seconds = sum(float(stages.get(stage, 0.0)) for stage in rule["stages"]) + stage_seconds = sum( + _finite_number_field(stages.get(stage, 0.0), f"profile stage {stage}") + for stage in rule["stages"] + ) stage_fraction = stage_seconds / total if total > 0 else 0.0 function_evidence = [ record - for record in functions - if isinstance(record, dict) and _matches(record, rule["evidence"]) + for record in function_records + if _matches(record, rule["evidence"]) ] - exact_function_locations = {_source_location(record) for record in function_evidence} + exact_function_locations = { + _source_location(record, "profile function line") + for record in function_evidence + } allocation_evidence = [ record - for record in allocations - if isinstance(record, dict) and _source_location(record) in exact_function_locations + for record in allocation_records + if _source_location(record, "profile allocation line") + in exact_function_locations ] - operation_calls = sum(int(operations.get(key, 0)) for key in rule["operations"]) - exact_function_calls = sum(int(record.get("calls", 0)) for record in function_evidence) + operation_calls = sum( + _integer_field(operations.get(key, 0), f"profile operation {key}") + for key in rule["operations"] + ) + exact_function_calls = sum( + _integer_field(record.get("calls", 0), "profile function calls") + for record in function_evidence + ) observed_calls = operation_calls or exact_function_calls significant_allocations = ( traced_peak_bytes is not None and traced_peak_bytes > 0 - and sum(int(record.get("bytes", 0)) for record in allocation_evidence) + and sum( + _integer_field(record.get("bytes", 0), "profile allocation bytes") + for record in allocation_evidence + ) / traced_peak_bytes >= 0.10 ) diff --git a/tests/performance/test_analysis_render.py b/tests/performance/test_analysis_render.py index 7e5e62e..73d0a9d 100644 --- a/tests/performance/test_analysis_render.py +++ b/tests/performance/test_analysis_render.py @@ -116,6 +116,75 @@ def test_hypothesis_classifier_requires_exact_profile_evidence() -> None: assert decision["evidence"] == profile["functions"] +def test_hypothesis_classifier_rejects_non_integer_profile_line() -> None: + profile = _empty_profile() + profile["functions"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": "bad", + "function": "build_context", + "self_seconds": 0.0, + "cumulative_seconds": 0.0, + "calls": 1, + } + ] + + with pytest.raises(TypeError, match="profile function line must be an integer"): + classify_hypotheses(profile) + + +def test_hypothesis_classifier_rejects_non_finite_stage_value() -> None: + profile = _empty_profile() + profile["stages"]["correlation"] = float("inf") # type: ignore[index] + + with pytest.raises( + TypeError, match="profile stage correlation must be a finite number" + ): + classify_hypotheses(profile) + + +def test_hypothesis_classifier_rejects_non_integer_operation_count() -> None: + profile = _empty_profile() + profile["operations"]["dataframe.corr"] = "bad" # type: ignore[index] + + with pytest.raises( + TypeError, match="profile operation dataframe.corr must be an integer" + ): + classify_hypotheses(profile) + + +def test_hypothesis_classifier_rejects_non_integer_function_call_count() -> None: + profile = _empty_profile() + profile["functions"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": 207, + "function": "numeric_corr_matrix", + "self_seconds": 0.4, + "cumulative_seconds": 0.4, + "calls": "bad", + } + ] + + with pytest.raises(TypeError, match="profile function calls must be an integer"): + classify_hypotheses(profile) + + +def test_hypothesis_classifier_rejects_non_integer_allocation_bytes() -> None: + profile = _empty_profile() + profile["allocations"] = [ + { + "file": "src/freshdata/engine/context.py", + "line": 207, + "bytes": "bad", + "count": 1, + } + ] + + with pytest.raises(TypeError, match="profile allocation bytes must be an integer"): + classify_hypotheses(profile) + + def test_hypothesis_classifier_does_not_substitute_unrelated_evidence() -> None: profile = _empty_profile() profile["stages"]["correlation"] = 0.40 # type: ignore[index] From d4f4eadeb27080d9bf48ccd3b6517d19e23c108b Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Tue, 14 Jul 2026 00:02:15 +0530 Subject: [PATCH 35/37] docs: publish semantic optimization outcome --- docs/performance-investigation.md | 56 ++++++++++++++++++++++++++++--- 1 file changed, 52 insertions(+), 4 deletions(-) diff --git a/docs/performance-investigation.md b/docs/performance-investigation.md index 47c64d1..d25d4c9 100644 --- a/docs/performance-investigation.md +++ b/docs/performance-investigation.md @@ -320,6 +320,27 @@ repetitions were not counted toward this decision. The table in section 3 is baseline-only. A later phase must rerun the same cases before presenting an optimization comparison. +### Phase 2 acceptance outcome (Task 9.5) + +The Task 2 decision is **`rejected_no_material_within_build_reuse`**. The +discovery evidence above estimates only `0.016639853` seconds of removable +repeat helper work, or `1.06%` of context-build time, which cannot plausibly +meet the required 10% end-to-end improvement threshold. Consequently, the +conditional Task 3 production optimization was not implemented. + +Per the brief's rejected branch, the serial before/after benchmark commands +and the confirming profile command were intentionally skipped; the Task 2 +discovery evidence is retained as the authoritative Phase 2 measurement. There +is therefore no before/after timing, RSS, allocation-peak, output-fingerprint, +report-fingerprint, result-type, or profile delta to claim. The outcome is an +evidence-backed rejection, not a projected performance result. `src/freshdata` +remains byte-for-byte unchanged relative to `6f6c2fe`. + +The final acceptance environment was macOS 15.5 arm64, Python 3.12.13, pandas +2.3.3, and NumPy 2.4.6. At verification the only worktree dirt was the +pre-existing untracked `.venv-qa/` directory; no raw benchmark output or +`.superpowers/sdd` report is part of the production change. + ## 12. Peak-memory comparison No optimization before/after memory comparison exists. This baseline-only 1M/ @@ -393,6 +414,32 @@ progress, but no optimization-specific user-documentation correction is claimed. ## 17. Exact verification commands and results +```bash +.venv-qa/bin/python -m pytest tests/test_semantic_cleaning.py tests/test_semantic_backends.py tests/test_execution/test_native_semantic.py tests/learning/test_replay.py tests/performance -q --no-cov +.venv-qa/bin/ruff check src tests benchmarks/performance +.venv-qa/bin/mypy src/freshdata +.venv-qa/bin/mypy benchmarks/performance/analysis.py +.venv-qa/bin/mkdocs build --strict +git diff --check +.venv-qa/bin/python -m pytest +``` + +Final Task 9.5 gate results: + +| Command | Exit | Result | +| :--- | ---: | :--- | +| Semantic/native/replay/performance tests | 0 | Completed at `[100%]`; no failures | +| Ruff (`src tests benchmarks/performance`) | 0 | `All checks passed!` | +| mypy `src/freshdata` | 0 | No issues in 187 source files | +| mypy `benchmarks/performance/analysis.py` | 0 | No issues in 1 source file | +| Strict MkDocs build | 0 | Documentation built successfully; only existing upstream warning and un-navigated-page INFO | +| `git diff --check` | 0 | No output | +| Full pytest suite | 0 | 3,238 passed, 7 skipped, 18 warnings in 223.55s; no failures | + +The focused and full suites were run serially. The documentation build's +Material-for-MkDocs upstream notice and four existing `docs/superpowers/` +navigation INFO messages are informational and do not fail strict mode. + ```bash .venv-qa/bin/python -m pytest tests/performance -q --no-cov .venv-qa/bin/mkdocs build --strict @@ -400,7 +447,7 @@ git diff --check git diff 6f6c2fe -- src/freshdata ``` -Results from the final documentation verification run: +Results from the earlier documentation verification run: | Command | Exit | Result | | :--- | ---: | :--- | @@ -415,6 +462,7 @@ a strict-build error. ### Optimization-specific acceptance verification -not yet applicable: no production optimization has been implemented - -Acceptance and equivalence results are pending a later production change. +Rejected by the Task 2 gate; no production optimization or before/after +equivalence comparison exists. The required final verification suite passed +serially (see the command table above), and the production-source identity +check remains clean. From 81bed0efb074d7c5e691668648c3da866e5f07a4 Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Tue, 14 Jul 2026 00:06:21 +0530 Subject: [PATCH 36/37] docs: clarify MkDocs navigation notices --- docs/performance-investigation.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/docs/performance-investigation.md b/docs/performance-investigation.md index d25d4c9..f3ac60f 100644 --- a/docs/performance-investigation.md +++ b/docs/performance-investigation.md @@ -436,9 +436,12 @@ Final Task 9.5 gate results: | `git diff --check` | 0 | No output | | Full pytest suite | 0 | 3,238 passed, 7 skipped, 18 warnings in 223.55s; no failures | -The focused and full suites were run serially. The documentation build's -Material-for-MkDocs upstream notice and four existing `docs/superpowers/` -navigation INFO messages are informational and do not fail strict mode. +The focused and full suites were run serially. The final Task 9.5 +documentation build's Material-for-MkDocs upstream notice and four existing +`docs/superpowers/` pages reported as not in `nav` were informational and did +not fail strict mode. The earlier documentation verification run reported two +such un-navigated pages; those were likewise informational and not a +strict-build error. ```bash .venv-qa/bin/python -m pytest tests/performance -q --no-cov From 2679f5a9057bfb5bf60b432b6246e29f17d43dbc Mon Sep 17 00:00:00 2001 From: Johnny Wilson Dougherty Date: Tue, 14 Jul 2026 09:37:06 +0530 Subject: [PATCH 37/37] fix CI compatibility for numeric parsing --- benchmarks/performance/baselines.py | 4 ++-- src/freshdata/steps/dtypes.py | 26 ++++++++++++++++++++++++++ tests/test_dtypes.py | 12 +++++++++++- 3 files changed, 39 insertions(+), 3 deletions(-) diff --git a/benchmarks/performance/baselines.py b/benchmarks/performance/baselines.py index b51e78e..59c827b 100644 --- a/benchmarks/performance/baselines.py +++ b/benchmarks/performance/baselines.py @@ -12,7 +12,7 @@ from dataclasses import asdict, replace from itertools import product from pathlib import Path -from typing import Callable, NoReturn +from typing import Callable, NoReturn, Union import pandas as pd @@ -22,7 +22,7 @@ from .models import BenchmarkCase, BenchmarkResult from .schema import validate_result -Baseline = Callable[[pd.DataFrame], pd.DataFrame | pd.Series] +Baseline = Callable[[pd.DataFrame], Union[pd.DataFrame, pd.Series]] def _numeric_median_fill(frame: pd.DataFrame) -> pd.DataFrame: diff --git a/src/freshdata/steps/dtypes.py b/src/freshdata/steps/dtypes.py index 28222fe..bfe8b3a 100644 --- a/src/freshdata/steps/dtypes.py +++ b/src/freshdata/steps/dtypes.py @@ -38,6 +38,10 @@ # digit. These are almost always identifiers (ZIP, phone, padded keys) where # coercion to int silently destroys the padding, so we keep them as text. _LEADING_ZERO = re.compile(r"^\s*[+-]?0\d") +_SCIENTIFIC_NOTATION = re.compile( + r"^[+-]?(?:\d+(?:\.\d*)?|\.\d+)[eE]([+-]?\d+)$" +) +_MAX_SAFE_EXPONENT = 308 def _number_format( @@ -142,12 +146,34 @@ def _try_boolean(s: pd.Series, nonnull: pd.Series) -> pd.Series | None: def _to_numeric_or_none(values: pd.Series) -> pd.Series | None: """``to_numeric`` that tolerates non-scalar cells (lists raise even with ``errors="coerce"``).""" + # pandas 2.3.x can segfault while parsing scientific notation with an + # exponent outside the finite float range. Mask those untrusted tokens + # before handing the series to pandas; they are non-numeric for cleaning + # purposes and will remain missing if the rest of the column converts. + if pd.api.types.is_object_dtype(values.dtype) or pd.api.types.is_string_dtype( + values.dtype + ): + unsafe = values.map(_has_unsafe_scientific_exponent) + if bool(unsafe.any()): + values = values.mask(unsafe) try: return pd.to_numeric(values, errors="coerce") except (TypeError, ValueError): return None +def _has_unsafe_scientific_exponent(value: object) -> bool: + if not isinstance(value, str): + return False + match = _SCIENTIFIC_NOTATION.fullmatch(value.strip()) + if match is None: + return False + try: + return abs(int(match.group(1))) > _MAX_SAFE_EXPONENT + except ValueError: + return True + + def _rescue_formatted( s: pd.Series, parsed: pd.Series, formatted_re: re.Pattern, cleanup: Callable[[pd.Series], pd.Series], diff --git a/tests/test_dtypes.py b/tests/test_dtypes.py index e66c8fe..fca3091 100644 --- a/tests/test_dtypes.py +++ b/tests/test_dtypes.py @@ -5,7 +5,7 @@ import pytest import freshdata as fd -from freshdata.steps.dtypes import _finalize_numeric +from freshdata.steps.dtypes import _finalize_numeric, _to_numeric_or_none def clean1(values, **options): @@ -197,3 +197,13 @@ def test_huge_integer_strings_still_stay_float_end_to_end(): as before the boundary fix.""" s = clean1(["18446744073709551616", "1"]) # 2**64 assert s.dtype == "float64" + + +def test_unsafe_scientific_exponents_are_quarantined_before_pandas_parse(): + """Malformed exponents must not reach pandas' vulnerable numeric parser.""" + values = pd.Series(["1", "1e3000000000", "3"]) + parsed = _to_numeric_or_none(values) + assert parsed is not None + assert parsed.iloc[0] == 1 + assert pd.isna(parsed.iloc[1]) + assert parsed.iloc[2] == 3