scigraphs-engine 0.1.1__tar.gz

scigraphs_engine-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 José Marín
+
+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.

scigraphs_engine-0.1.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: scigraphs-engine
+Version: 0.1.1
+Summary: Blender-free graph visualization engine: filters, backbones, bundling, PNG render.
+Author: José Marín
+License: MIT License
+        
+        Copyright (c) 2026 José Marín
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/SciBlend/SciGraphs
+Project-URL: Repository, https://github.com/SciBlend/SciGraphs
+Project-URL: Issues, https://github.com/SciBlend/SciGraphs/issues
+Project-URL: Documentation, https://github.com/SciBlend/SciGraphs/tree/main/docs
+Keywords: graph,network,visualization,rendering,layout
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Provides-Extra: igraph
+Requires-Dist: python-igraph>=0.10; extra == "igraph"
+Provides-Extra: scipy
+Requires-Dist: scipy>=1.9; extra == "scipy"
+Provides-Extra: networkx
+Requires-Dist: networkx>=2.8; extra == "networkx"
+Provides-Extra: all
+Requires-Dist: python-igraph>=0.10; extra == "all"
+Requires-Dist: scipy>=1.9; extra == "all"
+Requires-Dist: networkx>=2.8; extra == "all"
+Provides-Extra: wgpu
+Requires-Dist: wgpu>=0.32; extra == "wgpu"
+Requires-Dist: pillow>=9; extra == "wgpu"
+Dynamic: license-file
+
+# scigraphs-engine
+
+Graph visualization as a plain Python package. Coordinates, an edge list and
+whatever attributes they carry go in; geometry or pixels come out, with 26
+filter channels, structural sparsification, edge-style tessellation and
+hierarchical bundling in between.
+
+```python
+from scigraphs_engine import Graph
+
+g = Graph.from_arrays(coords, edges)
+g = g.filter(core__gte=0.5).simplify(backbone="disparity", alpha=0.05)
+g.style(edges="bundled").render(size=(1920, 1080)).save("out.png")
+```
+
+Nothing in this package imports `bpy`, `gpu`, `bmesh` or `mathutils`. The
+compute half needs only `numpy`, and `Graph.geometry()` runs with no graphics
+library installed at all, returning `MeshSpec`s that name their shader as a
+string, so any renderer can draw them. The GPU half is an optional extra.
+
+## Install
+
+```bash
+pip install scigraphs-engine                  # numpy only
+pip install "scigraphs-engine[igraph]"        # coreness, PageRank, betweenness, bridges
+pip install "scigraphs-engine[scipy]"         # components, hop distance, crowding
+pip install "scigraphs-engine[wgpu]"          # render() to pixels
+pip install "scigraphs-engine[all]"           # everything
+```
+
+Requires Python 3.10 or newer. A missing extra makes individual channels
+unavailable rather than breaking anything: `available_channels()` returns all 26
+with a reason for each one that cannot run.
+
+## Documentation
+
+https://github.com/SciBlend/SciGraphs/tree/main/docs
+
+```bash
+python engine/scigraphs_engine/tests/run.py          # -v for full output
+```
+
+## License
+
+MIT, see `LICENSE`. The SciGraphs Blender add-on is GPLv3 and is one caller of
+this package, not its owner. It reaches the package through a shim that prefers
+an installed `scigraphs_engine` over any copy shipped alongside it.

scigraphs_engine-0.1.1/README.md

@@ -0,0 +1,47 @@
+# scigraphs-engine
+
+Graph visualization as a plain Python package. Coordinates, an edge list and
+whatever attributes they carry go in; geometry or pixels come out, with 26
+filter channels, structural sparsification, edge-style tessellation and
+hierarchical bundling in between.
+
+```python
+from scigraphs_engine import Graph
+
+g = Graph.from_arrays(coords, edges)
+g = g.filter(core__gte=0.5).simplify(backbone="disparity", alpha=0.05)
+g.style(edges="bundled").render(size=(1920, 1080)).save("out.png")
+```
+
+Nothing in this package imports `bpy`, `gpu`, `bmesh` or `mathutils`. The
+compute half needs only `numpy`, and `Graph.geometry()` runs with no graphics
+library installed at all, returning `MeshSpec`s that name their shader as a
+string, so any renderer can draw them. The GPU half is an optional extra.
+
+## Install
+
+```bash
+pip install scigraphs-engine                  # numpy only
+pip install "scigraphs-engine[igraph]"        # coreness, PageRank, betweenness, bridges
+pip install "scigraphs-engine[scipy]"         # components, hop distance, crowding
+pip install "scigraphs-engine[wgpu]"          # render() to pixels
+pip install "scigraphs-engine[all]"           # everything
+```
+
+Requires Python 3.10 or newer. A missing extra makes individual channels
+unavailable rather than breaking anything: `available_channels()` returns all 26
+with a reason for each one that cannot run.
+
+## Documentation
+
+https://github.com/SciBlend/SciGraphs/tree/main/docs
+
+```bash
+python engine/scigraphs_engine/tests/run.py          # -v for full output
+```
+
+## License
+
+MIT, see `LICENSE`. The SciGraphs Blender add-on is GPLv3 and is one caller of
+this package, not its owner. It reaches the package through a shim that prefers
+an installed `scigraphs_engine` over any copy shipped alongside it.

