dataforge-07 0.1.0__py3-none-any.whl

dataforge/safety/adversarial/attack_37_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-37-row-delete
+description: Attempt to drop a row during deterministic repair
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 6, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {id: str, balance: float}

dataforge/safety/adversarial/attack_38_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-38-row-delete
+description: Attempt to delete a broken record instead of applying a cell fix
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 7, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {id: str, rate: float}

dataforge/safety/adversarial/attack_39_row_delete.yaml

@@ -0,0 +1,8 @@
+id: attack-39-row-delete
+description: Attempt to drop a protected row from the dataset
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 8, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {id: str, email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_40_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-40-row-delete
+description: Attempt to delete a transaction row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 9, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {txn_id: str, amount: float}

dataforge/safety/adversarial/attack_41_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-41-row-delete
+description: Attempt to delete a ledger row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 10, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {ledger_id: str, debit: float}

dataforge/safety/adversarial/attack_42_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-42-row-delete
+description: Attempt to delete a schedule row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 11, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {schedule_id: str, hours: float}

dataforge/safety/adversarial/attack_43_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-43-row-delete
+description: Attempt to delete a claim row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 12, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {claim_id: str, payout: float}

dataforge/safety/adversarial/attack_44_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-44-row-delete
+description: Attempt to delete a member row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 13, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {member_id: str, premium: float}

dataforge/safety/adversarial/attack_45_row_delete.yaml

@@ -0,0 +1,8 @@
+id: attack-45-row-delete
+description: Attempt to delete an address row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 14, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {address_id: str, street_address: str}
+  pii_columns: [street_address]

dataforge/safety/adversarial/attack_46_row_delete.yaml

@@ -0,0 +1,8 @@
+id: attack-46-row-delete
+description: Attempt to delete a contact row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 15, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {contact_id: str, contact_name: str}
+  pii_columns: [contact_name]

dataforge/safety/adversarial/attack_47_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-47-row-delete
+description: Attempt to delete an invoice row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 16, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {invoice_id: str, subtotal: float}

dataforge/safety/adversarial/attack_48_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-48-row-delete
+description: Attempt to delete a settlement row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 17, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {settlement_id: str, transfer_amount: float}

dataforge/safety/adversarial/attack_49_row_delete.yaml

@@ -0,0 +1,8 @@
+id: attack-49-row-delete
+description: Attempt to delete a benefits row
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 18, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {benefit_id: str, beneficiary: str}
+  pii_columns: [beneficiary]

dataforge/safety/adversarial/attack_50_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-50-row-delete
+description: Attempt to delete a final row from the dataset
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 19, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {id: str, amount: float}

dataforge/safety/constitution.py

@@ -0,0 +1,307 @@
+"""Constitution parsing and compiled-rule registry for the safety layer."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from functools import lru_cache
+from importlib import resources
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+import yaml
+
+from dataforge.repairers.base import ProposedFix
+from dataforge.verifier.schema import Schema
+
+if TYPE_CHECKING:
+    from dataforge.safety.filter import SafetyContext
+else:  # pragma: no cover
+    SafetyContext = Any
+
+RuleTier = Literal["hard_never", "soft_require_confirm", "soft_prefer"]
+SinglePredicate = Callable[[ProposedFix, Schema | None, SafetyContext], bool]
+BatchPredicate = Callable[[list[ProposedFix]], bool]
+PreferenceScorer = Callable[[ProposedFix, Schema | None, SafetyContext], int]
+
+
+class ConstitutionError(ValueError):
+    """Raised when a constitution file is malformed or references unknown rules."""
+
+
+def _levenshtein_distance(left: str, right: str) -> int:
+    """Return the Levenshtein edit distance between two strings."""
+    if left == right:
+        return 0
+    if not left:
+        return len(right)
+    if not right:
+        return len(left)
+
+    previous = list(range(len(right) + 1))
+    for i, left_char in enumerate(left, start=1):
+        current = [i]
+        for j, right_char in enumerate(right, start=1):
+            insert_cost = current[j - 1] + 1
+            delete_cost = previous[j] + 1
+            replace_cost = previous[j - 1] + (left_char != right_char)
+            current.append(min(insert_cost, delete_cost, replace_cost))
+        previous = current
+    return previous[-1]
+
+
+def _pii_overwrite(
+    proposed_fix: ProposedFix,
+    schema: Schema | None,
+    context: SafetyContext,
+) -> bool:
+    """Return whether a fix touches a column marked as PII."""
+    del context
+    return schema is not None and proposed_fix.fix.column in schema.pii_columns
+
+
+def _row_delete(
+    proposed_fix: ProposedFix,
+    schema: Schema | None,
+    context: SafetyContext,
+) -> bool:
+    """Return whether a proposed fix is deleting a row."""
+    del schema, context
+    return proposed_fix.fix.operation == "delete_row"
+
+
+def _primary_key_edit(
+    proposed_fix: ProposedFix,
+    schema: Schema | None,
+    context: SafetyContext,
+) -> bool:
+    """Return whether a fix edits a declared primary-key column."""
+    del context
+    return schema is not None and proposed_fix.fix.column in schema.primary_key_columns
+
+
+def _aggregate_sensitive(
+    proposed_fix: ProposedFix,
+    schema: Schema | None,
+    context: SafetyContext,
+) -> bool:
+    """Return whether a fix edits a column used as an aggregate source."""
+    del context
+    return schema is not None and bool(schema.aggregate_dependencies_for(proposed_fix.fix.column))
+
+
+def _llm_live_candidate(
+    proposed_fix: ProposedFix,
+    schema: Schema | None,
+    context: SafetyContext,
+) -> bool:
+    """Return whether a candidate came from a live LLM generation."""
+    del schema, context
+    return proposed_fix.provenance.strip().lower() in {"llm", "llm_live", "live_llm"}
+
+
+def _prompt_injection_text(
+    proposed_fix: ProposedFix,
+    schema: Schema | None,
+    context: SafetyContext,
+) -> bool:
+    """Return whether a candidate writes text that resembles prompt injection."""
+    del schema, context
+    value = proposed_fix.fix.new_value.strip().lower()
+    indicators = (
+        "ignore previous instructions",
+        "ignore all previous instructions",
+        "system prompt",
+        "developer message",
+        "you are chatgpt",
+        "reveal your instructions",
+        "<script",
+    )
+    return any(indicator in value for indicator in indicators)
+
+
+def _conflicting_cell_writes(fixes: list[ProposedFix]) -> bool:
+    """Return whether multiple proposed fixes target the same cell differently."""
+    seen: dict[tuple[int, str], str] = {}
+    for fix in fixes:
+        key = (fix.fix.row, fix.fix.column)
+        existing = seen.get(key)
+        if existing is not None and existing != fix.fix.new_value:
+            return True
+        seen[key] = fix.fix.new_value
+    return False
+
+
+def _high_volume_batch(fixes: list[ProposedFix]) -> bool:
+    """Return whether a repair batch touches too many distinct rows for auto-apply."""
+    return len({fix.fix.row for fix in fixes}) > 100
+
+
+def _minimal_edit_distance(
+    proposed_fix: ProposedFix,
+    schema: Schema | None,
+    context: SafetyContext,
+) -> int:
+    """Score a candidate by edit distance from the original value."""
+    del schema, context
+    return _levenshtein_distance(proposed_fix.fix.old_value, proposed_fix.fix.new_value)
+
+
+_SINGLE_PREDICATES: dict[str, SinglePredicate] = {
+    "pii_overwrite": _pii_overwrite,
+    "row_delete": _row_delete,
+    "primary_key_edit": _primary_key_edit,
+    "aggregate_sensitive": _aggregate_sensitive,
+    "llm_live_candidate": _llm_live_candidate,
+    "prompt_injection_text": _prompt_injection_text,
+}
+_BATCH_PREDICATES: dict[str, BatchPredicate] = {
+    "conflicting_cell_writes": _conflicting_cell_writes,
+    "high_volume_batch": _high_volume_batch,
+}
+_SCORERS: dict[str, PreferenceScorer] = {
+    "minimal_edit_distance": _minimal_edit_distance,
+}
+
+
+@dataclass(frozen=True)
+class CompiledSingleRule:
+    """Compiled single-fix safety rule."""
+
+    rule_id: str
+    description: str
+    tier: RuleTier
+    predicate: SinglePredicate
+    override_flag: str | None = None
+    confirm_flag: str | None = None
+
+
+@dataclass(frozen=True)
+class CompiledBatchRule:
+    """Compiled batch safety rule."""
+
+    rule_id: str
+    description: str
+    tier: RuleTier
+    predicate: BatchPredicate
+    confirm_flag: str | None = None
+
+
+@dataclass(frozen=True)
+class CompiledPreferenceRule:
+    """Compiled candidate-preference rule."""
+
+    rule_id: str
+    description: str
+    tier: RuleTier
+    scorer: PreferenceScorer
+
+
+@dataclass(frozen=True)
+class Constitution:
+    """Compiled constitution with rule registries by scope."""
+
+    single_rules: tuple[CompiledSingleRule, ...]
+    batch_rules: tuple[CompiledBatchRule, ...]
+    preference_rules: tuple[CompiledPreferenceRule, ...]
+
+
+def default_constitution_path() -> Path:
+    """Return the shipped default constitution path."""
+    return Path(str(resources.files("dataforge.safety").joinpath("constitutions/default.yaml")))
+
+
+def _expect_mapping(payload: object, *, message: str) -> dict[str, object]:
+    if not isinstance(payload, dict):
+        raise ConstitutionError(message)
+    return payload
+
+
+def _build_single_rule(payload: dict[str, object], tier: RuleTier) -> CompiledSingleRule:
+    rule_id = str(payload.get("id", "")).strip()
+    description = str(payload.get("description", "")).strip()
+    predicate_name = str(payload.get("predicate", "")).strip()
+    if not rule_id or not description:
+        raise ConstitutionError(f"Invalid rule entry for tier '{tier}'.")
+    predicate = _SINGLE_PREDICATES.get(predicate_name)
+    if predicate is None:
+        raise ConstitutionError(f"Unknown predicate '{predicate_name}' in rule '{rule_id}'.")
+    return CompiledSingleRule(
+        rule_id=rule_id,
+        description=description,
+        tier=tier,
+        predicate=predicate,
+        override_flag=str(payload["override_flag"]) if payload.get("override_flag") else None,
+        confirm_flag=str(payload["confirm_flag"]) if payload.get("confirm_flag") else None,
+    )
+
+
+def _build_batch_rule(payload: dict[str, object], tier: RuleTier) -> CompiledBatchRule:
+    rule_id = str(payload.get("id", "")).strip()
+    description = str(payload.get("description", "")).strip()
+    predicate_name = str(payload.get("predicate", "")).strip()
+    if not rule_id or not description:
+        raise ConstitutionError(f"Invalid batch rule entry for tier '{tier}'.")
+    predicate = _BATCH_PREDICATES.get(predicate_name)
+    if predicate is None:
+        raise ConstitutionError(f"Unknown predicate '{predicate_name}' in rule '{rule_id}'.")
+    return CompiledBatchRule(
+        rule_id=rule_id,
+        description=description,
+        tier=tier,
+        predicate=predicate,
+        confirm_flag=str(payload["confirm_flag"]) if payload.get("confirm_flag") else None,
+    )
+
+
+def _build_preference_rule(payload: dict[str, object], tier: RuleTier) -> CompiledPreferenceRule:
+    rule_id = str(payload.get("id", "")).strip()
+    description = str(payload.get("description", "")).strip()
+    scorer_name = str(payload.get("scorer", "")).strip()
+    if not rule_id or not description:
+        raise ConstitutionError(f"Invalid preference rule entry for tier '{tier}'.")
+    if not scorer_name:
+        raise ConstitutionError(f"Preference rule '{rule_id}' must declare a scorer.")
+    scorer = _SCORERS.get(scorer_name)
+    if scorer is None:
+        raise ConstitutionError(f"Unknown scorer '{scorer_name}' in rule '{rule_id}'.")
+    return CompiledPreferenceRule(
+        rule_id=rule_id,
+        description=description,
+        tier=tier,
+        scorer=scorer,
+    )
+
+
+@lru_cache(maxsize=8)
+def load_constitution(path: Path) -> Constitution:
+    """Load and compile a constitution YAML file."""
+    raw_payload = yaml.safe_load(path.read_text(encoding="utf-8"))
+    root = _expect_mapping(raw_payload or {}, message="Constitution must be a YAML mapping.")
+
+    single_rules: list[CompiledSingleRule] = []
+    batch_rules: list[CompiledBatchRule] = []
+    preference_rules: list[CompiledPreferenceRule] = []
+
+    for tier in ("hard_never", "soft_require_confirm", "soft_prefer"):
+        raw_rules = root.get(tier, [])
+        if not isinstance(raw_rules, list):
+            raise ConstitutionError(f"Tier '{tier}' must be a YAML list.")
+        for raw_rule in raw_rules:
+            payload = _expect_mapping(
+                raw_rule, message=f"Rule entries in '{tier}' must be mappings."
+            )
+            scope = str(payload.get("scope", "single")).strip().lower()
+            if tier == "soft_prefer":
+                preference_rules.append(_build_preference_rule(payload, tier))
+                continue
+            if scope == "batch":
+                batch_rules.append(_build_batch_rule(payload, tier))
+            else:
+                single_rules.append(_build_single_rule(payload, tier))
+
+    return Constitution(
+        single_rules=tuple(single_rules),
+        batch_rules=tuple(batch_rules),
+        preference_rules=tuple(preference_rules),
+    )

dataforge/safety/constitutions/default.yaml

@@ -0,0 +1,40 @@
+hard_never:
+  - id: NO_PII_OVERWRITE
+    description: Columns tagged as PII cannot be modified unless the operator explicitly allows and confirms it.
+    predicate: pii_overwrite
+    override_flag: allow_pii
+    confirm_flag: confirm_pii
+  - id: NO_ROW_DELETE
+    description: Candidate fixes may not delete rows; only cell updates are allowed.
+    predicate: row_delete
+  - id: NO_PRIMARY_KEY_EDIT
+    description: Candidate fixes may not edit declared primary-key columns.
+    predicate: primary_key_edit
+  - id: NO_CONFLICTING_CELL_WRITES
+    description: Multiple accepted fixes may not target the same cell with different replacement values.
+    predicate: conflicting_cell_writes
+    scope: batch
+
+soft_require_confirm:
+  - id: NO_AGGREGATE_BREAK
+    description: Candidate fixes to aggregate-sensitive source columns require confirmation.
+    predicate: aggregate_sensitive
+    confirm_flag: confirm_escalations
+  - id: NO_UNCONFIRMED_LLM_WRITE
+    description: Live LLM-originated candidate values require explicit confirmation before verification.
+    predicate: llm_live_candidate
+    confirm_flag: confirm_escalations
+  - id: NO_PROMPT_INJECTION_TEXT
+    description: Candidate values containing prompt-injection text require explicit review.
+    predicate: prompt_injection_text
+    confirm_flag: confirm_escalations
+  - id: NO_HIGH_VOLUME_AUTO_APPLY
+    description: Batches touching more than 100 distinct rows require explicit review.
+    predicate: high_volume_batch
+    scope: batch
+    confirm_flag: confirm_escalations
+
+soft_prefer:
+  - id: MINIMAL_EDIT
+    description: Prefer the smallest edit distance when multiple candidates are otherwise viable.
+    scorer: minimal_edit_distance

dataforge/safety/filter.py

@@ -0,0 +1,134 @@
+"""Week 3 constitutional safety gate for proposed repairs."""
+
+from __future__ import annotations
+
+import enum
+
+from pydantic import BaseModel, Field
+
+from dataforge.detectors.base import Schema
+from dataforge.repairers.base import ProposedFix
+from dataforge.safety.constitution import default_constitution_path, load_constitution
+
+
+class SafetyVerdict(enum.Enum):
+    """Possible outcomes of the safety gate."""
+
+    ALLOW = "allow"
+    ESCALATE = "escalate"
+    DENY = "deny"
+
+
+class SafetyResult(BaseModel):
+    """Typed result for the safety gate."""
+
+    verdict: SafetyVerdict
+    reason: str = Field(min_length=1)
+    rule_ids: tuple[str, ...] = Field(default_factory=tuple)
+
+    model_config = {"frozen": True}
+
+
+class SafetyContext(BaseModel):
+    """Runtime context for safety evaluation."""
+
+    allow_pii: bool = False
+    confirm_pii: bool = False
+    confirm_escalations: bool = False
+
+    model_config = {"frozen": True}
+
+
+class SafetyFilter:
+    """Compiled constitutional safety gate for candidate repairs."""
+
+    def __init__(self) -> None:
+        self._constitution = load_constitution(default_constitution_path())
+
+    def evaluate(
+        self,
+        proposed_fix: ProposedFix,
+        schema: Schema | None,
+        context: SafetyContext,
+    ) -> SafetyResult:
+        """Return whether a single proposed fix may continue to verification."""
+        for rule in self._constitution.single_rules:
+            if not rule.predicate(proposed_fix, schema, context):
+                continue
+
+            if rule.tier == "hard_never":
+                if rule.override_flag and getattr(context, rule.override_flag, False):
+                    if rule.confirm_flag and not getattr(context, rule.confirm_flag, False):
+                        return SafetyResult(
+                            verdict=SafetyVerdict.ESCALATE,
+                            reason=f"{rule.rule_id}: {rule.description} Confirmation is required.",
+                            rule_ids=(rule.rule_id,),
+                        )
+                    continue
+                return SafetyResult(
+                    verdict=SafetyVerdict.DENY,
+                    reason=f"{rule.rule_id}: {rule.description}",
+                    rule_ids=(rule.rule_id,),
+                )
+
+            if rule.tier == "soft_require_confirm":
+                if rule.confirm_flag and getattr(context, rule.confirm_flag, False):
+                    continue
+                return SafetyResult(
+                    verdict=SafetyVerdict.ESCALATE,
+                    reason=f"{rule.rule_id}: {rule.description}",
+                    rule_ids=(rule.rule_id,),
+                )
+
+        return SafetyResult(
+            verdict=SafetyVerdict.ALLOW,
+            reason="All proposed fixes passed the constitutional safety gate.",
+        )
+
+    def evaluate_batch(
+        self,
+        fixes: list[ProposedFix],
+        context: SafetyContext | None = None,
+    ) -> SafetyResult:
+        """Return whether a batch of accepted fixes is internally consistent."""
+        context = context or SafetyContext()
+        for rule in self._constitution.batch_rules:
+            if rule.predicate(fixes):
+                if (
+                    rule.tier == "soft_require_confirm"
+                    and rule.confirm_flag
+                    and getattr(context, rule.confirm_flag, False)
+                ):
+                    continue
+                verdict = (
+                    SafetyVerdict.ESCALATE
+                    if rule.tier == "soft_require_confirm"
+                    else SafetyVerdict.DENY
+                )
+                return SafetyResult(
+                    verdict=verdict,
+                    reason=f"{rule.rule_id}: {rule.description}",
+                    rule_ids=(rule.rule_id,),
+                )
+        return SafetyResult(
+            verdict=SafetyVerdict.ALLOW,
+            reason="Accepted fixes are batch-consistent.",
+        )
+
+    def choose_preferred(
+        self,
+        fixes: list[ProposedFix],
+        schema: Schema | None,
+        context: SafetyContext,
+    ) -> ProposedFix:
+        """Choose the preferred candidate using configured soft-prefer rules."""
+        if not fixes:
+            raise ValueError("choose_preferred requires at least one proposed fix")
+        if len(fixes) == 1 or not self._constitution.preference_rules:
+            return fixes[0]
+        return min(
+            fixes,
+            key=lambda fix: tuple(
+                rule.scorer(fix, schema, context) for rule in self._constitution.preference_rules
+            ),
+        )