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 1efa0b6..c397747 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/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/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/__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/analysis.py b/benchmarks/performance/analysis.py new file mode 100644 index 0000000..531818a --- /dev/null +++ b/benchmarks/performance/analysis.py @@ -0,0 +1,500 @@ +from __future__ import annotations + +import json +import math +from collections.abc import Iterable +from pathlib import Path +from typing import Any, TypedDict + +from .models import BenchmarkCase +from .schema import validate_finite_numbers, validate_result + + +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"), + "evidence": (("/freshdata/engine/context.py", ("numeric_corr_matrix",)),), + }, + "repeated_null_scans": { + "stages": ("missing",), + "operations": ("series.isna", "series.notna"), + "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"), + "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"), + "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"), + "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": (), + "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": (), + "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": (), + "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"), + ), + ), + }, +} + +_PROFILE_COMPANION_STABLE_FIELDS = ( + "schema_version", + "case", + "status", + "result_type", + "input_bytes", + "output_fingerprint", + "report_fingerprint", +) + + +def classify_change( + baseline: float, + candidate: float, + 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: + 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], + relationships: tuple[tuple[str, tuple[str, ...]], ...], +) -> bool: + path = str(record.get("file", "")).replace("\\", "/").lower() + function = str(record.get("function", "")).lower() + return any( + path.endswith(path_suffix) and function in functions + for path_suffix, functions in relationships + ) + + +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, _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(traced_peak_bytes, "traced peak bytes") + 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") + 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( + _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 function_records + if _matches(record, rule["evidence"]) + ] + exact_function_locations = { + _source_location(record, "profile function line") + for record in function_evidence + } + allocation_evidence = [ + record + for record in allocation_records + if _source_location(record, "profile allocation line") + in exact_function_locations + ] + 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( + _integer_field(record.get("bytes", 0), "profile allocation bytes") + for record in allocation_evidence + ) + / traced_peak_bytes + >= 0.10 + ) + evidence: list[dict[str, object]] = [] + evidence.extend(function_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("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), + ) + + +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") + ordered = sorted(materialized, 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 = _reconcile_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") + ) + 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")} + ) + 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( + ( + 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 = 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_finite_numbers(payload, f"result JSON {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..59c827b --- /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, Union + +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], Union[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 new file mode 100644 index 0000000..0f3bb2f --- /dev/null +++ b/benchmarks/performance/cli.py @@ -0,0 +1,179 @@ +from __future__ import annotations + +import argparse +import json +import shlex +import sys +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_finite_numbers, validate_result +from .worker import execute_profile_case + + +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): + 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") + _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("--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) + + 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 + + +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: + 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"), + parse_constant=_reject_non_standard_json_constant, + ) + 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 + 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), + 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, + ) + 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}") + 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/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/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/instrumentation.py b/benchmarks/performance/instrumentation.py new file mode 100644 index 0000000..801ffd4 --- /dev/null +++ b/benchmarks/performance/instrumentation.py @@ -0,0 +1,221 @@ +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", "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/"), +} + +_EXACT_FUNCTION_STAGES = { + "numeric_corr_matrix": "correlation", + "corr": "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, +) -> 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 + 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( + differences: list[tracemalloc.StatisticDiff], +) -> list[dict[str, object]]: + records: list[dict[str, object]] = [] + 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: + continue + records.append( + { + "file": frame.filename, + "line": frame.lineno, + "bytes": statistic.size_diff, + "count": statistic.count_diff, + } + ) + 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: + before = tracemalloc.take_snapshot() + 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() + after = tracemalloc.take_snapshot() + finally: + if not was_tracing: + tracemalloc.stop() + + functions, stages = _function_records(pstats.Stats(profiler)) + return ProfileResult( + functions=functions, + allocations=_allocation_records(after.compare_to(before, "lineno")), + stages=stages, + operations=dict(counter.counts), + ) 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/models.py b/benchmarks/performance/models.py new file mode 100644 index 0000000..cf5c4ed --- /dev/null +++ b/benchmarks/performance/models.py @@ -0,0 +1,252 @@ +from __future__ import annotations + +import hashlib +import json +import math +import statistics +from dataclasses import asdict, dataclass, field +from typing import TYPE_CHECKING, Any, Dict, List, Union # noqa: UP035 + +if TYPE_CHECKING: + from .instrumentation import ProfileResult + +JsonValue = Union[ + None, + bool, + int, + float, + str, + 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", + ) +) +_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: + 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)): + 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) +class BenchmarkCase: + rows: int + width: str + config_name: str + options: dict[str, JsonValue] + dataset_type: str = "mixed" + return_report: bool = False + backend: str = "pandas" + output_format: str = "pandas" + seed: int = 42 + warmups: int = 1 + 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: + raw = json.dumps(asdict(self), sort_keys=True, separators=(",", ":"), allow_nan=False) + 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 + 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, + *, + 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, + profile: ProfileResult | None = None, + baseline_name: str | None = None, + ) -> 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 + 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", + 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=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=input_to_peak_ratio, + command=command, + output_fingerprint=output_fingerprint, + report_fingerprint=report_fingerprint, + result_type=result_type, + profile=profile, + baseline_name=baseline_name, + ) + + def to_dict(self) -> dict[str, Any]: + payload = asdict(self) + json.dumps(payload, allow_nan=False) + return payload + + @classmethod + 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/render.py b/benchmarks/performance/render.py new file mode 100644 index 0000000..02ac9e0 --- /dev/null +++ b/benchmarks/performance/render.py @@ -0,0 +1,203 @@ +from __future__ import annotations + +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: + 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("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), + ) + + +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 + validate_finite_numbers(payload, "report payload") + 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_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", + "", + "## 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"### {case_label(result)}") + 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%}") + 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 " + 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[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_id, label, name, decision in candidates: + lines.append( + 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[3].get("status") != "candidate"] + for case_id, label, name, decision in rejected: + lines.append( + f"- `{name}` in `{case_id}` ({label}): {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/runner.py b/benchmarks/performance/runner.py new file mode 100644 index 0000000..0caed18 --- /dev/null +++ b/benchmarks/performance/runner.py @@ -0,0 +1,267 @@ +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 = "" + 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) + 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 result_error is not None: + result = _failure_result( + case=case, + status="failed", + command=command, + error_type=type(result_error).__name__, + error_message=str(result_error), + ) + else: + assert loaded_result is not None + result = loaded_result + _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/benchmarks/performance/schema.py b/benchmarks/performance/schema.py new file mode 100644 index 0000000..f55df02 --- /dev/null +++ b/benchmarks/performance/schema.py @@ -0,0 +1,342 @@ +from __future__ import annotations + +import json +import math +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", + "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", + "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", + "baseline_name", + ], + "additionalProperties": False, + "properties": { + "schema_version": {"type": "integer", "const": 1}, + "status": { + "type": "string", + "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", + ], + "additionalProperties": False, + "properties": { + "rows": {"type": "integer", "minimum": 1}, + "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", + "enum": [ + "mixed", + "numeric", + "categorical", + "string", + "nullable", + "datetime", + "high_cardinality", + ], + }, + "return_report": {"type": "boolean"}, + "backend": {"type": "string", "minLength": 1}, + "output_format": {"type": "string", "minLength": 1}, + "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"]}, + "baseline_name": {"type": ["string", "null"], "minLength": 1}, + "profile": { + "type": ["object", "null"], + "additionalProperties": False, + "required": ["functions", "allocations", "stages", "operations"], + "properties": { + "functions": { + "type": "array", + "maxItems": 100, + "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", + "maxItems": 100, + "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", + "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": ( + "Observed Python pandas method calls; these are not physical " + "buffer-copy counts." + ), + "type": "object", + "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}, + }, + }, + }, + }, + }, +} + + +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: + 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"]: + 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/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/benchmarks/performance/worker.py b/benchmarks/performance/worker.py new file mode 100644 index 0000000..51ad60e --- /dev/null +++ b/benchmarks/performance/worker.py @@ -0,0 +1,125 @@ +from __future__ import annotations + +import gc +import hashlib +import json +import time +import tracemalloc +from dataclasses import replace +from pathlib import Path +from typing import Any, NoReturn + +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 _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, + 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 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"), + parse_constant=_reject_non_standard_json_constant, + ) + 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/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/docs/benchmarks.md b/docs/benchmarks.md index be49b54..e3bba72 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..f3ac60f --- /dev/null +++ b/docs/performance-investigation.md @@ -0,0 +1,471 @@ +--- +title: Performance investigation +description: >- + Reproducible FreshData performance measurement, profiling, analysis, and + evidence-reporting methodology. +keywords: freshdata performance, scalability, profiling, benchmark methodology +--- + +# Performance investigation + +## 1. Executive summary + +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. + +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 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 + -> 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 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. + +### Supported environment and provenance + +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. + +## 2. Reproduction commands + +Install the development, benchmark, and optional ML dependencies first: + +```bash +pip install -e ".[dev,bench,ml]" +``` + +The timing evidence was captured with these selectors (500k and 1M widths were +run as separate commands with the shown width substituted): + +```bash +.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 last command is the incomplete MissForest attempt described in section 4; +the other six commands produced completed profile artifacts. + +```bash +.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 +``` + +### 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 + +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. + +### 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/ +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/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 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 +.venv-qa/bin/mkdocs build --strict +git diff --check +git diff 6f6c2fe -- src/freshdata +``` + +Results from the earlier 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 + +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. 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..08f6aee --- /dev/null +++ b/docs/superpowers/plans/2026-07-11-freshdata-performance-baseline-profiling.md @@ -0,0 +1,1418 @@ +# 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["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 = pd.concat( + [frame.iloc[:-duplicate_count], frame.iloc[:duplicate_count].copy()], + ignore_index=True, + ) + 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 = { + "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() + }), + "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 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 +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 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. + +- [ ] **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. 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..5865511 --- /dev/null +++ b/docs/superpowers/plans/2026-07-13-freshdata-semantic-performance-optimization.md @@ -0,0 +1,440 @@ +# 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": 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 +~~~ + +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_memo_reuses_only_within_one_memo() -> None: + memo = semantic_context._SemanticContextMemo() + calls = 0 + + def observed(value: object) -> bool: + nonlocal calls + calls += 1 + return semantic_context.is_plain_number(value) + + 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 + + +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 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** + +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. 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..745cc00 --- /dev/null +++ b/docs/superpowers/specs/2026-07-11-freshdata-confirmed-performance-bottlenecks-design.md @@ -0,0 +1,262 @@ +# 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 + -> calibrate proposals and decide + -> build replacement map + -> record every decision + -> apply replacements +``` + +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. + +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 +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. + +#### 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. 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 +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. 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 +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. 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. diff --git a/mkdocs.yml b/mkdocs.yml index 898ff46..a23df3d 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -136,6 +136,7 @@ nav: - Threat model: threat-model.md - Production-readiness checklist: production-readiness.md - Benchmarks: benchmarks.md + - Performance investigation: performance-investigation.md - Validation Gauntlet: validation-gauntlet.md - Benchmark fixtures: fixtures.md - API Reference: api-reference.md 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/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_analysis_render.py b/tests/performance/test_analysis_render.py new file mode 100644 index 0000000..73d0a9d --- /dev/null +++ b/tests/performance/test_analysis_render.py @@ -0,0 +1,839 @@ +from __future__ import annotations + +import json +from pathlib import Path + +import pytest +from benchmarks.performance.analysis import ( + analyze_results, + classify_change, + classify_hypotheses, + load_results, +) +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_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] + 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": "auto_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["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": 231, + "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["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", + [ + ( + "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: + 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_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_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, + "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_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() + (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 + + +@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) + + +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" + 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_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( + [ + "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_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 diff --git a/tests/performance/test_datasets.py b/tests/performance/test_datasets.py new file mode 100644 index 0000000..2fb9f1e --- /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 isinstance(df["category_0"].dtype, pd.CategoricalDtype) + 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 diff --git a/tests/performance/test_instrumentation.py b/tests/performance/test_instrumentation.py new file mode 100644 index 0000000..5d9afad --- /dev/null +++ b/tests/performance/test_instrumentation.py @@ -0,0 +1,352 @@ +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 ( + STAGE_RULES, + OperationCounter, + _function_records, + _stage_for, + 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 _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_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] = {} + 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(), + 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": {**dict.fromkeys(STAGE_RULES, 0.0), "total": 0.1}, + "operations": {**dict.fromkeys(OperationCounter.METHODS, 0), "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) + + +@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( + [ + "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")) diff --git a/tests/performance/test_models_schema.py b/tests/performance/test_models_schema.py new file mode 100644 index 0000000..402f215 --- /dev/null +++ b/tests/performance/test_models_schema.py @@ -0,0 +1,379 @@ +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 +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={}) + 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_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]}, + ) + + +@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 + 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_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) + + +@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( + 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", + ) + + +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", + ) + + +@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 + + with pytest.raises(ValueError, match="finite JSON"): + validate_result(payload) diff --git a/tests/performance/test_runner_cli.py b/tests/performance/test_runner_cli.py new file mode 100644 index 0000000..5f1d49d --- /dev/null +++ b/tests/performance/test_runner_cli.py @@ -0,0 +1,303 @@ +from __future__ import annotations + +import json +import shlex +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 + + +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", + [ + ("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_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() + + 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 diff --git a/tests/performance/test_semantic_probe.py b/tests/performance/test_semantic_probe.py new file mode 100644 index 0000000..c7adb54 --- /dev/null +++ b/tests/performance/test_semantic_probe.py @@ -0,0 +1,89 @@ +from __future__ import annotations + +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: + 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 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 + + +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: + 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 == (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 diff --git a/tests/performance/test_worker.py b/tests/performance/test_worker.py new file mode 100644 index 0000000..cd3935d --- /dev/null +++ b/tests/performance/test_worker.py @@ -0,0 +1,152 @@ +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, + 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=_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]" 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