scigraphs_engine-0.1.1/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scigraphs-engine"
+version = "0.1.1"
+description = "Blender-free graph visualization engine: filters, backbones, bundling, PNG render."
+readme = "README.md"
+# Floor matches Blender 4.1+ / 5.x Python.
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+authors = [{ name = "José Marín" }]
+keywords = ["graph", "network", "visualization", "rendering", "layout"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Visualization",
+]
+
+# Only hard dep. igraph/scipy/networkx are optional and degrade to None.
+dependencies = ["numpy>=1.23"]
+
+[project.urls]
+Homepage = "https://github.com/SciBlend/SciGraphs"
+Repository = "https://github.com/SciBlend/SciGraphs"
+Issues = "https://github.com/SciBlend/SciGraphs/issues"
+Documentation = "https://github.com/SciBlend/SciGraphs/tree/main/docs"
+
+[project.optional-dependencies]
+igraph = ["python-igraph>=0.10"]
+scipy = ["scipy>=1.9"]
+networkx = ["networkx>=2.8"]
+all = ["python-igraph>=0.10", "scipy>=1.9", "networkx>=2.8"]
+# Only needed for Graph.render(); import stays lazy.
+wgpu = ["wgpu>=0.32", "pillow>=9"]
+
+[tool.setuptools]
+# Listed one by one rather than discovered, so a new subpackage has to be added
+# here on purpose. Leaving one out ships a wheel that imports and then fails on
+# the first call into the missing module.
+packages = [
+    "scigraphs_engine",
+    "scigraphs_engine.backends",
+    "scigraphs_engine.backends.wgpu",
+    "scigraphs_engine.bundling",
+]
+license-files = ["LICENSE"]
+
+[tool.setuptools.package-data]
+"scigraphs_engine.backends.wgpu" = ["wgsl/*.wgsl", "wgsl/*.json"]

scigraphs_engine-0.1.1/scigraphs_engine/__init__.py

