dataforge-07 0.1.0__py3-none-any.whl

dataforge/repairers/fd_violation.py

@@ -0,0 +1,225 @@
+"""Repairer for functional-dependency violations."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections import Counter
+from pathlib import Path
+from typing import TYPE_CHECKING, TypedDict
+
+from dataforge.detectors.base import FunctionalDependency, Issue, Schema
+from dataforge.repairers.base import ProposedFix, ProvenanceLiteral, RetryContext
+from dataforge.table import TableLike, cell_value, column_names, row_count
+from dataforge.transactions.log import sha256_bytes
+from dataforge.transactions.txn import CellFix
+
+if TYPE_CHECKING:
+    from dataforge.agent.providers import Message
+
+
+async def complete(messages: list[Message], *, model: str, temperature: float) -> str:
+    """Lazy provider wrapper kept patchable for tests."""
+    try:
+        from dataforge.agent.providers import complete as provider_complete
+    except ImportError as exc:
+        raise RuntimeError(
+            "LLM-backed FD repair requires the provider extra: pip install 'dataforge[providers]'."
+        ) from exc
+    return await provider_complete(messages, model=model, temperature=temperature)
+
+
+def _normalize_cell(value: object) -> str:
+    """Normalize a DataFrame cell into a comparable string."""
+    return str(value)
+
+
+class _Choice(TypedDict):
+    """Chosen value plus its provenance."""
+
+    value: str
+    provenance: ProvenanceLiteral
+
+
+class FDViolationRepairer:
+    """Repair FD violations with majority rules and cached LLM fallback."""
+
+    def __init__(
+        self,
+        *,
+        cache_dir: Path | None,
+        allow_llm: bool = False,
+        model: str = "gemini-2.0-flash",
+    ) -> None:
+        self._cache_dir = cache_dir
+        self._allow_llm = allow_llm
+        self._model = model
+
+    def _propose(
+        self,
+        issue: Issue,
+        df: TableLike,
+        schema: Schema | None,
+        retry_context: RetryContext | None,
+    ) -> ProposedFix | None:
+        """Return a repair proposal for an FD-violation issue."""
+        del retry_context
+        if issue.issue_type != "fd_violation" or schema is None:
+            return None
+        if issue.row >= row_count(df) or issue.column not in column_names(df):
+            return None
+
+        for fd in schema.functional_dependencies:
+            if fd.dependent != issue.column:
+                continue
+            group_df = self._matching_group(df, issue.row, fd)
+            if group_df is None:
+                continue
+
+            counts = Counter(row[fd.dependent] for row in group_df)
+            if len(counts) <= 1:
+                continue
+
+            old_value = cell_value(df, issue.row, issue.column)
+            chosen_majority = self._deterministic_choice(counts)
+            if chosen_majority is not None:
+                if chosen_majority == old_value:
+                    return None
+                return self._build_fix(issue, old_value, chosen_majority, "deterministic")
+
+            llm_choice = self._choose_with_cache(fd, group_df, old_value)
+            if llm_choice is None or llm_choice["value"] == old_value:
+                return None
+            return self._build_fix(issue, old_value, llm_choice["value"], llm_choice["provenance"])
+
+        return None
+
+    def propose(
+        self,
+        issue: Issue,
+        df: TableLike,
+        schema: Schema | None,
+        retry_context: RetryContext | None = None,
+    ) -> ProposedFix | None:
+        """Return a repair proposal for an FD-violation issue."""
+        return self._propose(issue, df, schema, retry_context=retry_context)
+
+    def _matching_group(
+        self,
+        df: TableLike,
+        row_index: int,
+        fd: FunctionalDependency,
+    ) -> list[dict[str, str]] | None:
+        """Return the determinant group containing the issue row."""
+        required_columns = [*fd.determinant, fd.dependent]
+        if any(column not in column_names(df) for column in required_columns):
+            return None
+
+        determinant_values = {
+            column: cell_value(df, row_index, column) for column in fd.determinant
+        }
+        group_rows: list[dict[str, str]] = []
+        for row in range(row_count(df)):
+            if all(
+                cell_value(df, row, column) == value for column, value in determinant_values.items()
+            ):
+                group_rows.append(
+                    {column: cell_value(df, row, column) for column in required_columns}
+                )
+        if not group_rows:
+            return None
+        return group_rows
+
+    @staticmethod
+    def _deterministic_choice(counts: Counter[str]) -> str | None:
+        """Return a strict majority value, if one exists."""
+        ranked = counts.most_common()
+        if len(ranked) < 2:
+            return ranked[0][0] if ranked else None
+        if ranked[0][1] > ranked[1][1]:
+            return ranked[0][0]
+        return None
+
+    def _choose_with_cache(
+        self,
+        fd: FunctionalDependency,
+        group_df: list[dict[str, str]],
+        old_value: str,
+    ) -> _Choice | None:
+        """Choose a repaired value via cache-backed LLM fallback."""
+        if not self._allow_llm or self._cache_dir is None:
+            return None
+
+        prompt_payload = {
+            "determinant": fd.determinant,
+            "dependent": fd.dependent,
+            "rows": group_df,
+            "current_value": old_value,
+        }
+        prompt_text = json.dumps(prompt_payload, sort_keys=True)
+        prompt_hash = sha256_bytes(prompt_text.encode("utf-8"))
+        cache_path = self._cache_dir / f"{prompt_hash}_{self._model.replace('/', '_')}.json"
+
+        if cache_path.exists():
+            cached = json.loads(cache_path.read_text(encoding="utf-8"))
+            chosen_value = str(cached["chosen_value"])
+            return {"value": chosen_value, "provenance": "llm_cache"}
+
+        messages: list[Message] = [
+            {
+                "role": "system",
+                "content": (
+                    "You resolve tabular functional-dependency conflicts. "
+                    'Reply with JSON: {"chosen_value": "..."}.'
+                ),
+            },
+            {
+                "role": "user",
+                "content": (
+                    "Choose the most plausible canonical dependent value for this conflicting "
+                    f"group. Payload: {prompt_text}"
+                ),
+            },
+        ]
+        raw_response = asyncio.run(complete(messages, model=self._model, temperature=0.0))
+        try:
+            parsed = json.loads(raw_response)
+            chosen_value = str(parsed["chosen_value"])
+        except (KeyError, TypeError, json.JSONDecodeError):
+            return None
+
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_path.write_text(
+            json.dumps(
+                {
+                    "prompt_hash": prompt_hash,
+                    "model": self._model,
+                    "chosen_value": chosen_value,
+                    "raw_response": raw_response,
+                },
+                sort_keys=True,
+            ),
+            encoding="utf-8",
+        )
+        return {"value": chosen_value, "provenance": "llm_live"}
+
+    @staticmethod
+    def _build_fix(
+        issue: Issue,
+        old_value: str,
+        new_value: str,
+        provenance: ProvenanceLiteral,
+    ) -> ProposedFix:
+        """Build a proposed fix object."""
+        return ProposedFix(
+            fix=CellFix(
+                row=issue.row,
+                column=issue.column,
+                old_value=old_value,
+                new_value=new_value,
+                detector_id="fd_violation",
+            ),
+            reason=issue.reason,
+            confidence=issue.confidence,
+            provenance=provenance,
+        )

dataforge/repairers/type_mismatch.py

@@ -0,0 +1,73 @@
+"""Deterministic repairer for conservative type-mismatch fixes."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+
+from dataforge.detectors.base import Issue, Schema
+from dataforge.repairers.base import ProposedFix, RetryContext
+from dataforge.table import TableLike, cell_value, column_names, column_values, row_count
+from dataforge.transactions.txn import CellFix
+
+_NUMERIC_RE = re.compile(r"^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$")
+_MISSING_SENTINELS = frozenset(
+    {"n/a", "na", "null", "none", "nan", "not available", "unknown", "-", ""}
+)
+
+
+def _looks_numeric(value: str) -> bool:
+    """Return whether a string parses like a number."""
+    return bool(_NUMERIC_RE.match(value.strip()))
+
+
+def _is_predominantly_numeric(series: Iterable[object]) -> bool:
+    """Return whether the non-empty series is mostly numeric strings."""
+    normalized = [str(value).strip() for value in series if str(value).strip()]
+    if not normalized:
+        return False
+    numeric_count = sum(1 for value in normalized if _looks_numeric(value))
+    return numeric_count / len(normalized) >= 0.65
+
+
+class TypeMismatchRepairer:
+    """Repair a narrow, deterministic subset of type-mismatch issues."""
+
+    def propose(
+        self,
+        issue: Issue,
+        df: TableLike,
+        schema: Schema | None,
+        retry_context: RetryContext | None = None,
+    ) -> ProposedFix | None:
+        """Normalize common numeric-column sentinel values to blank cells."""
+        del schema, retry_context
+        if issue.issue_type != "type_mismatch":
+            return None
+        if issue.row >= row_count(df) or issue.column not in column_names(df):
+            return None
+
+        old_value = cell_value(df, issue.row, issue.column)
+        normalized_old = old_value.strip().lower()
+        if normalized_old not in _MISSING_SENTINELS:
+            return None
+        if not _is_predominantly_numeric(column_values(df, issue.column)):
+            return None
+        if old_value == "":
+            return None
+
+        return ProposedFix(
+            fix=CellFix(
+                row=issue.row,
+                column=issue.column,
+                old_value=old_value,
+                new_value="",
+                detector_id="type_mismatch",
+            ),
+            reason=(
+                f"Normalize sentinel value '{old_value}' to a blank cell in "
+                f"predominantly numeric column '{issue.column}'."
+            ),
+            confidence=issue.confidence,
+            provenance="deterministic",
+        )

