gcf-python 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

gcf/decode_generic.py

@@ -363,6 +363,55 @@ def _parse_attachment(
     raise ValueError(f"invalid attachment form: {after_name}")
 
 
+def _unflatten_paths(
+    path_columns: dict[str, list[str]],
+    flat_values: dict[str, Any],
+    flat_absent: set[str],
+) -> dict[str, Any]:
+    """Reconstruct nested objects from flat > path columns."""
+    groups: dict[str, list[str]] = {}
+    group_order: list[str] = []
+    for field_name, paths in path_columns.items():
+        if not paths:
+            continue
+        top = paths[0]
+        if top not in groups:
+            groups[top] = []
+            group_order.append(top)
+        groups[top].append(field_name)
+
+    result: dict[str, Any] = {}
+
+    for top in group_order:
+        field_names = groups[top]
+        all_absent = all(f in flat_absent for f in field_names)
+        all_null = all(
+            (f not in flat_absent and flat_values.get(f) is None)
+            for f in field_names
+        )
+
+        if all_absent:
+            continue
+        if all_null:
+            result[top] = None
+            continue
+
+        for field_name in field_names:
+            if field_name in flat_absent:
+                continue
+            paths = path_columns[field_name]
+            val = flat_values.get(field_name)
+
+            current = result
+            for k in paths[:-1]:
+                if k not in current:
+                    current[k] = {}
+                current = current[k]
+            current[paths[-1]] = val
+
+    return result
+
+
 def _parse_tabular_body(
     lines: list[str], start: int, depth: int, fields: list[str], expected_count: int
 ) -> tuple[list[Any], int]:
@@ -370,6 +419,12 @@ def _parse_tabular_body(
     rows: list[Any] = []
     i = start
 
+    # Detect path columns: fields containing ">".
+    path_column_map: dict[str, list[str]] = {}
+    for f in fields:
+        if ">" in f:
+            path_column_map[f] = f.split(">")
+
     # Track inline schemas and shared array schemas.
     inline_schemas: dict[str, list[str]] = {}
     shared_array_schemas: dict[str, list[str]] = {}
@@ -409,9 +464,22 @@ def _parse_tabular_body(
         inline_att_order: list[str] = []
         missing_fields: set[str] = set()
 
+        # Collect path column values for unflattening.
+        flat_values: dict[str, Any] = {}
+        flat_absent: set[str] = set()
+
         for j, f in enumerate(fields):
             cell_val = vals[j]
 
+            # Path columns: store values for later unflattening.
+            if f in path_column_map:
+                parsed = parse_scalar(cell_val, tabular_context=True)
+                if parsed is MISSING:
+                    flat_absent.add(f)
+                else:
+                    flat_values[f] = parsed
+                continue
+
             # Check for ^{fields} inline schema declaration.
             if cell_val.startswith("^{") and cell_val.endswith("}"):
                 schema_str = cell_val[1:]
@@ -548,6 +616,11 @@ def _parse_tabular_body(
                 row[f] = cell_values[f]
             elif f in attachment_values:
                 row[f] = attachment_values[f]
+        # Unflatten path columns into nested objects.
+        if path_column_map:
+            nested = _unflatten_paths(path_column_map, flat_values, flat_absent)
+            row.update(nested)
+
         rows.append(row)
 
         if expected_count >= 0 and len(rows) >= expected_count:

gcf/generic.py

@@ -145,15 +145,136 @@ def _shared_array_schema(arr: list[dict], field_name: str) -> list[str] | None:
     return canonical_fields
 
 
+# ── Nested object flattening (v3.2) ──────────────────────────────────────
+
+
+def _analyze_flattenable(
+    arr: list[dict], field_name: str, parent_path: str
+) -> list[dict] | None:
+    """Analyze whether a field can be flattened. Returns list of leaf descriptors or None."""
+    canonical_shape: dict[str, str] | None = None  # key -> "scalar" | "nested"
+
+    for item in arr:
+        if field_name not in item or item[field_name] is None:
+            continue
+        v = item[field_name]
+        if not isinstance(v, dict):
+            return None
+        if isinstance(v, list):
+            return None
+
+        keys = list(v.keys())
+
+        if canonical_shape is None:
+            canonical_shape = {}
+            for k in keys:
+                if ">" in k:
+                    return None
+                val = v[k]
+                if isinstance(val, list):
+                    return None
+                elif isinstance(val, dict):
+                    canonical_shape[k] = "nested"
+                else:
+                    canonical_shape[k] = "scalar"
+        else:
+            if len(keys) != len(canonical_shape):
+                return None
+            for k in keys:
+                if k not in canonical_shape:
+                    return None
+                val = v[k]
+                expected = canonical_shape[k]
+                if expected == "scalar":
+                    if isinstance(val, (dict, list)):
+                        return None
+                elif expected == "nested":
+                    if isinstance(val, list):
+                        return None
+                    if val is not None and not isinstance(val, dict):
+                        return None
+
+    if canonical_shape is None:
+        return None
+
+    current_path = f"{parent_path}>{field_name}" if parent_path else field_name
+    parent_keys = parent_path.split(">") + [field_name] if parent_path else [field_name]
+
+    leaves: list[dict] = []
+    for k in canonical_shape:
+        if canonical_shape[k] == "scalar":
+            leaves.append({"path": f"{current_path}>{k}", "keys": parent_keys + [k]})
+        else:
+            sub_arr = []
+            for item in arr:
+                if field_name not in item or item[field_name] is None:
+                    sub_arr.append({})
+                else:
+                    sub_arr.append(item[field_name])
+            sub_leaves = _analyze_flattenable(sub_arr, k, current_path)
+            if sub_leaves is None or len(sub_leaves) == 0:
+                return None
+            leaves.extend(sub_leaves)
+
+    # Guard: reject if any row has non-null object with all-null leaves.
+    if leaves:
+        for item in arr:
+            if field_name not in item or item[field_name] is None:
+                continue
+            all_null = all(
+                _resolve_key_chain(item, leaf["keys"])[0] is None
+                and _resolve_key_chain(item, leaf["keys"])[1]
+                for leaf in leaves
+            )
+            if all_null:
+                return None
+
+    return leaves
+
+
+def _resolve_key_chain(item: Any, keys: list[str]) -> tuple[Any, bool]:
+    """Traverse an object by key chain. Returns (value, exists)."""
+    if not keys or not isinstance(item, dict):
+        return None, False
+    if keys[0] not in item:
+        return None, False
+    current = item[keys[0]]
+    if current is None:
+        return None, True
+    for k in keys[1:]:
+        if not isinstance(current, dict) or k not in current:
+            return None, False
+        current = current[k]
+    return current, True
+
+
 def _encode_tabular(
     header_prefix: str, arr: list[dict], fields: list[str], out: list[str], depth: int
 ) -> None:
     prefix = _indent(depth)
 
-    # Pre-compute inline schemas and shared array schemas.
+    # Phase 0: Analyze fields for flattening.
+    flatten_map: dict[str, list[dict]] = {}
+    for f in fields:
+        leaves = _analyze_flattenable(arr, f, "")
+        if leaves and len(leaves) > 0:
+            flatten_map[f] = leaves
+
+    # Build expanded column list.
+    columns: list[dict] = []
+    for f in fields:
+        if f in flatten_map:
+            for leaf in flatten_map[f]:
+                columns.append({"header": format_key(leaf["path"]), "type": "flat", "field": f, "keys": leaf["keys"]})
+        else:
+            columns.append({"header": format_key(f), "type": "original", "field": f, "keys": []})
+
+    # Pre-compute inline schemas and shared array schemas (skip flattened fields).
     inline_schemas: dict[str, list[str]] = {}
     shared_arr_schemas: dict[str, list[str]] = {}
     for f in fields:
+        if f in flatten_map:
+            continue
         ifs = _inline_schema_fields(arr, f)
         if ifs is not None:
             inline_schemas[f] = ifs
@@ -161,15 +282,34 @@ def _encode_tabular(
         if sas is not None:
             shared_arr_schemas[f] = sas
 
-    fmt_fields = ",".join(format_key(f) for f in fields)
-    out.append(f"{header_prefix}[{len(arr)}]{{{fmt_fields}}}")
+    header_fields = ",".join(col["header"] for col in columns)
+    out.append(f"{header_prefix}[{len(arr)}]{{{header_fields}}}")
 
     for i, item in enumerate(arr):
         cells: list[str] = []
-        attachments: list[tuple[str, Any, bool, list[str] | None]] = []  # (name, value, inline, inline_fields)
+        attachments: list[tuple[str, Any, bool, list[str] | None]] = []
         row_has_attachment = False
 
-        for f in fields:
+        for col in columns:
+            if col["type"] == "flat":
+                keys = col["keys"]
+                if keys[0] not in item:
+                    cells.append("~")
+                else:
+                    top_val = item[keys[0]]
+                    if top_val is None:
+                        cells.append("-")
+                    else:
+                        val, exists = _resolve_key_chain(item, keys)
+                        if not exists:
+                            cells.append("~")
+                        elif val is None:
+                            cells.append("-")
+                        else:
+                            cells.append(format_scalar(val, "|"))
+                continue
+
+            f = col["field"]
             if f not in item:
                 cells.append("~")
                 continue

{gcf_python-2.1.1.dist-info → gcf_python-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gcf-python
-Version: 2.1.1
+Version: 2.2.0
 Summary: Drop-in JSON replacement for AI pipelines. 79% fewer tokens. 90.7% comprehension across 10 models. Zero dependencies.
 Project-URL: Homepage, https://github.com/blackwell-systems/gcf-python
 Project-URL: Documentation, https://blackwell-systems.github.io/gcf/
@@ -234,7 +234,7 @@ GCF wins 13/15 datasets on the expanded [token efficiency benchmark](https://git
 | n8n | `npm install n8n-nodes-gcf` | [gcf-n8n-nodes](https://github.com/blackwell-systems/gcf-n8n-nodes) (workflow encode/decode) |
 | Tree-sitter | `npm install tree-sitter-gcf` | [tree-sitter-gcf](https://github.com/blackwell-systems/tree-sitter-gcf) |
 
-Zero runtime dependencies. MIT licensed. All implementations support both generic profile (`encodeGeneric`) and graph profile (`encode`). CLI included in all 6 languages.
+**Zero runtime dependencies. Permanently.** All six implementations depend only on their language's standard library. No transitive dependencies. No supply chain risk. This is a permanent commitment: GCF will never take on external runtime dependencies. MIT licensed. All implementations support both generic profile (`encodeGeneric`) and graph profile (`encode`). CLI included in all 6 languages.
 
 **Specification:** [SPEC v3.1 Stable](https://github.com/blackwell-systems/gcf/blob/main/SPEC.md) with 157 conformance fixtures, 33,000,000,000+ lossless round-trips verified across 5 formats and 6 languages. All implementations at v2.1.0+ (Go v1.2.0). Cross-language 6x6 matrix verified.
 

{gcf_python-2.1.1.dist-info → gcf_python-2.2.0.dist-info}/RECORD

@@ -3,17 +3,17 @@ gcf/__main__.py,sha256=EpvBz1yc8H0D5OJ1zy2tYke-kRzvudKa4DEbfeW14ao,71
 gcf/cli.py,sha256=UEe1CAZn-rKGNIo_ap8-oez3ucl6DSRbsdv6RDnzygY,5256
 gcf/constants.py,sha256=cmZ8YJSOB0im_eyfN8v4UvrLpBC6Fuf4cfcKZGbutxY,638
 gcf/decode.py,sha256=nD8bXYhoeHQQ3LCeAJQOAgFuob-V_6us4mcBYtL_bBc,5978
-gcf/decode_generic.py,sha256=fb0vh14zbyS0qUMN-hEKouD7Nr99Ntw5eiSTgbGfUV0,23810
+gcf/decode_generic.py,sha256=QdwXIPZhTTJsfaYInYKW0TKr8Ln5cufmRE2kl40_kpY,26034
 gcf/delta.py,sha256=f90UC6zejXH-ujyU_OViWDCqnxLXk3i6Qion-RJGHY4,1670
 gcf/encode.py,sha256=CcqMSNmojrQAAw2X3MNfw8YR6l4rNw9hWDqwmf846oA,2929
-gcf/generic.py,sha256=h9IcvX0MCSG0kbbbGqlBQKe7uaPrBM9ewjJzGpgUn88,10432
+gcf/generic.py,sha256=7cSwYT_U3ySTZy8yLY_GtQrzzGIRkhHOE1SEIGmhdrg,15458
 gcf/scalar.py,sha256=MZay-KIROvaFHet-g2-pBghahT1bf_5bxZjG4yTZkSo,9329
 gcf/session.py,sha256=6-wytNGaBkgqH7uTar7ojUFYNwIMeEVAZhuV-s-upZM,4704
 gcf/stream.py,sha256=1Kt_a2daKpYHlWP1lnDJ4g549pUt9rc-U0xbARbXRKQ,5174
 gcf/stream_generic.py,sha256=RnqqiPSu5joJa-7e58QbbzSGfvxBICA587A3aArjZvE,3250
 gcf/types.py,sha256=AWm-LQoSqLHAYtEjcAxWQZqJ4JXqNreLUKO2mJFgNMA,1465
-gcf_python-2.1.1.dist-info/METADATA,sha256=LNaTf48XfyKNcSvZ0gI8zNMCWKwUgbB8hiTugMfs45I,9554
-gcf_python-2.1.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-gcf_python-2.1.1.dist-info/entry_points.txt,sha256=aFT6gqlkh8iGfM8cblE-LUMxHH08_v71IIoZtDdRIVA,37
-gcf_python-2.1.1.dist-info/licenses/LICENSE,sha256=2Fit9wnaIe--RMSAgyQqxC5hfZTyZqn4fIdBtp9qPDw,1072
-gcf_python-2.1.1.dist-info/RECORD,,
+gcf_python-2.2.0.dist-info/METADATA,sha256=Kc-fEX3jOtbvgBPwEiQL0gRf4hibJYlGJu4ea05kGfw,9781
+gcf_python-2.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+gcf_python-2.2.0.dist-info/entry_points.txt,sha256=aFT6gqlkh8iGfM8cblE-LUMxHH08_v71IIoZtDdRIVA,37
+gcf_python-2.2.0.dist-info/licenses/LICENSE,sha256=2Fit9wnaIe--RMSAgyQqxC5hfZTyZqn4fIdBtp9qPDw,1072
+gcf_python-2.2.0.dist-info/RECORD,,