wxcli 1.2.0__py3-none-any.whl

wxcli/migration/transform/cucm_pattern.py

@@ -0,0 +1,246 @@
+"""CUCM digit pattern compiler and overlap detection.
+
+Compiles CUCM route pattern strings into Python regexes and detects
+whether two patterns can match the same digit string. Used by css_mapper
+for ordering conflict detection.
+
+CUCM pattern symbols (from 04-css-decomposition.md):
+    X   — single digit 0-9
+    !   — one or more digits (greedy wildcard)
+    [n-m] — digit range
+    [^n] — negated digit
+    @   — national numbering plan macro (country-specific)
+    .   — separator (between access code and pattern)
+    +   — E.164 prefix (literal)
+"""
+
+from __future__ import annotations
+
+import random
+import re
+
+
+# ---------------------------------------------------------------------------
+# @ macro expansion — intentionally broad for overlap detection safety.
+# Real CUCM '@' expands to the loaded National Numbering Plan file, which
+# varies by cluster/country. This catch-all never produces false negatives
+# in overlap detection (it over-matches, so overlapping patterns are always
+# detected). generate_representative_strings compensates by producing
+# US-format 10-digit numbers for '@' patterns.
+# CUCM @ pattern matches "any dialed number" — exact expansion varies by
+# cluster/country dial plan. [0-9]{1,15} is a conservative over-match that
+# never produces false negatives in overlap detection. Safe approximation.
+# ---------------------------------------------------------------------------
+_AT_MACRO_REGEX = "[0-9]{1,15}"
+
+
+def cucm_pattern_to_regex(pattern: str) -> str:
+    """Convert a CUCM digit pattern to a Python regex string.
+
+    X → [0-9], ! → [0-9]+, [1-4] → [1-4], [^5] → [^5]
+    . → '' (stripped — separator only), + → \\+, @ → expanded
+
+    (from 03b-transform-mappers.md, cucm_pattern.py interface)
+    """
+    if not pattern or pattern.strip() == "" or pattern == ".":
+        raise ValueError(f"Empty or invalid CUCM pattern: {pattern!r}")
+
+    # Split on first '.' only — it's the access code separator
+    # (from 04-css-decomposition.md: '.' separates access code from pattern)
+    parts = pattern.split(".", 1)
+    if len(parts) == 2:
+        access_code, digit_pattern = parts[0], parts[1]
+    else:
+        access_code, digit_pattern = "", parts[0]
+
+    # Convert the access code (literal digits, + prefix)
+    regex = _convert_segment(access_code)
+    # Convert the digit pattern
+    regex += _convert_segment(digit_pattern)
+
+    return regex
+
+
+def _convert_segment(segment: str) -> str:
+    """Convert a CUCM pattern segment to regex."""
+    result = []
+    i = 0
+    while i < len(segment):
+        ch = segment[i]
+        if ch == "X":
+            result.append("[0-9]")
+        elif ch == "!":
+            result.append("[0-9]+")
+        elif ch == "@":
+            result.append(_AT_MACRO_REGEX)
+        elif ch == "+":
+            result.append("\\+")
+        elif ch == "[":
+            # Pass through bracket expressions (ranges and negation)
+            try:
+                end = segment.index("]", i)
+            except ValueError:
+                raise ValueError(f"Unclosed bracket in CUCM pattern segment: {segment!r}")
+            result.append(segment[i : end + 1])
+            i = end
+        elif ch.isdigit():
+            result.append(ch)
+        # Skip any other character (shouldn't normally appear)
+        i += 1
+    return "".join(result)
+
+
+def compile_cucm_pattern(pattern: str) -> re.Pattern:
+    """Compile a CUCM digit pattern into a Python regex Pattern object.
+
+    (from phase-02-risk-spikes.md: compile_cucm_pattern(pattern: str) -> re.Pattern)
+    """
+    regex_str = cucm_pattern_to_regex(pattern)
+    return re.compile(f"^{regex_str}$")
+
+
+def generate_representative_strings(pattern: str, count: int = 10) -> list[str]:
+    """Generate digit strings that match a CUCM pattern.
+
+    Uses random generation to produce representative strings for overlap testing.
+    For patterns with '!' (unbounded length), generates strings at representative
+    lengths (5, 7, 10, 11, 15 digits for the '!' portion).
+    (from 04-css-decomposition.md: enumeration approach #2)
+    """
+    if not pattern or pattern.strip() == "" or pattern == ".":
+        raise ValueError(f"Empty or invalid CUCM pattern: {pattern!r}")
+
+    # Split on first '.' — access code separator
+    parts = pattern.split(".", 1)
+    if len(parts) == 2:
+        access_code, digit_pattern = parts[0], parts[1]
+    else:
+        access_code, digit_pattern = "", parts[0]
+
+    compiled = compile_cucm_pattern(pattern)
+    results = []
+
+    for _ in range(count * 5):  # oversample to hit count
+        s = _generate_one(access_code) + _generate_one(digit_pattern)
+        if compiled.fullmatch(s):
+            results.append(s)
+        if len(results) >= count:
+            break
+
+    # Deduplicate but respect count
+    if len(results) < count:
+        # For exact patterns there's only one string
+        unique = list(dict.fromkeys(results))
+        # Pad with duplicates if needed
+        while len(results) < count and unique:
+            results.append(unique[0])
+
+    return results[:count]
+
+
+def _generate_one(segment: str) -> str:
+    """Generate one random digit string matching a CUCM pattern segment."""
+    result = []
+    i = 0
+    while i < len(segment):
+        ch = segment[i]
+        if ch == "X":
+            result.append(str(random.randint(0, 9)))
+        elif ch == "!":
+            # Generate at representative lengths for the '!' portion
+            bang_len = random.choice([1, 2, 4, 7, 10])
+            result.append("".join(str(random.randint(0, 9)) for _ in range(bang_len)))
+        elif ch == "@":
+            # US national plan: generate 10-digit number
+            result.append(
+                str(random.randint(2, 9))
+                + "".join(str(random.randint(0, 9)) for _ in range(9))
+            )
+        elif ch == "+":
+            result.append("+")
+        elif ch == "[":
+            try:
+                end = segment.index("]", i)
+            except ValueError:
+                raise ValueError(f"Unclosed bracket in CUCM pattern segment: {segment!r}")
+            bracket_content = segment[i + 1 : end]
+            digit = _random_from_bracket(bracket_content)
+            result.append(digit)
+            i = end
+        elif ch.isdigit():
+            result.append(ch)
+        i += 1
+    return "".join(result)
+
+
+def _random_from_bracket(content: str) -> str:
+    """Pick a random digit matching a bracket expression like '2-9' or '^0'."""
+    negated = content.startswith("^")
+    if negated:
+        content = content[1:]
+
+    # Build set of allowed digits
+    allowed = set()
+    i = 0
+    while i < len(content):
+        if i + 2 < len(content) and content[i + 1] == "-":
+            start, end = int(content[i]), int(content[i + 2])
+            allowed.update(range(start, end + 1))
+            i += 3
+        else:
+            allowed.add(int(content[i]))
+            i += 1
+
+    if negated:
+        allowed = set(range(10)) - allowed
+
+    if not allowed:
+        return "0"
+    return str(random.choice(sorted(allowed)))
+
+
+def cucm_patterns_overlap(pattern_a: str, pattern_b: str) -> bool:
+    """Return True if two CUCM patterns can match any common digit string.
+
+    Uses enumeration approach: generate representative digit strings from each
+    pattern's match space and test against the other. Tests at representative
+    lengths (4, 7, 10, 11, 15 digits) for patterns involving !.
+    (from 04-css-decomposition.md, overlap detection via enumeration)
+    (from 03b-transform-mappers.md, cucm_pattern.py interface)
+    """
+    compiled_a = compile_cucm_pattern(pattern_a)
+    compiled_b = compile_cucm_pattern(pattern_b)
+
+    # Generate samples from A, test against B
+    samples_a = generate_representative_strings(pattern_a, count=50)
+    for s in samples_a:
+        if compiled_b.fullmatch(s):
+            return True
+
+    # Generate samples from B, test against A
+    samples_b = generate_representative_strings(pattern_b, count=50)
+    for s in samples_b:
+        if compiled_a.fullmatch(s):
+            return True
+
+    return False
+
+
+def classify_block_pattern(
+    pattern: str,
+    category_rules: list[dict],
+) -> str | None:
+    """Classify a CUCM blocking pattern into a Webex permission category.
+
+    Returns category string (e.g., 'international', 'premium') or None if
+    unclassifiable. Uses configurable rules from migration config.
+    (from 03b-transform-mappers.md, cucm_pattern.py interface)
+
+    A rule matches if the blocking pattern is identical to the rule's pattern
+    (exact string match). For more sophisticated matching (e.g., pattern
+    subsumption), extend this function.
+    """
+    for rule in category_rules:
+        if rule["cucm_pattern"] == pattern:
+            return rule["webex_category"]
+    return None