@@ -0,0 +1,50 @@
+# Nothing in this package may import bpy, gpu, bmesh or mathutils; tests in the
+# SciGraphs repository parse this directory for those names. Everything below
+# numpy is lazy, so a MeshSpec caller never pays for igraph and scipy.
+
+import importlib as _importlib
+
+__version__ = "0.1.1"
+
+from .mesh import (  # noqa: F401
+    DrawState, MeshGroup, MeshSpec, ShaderRef, LINES, POINTS, TRIS,
+)
+from .settings import Clause, Settings, PREFIX  # noqa: F401
+from .source import ArraySource, GraphSource, EDGE, POINT  # noqa: F401
+
+_LAZY = (
+    "adaptive", "api", "blocks", "channels", "communities", "edge_styles",
+    "filters", "gpu_compute", "lod", "mesh", "palette", "settings", "simplify",
+    "source",
+)
+
+# Lets `from scigraphs_engine import Graph` resolve without importing api.
+_API_NAMES = (
+    "BackendUnavailable", "Camera", "ChannelResult", "ChannelSpec",
+    "ChannelUnavailable", "Condition", "EngineError", "Geometry", "Graph",
+    "Image", "Report", "UnknownChannel", "channel", "channel_names",
+    "channel_specs", "colormap_names", "gpu_available",
+)
+
+__all__ = [
+    "ArraySource", "Clause", "DrawState", "EDGE", "GraphSource", "LINES",
+    "MeshGroup", "MeshSpec", "POINT", "POINTS", "PREFIX", "Settings",
+    "ShaderRef", "TRIS", "__version__",
+] + list(_API_NAMES) + list(_LAZY)
+
+
+def __getattr__(name):
+    """Import a submodule or a public API name on first access (PEP 562)."""
+    if name in _LAZY:
+        module = _importlib.import_module("." + name, __name__)
+        globals()[name] = module
+        return module
+    if name in _API_NAMES:
+        value = getattr(_importlib.import_module(".api", __name__), name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(set(globals()) | set(_LAZY) | set(_API_NAMES))

scigraphs_engine-0.1.1/scigraphs_engine/_camera_math.py

@@ -0,0 +1,85 @@
+# Transcribed from backends/wgpu/camera.py, held float32-exact against it by
+# tests/test_camera.py. Depth is z in [0, 1] (WebGPU), not OpenGL's.
+
+import numpy as np
+
+
+def _normalize(v):
+    v = np.asarray(v, dtype=np.float64)
+    n = np.linalg.norm(v)
+    return v / n if n > 1e-12 else v
+
+
+def look_at(eye, target, up=(0.0, 0.0, 1.0)):
+    """World -> view, right-handed, looking down -z. +Z up like Blender."""
+    eye = np.asarray(eye, dtype=np.float64)
+    f = _normalize(np.asarray(target, dtype=np.float64) - eye)
+    up = _normalize(up)
+    if abs(float(np.dot(f, up))) > 0.9999:
+        up = np.array([0.0, 1.0, 0.0]) if abs(f[1]) < 0.9 else \
+            np.array([1.0, 0.0, 0.0])
+    s = _normalize(np.cross(f, up))
+    u = np.cross(s, f)
+    m = np.eye(4, dtype=np.float64)
+    m[0, :3], m[1, :3], m[2, :3] = s, u, -f
+    m[0, 3] = -float(np.dot(s, eye))
+    m[1, 3] = -float(np.dot(u, eye))
+    m[2, 3] = float(np.dot(f, eye))
+    return m.astype(np.float32)
+
+
+def perspective(fov_y_deg, aspect, near, far):
+    """View -> clip with z in [0, 1]."""
+    f = 1.0 / np.tan(np.radians(float(fov_y_deg)) * 0.5)
+    m = np.zeros((4, 4), dtype=np.float64)
+    m[0, 0] = f / float(aspect)
+    m[1, 1] = f
+    m[2, 2] = far / (near - far)
+    m[2, 3] = (far * near) / (near - far)
+    m[3, 2] = -1.0
+    return m.astype(np.float32)
+
+
+def bounding_sphere(coords):
+    """(center, radius) of the box's circumsphere. Over-frames a flat layout."""
+    coords = np.asarray(coords, dtype=np.float32).reshape(-1, 3)
+    if coords.size == 0:
+        return np.zeros(3, dtype=np.float32), 1.0
+    lo = coords.min(axis=0)
+    hi = coords.max(axis=0)
+    center = (lo + hi) * 0.5
+    radius = float(np.linalg.norm(hi - lo)) * 0.5
+    return center, (radius if radius > 1e-6 else 1.0)
+
+
+def fit_view(coords, size, fov_y_deg=45.0, margin=1.15,
+             direction=(0.0, -1.0, 0.35), up=(0.0, 0.0, 1.0)):
+    """A resolved api.Camera framing all of ``coords`` at ``size``."""
+    from .api import Camera
+
+    width, height = size
+    center, radius = bounding_sphere(coords)
+    aspect = float(width) / float(height)
+    # Fit the tighter axis: vertical-only fitting crops a portrait render.
+    half_v = np.radians(float(fov_y_deg)) * 0.5
+    half_h = np.arctan(np.tan(half_v) * aspect)
+    dist = radius * float(margin) / np.sin(min(half_v, half_h))
+
+    eye = center - _normalize(direction).astype(np.float32) * dist
+    near = max(dist - radius * 2.0, dist * 1e-3)
+    far = dist + radius * 4.0
+    return Camera(look_at(eye, center, up),
+                  perspective(fov_y_deg, aspect, near, far), near, far)
+
+
+def look_at_camera(eye, target, up, fov_y_deg, size, near=None, far=None):
+    from .api import Camera
+
+    width, height = size
+    eye = np.asarray(eye, dtype=np.float64)
+    span = float(np.linalg.norm(np.asarray(target, dtype=np.float64) - eye))
+    near = float(near) if near is not None else max(span * 1e-3, 1e-4)
+    far = float(far) if far is not None else max(span * 10.0, near * 100.0)
+    return Camera(look_at(eye, target, up),
+                  perspective(fov_y_deg, float(width) / float(height),
+                              near, far), near, far)