hypergraphz 0.1.5__tar.gz

hypergraphz-0.1.5/.gitignore

@@ -0,0 +1,13 @@
+/zig-*
+/.zig-*
+
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.dylib
+*.dll
+/dist/
+/wheelhouse/
+/.venv/
+*.egg-info/

hypergraphz-0.1.5/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Davy Duperron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hypergraphz-0.1.5/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: hypergraphz
+Version: 0.1.5
+Summary: Python bindings for the HypergraphZ hypergraph library
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# HypergraphZ - A Hypergraph Implementation in Zig
+
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/yamafaktory/hypergraphz/ci.yml?branch=main&style=flat-square)
+
+HypergraphZ is a directed hypergraph implementation in Zig (https://en.wikipedia.org/wiki/Hypergraph):
+
+- Each hyperedge can contain zero, one (unary) or multiple vertices.
+- Each hyperedge can contain vertices directed to themselves one or more times.
+
+---
+
+## For Python users
+
+### Installation
+
+```sh
+pip install hypergraphz
+# or with uv
+uv add hypergraphz
+```
+
+Pre-built wheels are available for Linux (x86\_64, aarch64), macOS (x86\_64, arm64), and Windows (x86\_64).
+
+### Quick start
+
+```python
+from hypergraphz import Hypergraph
+
+g = Hypergraph()
+
+# Add vertices and hyperedges
+alice = g.add_vertex({"name": "alice", "age": 30})
+bob   = g.add_vertex({"name": "bob",   "age": 25})
+carol = g.add_vertex({"name": "carol", "age": 35})
+
+collab = g.add_hyperedge({"type": "project"})
+g.connect(collab, [alice, bob, carol])
+
+# Build the reverse index before querying
+g.build()
+
+# Shortest path
+path = g.shortest_path(alice, carol)
+
+# Fluent query builders
+active = (
+    g.vertices()
+     .where(lambda d: d["age"] > 28)
+     .data()
+)
+
+# Structural algorithms
+scores, _, _ = g.page_rank()
+centrality    = g.centrality()
+components    = g.connected_components()
+
+# Sub-graph operations return independent Hypergraph objects
+sub = g.vertex_induced_subgraph([alice, bob])
+dual = g.dual()
+```
+
+### API summary
+
+| Category | Methods |
+|---|---|
+| Lifecycle | `build()`, `clear()`, `save()`, `load()`, `clone()` |
+| Vertices | `add_vertex()`, `get_vertex()`, `update_vertex()`, `delete_vertex()`, `vertex_count()`, `all_vertex_ids()` |
+| Hyperedges | `add_hyperedge()`, `get_hyperedge()`, `update_hyperedge()`, `delete_hyperedge()`, `hyperedge_count()`, `all_hyperedge_ids()` |
+| Relations | `connect()`, `prepend()`, `insert_vertex()`, `insert_many()`, `disconnect()`, `disconnect_at()` |
+| Degree | `vertex_indegree()`, `vertex_outdegree()` |
+| Queries | `hyperedge_vertices()`, `vertex_hyperedges()`, `neighborhood()`, `intersections()`, `hyperedges_connecting()`, `endpoints()`, `orphan_vertices()`, `orphan_hyperedges()` |
+| Boolean | `is_connected()`, `is_reachable()`, `has_cycle()`, `is_k_uniform()` |
+| Traversal | `shortest_path()`, `all_paths()`, `bfs()`, `dfs()`, `random_walk()` |
+| Algorithms | `connected_components()`, `topological_sort()`, `cut_vertices()`, `centrality()`, `page_rank()`, `inclusions()`, `nestedness_profile()` |
+| Matrices | `incidence_matrix()`, `incidence_matrix_coo()`, `laplacian()` |
+| Sub-graphs | `dual()`, `k_skeleton()`, `vertex_induced_subgraph()`, `edge_induced_subgraph()`, `core()`, `expand_to_graph()`, `expand_to_star()`, `line_graph()`, `transitive_closure()` |
+| Fluent builders | `vertices()` → `VertexQuery`, `hyperedges()` → `HyperedgeQuery` |
+
+### Exceptions
+
+All errors map to typed exceptions from `hypergraphz`:
+
+| Exception | When raised |
+|---|---|
+| `NotBuiltError` | Query requires `build()` first |
+| `VertexNotFoundError` | Vertex ID does not exist |
+| `HyperedgeNotFoundError` | Hyperedge ID does not exist |
+| `CycleDetectedError` | Operation requires a DAG |
+| `NoPathError` | No directed path exists |
+| `IndexOutOfBoundsError` | Insertion index out of range |
+| `NotEnoughVerticesError` | Operation needs more vertices |
+
+---
+
+## For Zig users
+
+### Zig version
+
+HypergraphZ currently requires **Zig 0.17.0-dev.242+5d55999d2**.
+
+### Usage
+
+Add `hypergraphz` as a dependency to your `build.zig.zon`:
+
+```sh
+zig fetch --save https://github.com/yamafaktory/hypergraphz/archive/v0.1.0.tar.gz
+```
+
+Add `hypergraphz` as a dependency to your `build.zig`:
+
+```zig
+const hypergraphz = b.dependency("hypergraphz", .{
+    .target = target,
+    .optimize = optimize,
+});
+exe.root_module.addImport("hypergraphz", hypergraphz.module("hypergraphz"));
+```
+
+### Example
+
+`examples/coauthorship.zig` models a small research community as a directed hypergraph
+where vertices are researchers and hyperedges are papers. The first listed author is
+treated as the corresponding author, giving each hyperedge a natural direction.
+
+```
+zig build example
+```
+
+It walks through seventeen features of the library in sequence:
+
+| Section                  | API                      | What it shows                                                |
+| ------------------------ | ------------------------ | ------------------------------------------------------------ |
+| Papers per researcher    | `getVertexHyperedges`    | reverse-index query                                          |
+| Research communities     | `getConnectedComponents` | two isolated groups with no cross-group papers               |
+| Betweenness centrality   | `computeCentrality`      | which researchers bridge the most collaboration paths        |
+| Degrees of separation    | `findShortestPath`       | 1–3 hops within a community; unreachable across communities  |
+| Dual: paper-centric view | `getDual`                | swap vertices ↔ hyperedges to see each researcher's papers   |
+| Shared authorship        | `getIntersections`       | researchers present on every paper in a given set            |
+| Seniority ordering       | `topologicalSort`        | hierarchy implied by the authorship direction                |
+| Pairwise expansion       | `expandToGraph`          | 6 papers encode 11 directed pairs in a regular graph         |
+| Spectral view            | `toLaplacian`            | normalized Laplacian; block-diagonal under disjoint groups   |
+| PageRank                 | `computePageRank`        | citation-weighted stationary distribution; sums to 1         |
+| Random walk              | `randomWalk`             | seeded weighted walk; stays inside the start's component     |
+| Star expansion           | `expandToStar`           | bipartite (researcher ↔ paper) projection; 2-uniform         |
+| Line graph               | `getLineGraph`           | papers as vertices, linked when they share an author         |
+| K-core decomposition     | `getCore`                | (s, t)-core peeling; trims the lone-paper researcher         |
+| Nestedness               | `getInclusions`          | strict-subset pairs across hyperedges; sized profile         |
+| Co-author neighborhoods  | `getVertexNeighborhood`  | undirected co-occurrence neighbors across all hyperedges     |
+
+---
+
+## Documentation
+
+The latest online documentation can be found [here](https://yamafaktory.github.io/hypergraphz/).

hypergraphz-0.1.5/README.md

@@ -0,0 +1,154 @@
+# HypergraphZ - A Hypergraph Implementation in Zig
+
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/yamafaktory/hypergraphz/ci.yml?branch=main&style=flat-square)
+
+HypergraphZ is a directed hypergraph implementation in Zig (https://en.wikipedia.org/wiki/Hypergraph):
+
+- Each hyperedge can contain zero, one (unary) or multiple vertices.
+- Each hyperedge can contain vertices directed to themselves one or more times.
+
+---
+
+## For Python users
+
+### Installation
+
+```sh
+pip install hypergraphz
+# or with uv
+uv add hypergraphz
+```
+
+Pre-built wheels are available for Linux (x86\_64, aarch64), macOS (x86\_64, arm64), and Windows (x86\_64).
+
+### Quick start
+
+```python
+from hypergraphz import Hypergraph
+
+g = Hypergraph()
+
+# Add vertices and hyperedges
+alice = g.add_vertex({"name": "alice", "age": 30})
+bob   = g.add_vertex({"name": "bob",   "age": 25})
+carol = g.add_vertex({"name": "carol", "age": 35})
+
+collab = g.add_hyperedge({"type": "project"})
+g.connect(collab, [alice, bob, carol])
+
+# Build the reverse index before querying
+g.build()
+
+# Shortest path
+path = g.shortest_path(alice, carol)
+
+# Fluent query builders
+active = (
+    g.vertices()
+     .where(lambda d: d["age"] > 28)
+     .data()
+)
+
+# Structural algorithms
+scores, _, _ = g.page_rank()
+centrality    = g.centrality()
+components    = g.connected_components()
+
+# Sub-graph operations return independent Hypergraph objects
+sub = g.vertex_induced_subgraph([alice, bob])
+dual = g.dual()
+```
+
+### API summary
+
+| Category | Methods |
+|---|---|
+| Lifecycle | `build()`, `clear()`, `save()`, `load()`, `clone()` |
+| Vertices | `add_vertex()`, `get_vertex()`, `update_vertex()`, `delete_vertex()`, `vertex_count()`, `all_vertex_ids()` |
+| Hyperedges | `add_hyperedge()`, `get_hyperedge()`, `update_hyperedge()`, `delete_hyperedge()`, `hyperedge_count()`, `all_hyperedge_ids()` |
+| Relations | `connect()`, `prepend()`, `insert_vertex()`, `insert_many()`, `disconnect()`, `disconnect_at()` |
+| Degree | `vertex_indegree()`, `vertex_outdegree()` |
+| Queries | `hyperedge_vertices()`, `vertex_hyperedges()`, `neighborhood()`, `intersections()`, `hyperedges_connecting()`, `endpoints()`, `orphan_vertices()`, `orphan_hyperedges()` |
+| Boolean | `is_connected()`, `is_reachable()`, `has_cycle()`, `is_k_uniform()` |
+| Traversal | `shortest_path()`, `all_paths()`, `bfs()`, `dfs()`, `random_walk()` |
+| Algorithms | `connected_components()`, `topological_sort()`, `cut_vertices()`, `centrality()`, `page_rank()`, `inclusions()`, `nestedness_profile()` |
+| Matrices | `incidence_matrix()`, `incidence_matrix_coo()`, `laplacian()` |
+| Sub-graphs | `dual()`, `k_skeleton()`, `vertex_induced_subgraph()`, `edge_induced_subgraph()`, `core()`, `expand_to_graph()`, `expand_to_star()`, `line_graph()`, `transitive_closure()` |
+| Fluent builders | `vertices()` → `VertexQuery`, `hyperedges()` → `HyperedgeQuery` |
+
+### Exceptions
+
+All errors map to typed exceptions from `hypergraphz`:
+
+| Exception | When raised |
+|---|---|
+| `NotBuiltError` | Query requires `build()` first |
+| `VertexNotFoundError` | Vertex ID does not exist |
+| `HyperedgeNotFoundError` | Hyperedge ID does not exist |
+| `CycleDetectedError` | Operation requires a DAG |
+| `NoPathError` | No directed path exists |
+| `IndexOutOfBoundsError` | Insertion index out of range |
+| `NotEnoughVerticesError` | Operation needs more vertices |
+
+---
+
+## For Zig users
+
+### Zig version
+
+HypergraphZ currently requires **Zig 0.17.0-dev.242+5d55999d2**.
+
+### Usage
+
+Add `hypergraphz` as a dependency to your `build.zig.zon`:
+
+```sh
+zig fetch --save https://github.com/yamafaktory/hypergraphz/archive/v0.1.0.tar.gz
+```
+
+Add `hypergraphz` as a dependency to your `build.zig`:
+
+```zig
+const hypergraphz = b.dependency("hypergraphz", .{
+    .target = target,
+    .optimize = optimize,
+});
+exe.root_module.addImport("hypergraphz", hypergraphz.module("hypergraphz"));
+```
+
+### Example
+
+`examples/coauthorship.zig` models a small research community as a directed hypergraph
+where vertices are researchers and hyperedges are papers. The first listed author is
+treated as the corresponding author, giving each hyperedge a natural direction.
+
+```
+zig build example
+```
+
+It walks through seventeen features of the library in sequence:
+
+| Section                  | API                      | What it shows                                                |
+| ------------------------ | ------------------------ | ------------------------------------------------------------ |
+| Papers per researcher    | `getVertexHyperedges`    | reverse-index query                                          |
+| Research communities     | `getConnectedComponents` | two isolated groups with no cross-group papers               |
+| Betweenness centrality   | `computeCentrality`      | which researchers bridge the most collaboration paths        |
+| Degrees of separation    | `findShortestPath`       | 1–3 hops within a community; unreachable across communities  |
+| Dual: paper-centric view | `getDual`                | swap vertices ↔ hyperedges to see each researcher's papers   |
+| Shared authorship        | `getIntersections`       | researchers present on every paper in a given set            |
+| Seniority ordering       | `topologicalSort`        | hierarchy implied by the authorship direction                |
+| Pairwise expansion       | `expandToGraph`          | 6 papers encode 11 directed pairs in a regular graph         |
+| Spectral view            | `toLaplacian`            | normalized Laplacian; block-diagonal under disjoint groups   |
+| PageRank                 | `computePageRank`        | citation-weighted stationary distribution; sums to 1         |
+| Random walk              | `randomWalk`             | seeded weighted walk; stays inside the start's component     |
+| Star expansion           | `expandToStar`           | bipartite (researcher ↔ paper) projection; 2-uniform         |
+| Line graph               | `getLineGraph`           | papers as vertices, linked when they share an author         |
+| K-core decomposition     | `getCore`                | (s, t)-core peeling; trims the lone-paper researcher         |
+| Nestedness               | `getInclusions`          | strict-subset pairs across hyperedges; sized profile         |
+| Co-author neighborhoods  | `getVertexNeighborhood`  | undirected co-occurrence neighbors across all hyperedges     |
+
+---
+
+## Documentation
+
+The latest online documentation can be found [here](https://yamafaktory.github.io/hypergraphz/).

hypergraphz-0.1.5/build.zig

@@ -0,0 +1,134 @@
+const std = @import("std");
+const HypergraphZPath = "src/hypergraphz.zig";
+const BenchPath = "bench/main.zig";
+const TestRootPath = "tests/root.zig";
+const CAbiPath = "src/hgz_c_api.zig";
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const root_source_file = b.path(HypergraphZPath);
+
+    const root_module = b.addModule("hypergraphz", .{
+        .root_source_file = root_source_file,
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const test_module = b.createModule(.{
+        .root_source_file = b.path(TestRootPath),
+        .imports = &.{.{ .name = "hypergraphz", .module = root_module }},
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const unit_tests = b.addTest(.{
+        .root_module = test_module,
+    });
+
+    const run_lib_unit_tests = b.addRunArtifact(unit_tests);
+
+    // Disable cache for unit tests to get logs.
+    // https://ziggit.dev/t/how-to-enable-more-logging-and-disable-caching-with-zig-build-test/2654/11
+    run_lib_unit_tests.has_side_effects = true;
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    // Notes:
+    // - `zig build test -Doptimize=ReleaseFast` to run the unit tests in release-fast mode.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_lib_unit_tests.step);
+
+    // Generate docs step.
+    const docs_step = b.step("docs", "Build the HypergraphZ docs");
+    const docs_obj = b.addObject(.{
+        .name = "HypergraphZ",
+        .root_module = b.createModule(.{
+            .root_source_file = root_source_file,
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+    const docs = docs_obj.getEmittedDocs();
+    docs_step.dependOn(&b.addInstallDirectory(.{
+        .source_dir = docs,
+        .install_dir = .prefix,
+        .install_subdir = "docs",
+    }).step);
+
+    // Format step.
+    const fmt_step = b.step("fmt", "Format all source files");
+    const fmt = b.addFmt(.{
+        .paths = &.{ HypergraphZPath, "bench", "build.zig", "tests", "examples" },
+    });
+    fmt_step.dependOn(&fmt.step);
+
+    // Check step used by the zls configuration.
+    const check_step = b.step("check", "Check if HypergraphZ compiles");
+    const check = b.addTest(.{
+        .root_module = test_module,
+    });
+    check_step.dependOn(&check.step);
+    const bench_check = b.addExecutable(.{
+        .name = "bench",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path(BenchPath),
+            .target = target,
+            .optimize = optimize,
+            .imports = &.{.{ .name = "hypergraphz", .module = root_module }},
+        }),
+    });
+    check_step.dependOn(&bench_check.step);
+
+    // Example step.
+    const example_step = b.step("example", "Run the co-authorship network example");
+    const example_exe = b.addExecutable(.{
+        .name = "coauthorship",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("examples/coauthorship.zig"),
+            .imports = &.{.{ .name = "hypergraphz", .module = root_module }},
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+    example_step.dependOn(&b.addRunArtifact(example_exe).step);
+    check_step.dependOn(&example_exe.step);
+
+    // Shared library step (C ABI for Python bindings).
+    const lib_step = b.step("lib", "Build the HypergraphZ shared library (C ABI)");
+    const lib = b.addLibrary(.{
+        .name = "hypergraphz",
+        .linkage = .dynamic,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path(CAbiPath),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+            .imports = &.{.{ .name = "hypergraphz", .module = root_module }},
+        }),
+    });
+    lib_step.dependOn(&b.addInstallArtifact(lib, .{}).step);
+
+    // Bench step.
+    const bench_source_file = b.path(BenchPath);
+    const bench_module = b.addModule("bench", .{
+        .root_source_file = bench_source_file,
+        .target = target,
+        .optimize = .ReleaseFast,
+        .imports = &.{.{ .name = "hypergraphz", .module = root_module }},
+    });
+
+    const bench_step = b.step("bench", "Run benchmarks");
+    const bench_exe = b.addExecutable(.{
+        .name = "bench",
+        .root_module = bench_module,
+    });
+    const bench_run = b.addRunArtifact(bench_exe);
+    if (b.args) |args| {
+        bench_run.addArgs(args);
+    }
+    bench_step.dependOn(&bench_run.step);
+}

hypergraphz-0.1.5/build.zig.zon

@@ -0,0 +1,14 @@
+.{
+    .name = .hypergraphz,
+    .fingerprint = 0xc4efc93d2a1d228a,
+    .version = "0.1.5",
+    .minimum_zig_version = "0.17.0-dev.242+5d55999d2",
+    .paths = .{
+        "LICENSE",
+        "README.md",
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "tests",
+    },
+}

hypergraphz-0.1.5/hatch_build.py

@@ -0,0 +1,45 @@
+"""Custom hatch build hook: compiles the Zig shared library during wheel packaging."""
+
+import shutil
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+ROOT = Path(__file__).parent
+PKG_DIR = ROOT / "python" / "hypergraphz"
+PATTERNS = ("libhypergraphz.so", "libhypergraphz.dylib", "hypergraphz.dll")
+
+
+def _wheel_tag() -> str:
+    python_tag = f"cp{sys.version_info.major}{sys.version_info.minor}"
+    plat = sysconfig.get_platform().replace("-", "_").replace(".", "_")
+    return f"{python_tag}-{python_tag}-{plat}"
+
+
+class CustomBuildHook(BuildHookInterface):
+    def initialize(self, version, build_data):
+        if self.target_name == "sdist":
+            return
+
+        # CI pre-copies the library before invoking cibuildwheel — nothing to build.
+        # Local development: build and copy if missing.
+        if not any(PKG_DIR.glob(p) for p in PATTERNS):
+            lib_dir = ROOT / "zig-out" / "lib"
+            subprocess.run(["zig", "build", "lib", "-Doptimize=ReleaseFast"], check=True, cwd=ROOT)
+
+            copied = False
+            for pattern in PATTERNS:
+                for lib in lib_dir.glob(pattern):
+                    shutil.copy2(lib, PKG_DIR / lib.name)
+                    copied = True
+
+            if not copied:
+                raise RuntimeError(f"No shared library found in {lib_dir}")
+
+        # Tell hatchling this is a platform wheel. Setting both keys because
+        # different hatchling versions look at one or the other.
+        build_data["pure_python"] = False
+        build_data["tag"] = _wheel_tag()

hypergraphz-0.1.5/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hypergraphz"
+dynamic = ["version"]
+description = "Python bindings for the HypergraphZ hypergraph library"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.4",
+    "hatch-vcs>=0.4",
+    "cibuildwheel>=2.20",
+    "wheel>=0.45",
+]
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["python/hypergraphz"]
+# Override .gitignore exclusions — hatchling respects gitignore by default
+artifacts = [
+    "python/hypergraphz/libhypergraphz.so",
+    "python/hypergraphz/libhypergraphz.dylib",
+    "python/hypergraphz/hypergraphz.dll",
+]
+
+[tool.hatch.build.hooks.custom]
+path = "hatch_build.py"
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "python/",
+    "src/",
+    "build.zig",
+    "build.zig.zon",
+    "hatch_build.py",
+]
+
+[tool.cibuildwheel]
+build = "cp311-*"
+skip = "pp*"
+
+
+[tool.cibuildwheel.macos]
+environment = { MACOSX_DEPLOYMENT_TARGET = "11.0" }
+
+[tool.cibuildwheel.windows]
+archs = ["AMD64"]
+
+[tool.ruff]
+src = ["python"]
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+ignore = ["E501"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["hypergraphz"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests-python"]

hypergraphz-0.1.5/python/hypergraphz/__init__.py

@@ -0,0 +1,28 @@
+"""HypergraphZ — Python bindings for the HypergraphZ Zig library."""
+
+from ._errors import (
+    CycleDetectedError,
+    HyperedgeNotFoundError,
+    HypergraphZError,
+    IndexOutOfBoundsError,
+    NoPathError,
+    NotBuiltError,
+    NotEnoughVerticesError,
+    VertexNotFoundError,
+)
+from ._graph import Hypergraph
+from ._query import HyperedgeQuery, VertexQuery
+
+__all__ = [
+    "Hypergraph",
+    "HyperedgeQuery",
+    "VertexQuery",
+    "HypergraphZError",
+    "NotBuiltError",
+    "VertexNotFoundError",
+    "HyperedgeNotFoundError",
+    "CycleDetectedError",
+    "NoPathError",
+    "IndexOutOfBoundsError",
+    "NotEnoughVerticesError",
+]