parseforge 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

parseforge/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.1"
+__version__ = "0.2.2"

parseforge/cli/main.py

@@ -6,6 +6,22 @@ import click
 
 from parseforge import naming
 
+_BUILDERS: dict[str, type[naming.RegexBuilder]] = {
+    "anthropic": naming.AnthropicRegexBuilder,
+    "deepseek": naming.DeepSeekRegexBuilder,
+}
+
+
+def _build_regex_builder(
+    provider: str, api_key: str | None, model: str | None
+) -> naming.RegexBuilder:
+    kwargs: dict[str, str] = {}
+    if api_key is not None:
+        kwargs["api_key"] = api_key
+    if model is not None:
+        kwargs["model"] = model
+    return _BUILDERS[provider](**kwargs)
+
 
 @click.group()
 @click.version_option(package_name="parseforge")
@@ -18,19 +34,42 @@ def main() -> None:
 @click.option("--family", required=True)
 @click.option("--os", "os_", required=True)
 @click.option("--version", required=True)
+@click.option(
+    "--provider",
+    type=click.Choice(sorted(_BUILDERS)),
+    default="anthropic",
+    show_default=True,
+)
+@click.option(
+    "--api-key",
+    default=None,
+    help="Provider API key. Defaults to that provider's own API key environment "
+    "variable (ANTHROPIC_API_KEY, DEEPSEEK_API_KEY); only needed on a cache miss.",
+)
+@click.option(
+    "--model",
+    default=None,
+    help="Defaults to the selected provider's own default model.",
+)
 @click.argument("command", nargs=-1, required=True)
 def name_cmd(
-    vendor: str, family: str, os_: str, version: str, command: tuple[str, ...]
+    vendor: str,
+    family: str,
+    os_: str,
+    version: str,
+    provider: str,
+    api_key: str | None,
+    model: str | None,
+    command: tuple[str, ...],
 ) -> None:
     """Print the canonical cli-name for a raw CLI COMMAND.
 
-    Looked up in the local cache first; only sent to an LLM (via a
-    RegexBuilder) on a cache miss. No RegexBuilder is wired into the
-    scaffold yet, so this only succeeds for commands already in
-    ~/.parseforge/.cli-name.json until one is implemented.
+    Looked up in the local cache first; only sent to the selected --provider
+    on a cache miss.
     """
     context = naming.CliContext(vendor=vendor, family=family, os=os_, version=version)
-    click.echo(naming.cli_name(" ".join(command), context))
+    builder = _build_regex_builder(provider, api_key, model)
+    click.echo(naming.cli_name(" ".join(command), context, builder=builder))
 
 
 @main.command("run")
