Rename connector enrich terminology to normalize

Author: shubhobm

avidtools/connectors/base.py

@@ -1,40 +1,40 @@
-"""Generic enrich helpers for AVID report JSON and JSONL files."""
+"""Generic normalize helpers for AVID report JSON and JSONL files."""
 
 import json
 from pathlib import Path
 
-from .utils import apply_enrich_normalizations
+from .utils import apply_normalizations
 
 
-def _enrich_report(report: dict) -> None:
-    """Apply generic enrich normalizations to a single report dict."""
+def _normalize_report(report: dict) -> None:
+    """Apply generic normalizations to a single report dict."""
 
-    apply_enrich_normalizations(report)
+    apply_normalizations(report)
 
 
 def process_json_file(
     input_path: Path,
     dry_run: bool,
 ) -> int:
-    """Enrich a JSON file containing one report object or a list of reports."""
+    """Normalize a JSON file containing one report object or a list of reports."""
 
     with input_path.open("r", encoding="utf-8") as file_obj:
         payload = json.load(file_obj)
 
-    reports_enriched = 0
+    reports_normalized = 0
 
     if isinstance(payload, dict):
-        _enrich_report(payload)
-        reports_enriched += 1
+        _normalize_report(payload)
+        reports_normalized += 1
     elif isinstance(payload, list):
         for index, report in enumerate(payload, 1):
             if not isinstance(report, dict):
                 raise ValueError(
                     "Invalid item at index "
                     f"{index} in JSON list: expected object"
                 )
-            _enrich_report(report)
-            reports_enriched += 1
+            _normalize_report(report)
+            reports_normalized += 1
     else:
         raise ValueError("Unsupported JSON structure: expected object or list")
 
