dsba-python1-alpha 0.1.0__py3-none-any.whl

dsba_checkers/workshops/__init__.py

@@ -0,0 +1 @@
+# workshops sub-package

dsba_checkers/workshops/w14_scipy.py

@@ -0,0 +1,286 @@
+"""
+dsba_checkers.workshops.w14_scipy
+──────────────────────────────────
+Checker for Workshop 14 — Using scipy.stats
+Dataset bundled inside the package (insurance.csv).
+
+Usage:
+    from dsba_checkers.workshops.w14_scipy import q1, q2, q3, q4, q5, q6, q7
+"""
+
+import importlib.resources
+import numpy as np
+import pandas as pd
+from scipy import stats
+
+from ..base_task import Task
+
+# ── Load bundled data once at import time ────────────────────────────────────
+
+def _load_df():
+    try:
+        # Python 3.9+
+        ref = importlib.resources.files("dsba_checkers.data").joinpath("insurance.csv")
+        with importlib.resources.as_file(ref) as path:
+            return pd.read_csv(path)
+    except AttributeError:
+        # Python 3.8 fallback
+        with importlib.resources.open_text("dsba_checkers.data", "insurance.csv") as f:
+            return pd.read_csv(f)
+
+_df = _load_df()
+
+
+# ── Task 1 — Descriptive statistics for `charges` ───────────────────────────
+
+class _Q1_DescriptiveStats(Task):
+    _hint = (
+        "Use df['charges'].mean(), .median(), stats.skew(df['charges']). "
+        "Outliers: q1 = quantile(0.25), q3 = quantile(0.75), "
+        "iqr = q3 - q1, then keep rows outside [q1 - 1.5*iqr, q3 + 1.5*iqr]."
+    )
+    _solution = """\
+  mean_charges     = df['charges'].mean()           # 13 270.42
+  median_charges   = df['charges'].median()         #  9 382.03
+  skewness_charges = stats.skew(df['charges'])      #     1.515
+
+  q1_val = df['charges'].quantile(0.25)
+  q3_val = df['charges'].quantile(0.75)
+  iqr    = q3_val - q1_val
+  outliers  = df[(df['charges'] < q1_val - 1.5*iqr) | (df['charges'] > q3_val + 1.5*iqr)]
+  n_outliers = len(outliers)   # 139"""
+
+    def _check(self, mean_charges, median_charges, skewness_charges, n_outliers):
+        ref_mean   = _df['charges'].mean()
+        ref_median = _df['charges'].median()
+        ref_skew   = float(stats.skew(_df['charges']))
+        q1v = _df['charges'].quantile(0.25)
+        q3v = _df['charges'].quantile(0.75)
+        iqr = q3v - q1v
+        ref_n = int(((_df['charges'] < q1v - 1.5*iqr) | (_df['charges'] > q3v + 1.5*iqr)).sum())
+
+        assert self._approx_equal(mean_charges, ref_mean), (
+            f"mean_charges ≈ {ref_mean:,.2f}, got {mean_charges:,.2f}.")
+        assert self._approx_equal(median_charges, ref_median), (
+            f"median_charges ≈ {ref_median:,.2f}, got {median_charges:,.2f}.")
+        assert self._approx_equal(skewness_charges, ref_skew, tol=0.02), (
+            f"skewness ≈ {ref_skew:.3f}, got {skewness_charges:.3f}. "
+            "Use stats.skew(df['charges']).")
+        assert int(n_outliers) == ref_n, (
+            f"Expected {ref_n} IQR outliers, got {n_outliers}.")
+        return True
+
+
+# ── Task 2 — Pearson correlation: age vs charges ─────────────────────────────
+
+class _Q2_PearsonAge(Task):
+    _hint = (
+        "stats.pearsonr(df['age'], df['charges']) returns (r, p_value). "
+        "Check: is p < 0.05?"
+    )
+    _solution = """\
+  r_age_charges, p_age_charges = stats.pearsonr(df['age'], df['charges'])
+  # r ≈ 0.2990,  p ≈ 0.0"""
+
+    def _check(self, r, p):
+        ref_r, ref_p = stats.pearsonr(_df['age'], _df['charges'])
+        assert self._approx_equal(r, ref_r, tol=0.005), (
+            f"r ≈ {ref_r:.4f}, got {r:.4f}. "
+            "Pass df['age'] and df['charges'] to stats.pearsonr().")
+        assert p < 0.05, (
+            f"p-value should be < 0.05 (actual ≈ {ref_p:.2e}). "
+            "Double-check which columns you passed.")
+        return True
+
+
+# ── Task 3 — Pearson vs Spearman, split by smoker ────────────────────────────
+
+class _Q3_PearsonSpearman(Task):
+    _hint = (
+        "stats.pearsonr(x, y) and stats.spearmanr(x, y) both return (stat, p). "
+        "Split first: non_smokers = df[df['smoker'] == 'no']."
+    )
+    _solution = """\
+  pearson_all  = stats.pearsonr( df['bmi'], df['charges'])
+  spearman_all = stats.spearmanr(df['bmi'], df['charges'])
+
+  ns = df[df['smoker'] == 'no']
+  pearson_ns  = stats.pearsonr( ns['bmi'], ns['charges'])
+  spearman_ns = stats.spearmanr(ns['bmi'], ns['charges'])
+
+  s = df[df['smoker'] == 'yes']
+  pearson_s  = stats.pearsonr( s['bmi'], s['charges'])
+  spearman_s = stats.spearmanr(s['bmi'], s['charges'])"""
+
+    def _check(self, pearson_all, spearman_all, pearson_ns, spearman_ns, pearson_s, spearman_s):
+        ns = _df[_df['smoker'] == 'no']
+        s  = _df[_df['smoker'] == 'yes']
+        refs = [
+            (pearson_all[0],  stats.pearsonr( _df['bmi'], _df['charges'])[0], "pearson_all"),
+            (spearman_all[0], stats.spearmanr(_df['bmi'], _df['charges'])[0], "spearman_all"),
+            (pearson_ns[0],   stats.pearsonr( ns['bmi'],  ns['charges'])[0],  "pearson_ns"),
+            (spearman_ns[0],  stats.spearmanr(ns['bmi'],  ns['charges'])[0],  "spearman_ns"),
+            (pearson_s[0],    stats.pearsonr( s['bmi'],   s['charges'])[0],   "pearson_s"),
+            (spearman_s[0],   stats.spearmanr(s['bmi'],   s['charges'])[0],   "spearman_s"),
+        ]
+        for got, ref, name in refs:
+            assert self._approx_equal(got, ref, tol=0.005), (
+                f"{name}: expected ≈ {ref:.4f}, got {got:.4f}.")
+        return True
+
+
+# ── Task 4 — Normality tests for BMI ─────────────────────────────────────────
+
+class _Q4_NormalityBMI(Task):
+    _hint = (
+        "stats.shapiro(df['bmi']) → (W, p). "
+        "stats.normaltest(df['bmi']) → (stat, p)."
+    )
+    _solution = """\
+  stat_sw, p_sw = stats.shapiro(df['bmi'])
+  stat_da, p_da = stats.normaltest(df['bmi'])
+  # Shapiro-Wilk:  W ≈ 0.9977, p ≈ 0.0099
+  # D'Agostino K²: stat ≈ 1.01,  p ≈ 0.603"""
+
+    def _check(self, stat_sw, p_sw, stat_da, p_da):
+        ref_sw_s, ref_sw_p = stats.shapiro(_df['bmi'])
+        ref_da_s, ref_da_p = stats.normaltest(_df['bmi'])
+        assert self._approx_equal(stat_sw, ref_sw_s, tol=0.001), (
+            f"Shapiro W ≈ {ref_sw_s:.4f}, got {stat_sw:.4f}.")
+        assert self._approx_equal(p_sw, ref_sw_p, tol=0.05), (
+            f"Shapiro p ≈ {ref_sw_p:.4f}, got {p_sw:.4f}.")
+        assert self._approx_equal(stat_da, ref_da_s, tol=0.05), (
+            f"D'Agostino stat ≈ {ref_da_s:.4f}, got {stat_da:.4f}. Use stats.normaltest().")
+        assert self._approx_equal(p_da, ref_da_p, tol=0.05), (
+            f"D'Agostino p ≈ {ref_da_p:.4f}, got {p_da:.4f}.")
+        return True
+
+
+# ── Task 5 — Two-sample t-test: smokers vs non-smokers ───────────────────────
+
+class _Q5_TTest(Task):
+    _hint = (
+        "Levene's test: stats.levene(smoker_charges, nonsmoker_charges). "
+        "Welch's t-test: stats.ttest_ind(..., equal_var=False). "
+        "Cohen's d = (mean1 - mean2) / pooled_std, "
+        "where pooled_std = sqrt(((n1-1)*s1² + (n2-1)*s2²) / (n1+n2-2))."
+    )
+    _solution = """\
+  sc  = df[df['smoker'] == 'yes']['charges']
+  nsc = df[df['smoker'] == 'no']['charges']
+
+  stat_levene, p_levene = stats.levene(sc, nsc)
+  stat_t, p_t = stats.ttest_ind(sc, nsc, equal_var=False)
+
+  n1, n2 = len(sc), len(nsc)
+  s1, s2 = sc.std(ddof=1), nsc.std(ddof=1)
+  pooled_std = np.sqrt(((n1-1)*s1**2 + (n2-1)*s2**2) / (n1+n2-2))
+  cohens_d   = (sc.mean() - nsc.mean()) / pooled_std   # ≈ 2.09"""
+
+    def _check(self, stat_t, p_t, cohens_d, stat_levene=None, p_levene=None):
+        sc  = _df[_df['smoker'] == 'yes']['charges']
+        nsc = _df[_df['smoker'] == 'no']['charges']
+        ref_t, ref_p = stats.ttest_ind(sc, nsc, equal_var=False)
+        n1, n2 = len(sc), len(nsc)
+        s1, s2 = sc.std(ddof=1), nsc.std(ddof=1)
+        pooled = np.sqrt(((n1-1)*s1**2 + (n2-1)*s2**2) / (n1+n2-2))
+        ref_d  = float((sc.mean() - nsc.mean()) / pooled)
+
+        assert self._approx_equal(abs(stat_t), abs(ref_t), tol=0.005), (
+            f"t ≈ {ref_t:.4f}, got {stat_t:.4f}. "
+            "Use stats.ttest_ind(sc, nsc, equal_var=False).")
+        assert p_t < 1e-10, f"p should be ≈ 0, got {p_t}."
+        assert self._approx_equal(cohens_d, ref_d, tol=0.02), (
+            f"Cohen's d ≈ {ref_d:.4f}, got {cohens_d:.4f}.")
+        if stat_levene is not None:
+            ref_lev, _ = stats.levene(sc, nsc)
+            assert self._approx_equal(stat_levene, ref_lev, tol=0.05), (
+                f"Levene stat ≈ {ref_lev:.4f}, got {stat_levene:.4f}.")
+        return True
+
+
+# ── Task 6 — Paired t-test: wellness BMI scenario ────────────────────────────
+
+class _Q6_PairedTTest(Task):
+    _hint = (
+        "diff = before_bmi - after_bmi. "
+        "mean_diff = np.mean(diff), std_diff = np.std(diff, ddof=1). "
+        "stats.ttest_rel(before_bmi, after_bmi) → (stat, p)."
+    )
+    _solution = """\
+  diff        = before_bmi - after_bmi
+  mean_diff   = np.mean(diff)            # ≈ 2.45
+  std_diff    = np.std(diff, ddof=1)
+  stat_paired, p_paired = stats.ttest_rel(before_bmi, after_bmi)
+  # stat ≈ 4.32,  p ≈ 0.00017"""
+
+    def _check(self, mean_diff, std_diff, stat_paired, p_paired):
+        np.random.seed(123)
+        before = np.random.normal(32, 5, 30)
+        after  = np.maximum(before - np.random.normal(2.5, 3, 30), 18)
+        diff   = before - after
+        ref_mean = float(np.mean(diff))
+        ref_std  = float(np.std(diff, ddof=1))
+        ref_stat, ref_p = stats.ttest_rel(before, after)
+
+        assert self._approx_equal(mean_diff, ref_mean, tol=0.02), (
+            f"mean_diff ≈ {ref_mean:.4f}, got {mean_diff:.4f}.")
+        assert self._approx_equal(std_diff, ref_std, tol=0.02), (
+            f"std_diff ≈ {ref_std:.4f}, got {std_diff:.4f}. Use ddof=1.")
+        assert self._approx_equal(abs(stat_paired), abs(ref_stat), tol=0.02), (
+            f"t ≈ {ref_stat:.4f}, got {stat_paired:.4f}.")
+        assert p_paired < 0.05, f"p should be < 0.05, got {p_paired:.4f}."
+        return True
+
+
+# ── Task 7 — Bonferroni correction across regions ────────────────────────────
+
+class _Q7_Bonferroni(Task):
+    _hint = (
+        "4 regions → C(4,2) = 6 pairs. bonferroni_alpha = 0.05 / 6. "
+        "Loop with combinations(regions, 2), call stats.ttest_ind(d1, d2), "
+        "count pairs where p_val < bonferroni_alpha."
+    )
+    _solution = """\
+  from itertools import combinations
+  regions          = df['region'].unique()
+  n_comparisons    = len(list(combinations(regions, 2)))   # 6
+  bonferroni_alpha = 0.05 / n_comparisons                  # ≈ 0.008333
+
+  n_significant_pairs = 0
+  for r1, r2 in combinations(regions, 2):
+      _, p = stats.ttest_ind(df[df['region']==r1]['charges'],
+                             df[df['region']==r2]['charges'])
+      if p < bonferroni_alpha:
+          n_significant_pairs += 1   # result: 1"""
+
+    def _check(self, n_comparisons, bonferroni_alpha, n_significant_pairs):
+        from itertools import combinations
+        regions   = _df['region'].unique()
+        ref_n     = len(list(combinations(regions, 2)))
+        ref_bonf  = 0.05 / ref_n
+        ref_sig   = sum(
+            1 for r1, r2 in combinations(regions, 2)
+            if stats.ttest_ind(_df[_df['region']==r1]['charges'],
+                               _df[_df['region']==r2]['charges'])[1] < ref_bonf
+        )
+        assert int(n_comparisons) == ref_n, (
+            f"Expected {ref_n} comparisons (C(4,2)), got {n_comparisons}.")
+        assert self._approx_equal(bonferroni_alpha, ref_bonf, tol=0.001), (
+            f"bonferroni_alpha = 0.05/{ref_n} ≈ {ref_bonf:.6f}, got {bonferroni_alpha:.6f}.")
+        assert int(n_significant_pairs) == ref_sig, (
+            f"Expected {ref_sig} significant pair(s), got {n_significant_pairs}.")
+        return True
+
+
+# ── Public objects ────────────────────────────────────────────────────────────
+
+q1 = _Q1_DescriptiveStats()
+q2 = _Q2_PearsonAge()
+q3 = _Q3_PearsonSpearman()
+q4 = _Q4_NormalityBMI()
+q5 = _Q5_TTest()
+q6 = _Q6_PairedTTest()
+q7 = _Q7_Bonferroni()
+
+__all__ = ["q1", "q2", "q3", "q4", "q5", "q6", "q7"]

