gcf-python 2.2.2__py3-none-any.whl → 2.4.0__py3-none-any.whl

gcf/__init__.py

@@ -36,9 +36,27 @@ Specification: https://github.com/blackwell-systems/gcf
 
 from .constants import KIND_ABBREV, KIND_EXPAND
 from .decode import DecodeError, decode
-from .delta import encode_delta
+from .delta import decode_delta, encode_delta, verify_delta
 from .encode import encode
 from .generic import encode_generic, GenericOptions
+from .generic_delta import (
+    GenericSet,
+    GenericDeltaPayload,
+    generic_pack_root,
+    diff_generic_sets,
+    encode_generic_full,
+    encode_generic_delta,
+    decode_generic_full,
+    decode_generic_delta,
+    verify_generic_delta,
+    GenericDeltaSession,
+    ReanchorPolicy,
+    ReanchorMode,
+    fixed_n,
+    size_guard,
+    DEFAULT_REANCHOR_N,
+)
+from .packroot import pack_root
 from .session import Session, encode_with_session
 from .decode_generic import decode_generic
 from .stream import StreamEncoder
@@ -58,12 +76,30 @@ __all__ = [
     "StreamEncoder",
     "Symbol",
     "decode",
+    "decode_delta",
     "decode_generic",
     "encode",
     "encode_delta",
+    "verify_delta",
     "encode_generic",
     "GenericOptions",
     "encode_with_session",
+    "GenericSet",
+    "GenericDeltaPayload",
+    "generic_pack_root",
+    "pack_root",
+    "diff_generic_sets",
+    "encode_generic_full",
+    "encode_generic_delta",
+    "decode_generic_full",
+    "decode_generic_delta",
+    "verify_generic_delta",
+    "GenericDeltaSession",
+    "ReanchorPolicy",
+    "ReanchorMode",
+    "fixed_n",
+    "size_guard",
+    "DEFAULT_REANCHOR_N",
 ]
 
-__version__ = "2.2.2"
+__version__ = "2.3.0"

gcf/decode_generic.py

