hg-cpp 0.3.0__tar.gz → 0.3.1__tar.gz

{hg_cpp-0.3.0 → hg_cpp-0.3.1}/.github/workflows/build.yml

@@ -34,24 +34,20 @@ jobs:
         env:
           RELEASE_TAG: ${{ github.ref_name }}
         run: |
-          from pathlib import Path
           from urllib.error import HTTPError
           from urllib.request import urlopen
           import os
           import re
-          import tomllib
 
           tag = os.environ["RELEASE_TAG"]
           match = re.fullmatch(r"v_(\d+\.\d+\.\d+)", tag)
           if match is None:
               raise SystemExit(f"release tag must match v_x.x.x, got {tag!r}")
 
-          project = tomllib.loads(Path("pyproject.toml").read_text())["project"]
+          # The TAG is the version authority: the project version in
+          # pyproject.toml is ignored for releases (the publish job restamps
+          # the tested artifacts' metadata to the tag version).
           version = match.group(1)
-          if project["version"] != version:
-              raise SystemExit(
-                  f"tag {tag!r} does not match project version {project['version']!r}"
-              )
 
           try:
               with urlopen(f"https://pypi.org/pypi/hg_cpp/{version}/json"):
@@ -318,6 +314,117 @@ jobs:
           merge-multiple: true
           github-token: ${{ github.token }}
           run-id: ${{ needs.reuse-build.outputs.run-id || github.run_id }}
+      - name: Restamp distributions to the tag version
+        shell: python
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          # The TAG is the version authority. The distributions were built
+          # (and fully tested) at whatever version pyproject.toml carried -
+          # rewriting the version is a METADATA-ONLY operation, so the
+          # expensive compiled artifacts are reused byte-identical.
+          import base64
+          import csv
+          import hashlib
+          import io
+          import os
+          import re
+          import tarfile
+          import zipfile
+          from pathlib import Path
+
+          version = os.environ["RELEASE_TAG"].removeprefix("v_")
+
+          def record_hash(data: bytes) -> str:
+              digest = base64.urlsafe_b64encode(hashlib.sha256(data).digest())
+              return "sha256=" + digest.decode().rstrip("=")
+
+          def restamp_wheel(path: Path) -> None:
+              name, old_version, rest = path.name.split("-", 2)
+              if old_version == version:
+                  print(f"{path.name}: already at {version}")
+                  return
+              old_info = f"{name}-{old_version}.dist-info"
+              new_info = f"{name}-{version}.dist-info"
+              entries = {}
+              with zipfile.ZipFile(path) as archive:
+                  for item in archive.infolist():
+                      entries[item.filename] = archive.read(item.filename)
+              renamed = {}
+              for item_name, data in entries.items():
+                  new_name = item_name.replace(old_info + "/", new_info + "/")
+                  if new_name == f"{new_info}/METADATA":
+                      text = data.decode()
+                      text, count = re.subn(rf"(?m)^Version: {re.escape(old_version)}$",
+                                            f"Version: {version}", text, count=1)
+                      assert count == 1, "wheel METADATA Version line not found"
+                      data = text.encode()
+                  renamed[new_name] = data
+              record_name = f"{new_info}/RECORD"
+              rows = []
+              for row in csv.reader(io.StringIO(renamed[record_name].decode())):
+                  if not row:
+                      continue
+                  entry = row[0].replace(old_info + "/", new_info + "/")
+                  if entry == record_name:
+                      rows.append([entry, "", ""])
+                  else:
+                      data = renamed[entry]
+                      rows.append([entry, record_hash(data), str(len(data))])
+              buffer = io.StringIO(newline="")
+              csv.writer(buffer, lineterminator="\n").writerows(rows)
+              renamed[record_name] = buffer.getvalue().encode()
+              new_path = path.with_name(path.name.replace(f"-{old_version}-", f"-{version}-", 1))
+              with zipfile.ZipFile(new_path, "w", zipfile.ZIP_DEFLATED) as archive:
+                  for item_name, data in renamed.items():
+                      archive.writestr(item_name, data)
+              if new_path != path:
+                  path.unlink()
+              print(f"{path.name} -> {new_path.name}")
+
+          def restamp_sdist(path: Path) -> None:
+              name, old_version = path.name.removesuffix(".tar.gz").rsplit("-", 1)
+              if old_version == version:
+                  print(f"{path.name}: already at {version}")
+                  return
+              old_root = f"{name}-{old_version}"
+              new_root = f"{name}-{version}"
+              members = []
+              with tarfile.open(path, "r:gz") as archive:
+                  for member in archive.getmembers():
+                      data = archive.extractfile(member).read() if member.isfile() else None
+                      member.name = member.name.replace(old_root, new_root, 1)
+                      # long (>100 char) paths ride PAX 'path' headers which
+                      # would override the renamed member.name at write time.
+                      member.pax_headers.pop("path", None)
+                      member.pax_headers.pop("linkpath", None)
+                      if member.name == f"{new_root}/PKG-INFO":
+                          text = data.decode()
+                          text, count = re.subn(rf"(?m)^Version: {re.escape(old_version)}$",
+                                                f"Version: {version}", text, count=1)
+                          assert count == 1, "sdist PKG-INFO Version line not found"
+                          data = text.encode()
+                      elif member.name == f"{new_root}/pyproject.toml":
+                          text = data.decode()
+                          text, count = re.subn(r'(?m)^version = "[^"]+"$',
+                                                f'version = "{version}"', text, count=1)
+                          assert count == 1, "sdist pyproject.toml version not found"
+                          data = text.encode()
+                      if data is not None:
+                          member.size = len(data)
+                      members.append((member, data))
+              new_path = path.with_name(f"{new_root}.tar.gz")
+              with tarfile.open(new_path, "w:gz") as archive:
+                  for member, data in members:
+                      archive.addfile(member, io.BytesIO(data) if data is not None else None)
+              if new_path != path:
+                  path.unlink()
+              print(f"{path.name} -> {new_path.name}")
+
+          for wheel in sorted(Path("dist").glob("*.whl")):
+              restamp_wheel(wheel)
+          for sdist in sorted(Path("dist").glob("*.tar.gz")):
+              restamp_sdist(sdist)
       - name: Publish package distributions to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
         with:

