ltc-code 0.1.89__tar.gz → 0.1.91__tar.gz

{ltc_code-0.1.89 → ltc_code-0.1.91}/PKG-INFO

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

{ltc_code-0.1.89 → ltc_code-0.1.91}/pyproject.toml

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

{ltc_code-0.1.89 → ltc_code-0.1.91}/src/ltc_code/june7.py

@@ -11,20 +11,8 @@ def resolve_rank_choice_duplicate_applications(
 ) -> Union[pl.DataFrame, pl.LazyFrame]:
     """Resolve duplicate rank-choice application rows.
 
-    Rank-choice files can put multiple school choices on one row. This helper
-    compares the set of school choices within each applicant context
-    (``base_keys``), collapses rows that look like the same underlying
-    application, and leaves distinct applications separate.
-
-    Rows are collapsed when they have the exact same school set, or when one
-    row's school set is a strict subset of another row's set and the outcomes
-    for overlapping schools agree. Collapsed rows keep one representative row
-    for record-specific fields and take maxes across ``ever_cols`` among valid
-    rows. Rows left separate are flagged as current duplicates if more than
-    one application remains for the same ``base_keys``.
-
-    If ``df`` is a LazyFrame, this helper collects it to perform pairwise
-    set/subset comparisons, then returns a LazyFrame built from the result.
+    If df is a LazyFrame, this helper collects it to do pairwise set/subset
+    comparisons, then returns a LazyFrame built from the result.
     """
     if not isinstance(df, (pl.DataFrame, pl.LazyFrame)):
         raise TypeError("df must be a polars DataFrame or LazyFrame.")
