ltc-code 0.1.92__tar.gz → 0.1.93__tar.gz

{ltc_code-0.1.92 → ltc_code-0.1.93}/PKG-INFO

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

{ltc_code-0.1.92 → ltc_code-0.1.93}/pyproject.toml

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

{ltc_code-0.1.92 → ltc_code-0.1.93}/src/ltc_code/june7.py

@@ -413,16 +413,19 @@ final = df.pipe(
 
 
 
+import re
 from typing import Mapping, Optional, Sequence, Union
 
 import polars as pl
 
 
-DEFAULT_PRIORITY_PATTERNS_BY_CMO = {
-    "default": {
-        "flags": {
+PRIORITY_PATTERNS_BY_CMO = {
+    "yes_prep": {
+        # Patterns used to create broad 1/0 priority flags.
+        "concept_patterns": {
             "sibling": [
                 r"\bsibling\s+attending\b",
+                r"\bdynamic\s+sa\b",
             ],
             "staff": [
                 r"\bemployee\b",
@@ -430,46 +433,95 @@ DEFAULT_PRIORITY_PATTERNS_BY_CMO = {
             "zoned": [
                 r"\bisd\b",
                 r"\bzoned\s+for\b",
-                r"\bdynamic\s+sa\b",
             ],
             "transfer": [
-                r"(?:^|\s{2,})transfer(?:\s{2,}|$)",
+                r"\btransfer\b",
             ],
         },
-        "repeat_flags": {
-            "sib_repeat": [
+
+        # Patterns used to flag repeated concepts.
+        # Example: "Sibling Attending - Sibling Attending Ben Holt"
+        # gives sibling_repeat = 1.
+        "repeat_patterns": {
+            "sibling_repeat": [
                 r"\bsibling\s+attending\b",
+                r"\bdynamic\s+sa\b",
             ],
             "zoned_repeat": [
                 r"\bzoned\s+for\b",
             ],
+            "transfer_repeat": [
+                r"\btransfer\b",
+            ],
+        },
+
+        # Patterns used to normalize each dash/plus-separated component.
+        # Anything unmatched is preserved as lowercased text.
+        "component_replacements": {
+            "sibling": [
+                r"\bsibling\s+attending(?:\s+.+)?\b",
+                r"\bdynamic\s+sa\b",
+            ],
+            "staff": [
+                r"\bemployee\b",
+            ],
+            "zoned": [
+                r"\bisd\b",
+                r"\bzoned\s+for\s+.+\b",
+            ],
+            "transfer": [
+                r"\btransfer\b",
+            ],
         },
     },
 
-    # Same as default for now, but this gives you a place to customize later.
-    "yes_prep": {
-        "flags": {
+    "aspire": {
+        "concept_patterns": {
             "sibling": [
                 r"\bsibling\s+attending\b",
+                r"\bmultiples\b",
+                r"\bmutiples\b",
             ],
             "staff": [
                 r"\bemployee\b",
             ],
             "zoned": [
-                r"\bisd\b",
-                r"\bzoned\s+for\b",
-                r"\bdynamic\s+sa\b",
+                r"\bin\s+district\b",
             ],
             "transfer": [
-                r"(?:^|\s{2,})transfer(?:\s{2,}|$)",
+                r"\btransfer\b",
             ],
         },
-        "repeat_flags": {
-            "sib_repeat": [
+
+        "repeat_patterns": {
+            "sibling_repeat": [
                 r"\bsibling\s+attending\b",
+                r"\bmultiples\b",
+                r"\bmutiples\b",
+            ],
+            "transfer_repeat": [
+                r"\btransfer\b",
             ],
             "zoned_repeat": [
-                r"\bzoned\s+for\b",
+                r"\bin\s+district\b",
+            ],
+        },
+
+        "component_replacements": {
+            "sibling": [
+                r"\bsibling\s+attending(?:\s+.+)?\b",
+                r"\bmultiples\b",
+                r"\bmutiples\b",
+            ],
+            "staff": [
+                r"\bemployee\b",
+            ],
+            "zoned": [
+                r"\bin\s+district\b",
+            ],
+            "transfer": [
+                r"\b(?:intra\s+)?aspire\s+transfer(?::?\s+.+)?\b",
+                r"\btransfer(?::?\s+.+)?\b",
             ],
         },
     },
@@ -479,22 +531,11 @@ DEFAULT_PRIORITY_PATTERNS_BY_CMO = {
 def add_priority_flags(
     df: Union[pl.DataFrame, pl.LazyFrame],
     priority_col: str,
-    cmo: str = "default",
+    cmo: str,
     patterns_by_cmo: Optional[Mapping[str, Mapping[str, Mapping[str, Sequence[str]]]]] = None,
+    cleaned_col: str = "priority_group_clean",
 ) -> Union[pl.DataFrame, pl.LazyFrame]:
-    """Create priority flags from a long priority string column.
-
-    Adds:
-        sibling
-        staff
-        zoned
-        transfer
-        sib_repeat
-        zoned_repeat
-
-    The helper lowercases the priority string and normalizes dashes/pluses to
-    spaces before matching regex patterns.
-    """
+    """Create broad priority flags and a normalized priority string."""
     if not isinstance(df, (pl.DataFrame, pl.LazyFrame)):
         raise TypeError("df must be a polars DataFrame or LazyFrame.")
 
@@ -502,7 +543,7 @@ def add_priority_flags(
     if priority_col not in columns:
         raise ValueError("Missing priority column: %s" % priority_col)
 
-    patterns_by_cmo = patterns_by_cmo or DEFAULT_PRIORITY_PATTERNS_BY_CMO
+    patterns_by_cmo = patterns_by_cmo or PRIORITY_PATTERNS_BY_CMO
     if cmo not in patterns_by_cmo:
         raise ValueError(
             "No priority pattern mapping found for cmo=%r. Available CMOs: %s"
@@ -510,56 +551,101 @@ def add_priority_flags(
         )
 
     config = patterns_by_cmo[cmo]
-    flag_patterns = config.get("flags", {})
-    repeat_patterns = config.get("repeat_flags", {})
+    concept_patterns = config.get("concept_patterns", {})
+    repeat_patterns = config.get("repeat_patterns", {})
+    component_replacements = config.get("component_replacements", {})
 
-    def _combined_regex(patterns: Sequence[str]) -> str:
-        return "|".join("(%s)" % pattern for pattern in patterns)
+    def _contains_any(patterns: Sequence[str]) -> pl.Expr:
+        if not patterns:
+            return pl.lit(False)
+        return pl.any_horizontal(
+            [pl.col("_priority_text").str.contains(pattern) for pattern in patterns]
+        )
 
-    def _count_expr(patterns: Sequence[str]) -> pl.Expr:
+    def _count_any(patterns: Sequence[str]) -> pl.Expr:
         if not patterns:
             return pl.lit(0)
         return pl.sum_horizontal(
-            [
-                pl.col("_priority_text").str.count_matches(pattern)
-                for pattern in patterns
-            ]
+            [pl.col("_priority_text").str.count_matches(pattern) for pattern in patterns]
         )
 
+    def _clean_component(value: object) -> Optional[str]:
+        if value is None:
+            return None
+
+        text = str(value).strip().lower()
+        if not text:
+            return None
+
+        text = re.sub(r"\s+", " ", text)
+
+        for clean_label, patterns in component_replacements.items():
+            for pattern in patterns:
+                if re.search(pattern, text):
+                    return clean_label
+
+        return text
+
+    def _normalize_priority(value: object) -> Optional[str]:
+        if value is None:
+            return None
+
+        text = str(value).lower()
+        text = re.sub(r"[-+]", "|", text)
+        raw_parts = [part.strip() for part in text.split("|")]
+
+        cleaned_parts = []
+        seen = set()
+        for part in raw_parts:
+            cleaned = _clean_component(part)
+            if cleaned is None or cleaned in seen:
+                continue
+            cleaned_parts.append(cleaned)
+            seen.add(cleaned)
+
+        if not cleaned_parts:
+            return None
+
+        return " - ".join(sorted(cleaned_parts))
+
     result = df.with_columns(
         pl.col(priority_col)
         .cast(pl.Utf8, strict=False)
         .fill_null("")
         .str.to_lowercase()
-        .str.replace_all(r"[-+]", " ")
         .alias("_priority_text")
     )
 
     result = result.with_columns(
         [
-            pl.col("_priority_text")
-            .str.contains(_combined_regex(patterns))
-            .cast(pl.Int8)
-            .alias(flag_name)
-            for flag_name, patterns in flag_patterns.items()
+            _contains_any(patterns).cast(pl.Int8).alias(flag_name)
+            for flag_name, patterns in concept_patterns.items()
         ]
     )
 
     result = result.with_columns(
         [
-            (_count_expr(patterns) > 1)
-            .cast(pl.Int8)
-            .alias(flag_name)
+            (_count_any(patterns) > 1).cast(pl.Int8).alias(flag_name)
             for flag_name, patterns in repeat_patterns.items()
         ]
     )
 
-    return result.drop("_priority_text")
+    result = result.with_columns(
+        pl.col(priority_col)
+        .map_elements(_normalize_priority, return_dtype=pl.Utf8)
+        .alias(cleaned_col)
+    )
 
+    return result.drop("_priority_text")
 
 
 df = df.pipe(
     add_priority_flags,
     priority_col="priority_group_name",
     cmo="yes_prep",
+)
+df = df.pipe(
+    add_priority_flags,
+    priority_col="priority_group_name",
+    cmo="aspire",
 )