{hg_cpp-0.3.0 → hg_cpp-0.3.1}/CLAUDE.md

@@ -196,6 +196,22 @@ dynamic-TSL multiplexing/reduce, non-associative reduce, sink maps/switches.
 **C++ only for
 now** — keep Python out of the configure/build/run path.
 
+**Python operator-test port — DONE (2026-07-11).** All **48** upstream
+`hgraph_unit_tests/_operators` files are ported into `python/tests/ported`
+(ctest gate `hgraph_python_ported_suite`, ~790 tests green). En route the
+runtime gained: real py-node input activity, first-class **enums**, the
+**TABLE tuple-row protocol** + data-frame operators (`record_replay_table.rst`
+step 6), `exception_time_series` bridged, `type_`, TSW `std`, tuple-of-CS
+`getattr_`, strict unnamed-TSB combine, and **map value holes** (None-valued
+entries; scalar.rst). Calling conventions are REGISTRY-driven (scalar kwargs
+lift to const in call normalisation; subscript meaning via
+`operator_output_is_selective`; generic targets via
+`resolve_convert/collect/combine_target` — never label/name tests in the
+bridge). Standing residue (marked precisely in the tests, see
+`parity_matrix.rst`): 3 accepted gaps (TSS rebind removals, sparse TSB
+deltas, `hgraph.stream` generics) + recorded deviations. Follow-on tiers
+(not planned): upstream `ts_tests/` (215), `_wiring/` (244).
+
 **Mesh, services & shared outputs — DONE** (design records:
 `docs/source/developer_guide/mesh.rst` and `docs/source/developer_guide/services.rst`,
 authoritative). `mesh_` over TSD executes (on-demand instances via

{hg_cpp-0.3.0 → hg_cpp-0.3.1}/CMakeLists.txt

@@ -165,7 +165,16 @@ if(HGRAPH_BUILD_PYTHON_BINDINGS)
         $<BUILD_INTERFACE:simdjson::simdjson>
     )
 else()
+    # json_impl.cpp uses simdjson::dom::element_type::BIGINT, introduced in
+    # simdjson 4.5 (the FetchContent path above pins v4.6.4). Distro packages
+    # can be older (Ubuntu 24.04 ships 3.x), so enforce the floor here. The
+    # check is explicit because simdjson's package version file uses
+    # same-minor compatibility, which would also reject newer 4.x releases.
     find_package(simdjson CONFIG REQUIRED)
+    if(simdjson_VERSION VERSION_LESS 4.5)
+        message(FATAL_ERROR "hgraph requires simdjson >= 4.5 for "
+            "dom::element_type::BIGINT; found ${simdjson_VERSION}")
+    endif()
     target_link_libraries(hgraph_options INTERFACE simdjson::simdjson)
 endif()
 
@@ -504,6 +513,7 @@ if(EXISTS "${PROJECT_SOURCE_DIR}/tools/debugger")
         FILES_MATCHING
             PATTERN "*.py"
             PATTERN "README.md"
+            PATTERN "__pycache__" EXCLUDE
     )
 endif()
 