@@ -41,10 +29,6 @@ def resolve_rank_choice_duplicate_applications(
 
     requested = base_keys + school_choice_cols + ever_cols + info_cols
     requested.extend(outcome_school_cols.values())
-    if late_col in columns:
-        requested.append(late_col)
-    if cancel_col in columns:
-        requested.append(cancel_col)
 
     missing = [column for column in requested if column not in columns]
     if missing:
@@ -87,12 +71,8 @@ def resolve_rank_choice_duplicate_applications(
 
     def _outcome_signature(row: Mapping[str, Any], schools: Iterable[str]) -> Tuple[Any, ...]:
         overlap = sorted(set(schools))
-        mapped_outcomes = [
-            column for column in ever_cols if column in outcome_school_cols
-        ]
+        mapped_outcomes = [column for column in ever_cols if column in outcome_school_cols]
 
-        # Best case: an outcome flag has a paired school column, e.g.
-        # offer + offer_school. Then compare outcomes only for overlap schools.
         if mapped_outcomes:
             values = []
             for school in overlap:
@@ -108,9 +88,6 @@ def resolve_rank_choice_duplicate_applications(
                     )
             return tuple(values)
 
-        # Fallback: without school-specific outcome columns, the helper can only
-        # compare row-level outcome flags. This is enough for exact school-set
-        # duplicates, but it is a weaker assumption for subset decisions.
         return tuple((column, int(_is_one(row[column]))) for column in ever_cols)
 
     def _same_overlap_outcomes(
@@ -126,18 +103,32 @@ def resolve_rank_choice_duplicate_applications(
     def _component_name(base_values: Tuple[Any, ...], school_set: Tuple[str, ...]) -> str:
         return "%r|schools=%r" % (base_values, school_set)
 
+    def _find(parent: Dict[int, int], row_id: int) -> int:
+        while parent[row_id] != row_id:
+            parent[row_id] = parent[parent[row_id]]
+            row_id = parent[row_id]
+        return row_id
+
+    def _union(parent: Dict[int, int], left_id: int, right_id: int) -> None:
+        left_root = _find(parent, left_id)
+        right_root = _find(parent, right_id)
+        if left_root == right_root:
+            return
+        parent[max(left_root, right_root)] = min(left_root, right_root)
+
     work = frame.with_row_index("_rc_row_id")
     rows = work.to_dicts()
 
     metadata = {}
+    parent = {}
     for row in rows:
         ordered_schools, school_set = _school_values(row)
         row_id = row["_rc_row_id"]
+        parent[row_id] = row_id
         metadata[row_id] = {
             "base": tuple(row[column] for column in base_keys),
             "ordered": ordered_schools,
             "set": school_set,
-            "component": "%r|row=%s" % (tuple(row[column] for column in base_keys), row_id),
             "case": 0,
             "school_set_readable": " | ".join(school_set) or None,
             "school_ordered_readable": " | ".join(ordered_schools) or None,
@@ -152,32 +143,23 @@ def resolve_rank_choice_duplicate_applications(
         for row in group_rows:
             rows_by_set.setdefault(metadata[row["_rc_row_id"]]["set"], []).append(row)
 
-        # Cases 1-2: exact same application school set. These collapse even
-        # when row-level outcomes differ, because max(ever_cols) keeps evidence.
         for school_set, set_rows in rows_by_set.items():
             if len(set_rows) <= 1:
                 continue
-            signatures = {
-                _outcome_signature(row, school_set)
-                for row in set_rows
-            }
+            signatures = {_outcome_signature(row, school_set) for row in set_rows}
             case = 1 if len(signatures) == 1 else 2
-            component = _component_name(base_values, school_set)
+            anchor_id = set_rows[0]["_rc_row_id"]
             for row in set_rows:
                 row_id = row["_rc_row_id"]
-                metadata[row_id]["component"] = component
+                _union(parent, anchor_id, row_id)
                 metadata[row_id]["case"] = case
 
-        # Case 3: a strict subset row can collapse into a richer superset row
-        # when outcomes agree for the overlapping schools. If more than one
-        # superset qualifies, choose the largest/richest one deterministically.
         for row in group_rows:
             row_id = row["_rc_row_id"]
             school_set = set(metadata[row_id]["set"])
             if not school_set:
                 continue
 
-            candidates = []
             for other in group_rows:
                 other_id = other["_rc_row_id"]
                 if row_id == other_id:
@@ -187,36 +169,49 @@ def resolve_rank_choice_duplicate_applications(
                     continue
                 if not _same_overlap_outcomes(row, other, school_set):
                     continue
-                candidates.append(other)
-
-            if not candidates:
-                continue
+                _union(parent, row_id, other_id)
+                if metadata[row_id]["case"] == 0:
+                    metadata[row_id]["case"] = 3
+                if metadata[other_id]["case"] == 0:
+                    metadata[other_id]["case"] = 3
 
-            candidates.sort(
-                key=lambda candidate: (
-                    len(metadata[candidate["_rc_row_id"]]["set"]),
-                    _info_count(candidate),
-                    -candidate["_rc_row_id"],
-                ),
-                reverse=True,
-            )
-            target_set = metadata[candidates[0]["_rc_row_id"]]["set"]
-            component = _component_name(base_values, target_set)
-            metadata[row_id]["component"] = component
-            metadata[row_id]["case"] = 3
-            for target_row in rows_by_set[target_set]:
-                target_id = target_row["_rc_row_id"]
-                metadata[target_id]["component"] = component
+    component_rows = {}
+    for row in rows:
+        row_id = row["_rc_row_id"]
+        component_rows.setdefault(_find(parent, row_id), []).append(row_id)
+
+    component_labels = {}
+    for component_row_ids in component_rows.values():
+        representative_id = max(
+            component_row_ids,
+            key=lambda row_id: (
+                len(metadata[row_id]["set"]),
+                _info_count(rows[row_id]),
+                -row_id,
+            ),
+        )
+        component_school_set = metadata[representative_id]["set"]
+        component_base = metadata[representative_id]["base"]
+        if len(component_row_ids) == 1:
+            component = "%r|row=%s" % (component_base, representative_id)
+        else:
+            component = _component_name(component_base, component_school_set)
+
+        component_case = max(metadata[row_id]["case"] for row_id in component_row_ids)
+        for row_id in component_row_ids:
+            component_labels[row_id] = component
+            metadata[row_id]["case"] = component_case
 
     assignment_rows = []
     for row_id, values in metadata.items():
         assignment_rows.append(
             {
                 "_rc_row_id": row_id,
-                "_rc_component": values["component"],
+                "_rc_component": component_labels[row_id],
                 "rank_choice_duplicate_case": values["case"],
                 "rank_choice_school_set": values["school_set_readable"],
                 "rank_choice_school_ordered": values["school_ordered_readable"],
+                "_rc_school_count": len(values["set"]),
             }
         )
 
@@ -234,12 +229,11 @@ def resolve_rank_choice_duplicate_applications(
             ]
         )
     )
+
     work = (
         work
         .join(component_sizes, on="_rc_component", how="left")
-        .with_columns(
-            pl.col("_rc_component_case").alias("rank_choice_duplicate_case")
-        )
+        .with_columns(pl.col("_rc_component_case").alias("rank_choice_duplicate_case"))
     )
 
     outcome_rank = pl.lit(len(ever_cols))
@@ -255,6 +249,7 @@ def resolve_rank_choice_duplicate_applications(
         if late_col in columns
         else pl.lit(0)
     )
+
     cancel_rank = (
         pl.when(pl.col(cancel_col) == 1)
         .then(2)
@@ -264,6 +259,7 @@ def resolve_rank_choice_duplicate_applications(
         if cancel_col in columns
         else pl.lit(0)
     )
+
     info_count = (
         pl.sum_horizontal([pl.col(c).is_not_null().cast(pl.Int8) for c in info_cols])
         if info_cols
@@ -271,14 +267,17 @@ def resolve_rank_choice_duplicate_applications(
     )
 
     existing_date_tiebreakers = [column for column in date_tiebreakers if column in columns]
+
     sort_cols = [
         "_rc_component",
         "_late_rank",
         "_cancel_rank",
         "_outcome_rank",
+        "_rc_school_count",
         "_info_count",
     ] + existing_date_tiebreakers
-    descending = [False, False, False, False, True] + [
+
+    descending = [False, False, False, False, True, True] + [
         False for _ in existing_date_tiebreakers
     ]
 
@@ -290,6 +289,7 @@ def resolve_rank_choice_duplicate_applications(
     )
 
     untouched = ranked.filter(pl.col("_rc_component_n") == 1)
+
     collapsed = (
         ranked
         .filter(pl.col("_rc_component_n") > 1)
@@ -311,16 +311,6 @@ def resolve_rank_choice_duplicate_applications(
         .agg([pl.col(c).max().alias("_%s_collapsed" % c) for c in ever_cols])
     )
 
-    temp_cols = [
-        "_rc_row_id",
-        "_rc_component",
-        "_rc_component_n",
-        "_rc_component_case",
-        "_late_rank",
-        "_cancel_rank",
-        "_outcome_rank",
-        "_info_count",
-    ]
     collapsed_flag_cols = ["_%s_collapsed" % column for column in ever_cols]
 
     collapsed_resolved = (
@@ -328,9 +318,7 @@ def resolve_rank_choice_duplicate_applications(
         .join(collapsed_flags, on="_rc_component", how="left")
         .with_columns(
             [
-                pl.coalesce(pl.col("_%s_collapsed" % column), pl.col(column)).alias(
-                    column
-                )
+                pl.coalesce(pl.col("_%s_collapsed" % column), pl.col(column)).alias(column)
                 for column in ever_cols
             ]
             + [pl.lit(1, dtype=pl.Int8).alias("former_dupe")]
@@ -339,6 +327,7 @@ def resolve_rank_choice_duplicate_applications(
     )
 
     untouched = untouched.with_columns(pl.lit(0, dtype=pl.Int8).alias("former_dupe"))
+
     output_columns = [
         column for column in columns
         if column not in {"former_dupe", "current_dupe"}
@@ -362,6 +351,7 @@ def resolve_rank_choice_duplicate_applications(
         .group_by(base_keys)
         .agg((pl.len() > 1).cast(pl.Int8).alias("current_dupe"))
     )
+
     result = result.join(current_dupe_flags, on=base_keys, how="left")
 
     final_columns = output_columns + ["current_dupe"]
@@ -371,6 +361,7 @@ def resolve_rank_choice_duplicate_applications(
         (pl.col("rank_choice_duplicate_case").is_in([1, 2, 3]))
         & (pl.col("former_dupe") != 1)
     ).height
+
     assert unresolved_collapsible == 0, (
         "Found %s rows marked as collapsible cases but not collapsed."
         % unresolved_collapsible
@@ -380,6 +371,7 @@ def resolve_rank_choice_duplicate_applications(
         (pl.len().over(base_keys) > 1)
         & (pl.col("current_dupe") != 1)
     ).height
+
     assert current_dupe_errors == 0, (
         "Found %s rows remaining duplicated at base_keys without current_dupe=1."
         % current_dupe_errors
@@ -388,6 +380,8 @@ def resolve_rank_choice_duplicate_applications(
     return result.lazy() if is_lazy else result
 
 
+
+
 # Example call without school specific outcomes
 final = df.pipe(
     resolve_rank_choice_duplicate_applications,