hg-cpp 0.3.0__tar.gz

hg_cpp-0.3.0/.github/workflows/build.yml

@@ -0,0 +1,324 @@
+name: Build, test, and publish Python distributions
+
+on:
+  push:
+    branches:
+      - "**"
+    tags:
+      - "v_*.*.*"
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  actions: read
+  contents: read
+
+jobs:
+  validate-release:
+    name: Validate release metadata
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Validate package metadata
+        run: |
+          python -m pip install --upgrade trove-classifiers
+          python python/tests/test_packaging.py
+      - name: Validate release tag
+        if: github.ref_type == 'tag'
+        shell: python
+        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"]
+          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"):
+                  pass
+          except HTTPError as error:
+              if error.code != 404:
+                  raise
+          else:
+              raise SystemExit(f"hg_cpp {version} already exists on PyPI")
+
+          print(f"Validated new hg_cpp release {version}")
+
+  reuse-build:
+    name: Find tested distributions for this commit
+    needs: validate-release
+    runs-on: ubuntu-latest
+    outputs:
+      run-id: ${{ steps.find.outputs.run-id }}
+    steps:
+      - name: Find successful build by commit SHA
+        id: find
+        if: github.ref_type == 'tag'
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const requiredArtifacts = new Set([
+              "distribution-sdist",
+              "distribution-wheel-macos-26",
+              "distribution-wheel-ubuntu-latest",
+              "distribution-wheel-windows-latest",
+            ]);
+            const runs = await github.paginate(
+              github.rest.actions.listWorkflowRuns,
+              {
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                workflow_id: "build.yml",
+                event: "push",
+                head_sha: context.sha,
+                status: "success",
+                per_page: 100,
+              },
+            );
+
+            for (const run of runs) {
+              if (run.head_sha !== context.sha || run.id === context.runId) {
+                continue;
+              }
+
+              const artifacts = await github.paginate(
+                github.rest.actions.listWorkflowRunArtifacts,
+                {
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  run_id: run.id,
+                  per_page: 100,
+                },
+              );
+              const availableArtifacts = new Set(
+                artifacts
+                  .filter((artifact) => !artifact.expired)
+                  .map((artifact) => artifact.name),
+              );
+              if ([...requiredArtifacts].every((name) => availableArtifacts.has(name))) {
+                core.notice(`Reusing tested distributions from workflow run ${run.id}`);
+                core.setOutput("run-id", String(run.id));
+                return;
+              }
+            }
+
+            core.notice(`No reusable distributions found for commit ${context.sha}`);
+            core.setOutput("run-id", "");
+
+  build-wheel:
+    name: Build ${{ matrix.os }} wheel
+    needs:
+      - validate-release
+      - reuse-build
+    if: needs.reuse-build.outputs.run-id == ''
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            parallel: "2"
+            cmake_args: -DHGRAPH_WARNINGS_AS_ERRORS=ON
+          - os: windows-latest
+            parallel: "2"
+            cmake_args: -DHGRAPH_WARNINGS_AS_ERRORS=OFF
+          - os: macos-26
+            parallel: "1"
+            cmake_args: -DHGRAPH_WARNINGS_AS_ERRORS=OFF -DCMAKE_OSX_DEPLOYMENT_TARGET=15.0
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Configure current Clang on macOS
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          echo "CC=/usr/bin/clang" >> "$GITHUB_ENV"
+          echo "CXX=/usr/bin/clang++" >> "$GITHUB_ENV"
+          echo "MACOSX_DEPLOYMENT_TARGET=15.0" >> "$GITHUB_ENV"
+          /usr/bin/clang++ --version
+      - name: Install wheel build tools
+        run: python -m pip install --upgrade build abi3audit
+      - name: Build stable ABI wheel
+        env:
+          CMAKE_ARGS: ${{ matrix.cmake_args }}
+          CMAKE_BUILD_PARALLEL_LEVEL: ${{ matrix.parallel }}
+        run: python -m build --wheel
+      - name: Repair Linux wheel
+        if: runner.os == 'Linux'
+        run: |
+          python -m pip install --upgrade auditwheel
+          mkdir wheelhouse
+          auditwheel repair \
+            --exclude libarrow.so.2400 \
+            --exclude libarrow_compute.so.2400 \
+            --wheel-dir wheelhouse \
+            dist/*.whl
+          rm dist/*.whl
+          mv wheelhouse/*.whl dist/
+      - name: Verify wheel ABI
+        shell: python
+        run: |
+          from pathlib import Path
+          import subprocess
+          import sys
+
+          wheels = list(Path("dist").glob("*.whl"))
+          assert len(wheels) == 1, wheels
+          wheel = wheels[0]
+          assert wheel.name.startswith("hg_cpp-"), wheel.name
+          assert "-cp312-abi3-" in wheel.name, wheel.name
+          if sys.platform == "darwin":
+              assert "-macosx_15_0_arm64.whl" in wheel.name, wheel.name
+          elif sys.platform == "win32":
+              assert wheel.name.endswith("-win_amd64.whl"), wheel.name
+          else:
+              assert wheel.name.endswith("_x86_64.whl"), wheel.name
+          subprocess.check_call(["abi3audit", "--strict", str(wheel)])
+      - uses: actions/upload-artifact@v7
+        with:
+          name: distribution-wheel-${{ matrix.os }}
+          path: dist/*.whl
+          if-no-files-found: error
+
+  build-sdist:
+    name: Build source distribution
+    needs:
+      - validate-release
+      - reuse-build
+    if: needs.reuse-build.outputs.run-id == ''
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Build source distribution
+        run: |
+          python -m pip install --upgrade build
+          python -m build --sdist
+      - name: Verify source distribution
+        shell: python
+        run: |
+          from pathlib import Path
+          import tomllib
+
+          version = tomllib.loads(Path("pyproject.toml").read_text())["project"]["version"]
+          archives = list(Path("dist").glob("*.tar.gz"))
+          assert len(archives) == 1, archives
+          assert archives[0].name == f"hg_cpp-{version}.tar.gz", archives[0].name
+      - uses: actions/upload-artifact@v7
+        with:
+          name: distribution-sdist
+          path: dist/*.tar.gz
+          if-no-files-found: error
+
+  test-wheel:
+    name: Test ${{ matrix.os }} / Python ${{ matrix.python-version }}
+    needs:
+      - reuse-build
+      - build-wheel
+    if: needs.reuse-build.outputs.run-id == ''
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-26
+        python-version:
+          - "3.12"
+          - "3.13"
+          - "3.14"
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+      - uses: actions/download-artifact@v7
+        with:
+          name: distribution-wheel-${{ matrix.os }}
+          path: dist
+      - name: Install wheel and test dependencies
+        shell: python
+        run: |
+          from pathlib import Path
+          import subprocess
+          import sys
+
+          wheels = list(Path("dist").glob("*.whl"))
+          assert len(wheels) == 1, wheels
+          subprocess.check_call([
+              sys.executable, "-m", "pip", "install", "--upgrade",
+              str(wheels[0]), "pytest>=8", "frozendict>=2.4", "trove-classifiers",
+          ])
+      - name: Confirm installed distribution
+        run: python -c "import importlib.metadata as m; import _hgraph; print(m.version('hg_cpp'), _hgraph.__file__)"
+      - name: Run Python compatibility suite
+        run: python -m pytest python/tests -q -m "not wip"
+
+  publish:
+    name: Publish hg_cpp to PyPI
+    if: >-
+      always() &&
+      startsWith(github.ref, 'refs/tags/v_') &&
+      needs.validate-release.result == 'success' &&
+      needs.reuse-build.result == 'success' &&
+      (
+        needs.reuse-build.outputs.run-id != '' ||
+        (needs.build-sdist.result == 'success' && needs.test-wheel.result == 'success')
+      )
+    needs:
+      - validate-release
+      - reuse-build
+      - build-sdist
+      - test-wheel
+    runs-on: ubuntu-latest
+    environment:
+      name: release
+      url: https://pypi.org/p/hg_cpp
+    permissions:
+      actions: read
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          pattern: distribution-*
+          path: dist
+          merge-multiple: true
+          github-token: ${{ github.token }}
+          run-id: ${{ needs.reuse-build.outputs.run-id || github.run_id }}
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

hg_cpp-0.3.0/.gitignore

@@ -0,0 +1,12 @@
+/docs/build/
+/dist/
+/wheelhouse/
+/CMakeFiles/
+/.idea/
+/cmake-build*/
+/*build*/
+/**/__pycache__/
+/docs/_build/
+/REVIEW.md
+
+.claude/