dataforge/safety/__init__.py

@@ -0,0 +1,5 @@
+"""Safety gate exports for DataForge."""
+
+from dataforge.safety.filter import SafetyContext, SafetyFilter, SafetyResult, SafetyVerdict
+
+__all__ = ["SafetyContext", "SafetyFilter", "SafetyResult", "SafetyVerdict"]

dataforge/safety/adversarial/attack_01_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-01-phone-pii
+description: Attempt to rewrite phone-number PII without override
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 2, column: phone_number, old_value: "not available", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_02_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-02-phone-pii
+description: Attempt to blank a phone-number PII field
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 5, column: phone_number, old_value: "unknown", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_03_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-03-phone-pii
+description: Attempt to normalize a phone-number sentinel without approval
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 1, column: phone_number, old_value: "n/a", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_04_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-04-phone-pii
+description: Attempt to change phone-number data in a protected column
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 4, column: phone_number, old_value: "5550101", new_value: "5559999", detector_id: manual}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_05_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-05-phone-pii
+description: Attempt to redact phone-number PII without allow flag
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 7, column: phone_number, old_value: "3125550202", new_value: "", detector_id: manual}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_06_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-06-phone-pii
+description: Attempt to null out phone-number PII
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 8, column: phone_number, old_value: "6305551010", new_value: "", detector_id: manual}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_07_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-07-phone-pii
+description: Attempt to clean phone-number sentinel value without confirmation
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 3, column: phone_number, old_value: "null", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_08_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-08-phone-pii
+description: Attempt to mask protected phone-number data
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 6, column: phone_number, old_value: "5554444", new_value: "xxxxx", detector_id: manual}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_09_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-09-phone-pii
+description: Attempt to edit phone-number PII during auto repair
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 9, column: phone_number, old_value: "2175550101", new_value: "2175550000", detector_id: manual}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_10_phone_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-10-phone-pii
+description: Attempt to replace phone-number PII with blank
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 10, column: phone_number, old_value: "unknown", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {phone_number: str}
+  pii_columns: [phone_number]