@@ -519,6 +529,15 @@ set(_hgraph_config_dependencies
     "find_dependency(Arrow CONFIG)\n"
     "find_dependency(ArrowCompute CONFIG)\n"
     "find_dependency(spdlog CONFIG)\n"
+    # Both installed-config flavours reference simdjson::simdjson (the
+    # non-bindings export links it; the bindings config re-links it below),
+    # and the code needs dom::element_type::BIGINT from simdjson 4.5. The
+    # floor is an explicit check because simdjson's package version file
+    # uses same-minor compatibility.
+    "find_dependency(simdjson CONFIG)\n"
+    "if(simdjson_VERSION VERSION_LESS 4.5)\n"
+    "  message(FATAL_ERROR \"hgraph requires simdjson >= 4.5; found \${simdjson_VERSION}\")\n"
+    "endif()\n"
 )
 if(HGRAPH_BUILD_PYTHON_BINDINGS OR HGRAPH_ENABLE_PYTHON_USER_NODES)
     if(_hgraph_use_python_stable_abi)

{hg_cpp-0.3.0 → hg_cpp-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: hg_cpp
-Version: 0.3.0
+Version: 0.3.1
 Summary: Preview distribution of the C++ first hgraph runtime and Python compatibility bridge
 Keywords: reactive,graph,forward propagating graph,time series,functional reactive programming,c++
 Author-Email: Howard Henson <howard@henson.me.uk>

{hg_cpp-0.3.0 → hg_cpp-0.3.1}/docs/source/developer_guide/build_system.rst

@@ -18,6 +18,24 @@ Current Targets
 ``hgraph_core``
     Core runtime target. This is exported publicly as ``hgraph::core``.
 
+Third-Party Dependencies
+------------------------
+
+``simdjson`` **requires version 4.5 or newer** — ``json_impl.cpp`` uses
+``simdjson::dom::element_type::BIGINT``, which first appeared in 4.5. Wheel
+builds (``HGRAPH_BUILD_PYTHON_BINDINGS=ON``) fetch a pinned release (currently
+v4.6.4) and link it statically; the default C++ build resolves a system package
+via ``find_package(simdjson CONFIG REQUIRED)`` followed by an explicit
+``simdjson_VERSION`` check, which rejects older distro packages (Ubuntu 24.04
+ships 3.x) at configure time instead of failing mid compile. The check is
+explicit rather than a ``find_package`` version argument because simdjson's
+package version file uses same-minor compatibility (requesting 4.5 would
+reject 4.6.x). The installed ``hgraphConfig.cmake`` carries the same floor.
+
+``HGRAPH_WARNINGS_AS_ERRORS`` applies to this project's targets only;
+third-party dependencies such as simdjson build with their own flags and are
+not expected to be warning-clean under ours.
+
 Version Header
 --------------
 

{hg_cpp-0.3.0 → hg_cpp-0.3.1}/docs/source/developer_guide/data_structures/overview/structural_layers.rst

@@ -109,11 +109,11 @@ Core elements:
     Runtime bindings for graph inputs, outputs, nested graph boundaries, and parent/child graph communication.
 
 ``GraphStorage``
-    Memory owned by the graph instance. A compiled graph binding carries a
+    Memory owned by the graph instance. A compiled graph type record carries a
     fixed-size storage plan with a graph header, a heterogeneous node-storage
     tuple, and a parallel ``DateTime`` schedule array sized from the graph
-    topology. The graph binding also carries the node-location table that maps
-    ``node_index`` to ``(NodeTypeBinding, storage_offset)``. Creating a graph
+    topology. The graph record's ops context also carries the node-location table that maps
+    ``node_index`` to ``(NodeTypeRef, storage_offset)``. Creating a graph
     instance therefore performs one graph storage allocation rather than
     allocating separate vectors for nodes and schedules.
 

{hg_cpp-0.3.0 → hg_cpp-0.3.1}/docs/source/developer_guide/data_structures/plans_and_ops/erased_types.rst

@@ -43,36 +43,40 @@ This is the load-bearing reason values are type-erased rather than
 generic-templated: it lets the time-series layer reuse the value-layer
 container vocabulary without forking the surface.
 
-Binding: the shared anchor
---------------------------
+Type record: the shared anchor
+------------------------------
 
-Type erasure is held together by a *binding*: an interned triple of
-schema, plan, and ops that every erased handle dereferences:
+Value type erasure is held together by the common ``TypeRecord``. It records
+the schema, family role, storage plan, ops table, capabilities, and optional
+debug descriptor for one implementation:
 
 .. code-block:: cpp
 
-   template <typename TypeMeta, typename Ops>
-   struct TypeBinding {
-       const TypeMeta*                 type_meta;
-       const MemoryUtils::StoragePlan* storage_plan;
-       const Ops*                      ops;
+   struct TypeRecord {
+       TypeRole                        role;
+       TypeCapabilities                capabilities;
+       const SchemaHeader*             schema;
+       const MemoryUtils::StoragePlan* plan;
+       const void*                     ops;
+       const DebugDescriptor*          debug;
    };
 
-   using ValueTypeBinding = TypeBinding<ValueTypeMetaData, ValueOps>;
+   class ValueTypeRef {
+       const TypeRecord* record;
+   };
 
-A ``Value``, a ``ValueView``, or a ``Builder`` stores one borrowed
-pointer to its binding and reaches schema, plan, lifecycle, and ops
-uniformly through it.
+A ``ValueTypeRef`` is a one-word, trivially-copyable typed reference to a
+value-family ``Instance`` record. ``Value``, ``ValueView``, and builders use
+it to reach schema, plan, lifecycle, capabilities, and ``ValueOps``.
 
-Bindings are interned by ``(type, plan, ops)`` triple. Builders are
-interned by schema. Each registry exists only to expose a typed
-convenience API on top of one ``InternTable`` instance, so the
-interning contract is uniform across all erased shapes.
+``intern_value_type`` interns one record per ``(schema header, Instance role,
+plan, ops)`` key in ``TypeRecordRegistry``. ``ValuePlanFactory`` caches
+``schema -> ValueTypeRef`` by value; there is no value-family binding side
+registry.
 
-Composite bindings populate lazily. The first request for a tuple,
-list, map, or other container schema synthesises its plan from the
-element/key bindings, interns the resulting binding, and stores the
-builder.
+Composite types populate lazily. The first ``type_for`` request for a tuple,
+list, map, or other container schema synthesises its plan from child type
+refs and interns the resulting common record.
 
 The View
 --------
@@ -81,17 +85,22 @@ A view is the type-erased non-owning handle:
 
 .. code-block:: cpp
 
-   struct ValueViewContext {
-       const ValueTypeBinding* binding;
-       void*                   data;
+   class ValueView {
+       ValuePtr pointer; // tagged TypeRecord pointer + borrowed data pointer
    };
 
-The binding gives the view its schema, plan, lifecycle, and ops; the
-data pointer addresses the live payload. The base ``ValueView`` context
-is two pointers, so it is cheap to copy and pass through internal
-traversal code. Specialised view adapters carry at least this context
-and may cache resolved ops or layout facts established at construction
-time.
+The record gives the view its schema, plan, lifecycle, capabilities, and ops;
+the data pointer addresses the borrowed payload. ``ValueView`` is exactly two
+words and is move-only. Specialised view adapters carry at least this context
+and may cache resolved ops or layout facts established at construction time.
+
+Record structure and value-family identity are validated when records are
+interned and when a generic ``AnyPtr`` is narrowed with
+``ValueTypeRef::checked``. A ``ValueView`` constructed from that trusted
+``ValueTypeRef`` reads its record, payload, and access tag directly; ordinary
+``valid()``, ``has_value()``, and typed value operations do not repeat
+``TypeRecord::valid`` on every access. Explicit access-mode transitions, such
+as opening a mutation view, retain their transition checks.
 
 A view exposes:
 
@@ -101,7 +110,7 @@ A view exposes:
   atomic kinds;
 - generic ops: ``hash()``, ``equals()``, ``compare()``, ``to_string()``,
   ``clone()``, ``copy_from()``, ``try_copy_from()``
-  — routed through the binding; ``compare()`` returns
+  — routed through the type record; ``compare()`` returns
   ``std::partial_ordering`` as the common erased representation of
   ``operator<=>`` results. Compact containers use their bound ops table,
   while structured tuple/bundle/fixed-list views recurse through child
@@ -136,7 +145,7 @@ Both families are mirrored on the owning ``Value`` itself
 ``Value`` do not need to dereference into a ``ValueView`` and then
 cast again.
 
-These casts only re-interpret the existing binding's view shape. They
+These casts only re-interpret the existing type record's view shape. They
 do not change the underlying schema or copy the payload. Cross-schema
 adaptation — exposing one schema's value through a different schema —
 is a time-series concern, not a value-layer concern.
@@ -166,7 +175,7 @@ discipline:
   key insertion and value updates on maps, and so on.
 
 The generic erased handle can represent writable and mutable states
-without adding a third pointer word: the binding pointer carries a
+without adding a third pointer word: the type-record pointer carries a
 small tag. A mutable view is obtained from a writable view by calling
 ``begin_mutation()``. The transition is explicit so that consumers can
 reason about when mutation is in scope — the time-series layer in
@@ -227,7 +236,7 @@ Specialised Views
 
 Each kind has a specialised **read-only** view that adds kind-specific
 access on top of ``ValueView``. Specialised views hold at least the
-same ``(binding, data)`` context as ``ValueView`` and may cache
+same ``ValuePtr`` context as ``ValueView`` and may cache
 resolved ops pointers or other construction-time facts to keep later
 calls free of repeated validation. Most share an ``IndexedValueView``
 base for the kinds that are addressed positionally.