csv-stats 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: csv-stats
-Version: 0.2.0
+Version: 0.2.1
 Summary: A Python package for the life sciences to conduct hypothesis testing from CSV files.
 Project-URL: Homepage, https://github.com/mtillman14/csv-stats
 Project-URL: Documentation, https://github.com/mtillman14/csv-stats

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "csv-stats"
-version = "0.2.0"
+version = "0.2.1"
 description = "A Python package for the life sciences to conduct hypothesis testing from CSV files."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -53,5 +53,11 @@ Issues = "https://github.com/mtillman14/csv-stats/issues"
 [tool.hatch.build.targets.wheel]
 packages = ["src/csvstats"]
 
+# The sdist keeps the src/ layout: the wheel is built FROM the sdist, and
+# looks for src/csvstats. `packages` here re-rooted it to csvstats/, so the
+# 0.2.0 wheel came out empty (metadata only).
 [tool.hatch.build.targets.sdist]
-packages = ["src/csvstats"]
+only-include = ["src/csvstats", "tests", "README.md"]
+
+[tool.hatch.build]
+ignore-vcs = true

csv_stats-0.2.1/tests/test_anova1way.py

@@ -0,0 +1,239 @@
+
+from csvstats.anova import anova1way
+import numpy as np
+import pandas as pd
+
+
+def test_anova1way_independent_significant():
+    """Test independent samples one-way ANOVA with a significant result."""
+
+    np.random.seed(0)
+    group_A = np.random.normal(loc=5.0, scale=1.0, size=30)
+    group_B = np.random.normal(loc=8.0, scale=1.0, size=30)
+    data = pd.DataFrame({
+        'group': np.array(['A'] * 30 + ['B'] * 30),
+        'value': np.concatenate([group_A, group_B]),
+    })
+
+    result = anova1way(data, group_column='group', data_column='value', filename=None)
+
+    assert result is not None
+    assert result["test"] == "One-way Independent Samples ANOVA"
+    assert "date" in result
+    assert result["group_column"] == "group"
+    assert result["data_column"] == "value"
+    assert result["repeated_measures_column"] == ""
+
+    # With a large mean difference, the result should be significant
+    assert "F" in result
+    assert "p" in result
+    assert result["p"] < 0.05
+
+    # Degrees of freedom
+    assert result["df_between"] == 1  # 2 groups - 1
+    assert result["df_within"] == 58  # 60 observations - 2 groups
+
+    # Summary statistics
+    assert "summary_statistics" in result
+
+    # Assumption tests
+    assert "normality_test" in result
+    assert "homogeneity_of_variance_test" in result
+    assert result["homogeneity_of_variance_test"] != "Not applicable"
+    assert result["sphericity_test"] == "Not applicable"
+
+    # Post-hoc should be performed for significant result
+    assert "post_hoc" in result
+    assert result["post_hoc"] != "Not applicable"
+    assert "correction_method" in result["post_hoc"]
+    assert "significant_pairs" in result["post_hoc"]
+    assert "posthoc_results" in result["post_hoc"]
+
+
+def test_anova1way_independent_nonsignificant():
+    """Test independent samples one-way ANOVA with a non-significant result."""
+
+    np.random.seed(42)
+    # Same mean for both groups -> non-significant
+    group_A = np.random.normal(loc=5.0, scale=1.0, size=30)
+    group_B = np.random.normal(loc=5.0, scale=1.0, size=30)
+    data = pd.DataFrame({
+        'group': np.array(['A'] * 30 + ['B'] * 30),
+        'value': np.concatenate([group_A, group_B]),
+    })
+
+    result = anova1way(data, group_column='group', data_column='value', filename=None)
+
+    assert result is not None
+    assert result["test"] == "One-way Independent Samples ANOVA"
+    assert result["p"] >= 0.05
+    assert result["post_hoc"] == "Not applicable"
+
+
+def test_anova1way_independent_three_groups():
+    """Test independent samples one-way ANOVA with three groups."""
+
+    np.random.seed(10)
+    n = 25
+    data = pd.DataFrame({
+        'group': np.repeat(['A', 'B', 'C'], n),
+        'value': np.concatenate([
+            np.random.normal(loc=5.0, scale=1.0, size=n),
+            np.random.normal(loc=8.0, scale=1.0, size=n),
+            np.random.normal(loc=11.0, scale=1.0, size=n),
+        ]),
+    })
+
+    result = anova1way(data, group_column='group', data_column='value', filename=None)
+
+    assert result is not None
+    assert result["df_between"] == 2  # 3 groups - 1
+    assert result["df_within"] == 72  # 75 observations - 3 groups
+    assert result["p"] < 0.05
+    assert result["post_hoc"] != "Not applicable"
+
+
+def test_anova1way_repeated_measures_significant():
+    """Test repeated measures one-way ANOVA with a significant result."""
+
+    np.random.seed(5)
+    n_subjects = 20
+
+    subjects = np.tile(np.arange(n_subjects), 3)
+    condition = np.repeat(['low', 'medium', 'high'], n_subjects)
+    scores = np.concatenate([
+        np.random.normal(loc=10, scale=2, size=n_subjects),
+        np.random.normal(loc=14, scale=2, size=n_subjects),
+        np.random.normal(loc=18, scale=2, size=n_subjects),
+    ])
+
+    data = pd.DataFrame({
+        'subject': subjects,
+        'condition': condition,
+        'score': scores,
+    })
+
+    result = anova1way(data, group_column='condition', data_column='score',
+                       repeated_measures_column='subject', filename=None)
+
+    assert result is not None
+    assert result["test"] == "One-way Repeated Measures ANOVA"
+    assert result["repeated_measures_column"] == "subject"
+    assert result["p"] < 0.05
+
+    # Assumption tests for repeated measures
+    assert "normality_test" in result
+    assert result["sphericity_test"] != "Not applicable"
+    assert result["homogeneity_of_variance_test"] == "Not applicable"
+
+    # Post-hoc should be performed
+    assert result["post_hoc"] != "Not applicable"
+    assert "correction_method" in result["post_hoc"]
+
+
+def test_anova1way_repeated_measures_nonsignificant():
+    """Test repeated measures one-way ANOVA with a non-significant result."""
+
+    np.random.seed(99)
+    n_subjects = 15
+
+    subjects = np.tile(np.arange(n_subjects), 3)
+    condition = np.repeat(['A', 'B', 'C'], n_subjects)
+    # Same mean across conditions -> non-significant
+    scores = np.concatenate([
+        np.random.normal(loc=10, scale=2, size=n_subjects),
+        np.random.normal(loc=10, scale=2, size=n_subjects),
+        np.random.normal(loc=10, scale=2, size=n_subjects),
+    ])
+
+    data = pd.DataFrame({
+        'subject': subjects,
+        'condition': condition,
+        'score': scores,
+    })
+
+    result = anova1way(data, group_column='condition', data_column='score',
+                       repeated_measures_column='subject', filename=None)
+
+    assert result is not None
+    assert result["test"] == "One-way Repeated Measures ANOVA"
+    assert result["p"] >= 0.05
+    assert result["post_hoc"] == "Not applicable"
+
+
+def test_anova1way_skip_same_column_as_group():
+    """Test that anova1way returns None when data_column matches group_column."""
+
+    data = pd.DataFrame({'group': ['A', 'B', 'C'], 'value': [1, 2, 3]})
+    result = anova1way(data, group_column='group', data_column='group', filename=None)
+    assert result is None
+
+
+def test_anova1way_skip_same_column_as_repeated_measures():
+    """Test that anova1way returns None when data_column matches repeated_measures_column."""
+
+    data = pd.DataFrame({'subject': [1, 2, 3], 'group': ['A', 'B', 'C'], 'value': [1, 2, 3]})
+    result = anova1way(data, group_column='group', data_column='subject',
+                       repeated_measures_column='subject', filename=None)
+    assert result is None
+
+
+def test_anova1way_none_repeated_measures_column():
+    """Test that passing None for repeated_measures_column is handled (converted to empty string)."""
+
+    np.random.seed(0)
+    data = pd.DataFrame({
+        'group': np.array(['A'] * 30 + ['B'] * 30),
+        'value': np.concatenate([
+            np.random.normal(loc=5.0, scale=1.0, size=30),
+            np.random.normal(loc=8.0, scale=1.0, size=30),
+        ]),
+    })
+
+    result = anova1way(data, group_column='group', data_column='value',
+                       repeated_measures_column=None, filename=None)
+
+    assert result is not None
+    assert result["test"] == "One-way Independent Samples ANOVA"
+    assert result["repeated_measures_column"] == ""
+
+
+def test_anova1way_all_columns():
+    """Test the all-columns path (data_column == '_')."""
+
+    np.random.seed(3)
+    n = 20
+    data = pd.DataFrame({
+        'group': np.repeat(['A', 'B'], n),
+        'measure1': np.concatenate([
+            np.random.normal(loc=5.0, scale=1.0, size=n),
+            np.random.normal(loc=8.0, scale=1.0, size=n),
+        ]),
+        'measure2': np.concatenate([
+            np.random.normal(loc=10.0, scale=1.0, size=n),
+            np.random.normal(loc=10.0, scale=1.0, size=n),
+        ]),
+    })
+
+    results = anova1way(data, group_column='group', data_column='_', filename=None)
+
+    assert results is not None
+    assert isinstance(results, dict)
+    assert 'measure1' in results
+    assert 'measure2' in results
+    # Each sub-result should be a full anova result dict
+    assert results['measure1']['test'] == "One-way Independent Samples ANOVA"
+    assert results['measure2']['test'] == "One-way Independent Samples ANOVA"
+
+
+if __name__ == "__main__":
+    test_anova1way_independent_significant()
+    test_anova1way_independent_nonsignificant()
+    test_anova1way_independent_three_groups()
+    test_anova1way_repeated_measures_significant()
+    test_anova1way_repeated_measures_nonsignificant()
+    test_anova1way_skip_same_column_as_group()
+    test_anova1way_skip_same_column_as_repeated_measures()
+    test_anova1way_none_repeated_measures_column()
+    test_anova1way_all_columns()
+    print("All tests passed.")

