ltc-code 0.1.87__tar.gz → 0.1.88__tar.gz

{ltc_code-0.1.87 → ltc_code-0.1.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ltc-code
-Version: 0.1.87
+Version: 0.1.88
 Summary: Add your description here
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{ltc_code-0.1.87 → ltc_code-0.1.88}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ltc-code"
-version = "0.1.87"
+version = "0.1.88"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.9"

ltc_code-0.1.88/src/ltc_code/june5.py

@@ -0,0 +1,187 @@
+DEDUP_KEYS = [
+    "sid_cepr",
+    "school_year",
+    "entry_grade_clean",
+    "school_name",
+]
+
+EVER_COLS = [
+    "offer",
+    "waitlist",
+    "withdraw",
+    "offer_accepted",
+    "enroll",
+    "sibling",
+    "staff",
+    "zoned",
+]
+
+INFO_COLS = [
+    "lottery_number",
+    "waitlist_number",
+    "priority_group",
+    "priority_group_name",
+    "school_accept",
+]
+
+
+
+
+from typing import List, Union
+
+import polars as pl
+
+
+def resolve_duplicate_applications(
+    df: Union[pl.DataFrame, pl.LazyFrame],
+    dedup_keys: List[str],
+    ever_cols: List[str],
+    info_cols: List[str],
+) -> Union[pl.DataFrame, pl.LazyFrame]:
+    columns = df.collect_schema().names() if isinstance(df, pl.LazyFrame) else df.columns
+
+    missing = [
+        c for c in dedup_keys + ever_cols + info_cols
+        if c not in columns
+    ]
+    if missing:
+        raise ValueError("Missing specified columns: %s" % missing)
+
+    has_late_app = "late_app" in columns
+    has_application_cancel = "application_cancel" in columns
+
+    # These are optional tie-breakers only. They are not required and they do
+    # not affect the collapsed event flags.
+    date_tiebreakers = [
+        c for c in ["application_date", "offer_date"]
+        if c in columns
+    ]
+
+    late_rank = (
+        pl.when(pl.col("late_app") == 1)
+        .then(2)
+        .when(pl.col("late_app").is_null())
+        .then(1)
+        .otherwise(0)
+        if has_late_app
+        else pl.lit(0)
+    )
+
+    cancel_rank = (
+        pl.when(pl.col("application_cancel") == 1)
+        .then(2)
+        .when(pl.col("application_cancel").is_null())
+        .then(1)
+        .otherwise(0)
+        if has_application_cancel
+        else pl.lit(0)
+    )
+
+    # Outcome ranking follows the order of ever_cols:
+    # earlier columns are treated as stronger representative-row evidence.
+    outcome_rank = pl.lit(len(ever_cols))
+    for i, col in reversed(list(enumerate(ever_cols))):
+        outcome_rank = (
+            pl.when(pl.col(col) == 1)
+            .then(i)
+            .otherwise(outcome_rank)
+        )
+
+    sort_cols = (
+        dedup_keys
+        + ["_late_rank", "_cancel_rank", "_outcome_rank", "_info_count"]
+        + date_tiebreakers
+    )
+
+    descending = (
+        [False] * len(dedup_keys)
+        + [
+            False,  # prefer not late, if late_app exists
+            False,  # prefer not cancelled, if application_cancel exists
+            False,  # prefer earlier/stronger event columns from ever_cols
+            True,   # prefer rows with more non-null info columns
+        ]
+        + [False] * len(date_tiebreakers)
+    )
+
+    ranked = (
+        df
+        .with_columns(pl.len().over(dedup_keys).alias("_dup_n"))
+        .with_columns(
+            _late_rank=late_rank,
+            _cancel_rank=cancel_rank,
+            _outcome_rank=outcome_rank,
+            _info_count=pl.sum_horizontal(
+                [pl.col(c).is_not_null().cast(pl.Int8) for c in info_cols]
+            ),
+        )
+    )
+
+    temp_cols = [
+        "_dup_n",
+        "_late_rank",
+        "_cancel_rank",
+        "_outcome_rank",
+        "_info_count",
+    ]
+
+    non_dupes = (
+        ranked
+        .filter(pl.col("_dup_n") == 1)
+        .drop(temp_cols, strict=False)
+    )
+
+    dupes = (
+        ranked
+        .filter(pl.col("_dup_n") > 1)
+        .sort(sort_cols, descending=descending, nulls_last=True)
+    )
+
+    rep_rows = dupes.group_by(dedup_keys).first()
+
+    valid_filter = pl.lit(True)
+
+    if has_late_app:
+        valid_filter = valid_filter & (pl.col("late_app") != 1).fill_null(True)
+
+    if has_application_cancel:
+        valid_filter = (
+            valid_filter
+            & (pl.col("application_cancel") != 1).fill_null(True)
+        )
+
+    valid_dupes = dupes.filter(valid_filter)
+
+    collapsed_flags = (
+        valid_dupes
+        .group_by(dedup_keys)
+        .agg([pl.col(c).max().alias("_%s_collapsed" % c) for c in ever_cols])
+    )
+
+    dupes_resolved = (
+        rep_rows
+        .join(collapsed_flags, on=dedup_keys, how="left")
+        .with_columns(
+            [
+                pl.coalesce(pl.col("_%s_collapsed" % c), pl.col(c)).alias(c)
+                for c in ever_cols
+            ]
+        )
+        .drop(
+            temp_cols + ["_%s_collapsed" % c for c in ever_cols],
+            strict=False,
+        )
+    )
+
+    final = pl.concat([non_dupes, dupes_resolved], how="vertical_relaxed")
+
+    if isinstance(final, pl.DataFrame):
+        duplicate_count = (
+            final.select(dedup_keys).height
+            - final.select(dedup_keys).unique().height
+        )
+        assert duplicate_count == 0, (
+            "Found %s unresolved duplicate rows." % duplicate_count
+        )
+
+    return final