wxcli/migration/transform/decisions.py

@@ -0,0 +1,301 @@
+"""Decision model helpers for querying, summarizing, and formatting decisions.
+
+Complements the Mapper._fingerprint() method with higher-level helpers
+for CLI reporting and programmatic queries.
+
+(from 03b-transform-mappers.md, shared patterns)
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+from wxcli.migration.store import MigrationStore
+
+
+def summarize_decisions(decisions: list[dict[str, Any]]) -> dict[str, dict[str, int]]:
+    """Group decisions by type and severity.
+
+    Returns a nested dict: {type: {severity: count}}.
+
+    Args:
+        decisions: list of decision dicts (from store.get_all_decisions() or similar).
+
+    Example return::
+
+        {
+            "DEVICE_INCOMPATIBLE": {"HIGH": 3, "MEDIUM": 1},
+            "MISSING_DATA": {"MEDIUM": 5, "LOW": 2},
+        }
+    """
+    summary: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    for dec in decisions:
+        dec_type = dec.get("type", "UNKNOWN")
+        severity = dec.get("severity", "UNKNOWN")
+        summary[dec_type][severity] += 1
+    # Convert defaultdicts to regular dicts for clean serialization
+    return {k: dict(v) for k, v in summary.items()}
+
+
+def format_decision_report(decisions: list[dict[str, Any]]) -> str:
+    """Human-readable decision summary for CLI output.
+
+    Produces a compact multi-line report grouped by type with counts
+    and resolution status.
+
+    Args:
+        decisions: list of decision dicts.
+
+    Returns:
+        Multi-line string suitable for console display.
+    """
+    if not decisions:
+        return "No decisions to report."
+
+    summary = summarize_decisions(decisions)
+
+    # Count resolved vs pending
+    total = len(decisions)
+    resolved = sum(1 for d in decisions if d.get("chosen_option") is not None)
+    pending = total - resolved
+
+    lines: list[str] = [
+        f"Decision Report: {total} total ({resolved} resolved, {pending} pending)",
+        "-" * 60,
+    ]
+
+    # Sort types by total count descending
+    type_totals = {
+        dec_type: sum(sev_counts.values())
+        for dec_type, sev_counts in summary.items()
+    }
+    for dec_type in sorted(type_totals, key=type_totals.get, reverse=True):  # type: ignore[arg-type]
+        sev_counts = summary[dec_type]
+        sev_parts = ", ".join(
+            f"{sev}: {count}" for sev, count in sorted(sev_counts.items())
+        )
+        lines.append(f"  {dec_type}: {type_totals[dec_type]} ({sev_parts})")
+
+    # Pending breakdown
+    if pending > 0:
+        lines.append("")
+        lines.append(f"Pending decisions requiring resolution: {pending}")
+        pending_by_severity: dict[str, int] = defaultdict(int)
+        for d in decisions:
+            if d.get("chosen_option") is None:
+                pending_by_severity[d.get("severity", "UNKNOWN")] += 1
+        for sev in ("CRITICAL", "HIGH", "MEDIUM", "LOW"):
+            count = pending_by_severity.get(sev, 0)
+            if count:
+                lines.append(f"    {sev}: {count}")
+
+    return "\n".join(lines)
+
+
+def decisions_by_type(
+    store: MigrationStore, decision_type: str
+) -> list[dict[str, Any]]:
+    """Query all decisions of a given type from the store.
+
+    Args:
+        store: MigrationStore instance.
+        decision_type: DecisionType value string (e.g., "DEVICE_INCOMPATIBLE").
+
+    Returns:
+        List of decision dicts matching the given type.
+    """
+    all_decisions = store.get_all_decisions()
+    return [d for d in all_decisions if d.get("type") == decision_type]
+
+
+def pending_decisions(store: MigrationStore) -> list[dict[str, Any]]:
+    """Query all unresolved decisions from the store.
+
+    Returns:
+        List of decision dicts where chosen_option is None.
+    """
+    all_decisions = store.get_all_decisions()
+    return [d for d in all_decisions if d.get("chosen_option") is None]
+
+
+def resolved_decisions(store: MigrationStore) -> list[dict[str, Any]]:
+    """Query all resolved decisions from the store.
+
+    Returns:
+        List of decision dicts where chosen_option is not None.
+    """
+    all_decisions = store.get_all_decisions()
+    return [d for d in all_decisions if d.get("chosen_option") is not None]
+
+
+# ---------------------------------------------------------------------------
+# Auto-apply / needs-input classification
+# ---------------------------------------------------------------------------
+
+def classify_decisions(
+    store: MigrationStore,
+    config: dict[str, Any],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """Split pending decisions into auto-apply and needs-input groups.
+
+    Auto-apply = pending decisions that the project's ``config["auto_rules"]``
+    would resolve. Each item is augmented with ``auto_choice`` and
+    ``auto_reason`` keys (from ``preview_auto_rules``).
+
+    Needs-input = pending decisions that no rule matches.
+
+    Both groups exclude already-resolved decisions and ``__stale__``
+    decisions.
+    """
+    from wxcli.migration.transform.rules import preview_auto_rules
+
+    auto_apply = preview_auto_rules(store, config)
+    auto_apply_ids = {d["decision_id"] for d in auto_apply}
+
+    all_decisions = store.get_all_decisions()
+    needs_input = [
+        d for d in all_decisions
+        if d.get("chosen_option") is None
+        and d["decision_id"] not in auto_apply_ids
+    ]
+
+    return auto_apply, needs_input
+
+
+# ---------------------------------------------------------------------------
+# Decision review export (markdown)
+# ---------------------------------------------------------------------------
+
+# Group labels for the needs-input section
+_DECISION_CATEGORY: dict[str, str] = {
+    "LOCATION_AMBIGUOUS": "Location",
+    "DEVICE_FIRMWARE_CONVERTIBLE": "Device",
+    "DEVICE_INCOMPATIBLE": "Device",
+    "WORKSPACE_LICENSE_TIER": "Workspace",
+    "WORKSPACE_TYPE_UNCERTAIN": "Workspace",
+    "HOTDESK_DN_CONFLICT": "Workspace",
+    "EXTENSION_CONFLICT": "User",
+    "DN_AMBIGUOUS": "User",
+    "DUPLICATE_USER": "User",
+    "SHARED_LINE_COMPLEX": "User",
+    "MISSING_DATA": "Data Quality",
+    "CSS_ROUTING_MISMATCH": "Routing",
+    "CALLING_PERMISSION_MISMATCH": "Permissions",
+    "VOICEMAIL_INCOMPATIBLE": "Voicemail",
+    "FEATURE_APPROXIMATION": "Feature",
+    "NUMBER_CONFLICT": "Number",
+}
+
+
+def generate_decision_review(
+    store: MigrationStore,
+    project_id: str,
+    config: dict[str, Any],
+) -> str:
+    """Generate a markdown decision review file with auto-apply and needs-input sections."""
+    auto_apply, needs_input = classify_decisions(store, config)
+
+    lines: list[str] = []
+    lines.append(f"# Migration Decision Review — {project_id}")
+    lines.append(f"Generated: {_now_date()}")
+    lines.append("")
+
+    # --- Section 1: Auto-apply ---
+    lines.append(f"## Auto-Apply ({len(auto_apply)} decisions)")
+    lines.append("")
+    if auto_apply:
+        lines.append("These have only one sensible resolution and will be applied when you run")
+        lines.append("`wxcli cucm decide --apply-auto`. Review and raise any concerns before applying.")
+        lines.append("")
+        lines.append("| ID | Type | Object | Resolution | Reason |")
+        lines.append("|----|------|--------|------------|--------|")
+        for d in auto_apply:
+            did = d.get("decision_id", "")
+            dtype = d.get("type", "")
+            obj_name = _object_name(d)
+            choice = d.get("auto_choice", "")
+            reason = d.get("auto_reason", "")
+            lines.append(f"| {did} | {dtype} | {obj_name} | {choice} | {reason} |")
+    else:
+        lines.append("No auto-apply decisions.")
+    lines.append("")
+
+    # --- Section 2: Needs input ---
+    lines.append(f"## Needs Your Input ({len(needs_input)} decisions)")
+    lines.append("")
+    if needs_input:
+        lines.append("Each decision requires admin judgment. Options are listed — discuss with")
+        lines.append("your migration team if needed. Resolve via `wxcli cucm decide <ID> <choice>`")
+        lines.append("or tell the migration agent your choices.")
+        lines.append("")
+
+        # Group by category
+        grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for d in needs_input:
+            cat = _DECISION_CATEGORY.get(d.get("type", ""), "Other")
+            grouped[cat].append(d)
+
+        for category in sorted(grouped.keys()):
+            decs = grouped[category]
+            lines.append(f"### {category} Decisions ({len(decs)})")
+            lines.append("")
+            lines.append("| ID | Severity | Summary | Options |")
+            lines.append("|----|----------|---------|---------|")
+            for d in decs:
+                did = d.get("decision_id", "")
+                sev = d.get("severity", "")
+                summary = d.get("summary", "").replace("|", "/")
+                opts = _format_options_short(d.get("options", []))
+                lines.append(f"| {did} | {sev} | {summary} | {opts} |")
+
+            # Detail section: show context for each decision
+            lines.append("")
+            for d in decs:
+                did = d.get("decision_id", "")
+                lines.append(f"**{did}** — {d.get('summary', '')}")
+                lines.append("")
+                for i, opt in enumerate(d.get("options", [])):
+                    letter = chr(ord("a") + i)
+                    opt_id = opt.get("id", "") if isinstance(opt, dict) else str(opt)
+                    label = opt.get("label", opt_id) if isinstance(opt, dict) else str(opt)
+                    impact = opt.get("impact", "") if isinstance(opt, dict) else ""
+                    lines.append(f"  {letter}) **{label}** (`{opt_id}`) — {impact}")
+                lines.append("")
+    else:
+        lines.append("No decisions require input — all are auto-apply.")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def _object_name(decision: dict[str, Any]) -> str:
+    """Extract a readable object name from a decision's context or affected_objects."""
+    ctx = decision.get("context", {})
+    for key in ("device_name", "name", "canonical_id", "object_name"):
+        val = ctx.get(key)
+        if val:
+            return str(val)
+    affected = ctx.get("_affected_objects", [])
+    if affected:
+        return str(affected[0])
+    return "unknown"
+
+
+def _format_options_short(options: list) -> str:
+    """Format options as a compact lettered list for table cells."""
+    parts = []
+    for i, opt in enumerate(options):
+        letter = chr(ord("a") + i)
+        if isinstance(opt, dict):
+            opt_id = opt.get("id", "")
+            label = opt.get("label", opt_id)
+        else:
+            label = str(opt)
+        parts.append(f"**{letter}**) {label}")
+    return " ".join(parts)
+
+
+def _now_date() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")