@@ -38,17 +77,125 @@ def name_cmd(
 @click.option("--family", required=True)
 @click.option("--os", "os_", required=True)
 @click.option("--version", required=True)
+@click.option("--host", required=True, help="Device host/IP to sample from.")
+@click.option("--username", required=True)
+@click.option(
+    "--password",
+    required=True,
+    envvar="PARSEFORGE_DEVICE_PASSWORD",
+    help="Device password. Defaults to the PARSEFORGE_DEVICE_PASSWORD "
+    "environment variable.",
+)
+@click.option(
+    "--device-type",
+    required=True,
+    help='Netmiko device_type, e.g. "cisco_ios".',
+)
+@click.option(
+    "--naming-provider",
+    type=click.Choice(sorted(_BUILDERS)),
+    default="anthropic",
+    show_default=True,
+)
+@click.option(
+    "--naming-api-key",
+    default=None,
+    help="API key for the naming LLM call. Defaults to that provider's own "
+    "API key environment variable; only needed on a cache miss.",
+)
+@click.option(
+    "--naming-model",
+    default=None,
+    help="Defaults to the naming provider's own default model.",
+)
+@click.option(
+    "--generation-provider",
+    required=True,
+    help="LLM provider for template generation (textfsm-ai's own registry, "
+    'e.g. "anthropic", "deepseek").',
+)
+@click.option(
+    "--generation-api-key",
+    required=True,
+    help="API key for the template-generation LLM call.",
+)
+@click.option(
+    "--generation-model",
+    required=True,
+    help="Model for the template-generation LLM call.",
+)
+@click.option(
+    "--store-root",
+    default=None,
+    help="Root directory for trial output. Defaults to ~/.parseforge/tests.",
+)
+@click.option("--project", default=None)
+@click.option("--email", default=None)
+@click.option("--description", default=None)
 @click.argument("command", nargs=-1, required=True)
 def run_cmd(
-    vendor: str, family: str, os_: str, version: str, command: tuple[str, ...]
+    vendor: str,
+    family: str,
+    os_: str,
+    version: str,
+    host: str,
+    username: str,
+    password: str,
+    device_type: str,
+    naming_provider: str,
+    naming_api_key: str | None,
+    naming_model: str | None,
+    generation_provider: str,
+    generation_api_key: str,
+    generation_model: str,
+    store_root: str | None,
+    project: str | None,
+    email: str | None,
+    description: str | None,
+    command: tuple[str, ...],
 ) -> None:
-    """Run the pipeline for a single CLI COMMAND against a device (§5)."""
-    from parseforge.pipeline import run_command_pipeline
+    """Run a single trial: sample COMMAND from a device, generate a
+    TextFSM template for it, and write the result under a trial
+    directory (SPEC.md §5 steps 1-7)."""
+    from pathlib import Path
+
+    from parseforge import paths
+    from parseforge.pipeline import (
+        LLMProviderConfig,
+        TrialMetadata,
+        run_command_pipeline,
+    )
+    from parseforge.sampling import DeviceConnection
+    from parseforge.sampling.backends import NetmikoSampler
+
+    context = naming.CliContext(vendor=vendor, family=family, os=os_, version=version)
+    connection = DeviceConnection(
+        host=host, username=username, password=password, device_type=device_type
+    )
+    naming_builder = _build_regex_builder(naming_provider, naming_api_key, naming_model)
+    generation_config = LLMProviderConfig(
+        provider=generation_provider, api_key=generation_api_key, model=generation_model
+    )
+    metadata = TrialMetadata(
+        project=project,
+        username=username,
+        email=email,
+        description=description,
+    )
 
-    run_command_pipeline(
+    result = run_command_pipeline(
         " ".join(command),
-        key_fields={"vendor": vendor, "family": family, "os": os_, "version": version},
+        context,
+        connection,
+        naming_builder,
+        NetmikoSampler(),
+        generation_config,
+        store_root=Path(store_root) if store_root else paths.DEFAULT_STORE_ROOT,
+        metadata=metadata,
     )
+    click.echo(f"cli_name : {result.cli_name}")
+    click.echo(f"passed   : {result.passed}")
+    click.echo(f"run_dir  : {result.run_dir}")
 
 
 if __name__ == "__main__":

parseforge/generation.py

@@ -1,40 +1,112 @@
-"""Generation stage — LLM call and template extraction (SPEC.md §5 steps 5-6).
+"""Generation stage — LLM call, extraction, cleanup, and DSL compile
+(SPEC.md §5 steps 5-6), delegated to textfsm-ai's delivery pipeline
+rather than reimplemented here.
 
-Writes raw-llm-response.txt / usage.txt (step 5), then extracts and
-cleans the template into raw-template / template.textfsm (step 6).
+textfsm-ai's run_pipeline() already covers extraction + cleanup + DSL
+compilation (canonical template, readable DSL, recognizers) in one
+call — see https://github.com/Geeks-Trident-LLC/textfsm-ai. Always run
+in debug mode with JSON output, for full usage/timing/pipeline detail
+(see GenerationResult.raw).
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Protocol
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+from textfsm_ai import run_pipeline
+
+_SENSITIVE_KEYS = {"api_key"}
+
+
+def _redact(value: Any) -> Any:
+    """Strip credential-shaped fields from a parsed debug payload.
+
+    textfsm-ai's Serializable.to_dict()/to_json() run plain
+    dataclasses.asdict() — masking (mask_middle()) only happens in its
+    *text*-mode output, not JSON. Debug mode's JSON embeds the raw API
+    key unmasked, so it must be stripped before this result is stored
+    or logged anywhere.
+    """
+    if isinstance(value, dict):
+        return {
+            k: "<redacted>" if k in _SENSITIVE_KEYS else _redact(v)
+            for k, v in value.items()
+        }
+    if isinstance(value, list):
+        return [_redact(v) for v in value]
+    return value
+
+
+@dataclass(frozen=True)
+class TokenUsage:
+    input_tokens: int
+    output_tokens: int
+    total_tokens: int
+    estimated_cost: float
 
 
 @dataclass(frozen=True)
 class GenerationResult:
-    raw_response: str
-    usage: str
-    raw_template: str
-    template: str
+    """Structured result of generating + DSL-compiling a template from a sample."""
 
+    template: str  # canonical, DSL-compiled TextFSM template
+    raw_template: str  # pre-cleanup template, as the LLM returned it
+    readable_dsl: str
+    recognizers: list[str]
+    records: list[dict[str, str]]
+    usage: TokenUsage
+    duration_ms: float
+    ready: bool
+    reason: str
+    raw: dict[str, Any] = field(repr=False)
 
-class Generator(Protocol):
-    """An LLM backend capable of producing a TextFSM template from sample input.
 
-    ``prior_context`` carries additional samples of the same command when
-    running in Mode 1 (batch) per §4.
-    """
+def generate(
+    sample: str,
+    provider: str,
+    api_key: str,
+    model: str,
+    **kwargs: Any,
+) -> GenerationResult:
+    """Run textfsm-ai's full sample -> template -> DSL-compiled pipeline.
+
+    Always runs in debug mode with JSON output (not overridable — pass
+    ``mode``/``as_json`` in ``kwargs`` and this raises, same as calling
+    ``run_pipeline()`` twice for the same argument would). ``**kwargs``
+    forwards to ``run_pipeline()`` for everything else (``endpoint``,
+    ``region``, ``max_tries``, ...).
 
-    def generate(
-        self, input_text: str, prior_context: list[str] | None = None
-    ) -> GenerationResult: ...
+    Never raises for a failed generation — check ``.ready``.
+    """
+    result = run_pipeline(
+        sample, provider, api_key, model, mode="debug", as_json=True, **kwargs
+    )
+    debug = _redact(json.loads(result.output))
 
+    usage_data = debug.get("usage") or {}
+    usage = TokenUsage(
+        input_tokens=usage_data.get("input_tokens", 0),
+        output_tokens=usage_data.get("output_tokens", 0),
+        total_tokens=usage_data.get("total_tokens", 0),
+        estimated_cost=usage_data.get("estimated_cost", 0.0),
+    )
 
-def extract_template(raw_response: str) -> str:
-    """Pull the template body out of a raw LLM response (step 6, pre-cleanup)."""
-    raise NotImplementedError("extraction rule TBD — see SPEC.md §5 step 6")
+    gen_stage = (debug.get("generation_pipeline") or {}).get("last_stage") or {}
+    gen_metadata = gen_stage.get("metadata") or {}
 
+    dsl = (debug.get("dsl_pipeline") or {}).get("dsl") or {}
 
-def clean_template(raw_template: str) -> str:
-    """Normalize an extracted template into a valid template.textfsm body."""
-    raise NotImplementedError("cleanup rule TBD — see SPEC.md §5 step 6")
+    return GenerationResult(
+        template=dsl.get("canonical") or "",
+        raw_template=dsl.get("raw_template") or gen_metadata.get("template") or "",
+        readable_dsl=dsl.get("readable") or "",
+        recognizers=dsl.get("recognizers") or [],
+        records=gen_metadata.get("records") or [],
+        usage=usage,
+        duration_ms=debug.get("duration_ms", 0.0),
+        ready=result.passed,
+        reason=result.error,
+        raw=debug,
+    )

parseforge/integration.py

@@ -0,0 +1,314 @@
+"""Integration — cluster trials for a cli-name into output-schema groups
+(SPEC.md §3.2, §5 step 8; §6 multi-variant note).
+
+Unlike §3.2's original single "common-result" winner, a cli-name's output
+can legitimately vary by hardware/firmware (§6). ``build_integration``
+groups every trial for a cli-name by the field-key signature of its parsed
+records, and within a group further distinguishes byte-identical template
+variants from divergent ones. This is pure evidence gathering — no
+promotion decision is made or stored here (see :mod:`parseforge.promotion`
+for that, which reads ``reference.json`` back out).
+
+Only trials whose own summary.json says ``passed: true`` are eligible —
+see :func:`_trial_passed`. A trial can fail for reasons a template/sample
+re-parse alone wouldn't catch (e.g. a truncated, not-ready generation
+whose partial output still happens to self-parse), so that stored verdict
+is trusted rather than re-derived.
+
+``build_integration`` is a full rebuild each call: every trial run-dir for
+the cli-name is rescanned and ``reference.json`` is regenerated from
+scratch, rather than incrementally diffed against its prior contents. A new
+trial is only ever compared against the (small) set of distinct groups
+already found, not every past trial, so this costs the same either way and
+avoids partial-state bugs. Group/variant numbering stays deterministic
+because trial run-dirs are iterated in chronological run-id order.
+
+``reference.json`` is ``{total_case_count, total_passed_case_count,
+groups: {group_id: {keys, sample_path, group_case_count, variants}}}`` —
+every one of those counts is a snapshot from that same rebuild (as fresh
+as everything else in the file), included so match rate is readable
+without re-globbing trials/. :func:`build_reference_summary` turns those
+counts into ratios across every cli-name in one report;
+:mod:`parseforge.promotion` still recomputes its own count independently
+at decision time rather than trusting either snapshot.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from parseforge import paths, validation
+
+
+@dataclass(frozen=True)
+class ReferenceVariant:
+    template_path: str
+    exact_template_count: int
+    exact_records_count: int
+
+
+@dataclass(frozen=True)
+class ReferenceGroup:
+    keys: list[str]
+    sample_path: str
+    variants: dict[str, ReferenceVariant] = field(default_factory=dict)
+
+    @property
+    def group_case_count(self) -> int:
+        """Total trials belonging to this group — the sum of every
+        variant's exact_template_count. A property (not a stored field) so
+        it can never drift out of sync with ``variants``."""
+        return sum(v.exact_template_count for v in self.variants.values())
+
+
+Reference = dict[str, ReferenceGroup]
+
+
+def _load_reference(path: Path) -> Reference:
+    if not path.exists():
+        return {}
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    reference: Reference = {}
+    for group_id, group_raw in raw.get("groups", {}).items():
+        variants = {
+            variant_id: ReferenceVariant(**variant_raw)
+            for variant_id, variant_raw in group_raw["variants"].items()
+        }
+        reference[group_id] = ReferenceGroup(
+            keys=group_raw["keys"],
+            sample_path=group_raw["sample_path"],
+            variants=variants,
+        )
+    return reference
+
+
+def _save_reference(
+    path: Path,
+    reference: Reference,
+    total_case_count: int,
+    total_passed_case_count: int,
+) -> None:
+    """Write reference.json as
+    ``{total_case_count, total_passed_case_count, groups}``.
+
+    Both counts are snapshots from the same trial scan that produced
+    ``groups`` below them — as fresh as the rest of this file, and
+    included purely so a reader (or :func:`build_reference_summary`) can
+    compute match rate without re-globbing trials/. Promotion decisions
+    still recompute their own count independently at decision time (see
+    :mod:`parseforge.promotion`) rather than trusting either snapshot.
+
+    ``total_passed_case_count`` (trials whose own summary.json says
+    passed) is normally close to the sum of every group's
+    group_case_count, but isn't guaranteed identical to it — a passed
+    trial can still fall out of clustering if its derive/samples files
+    are missing or its template unexpectedly fails to re-parse. Reporting
+    both numbers surfaces that gap instead of hiding it.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    serializable = {
+        "total_case_count": total_case_count,
+        "total_passed_case_count": total_passed_case_count,
+        "groups": {
+            group_id: {
+                "keys": group.keys,
+                "sample_path": group.sample_path,
+                "group_case_count": group.group_case_count,
+                "variants": {
+                    variant_id: asdict(variant)
+                    for variant_id, variant in group.variants.items()
+                },
+            }
+            for group_id, group in reference.items()
+        },
+    }
+    path.write_text(
+        json.dumps(serializable, indent=2, sort_keys=True), encoding="utf-8"
+    )
+
+
+def build_integration(store_root: Path, key: paths.DeviceKey) -> Reference:
+    """Rebuild the group clustering for ``key.cli_name`` from every trial
+    currently under ``trials/<vendor>/.../<cli-name>/``, and persist it to
+    ``integration/.../<cli-name>/reference.json``.
+    """
+    trials_dir = paths.tier_path(store_root, paths.TRIALS, key)
+    integration_dir = paths.integration_dir(store_root, key)
+    integration_dir.mkdir(parents=True, exist_ok=True)
+
+    reference: Reference = {}
+    if not trials_dir.exists():
+        _save_reference(
+            integration_dir / "reference.json",
+            reference,
+            total_case_count=0,
+            total_passed_case_count=0,
+        )
+        return reference
+
+    run_dirs = sorted(d for d in trials_dir.iterdir() if d.is_dir())
+    total_passed_case_count = 0
+
+    for run_dir in run_dirs:
+        if not _trial_passed(run_dir):
+            continue
+        total_passed_case_count += 1
+
+        template_path = run_dir / "derive" / "template.textfsm"
+        sample_path = run_dir / "samples" / "sample.txt"
+        if not template_path.exists() or not sample_path.exists():
+            continue
+
+        template_text = template_path.read_text(encoding="utf-8")
+        sample_text = sample_path.read_text(encoding="utf-8")
+
+        parsed = validation.parse(template_text, sample_text)
+        if not parsed.passed or not parsed.records:
+            continue
+
+        record_keys = sorted(parsed.records[0].keys())
+        group_id = _find_matching_group(reference, record_keys)
+        if group_id is None:
+            group_id = f"group{len(reference) + 1}"
+            reference[group_id] = ReferenceGroup(
+                keys=record_keys, sample_path=str(sample_path), variants={}
+            )
+
+        group = reference[group_id]
+        variant_id = _find_matching_variant(group, template_text)
+        if variant_id is not None:
+            variant = group.variants[variant_id]
+            group.variants[variant_id] = ReferenceVariant(
+                template_path=variant.template_path,
+                exact_template_count=variant.exact_template_count + 1,
+                exact_records_count=variant.exact_records_count + len(parsed.records),
+            )
+        else:
+            variant_id = str(len(group.variants) + 1)
+            group.variants[variant_id] = ReferenceVariant(
+                template_path=str(template_path),
+                exact_template_count=1,
+                exact_records_count=len(parsed.records),
+            )
+            dest_name = f"{group_id}-template{variant_id}.textfsm"
+            (integration_dir / dest_name).write_text(template_text, encoding="utf-8")
+
+    _save_reference(
+        integration_dir / "reference.json",
+        reference,
+        total_case_count=len(run_dirs),
+        total_passed_case_count=total_passed_case_count,
+    )
+    return reference
+
+
+def _trial_passed(run_dir: Path) -> bool:
+    """A trial is only clustering material if its own summary.json says it
+    passed. This isn't re-derivable from template.textfsm + sample.txt
+    alone: a template can be truncated (generation not ready) yet still
+    happen to parse its own sample, which the record-schema re-parse below
+    wouldn't catch on its own — unlike total_case_count, "did this specific
+    past trial succeed" isn't something that goes stale, so trusting the
+    stored verdict here is correct, not a shortcut."""
+    summary_path = run_dir / "summary.json"
+    if not summary_path.exists():
+        return False
+    summary = json.loads(summary_path.read_text(encoding="utf-8"))
+    return bool(summary.get("passed"))
+
+
+def _find_matching_group(reference: Reference, keys: list[str]) -> str | None:
+    for group_id, group in reference.items():
+        if group.keys == keys:
+            return group_id
+    return None
+
+
+def _find_matching_variant(group: ReferenceGroup, template_text: str) -> str | None:
+    for variant_id, variant in group.variants.items():
+        existing_text = Path(variant.template_path).read_text(encoding="utf-8")
+        if existing_text == template_text:
+            return variant_id
+    return None
+
+
+def build_reference_summary(store_root: Path) -> dict[str, Any]:
+    """Aggregate every reference.json under the integration tier into one
+    cross-cli-name match-rate report — a read-only transform of whatever
+    build_integration() has already written, no filesystem rescan of
+    trials/. Ratios are 0.0 for any cli-name with total_case_count (or
+    total_passed_case_count) == 0, rather than dividing by zero.
+
+    Every ratio comes in two flavors: ``ratio_of_total`` (share of *every*
+    trial attempted, pass or fail) and ``ratio_of_passed`` (share of only
+    the trials that actually passed — the only trials group_case_count
+    can ever include, since a failed trial can never join a group). The
+    "of_total" figure is diluted by raw generation failures; "of_passed"
+    isolates template-consistency among the runs that succeeded.
+    """
+    integration_root = paths.tier_root(store_root, paths.INTEGRATION)
+    cases: dict[str, Any] = {}
+
+    if integration_root.exists():
+        for reference_path in sorted(integration_root.rglob("reference.json")):
+            case_key = reference_path.parent.relative_to(integration_root).as_posix()
+            raw = json.loads(reference_path.read_text(encoding="utf-8"))
+            total_case_count = raw.get("total_case_count", 0)
+            total_passed_case_count = raw.get("total_passed_case_count", 0)
+
+            groups_summary = {}
+            for group_id, group_raw in raw.get("groups", {}).items():
+                group_case_count = group_raw.get("group_case_count", 0)
+                variants_summary = {}
+                for variant_id, variant_raw in group_raw.get("variants", {}).items():
+                    exact = variant_raw.get("exact_template_count", 0)
+                    variants_summary[variant_id] = {
+                        "ratio_of_group": (
+                            exact / group_case_count if group_case_count else 0.0
+                        ),
+                        "ratio_of_total": (
+                            exact / total_case_count if total_case_count else 0.0
+                        ),
+                        "ratio_of_passed": (
+                            exact / total_passed_case_count
+                            if total_passed_case_count
+                            else 0.0
+                        ),
+                    }
+                groups_summary[group_id] = {
+                    "keys": group_raw.get("keys", []),
+                    "case_count": group_case_count,
+                    "ratio_of_total": (
+                        group_case_count / total_case_count if total_case_count else 0.0
+                    ),
+                    "ratio_of_passed": (
+                        group_case_count / total_passed_case_count
+                        if total_passed_case_count
+                        else 0.0
+                    ),
+                    "variants": variants_summary,
+                }
+
+            cases[case_key] = {
+                "total_case_count": total_case_count,
+                "total_passed_case_count": total_passed_case_count,
+                "groups": groups_summary,
+            }
+
+    return {
+        "trial_project": str(paths.tier_root(store_root, paths.TRIALS)),
+        "cases": cases,
+    }
+
+
+def write_reference_summary(store_root: Path) -> Path:
+    """Write build_reference_summary()'s report to
+    integration/reference-summary.json and return its path."""
+    summary = build_reference_summary(store_root)
+    path = paths.reference_summary_path(store_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(summary, indent=2, sort_keys=True), encoding="utf-8")
+    return path

parseforge/naming/__init__.py

@@ -1,15 +1,30 @@
-from .assemble import pattern_to_cli_name
+from .assemble import normalize_pattern, pattern_to_cli_name
 from .cache import DEFAULT_INDEX_PATH, NameIndex
-from .llm import CliContext, RegexBuilder, UnimplementedRegexBuilder, build_prompt
-from .resolver import cli_name
+from .llm import (
+    CliContext,
+    LLMCLIResponse,
+    RegexBuilder,
+    TokenUsage,
+    UnimplementedRegexBuilder,
+    build_prompt,
+)
+from .providers import AnthropicRegexBuilder, DeepSeekRegexBuilder
+from .resolver import NamingResolution, cli_name, resolve_cli_name
 
 __all__ = [
     "cli_name",
+    "resolve_cli_name",
+    "NamingResolution",
     "CliContext",
     "RegexBuilder",
     "UnimplementedRegexBuilder",
+    "AnthropicRegexBuilder",
+    "DeepSeekRegexBuilder",
+    "LLMCLIResponse",
+    "TokenUsage",
     "build_prompt",
     "NameIndex",
     "DEFAULT_INDEX_PATH",
     "pattern_to_cli_name",
+    "normalize_pattern",
 ]