hg_cpp-0.3.0/.gitmodules

@@ -0,0 +1,12 @@
+[submodule "ext/2603"]
+	path = ext/2603
+	url = /Users/hhenson/CLionProjects/hgraph_2
+	branch = ts_value_2603
+[submodule "ext/2604"]
+	path = ext/2604
+	url = /Users/hhenson/CLionProjects/hgraph_1
+	branch = ts_value_26_04
+[submodule "ext/main"]
+	path = ext/main
+	url = git@github.com:hhenson/hgraph.git
+	branch = main

hg_cpp-0.3.0/.readthedocs.yaml

@@ -0,0 +1,13 @@
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.12"
+
+sphinx:
+  configuration: docs/source/conf.py
+
+python:
+  install:
+    - requirements: docs/requirements.txt

hg_cpp-0.3.0/AGENTS.md

@@ -0,0 +1,70 @@
+# AGENTS.md
+
+## Project Direction
+
+This repository is the C++ first implementation of hgraph. The runtime, system nodes, graph execution, time-series values, and native C++ graph/node APIs should be implemented in C++ as the primary source of truth.
+
+Python remains important, but it is not the runtime foundation. Python support is for:
+
+- wiring and compatibility with the current Python hgraph ecosystem,
+- Python user-authored nodes running inside the C++ runtime,
+- optional packaging and bindings through the Python bridge.
+
+Do not make normal CMake configure/build depend on Python, nanobind, or Python package installation unless the Python bridge is explicitly enabled.
+
+## Build System
+
+- Use CMake as the primary build system.
+- Keep `CMakeLists.txt` usable for a pure C++ build.
+- Keep `pyproject.toml` as the Python packaging bridge, not as the authoritative build definition.
+- Prefer explicit CMake targets over global include/link state.
+- The main runtime target should remain `hgraph_core` with the public alias `hgraph::core`.
+- Python bindings should be opt-in through `HGRAPH_BUILD_PYTHON_BINDINGS`.
+- Python user-node support should be opt-in through `HGRAPH_ENABLE_PYTHON_USER_NODES`.
+
+Useful local checks:
+
+```sh
+cmake -S . -B /tmp/hg_cpp-cmake-check
+cmake --build /tmp/hg_cpp-cmake-check
+cmake --install /tmp/hg_cpp-cmake-check --prefix /tmp/hg_cpp-install
+python3 -c "import pathlib, tomllib; tomllib.loads(pathlib.Path('pyproject.toml').read_text())"
+```
+
+## Source Layout
+
+Expected layout as the codebase grows:
+
+- `include/hgraph/...`: public C++ headers.
+- `src/...`: C++ runtime implementation.
+- `bindings/python/...`: optional Python extension bridge.
+- `tests/cpp/...`: C++ tests.
+- `tests/python/...`: Python compatibility tests only where the bridge or wiring requires them.
+- `docs/source/...`: Sphinx documentation for Read the Docs, split into user and developer guides.
+
+`include/hgraph/version.h` is generated from `include/hgraph/version.h.in` into the CMake build tree and installed with the public headers.
+
+Avoid committing generated build trees, CMake cache files, virtual environments, or Python bytecode.
+
+## Implementation Guidelines
+
+- Prefer C++23 library features where they simplify the code.
+- Keep Python-specific code behind clear boundaries.
+- System nodes should be C++ only.
+- C++ graph and node authoring should be first-class, not a binding layer over Python concepts.
+- When porting from older attempts, preserve useful C++ runtime ideas but avoid copying Python-first build assumptions.
+- Add abstractions only when they clarify ownership, runtime behavior, or public API shape.
+- Keep tests close to the behavior being introduced.
+
+## Dependency Policy
+
+- Prefer CMake packages when available.
+- Use `FetchContent` only deliberately and behind normal CMake options or dependency discovery.
+- Do not introduce heavyweight runtime dependencies without a clear need.
+- Python packaging dependencies belong in `pyproject.toml`; C++ runtime dependencies belong in CMake.
+
+## Git Hygiene
+
+- The worktree may contain unrelated user changes. Do not revert them.
+- Keep edits scoped to the requested task.
+- Do not delete or rewrite existing staged work unless explicitly asked.