wxcli/migration/transform/e164.py

@@ -0,0 +1,145 @@
+"""E.164 normalization for CUCM Directory Numbers.
+
+Classifies DNs as EXTENSION / NATIONAL / E164 / AMBIGUOUS and normalizes
+to E.164 format using Google's phonenumbers library (libphonenumber).
+
+Used by line_mapper during normalization pass 2 to produce CanonicalLine
+objects with both bare extension and E.164 phone number fields.
+
+(from 02-normalization-architecture.md, E.164 normalization section)
+(from 03b-transform-mappers.md, line_mapper E.164 normalization algorithm)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import phonenumbers
+
+
+@dataclass
+class E164Result:
+    """Result of E.164 normalization for a single DN.
+
+    Fields match what line_mapper in 03b-transform-mappers.md expects:
+    - e164: normalized E.164 string (e.g., "+14155551234") or None
+    - extension: bare extension digits (e.g., "1001") or None
+    - raw: the original input DN string
+    - classification: one of EXTENSION, NATIONAL, E164, AMBIGUOUS
+    """
+
+    e164: str | None
+    extension: str | None
+    raw: str
+    classification: str  # EXTENSION | NATIONAL | E164 | AMBIGUOUS
+
+
+# Maximum digits for a DN to be classified as an extension.
+# (from 02-normalization-architecture.md: "if len(stripped) <= 6")
+# Extended to handle CUCM extensions up to 10 digits, but phonenumbers
+# is tried first — only numbers that fail phonenumbers parsing fall back
+# to extension classification.
+_MAX_EXTENSION_DIGITS = 6
+
+
+def apply_prefix_rules(dn: str, rules: list[dict]) -> str:
+    """Strip a site-specific prefix from a DN.
+
+    Rules are applied in order; the first matching rule is used.
+    Each rule is a dict with "prefix" (str) and optionally "description".
+
+    (from 02-normalization-architecture.md: "Step 1: Strip site prefix")
+    (from 03b-transform-mappers.md, line_mapper field table: site prefix rules)
+    """
+    for rule in rules:
+        prefix = rule["prefix"]
+        if dn.startswith(prefix) and len(dn) > len(prefix):
+            return dn[len(prefix) :]
+    return dn
+
+
+def normalize_dn(
+    dn: str,
+    country_code: str,
+    site_prefix_rules: list[dict],
+) -> E164Result:
+    """Normalize a CUCM DN to E.164 using libphonenumber.
+
+    (from 02-normalization-architecture.md, normalize_dn function)
+    (from 03b-transform-mappers.md, line_mapper E.164 normalization algorithm)
+
+    Args:
+        dn: Raw directory number string from CUCM.
+        country_code: ISO 3166-1 alpha-2 code (e.g., "US", "GB", "DE").
+            Comes from the DN's resolved location.
+        site_prefix_rules: List of prefix stripping rules from migration config.
+
+    Returns:
+        E164Result with classification and normalized values.
+        Invalid numbers produce AMBIGUOUS, never exceptions.
+    """
+    # Guard: empty or whitespace-only DN
+    if not dn or not dn.strip():
+        return E164Result(
+            e164=None,
+            extension=None,
+            raw=dn or "",
+            classification="AMBIGUOUS",
+        )
+
+    # Guard: non-digit characters that aren't '+' indicate special codes
+    if not dn[0].isdigit() and dn[0] != "+":
+        return E164Result(
+            e164=None,
+            extension=None,
+            raw=dn,
+            classification="AMBIGUOUS",
+        )
+
+    # Step 1: Strip site prefix (from 02-normalization-architecture.md)
+    stripped = apply_prefix_rules(dn, site_prefix_rules)
+
+    # Step 2: Try to parse as a phone number using phonenumbers
+    # (from 02-normalization-architecture.md: phonenumbers library usage)
+    try:
+        parsed = phonenumbers.parse(stripped, country_code)
+        if phonenumbers.is_valid_number(parsed):
+            e164 = phonenumbers.format_number(
+                parsed, phonenumbers.PhoneNumberFormat.E164
+            )
+            # Classify: already had '+' → E164, otherwise NATIONAL.
+            # Design doc (02-normalization-architecture.md:162) uses
+            # len(stripped) <= 10 heuristic; we use '+' prefix detection
+            # instead, which is more accurate for 11-digit national numbers
+            # like "14155551234" that shouldn't be classified as E164.
+            if stripped.startswith("+"):
+                classification = "E164"
+            else:
+                classification = "NATIONAL"
+            return E164Result(
+                e164=e164,
+                extension=None,
+                raw=dn,
+                classification=classification,
+            )
+    except phonenumbers.NumberParseException:
+        pass
+
+    # Step 3: Short number = extension
+    # (from 02-normalization-architecture.md: "if len(stripped) <= 6")
+    digits_only = stripped.replace("+", "")
+    if digits_only.isdigit() and len(digits_only) <= _MAX_EXTENSION_DIGITS:
+        return E164Result(
+            e164=None,
+            extension=stripped,
+            raw=dn,
+            classification="EXTENSION",
+        )
+
+    # Step 4: Can't classify
+    return E164Result(
+        e164=None,
+        extension=None,
+        raw=dn,
+        classification="AMBIGUOUS",
+    )