dataforge-ml 0.1.0__tar.gz → 0.3.0__tar.gz

{dataforge_ml-0.1.0 → dataforge_ml-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataforge-ml
-Version: 0.1.0
+Version: 0.3.0
 Summary: A automated feature engineering and designing pipeline library
 License: MIT
 Classifier: License :: OSI Approved :: MIT License

{dataforge_ml-0.1.0 → dataforge_ml-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dataforge-ml"
-version = "0.1.0"
+version = "0.3.0"
 description = "A automated feature engineering and designing pipeline library"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,4 +32,4 @@ dev = [
 testpaths = ["tests"]
 
 [tool.setuptools.packages.find]
-where = ["."]
+where = ["src"]

dataforge_ml-0.3.0/src/dataforge_ml/__init__.py

@@ -0,0 +1,21 @@
+from .profiling.structural import StructuralProfiler
+from .profiling.config import (
+    ProfileConfig,
+    SemanticType,
+    Modality,
+    StructuralProfileResult,
+)
+from .splitting import DataSplitter, SplitResult, FoldResult
+from .utils.data_loader import DataLoader
+
+__all__ = [
+    "StructuralProfiler",
+    "StructuralProfileResult",
+    "ProfileConfig",
+    "SemanticType",
+    "Modality",
+    "DataSplitter",
+    "SplitResult",
+    "FoldResult",
+    "DataLoader"
+]

{dataforge_ml-0.1.0 → dataforge_ml-0.3.0/src/dataforge_ml}/utils/data_loader.py

@@ -103,8 +103,3 @@ class DataLoader:
 
         loader = _EXT_LOADERS[resolved_fmt]
         return loader(raw)
-
-
-def load(source: PathOrBuffer, fmt: str | None = None) -> pl.DataFrame:
-    """Convenience wrapper — equivalent to ``DataLoader().load(source, fmt)``."""
-    return DataLoader().load(source, fmt=fmt)

{dataforge_ml-0.1.0 → dataforge_ml-0.3.0/src}/dataforge_ml.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataforge-ml
-Version: 0.1.0
+Version: 0.3.0
 Summary: A automated feature engineering and designing pipeline library
 License: MIT
 Classifier: License :: OSI Approved :: MIT License

dataforge_ml-0.3.0/src/dataforge_ml.egg-info/SOURCES.txt

@@ -0,0 +1,39 @@
+LICENSE
+README.md
+pyproject.toml
+src/dataforge_ml/__init__.py
+src/dataforge_ml.egg-info/PKG-INFO
+src/dataforge_ml.egg-info/SOURCES.txt
+src/dataforge_ml.egg-info/dependency_links.txt
+src/dataforge_ml.egg-info/requires.txt
+src/dataforge_ml.egg-info/top_level.txt
+src/dataforge_ml/models/__init__.py
+src/dataforge_ml/models/_data_structure.py
+src/dataforge_ml/models/_data_types.py
+src/dataforge_ml/profiling/__init__.py
+src/dataforge_ml/profiling/_base.py
+src/dataforge_ml/profiling/_boolean_config.py
+src/dataforge_ml/profiling/_boolean_profiler.py
+src/dataforge_ml/profiling/_categorical.py
+src/dataforge_ml/profiling/_categorical_config.py
+src/dataforge_ml/profiling/_correlation_config.py
+src/dataforge_ml/profiling/_correlation_profiler.py
+src/dataforge_ml/profiling/_datetime_config.py
+src/dataforge_ml/profiling/_datetime_profiler.py
+src/dataforge_ml/profiling/_missingness_config.py
+src/dataforge_ml/profiling/_missingness_profiler.py
+src/dataforge_ml/profiling/_numeric_config.py
+src/dataforge_ml/profiling/_numeric_profiler.py
+src/dataforge_ml/profiling/_tabular.py
+src/dataforge_ml/profiling/_target_config.py
+src/dataforge_ml/profiling/_target_profiler.py
+src/dataforge_ml/profiling/_text_config.py
+src/dataforge_ml/profiling/_text_profiler.py
+src/dataforge_ml/profiling/_type_detector.py
+src/dataforge_ml/profiling/config.py
+src/dataforge_ml/profiling/structural.py
+src/dataforge_ml/splitting/__init__.py
+src/dataforge_ml/splitting/_config.py
+src/dataforge_ml/splitting/_splitter.py
+src/dataforge_ml/utils/__init__.py
+src/dataforge_ml/utils/data_loader.py

dataforge_ml-0.3.0/src/dataforge_ml.egg-info/top_level.txt

@@ -0,0 +1 @@
+dataforge_ml

dataforge_ml-0.1.0/dataforge_ml.egg-info/SOURCES.txt

@@ -1,57 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-dataforge_ml.egg-info/PKG-INFO
-dataforge_ml.egg-info/SOURCES.txt
-dataforge_ml.egg-info/dependency_links.txt
-dataforge_ml.egg-info/requires.txt
-dataforge_ml.egg-info/top_level.txt
-models/__init__.py
-models/_data_structure.py
-models/_data_types.py
-profiling/__init__.py
-profiling/_base.py
-profiling/_boolean_config.py
-profiling/_boolean_profiler.py
-profiling/_categorical.py
-profiling/_categorical_config.py
-profiling/_correlation_config.py
-profiling/_correlation_profiler.py
-profiling/_datetime_config.py
-profiling/_datetime_profiler.py
-profiling/_missingness_config.py
-profiling/_missingness_profiler.py
-profiling/_numeric_config.py
-profiling/_numeric_profiler.py
-profiling/_tabular.py
-profiling/_target_config.py
-profiling/_target_profiler.py
-profiling/_text_config.py
-profiling/_text_profiler.py
-profiling/_type_detector.py
-profiling/config.py
-profiling/structural.py
-splitting/__init__.py
-splitting/_config.py
-splitting/_splitter.py
-tests/__init__.py
-tests/conftest.py
-tests/integration/__init__.py
-tests/integration/conftest.py
-tests/integration/test_structural_end_to_end.py
-tests/unit/__init__.py
-tests/unit/profiling/__init__.py
-tests/unit/profiling/conftest.py
-tests/unit/profiling/test_boolean_profiler.py
-tests/unit/profiling/test_categorical_profiler.py
-tests/unit/profiling/test_correlation_profiler.py
-tests/unit/profiling/test_datetime_profiler.py
-tests/unit/profiling/test_missingness_profiler.py
-tests/unit/profiling/test_numeric_profiler.py
-tests/unit/profiling/test_target_profiler.py
-tests/unit/profiling/test_text_profiler.py
-tests/unit/profiling/test_type_detector.py
-tests/unit/splitting/__init__.py
-tests/unit/splitting/test_data_splitter.py
-utils/__init__.py
-utils/data_loader.py

dataforge_ml-0.1.0/dataforge_ml.egg-info/top_level.txt

@@ -1,6 +0,0 @@
-dist
-models
-profiling
-splitting
-tests
-utils

dataforge_ml-0.1.0/tests/conftest.py

@@ -1,7 +0,0 @@
-import numpy as np
-import pytest
-
-
-@pytest.fixture(scope="session")
-def rng():
-    return np.random.default_rng(42)

dataforge_ml-0.1.0/tests/integration/conftest.py

@@ -1,82 +0,0 @@
-
-import polars as pl
-import pytest
-
-
-@pytest.fixture(scope="session")
-def override_df():
-    n = 60
-    return pl.DataFrame(
-        {
-            "score": pl.Series([float(i) for i in range(n)], dtype=pl.Float64),
-            "category": pl.Series(["A", "B", "C"] * (n // 3), dtype=pl.Utf8),
-        }
-    )
-
-
-@pytest.fixture(scope="session")
-def target_df(rng):
-    n = 100
-    features = rng.normal(0, 1, size=n).tolist()
-    labels = ["pos", "neg"] * (n // 2)
-    return pl.DataFrame(
-        {
-            "feature": pl.Series(features, dtype=pl.Float64),
-            "label": pl.Series(labels, dtype=pl.Utf8),
-        }
-    )
-
-
-@pytest.fixture(scope="session")
-def empty_df():
-    return pl.DataFrame(
-        {
-            "x": pl.Series([], dtype=pl.Float64),
-            "y": pl.Series([], dtype=pl.Utf8),
-        }
-    )
-
-
-@pytest.fixture(scope="session")
-def text_df():
-    n = 200
-    topics = ["science", "art", "history", "technology", "nature", "music"]
-    texts = [
-        f"A detailed description covering the topic of {topics[i % len(topics)]} "
-        f"with multiple words that comfortably exceed the free-text threshold in row {i}"
-        for i in range(n)
-    ]
-    return pl.DataFrame({"review": pl.Series(texts, dtype=pl.Utf8)})
-
-
-@pytest.fixture(scope="session")
-def mixed_df(rng):
-    n = 300
-
-    age = rng.integers(18, 75, size=n)
-    income = age * 1200 + rng.normal(0, 5000, size=n)
-
-    salary = rng.normal(50_000, 15_000, size=n).tolist()
-    null_mask = rng.random(n) < 0.10
-    salary = [None if null_mask[i] else salary[i] for i in range(n)]
-
-    country_choices = ["US", "UK", "CA", "AU", "DE"]
-    country = [country_choices[i % len(country_choices)] for i in range(n)]
-
-    names = [f"person_{i}" for i in range(n)]
-
-    is_active = [bool(v) for v in rng.integers(0, 2, size=n)]
-
-    from datetime import date, timedelta
-    base = date(2020, 1, 1)
-    joined = [base + timedelta(days=int(d)) for d in rng.integers(0, 1460, size=n)]
-
-    return pl.DataFrame({
-        "age": pl.Series(age.tolist(), dtype=pl.Int64),
-        "income": pl.Series(income.tolist(), dtype=pl.Float64),
-        "salary": pl.Series(salary, dtype=pl.Float64),
-        "country": pl.Series(country, dtype=pl.Utf8),
-        "name": pl.Series(names, dtype=pl.Utf8),
-        "is_active": pl.Series(is_active, dtype=pl.Boolean),
-        "joined": pl.Series(joined, dtype=pl.Date),
-    })

dataforge_ml-0.1.0/tests/integration/test_structural_end_to_end.py

@@ -1,219 +0,0 @@
-import pytest
-from ...profiling.structural import StructuralProfiler
-from ...profiling.config import (
-    ProfileConfig,
-    StructuralProfileResult,
-    SemanticType,
-)
-from ...profiling._numeric_config import NumericStats
-from ...profiling._categorical_config import CategoricalStats
-from ...profiling._datetime_config import DatetimeStats
-from ...profiling._boolean_config import BooleanStats
-from ...profiling._text_config import TextStats
-from ...profiling._target_config import TargetProfileResult
-
-
-def test_happy_path(mixed_df):
-    config = ProfileConfig(compute_correlation=True)
-    result = StructuralProfiler(config).profile(mixed_df)
-
-    assert isinstance(result, StructuralProfileResult)
-    assert set(result.columns.keys()) == set(mixed_df.columns)
-    for col_profile in result.columns.values():
-        assert (
-            col_profile.semantic_type is not None
-        ), f"column '{col_profile.name}' has no semantic_type"
-
-
-    assert result.dataset.row_count == mixed_df.height
-    assert result.dataset.feature_correlation is not None
-
-
-def test_no_correlation(mixed_df):
-    config = ProfileConfig(compute_correlation=False)
-    result = StructuralProfiler(config).profile(mixed_df)
-
-    assert result.dataset.feature_correlation is None
-
-
-def test_boolean_handoff(mixed_df):
-    result = StructuralProfiler(ProfileConfig()).profile(mixed_df)
-
-    cp = result.columns["is_active"]
-    assert cp.semantic_type == SemanticType.Boolean
-    assert cp.stats is not None
-    assert isinstance(cp.stats, BooleanStats)
-    assert cp.stats.mode in (True, False, None)
-
-
-def test_text_handoff(text_df):
-    result = StructuralProfiler(ProfileConfig()).profile(text_df)
-
-    cp = result.columns["review"]
-    assert cp.semantic_type == SemanticType.Text
-    assert cp.stats is not None
-    assert isinstance(cp.stats, TextStats)
-
-    assert cp.stats.vocabulary_size > 0
-    assert cp.stats.char_length_max >= cp.stats.char_length_min
-    assert cp.stats.avg_token_count > 0
-    assert 0.0 <= cp.stats.empty_ratio <= 1.0
-
-
-def test_correlation_consistency(mixed_df):
-    config = ProfileConfig(compute_correlation=True)
-    result = StructuralProfiler(config).profile(mixed_df)
-
-    fc = result.dataset.feature_correlation
-    assert fc is not None
-
-    # age and income are correlated by construction — forward invariant must not be vacuous
-    assert len(fc.near_redundant_pairs) >= 1, (
-        "expected at least one near-redundant pair (age/income are strongly correlated)"
-    )
-
-    # Forward invariant: every near_redundant pair must have both columns co-located
-    # in the same NearRedundancyGroup
-    for pair in fc.pairwise:
-        if not pair.near_redundant:
-            continue
-        assert any(
-            pair.col_a in group.columns and pair.col_b in group.columns
-            for group in fc.near_redundancy_groups
-        ), (
-            f"near_redundant pair ({pair.col_a}, {pair.col_b}) "
-            f"not co-located in any NearRedundancyGroup"
-        )
-
-    # Backward invariant: every column in a redundancy group must have at least
-    # one near_redundant=True pair in pairwise
-    for group in fc.near_redundancy_groups:
-        for col in group.columns:
-            assert any(
-                (p.col_a == col or p.col_b == col) and p.near_redundant
-                for p in fc.pairwise
-            ), (
-                f"column '{col}' is in a NearRedundancyGroup but has no "
-                f"near_redundant=True pair in pairwise"
-            )
-
-    # Matrix symmetry — Pearson
-    for col_a, row in fc.pearson_matrix.items():
-        for col_b, val in row.items():
-            mirror = fc.pearson_matrix.get(col_b, {}).get(col_a)
-            assert mirror is not None and abs(val - mirror) < 1e-10, (
-                f"Pearson matrix asymmetry: [{col_a}][{col_b}]={val} "
-                f"vs [{col_b}][{col_a}]={mirror}"
-            )
-
-    # Matrix symmetry — Spearman
-    for col_a, row in fc.spearman_matrix.items():
-        for col_b, val in row.items():
-            mirror = fc.spearman_matrix.get(col_b, {}).get(col_a)
-            assert mirror is not None and abs(val - mirror) < 1e-10, (
-                f"Spearman matrix asymmetry: [{col_a}][{col_b}]={val} "
-                f"vs [{col_b}][{col_a}]={mirror}"
-            )
-
-    # Suggested drop is a strict subset of its group's columns
-    for group in fc.near_redundancy_groups:
-        group_cols = set(group.columns)
-        drop_cols = set(group.suggested_drop)
-        assert drop_cols < group_cols, (
-            f"suggested_drop {drop_cols} is not a strict subset of "
-            f"group columns {group_cols}"
-        )
-
-
-def test_column_handoffs(mixed_df):
-    result = StructuralProfiler(ProfileConfig()).profile(mixed_df)
-
-    stats_type_for = {
-        SemanticType.Numeric: NumericStats,
-        SemanticType.Categorical: CategoricalStats,
-        SemanticType.Datetime: DatetimeStats,
-        SemanticType.Boolean: BooleanStats,
-    }
-
-    for name, cp in result.columns.items():
-        expected_type = stats_type_for.get(cp.semantic_type)
-        if expected_type is None:
-            continue
-
-        assert cp.stats is not None, (
-            f"column '{name}' has semantic_type={cp.semantic_type} but stats is None"
-        )
-        assert isinstance(cp.stats, expected_type), (
-            f"column '{name}' has semantic_type={cp.semantic_type} "
-            f"but stats type is {type(cp.stats).__name__}, expected {expected_type.__name__}"
-        )
-
-
-# ---------------------------------------------------------------------------
-# Override: numeric column forced to Categorical via column_overrides
-# ---------------------------------------------------------------------------
-
-
-def test_column_override_changes_stats_type(override_df):
-    config = ProfileConfig(column_overrides={"score": SemanticType.Categorical})
-    result = StructuralProfiler(config).profile(override_df)
-    cp = result.columns["score"]
-    assert isinstance(cp.stats, CategoricalStats)
-
-
-# ---------------------------------------------------------------------------
-# Target profiling integration
-# ---------------------------------------------------------------------------
-
-
-def test_target_profiling_integration(target_df):
-    config = ProfileConfig(target_columns=["label"])
-    result = StructuralProfiler(config).profile(target_df)
-    assert "label" in result.targets
-    assert isinstance(result.targets["label"], TargetProfileResult)
-
-
-# ---------------------------------------------------------------------------
-# Empty DataFrame does not crash
-# ---------------------------------------------------------------------------
-
-
-def test_empty_dataframe_does_not_crash(empty_df):
-    result = StructuralProfiler(ProfileConfig()).profile(empty_df)
-    assert isinstance(result, StructuralProfileResult)
-
-
-# ---------------------------------------------------------------------------
-# Numeric handoff: float column produces NumericStats on ColumnProfile
-# ---------------------------------------------------------------------------
-
-
-def test_numeric_handoff(mixed_df):
-    result = StructuralProfiler(ProfileConfig()).profile(mixed_df)
-    cp = result.columns["income"]
-    assert cp.stats is not None
-    assert isinstance(cp.stats, NumericStats)
-
-
-# ---------------------------------------------------------------------------
-# Datetime handoff: date column produces DatetimeStats on ColumnProfile
-# ---------------------------------------------------------------------------
-
-
-def test_datetime_handoff(mixed_df):
-    result = StructuralProfiler(ProfileConfig()).profile(mixed_df)
-    cp = result.columns["joined"]
-    assert cp.stats is not None
-    assert isinstance(cp.stats, DatetimeStats)
-
-
-# ---------------------------------------------------------------------------
-# Missingness surfaced at column level for columns with nulls
-# ---------------------------------------------------------------------------
-
-
-def test_missingness_surfaced(mixed_df):
-    result = StructuralProfiler(ProfileConfig()).profile(mixed_df)
-    cp = result.columns["salary"]  # salary has ~10 % nulls by construction
-    assert cp.missingness is not None
-    assert cp.missingness.standard_null_count > 0

dataforge_ml-0.1.0/tests/unit/profiling/conftest.py

@@ -1,81 +0,0 @@
-from datetime import date, timedelta
-
-import polars as pl
-import pytest
-
-_BASE_DATE = date(2023, 1, 1)
-_N = 60
-
-
-@pytest.fixture(scope="session")
-def empty_df() -> pl.DataFrame:
-    return pl.DataFrame(
-        {
-            "score": pl.Series([], dtype=pl.Float64),
-            "count": pl.Series([], dtype=pl.Int64),
-            "category": pl.Series([], dtype=pl.Utf8),
-            "active": pl.Series([], dtype=pl.Boolean),
-            "event_date": pl.Series([], dtype=pl.Date),
-        }
-    )
-
-
-@pytest.fixture(scope="session")
-def all_null_df() -> pl.DataFrame:
-    nulls = [None] * _N
-    return pl.DataFrame(
-        {
-            "float_col": pl.Series(nulls, dtype=pl.Float64),
-            "int_col": pl.Series(nulls, dtype=pl.Int64),
-            "str_col": pl.Series(nulls, dtype=pl.Utf8),
-            "bool_col": pl.Series(nulls, dtype=pl.Boolean),
-        }
-    )
-
-
-@pytest.fixture(scope="session")
-def single_value_df() -> pl.DataFrame:
-    return pl.DataFrame(
-        {
-            "score": pl.Series([5.0] * _N, dtype=pl.Float64),
-            "count": pl.Series([1] * _N, dtype=pl.Int64),
-            "category": pl.Series(["X"] * _N, dtype=pl.Utf8),
-            "active": pl.Series([True] * _N, dtype=pl.Boolean),
-        }
-    )
-
-
-@pytest.fixture(scope="session")
-def single_row_df() -> pl.DataFrame:
-    return pl.DataFrame(
-        {
-            "score": pl.Series([42.0], dtype=pl.Float64),
-            "count": pl.Series([7], dtype=pl.Int64),
-            "category": pl.Series(["A"], dtype=pl.Utf8),
-            "active": pl.Series([True], dtype=pl.Boolean),
-            "event_date": pl.Series([_BASE_DATE], dtype=pl.Date),
-        }
-    )
-
-
-@pytest.fixture(scope="session")
-def normal_mixed_df() -> pl.DataFrame:
-    _CATEGORIES = ["A", "B", "C", "D", "E"]
-
-    scores = [round(1.5 + i * 1.7 + (i % 7) * 0.3, 2) for i in range(_N)]
-    counts = [i % 20 for i in range(_N)]
-    categories = [_CATEGORIES[i % len(_CATEGORIES)] for i in range(_N)]
-    active = [i % 2 == 0 for i in range(_N)]
-    dates = [_BASE_DATE + timedelta(days=i) for i in range(_N)]
-    salary = [None if i % 10 == 0 else round(30_000.0 + i * 500.0, 2) for i in range(_N)]
-
-    return pl.DataFrame(
-        {
-            "score": pl.Series(scores, dtype=pl.Float64),
-            "count": pl.Series(counts, dtype=pl.Int64),
-            "category": pl.Series(categories, dtype=pl.Utf8),
-            "active": pl.Series(active, dtype=pl.Boolean),
-            "event_date": pl.Series(dates, dtype=pl.Date),
-            "salary": pl.Series(salary, dtype=pl.Float64),
-        }
-    )

dataforge_ml-0.1.0/tests/unit/profiling/test_boolean_profiler.py

@@ -1,91 +0,0 @@
-import polars as pl
-
-from ....profiling._boolean_profiler import BooleanProfiler
-from ....profiling._boolean_config import BooleanProfileResult, BooleanStats
-
-
-# ---------------------------------------------------------------------------
-# Result type & analysed_columns
-# ---------------------------------------------------------------------------
-
-
-def test_result_type_and_analysed_columns():
-    df = pl.DataFrame(
-        {
-            "flag": pl.Series([True, False, True], dtype=pl.Boolean),
-            "score": pl.Series([1.0, 2.0, 3.0], dtype=pl.Float64),
-        }
-    )
-    result = BooleanProfiler().profile(df, ["flag", "score"])
-    assert isinstance(result, BooleanProfileResult)
-    assert "flag" in result.analysed_columns
-    assert "score" not in result.analysed_columns
-
-
-# ---------------------------------------------------------------------------
-# Counts
-# ---------------------------------------------------------------------------
-
-
-def test_true_false_count_sum_equals_non_null_count():
-    values = [True, False, True, None, True, False, None]
-    df = pl.DataFrame({"flag": pl.Series(values, dtype=pl.Boolean)})
-    stats = BooleanProfiler().profile(df, ["flag"]).columns["flag"]
-    non_null_count = df["flag"].drop_nulls().len()
-    assert stats.true_count + stats.false_count == non_null_count
-
-
-# ---------------------------------------------------------------------------
-# Ratios
-# ---------------------------------------------------------------------------
-
-
-def test_true_ratio_plus_false_ratio_equals_one():
-    values = [True, True, False, True, False, True]
-    df = pl.DataFrame({"flag": pl.Series(values, dtype=pl.Boolean)})
-    stats = BooleanProfiler().profile(df, ["flag"]).columns["flag"]
-    assert abs(stats.true_ratio + stats.false_ratio - 1.0) < 1e-10
-
-
-# ---------------------------------------------------------------------------
-# Mode
-# ---------------------------------------------------------------------------
-
-
-def test_tied_column_mode_is_none():
-    values = [True] * 5 + [False] * 5
-    df = pl.DataFrame({"flag": pl.Series(values, dtype=pl.Boolean)})
-    stats = BooleanProfiler().profile(df, ["flag"]).columns["flag"]
-    assert stats.mode is None
-
-
-# ---------------------------------------------------------------------------
-# Integer {0, 1} columns
-# ---------------------------------------------------------------------------
-
-
-def test_integer_01_eligible_with_correct_counts_and_ratios():
-    values = [1, 0, 1, 1, 0, None]
-    df = pl.DataFrame({"bin": pl.Series(values, dtype=pl.Int64)})
-    result = BooleanProfiler().profile(df, ["bin"])
-    assert "bin" in result.analysed_columns
-    stats = result.columns["bin"]
-    non_null = [v for v in values if v is not None]
-    expected_true = sum(non_null)
-    expected_false = len(non_null) - expected_true
-    assert stats.true_count == expected_true
-    assert stats.false_count == expected_false
-    assert abs(stats.true_ratio + stats.false_ratio - 1.0) < 1e-10
-
-
-# ---------------------------------------------------------------------------
-# All-null boolean column
-# ---------------------------------------------------------------------------
-
-
-def test_all_null_boolean_returns_default_stats_without_crashing():
-    df = pl.DataFrame({"flag": pl.Series([None, None, None], dtype=pl.Boolean)})
-    stats = BooleanProfiler().profile(df, ["flag"]).columns["flag"]
-    assert isinstance(stats, BooleanStats)
-    assert stats.true_count == 0
-    assert stats.false_count == 0