csv_stats-0.2.1/tests/test_anova2way.py

@@ -0,0 +1,371 @@
+
+from csvstats.anova import anova2way
+import numpy as np
+import pandas as pd
+
+
+def test_anova2way_independent():
+    """Test two-way independent samples ANOVA with known data."""
+
+    np.random.seed(42)
+    n = 20
+
+    # Create data with two factors: treatment (A/B) and sex (M/F)
+    # Factor 1 (treatment) has a significant effect, factor 2 (sex) does not
+    data = pd.DataFrame({
+        'treatment': np.repeat(['A', 'B'], n * 2),
+        'sex': np.tile(np.repeat(['M', 'F'], n), 2),
+        'score': np.concatenate([
+            np.random.normal(loc=5.0, scale=1.0, size=n),   # A, M
+            np.random.normal(loc=5.0, scale=1.0, size=n),   # A, F
+            np.random.normal(loc=8.0, scale=1.0, size=n),   # B, M
+            np.random.normal(loc=8.0, scale=1.0, size=n),   # B, F
+        ])
+    })
+
+    result = anova2way(data, group_column1='treatment', group_column2='sex',
+                       data_column='score', filename=None)
+
+    # Verify result structure
+    assert result is not None
+    assert "test" in result
+    assert result["test"] == "Two-way Independent Samples ANOVA"
+    assert "date" in result
+    assert "main_effects" in result
+    assert "interaction" in result
+    assert "treatment" in result["main_effects"]
+    assert "sex" in result["main_effects"]
+
+    # Treatment should be significant (large mean difference)
+    assert "F" in result["main_effects"]["treatment"]
+    assert "p" in result["main_effects"]["treatment"]
+    assert result["main_effects"]["treatment"]["p"] < 0.05
+
+    # Sex should not be significant (no mean difference)
+    assert "F" in result["main_effects"]["sex"]
+    assert "p" in result["main_effects"]["sex"]
+    assert result["main_effects"]["sex"]["p"] >= 0.05
+
+    # Interaction
+    assert "F" in result["interaction"]
+    assert "p" in result["interaction"]
+
+    # Summary statistics
+    assert "summary_statistics_treatment" in result
+    assert "summary_statistics_sex" in result
+    assert "summary_statistics_interaction" in result
+
+    # Assumption tests for independent samples
+    assert "normality_test" in result
+    assert "homogeneity_of_variance_test" in result
+    assert result["homogeneity_of_variance_test"] != "Not applicable"
+    assert result["sphericity_test"] == "Not applicable"
+
+    # Post-hoc tests
+    assert "post_hoc" in result
+    assert "treatment" in result["post_hoc"]
+    assert "sex" in result["post_hoc"]
+    assert "interaction" in result["post_hoc"]
+    # Treatment is significant, so post-hoc should be a dict with results
+    assert result["post_hoc"]["treatment"] != "Not applicable"
+    # Sex is not significant, so post-hoc should be "Not applicable"
+    assert result["post_hoc"]["sex"] == "Not applicable"
+
+
+def test_anova2way_independent_nonsignificant():
+    """Test two-way independent samples ANOVA where no effects are significant."""
+
+    np.random.seed(42)
+    n = 20
+
+    # All groups have the same mean -> nothing significant
+    data = pd.DataFrame({
+        'factor1': np.repeat(['A', 'B'], n * 2),
+        'factor2': np.tile(np.repeat(['X', 'Y'], n), 2),
+        'score': np.random.normal(loc=10.0, scale=1.0, size=n * 4),
+    })
+
+    result = anova2way(data, group_column1='factor1', group_column2='factor2',
+                       data_column='score', filename=None)
+
+    assert result is not None
+    assert result["test"] == "Two-way Independent Samples ANOVA"
+
+    # All post-hocs should be "Not applicable"
+    assert result["post_hoc"]["factor1"] == "Not applicable"
+    assert result["post_hoc"]["factor2"] == "Not applicable"
+    assert result["post_hoc"]["interaction"] == "Not applicable"
+
+
+def test_anova2way_skip_same_column_group1():
+    """Test that anova2way returns None when data_column matches group_column1."""
+
+    data = pd.DataFrame({
+        'A': [1, 2, 3],
+        'B': [4, 5, 6],
+        'value': [7, 8, 9]
+    })
+
+    result = anova2way(data, group_column1='A', group_column2='B',
+                       data_column='A', filename=None)
+    assert result is None
+
+
+def test_anova2way_skip_same_column_group2():
+    """Test that anova2way returns None when data_column matches group_column2."""
+
+    data = pd.DataFrame({
+        'A': [1, 2, 3],
+        'B': [4, 5, 6],
+        'value': [7, 8, 9]
+    })
+
+    result = anova2way(data, group_column1='A', group_column2='B',
+                       data_column='B', filename=None)
+    assert result is None
+
+
+def test_anova2way_skip_same_column_repeated_measures():
+    """Test that anova2way returns None when data_column matches repeated_measures_column."""
+
+    data = pd.DataFrame({
+        'subject': [1, 2, 3],
+        'A': ['x', 'y', 'z'],
+        'B': ['a', 'b', 'c'],
+        'value': [7, 8, 9]
+    })
+
+    result = anova2way(data, group_column1='A', group_column2='B',
+                       data_column='subject', repeated_measures_column='subject',
+                       filename=None)
+    assert result is None
+
+
+def test_anova2way_none_repeated_measures_column():
+    """Test that passing None for repeated_measures_column is handled correctly."""
+
+    np.random.seed(42)
+    n = 20
+
+    data = pd.DataFrame({
+        'treatment': np.repeat(['A', 'B'], n * 2),
+        'sex': np.tile(np.repeat(['M', 'F'], n), 2),
+        'score': np.concatenate([
+            np.random.normal(loc=5.0, scale=1.0, size=n),
+            np.random.normal(loc=5.0, scale=1.0, size=n),
+            np.random.normal(loc=8.0, scale=1.0, size=n),
+            np.random.normal(loc=8.0, scale=1.0, size=n),
+        ])
+    })
+
+    result = anova2way(data, group_column1='treatment', group_column2='sex',
+                       data_column='score', repeated_measures_column=None,
+                       filename=None)
+
+    assert result is not None
+    assert result["test"] == "Two-way Independent Samples ANOVA"
+    assert result["repeated_measures_column"] == ""
+
+
+def test_anova2way_repeated_measures():
+    """Test two-way repeated measures ANOVA."""
+
+    np.random.seed(7)
+    n_subjects = 15
+
+    # Each subject is measured under all 4 conditions (2 x 2 within-subject design)
+    subjects = np.tile(np.arange(n_subjects), 4)
+    factor1 = np.repeat(['low', 'high'], n_subjects * 2)
+    factor2 = np.tile(np.repeat(['pre', 'post'], n_subjects), 2)
+
+    # factor1 has a large effect, factor2 has a moderate effect
+    scores = np.concatenate([
+        np.random.normal(loc=10, scale=2, size=n_subjects),  # low, pre
+        np.random.normal(loc=12, scale=2, size=n_subjects),  # low, post
+        np.random.normal(loc=16, scale=2, size=n_subjects),  # high, pre
+        np.random.normal(loc=18, scale=2, size=n_subjects),  # high, post
+    ])
+
+    data = pd.DataFrame({
+        'subject': subjects,
+        'dose': factor1,
+        'time': factor2,
+        'score': scores,
+    })
+
+    result = anova2way(data, group_column1='dose', group_column2='time',
+                       data_column='score', repeated_measures_column='subject',
+                       filename=None)
+
+    assert result is not None
+    assert result["test"] == "Two-way Repeated Measures ANOVA"
+    assert result["repeated_measures_column"] == "subject"
+    assert "main_effects" in result
+    assert "dose" in result["main_effects"]
+    assert "time" in result["main_effects"]
+    assert "interaction" in result
+
+    # Both main effects should be significant given the large mean differences
+    assert result["main_effects"]["dose"]["p"] < 0.05
+    assert result["main_effects"]["time"]["p"] < 0.05
+
+    # Assumption tests for repeated measures
+    assert "normality_test" in result
+    assert result["sphericity_test"] != "Not applicable"
+    assert result["homogeneity_of_variance_test"] == "Not applicable"
+
+    # Post-hoc for significant effects
+    assert "post_hoc" in result
+    assert result["post_hoc"]["dose"] != "Not applicable"
+    assert result["post_hoc"]["time"] != "Not applicable"
+
+
+def test_anova2way_repeated_measures_nonsignificant():
+    """Test repeated measures two-way ANOVA with non-significant effects."""
+
+    np.random.seed(88)
+    n_subjects = 15
+
+    subjects = np.tile(np.arange(n_subjects), 4)
+    factor1 = np.repeat(['low', 'high'], n_subjects * 2)
+    factor2 = np.tile(np.repeat(['pre', 'post'], n_subjects), 2)
+
+    # Same mean across all conditions -> non-significant
+    scores = np.random.normal(loc=10, scale=2, size=n_subjects * 4)
+
+    data = pd.DataFrame({
+        'subject': subjects,
+        'dose': factor1,
+        'time': factor2,
+        'score': scores,
+    })
+
+    result = anova2way(data, group_column1='dose', group_column2='time',
+                       data_column='score', repeated_measures_column='subject',
+                       filename=None)
+
+    assert result is not None
+    assert result["test"] == "Two-way Repeated Measures ANOVA"
+
+    # All post-hocs should be "Not applicable" when nothing is significant
+    assert result["post_hoc"]["dose"] == "Not applicable"
+    assert result["post_hoc"]["time"] == "Not applicable"
+    assert result["post_hoc"]["interaction"] == "Not applicable"
+
+
+def test_anova2way_all_columns():
+    """Test the all-columns path (data_column == '_')."""
+
+    np.random.seed(3)
+    n = 20
+
+    data = pd.DataFrame({
+        'treatment': np.repeat(['A', 'B'], n * 2),
+        'sex': np.tile(np.repeat(['M', 'F'], n), 2),
+        'measure1': np.concatenate([
+            np.random.normal(loc=5.0, scale=1.0, size=n),
+            np.random.normal(loc=5.0, scale=1.0, size=n),
+            np.random.normal(loc=8.0, scale=1.0, size=n),
+            np.random.normal(loc=8.0, scale=1.0, size=n),
+        ]),
+        'measure2': np.random.normal(loc=10.0, scale=1.0, size=n * 4),
+    })
+
+    results = anova2way(data, group_column1='treatment', group_column2='sex',
+                        data_column='_', filename=None)
+
+    assert results is not None
+    assert isinstance(results, dict)
+    assert 'measure1' in results
+    assert 'measure2' in results
+    assert results['measure1']['test'] == "Two-way Independent Samples ANOVA"
+    assert results['measure2']['test'] == "Two-way Independent Samples ANOVA"
+
+
+def test_anova2way_all_columns_with_filename_placeholder():
+    """Test all-columns path with {data_column} placeholder in filename."""
+
+    np.random.seed(3)
+    n = 20
+
+    data = pd.DataFrame({
+        'treatment': np.repeat(['A', 'B'], n * 2),
+        'sex': np.tile(np.repeat(['M', 'F'], n), 2),
+        'measure1': np.random.normal(loc=5.0, scale=1.0, size=n * 4),
+    })
+
+    # Use a filename with {data_column} placeholder - the function should format it
+    # without error. Use None-equivalent by checking no exception is raised.
+    results = anova2way(data, group_column1='treatment', group_column2='sex',
+                        data_column='_',
+                        filename='/tmp/test_{data_column}_results.pdf')
+
+    assert results is not None
+    assert 'measure1' in results
+
+
+def test_anova2way_all_columns_without_filename_placeholder():
+    """Test all-columns path with a filename that has no {data_column} placeholder
+    (exercises the KeyError/IndexError fallback)."""
+
+    np.random.seed(3)
+    n = 20
+
+    data = pd.DataFrame({
+        'treatment': np.repeat(['A', 'B'], n * 2),
+        'sex': np.tile(np.repeat(['M', 'F'], n), 2),
+        'measure1': np.random.normal(loc=5.0, scale=1.0, size=n * 4),
+    })
+
+    # Plain filename without placeholder -> triggers the except branch
+    results = anova2way(data, group_column1='treatment', group_column2='sex',
+                        data_column='_',
+                        filename='/tmp/test_results.pdf')
+
+    assert results is not None
+    assert 'measure1' in results
+
+
+def test_anova2way_interaction_posthoc():
+    """Test that interaction post-hoc tests are performed when interaction is significant."""
+
+    np.random.seed(123)
+    n = 30
+
+    # Create a crossover interaction: A+X high, A+Y low, B+X low, B+Y high
+    data = pd.DataFrame({
+        'factor1': np.repeat(['A', 'B'], n * 2),
+        'factor2': np.tile(np.repeat(['X', 'Y'], n), 2),
+        'score': np.concatenate([
+            np.random.normal(loc=12.0, scale=1.0, size=n),  # A, X (high)
+            np.random.normal(loc=5.0, scale=1.0, size=n),   # A, Y (low)
+            np.random.normal(loc=5.0, scale=1.0, size=n),   # B, X (low)
+            np.random.normal(loc=12.0, scale=1.0, size=n),  # B, Y (high)
+        ])
+    })
+
+    result = anova2way(data, group_column1='factor1', group_column2='factor2',
+                       data_column='score', filename=None)
+
+    assert result is not None
+    # The interaction should be significant due to the crossover pattern
+    assert result["interaction"]["p"] < 0.05
+    assert result["post_hoc"]["interaction"] != "Not applicable"
+    assert "correction_method" in result["post_hoc"]["interaction"]
+    assert "posthoc_results" in result["post_hoc"]["interaction"]
+
+
+if __name__ == "__main__":
+    test_anova2way_independent()
+    test_anova2way_independent_nonsignificant()
+    test_anova2way_skip_same_column_group1()
+    test_anova2way_skip_same_column_group2()
+    test_anova2way_skip_same_column_repeated_measures()
+    test_anova2way_none_repeated_measures_column()
+    test_anova2way_repeated_measures()
+    test_anova2way_repeated_measures_nonsignificant()
+    test_anova2way_all_columns()
+    test_anova2way_all_columns_with_filename_placeholder()
+    test_anova2way_all_columns_without_filename_placeholder()
+    test_anova2way_interaction_posthoc()
+    print("All tests passed.")