dsba_python1_alpha-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: dsba-python1-alpha
+Version: 0.1.0
+Summary: Auto-checkers for the DSBA Python for Data Science course
+Project-URL: Homepage, https://github.com/your-org/dsba-checkers
+License: MIT
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.21
+Requires-Dist: pandas>=1.3
+Requires-Dist: scipy>=1.7
+Description-Content-Type: text/markdown
+
+# dsba-python1-alpha
+
+Auto-checkers for the **DSBA Python for Data Science** course.  
+Inspired by Kaggle's `learntools` — same `.check()` / `.hint()` / `.solution()` API,  
+all datasets bundled inside the package (no internet required).
+
+## Install
+
+```bash
+pip install dsba-python1-alpha
+```
+
+## Workshop 14 — scipy.stats
+
+```python
+from dsba_checkers.workshops.w14_scipy import q1, q2, q3, q4, q5, q6, q7
+
+# After writing your code:
+q1.check(mean_charges, median_charges, skewness_charges, n_outliers)
+# ✓  Correct!
+
+# Stuck? Ask for a hint:
+q1.hint()
+
+# Give up? Show the solution (also shown automatically after 3 failed attempts):
+q1.solution()
+```
+
+## Available workshops
+
+| Module | Topic |
+|--------|-------|
+| `dsba_checkers.workshops.w14_scipy` | scipy.stats: descriptive stats, correlation, t-tests, Bonferroni |
+
+More workshops coming in future versions.