@@ -177,7 +177,14 @@ def _parse_object_body(
                         i += 1
                         continue
 
-        i += 1
+        # An object-body line that is not a `## ` section, a `key=value` field, or
+        # an inline array is not valid content and MUST NOT be silently skipped
+        # (that dropped data, a lossless round-trip hole). A pipe-delimited line is
+        # a stray positional inline body with no eligible `^` cell (SPEC 16.5,
+        # orphan_inline_attachment); any other unrecognized line is likewise rejected.
+        if "|" in content:
+            raise ValueError(f"orphan_inline_attachment: {content}")
+        raise ValueError(f"invalid_line: unexpected content in object body: {content!r}")
     return i - start
 
 
@@ -521,6 +528,11 @@ def _parse_tabular_body(
         if row_has_id:
             inline_idx = 0
 
+            # Columns that carry a `^` marker cell in this row legitimately expect
+            # a `.field` body. Any other `.field` is an orphan (Section 16.5) unless
+            # its name contains `>` (the flatten-fallback attachment, Section 7.4.6.1.4).
+            expected_att = set(traditional_att_fields) | set(inline_att_fields)
+
             while i < len(lines):
                 a_line = lines[i]
                 a_content: str | None = None
@@ -541,6 +553,14 @@ def _parse_tabular_body(
                     att_name, after_name = _parse_attachment_name(rest)
                     after_name_stripped = after_name.lstrip()
 
+                    # Orphan attachment: a `.field` with no matching `^` cell in this
+                    # row is only legitimate for a `>`-named field (Section 7.4.6.1.4).
+                    # Any other unmatched attachment is rejected rather than silently
+                    # injected as an undeclared extra field, which would decode to a
+                    # record no encoder produces (Section 16.5, lossless round-trip).
+                    if att_name not in expected_att and ">" not in att_name:
+                        raise ValueError(f"orphan_attachment: {att_name}")
+
                     # Prefixed inline data.
                     ifs = inline_schemas.get(att_name)
                     if ifs and not after_name_stripped.startswith("{}") and not after_name_stripped.startswith("["):

gcf/delta.py

@@ -1,7 +1,8 @@
 """GCF delta encoding: only added/removed symbols for incremental delivery."""
 
-from .constants import KIND_ABBREV
-from .types import DeltaPayload
+from .constants import KIND_ABBREV, KIND_EXPAND
+from .packroot import pack_root
+from .types import DeltaPayload, Edge, Symbol
 
 
 def encode_delta(d: DeltaPayload) -> str:
@@ -37,7 +38,9 @@ def encode_delta(d: DeltaPayload) -> str:
         parts.append("## added")
         for i, s in enumerate(d.added):
             kind = KIND_ABBREV.get(s.kind, s.kind)
-            parts.append(f"@{i} {kind} {s.qualified_name} {s.score:.2f} {s.provenance}")
+            parts.append(
+                f"@{i} {kind} {s.qualified_name} {s.score:.2f} {s.provenance} {s.distance}"
+            )
 
     # Removed edges.
     if d.removed_edges:
@@ -52,3 +55,183 @@ def encode_delta(d: DeltaPayload) -> str:
             parts.append(f"{e.source} -> {e.target} {e.edge_type}")
 
     return "\n".join(parts) + "\n"
+
+
+def _expand_kind(k: str) -> str:
+    """Reverse a kind abbreviation to its full form (identity if unknown)."""
+    return KIND_EXPAND.get(k, k)
+
+
+def _parse_delta_edge(line: str) -> Edge:
+    """Parse a `source -> target type` delta edge line."""
+    idx = line.find(" -> ")
+    if idx < 0:
+        raise ValueError(f"malformed_delta: edge line missing ' -> ': {line!r}")
+    source = line[:idx]
+    rest = line[idx + 4 :].split()
+    if len(rest) != 2:
+        raise ValueError(
+            f"malformed_delta: edge line {line!r} must be 'source -> target type'"
+        )
+    return Edge(source=source, target=rest[0], edge_type=rest[1])
+
+
+def decode_delta(wire: str) -> DeltaPayload:
+    """Parse a GCF graph delta wire payload back into a DeltaPayload.
+
+    Kind abbreviations on removed/added lines are expanded to their full form so the
+    result matches a base snapshot's symbol identities. Raises ValueError containing
+    ``malformed_delta`` on bad lines or unknown sections.
+    """
+    lines = wire.rstrip("\n").split("\n")
+    if not lines or lines[0] == "":
+        raise ValueError("missing_header: empty delta payload")
+    header = lines[0].rstrip("\r")
+    if not header.startswith("GCF profile=graph"):
+        raise ValueError(
+            "missing_profile: delta header must begin with 'GCF profile=graph'"
+        )
+
+    d = DeltaPayload()
+    for field in header.split():
+        kv = field.split("=", 1)
+        if len(kv) != 2:
+            continue
+        key, value = kv
+        if key == "tool":
+            d.tool = value
+        elif key == "base_root":
+            d.base_root = value
+        elif key == "new_root":
+            d.new_root = value
+
+    section = ""
+    for raw in lines[1:]:
+        line = raw.rstrip("\r")
+        if line == "":
+            continue
+        if line.startswith("## "):
+            section = line[3:].strip()
+            if section not in ("removed", "added", "edges_removed", "edges_added"):
+                raise ValueError(f"malformed_delta: unknown section {section!r}")
+            continue
+        if section == "removed":
+            parts = line.split()
+            if len(parts) != 2:
+                raise ValueError(
+                    f"malformed_delta: removed line {line!r} must be 'kind qname'"
+                )
+            d.removed.append(
+                Symbol(kind=_expand_kind(parts[0]), qualified_name=parts[1])
+            )
+        elif section == "added":
+            parts = line.split()
+            if len(parts) != 6:
+                raise ValueError(
+                    f"malformed_delta: added line {line!r} must be "
+                    "'@id kind qname score provenance distance'"
+                )
+            try:
+                score = float(parts[3])
+            except ValueError:
+                raise ValueError(f"malformed_delta: invalid added score {parts[3]!r}")
+            try:
+                dist = int(parts[5])
+            except ValueError:
+                raise ValueError(
+                    f"malformed_delta: invalid added distance {parts[5]!r}"
+                )
+            d.added.append(
+                Symbol(
+                    kind=_expand_kind(parts[1]),
+                    qualified_name=parts[2],
+                    score=score,
+                    provenance=parts[4],
+                    distance=dist,
+                )
+            )
+        elif section in ("edges_removed", "edges_added"):
+            e = _parse_delta_edge(line)
+            if section == "edges_removed":
+                d.removed_edges.append(e)
+            else:
+                d.added_edges.append(e)
+        else:
+            raise ValueError(
+                f"malformed_delta: data line {line!r} before any section header"
+            )
+    return d
+
+
+def verify_delta(
+    base_symbols: list[Symbol],
+    base_edges: list[Edge],
+    removed: list[Symbol],
+    added: list[Symbol],
+    removed_edges: list[Edge],
+    added_edges: list[Edge],
+    expected_new_root: str,
+) -> tuple[list[Symbol], list[Edge]]:
+    """Apply a delta to a base snapshot and verify the resulting pack root.
+
+    Symbols are matched by identity ``(kind, qualified_name)``; edges by
+    ``(source, target, edge_type)``. Raises ValueError containing ``delta_invalid``
+    when removing a symbol/edge that does not exist or adding one that already exists,
+    and ``root_mismatch`` when the recomputed pack root differs from
+    ``expected_new_root``. On success returns the applied ``(symbols, edges)``.
+    """
+    sym_map: dict[tuple[str, str], Symbol] = {}
+    for s in base_symbols:
+        sym_map[(s.kind, s.qualified_name)] = s
+
+    for s in removed:
+        key = (s.kind, s.qualified_name)
+        if key not in sym_map:
+            raise ValueError(
+                f"delta_invalid: removing symbol {s.kind} {s.qualified_name} "
+                "that does not exist in base"
+            )
+        del sym_map[key]
+
+    for s in added:
+        key = (s.kind, s.qualified_name)
+        if key in sym_map:
+            raise ValueError(
+                f"delta_invalid: adding symbol {s.kind} {s.qualified_name} "
+                "that already exists"
+            )
+        sym_map[key] = s
+
+    result_symbols = list(sym_map.values())
+
+    edge_map: dict[tuple[str, str, str], Edge] = {}
+    for e in base_edges:
+        edge_map[(e.source, e.target, e.edge_type)] = e
+
+    for e in removed_edges:
+        key = (e.source, e.target, e.edge_type)
+        if key not in edge_map:
+            raise ValueError(
+                f"delta_invalid: removing edge {e.source} -> {e.target} "
+                f"{e.edge_type} that does not exist"
+            )
+        del edge_map[key]
+
+    for e in added_edges:
+        key = (e.source, e.target, e.edge_type)
+        if key in edge_map:
+            raise ValueError(
+                f"delta_invalid: adding edge {e.source} -> {e.target} "
+                f"{e.edge_type} that already exists"
+            )
+        edge_map[key] = e
+
+    result_edges = list(edge_map.values())
+
+    computed_root = pack_root(result_symbols, result_edges)
+    if computed_root != expected_new_root:
+        raise ValueError(
+            f"root_mismatch: computed {computed_root}, expected {expected_new_root}"
+        )
+
+    return result_symbols, result_edges

gcf/encode.py

@@ -17,10 +17,16 @@ def encode(p: Payload) -> str:
     """
     parts: list[str] = []
 
-    # Build symbol index for edge references.
+    # Group symbols by distance (sorted by score descending within each group),
+    # then assign local IDs in output order so they are sequential in the wire
+    # (SPEC 16.1).
+    groups = _group_by_distance(p.symbols)
     sym_index: dict[str, int] = {}
-    for i, s in enumerate(p.symbols):
-        sym_index[s.qualified_name] = i
+    next_id = 0
+    for _distance, g_symbols in groups:
+        for s in g_symbols:
+            sym_index[s.qualified_name] = next_id
+            next_id += 1
 
     # Count valid edges (both endpoints in symbol index).
     valid_edges = sum(
@@ -28,14 +34,20 @@ def encode(p: Payload) -> str:
         if e.source in sym_index and e.target in sym_index
     )
 
-    # Header line.
-    header = f"GCF profile=graph tool={p.tool} budget={p.token_budget} tokens={p.tokens_used} symbols={len(p.symbols)} edges={valid_edges}"
+    # Header line (SPEC 16.1): omit budget/tokens/edges when zero, matching the
+    # reference encoder.
+    header = f"GCF profile=graph tool={p.tool}"
+    if p.token_budget > 0:
+        header += f" budget={p.token_budget}"
+    if p.tokens_used > 0:
+        header += f" tokens={p.tokens_used}"
+    header += f" symbols={len(p.symbols)}"
+    if valid_edges > 0:
+        header += f" edges={valid_edges}"
     if p.pack_root:
         header += f" pack_root={p.pack_root}"
     parts.append(header)
 
-    # Group symbols by distance.
-    groups = _group_by_distance(p.symbols)
     group_names = ["targets", "related", "extended"]
 
     for g_distance, g_symbols in groups:
@@ -52,17 +64,25 @@ def encode(p: Payload) -> str:
             kind = KIND_ABBREV.get(s.kind, s.kind)
             parts.append(f"@{idx} {kind} {s.qualified_name} {s.score:.2f} {s.provenance}")
 
-    # Edges section.
+    # Edges section. Order edges by source ID then target ID (then edge type
+    # for parallel edges) so the wire is canonical regardless of the order
+    # edges were provided (SPEC 16.1). Edge reordering is decode-invariant
+    # (edges are a set) and does not affect pack_root, which sorts edge records
+    # independently.
     if p.edges:
-        edge_lines: list[str] = []
+        resolved: list[tuple[int, int, str, str]] = []
         for e in p.edges:
             src_idx = sym_index.get(e.source)
             tgt_idx = sym_index.get(e.target)
             if src_idx is None or tgt_idx is None:
                 continue
-            line = f"@{tgt_idx}<@{src_idx} {e.edge_type}"
-            if e.status and e.status != "unchanged":
-                line += f" {e.status}"
+            resolved.append((src_idx, tgt_idx, e.edge_type, e.status))
+        resolved.sort(key=lambda r: (r[0], r[1], r[2]))
+        edge_lines: list[str] = []
+        for src_idx, tgt_idx, edge_type, status in resolved:
+            line = f"@{tgt_idx}<@{src_idx} {edge_type}"
+            if status and status != "unchanged":
+                line += f" {status}"
             edge_lines.append(line)
         parts.append(f"## edges [{len(edge_lines)}]")
         parts.extend(edge_lines)
@@ -71,15 +91,17 @@ def encode(p: Payload) -> str:
 
 
 def _group_by_distance(symbols: list[Symbol]) -> list[tuple[int, list[Symbol]]]:
-    """Group symbols by distance, preserving order."""
+    """Group symbols by distance ascending, sorted by score descending within each
+    group (stable), matching the reference encoder so IDs are assigned canonically."""
     if not symbols:
         return []
 
+    ordered = sorted(symbols, key=lambda s: (s.distance, -s.score))
     groups: list[tuple[int, list[Symbol]]] = []
     current_distance: int | None = None
     current_symbols: list[Symbol] = []
 
-    for s in symbols:
+    for s in ordered:
         if current_distance is None or current_distance != s.distance:
             if current_symbols:
                 groups.append((current_distance, current_symbols))  # type: ignore[arg-type]

gcf/generic_delta.py

@@ -0,0 +1,487 @@
+"""GCF generic-profile delta encoding (SPEC Section 10a).
+
+Producer + consumer. Mirrors the gcf-go reference implementation; the shared
+conformance fixtures (generic-pack-root/, generic-delta/) hold both to identical
+bytes and hashes.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from .scalar import (
+    format_key,
+    format_number,
+    format_scalar,
+    parse_scalar,
+    quote_string,
+    split_respecting_quotes,
+)
+
+
+@dataclass
+class GenericSet:
+    """A keyed record set: the unit generic-profile delta operates on (Section 10a).
+
+    Rows are order-agnostic (set semantics); ``fields`` carries the declared column
+    order for the wire form; ``key`` names the identity column (the ``@id`` / ``key=``);
+    ``name`` is the tabular section name for a full payload.
+    """
+
+    key: str
+    fields: list[str]
+    rows: list[dict[str, Any]]
+    name: str = "rows"
+
+
+@dataclass
+class GenericDeltaPayload:
+    key: str
+    fields: list[str]
+    base_root: str = ""
+    new_root: str = ""
+    added: list[dict[str, Any]] = field(default_factory=list)
+    changed: list[dict[str, Any]] = field(default_factory=list)
+    removed: list[Any] = field(default_factory=list)
+    tool: str = ""
+    delta_tokens: int = 0
+    full_tokens: int = 0
+
+
+def _canonical_cell(v: Any) -> str:
+    """Canonicalize one value for the pack-root record (Section 10a.3).
+
+    Decoupled from the wire cell encoder: collision-free and record-safe, not
+    round-trippable. Typed literals stay bare (null is ``-``, booleans true/false,
+    numbers canonical); strings are ALWAYS quoted so they cannot collide with a
+    typed literal and any tab/newline inside is escaped.
+    """
+    if v is None:
+        return "-"
+    if isinstance(v, bool):  # must precede int: bool is a subclass of int
+        return "true" if v else "false"
+    if isinstance(v, (int, float)):
+        return format_number(float(v))
+    if isinstance(v, str):
+        return quote_string(v)
+    return quote_string(str(v))
+
+
+def generic_pack_root(s: GenericSet) -> str:
+    """Canonical pack root for a keyed set (gcf-pack-root-v1, generic profile, 10a.3).
+
+    Records and fields are sorted by unsigned UTF-8 byte order to match every SDK.
+    """
+    sorted_fields = sorted(s.fields, key=lambda x: x.encode("utf-8"))
+    records: list[str] = []
+    for row in s.rows:
+        parts = ["R"]
+        for f in sorted_fields:
+            parts.append(f)
+            parts.append(_canonical_cell(row.get(f)))
+        records.append("\t".join(parts) + "\n")
+    records.sort(key=lambda r: r.encode("utf-8"))
+    digest = hashlib.sha256("".join(records).encode("utf-8")).hexdigest()
+    return "sha256:" + digest
+
+
+def _index_by_key(s: GenericSet) -> dict[str, dict[str, Any]]:
+    m: dict[str, dict[str, Any]] = {}
+    for row in s.rows:
+        ident = _canonical_cell(row.get(s.key))
+        if ident in m:
+            raise ValueError(f"delta_invalid: duplicate identity {ident} for key {s.key!r}")
+        m[ident] = row
+    return m
+
+
+def _rows_equal(a: dict[str, Any], b: dict[str, Any], fields: list[str]) -> bool:
+    return all(_canonical_cell(a.get(f)) == _canonical_cell(b.get(f)) for f in fields)
+
+
+def diff_generic_sets(base: GenericSet, nxt: GenericSet) -> GenericDeltaPayload:
+    """Compute the delta from ``base`` to ``nxt`` (the blessed producer path).
+
+    Centralizes the keyed-diff invariants: identity uniqueness, added-not-in-base,
+    changed-must-exist, whole-row replacement, unchanged rows omitted. Output is
+    sorted by identity for reproducibility (10a.6). Schema change or a missing key
+    raises (caller must send full, 10a.7).
+    """
+    if not nxt.key:
+        raise ValueError("delta_invalid: no identity key")
+    if nxt.key != base.key or list(base.fields) != list(nxt.fields):
+        raise ValueError("delta_invalid: schema change (send full)")
+
+    base_by_id = _index_by_key(base)
+    next_by_id = _index_by_key(nxt)
+
+    d = GenericDeltaPayload(
+        key=nxt.key,
+        fields=list(nxt.fields),
+        base_root=generic_pack_root(base),
+        new_root=generic_pack_root(nxt),
+    )
+    for ident, row in next_by_id.items():
+        brow = base_by_id.get(ident)
+        if brow is None:
+            d.added.append(row)
+        elif not _rows_equal(brow, row, nxt.fields):
+            d.changed.append(row)
+        # equal rows are omitted (silence = "keep it", 10a.5)
+    for ident, brow in base_by_id.items():
+        if ident not in next_by_id:
+            d.removed.append(brow.get(nxt.key))
+
+    d.added.sort(key=lambda r: _canonical_cell(r.get(d.key)))
+    d.changed.sort(key=lambda r: _canonical_cell(r.get(d.key)))
+    d.removed.sort(key=_canonical_cell)
+    return d
+
+
+def _field_decl(fields: list[str], key: str) -> str:
+    return ",".join(("@" + format_key(f)) if f == key else format_key(f) for f in fields)
+
+
+def _encode_row(row: dict[str, Any], fields: list[str]) -> str:
+    return "|".join(format_scalar(row.get(f), "|") for f in fields)
+
+
+def encode_generic_full(s: GenericSet, tool: str = "") -> str:
+    """Emit a delta-participating full base payload: key= header, @id field, rows."""
+    name = s.name or "rows"
+    header = "GCF profile=generic"
+    if tool:
+        header += f" tool={tool}"
+    header += f" pack_root={generic_pack_root(s)} key={s.key}"
+    lines = [header, f"## {name} [{len(s.rows)}]{{{_field_decl(s.fields, s.key)}}}"]
+    lines += [_encode_row(row, s.fields) for row in s.rows]
+    return "\n".join(lines) + "\n"
+
+
+def encode_generic_delta(d: GenericDeltaPayload) -> str:
+    """Serialize a delta payload (10a.2). Sections ordered added/changed/removed."""
+    header = "GCF profile=generic"
+    if d.tool:
+        header += f" tool={d.tool}"
+    header += f" delta=true base_root={d.base_root} new_root={d.new_root} key={d.key}"
+    if d.full_tokens > 0:
+        savings = 100.0 * (1.0 - d.delta_tokens / d.full_tokens)
+        header += f" savings={savings:.0f}%"
+    lines = [header]
+    if d.added:
+        lines.append(f"## added [{len(d.added)}]{{{_field_decl(d.fields, d.key)}}}")
+        lines += [_encode_row(r, d.fields) for r in d.added]
+    if d.changed:
+        lines.append(f"## changed [{len(d.changed)}]{{{_field_decl(d.fields, d.key)}}}")
+        lines += [_encode_row(r, d.fields) for r in d.changed]
+    if d.removed:
+        lines.append(f"## removed [{len(d.removed)}]{{@{d.key}}}")
+        lines += [format_scalar(idv, "|") for idv in d.removed]
+    return "\n".join(lines) + "\n"
+
+
+def verify_generic_delta(base: GenericSet, d: GenericDeltaPayload, expected_new_root: str) -> GenericSet:
+    """Apply a delta to a base set and verify the result hashes to expected_new_root.
+
+    Atomic (10a.5): the whole payload is validated before any mutation; on failure the
+    base is left untouched and a ValueError is raised.
+    """
+    if generic_pack_root(base) != d.base_root:
+        raise ValueError("base_mismatch: base root does not equal delta base_root")
+    base_by_id = _index_by_key(base)
+
+    for idv in d.removed:
+        if _canonical_cell(idv) not in base_by_id:
+            raise ValueError(f"delta_invalid: removing identity {_canonical_cell(idv)} not in base")
+    for row in d.added:
+        if _canonical_cell(row.get(d.key)) in base_by_id:
+            raise ValueError(f"delta_invalid: adding identity {_canonical_cell(row.get(d.key))} that already exists")
+    for row in d.changed:
+        if _canonical_cell(row.get(d.key)) not in base_by_id:
+            raise ValueError(f"delta_invalid: changing identity {_canonical_cell(row.get(d.key))} not in base")
+
+    work = dict(base_by_id)
+    for idv in d.removed:
+        work.pop(_canonical_cell(idv), None)
+    for row in d.added:
+        work[_canonical_cell(row.get(d.key))] = row
+    for row in d.changed:
+        work[_canonical_cell(row.get(d.key))] = row
+
+    result = GenericSet(key=base.key, fields=list(base.fields), rows=list(work.values()), name=base.name)
+    got = generic_pack_root(result)
+    if got != expected_new_root:
+        raise ValueError(f"root_mismatch: computed {got}, expected {expected_new_root}")
+    return result
+
+
+# --- consumer-side wire parsing ---
+
+
+def _parse_header_fields(header: str) -> dict[str, str]:
+    m: dict[str, str] = {}
+    for tok in header.split():
+        if "=" in tok:
+            k, _, v = tok.partition("=")
+            if k:
+                m[k] = v
+    return m
+
+
+def _parse_count(s: str) -> int:
+    if s == "0":
+        return 0
+    if not s or s[0] == "0" or not s.isdigit():
+        raise ValueError(f"invalid_count: {s}")
+    return int(s)
+
+
+def _split_delta_field_decl(decl: str) -> tuple[list[str], str]:
+    if len(decl) < 2 or decl[0] != "{" or decl[-1] != "}":
+        raise ValueError(f"invalid field declaration: {decl}")
+    inner = decl[1:-1]
+    if inner == "":
+        return [], ""
+    fields: list[str] = []
+    key_field = ""
+    for raw in split_respecting_quotes(inner, ","):
+        f = raw.strip()
+        is_key = False
+        if f.startswith("@"):
+            f = f[1:]
+            is_key = True
+        if len(f) >= 2 and f[0] == '"' and f[-1] == '"':
+            from .scalar import parse_quoted_string
+
+            f = parse_quoted_string(f)
+        if is_key:
+            key_field = f
+        fields.append(f)
+    return fields, key_field
+
+
+def _parse_section_header(content: str) -> tuple[str, int, list[str], str]:
+    bi = content.find(" [")
+    if bi < 0:
+        raise ValueError(f"delta_invalid: section header without count: {content!r}")
+    name = content[:bi].strip()
+    rest = content[bi + 1:]  # "[N]{...}"
+    if not rest or rest[0] != "[":
+        raise ValueError(f"delta_invalid: malformed section header: {content!r}")
+    close = rest.find("]")
+    if close < 0:
+        raise ValueError(f"delta_invalid: unterminated count: {content!r}")
+    count = _parse_count(rest[1:close])
+    fields, key_field = _split_delta_field_decl(rest[close + 1:])
+    return name, count, fields, key_field
+
+
+def _parse_row(line: str, fields: list[str]) -> dict[str, Any]:
+    cells = split_respecting_quotes(line, "|")
+    if len(cells) != len(fields):
+        raise ValueError(f"delta_invalid: row has {len(cells)} cells, expected {len(fields)}: {line!r}")
+    return {f: parse_scalar(cells[i], True) for i, f in enumerate(fields)}
+
+
+def decode_generic_full(text: str) -> tuple[GenericSet, str]:
+    """Parse a delta-participating full base payload into (GenericSet, pack_root)."""
+    lines = text.rstrip("\n").split("\n")
+    if not lines:
+        raise ValueError("empty payload")
+    hdr = _parse_header_fields(lines[0])
+    if hdr.get("profile") != "generic":
+        raise ValueError("not a generic payload")
+    s = GenericSet(key=hdr.get("key", ""), fields=[], rows=[])
+    i = 1
+    while i < len(lines):
+        line = lines[i]
+        if not line.startswith("## "):
+            i += 1
+            continue
+        name, count, fields, key_field = _parse_section_header(line[3:])
+        s.name, s.fields = name, fields
+        if not s.key:
+            s.key = key_field
+        i += 1
+        for _ in range(count):
+            if i >= len(lines):
+                raise ValueError("delta_invalid: fewer rows than declared count")
+            s.rows.append(_parse_row(lines[i], fields))
+            i += 1
+    return s, hdr.get("pack_root", "")
+
+
+def decode_generic_delta(text: str) -> GenericDeltaPayload:
+    """Parse a delta payload (10a.2) into a GenericDeltaPayload for application."""
+    lines = text.rstrip("\n").split("\n")
+    if not lines:
+        raise ValueError("empty payload")
+    hdr = _parse_header_fields(lines[0])
+    if hdr.get("profile") != "generic":
+        raise ValueError("not a generic payload")
+    if hdr.get("delta") != "true":
+        raise ValueError("not a delta payload")
+    d = GenericDeltaPayload(
+        key=hdr.get("key", ""),
+        fields=[],
+        base_root=hdr.get("base_root", ""),
+        new_root=hdr.get("new_root", ""),
+        tool=hdr.get("tool", ""),
+    )
+    i = 1
+    while i < len(lines):
+        line = lines[i]
+        if not line.startswith("## "):
+            i += 1
+            continue
+        name, count, fields, key_field = _parse_section_header(line[3:])
+        if not d.key and key_field:
+            d.key = key_field
+        if not d.fields and name in ("added", "changed"):
+            d.fields = fields
+        i += 1
+        if name in ("added", "changed"):
+            rows = []
+            for _ in range(count):
+                if i >= len(lines):
+                    raise ValueError(f"delta_invalid: fewer rows than declared count in ## {name}")
+                rows.append(_parse_row(lines[i], fields))
+                i += 1
+            if name == "added":
+                d.added = rows
+            else:
+                d.changed = rows
+        elif name == "removed":
+            for _ in range(count):
+                if i >= len(lines):
+                    raise ValueError("delta_invalid: fewer identities than declared count in ## removed")
+                d.removed.append(parse_scalar(lines[i], True))
+                i += 1
+        else:
+            raise ValueError(f"delta_invalid: unknown delta section {name!r}")
+    return d
+
+
+# --- producer-side re-anchor session helper (SPEC Section 10a.8) ---
+#
+# GenericDeltaSession manages the re-anchor cadence for a stream of
+# generic-profile updates. It is thin sugar over the primitives: each ``next``
+# emits either a compact delta or, on its chosen cadence, a full re-anchor,
+# updating its held base. It introduces NO new wire syntax: every payload it
+# emits is exactly what ``encode_generic_full`` or ``encode_generic_delta``
+# produce, and the decoder accepts them cadence-agnostically. N and the size
+# guard are the helper's knobs; they are never wire fields. (Section 10a.8 is
+# non-normative producer policy.)
+
+
+# The working default cadence for FixedN (SPEC Section 10a.8).
+DEFAULT_REANCHOR_N = 15
+
+
+class ReanchorMode(Enum):
+    """Selects the session's cadence policy."""
+
+    FIXED_N = 0  # re-anchor every N turns
+    SIZE_GUARD = 1  # re-anchor once cumulative delta reaches the full payload's size
+
+
+@dataclass
+class ReanchorPolicy:
+    """Selects when a :class:`GenericDeltaSession` re-anchors.
+
+    Construct it with :func:`fixed_n` or :func:`size_guard`.
+    """
+
+    mode: ReanchorMode = ReanchorMode.FIXED_N
+    n: int = 0  # turns between anchors; FixedN only
+
+
+def fixed_n(n: int) -> ReanchorPolicy:
+    """Re-anchor every ``n`` turns. ``n <= 0`` falls back to ``DEFAULT_REANCHOR_N``."""
+    if n <= 0:
+        n = DEFAULT_REANCHOR_N
+    return ReanchorPolicy(mode=ReanchorMode.FIXED_N, n=n)
+
+
+def size_guard() -> ReanchorPolicy:
+    """Re-anchor once the cumulative delta bytes since the last anchor reach the
+    current full payload's byte size: it re-anchors more under heavy churn, rarely
+    under light churn, and bounds the delta spent between anchors to about one full
+    payload. Production-recommended.
+    """
+    return ReanchorPolicy(mode=ReanchorMode.SIZE_GUARD)
+
+
+def _byte_len(s: str) -> int:
+    """UTF-8 byte length, matching Go's ``len(string)`` (bytes, not code points)."""
+    return len(s.encode("utf-8"))
+
+
+class GenericDeltaSession:
+    """Holds the current base and re-anchor state for a producer loop.
+
+    Not safe for concurrent use. Call :meth:`current_full` to get the initial
+    full payload to transmit, then :meth:`next` for each subsequent state.
+    """
+
+    def __init__(self, base: GenericSet, tool: str, policy: ReanchorPolicy) -> None:
+        if policy.mode == ReanchorMode.FIXED_N and policy.n <= 0:
+            policy = ReanchorPolicy(mode=policy.mode, n=DEFAULT_REANCHOR_N)
+        self._base = base
+        self._tool = tool
+        self._policy = policy
+        self._turn = 0
+        self._cum = 0  # cumulative delta bytes since the last anchor
+
+    @property
+    def turn(self) -> int:
+        """The number of :meth:`next` calls so far (the initial full is turn 0)."""
+        return self._turn
+
+    def current_full(self) -> str:
+        """Return the full payload for the current base (:func:`encode_generic_full`).
+
+        Send this first to establish the base; it is also a valid manual re-anchor.
+        """
+        return encode_generic_full(self._base, self._tool)
+
+    def _reanchor(self, nxt: GenericSet) -> str:
+        wire = encode_generic_full(nxt, self._tool)
+        self._base = nxt
+        self._cum = 0
+        return wire
+
+    def next(self, nxt: GenericSet) -> tuple[str, bool]:
+        """Advance the session by one turn to ``nxt``.
+
+        Returns ``(wire, is_full)``: the wire to transmit and whether it is a full
+        re-anchor (``True``) or a delta (``False``). A schema change forces a full
+        (Section 10a.7). The held base becomes ``nxt`` either way. The wire is
+        byte-identical to calling ``encode_generic_full`` / ``encode_generic_delta``
+        directly. May raise on duplicate identity / no key (propagated from
+        :func:`diff_generic_sets`).
+        """
+        self._turn += 1
+
+        # Schema change (or a fresh key) cannot be expressed as a delta -> full.
+        if nxt.key != self._base.key or list(self._base.fields) != list(nxt.fields):
+            return self._reanchor(nxt), True
+
+        d = diff_generic_sets(self._base, nxt)
+        delta_wire = encode_generic_delta(d)
+
+        if self._policy.mode == ReanchorMode.SIZE_GUARD:
+            reanchor = self._cum + _byte_len(delta_wire) >= _byte_len(
+                encode_generic_full(nxt, self._tool)
+            )
+        else:  # FIXED_N
+            reanchor = self._turn % self._policy.n == 0
+
+        if reanchor:
+            return self._reanchor(nxt), True
+        self._base = nxt
+        self._cum += _byte_len(delta_wire)
+        return delta_wire, False

gcf/packroot.py

@@ -0,0 +1,53 @@
+"""GCF graph-profile pack root (gcf-pack-root-v1, SPEC Section 10.2).
+
+Computes the canonical pack root hash for a graph snapshot (symbols + edges).
+Mirrors the gcf-go reference implementation (packroot.go); the shared conformance
+fixtures (graph-pack-root/) hold both to identical bytes and hashes.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+from .constants import KIND_ABBREV
+from .scalar import format_number
+from .types import Edge, Symbol
+
+
+def pack_root(symbols: list[Symbol], edges: list[Edge]) -> str:
+    """Canonical pack root for a graph snapshot (gcf-pack-root-v1, graph profile, 10.2).
+
+    Symbol and edge records are sorted independently by unsigned UTF-8 byte order,
+    then concatenated (all symbols, then all edges) and hashed with SHA-256. Two
+    implementations given the same logical graph MUST produce the same result.
+    """
+    # Build canonical symbol records.
+    sym_records: list[str] = []
+    for s in symbols:
+        kind = KIND_ABBREV.get(s.kind, s.kind)
+        score = format_number(float(s.score))
+        sym_records.append(
+            f"S\t{kind}\t{s.qualified_name}\t{score}\t{s.provenance}\t{s.distance}\n"
+        )
+
+    # Map qualified_name -> kind abbreviation for edge endpoint resolution.
+    sym_kind_map: dict[str, str] = {}
+    for s in symbols:
+        sym_kind_map[s.qualified_name] = KIND_ABBREV.get(s.kind, s.kind)
+
+    # Build canonical edge records.
+    edge_records: list[str] = []
+    for e in edges:
+        src_kind = sym_kind_map.get(e.source, "")
+        tgt_kind = sym_kind_map.get(e.target, "")
+        edge_records.append(
+            f"E\t{src_kind}\t{e.source}\t{tgt_kind}\t{e.target}\t{e.edge_type}\n"
+        )
+
+    # Sort independently by unsigned UTF-8 byte order.
+    sym_records.sort(key=lambda r: r.encode("utf-8"))
+    edge_records.sort(key=lambda r: r.encode("utf-8"))
+
+    canonical = "".join(sym_records) + "".join(edge_records)
+    digest = hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+    return "sha256:" + digest

gcf/session.py

@@ -77,22 +77,32 @@ def encode_with_session(p: Payload, sess: Session | None = None) -> str:
 
     parts: list[str] = []
 
-    # Build local ID mapping for this response.
+    # Build session-stable ID mapping (matching the reference encoder):
+    # previously transmitted symbols keep their existing session-global ID;
+    # new symbols get the next available session IDs in payload order. These
+    # are NOT per-call local indices, so IDs stay stable across calls within a
+    # session (see graph-session conformance fixtures).
     local_index: dict[str, int] = {}
-    for i, s in enumerate(p.symbols):
-        local_index[s.qualified_name] = i
-
-    # Count valid edges.
-    valid_edges = sum(
-        1 for e in p.edges
-        if e.source in local_index and e.target in local_index
-    )
-
-    # Header with session=true marker.
-    header = (
-        f"GCF profile=graph tool={p.tool} budget={p.token_budget} tokens={p.tokens_used} "
-        f"symbols={len(p.symbols)} edges={valid_edges} session=true"
-    )
+    for s in p.symbols:
+        if sess.transmitted(s.qualified_name):
+            local_index[s.qualified_name] = sess.get_id(s.qualified_name)
+    next_new = sess.size()
+    for s in p.symbols:
+        if not sess.transmitted(s.qualified_name):
+            local_index[s.qualified_name] = next_new
+            next_new += 1
+
+    # Header with session=true marker. Omit budget/tokens/edges when zero,
+    # matching the reference encoder.
+    header = f"GCF profile=graph tool={p.tool}"
+    if p.token_budget > 0:
+        header += f" budget={p.token_budget}"
+    if p.tokens_used > 0:
+        header += f" tokens={p.tokens_used}"
+    header += f" symbols={len(p.symbols)}"
+    if p.edges:
+        header += f" edges={len(p.edges)}"
+    header += " session=true"
     if p.pack_root:
         header += f" pack_root={p.pack_root}"
     parts.append(header)
@@ -128,7 +138,7 @@ def encode_with_session(p: Payload, sess: Session | None = None) -> str:
 
     # Edges section.
     if p.edges:
-        parts.append(f"## edges [{valid_edges}]")
+        parts.append(f"## edges [{len(p.edges)}]")
         for e in p.edges:
             src_idx = local_index.get(e.source)
             tgt_idx = local_index.get(e.target)

gcf/stream.py

@@ -38,8 +38,10 @@ class StreamEncoder:
         tokens_used: int = 0,
         pack_root: str = "",
         session: bool = False,
+        labeled_trailer_counts: bool = False,
     ) -> None:
         self._w = writer
+        self._labeled_trailer_counts = labeled_trailer_counts
         self._lock = threading.Lock()
         self._sym_index: dict[str, int] = {}
         self._next_id = 0
@@ -122,22 +124,29 @@ class StreamEncoder:
     def close(self) -> None:
         """Emit ##! summary trailer with final counts."""
         with self._lock:
-            counts: list[str] = []
-            group_order = ["targets", "related", "extended"]
-
-            for g in group_order:
-                c = self._group_counts.get(g, 0)
-                if c > 0:
-                    counts.append(str(c))
-            for g, c in self._group_counts.items():
-                if g not in group_order and c > 0:
-                    counts.append(str(c))
-            if self._edge_count > 0:
-                counts.append(str(self._edge_count))
+            # Build label:count sections, then either emit as-is (labeled form,
+            # SPEC 8.4.1) or strip to values (default positional form).
+            # One entry per non-empty distance group in group-header emission order
+            # (SPEC 8.4). The dict preserves insertion order, which is the order the
+            # group headers were emitted, so the trailer is deterministic and matches
+            # the section order (including distance_N groups) across all SDKs.
+            sections: list[str] = [
+                f"{g}:{c}" for g, c in self._group_counts.items() if c > 0
+            ]
+            # The edge count is always the last counts entry, even when 0 (SPEC
+            # 8.4, 8.4.1): it keeps the positional form unambiguous and anchors the
+            # labeled form (minimal counts=edges:0). Zero-count distance groups are
+            # omitted, but edges is not.
+            sections.append(f"edges:{self._edge_count}")
+
+            if self._labeled_trailer_counts:
+                counts_str = ",".join(sections)
+            else:
+                counts_str = ",".join(s.split(":", 1)[1] for s in sections)
 
             self._w.write(
                 f"##! summary symbols={self._next_id} edges={self._edge_count}"
-                f" counts={','.join(counts)}\n"
+                f" counts={counts_str}\n"
             )
 
     @property

{gcf_python-2.2.2.dist-info → gcf_python-2.4.0.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: gcf-python
-Version: 2.2.2
-Summary: The AI-native wire format for structured data. 50-92% fewer tokens than JSON. 100% comprehension on every frontier model. Zero dependencies.
+Version: 2.4.0
+Summary: The AI-native wire format for structured data. 50-92% fewer tokens than JSON, with multi-turn delta encoding for agent loops. 100% comprehension on every frontier model. Zero dependencies.
 Project-URL: Homepage, https://github.com/blackwell-systems/gcf-python
-Project-URL: Documentation, https://blackwell-systems.github.io/gcf/
+Project-URL: Documentation, https://gcformat.com/
 Project-URL: Specification, https://github.com/blackwell-systems/gcf
 Author: Blackwell Systems
 License: MIT
 License-File: LICENSE
-Keywords: gcf,graph,llm,mcp,token-efficient,wire-format
-Classifier: Development Status :: 4 - Beta
+Keywords: agents,delta,gcf,graph,llm,mcp,multi-turn,token-efficient,wire-format
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -23,6 +23,10 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 
+<p align="center">
+  <img src="assets/gcf-python-diagram.png" alt="gcf-python" width="100%">
+</p>
+
 <p align="center">
   <a href="https://github.com/blackwell-systems"><img src="https://raw.githubusercontent.com/blackwell-systems/blackwell-docs-theme/main/badge-trademark.svg" alt="Blackwell Systems"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
@@ -119,7 +123,7 @@ enc = StreamEncoder(sys.stdout, "context_for_task", token_budget=5000)
 enc.write_symbol(Symbol(qualified_name="pkg.Auth", kind="function", score=0.95, provenance="lsp", distance=0))
 enc.write_symbol(Symbol(qualified_name="pkg.Server", kind="function", score=0.60, provenance="lsp", distance=1))
 enc.write_edge(Edge(source="pkg.Server", target="pkg.Auth", edge_type="calls"))
-enc.close()  # emits ## _summary trailer
+enc.close()  # emits ##! summary trailer
 ```
 
 Output:
@@ -131,7 +135,7 @@ GCF tool=context_for_task budget=5000
 @1 fn pkg.Server 0.60 lsp
 ## edges [?]
 @0<@1 calls
-## _summary symbols=2 edges=1 sections=targets:1,related:1,edges:1
+##! summary symbols=2 edges=1 counts=1,1,1
 ```
 
 The writer is any object with a `write(s: str)` method. Thread-safe. Standard `decode()` handles streaming output with no changes.
@@ -182,6 +186,44 @@ Output:
 
 Works on dicts, lists, and primitives. Lists of uniform dicts get tabular rows. Nested dicts use `## key` section headers.
 
+## Generic-Profile Delta (multi-turn)
+
+In an agent loop the same keyed table gets re-queried turn after turn. Instead of re-sending the whole table each time, send only the changed rows (SPEC §10a):
+
+```python
+from gcf import GenericSet, diff_generic_sets, encode_generic_delta, verify_generic_delta
+
+base = GenericSet(key="id", fields=["id", "status"], rows=[
+    {"id": 1001, "status": "pending"},
+    {"id": 1002, "status": "shipped"},
+])
+nxt = GenericSet(key="id", fields=["id", "status"], rows=[
+    {"id": 1001, "status": "shipped"},   # changed
+    {"id": 1003, "status": "pending"},   # added (1002 removed)
+])
+
+d = diff_generic_sets(base, nxt)
+wire = encode_generic_delta(d)                       # ## added / ## changed / ## removed
+held = verify_generic_delta(base, d, d.new_root)     # atomic apply + new_root verification
+```
+
+Opt-in and bilateral, keyed on content-addressed pack roots. By the 5th overlapping call, ~97% fewer tokens than re-sending JSON.
+
+### Re-anchor session helper
+
+`GenericDeltaSession` manages the delta/re-anchor cadence for you: each `next()` returns either a compact delta or, on its cadence, a full re-anchor (which re-grounds the consumer), updating its held base.
+
+```python
+from gcf import GenericDeltaSession, fixed_n, size_guard
+
+sess = GenericDeltaSession(base, tool="orders", policy=size_guard())
+wire = sess.current_full()                # transmit the base once to establish it
+for snapshot in stream:                   # each turn's current GenericSet
+    wire, is_full = sess.next(snapshot)    # a compact delta, or a periodic full re-anchor
+```
+
+`fixed_n(15)` re-anchors every N turns; `size_guard()` (recommended) re-anchors once the cumulative delta reaches a full payload's size. It introduces no new wire syntax and the decoder stays cadence-agnostic, so a re-anchor is just the protocol's "full" outcome on a schedule.
+
 ## API
 
 | Function | Description |
@@ -190,7 +232,11 @@ Works on dicts, lists, and primitives. Lists of uniform dicts get tabular rows.
 | `encode_generic(data: Any) -> str` | Encode any value to GCF tabular format |
 | `decode(input_text: str) -> Payload` | Parse GCF text back to a Payload |
 | `encode_with_session(p: Payload, s: Session) -> str` | Encode with session deduplication |
-| `encode_delta(d: DeltaPayload) -> str` | Encode a delta (added/removed only) |
+| `encode_delta(d: DeltaPayload) -> str` | Encode a graph delta (added/removed only) |
+| `diff_generic_sets(base, next) -> GenericDeltaPayload` | Diff two keyed record sets (generic profile) |
+| `encode_generic_delta(d) -> str` / `decode_generic_delta(s)` | Generic-profile delta wire (§10a) |
+| `verify_generic_delta(base, d, root) -> GenericSet` | Atomic apply + `new_root` verification |
+| `GenericDeltaSession(base, tool, policy)` | Producer-side re-anchor cadence helper (§10a.8) |
 | `Session()` | Create a new session tracker (thread-safe) |
 
 ## Types
@@ -200,7 +246,9 @@ Works on dicts, lists, and primitives. Lists of uniform dicts get tabular rows.
 | `Payload` | Full GCF payload: tool, budget, symbols, edges, pack root |
 | `Symbol` | Graph node: qualified name, kind, score, provenance, distance |
 | `Edge` | Directed relationship: source, target, edge type |
-| `DeltaPayload` | Diff between two packs: added/removed symbols and edges |
+| `DeltaPayload` | Diff between two graph packs: added/removed symbols and edges |
+| `GenericSet` / `GenericDeltaPayload` | Keyed record set and its generic-profile diff (§10a) |
+| `GenericDeltaSession` | Stateful producer that schedules delta vs full re-anchor (§10a.8) |
 | `Session` | Thread-safe tracker for multi-call deduplication |
 | `KIND_ABBREV` / `KIND_EXPAND` | Bidirectional kind abbreviation dicts |
 

gcf_python-2.4.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+gcf/__init__.py,sha256=dZkdcjbG-dcolg_7TBROjRq3opftDGU423ankMIOhyA,2616
+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=ozYmGiZu9S1zTGsN1PuMTF8soV53eq1v5PXMx2YNgWQ,27888
+gcf/delta.py,sha256=oviQ9WsDRYXPXE8bw6SFutmzMRIvu-U_Zzw-39Nd5Ic,8053
+gcf/encode.py,sha256=OYGDyF3oP2I8Y2PrPL_5yDVURqB0mghtqlOGyDEd-Fs,4081
+gcf/generic.py,sha256=t0Px1fAoWsmFFeICbL65LL8UTGFfnbh4PCanvMMKqYs,18198
+gcf/generic_delta.py,sha256=GU7CNumz3PQhC0Xs5pO30Nb3ACvSorHEQMu-4kazpFM,17838
+gcf/packroot.py,sha256=0rZY7TEVcLzA8XhoIOc6_g9lbRCn-MUr54YTRVhzsO4,2019
+gcf/scalar.py,sha256=MZay-KIROvaFHet-g2-pBghahT1bf_5bxZjG4yTZkSo,9329
+gcf/session.py,sha256=rPqR4xsHKpi_G37t1ODwkTUdHhVAGa3Uig8F60h34Ms,5335
+gcf/stream.py,sha256=3eyzmLMZPyEGC1MS9pujxio2x_t7rCL-eNuJ4DjYkaA,5938
+gcf/stream_generic.py,sha256=RnqqiPSu5joJa-7e58QbbzSGfvxBICA587A3aArjZvE,3250
+gcf/types.py,sha256=AWm-LQoSqLHAYtEjcAxWQZqJ4JXqNreLUKO2mJFgNMA,1465
+gcf_python-2.4.0.dist-info/METADATA,sha256=xDum3Ytd_7KX6SP8940MQDWL08VAwmbdkQuc-nkzN6M,13115
+gcf_python-2.4.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+gcf_python-2.4.0.dist-info/entry_points.txt,sha256=aFT6gqlkh8iGfM8cblE-LUMxHH08_v71IIoZtDdRIVA,37
+gcf_python-2.4.0.dist-info/licenses/LICENSE,sha256=2Fit9wnaIe--RMSAgyQqxC5hfZTyZqn4fIdBtp9qPDw,1072
+gcf_python-2.4.0.dist-info/RECORD,,

gcf_python-2.2.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-gcf/__init__.py,sha256=ZPd4iye7cr6HgIsFoe6Lq7Qd3mmIAyVhfjjn5AwID2E,1776
-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=ZlFZqwenOzCnvbJijKscb6aQHoHQ81qoHBkaalVbqqo,26381
-gcf/delta.py,sha256=f90UC6zejXH-ujyU_OViWDCqnxLXk3i6Qion-RJGHY4,1670
-gcf/encode.py,sha256=CcqMSNmojrQAAw2X3MNfw8YR6l4rNw9hWDqwmf846oA,2929
-gcf/generic.py,sha256=t0Px1fAoWsmFFeICbL65LL8UTGFfnbh4PCanvMMKqYs,18198
-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.2.2.dist-info/METADATA,sha256=J-3Wr4vqhMqAucwtl4rhHBWBYUYCr3itkFla6FhLuqU,10489
-gcf_python-2.2.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-gcf_python-2.2.2.dist-info/entry_points.txt,sha256=aFT6gqlkh8iGfM8cblE-LUMxHH08_v71IIoZtDdRIVA,37
-gcf_python-2.2.2.dist-info/licenses/LICENSE,sha256=2Fit9wnaIe--RMSAgyQqxC5hfZTyZqn4fIdBtp9qPDw,1072
-gcf_python-2.2.2.dist-info/RECORD,,