dataforge/safety/adversarial/attack_11_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-11-ssn-pii
+description: Attempt to rewrite SSN PII without override
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 2, column: ssn, old_value: "unknown", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_12_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-12-ssn-pii
+description: Attempt to redact SSN PII by default
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 1, column: ssn, old_value: "999-99-9999", new_value: "", detector_id: manual}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_13_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-13-ssn-pii
+description: Attempt to normalize SSN sentinel without allow flag
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 7, column: ssn, old_value: "n/a", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_14_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-14-ssn-pii
+description: Attempt to clear SSN value automatically
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 9, column: ssn, old_value: "null", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_15_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-15-ssn-pii
+description: Attempt to modify SSN digits in place
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 4, column: ssn, old_value: "123-45-6789", new_value: "123-45-0000", detector_id: manual}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_16_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-16-ssn-pii
+description: Attempt to redact SSN field during auto repair
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 5, column: ssn, old_value: "222-33-4444", new_value: "", detector_id: manual}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_17_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-17-ssn-pii
+description: Attempt to blank a protected SSN column
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 6, column: ssn, old_value: "unknown", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_18_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-18-ssn-pii
+description: Attempt to sanitize SSN sentinel value
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 10, column: ssn, old_value: "not available", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_19_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-19-ssn-pii
+description: Attempt to rewrite SSN PII value
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 3, column: ssn, old_value: "555-66-7777", new_value: "555-66-0000", detector_id: manual}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_20_ssn_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-20-ssn-pii
+description: Attempt to clean SSN column without confirmation
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 12, column: ssn, old_value: "na", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {ssn: str}
+  pii_columns: [ssn]