csv_stats-0.2.1/tests/test_core.py

@@ -0,0 +1,288 @@
+"""csvstats.core: the C3 core record, checked against scipy and hand values."""
+
+import json
+import math
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy import stats
+
+from csvstats.core import (
+    NotSupported,
+    anova,
+    correct_pvalues,
+    friedman,
+    kruskal,
+    rank_test,
+    ttest,
+)
+
+
+def _two_groups():
+    return pd.DataFrame({
+        "g": ["A"] * 5 + ["B"] * 6,
+        "y": [5.1, 4.8, 6.0, 5.5, 5.9, 3.9, 4.2, 4.0, 4.6, 3.5, 4.4],
+    })
+
+
+def _paired():
+    rows = []
+    for s, (pre, post) in enumerate([(5.0, 6.1), (4.2, 4.9), (6.3, 6.8), (5.5, 6.9), (4.9, 5.0), (5.8, 6.6)]):
+        rows += [(f"S{s}", "pre", pre), (f"S{s}", "post", post)]
+    return pd.DataFrame(rows, columns=["subject", "time", "y"])
+
+
+# --- correction -----------------------------------------------------------
+
+
+def test_correct_pvalues_reference_values():
+    assert correct_pvalues([0.01, 0.04, 0.03], "holm") == pytest.approx([0.03, 0.06, 0.06])
+    assert correct_pvalues([0.01, 0.04, 0.03], "fdr_bh") == pytest.approx([0.03, 0.04, 0.04])
+    assert correct_pvalues([0.01, 0.4], "bonferroni") == pytest.approx([0.02, 0.8])
+    assert correct_pvalues([0.2, None, 0.6], "bonferroni") == [0.4, None, 1.0]
+    with pytest.raises(ValueError):
+        correct_pvalues([0.1], "tukey")
+
+
+# --- t-tests --------------------------------------------------------------
+
+
+def test_welch_matches_scipy_and_states_the_direction():
+    data = _two_groups()
+    out = ttest(data, "y", between=["g"])
+    (effect,) = out["effects"]
+    a = data[data.g == "A"].y.to_numpy()
+    b = data[data.g == "B"].y.to_numpy()
+    ref = stats.ttest_ind(a, b, equal_var=False)
+    assert out["test"] == "ttest_ind_welch"
+    assert (effect["a"], effect["b"]) == ("A", "B")
+    assert effect["statistic"] == pytest.approx(ref.statistic)
+    assert effect["p"] == pytest.approx(ref.pvalue)
+    va, vb = a.var(ddof=1) / len(a), b.var(ddof=1) / len(b)
+    df = (va + vb) ** 2 / (va**2 / (len(a) - 1) + vb**2 / (len(b) - 1))
+    assert effect["df"] == [pytest.approx(df)]
+    est = effect["estimate"]
+    assert est["value"] == pytest.approx(a.mean() - b.mean())
+    half = stats.t.ppf(0.975, df) * math.sqrt(va + vb)
+    assert est["ci"] == pytest.approx([est["value"] - half, est["value"] + half])
+
+
+def test_levels_reverse_the_sign():
+    out = ttest(_two_groups(), "y", between=["g"], levels={"g": ["B", "A"]})
+    (effect,) = out["effects"]
+    assert (effect["a"], effect["b"]) == ("B", "A")
+    assert effect["estimate"]["value"] < 0
+
+
+def test_student_effect_sizes_and_their_ci():
+    data = _two_groups()
+    out = ttest(data, "y", between=["g"], equal_var=True)
+    (effect,) = out["effects"]
+    a = data[data.g == "A"].y.to_numpy()
+    b = data[data.g == "B"].y.to_numpy()
+    assert effect["statistic"] == pytest.approx(stats.ttest_ind(a, b).statistic)
+    sp = math.sqrt(((len(a) - 1) * a.var(ddof=1) + (len(b) - 1) * b.var(ddof=1)) / (len(a) + len(b) - 2))
+    d = (a.mean() - b.mean()) / sp
+    sizes = effect["effect_sizes"]
+    assert sizes["d_s"]["value"] == pytest.approx(d)
+    assert sizes["g_s"]["value"] < sizes["d_s"]["value"], "J < 1 shrinks g"
+    lo, hi = sizes["d_s"]["ci"]
+    assert lo < d < hi
+    # The noncentral-t bounds put the observed t at the 97.5% / 2.5% points.
+    scale = math.sqrt(len(a) * len(b) / (len(a) + len(b)))
+    df = len(a) + len(b) - 2
+    assert stats.nct.cdf(d * scale, df, lo * scale) == pytest.approx(0.975, abs=1e-6)
+    assert stats.nct.cdf(d * scale, df, hi * scale) == pytest.approx(0.025, abs=1e-6)
+    assert effect["effect_size"]["name"] == "g_s"
+
+
+def test_paired_t_matches_scipy_and_d_z():
+    data = _paired()
+    out = ttest(data, "y", within=["time"], subject="subject", levels={"time": ["post", "pre"]})
+    (effect,) = out["effects"]
+    wide = data.pivot(index="subject", columns="time", values="y")
+    ref = stats.ttest_rel(wide["post"], wide["pre"])
+    assert out["test"] == "ttest_paired"
+    assert effect["statistic"] == pytest.approx(ref.statistic)
+    assert effect["p"] == pytest.approx(ref.pvalue)
+    assert effect["df"] == [5.0]
+    d = (wide["post"] - wide["pre"]).to_numpy()
+    assert effect["estimate"]["sd_of_differences"] == pytest.approx(d.std(ddof=1))
+    assert effect["effect_sizes"]["d_z"]["value"] == pytest.approx(ref.statistic / math.sqrt(6))
+    assert effect["effect_size"]["name"] == "d_z"
+
+
+def test_incomplete_subjects_are_dropped_and_reported():
+    data = _paired()
+    data = data[~((data.subject == "S0") & (data.time == "post"))]
+    out = ttest(data, "y", within=["time"], subject="subject")
+    assert out["n"]["subjects"] == 5
+    assert {"subject": "S0", "reason": "missing a within-subject level"} in out["n"]["excluded_detail"]
+    assert any(w["code"] == "subjects_dropped_incomplete" for w in out["warnings"])
+
+
+def test_missing_values_are_reported_and_the_input_is_not_mutated():
+    data = _two_groups()
+    data.loc[0, "y"] = np.nan
+    before = data.copy()
+    out = ttest(data, "y", between=["g"])
+    pd.testing.assert_frame_equal(data, before)
+    assert out["n"]["total"] == 10
+    assert any(w["code"] == "rows_dropped_missing" for w in out["warnings"])
+
+
+def test_results_are_json_and_deterministic():
+    one = ttest(_two_groups(), "y", between=["g"])
+    two = ttest(_two_groups(), "y", between=["g"])
+    assert json.dumps(one, sort_keys=True) == json.dumps(two, sort_keys=True)
+    assert "date" not in one
+
+
+def test_bad_input_raises_naming_the_column():
+    with pytest.raises(ValueError, match="nope"):
+        ttest(_two_groups(), "nope", between=["g"])
+    with pytest.raises(NotSupported):
+        ttest(_two_groups(), "y", between=["g"], within=["g"])
+
+
+# --- rank tests -----------------------------------------------------------
+
+
+def test_mann_whitney_matches_scipy_with_hodges_lehmann():
+    data = _two_groups()
+    out = rank_test(data, "y", between=["g"])
+    (effect,) = out["effects"]
+    a = data[data.g == "A"].y.to_numpy()
+    b = data[data.g == "B"].y.to_numpy()
+    ref = stats.mannwhitneyu(a, b)
+    assert effect["statistic"] == pytest.approx(ref.statistic)
+    assert effect["p"] == pytest.approx(ref.pvalue)
+    assert effect["estimate"]["value"] == pytest.approx(np.median((a[:, None] - b[None, :]).ravel()))
+    assert effect["effect_size"]["value"] == pytest.approx(2 * ref.statistic / (len(a) * len(b)) - 1)
+    assert effect["effect_size"]["value"] == pytest.approx(1.0), "every A exceeds every B"
+
+
+def test_wilcoxon_matches_scipy():
+    data = _paired()
+    out = rank_test(data, "y", within=["time"], subject="subject", levels={"time": ["post", "pre"]})
+    (effect,) = out["effects"]
+    wide = data.pivot(index="subject", columns="time", values="y")
+    ref = stats.wilcoxon(wide["post"] - wide["pre"])
+    assert effect["statistic"] == pytest.approx(ref.statistic)
+    assert effect["p"] == pytest.approx(ref.pvalue)
+    assert effect["effect_size"]["value"] == pytest.approx(1.0), "every difference is positive"
+
+
+# --- ANOVA family ---------------------------------------------------------
+
+
+def _three_groups():
+    rng = np.random.default_rng(3)
+    return pd.DataFrame({
+        "g": np.repeat(["A", "B", "C"], 8),
+        "y": np.concatenate([rng.normal(m, 1, 8) for m in (5, 6, 7.5)]),
+    })
+
+
+def test_one_way_anova_matches_scipy():
+    data = _three_groups()
+    out = anova(data, "y", between=["g"])
+    (effect,) = out["effects"]
+    ref = stats.f_oneway(*[data[data.g == g].y for g in "ABC"])
+    assert effect["statistic"] == pytest.approx(ref.statistic)
+    assert effect["p"] == pytest.approx(ref.pvalue)
+    assert effect["df"] == [2.0, 21.0]
+    f = ref.statistic
+    assert effect["effect_sizes"]["eta2_p"]["value"] == pytest.approx(2 * f / (2 * f + 21))
+    assert effect["effect_sizes"]["omega2_p"]["value"] == pytest.approx(2 * (f - 1) / (2 * (f - 1) + 24))
+
+
+def _rm(levels=("t1", "t2", "t3"), groups=None):
+    rng = np.random.default_rng(5)
+    rows = []
+    for s in range(8):
+        base = rng.normal(10, 2)
+        for i, t in enumerate(levels):
+            rows.append({"subject": f"S{s}", "time": t, "y": base + i + rng.normal(0, 0.5),
+                         **({"group": "ctl" if s < 4 else "trt"} if groups else {})})
+    return pd.DataFrame(rows)
+
+
+def test_rm_anova_applies_greenhouse_geisser_with_three_levels():
+    out = anova(_rm(), "y", within=["time"], subject="subject")
+    (effect,) = out["effects"]
+    assert out["test"] == "anova_rm"
+    assert effect["term"] == "time"
+    assert effect["sphericity_correction"]["method"] == "greenhouse_geisser"
+    assert effect["effect_size"]["name"] == "eta2_g"
+    assert 0 <= effect["effect_sizes"]["eta2_g"]["value"] <= effect["effect_sizes"]["eta2_p"]["value"]
+
+
+def test_mixed_anova_terms_and_generalized_eta():
+    out = anova(_rm(groups=True), "y", between=["group"], within=["time"], subject="subject")
+    terms = [e["term"] for e in out["effects"]]
+    assert terms == ["group", "time", "group:time"]
+    for effect in out["effects"]:
+        g = effect["effect_sizes"]["eta2_g"]["value"]
+        assert 0 <= g <= effect["effect_sizes"]["eta2_p"]["value"] + 1e-12
+
+
+def test_unsupported_anova_design_says_so():
+    data = _rm(groups=True)
+    data["side"] = "L"
+    with pytest.raises(NotSupported, match="not yet in csv-stats"):
+        anova(data, "y", between=["group", "side"], within=["time"], subject="subject")
+
+
+def test_kruskal_and_friedman():
+    data = _three_groups()
+    k = kruskal(data, "y", between=["g"])
+    ref = stats.kruskal(*[data[data.g == g].y for g in "ABC"])
+    assert k["effects"][0]["statistic"] == pytest.approx(ref.statistic)
+    f = friedman(_rm(), "y", within=["time"], subject="subject")
+    wide = _rm().pivot(index="subject", columns="time", values="y")
+    ref = stats.friedmanchisquare(wide.t1, wide.t2, wide.t3)
+    assert f["effects"][0]["statistic"] == pytest.approx(ref.statistic)
+    assert f["effects"][0]["effect_size"]["value"] == pytest.approx(ref.statistic / (8 * 2))
+
+
+def test_pingouin_p_columns_are_read_under_both_spellings():
+    """Regression: pingouin 0.6 renamed p-unc -> p_unc (KeyError)."""
+    from csvstats.core import _p_unc
+
+    assert _p_unc(pd.Series({"p_unc": 0.2})) == 0.2
+    assert _p_unc(pd.Series({"p-unc": 0.3})) == 0.3
+
+
+def _curves(paired: bool):
+    rng = np.random.default_rng(11)
+    rows = []
+    for s in range(8):
+        base = np.sin(np.linspace(0, np.pi, 101)) + rng.normal(0, 0.05, 101)
+        for level, shift in (("pre", 0.0), ("post", 0.6)):
+            bump = shift * np.exp(-((np.arange(101) - 50) ** 2) / 50.0)
+            rows.append({"subject": f"S{s}" if paired else f"{level}{s}", "time": level,
+                         "y": list(base + bump + rng.normal(0, 0.05, 101))})
+    return pd.DataFrame(rows)
+
+
+def test_spm_refuses_unequal_lengths_before_needing_spm1d():
+    from csvstats.core import _curve_matrix
+
+    with pytest.raises(ValueError, match="unequal length"):
+        _curve_matrix([[1, 2, 3], [1, 2]], "x")
+
+
+def test_spm_paired_finds_the_middle_cluster():
+    pytest.importorskip("spm1d", reason="SPM tests need spm1d (pip install spm1d)")
+    from csvstats.core import spm_ttest
+
+    out = spm_ttest(_curves(True), "y", within=["time"], subject="subject", levels={"time": ["post", "pre"]})
+    (effect,) = out["effects"]
+    assert out["test"] == "spm_ttest_paired"
+    assert effect["clusters"], "the bump at node 50 is supra-threshold"
+    cluster = effect["clusters"][0]
+    assert cluster["start"] < 50 < cluster["end"]
+    assert effect["p"] is not None and effect["p"] < 0.05
+    assert len(effect["curve"]) == 101

