| """Back-to-back validation engine for Perl-to-Python rule migration."""
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import hashlib
|
| import json
|
| import math
|
| import subprocess
|
| from datetime import datetime, timezone
|
| from pathlib import Path
|
| from statistics import mean
|
| from typing import Dict, List, Mapping, Sequence, Set
|
| from uuid import uuid4
|
|
|
| from declarative.check_runners import run_declarative_checks
|
| from data.load_dataset import (
|
| DB_PATH,
|
| DEFAULT_OFF_JSONL,
|
| SAMPLE_FILE,
|
| create_and_load_dataset,
|
| )
|
| from duckdb_utils.create_tables import count_violations, sample_violations
|
| from extractor.perl_logic_extractor import extract_rules
|
| from migration.llm_converter import convert_rules, repair_conversion_with_counterexamples
|
| from perl_checks.legacy_checks import LEGACY_RULES, get_legacy_rule_map, get_perl_rule_snippets, run_perl_checks
|
| from python_checks.generated_checks import compile_generated_checks
|
| from rulepacks.registry import DEFAULT_PROFILE, SUPPORTED_PROFILES, attach_profile_metadata, get_profile_rule_names, validate_profile
|
| from validation.verification import run_rule_verification
|
|
|
| RESULT_PATH = Path(__file__).resolve().parent.parent / "results" / "migration_results.json"
|
| TABLE_NAME = "nutrition_table"
|
|
|
|
|
| def _sha256_text(text: str) -> str:
|
| return hashlib.sha256(text.encode("utf-8")).hexdigest()
|
|
|
|
|
| def _sha256_json(payload: object) -> str:
|
| normalized = json.dumps(payload, sort_keys=True, default=str, separators=(",", ":"))
|
| return _sha256_text(normalized)
|
|
|
|
|
| def _resolve_git_commit() -> str:
|
| try:
|
| completed = subprocess.run(
|
| ["git", "rev-parse", "HEAD"],
|
| capture_output=True,
|
| text=True,
|
| encoding="utf-8",
|
| errors="replace",
|
| check=False,
|
| timeout=5,
|
| )
|
| if completed.returncode == 0:
|
| value = (completed.stdout or "").strip()
|
| if value:
|
| return value
|
| except Exception:
|
| pass
|
| return "unknown"
|
|
|
|
|
| def _dataset_fingerprint_payload(
|
| products: Sequence[Mapping[str, object]],
|
| source_path: Path | None,
|
| dataset_size: int,
|
| seed: int,
|
| ) -> Dict[str, object]:
|
| normalized_products = [
|
| {key: product.get(key) for key in sorted(product.keys())}
|
| for product in sorted(products, key=lambda row: str(row.get("product_id", "")))
|
| ]
|
| product_ids = [str(product.get("product_id", "")) for product in normalized_products if product.get("product_id")]
|
| source_mode = "off_jsonl" if source_path else "synthetic"
|
| payload = {
|
| "source_mode": source_mode,
|
| "source_jsonl": str(source_path) if source_path else "synthetic",
|
| "requested_size": int(dataset_size),
|
| "products_tested": len(normalized_products),
|
| "seed": int(seed) if source_mode == "synthetic" else None,
|
| "product_id_first": product_ids[0] if product_ids else None,
|
| "product_id_last": product_ids[-1] if product_ids else None,
|
| "sha256": _sha256_json(normalized_products),
|
| }
|
| return payload
|
|
|
|
|
| def _rulepack_fingerprint_payload(structured_rules: Sequence[Mapping[str, object]], profile_name: str) -> Dict[str, object]:
|
| rule_names = sorted(str(rule.get("rule_name", "")) for rule in structured_rules)
|
| ir_hashes = sorted(str(rule.get("rule_ir_hash", "")) for rule in structured_rules)
|
| payload = {
|
| "profile": profile_name,
|
| "rule_count": len(structured_rules),
|
| "rule_names_sha256": _sha256_json(rule_names),
|
| "rule_ir_sha256": _sha256_json(ir_hashes),
|
| }
|
| return payload
|
|
|
|
|
| def _wilson_interval(successes: int, trials: int, z: float = 1.96) -> tuple[float, float]:
|
| """Return two-sided Wilson score interval for a binomial proportion."""
|
| if trials <= 0:
|
| return 0.0, 1.0
|
| p = successes / trials
|
| z2 = z * z
|
| denom = 1.0 + (z2 / trials)
|
| center = (p + (z2 / (2.0 * trials))) / denom
|
| margin = (z * (((p * (1.0 - p)) + (z2 / (4.0 * trials))) / trials) ** 0.5) / denom
|
| lower = max(0.0, center - margin)
|
| upper = min(1.0, center + margin)
|
| return lower, upper
|
|
|
|
|
| def _beta_continued_fraction(a: float, b: float, x: float, max_iter: int = 400, eps: float = 3e-12) -> float:
|
| """Continued fraction helper for incomplete beta evaluation."""
|
| qab = a + b
|
| qap = a + 1.0
|
| qam = a - 1.0
|
| c = 1.0
|
| d = 1.0 - (qab * x / qap)
|
| if abs(d) < 1e-30:
|
| d = 1e-30
|
| d = 1.0 / d
|
| h = d
|
|
|
| for m in range(1, max_iter + 1):
|
| m2 = 2 * m
|
| aa = (m * (b - m) * x) / ((qam + m2) * (a + m2))
|
| d = 1.0 + aa * d
|
| if abs(d) < 1e-30:
|
| d = 1e-30
|
| c = 1.0 + aa / c
|
| if abs(c) < 1e-30:
|
| c = 1e-30
|
| d = 1.0 / d
|
| h *= d * c
|
|
|
| aa = (-(a + m) * (qab + m) * x) / ((a + m2) * (qap + m2))
|
| d = 1.0 + aa * d
|
| if abs(d) < 1e-30:
|
| d = 1e-30
|
| c = 1.0 + aa / c
|
| if abs(c) < 1e-30:
|
| c = 1e-30
|
| d = 1.0 / d
|
| delta = d * c
|
| h *= delta
|
| if abs(delta - 1.0) < eps:
|
| break
|
|
|
| return h
|
|
|
|
|
| def _regularized_incomplete_beta(a: float, b: float, x: float) -> float:
|
| """Regularized incomplete beta I_x(a,b) in [0,1]."""
|
| if x <= 0.0:
|
| return 0.0
|
| if x >= 1.0:
|
| return 1.0
|
|
|
| bt = math.exp(
|
| math.lgamma(a + b)
|
| - math.lgamma(a)
|
| - math.lgamma(b)
|
| + a * math.log(x)
|
| + b * math.log(1.0 - x)
|
| )
|
|
|
| if x < (a + 1.0) / (a + b + 2.0):
|
| return bt * _beta_continued_fraction(a, b, x) / a
|
| return 1.0 - (bt * _beta_continued_fraction(b, a, 1.0 - x) / b)
|
|
|
|
|
| def _beta_ppf(probability: float, alpha: float, beta: float, tol: float = 1e-7, max_iter: int = 200) -> float:
|
| """Inverse CDF for Beta(alpha, beta) using monotonic bisection."""
|
| p = min(1.0, max(0.0, probability))
|
| lo = 0.0
|
| hi = 1.0
|
| for _ in range(max_iter):
|
| mid = (lo + hi) / 2.0
|
| cdf_mid = _regularized_incomplete_beta(alpha, beta, mid)
|
| if abs(cdf_mid - p) < tol:
|
| return mid
|
| if cdf_mid < p:
|
| lo = mid
|
| else:
|
| hi = mid
|
| return (lo + hi) / 2.0
|
|
|
|
|
| def _run_python_checks(
|
| products: Sequence[Mapping[str, object]],
|
| structured_rules: Sequence[Dict[str, object]],
|
| python_checks: Dict[str, object],
|
| ) -> Dict[str, Dict[str, object]]:
|
| rule_names = [str(rule["rule_name"]) for rule in structured_rules]
|
| per_rule_products: Dict[str, Set[str]] = {rule_name: set() for rule_name in rule_names}
|
| per_product_tags: Dict[str, List[str]] = {}
|
|
|
| for product in products:
|
| product_id = str(product.get("product_id"))
|
| tags: List[str] = []
|
| for rule in structured_rules:
|
| rule_name = str(rule["rule_name"])
|
| check_fn = python_checks[rule_name]
|
| tag = check_fn(product)
|
| if tag:
|
| tags.append(str(tag))
|
| per_rule_products[rule_name].add(product_id)
|
| per_product_tags[product_id] = tags
|
|
|
| return {
|
| "per_product": per_product_tags,
|
| "per_rule": {name: sorted(ids) for name, ids in per_rule_products.items()},
|
| }
|
|
|
|
|
| def _run_python_verification(
|
| structured_rules: Sequence[Dict[str, object]],
|
| python_checks: Mapping[str, object],
|
| conversion_metadata: Mapping[str, Mapping[str, object]],
|
| seed: int,
|
| legacy_rules: Sequence[object],
|
| ) -> Dict[str, Dict[str, object]]:
|
| legacy_map = get_legacy_rule_map(legacy_rules)
|
| verification_by_rule: Dict[str, Dict[str, object]] = {}
|
| for rule in structured_rules:
|
| rule_name = str(rule["rule_name"])
|
| legacy_rule = legacy_map.get(rule_name)
|
| if legacy_rule is None:
|
| verification_by_rule[rule_name] = {
|
| "equivalence_cases": 0,
|
| "equivalence_matches": 0,
|
| "equivalence_mismatches": 0,
|
| "equivalence_match_rate": 1.0,
|
| "equivalence_status": "PASS",
|
| "counterexamples": [],
|
| "mutation_total": 0,
|
| "mutation_killed": 0,
|
| "mutation_survived": 0,
|
| "mutation_score": 1.0,
|
| "mutation_survived_mutants": [],
|
| "verification_score": 1.0,
|
| }
|
| continue
|
| verification_by_rule[rule_name] = run_rule_verification(
|
| rule=rule,
|
| perl_evaluator=legacy_rule.evaluator,
|
| check_fn=python_checks[rule_name],
|
| python_code=str(conversion_metadata[rule_name]["python_code"]),
|
| function_name=str(conversion_metadata[rule_name]["function_name"]),
|
| seed=seed,
|
| )
|
| return verification_by_rule
|
|
|
|
|
| def _build_failed_case_rows(
|
| mismatch_ids: Sequence[str],
|
| product_map: Dict[str, Mapping[str, object]],
|
| perl_ids: Set[str],
|
| python_ids: Set[str],
|
| limit: int = 10,
|
| ) -> List[Dict[str, object]]:
|
| rows: List[Dict[str, object]] = []
|
| for product_id in mismatch_ids[:limit]:
|
| product = dict(product_map[product_id])
|
| rows.append(
|
| {
|
| "product_id": product_id,
|
| "perl_triggered": product_id in perl_ids,
|
| "python_triggered": product_id in python_ids,
|
| "energy_kj": product.get("energy_kj"),
|
| "energy_kj_computed": product.get("energy_kj_computed"),
|
| "energy_kcal": product.get("energy_kcal"),
|
| "fat": product.get("fat"),
|
| "saturated_fat": product.get("saturated_fat"),
|
| "carbohydrates": product.get("carbohydrates"),
|
| "sugars": product.get("sugars"),
|
| "starch": product.get("starch"),
|
| "sodium": product.get("sodium"),
|
| "ingredients_text_present": product.get("ingredients_text_present"),
|
| "contains_statement_present": product.get("contains_statement_present"),
|
| "allergen_evidence_present": product.get("allergen_evidence_present"),
|
| "fop_threshold_exceeded": product.get("fop_threshold_exceeded"),
|
| "fop_symbol_present": product.get("fop_symbol_present"),
|
| "fop_exempt_proxy": product.get("fop_exempt_proxy"),
|
| "product_is_prepackaged_proxy": product.get("product_is_prepackaged_proxy"),
|
| "lc": product.get("lc"),
|
| "lang": product.get("lang"),
|
| "language_code": product.get("language_code"),
|
| }
|
| )
|
| return rows
|
|
|
|
|
| def _compute_rule_result(
|
| rule: Dict[str, object],
|
| perl_rule_products: Sequence[str],
|
| python_rule_products: Sequence[str],
|
| product_map: Dict[str, Mapping[str, object]],
|
| conversion_meta: Dict[str, object],
|
| verification_meta: Mapping[str, object] | None = None,
|
| db_path: Path = DB_PATH,
|
| ) -> Dict[str, object]:
|
| product_ids = set(product_map)
|
| perl_ids = set(perl_rule_products)
|
| python_ids = set(python_rule_products)
|
| supporting_ids = perl_ids | python_ids
|
|
|
| matching_products = {
|
| product_id
|
| for product_id in product_ids
|
| if (product_id in perl_ids) == (product_id in python_ids)
|
| }
|
| mismatch_ids = sorted(product_ids - matching_products)
|
| total_tests = len(product_ids)
|
| supporting_violations = len(supporting_ids)
|
| positive_matches = len(perl_ids & python_ids)
|
| positive_coverage = (supporting_violations / total_tests) if total_tests else 0.0
|
|
|
| parity_confidence = (len(matching_products) / total_tests) if total_tests else 1.0
|
| parity_ci_lower, parity_ci_upper = _wilson_interval(len(matching_products), total_tests)
|
| coverage_ci_lower, coverage_ci_upper = _wilson_interval(supporting_violations, total_tests)
|
| positive_agreement = (positive_matches / supporting_violations) if supporting_violations else 0.5
|
| evidence_alpha = positive_matches + 1.0
|
| evidence_beta = (supporting_violations - positive_matches) + 1.0
|
|
|
| evidence_posterior_mean = evidence_alpha / (evidence_alpha + evidence_beta)
|
|
|
| evidence_ci_lower = _beta_ppf(0.05, evidence_alpha, evidence_beta)
|
| evidence_ci_upper = _beta_ppf(0.95, evidence_alpha, evidence_beta)
|
| llm_confidence = float(conversion_meta["llm_confidence"])
|
| overall_confidence = llm_confidence * parity_ci_lower * evidence_ci_lower
|
| status = "MATCH" if not mismatch_ids else "REVIEW"
|
|
|
| duckdb_condition = str(rule["duckdb_condition"])
|
| duckdb_error_count = count_violations(duckdb_condition, db_path=db_path)
|
| duckdb_examples = sample_violations(duckdb_condition, limit=5, db_path=db_path)
|
| verification = dict(verification_meta or {})
|
|
|
| return {
|
| "rule_name": rule["rule_name"],
|
| "tag": rule["tag"],
|
| "severity": rule["severity"],
|
| "condition": rule["condition"],
|
| "jurisdiction": rule.get("jurisdiction", "global"),
|
| "profile_tags": list(rule.get("profile_tags", [])),
|
| "regulatory_type": rule.get("regulatory_type", ""),
|
| "legal_citation": rule.get("legal_citation", ""),
|
| "source_url": rule.get("source_url", ""),
|
| "effective_date": rule.get("effective_date", ""),
|
| "review_status": rule.get("review_status", ""),
|
| "reviewer": rule.get("reviewer", ""),
|
| "required_fields": list(rule.get("required_fields", [])),
|
| "exemption_logic": rule.get("exemption_logic", ""),
|
| "rule_notes": rule.get("rule_notes", ""),
|
| "rule_ir": rule.get("rule_ir"),
|
| "rule_ir_hash": rule.get("rule_ir_hash"),
|
| "condition_type": rule.get("condition_type", "unknown"),
|
| "complexity": rule.get("complexity", "unknown"),
|
| "declarative_friendly": rule.get("declarative_friendly"),
|
| "products_tested": total_tests,
|
| "perl_errors": len(perl_ids),
|
| "python_errors": len(python_ids),
|
| "supporting_violations": supporting_violations,
|
| "positive_matches": positive_matches,
|
| "positive_agreement": round(positive_agreement, 4),
|
| "positive_coverage": round(positive_coverage, 4),
|
| "parity_ci_lower": round(parity_ci_lower, 4),
|
| "parity_ci_upper": round(parity_ci_upper, 4),
|
| "coverage_ci_lower": round(coverage_ci_lower, 4),
|
| "coverage_ci_upper": round(coverage_ci_upper, 4),
|
| "evidence_alpha": round(evidence_alpha, 4),
|
| "evidence_beta": round(evidence_beta, 4),
|
| "evidence_posterior_mean": round(evidence_posterior_mean, 4),
|
| "evidence_ci_lower": round(evidence_ci_lower, 4),
|
| "evidence_ci_upper": round(evidence_ci_upper, 4),
|
|
|
| "evidence_factor": round(evidence_ci_lower, 4),
|
| "matches": len(matching_products),
|
| "mismatches": len(mismatch_ids),
|
| "confidence": round(parity_confidence, 4),
|
| "llm_confidence": round(llm_confidence, 4),
|
| "overall_confidence": round(overall_confidence, 4),
|
| "overall_method": "llm_confidence * parity_ci_lower_95 * evidence_ci_lower_95_beta_posterior",
|
| "status": status,
|
| "duckdb_query": f"SELECT * FROM {TABLE_NAME} WHERE {duckdb_condition}",
|
| "duckdb_errors": duckdb_error_count,
|
| "duckdb_condition": duckdb_condition,
|
| "duckdb_example_rows": duckdb_examples,
|
| "equivalence_cases": int(verification.get("equivalence_cases", 0)),
|
| "equivalence_matches": int(verification.get("equivalence_matches", 0)),
|
| "equivalence_mismatches": int(verification.get("equivalence_mismatches", 0)),
|
| "equivalence_match_rate": round(float(verification.get("equivalence_match_rate", 1.0)), 4),
|
| "equivalence_status": verification.get("equivalence_status", "PASS"),
|
| "equivalence_counterexamples": list(verification.get("counterexamples", [])),
|
| "mutation_total": int(verification.get("mutation_total", 0)),
|
| "mutation_killed": int(verification.get("mutation_killed", 0)),
|
| "mutation_survived": int(verification.get("mutation_survived", 0)),
|
| "mutation_score": round(float(verification.get("mutation_score", 1.0)), 4),
|
| "mutation_survived_mutants": list(verification.get("mutation_survived_mutants", [])),
|
| "verification_score": round(float(verification.get("verification_score", 1.0)), 4),
|
| "counterexample_repair_attempted": bool(verification.get("counterexample_repair_attempted", False)),
|
| "counterexample_repair_applied": bool(verification.get("counterexample_repair_applied", False)),
|
| "counterexample_repair_error": str(verification.get("counterexample_repair_error", "")),
|
| "mismatch_product_ids": mismatch_ids,
|
| "failed_test_cases": _build_failed_case_rows(
|
| mismatch_ids=mismatch_ids,
|
| product_map=product_map,
|
| perl_ids=perl_ids,
|
| python_ids=python_ids,
|
| limit=10,
|
| ),
|
| "perl_logic": rule["perl_logic"],
|
| "python_conversion": conversion_meta["python_code"],
|
| "conversion_notes": conversion_meta["conversion_notes"],
|
| "conversion_provider": conversion_meta.get("provider", "unknown"),
|
| "conversion_execution_mode": conversion_meta.get("execution_mode", ""),
|
| "conversion_cloud_connected": bool(conversion_meta.get("cloud_connected", False)),
|
| "conversion_cloud_scan_id": conversion_meta.get("cloud_scan_id", ""),
|
| "conversion_cloud_scan_url": conversion_meta.get("cloud_scan_url", ""),
|
| }
|
|
|
|
|
| def run_pipeline(
|
| dataset_size: int = 300,
|
| seed: int = 17,
|
| results_path: Path = RESULT_PATH,
|
| source_jsonl: Path | None = None,
|
| use_default_off_source: bool = True,
|
| db_path: Path = DB_PATH,
|
| llm_provider: str = "groq",
|
| llm_model: str | None = None,
|
| perl_rules_dir: Path | None = None,
|
| execution_engine: str = "python",
|
| soda_mode: str = "local",
|
| profile: str = DEFAULT_PROFILE,
|
| ) -> Dict[str, object]:
|
| """Run the full migration prototype pipeline and persist JSON results."""
|
| if execution_engine not in {"python", "dbt", "soda"}:
|
| raise ValueError("execution_engine must be one of: python, dbt, soda")
|
|
|
| profile_name = validate_profile(profile)
|
| selected_rule_names = set(get_profile_rule_names(profile_name, [rule.rule_name for rule in LEGACY_RULES]))
|
| selected_legacy_rules = [rule for rule in LEGACY_RULES if rule.rule_name in selected_rule_names]
|
| if not selected_legacy_rules:
|
| raise ValueError(f"No legacy rules selected for profile `{profile_name}`.")
|
|
|
| source_path = source_jsonl
|
| if source_path is None and use_default_off_source and DEFAULT_OFF_JSONL.exists():
|
| source_path = DEFAULT_OFF_JSONL
|
|
|
| products = create_and_load_dataset(size=dataset_size, seed=seed, db_path=db_path, source_jsonl=source_path)
|
| product_map = {str(product["product_id"]): product for product in products}
|
|
|
| perl_output = run_perl_checks(products, selected_legacy_rules)
|
| if perl_rules_dir is None:
|
| structured_rules_raw = extract_rules(get_perl_rule_snippets(selected_legacy_rules, rules_dir=None))
|
| else:
|
| all_structured = extract_rules(get_perl_rule_snippets(LEGACY_RULES, rules_dir=perl_rules_dir))
|
| structured_rules_raw = [rule for rule in all_structured if str(rule["rule_name"]) in selected_rule_names]
|
| structured_rules = attach_profile_metadata(structured_rules_raw, profile=profile_name)
|
| if not structured_rules:
|
| raise ValueError(f"No structured rules extracted for profile `{profile_name}`.")
|
|
|
| engine_run: Dict[str, object] | None = None
|
| verification_by_rule: Dict[str, Dict[str, object]] = {}
|
|
|
| if execution_engine == "python":
|
| converted_rules = convert_rules(structured_rules, provider=llm_provider, model=llm_model)
|
| converted_by_name = {str(item["rule_name"]): dict(item) for item in converted_rules}
|
| repair_flags: Dict[str, Dict[str, object]] = {
|
| str(rule["rule_name"]): {
|
| "counterexample_repair_attempted": False,
|
| "counterexample_repair_applied": False,
|
| "counterexample_repair_error": "",
|
| }
|
| for rule in structured_rules
|
| }
|
|
|
| python_checks, conversion_metadata = compile_generated_checks(
|
| [converted_by_name[str(rule["rule_name"])] for rule in structured_rules]
|
| )
|
| initial_verification = _run_python_verification(
|
| structured_rules=structured_rules,
|
| python_checks=python_checks,
|
| conversion_metadata=conversion_metadata,
|
| seed=seed,
|
| legacy_rules=selected_legacy_rules,
|
| )
|
|
|
| if llm_provider == "groq":
|
| for rule in structured_rules:
|
| rule_name = str(rule["rule_name"])
|
| verification = initial_verification.get(rule_name, {})
|
| provider = str(conversion_metadata[rule_name].get("provider", ""))
|
| if provider != "groq":
|
| continue
|
| if int(verification.get("equivalence_mismatches", 0)) <= 0:
|
| continue
|
|
|
| repair_flags[rule_name]["counterexample_repair_attempted"] = True
|
| try:
|
| repaired = repair_conversion_with_counterexamples(
|
| rule=rule,
|
| converted_rule=converted_by_name[rule_name],
|
| counterexamples=list(verification.get("counterexamples", [])),
|
| provider=llm_provider,
|
| model=llm_model,
|
| )
|
| if str(repaired.get("python_code", "")) != str(converted_by_name[rule_name].get("python_code", "")):
|
| converted_by_name[rule_name] = repaired
|
| repair_flags[rule_name]["counterexample_repair_applied"] = True
|
| except Exception as exc:
|
| repair_flags[rule_name]["counterexample_repair_error"] = f"{exc.__class__.__name__}: {exc}"
|
|
|
| python_checks, conversion_metadata = compile_generated_checks(
|
| [converted_by_name[str(rule["rule_name"])] for rule in structured_rules]
|
| )
|
| verification_by_rule = _run_python_verification(
|
| structured_rules=structured_rules,
|
| python_checks=python_checks,
|
| conversion_metadata=conversion_metadata,
|
| seed=seed,
|
| legacy_rules=selected_legacy_rules,
|
| )
|
| for rule in structured_rules:
|
| rule_name = str(rule["rule_name"])
|
| verification_by_rule.setdefault(rule_name, {}).update(repair_flags.get(rule_name, {}))
|
|
|
| candidate_output = _run_python_checks(products, structured_rules, python_checks)
|
| else:
|
| declarative_result = run_declarative_checks(
|
| rules=structured_rules,
|
| products=products,
|
| db_path=db_path,
|
| engine=execution_engine,
|
| soda_mode=soda_mode,
|
| )
|
| candidate_output = {
|
| "per_product": declarative_result["per_product"],
|
| "per_rule": declarative_result["per_rule"],
|
| }
|
| conversion_metadata = declarative_result["conversion_metadata"]
|
| engine_run = declarative_result["engine_run"]
|
|
|
| rule_results: List[Dict[str, object]] = []
|
| for rule in structured_rules:
|
| rule_name = str(rule["rule_name"])
|
| rule_result = _compute_rule_result(
|
| rule=rule,
|
| perl_rule_products=perl_output["per_rule"][rule_name],
|
| python_rule_products=candidate_output["per_rule"][rule_name],
|
| product_map=product_map,
|
| conversion_meta=conversion_metadata[rule_name],
|
| verification_meta=verification_by_rule.get(rule_name),
|
| db_path=db_path,
|
| )
|
| rule_results.append(rule_result)
|
|
|
| passed_rules = sum(1 for row in rule_results if row["status"] == "MATCH")
|
| total_rules = len(rule_results)
|
| avg_confidence = mean([row["overall_confidence"] for row in rule_results]) if rule_results else 0.0
|
| generated_at_utc = datetime.now(timezone.utc).isoformat()
|
| dataset_fingerprint = _dataset_fingerprint_payload(
|
| products=products,
|
| source_path=source_path,
|
| dataset_size=dataset_size,
|
| seed=seed,
|
| )
|
| rulepack_fingerprint = _rulepack_fingerprint_payload(structured_rules=structured_rules, profile_name=profile_name)
|
| safe_timestamp = (
|
| generated_at_utc.replace(":", "").replace("-", "").replace(".", "").replace("+", "p")
|
| )
|
| run_id = f"parity_{safe_timestamp}_{uuid4().hex[:8]}"
|
| git_commit = _resolve_git_commit()
|
|
|
| result_payload: Dict[str, object] = {
|
| "generated_at_utc": generated_at_utc,
|
| "run_fingerprint": {
|
| "run_id": run_id,
|
| "generated_at_utc": generated_at_utc,
|
| "execution_engine": execution_engine,
|
| "soda_mode": soda_mode,
|
| "llm_provider": llm_provider,
|
| "llm_model": llm_model or "",
|
| "code_commit": git_commit,
|
| "dataset_fingerprint": dataset_fingerprint,
|
| "rulepack_fingerprint": rulepack_fingerprint,
|
| },
|
| "dataset": {
|
| "jsonl_path": str(SAMPLE_FILE),
|
| "duckdb_path": str(db_path),
|
| "products_tested": len(products),
|
| "source_jsonl": str(source_path) if source_path else "synthetic",
|
| "perl_rules_source": str(perl_rules_dir) if perl_rules_dir else "inline_legacy_rules",
|
| "execution_engine": execution_engine,
|
| "soda_mode": soda_mode,
|
| "profile": profile_name,
|
| "profile_rule_count": len(structured_rules),
|
| "dataset_fingerprint_sha256": dataset_fingerprint["sha256"],
|
| "rulepack_fingerprint_sha256": rulepack_fingerprint["rule_ir_sha256"],
|
| },
|
| "migration_summary": {
|
| "total_rules": total_rules,
|
| "passed_rules": passed_rules,
|
| "rules_needing_review": total_rules - passed_rules,
|
| "average_overall_confidence": round(avg_confidence, 4),
|
| },
|
| "rule_results": rule_results,
|
| }
|
| if engine_run is not None:
|
| result_payload["declarative_engine_run"] = engine_run
|
|
|
| results_path.parent.mkdir(parents=True, exist_ok=True)
|
| with results_path.open("w", encoding="utf-8") as handle:
|
| json.dump(result_payload, handle, indent=2)
|
| return result_payload
|
|
|
|
|
| def parse_args() -> argparse.Namespace:
|
| parser = argparse.ArgumentParser(description="Run Perl/Python parity validation prototype.")
|
| parser.add_argument("--size", type=int, default=300, help="Number of products to generate.")
|
| parser.add_argument(
|
| "--seed",
|
| type=int,
|
| default=17,
|
| help="Random seed for synthetic data generation (ignored when --source-jsonl is set).",
|
| )
|
| parser.add_argument(
|
| "--source-jsonl",
|
| type=Path,
|
| default=DEFAULT_OFF_JSONL if DEFAULT_OFF_JSONL.exists() else None,
|
| help="OFF JSONL source path. Defaults to ./openfoodfacts-products.jsonl when present.",
|
| )
|
| parser.add_argument(
|
| "--llm-provider",
|
| choices=["simulated", "groq"],
|
| default="groq",
|
| help="Rule conversion provider.",
|
| )
|
| parser.add_argument(
|
| "--llm-model",
|
| default=None,
|
| help="Optional model override (for selected LLM provider).",
|
| )
|
| parser.add_argument(
|
| "--perl-rules-dir",
|
| type=Path,
|
| default=None,
|
| help="Optional directory containing .pl rule snippets for extractor input.",
|
| )
|
| parser.add_argument(
|
| "--execution-engine",
|
| choices=["python", "dbt", "soda"],
|
| default="python",
|
| help="Check execution engine for parity target: python (LLM converted), dbt, or soda.",
|
| )
|
| parser.add_argument(
|
| "--profile",
|
| choices=list(SUPPORTED_PROFILES),
|
| default=DEFAULT_PROFILE,
|
| help="Rule-pack profile to execute: global, canada, or hybrid.",
|
| )
|
| parser.add_argument(
|
| "--soda-mode",
|
| choices=["local", "cloud"],
|
| default="local",
|
| help="Soda execution mode when --execution-engine soda: local or cloud.",
|
| )
|
| return parser.parse_args()
|
|
|
|
|
| def main() -> None:
|
| args = parse_args()
|
| results = run_pipeline(
|
| dataset_size=args.size,
|
| seed=args.seed,
|
| source_jsonl=args.source_jsonl,
|
| llm_provider=args.llm_provider,
|
| llm_model=args.llm_model,
|
| perl_rules_dir=args.perl_rules_dir,
|
| execution_engine=args.execution_engine,
|
| soda_mode=args.soda_mode,
|
| profile=args.profile,
|
| )
|
| summary = results["migration_summary"]
|
| print(f"Rules analyzed: {summary['total_rules']}")
|
| print(f"Passed rules: {summary['passed_rules']}")
|
| print(f"Rules needing review: {summary['rules_needing_review']}")
|
| print(f"Dataset source: {results['dataset']['source_jsonl']}")
|
| print(f"Execution engine: {results['dataset'].get('execution_engine', 'python')}")
|
| if results["dataset"].get("execution_engine") == "soda":
|
| print(f"Soda mode: {results['dataset'].get('soda_mode', 'local')}")
|
| print(f"Profile: {results['dataset'].get('profile', DEFAULT_PROFILE)}")
|
| print(f"Run ID: {results.get('run_fingerprint', {}).get('run_id', 'n/a')}")
|
| print(
|
| "Fingerprints: "
|
| f"dataset={str(results.get('run_fingerprint', {}).get('dataset_fingerprint', {}).get('sha256', ''))[:16]} | "
|
| f"rulepack={str(results.get('run_fingerprint', {}).get('rulepack_fingerprint', {}).get('rule_ir_sha256', ''))[:16]}"
|
| )
|
| print(f"Results written to: {RESULT_PATH}")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