@@ -43,17 +43,17 @@ def process_json_file(
             json.dump(payload, file_obj, indent=2)
             file_obj.write("\n")
 
-    return reports_enriched
+    return reports_normalized
 
 
 def process_jsonl_file(
     input_path: Path,
     dry_run: bool,
 ) -> int:
-    """Enrich each report object in a JSONL file."""
+    """Normalize each report object in a JSONL file."""
 
-    reports_enriched = 0
-    enriched_lines = []
+    reports_normalized = 0
+    normalized_lines = []
 
     with input_path.open("r", encoding="utf-8") as file_obj:
         for line_num, line in enumerate(file_obj, 1):
@@ -73,20 +73,20 @@ def process_jsonl_file(
                     f"Invalid JSON object on line {line_num}: expected object"
                 )
 
-            _enrich_report(report)
-            reports_enriched += 1
-            enriched_lines.append(json.dumps(report, ensure_ascii=False))
+            _normalize_report(report)
+            reports_normalized += 1
+            normalized_lines.append(json.dumps(report, ensure_ascii=False))
 
     if not dry_run:
         with input_path.open("w", encoding="utf-8") as file_obj:
-            if enriched_lines:
-                file_obj.write("\n".join(enriched_lines) + "\n")
+            if normalized_lines:
+                file_obj.write("\n".join(normalized_lines) + "\n")
 
-    return reports_enriched
+    return reports_normalized
 
 
-def enrich_file(input_path: Path, dry_run: bool = False) -> int:
-    """Dispatch enrich processing based on input file extension."""
+def normalize_file(input_path: Path, dry_run: bool = False) -> int:
+    """Dispatch normalize processing based on input file extension."""
 
     if input_path.suffix == ".json":
         return process_json_file(input_path, dry_run)

avidtools/connectors/garak.py

@@ -1,4 +1,4 @@
-"""Garak-specific enrich helpers for AVID report JSON and JSONL files."""
+"""Garak-specific normalize helpers for AVID report JSON and JSONL files."""
 
 import asyncio
 import json
@@ -11,7 +11,7 @@
 from urllib.request import Request, urlopen
 
 from .utils import (
-    apply_enrich_normalizations,
+    apply_normalizations,
     choose_model_subject_label,
     to_list,
 )
@@ -252,7 +252,7 @@ def _fetch_probe_reference_text(probe_name: str) -> Optional[str]:
     _, reference_url = _probe_urls(probe_name)
     request = Request(
         reference_url,
-        headers={"User-Agent": "avid-db-garak-enrich/1.0"},
+        headers={"User-Agent": "avid-db-garak-normalize/1.0"},
     )
     try:
         with urlopen(request, timeout=30) as response:
@@ -763,16 +763,16 @@ def _extract_primary_model_developer_and_deployer(report: dict):
     return model_name, developer_name, deployer_name
 
 
-def _enrich_report(
+def _normalize_report(
     report: dict,
     probe_summaries: Dict[str, str],
     module_behaviors: Dict[str, str],
 ):
-    """Apply Garak-specific enrich transforms to a single report."""
+    """Apply Garak-specific normalize transforms to a single report."""
 
     preferred_model_name = _shorten_artifact_model_names(report)
     _apply_litellm_deployer_mapping(report)
-    apply_enrich_normalizations(
+    apply_normalizations(
         report,
         preferred_model_name=preferred_model_name,
     )
@@ -887,12 +887,12 @@ def _save_reports(input_path: Path, reports, shape: str):
     raise ValueError(f"Unknown shape: {shape}")
 
 
-def enrich_file(
+def normalize_file(
     input_path: Path,
     dry_run: bool = False,
     cache_path: Path = CACHE_PATH,
 ) -> int:
-    """Enrich a Garak JSON/JSONL input file and optionally rewrite in place."""
+    """Normalize a Garak JSON/JSONL input file and optionally rewrite in place."""
 
     reports, shape = _load_reports(input_path)
 
@@ -907,7 +907,7 @@ def enrich_file(
     )
 
     for report in reports:
-        _enrich_report(report, probe_summaries, module_behaviors)
+        _normalize_report(report, probe_summaries, module_behaviors)
 
     if not dry_run:
         _save_reports(input_path, reports, shape)

avidtools/connectors/inspect.py

@@ -1,4 +1,4 @@
-"""Connector helpers for converting and enriching Inspect evaluation reports."""
+"""Connector helpers for converting and normalizing Inspect evaluation reports."""
 
 import json
 import re
@@ -78,15 +78,15 @@ def import_eval_log(file_path: str) -> Any:
     return read_eval_log(file_path)
 
 
-def convert_eval_log(file_path: str, enrich: bool = False) -> List[Report]:
+def convert_eval_log(file_path: str, normalize: bool = False) -> List[Report]:
     """Convert an Inspect evaluation log into a list of AVID Report objects.
 
     Parameters
     ----------
     file_path : str
         Path to the evaluation log file (.eval or .json).
-    enrich : bool
-        If True, run enrich steps that fetch benchmark overview/scoring
+    normalize : bool
+        If True, run normalize steps that fetch benchmark overview/scoring
         and apply report normalizations.
 
     Returns
@@ -166,13 +166,13 @@ def convert_eval_log(file_path: str, enrich: bool = False) -> List[Report]:
         )
         report.description = LangValue(lang="eng", value=full_description)
 
-        if enrich:
+        if normalize:
             report_payload = (
                 report.model_dump()
                 if hasattr(report, "model_dump")
                 else report.dict()
             )
-            enrich_report_data(report_payload)
+            normalize_report_data(report_payload)
             report = Report(**report_payload)
 
         reports.append(report)
@@ -321,7 +321,7 @@ def _build_new_description(
     overview: str,
     scoring: str,
 ) -> str:
-    """Build standardized enriched report description text."""
+    """Build standardized normalized report description text."""
 
     return (
         f"{overview}\n\n"
@@ -341,8 +341,8 @@ def _first_line(text: str) -> str:
     return ""
 
 
-def enrich_report_data(report: dict):
-    """Apply Inspect enrich transformations to a report dictionary."""
+def normalize_report_data(report: dict):
+    """Apply Inspect normalize transformations to a report dictionary."""
 
     problem_desc = (
         report.get("problemtype", {})
@@ -375,12 +375,12 @@ def enrich_report_data(report: dict):
 
 
 def process_report(file_path: Path):
-    """Load, enrich, and rewrite a single Inspect report file."""
+    """Load, normalize, and rewrite a single Inspect report file."""
 
     with file_path.open("r", encoding="utf-8") as file_obj:
         report = json.load(file_obj)
 
-    enrich_report_data(report)
+    normalize_report_data(report)
 
     with file_path.open("w", encoding="utf-8") as file_obj:
         json.dump(report, file_obj, indent=2)

avidtools/connectors/utils.py

@@ -196,11 +196,11 @@ def apply_openai_system_artifact_type(
     return updated
 
 
-def apply_enrich_normalizations(
+def apply_normalizations(
     report: dict,
     preferred_model_name: Optional[str] = None,
 ) -> bool:
-    """Apply the default enrich normalization suite to a report."""
+    """Apply the default normalization suite to a report."""
 
     model_names = extract_model_names(
         report,
@@ -221,9 +221,9 @@ def apply_review_normalizations(
     report: dict,
     preferred_model_name: Optional[str] = None,
 ) -> bool:
-    """Backward-compatible alias for enrich normalizations."""
+    """Backward-compatible alias for default normalizations."""
 
-    return apply_enrich_normalizations(
+    return apply_normalizations(
         report,
         preferred_model_name=preferred_model_name,
     )

scripts/odin.py

@@ -160,7 +160,7 @@ def extract_odin_metadata_from_html(html_content: str, page_text: str) -> dict:
         page_text: Text content from the page
         
     Returns:
-        Dictionary with extracted 0DIN metadata for report enrichment.
+        Dictionary with extracted 0DIN metadata for report normalization.
     """
     print(f"Extracting 0DIN metadata from scraped content...")
 

tests/unit/connectors/test_garak.py

@@ -1,4 +1,4 @@
-"""Unit tests for Garak connector enrich helpers."""
+"""Unit tests for Garak connector normalize helpers."""
 
 from avidtools.connectors.garak import _normalize_metric_results
 

tests/unit/connectors/test_inspect.py

@@ -225,21 +225,21 @@ def test_convert_eval_log_different_model(self, mock_import):
         assert report.affects.deployer == ["anthropic/claude-3"]
         assert report.affects.artifacts[0].name == "claude-3"
 
-    @patch('avidtools.connectors.inspect.enrich_report_data')
+    @patch('avidtools.connectors.inspect.normalize_report_data')
     @patch('avidtools.connectors.inspect.import_eval_log')
-    def test_convert_eval_log_with_enrich_enabled(
+    def test_convert_eval_log_with_normalize_enabled(
         self,
         mock_import,
-        mock_enrich,
+        mock_normalize,
     ):
-        """Enrich mode should call enrich_report_data for each sample."""
+        """Normalize mode should call normalize_report_data for each sample."""
         mock_eval_log = MockEvalLog()
         mock_import.return_value = mock_eval_log
 
-        reports = convert_eval_log("/path/to/eval.json", enrich=True)
+        reports = convert_eval_log("/path/to/eval.json", normalize=True)
 
         assert len(reports) == 1
-        assert mock_enrich.call_count == 1
+        assert mock_normalize.call_count == 1
 
     @patch('avidtools.connectors.inspect.urlopen')
     def test_fetch_sections_raises_on_unresolved_benchmark(self, mock_urlopen):

…sts/unit/connectors/test_enrich_utils.py …/unit/connectors/test_normalize_utils.pytests/unit/connectors/test_enrich_utils.py renamed to tests/unit/connectors/test_normalize_utils.py tests/unit/connectors/test_enrich_utils.py renamed to tests/unit/connectors/test_normalize_utils.py

@@ -1,9 +1,9 @@
-"""Unit tests for enrich normalization utilities."""
+"""Unit tests for normalization utilities."""
 
-from avidtools.connectors.utils import apply_enrich_normalizations
+from avidtools.connectors.utils import apply_normalizations
 
 
-def test_apply_enrich_normalizations_sets_openai_deployer_for_gpt_model():
+def test_apply_normalizations_sets_openai_deployer_for_gpt_model():
     """GPT model artifacts should normalize deployer to OpenAI."""
     report = {
         "affects": {
@@ -14,14 +14,14 @@ def test_apply_enrich_normalizations_sets_openai_deployer_for_gpt_model():
         "problemtype": {"description": {"value": ""}},
     }
 
-    updated = apply_enrich_normalizations(report)
+    updated = apply_normalizations(report)
 
     assert updated is True
     assert report["affects"]["deployer"] == ["OpenAI"]
     assert report["affects"]["artifacts"][0]["type"] == "System"
 
 
-def test_apply_enrich_normalizations_sets_together_ai_deployer():
+def test_apply_normalizations_sets_together_ai_deployer():
     """Together-prefixed deployers should normalize to Together AI."""
     report = {
         "affects": {
@@ -32,7 +32,7 @@ def test_apply_enrich_normalizations_sets_together_ai_deployer():
         "problemtype": {"description": {"value": ""}},
     }
 
-    updated = apply_enrich_normalizations(report)
+    updated = apply_normalizations(report)
 
     assert updated is True
     assert report["affects"]["deployer"] == ["Together AI"]