dsba_python1_alpha-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dsba_checkers/__init__.py,sha256=-Nql8Eus0KntYBV-SFhWnNYurjoD7EsNRL8fI5w1TWk,395
+dsba_checkers/base_task.py,sha256=nywQPKSQ3R4YXLd3fdoYo4GTzBUUVwejLGYlpFVNtRo,1808
+dsba_checkers/data/__init__.py,sha256=V1sknNbutTDg3wiZ0UuYMwWQiLKMMMK9FL-YZfsoJEE,53
+dsba_checkers/workshops/__init__.py,sha256=puMXpi3fz5ZBMyKz-gYuefbv9UF7ySbc8hO2zBRs7G8,24
+dsba_checkers/workshops/w14_scipy.py,sha256=Dsj05RN9hfkurXhZw8cHAyueuVCypchzSFehgGbY8V4,12541
+dsba_checkers/data/insurance.csv,sha256=UFwcvC5j0DY7rFlQFWPfJTCq30zbnP7iJvTvMvVGgoE,54288
+dsba_python1_alpha-0.1.0.dist-info/METADATA,sha256=Waryy72vlpxyTz4q3-HZU0fbegQBTguwoGwmw_CSyp8,1225
+dsba_python1_alpha-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+dsba_python1_alpha-0.1.0.dist-info/RECORD,,

dsba_python1_alpha-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any