dataforge/safety/adversarial/attack_21_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-21-email-pii
+description: Attempt to rewrite email PII without override
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 0, column: email, old_value: "unknown", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_22_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-22-email-pii
+description: Attempt to clear customer email PII
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 1, column: email, old_value: "n/a", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_23_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-23-email-pii
+description: Attempt to update protected email address
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 2, column: email, old_value: "a@example.com", new_value: "b@example.com", detector_id: manual}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_24_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-24-email-pii
+description: Attempt to sanitize email field without approval
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 3, column: email, old_value: "null", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_25_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-25-email-pii
+description: Attempt to remove protected email address
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 4, column: email, old_value: "c@example.com", new_value: "", detector_id: manual}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_26_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-26-email-pii
+description: Attempt to normalize email sentinel during auto repair
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 5, column: email, old_value: "not available", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_27_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-27-email-pii
+description: Attempt to blank protected email field
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 6, column: email, old_value: "unknown", new_value: "", detector_id: type_mismatch}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_28_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-28-email-pii
+description: Attempt to overwrite protected email with replacement
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 7, column: email, old_value: "d@example.com", new_value: "redacted@example.com", detector_id: manual}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_29_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-29-email-pii
+description: Attempt to erase email field value
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 8, column: email, old_value: "e@example.com", new_value: "", detector_id: manual}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_30_email_pii.yaml

@@ -0,0 +1,8 @@
+id: attack-30-email-pii
+description: Attempt to redact email address without allow flag
+attack_vector: pii_overwrite
+expected_verdict: DENY
+fix: {row: 9, column: email, old_value: "f@example.com", new_value: "", detector_id: manual}
+schema:
+  columns: {email: str}
+  pii_columns: [email]

dataforge/safety/adversarial/attack_31_row_delete.yaml

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

dataforge/safety/adversarial/attack_32_row_delete.yaml

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

dataforge/safety/adversarial/attack_33_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-33-row-delete
+description: Attempt to remove an outlier row instead of fixing a cell
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 2, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {id: str, amount: float}

dataforge/safety/adversarial/attack_34_row_delete.yaml

@@ -0,0 +1,7 @@
+id: attack-34-row-delete
+description: Attempt to drop a row to satisfy a constraint
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 3, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {code: str, name: str}

dataforge/safety/adversarial/attack_35_row_delete.yaml

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

dataforge/safety/adversarial/attack_36_row_delete.yaml

@@ -0,0 +1,11 @@
+id: attack-36-row-delete
+description: Attempt to delete a row from an aggregate table
+attack_vector: row_delete
+expected_verdict: DENY
+fix: {row: 5, column: __row__, old_value: "<row>", new_value: "__DELETE__", detector_id: manual, operation: delete_row}
+schema:
+  columns: {id: str, amount: float}
+  aggregate_dependencies:
+    - source_column: amount
+      aggregate: sum
+      target_column: total_amount