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

gcf/decode_generic.py

@@ -151,6 +151,17 @@ def _parse_object_body(
             i += consumed
             continue
 
+        # Key=value. Check before inline array so bracket patterns in quoted
+        # values (e.g. text="ERR[404]: Not Found") are not misinterpreted.
+        eq_idx = _find_kv_split(content)
+        if eq_idx > 0:
+            name = _parse_key_from_header(content[:eq_idx])
+            _check_dup(out, name)
+            out[name] = parse_scalar(content[eq_idx + 1:])
+            i += 1
+            continue
+
+        # Inline array (e.g. items[3]: a,b,c). Only reached if no = found.
         if not content.startswith("@") and not content.startswith("##"):
             bracket_idx = content.find("[")
             if bracket_idx > 0:
@@ -166,14 +177,6 @@ def _parse_object_body(
                         i += 1
                         continue
 
-        eq_idx = _find_kv_split(content)
-        if eq_idx > 0:
-            name = _parse_key_from_header(content[:eq_idx])
-            _check_dup(out, name)
-            out[name] = parse_scalar(content[eq_idx + 1:])
-            i += 1
-            continue
-
         i += 1
     return i - start
 
@@ -191,7 +194,13 @@ def _find_kv_split(s: str) -> int:
                 return i + 1 if i + 1 < len(s) and s[i + 1] == "=" else -1
             i += 1
         return -1
-    return s.find("=")
+    eq_idx = s.find("=")
+    if eq_idx < 0:
+        return -1
+    bracket_idx = s.find("[")
+    if bracket_idx >= 0 and bracket_idx < eq_idx:
+        return -1
+    return eq_idx
 
 
 def _parse_key_from_header(s: str) -> str:
@@ -354,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]:
@@ -361,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]] = {}
@@ -400,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:]
@@ -539,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/scalar.py

@@ -8,6 +8,7 @@ from typing import Any
 
 _JSON_NUMBER_RE = re.compile(r"^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$")
 _NUMERIC_LIKE_RE = re.compile(r"^[+-]\.?\d|^\.\d|^0\d")
+_INLINE_ARRAY_RE = re.compile(r"\[[^\]]*\]\s*:")
 _BARE_KEY_RE = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
 
 
@@ -36,6 +37,8 @@ def needs_quote(s: str) -> bool:
         return True
     if s[0] in ("#", "@", "."):
         return True
+    if _INLINE_ARRAY_RE.search(s):
+        return True
     for c in s:
         o = ord(c)
         if c in ('"', "\\", "|", ",") or o < 0x20 or c in ("\n", "\r"):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gcf-python
-Version: 2.1.0
+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/
@@ -217,26 +217,26 @@ Works on dicts, lists, and primitives. Lists of uniform dicts get tabular rows.
 
 GCF wins 13/15 datasets on the expanded [token efficiency benchmark](https://github.com/blackwell-systems/toon/tree/gcf-comparison). Full results: [gcformat.com/guide/benchmarks](https://gcformat.com/guide/benchmarks.html)
 
-## Links
-
-- [Documentation](https://gcformat.com/)
-- [Playground](https://gcformat.com/playground.html)
-- [Specification](https://github.com/blackwell-systems/gcf)
-- [Go library](https://github.com/blackwell-systems/gcf-go)
-- [TypeScript library](https://github.com/blackwell-systems/gcf-typescript)
-- [MCP Proxy](https://github.com/blackwell-systems/gcf-proxy) (zero-code adoption)
-- [GCF vs TOON](https://gcformat.com/guide/vs-toon.html)
-- [TOON benchmark fork](https://github.com/blackwell-systems/toon/tree/gcf-comparison)
-
-
-<details>
-<summary>More links</summary>
-
-- [betterthanjson.com](https://betterthanjson.com)
-- [jsonalternative.com](https://jsonalternative.com)
-- [betterthantoon.com](https://betterthantoon.com)
-
-</details>
+## Implementations
+
+| Language | Package | Repository |
+|----------|---------|-----------|
+| Go | `go get github.com/blackwell-systems/gcf-go` | [gcf-go](https://github.com/blackwell-systems/gcf-go) |
+| TypeScript | `npm install @blackwell-systems/gcf` | [gcf-typescript](https://github.com/blackwell-systems/gcf-typescript) |
+| Python | `pip install gcf-python` | [gcf-python](https://github.com/blackwell-systems/gcf-python) |
+| Rust | `cargo add gcf` | [gcf-rust](https://github.com/blackwell-systems/gcf-rust) |
+| Swift | Swift Package Manager | [gcf-swift](https://github.com/blackwell-systems/gcf-swift) |
+| Kotlin | JitPack | [gcf-kotlin](https://github.com/blackwell-systems/gcf-kotlin) |
+| MCP Proxy | `pip install gcf-proxy` | [gcf-proxy](https://github.com/blackwell-systems/gcf-proxy) (bidirectional, session dedup, HTTP frontend) |
+| Claude Code Plugin | `/plugin install` | [gcf-claude-plugin](https://github.com/blackwell-systems/gcf-claude-plugin) (one-command install, session stats hook) |
+| Codex Plugin | `codex plugin add` | [gcf-codex-plugin](https://github.com/blackwell-systems/gcf-codex-plugin) (one-command install, session stats hook) |
+| VS Code | `ext install blackwell-systems.gcf-vscode` | [gcf-vscode](https://marketplace.visualstudio.com/items?itemName=blackwell-systems.gcf-vscode) (syntax highlighting) |
+| 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. 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.
 
 ## License
 

{gcf_python-2.1.0.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=49_X9fKuBctd9Djd1103iaZWpPZX8TP_KgnWpji130s,23428
+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/scalar.py,sha256=YBPTGcgFPwN_lgPLuRg8U4uHVlJ2vn5d1Gz1AGf-E00,9225
+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.0.dist-info/METADATA,sha256=f4x6jJYGrKcClX0G9OeJDPUgRv6SGCOQlUmQivk45MA,8234
-gcf_python-2.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-gcf_python-2.1.0.dist-info/entry_points.txt,sha256=aFT6gqlkh8iGfM8cblE-LUMxHH08_v71IIoZtDdRIVA,37
-gcf_python-2.1.0.dist-info/licenses/LICENSE,sha256=2Fit9wnaIe--RMSAgyQqxC5hfZTyZqn4fIdBtp9qPDw,1072
-gcf_python-2.1.0.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,,