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

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

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

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

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

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

@@ -403,4 +403,249 @@ final = df.pipe(
         "waitlist": "waitlist_school",
         "withdraw": "withdraw_school",
     },
+)
+
+
+
+
+
+
+
+
+
+import re
+from typing import Mapping, Optional, Sequence, Union
+
+import polars as pl
+
+
+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",
+            ],
+            "zoned": [
+                r"\bisd\b",
+                r"\bzoned\s+for\b",
+            ],
+            "transfer": [
+                r"\btransfer\b",
+            ],
+        },
+
+        # 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",
+            ],
+        },
+    },
+
+    "aspire": {
+        "concept_patterns": {
+            "sibling": [
+                r"\bsibling\s+attending\b",
+                r"\bmultiples\b",
+                r"\bmutiples\b",
+            ],
+            "staff": [
+                r"\bemployee\b",
+            ],
+            "zoned": [
+                r"\bin\s+district\b",
+            ],
+            "transfer": [
+                r"\btransfer\b",
+            ],
+        },
+
+        "repeat_patterns": {
+            "sibling_repeat": [
+                r"\bsibling\s+attending\b",
+                r"\bmultiples\b",
+                r"\bmutiples\b",
+            ],
+            "transfer_repeat": [
+                r"\btransfer\b",
+            ],
+            "zoned_repeat": [
+                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",
+            ],
+        },
+    },
+}
+
+
+def add_priority_flags(
+    df: Union[pl.DataFrame, pl.LazyFrame],
+    priority_col: str,
+    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 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.")
+
+    columns = df.collect_schema().names() if isinstance(df, pl.LazyFrame) else df.columns
+    if priority_col not in columns:
+        raise ValueError("Missing priority column: %s" % priority_col)
+
+    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"
+            % (cmo, sorted(patterns_by_cmo))
+        )
+
+    config = patterns_by_cmo[cmo]
+    concept_patterns = config.get("concept_patterns", {})
+    repeat_patterns = config.get("repeat_patterns", {})
+    component_replacements = config.get("component_replacements", {})
+
+    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_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]
+        )
+
+    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()
+        .alias("_priority_text")
+    )
+
+    result = result.with_columns(
+        [
+            _contains_any(patterns).cast(pl.Int8).alias(flag_name)
+            for flag_name, patterns in concept_patterns.items()
+        ]
+    )
+
+    result = result.with_columns(
+        [
+            (_count_any(patterns) > 1).cast(pl.Int8).alias(flag_name)
+            for flag_name, patterns in repeat_patterns.items()
+        ]
+    )
+
+    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",
 )