clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/operations/manipulators/tabular.py

@@ -0,0 +1,334 @@
+"""Tabular Baldwin Modularity Manipulator (Sprint 393 / DEL-393-02).
+
+Algebraic operations over CSV and tabular datasets:
+- split: Partition dataset by ratio (e.g., train/test) or predicate filter.
+- substitute: Map/replace values in columns or rename columns.
+- augment: Add derived columns computed from existing fields.
+- exclude: Redact sensitive columns (PII removal) or filter out rows.
+- invert: Invert row order or transpose tabular matrix.
+- port: Transcode CSV to JSON objects or structured records.
+
+Layer 1 module (no imports above L1).
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import random
+import re
+from typing import Any
+
+
+class TabularManipulator:
+    """Modality manipulator for tabular CSV/structured table data."""
+
+    @staticmethod
+    def _parse_csv(data: str | bytes) -> tuple[list[str], list[list[str]]]:
+        """Parse raw CSV string or bytes into headers and rows."""
+        text = data.decode("utf-8") if isinstance(data, bytes) else str(data)
+        reader = csv.reader(io.StringIO(text))
+        rows = [r for r in reader if r]
+        if not rows:
+            return [], []
+        headers = rows[0]
+        data_rows = rows[1:]
+        return headers, data_rows
+
+    @staticmethod
+    def _render_csv(headers: list[str], rows: list[list[str]]) -> str:
+        """Render headers and rows back into standard CSV string."""
+        out = io.StringIO()
+        writer = csv.writer(out, lineterminator="\n")
+        if headers:
+            writer.writerow(headers)
+        writer.writerows(rows)
+        return out.getvalue()
+
+    @classmethod
+    def split(
+        cls,
+        data: str | bytes,
+        parameters: dict[str, Any] | None = None,
+    ) -> dict[str, str]:
+        """Split a tabular dataset into orthogonal partitions.
+
+        Parameters:
+            ratios: dict of partition name -> float ratio (e.g. {'train': 0.8, 'test': 0.2})
+            seed: optional random seed for deterministic shuffling
+            predicate: optional predicate formula (e.g. "status == 'active'")
+        """
+        params = parameters or {}
+        headers, rows = cls._parse_csv(data)
+        if not rows:
+            return {"part_1": cls._render_csv(headers, []), "part_2": cls._render_csv(headers, [])}
+
+        ratios = params.get("ratios")
+        predicate = params.get("predicate") or params.get("condition")
+
+        if predicate and headers:
+            # Split into match vs non-match
+            # Simple expression evaluation over row dict
+            matched: list[list[str]] = []
+            unmatched: list[list[str]] = []
+            for r in rows:
+                row_dict = dict(zip(headers, r))
+                val = cls._eval_simple_condition(predicate, row_dict)
+                if val:
+                    matched.append(r)
+                else:
+                    unmatched.append(r)
+            return {
+                "matched": cls._render_csv(headers, matched),
+                "unmatched": cls._render_csv(headers, unmatched),
+            }
+
+        if ratios:
+            seed = params.get("seed")
+            shuffled_rows = list(rows)
+            if seed is not None:
+                rng = random.Random(seed)
+                rng.shuffle(shuffled_rows)
+
+            total = len(shuffled_rows)
+            partitions: dict[str, str] = {}
+            current_idx = 0
+            items = list(ratios.items())
+
+            for i, (name, ratio) in enumerate(items):
+                if i == len(items) - 1:
+                    # Last partition gets all remainder to guarantee exact Noetherian conservation
+                    part_rows = shuffled_rows[current_idx:]
+                else:
+                    count = int(round(total * ratio))
+                    part_rows = shuffled_rows[current_idx : current_idx + count]
+                    current_idx += count
+                partitions[name] = cls._render_csv(headers, part_rows)
+            return partitions
+
+        # Default 50/50 split
+        mid = len(rows) // 2
+        return {
+            "part_1": cls._render_csv(headers, rows[:mid]),
+            "part_2": cls._render_csv(headers, rows[mid:]),
+        }
+
+    @classmethod
+    def substitute(
+        cls,
+        data: str | bytes,
+        parameters: dict[str, Any] | None = None,
+    ) -> str:
+        """Substitute column names or column values in tabular data.
+
+        Parameters:
+            rename_columns: dict of old_name -> new_name
+            value_map: dict of column_name -> dict of old_val -> new_val
+        """
+        params = parameters or {}
+        headers, rows = cls._parse_csv(data)
+        rename = params.get("rename_columns", {})
+        value_map = params.get("value_map", {})
+
+        new_headers = [rename.get(h, h) for h in headers]
+        col_to_idx = {h: idx for idx, h in enumerate(headers)}
+
+        new_rows: list[list[str]] = []
+        for r in rows:
+            new_r = list(r)
+            for col, mapping in value_map.items():
+                if col in col_to_idx and col_to_idx[col] < len(new_r):
+                    val = new_r[col_to_idx[col]]
+                    if val in mapping:
+                        new_r[col_to_idx[col]] = str(mapping[val])
+            new_rows.append(new_r)
+
+        return cls._render_csv(new_headers, new_rows)
+
+    @classmethod
+    def augment(
+        cls,
+        data: str | bytes,
+        parameters: dict[str, Any] | None = None,
+    ) -> str:
+        """Augment tabular data with a new derived column.
+
+        Parameters:
+            target_column: name of new column
+            source_column: optional source column
+            formula: expression or mapping logic
+            constant_value: optional constant value
+        """
+        params = parameters or {}
+        headers, rows = cls._parse_csv(data)
+        target_col = params.get("column_name") or params.get("target_column") or "augmented_col"
+        source_col = params.get("source_column")
+        formula = params.get("formula")
+        constant_val = params.get("default_value") if params.get("default_value") is not None else params.get("constant_value")
+
+        new_headers = list(headers) + [target_col]
+        col_to_idx = {h: idx for idx, h in enumerate(headers)}
+        new_rows: list[list[str]] = []
+
+        for r in rows:
+            row_dict = dict(zip(headers, r))
+            if constant_val is not None:
+                val = str(constant_val)
+            elif formula:
+                val = cls._eval_formula(formula, row_dict)
+            elif source_col and source_col in col_to_idx:
+                val = r[col_to_idx[source_col]]
+            else:
+                val = ""
+            new_rows.append(list(r) + [val])
+
+        return cls._render_csv(new_headers, new_rows)
+
+    @classmethod
+    def exclude(
+        cls,
+        data: str | bytes,
+        parameters: dict[str, Any] | None = None,
+    ) -> str:
+        """Exclude (drop) columns or filter out rows.
+
+        Parameters:
+            columns: list of column names to redact/drop
+            condition: optional row condition to exclude
+        """
+        params = parameters or {}
+        headers, rows = cls._parse_csv(data)
+        drop_cols = set(params.get("columns") or params.get("target_columns") or [])
+        condition = params.get("condition") or params.get("predicate")
+
+        # Column projection
+        keep_indices = [i for i, h in enumerate(headers) if h not in drop_cols]
+        new_headers = [headers[i] for i in keep_indices]
+
+        new_rows: list[list[str]] = []
+        for r in rows:
+            row_dict = dict(zip(headers, r))
+            if condition and cls._eval_simple_condition(condition, row_dict):
+                # Exclude matching rows
+                continue
+            new_rows.append([r[i] for i in keep_indices if i < len(r)])
+
+        return cls._render_csv(new_headers, new_rows)
+
+    @classmethod
+    def invert(
+        cls,
+        data: str | bytes,
+        parameters: dict[str, Any] | None = None,
+    ) -> str:
+        """Invert tabular data by reversing rows or transposing.
+
+        Parameters:
+            strategy: 'reverse_rows' (default) or 'transpose'
+        """
+        params = parameters or {}
+        strategy = params.get("strategy", "reverse_rows")
+        headers, rows = cls._parse_csv(data)
+
+        if strategy == "transpose" and headers:
+            all_matrix = [headers] + rows
+            transposed = list(map(list, zip(*all_matrix)))
+            new_headers = transposed[0] if transposed else []
+            new_rows = transposed[1:] if len(transposed) > 1 else []
+            return cls._render_csv(new_headers, new_rows)
+
+        # Default: reverse row order
+        reversed_rows = list(reversed(rows))
+        return cls._render_csv(headers, reversed_rows)
+
+    @classmethod
+    def port(
+        cls,
+        data: str | bytes,
+        parameters: dict[str, Any] | None = None,
+    ) -> str:
+        """Port tabular data across representations (e.g. CSV to JSON array).
+
+        Parameters:
+            target_format: 'json' (default) or 'tsv'
+        """
+        params = parameters or {}
+        target_fmt = params.get("target_format", "json").lower()
+        headers, rows = cls._parse_csv(data)
+
+        if target_fmt == "json":
+            records = [dict(zip(headers, r)) for r in rows]
+            return json.dumps(records, indent=2)
+        elif target_fmt == "tsv":
+            out = io.StringIO()
+            writer = csv.writer(out, delimiter="\t", lineterminator="\n")
+            if headers:
+                writer.writerow(headers)
+            writer.writerows(rows)
+            return out.getvalue()
+        return cls._render_csv(headers, rows)
+
+    @staticmethod
+    def _eval_simple_condition(condition: str, row: dict[str, str]) -> bool:
+        """Safely evaluate simple conditions like 'col == val' or 'col != val' without eval()."""
+        cond = condition.strip()
+        # Check !=
+        if "!=" in cond:
+            parts = cond.split("!=", 1)
+            col = parts[0].strip().strip("'\"")
+            target = parts[1].strip().strip("'\"")
+            return str(row.get(col, "")) != target
+        # Check ==
+        if "==" in cond:
+            parts = cond.split("==", 1)
+            col = parts[0].strip().strip("'\"")
+            target = parts[1].strip().strip("'\"")
+            return str(row.get(col, "")) == target
+        # Check >=
+        if ">=" in cond:
+            parts = cond.split(">=", 1)
+            col = parts[0].strip()
+            target = float(parts[1].strip())
+            return float(row.get(col, 0)) >= target
+        # Check <=
+        if "<=" in cond:
+            parts = cond.split("<=", 1)
+            col = parts[0].strip()
+            target = float(parts[1].strip())
+            return float(row.get(col, 0)) <= target
+        # Check >
+        if ">" in cond:
+            parts = cond.split(">", 1)
+            col = parts[0].strip()
+            target = float(parts[1].strip())
+            return float(row.get(col, 0)) > target
+        # Check <
+        if "<" in cond:
+            parts = cond.split("<", 1)
+            col = parts[0].strip()
+            target = float(parts[1].strip())
+            return float(row.get(col, 0)) < target
+
+        return bool(row.get(cond))
+
+    @staticmethod
+    def _eval_formula(formula: str, row: dict[str, str]) -> str:
+        """Safely evaluate formula/tier rules (e.g. ternary or string replacement)."""
+        f = formula.strip()
+        # Ternary pattern: cond ? 'val1' : 'val2'
+        ternary_match = re.match(r"(.+?)\s*\?\s*['\"](.*?)['\"]\s*:\s*['\"](.*?)['\"]", f)
+        if ternary_match:
+            cond, true_val, false_val = ternary_match.groups()
+            if TabularManipulator._eval_simple_condition(cond, row):
+                return true_val
+            return false_val
+
+        # Interpolation pattern: {col1}_{col2}
+        if "{" in f and "}" in f:
+            res = f
+            for k, v in row.items():
+                res = res.replace(f"{{{k}}}", str(v))
+            return res
+
+        return f

clm/layer1/operations/port.py

@@ -0,0 +1,65 @@
+"""Baldwin Port Operator (DEL-388-02).
+
+Translation Operator (->): A_X -> A_Y.
+Migrates an implementation across heterogeneous host runtime domains
+(e.g., Python -> Rust / Wasm / Bash) without altering its logical abstract
+specification or balanced invariants, preserving triadic syntactic closure.
+"""
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+import yaml
+
+from clm.layer0.model.card import MCard
+from clm.layer1.operations.split import _parse_manifest, ensure_triadic_closure
+
+
+def op_port(impl: dict[str, Any], target: MCard, ctx: dict[str, Any]) -> dict[str, Any]:
+    """Execute the Baldwin Port (->) operation.
+
+    Args:
+        impl: Configuration dict for port:
+              target_runtime (str): Target runtime (e.g. "rust", "wasm", "node", "bash").
+        target: Target MCard to port.
+        ctx: Execution context.
+
+    Returns:
+        Dict containing the ported manifest, new MCard, and closure proof.
+    """
+    manifest = _parse_manifest(target)
+    target_runtime = impl.get("target_runtime", ctx.get("target_runtime", "rust"))
+
+    updated = copy.deepcopy(manifest)
+
+    # Concrete implementation is adapted to target runtime
+    c_impl = updated.get("concrete_impl", {})
+    if isinstance(c_impl, dict):
+        orig_runtime = c_impl.get("runtime", "python")
+        c_impl["runtime"] = target_runtime
+        c_impl["ported_from"] = orig_runtime
+    else:
+        updated["concrete_impl"] = {
+            "runtime": target_runtime,
+            "ported_from": "python",
+        }
+
+    # Abstract spec and balanced expectations remain invariant
+    final_manifest = ensure_triadic_closure(updated)
+    yaml_content = yaml.dump(final_manifest, default_flow_style=False)
+    new_card = MCard(yaml_content)
+
+    return {
+        "success": True,
+        "operator": "port",
+        "target_runtime": target_runtime,
+        "syntactic_closure": True,
+        "manifest": final_manifest,
+        "hash": new_card.hash,
+        "content": yaml_content,
+        "mcard": new_card,
+    }
+
+
+__all__ = ["op_port"]