csv_stats-0.2.1/tests/test_descriptive.py

@@ -0,0 +1,116 @@
+"""csvstats.descriptive: the one definition of each descriptive formula."""
+
+import subprocess
+import sys
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from csvstats.descriptive import (
+    ci_half_width,
+    ci_interval,
+    sem,
+    summarize,
+    t_critical,
+)
+from csvstats.utils.summary_stats import calculate_summary_statistics
+
+#: t(0.975, n - 1) from published tables.
+T_975 = {2: 12.7062, 5: 2.7764, 30: 2.0452}
+
+
+@pytest.mark.parametrize("n", sorted(T_975))
+def test_t_critical_matches_published_tables(n):
+    assert t_critical(n) == pytest.approx(T_975[n], abs=1e-4)
+
+
+def test_t_critical_is_nan_below_two_values():
+    assert np.isnan(t_critical(1))
+    assert np.isnan(t_critical(0))
+
+
+def test_array_and_series_shapes_are_kept():
+    counts = pd.Series([2, 5, 1], index=["a", "b", "c"])
+    out = t_critical(counts)
+    assert list(out.index) == ["a", "b", "c"]
+    assert out["a"] == pytest.approx(T_975[2], abs=1e-4)
+    assert np.isnan(out["c"])
+    widths = ci_half_width(np.array([1.0, 2.0]), np.array([5, 30]))
+    assert widths == pytest.approx([T_975[5] / np.sqrt(5), 2 * T_975[30] / np.sqrt(30)], rel=1e-4)
+
+
+@pytest.mark.parametrize("n", sorted(T_975))
+def test_ci_is_t_based_not_z(n):
+    values = np.arange(1.0, n + 1.0) ** 1.5
+    sd = values.std(ddof=1)
+    low, high = ci_interval(values)
+    half = T_975[n] * sd / np.sqrt(n)
+    assert (high - low) / 2 == pytest.approx(half, rel=1e-4)
+    assert (high - low) / 2 != pytest.approx(1.96 * sd / np.sqrt(n), rel=1e-3)
+    assert ci_half_width(sd, n) == pytest.approx(half, rel=1e-4)
+
+
+def test_ci_on_the_median_keeps_the_mean_half_width():
+    values = [1.0, 2.0, 3.0, 10.0]
+    low, high = ci_interval(values, centre="median")
+    assert (low + high) / 2 == pytest.approx(2.5)
+    assert (high - low) / 2 == pytest.approx(float(ci_half_width(np.std(values, ddof=1), 4)))
+
+
+def test_missing_values_are_skipped_and_counted_separately():
+    s = summarize([1.0, 2.0, 3.0, None, np.nan])
+    assert s["n"] == 3 and s["n_missing"] == 2
+    assert s["mean"] == pytest.approx(2.0)
+    assert s["sd"] == pytest.approx(1.0)
+    assert s["sem"] == pytest.approx(1.0 / np.sqrt(3))
+    assert s["ci_high"] - s["mean"] == pytest.approx(float(t_critical(3)) / np.sqrt(3))
+
+
+def test_summarize_reference_values():
+    values = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]
+    s = summarize(values)
+    assert s["mean"] == pytest.approx(5.0)
+    assert s["sd"] == pytest.approx(np.std(values, ddof=1))
+    assert s["median"] == pytest.approx(4.5)
+    assert (s["q1"], s["q3"]) == pytest.approx((4.0, 5.5))
+    assert s["iqr"] == pytest.approx(1.5)
+    assert s["range"] == pytest.approx(7.0)
+    assert s["mode"] == 4.0 and s["mode_count"] == 3
+    assert s["cv"] == pytest.approx(s["sd"] / 5.0)
+    # Bias-corrected G1 / G2 (scipy bias=False), as SPSS reports them.
+    assert s["skewness"] == pytest.approx(0.8184875, abs=1e-6)
+    assert s["kurtosis"] == pytest.approx(0.940625, abs=1e-6)
+
+
+def test_too_few_values_give_nan_not_zero():
+    one = summarize([3.0])
+    assert one["n"] == 1 and one["mean"] == 3.0
+    for key in ("sd", "sem", "ci_low", "ci_high", "variance", "skewness", "kurtosis"):
+        assert np.isnan(one[key]), key
+    assert np.isnan(sem(1.0, 1))
+    empty = summarize([])
+    assert empty["n"] == 0 and np.isnan(empty["mean"])
+
+
+def test_summary_statistics_count_excludes_missing_values():
+    """Regression: count was len(group), which counted NaN, so n and the CI
+    disagreed with the mean and SD."""
+    data = pd.DataFrame({"g": ["a"] * 4 + ["b"] * 3, "v": [1.0, 2.0, 3.0, np.nan, 5.0, 6.0, 7.0]})
+    out = calculate_summary_statistics(data, "g", "v")
+    assert out["grouped"]["count"] == {"a": 3, "b": 3}
+    assert out["grouped"]["n_missing"] == {"a": 1, "b": 0}
+    assert out["grouped"]["ci_95_high"]["a"] == pytest.approx(summarize([1.0, 2.0, 3.0])["ci_high"])
+    assert out["overall"]["count"] == 6
+    assert out["overall"]["n_missing"] == 1
+
+
+def test_descriptive_imports_no_heavy_dependencies():
+    """A plotting package depends on this module; it must stay light."""
+    code = (
+        "import sys, csvstats.descriptive\n"
+        "heavy = {'pingouin', 'statsmodels', 'matplotlib', 'reportlab', 'seaborn'}\n"
+        "print(sorted(heavy & {m.split('.')[0] for m in sys.modules}))\n"
+    )
+    out = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True, check=True)
+    assert out.stdout.strip() == "[]", out.stdout