anywidget-graph 0.1.0__tar.gz → 0.2.1__tar.gz

anywidget_graph-0.2.1/.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --dev
+
+      - name: Run ruff check
+        run: uv run ruff check .
+
+      - name: Run ruff format check
+        run: uv run ruff format --check .
+
+      - name: Run tests
+        run: uv run pytest -v

anywidget_graph-0.2.1/.github/workflows/pypi.yml

@@ -0,0 +1,40 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Build package
+        run: uv build
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{anywidget_graph-0.1.0 → anywidget_graph-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anywidget-graph
-Version: 0.1.0
+Version: 0.2.1
 Summary: Interactive graph visualization for Python notebooks using anywidget
 Project-URL: Homepage, https://grafeo.dev/
 Project-URL: Repository, https://github.com/GrafeoDB/anywidget-graph
@@ -19,11 +19,12 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Requires-Python: >=3.12
 Requires-Dist: anywidget>=0.9.21
+Requires-Dist: marimo>=0.19.7
 Provides-Extra: dev
 Requires-Dist: marimo>=0.19.7; extra == 'dev'
 Requires-Dist: prek>=0.3.1; extra == 'dev'
 Requires-Dist: pytest>=9.0.2; extra == 'dev'
-Requires-Dist: ruff>=0.14.14; extra == 'dev'
+Requires-Dist: ruff>=0.15.0; extra == 'dev'
 Requires-Dist: ty>=0.0.14; extra == 'dev'
 Provides-Extra: networkx
 Requires-Dist: networkx>=3.0; extra == 'networkx'
@@ -251,7 +252,7 @@ graph.to_json("graph.json")
 
 - [anywidget](https://anywidget.dev/) — Custom Jupyter widgets made easy
 - [Grafeo](https://github.com/GrafeoDB/grafeo) — Embeddable graph database
-- [grafeo-wasm](https://github.com/GrafeoDB/grafeo-wasm) — Grafeo in the browser
+- [grafeo-web](https://github.com/GrafeoDB/grafeo-web) — Grafeo in the browser
 
 ## License
 

{anywidget_graph-0.1.0 → anywidget_graph-0.2.1}/README.md

@@ -218,7 +218,7 @@ graph.to_json("graph.json")
 
 - [anywidget](https://anywidget.dev/) — Custom Jupyter widgets made easy
 - [Grafeo](https://github.com/GrafeoDB/grafeo) — Embeddable graph database
-- [grafeo-wasm](https://github.com/GrafeoDB/grafeo-wasm) — Grafeo in the browser
+- [grafeo-web](https://github.com/GrafeoDB/grafeo-web) — Grafeo in the browser
 
 ## License
 

{anywidget_graph-0.1.0 → anywidget_graph-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anywidget-graph"
-version = "0.1.0"
+version = "0.2.1"
 description = "Interactive graph visualization for Python notebooks using anywidget"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -22,13 +22,14 @@ classifiers = [
 
 dependencies = [
     "anywidget>=0.9.21",
+    "marimo>=0.19.7",
 ]
 
 [project.optional-dependencies]
 dev = [
     "prek>=0.3.1",
     "pytest>=9.0.2",
-    "ruff>=0.14.14",
+    "ruff>=0.15.0",
     "ty>=0.0.14",
     "marimo>=0.19.7",
 ]

{anywidget_graph-0.1.0 → anywidget_graph-0.2.1}/src/anywidget_graph/__init__.py

@@ -3,4 +3,4 @@
 from anywidget_graph.widget import Graph
 
 __all__ = ["Graph"]
-__version__ = "0.1.0"
+__version__ = "0.2.1"

anywidget_graph-0.2.1/src/anywidget_graph/backends/__init__.py

@@ -0,0 +1,71 @@
+"""Database backend abstractions for anywidget-graph."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from anywidget_graph.backends.arango import ArangoBackend
+from anywidget_graph.backends.grafeo import GrafeoBackend
+from anywidget_graph.backends.ladybug import LadybugBackend
+from anywidget_graph.backends.neo4j import Neo4jBackend
+
+__all__ = [
+    # Protocol
+    "DatabaseBackend",
+    # Backends
+    "ArangoBackend",
+    "GrafeoBackend",
+    "LadybugBackend",
+    "Neo4jBackend",
+    # Registries
+    "BACKENDS",
+    "QUERY_LANGUAGES",
+]
+
+
+@runtime_checkable
+class DatabaseBackend(Protocol):
+    """Protocol defining the interface for database backends.
+
+    Implementations must provide:
+    - execute(query) -> (nodes, edges)
+    - fetch_schema() -> (node_types, edge_types)
+
+    Example
+    -------
+    >>> class MyBackend:
+    ...     def execute(self, query: str) -> tuple[list[dict], list[dict]]:
+    ...         # Execute query and return nodes/edges
+    ...         return [], []
+    ...
+    ...     def fetch_schema(self) -> tuple[list[dict], list[dict]]:
+    ...         return [], []
+    """
+
+    def execute(self, query: str) -> tuple[list[dict], list[dict]]:
+        """Execute a query and return (nodes, edges)."""
+        ...
+
+    def fetch_schema(self) -> tuple[list[dict], list[dict]]:
+        """Fetch schema and return (node_types, edge_types)."""
+        ...
+
+
+# Backend registry for UI
+BACKENDS = [
+    {"id": "neo4j", "name": "Neo4j", "side": "browser", "language": "cypher"},
+    {"id": "neo4j-python", "name": "Neo4j (Python)", "side": "python", "language": "cypher"},
+    {"id": "grafeo", "name": "Grafeo", "side": "python", "language": "cypher"},
+    {"id": "ladybug", "name": "LadybugDB", "side": "python", "language": "cypher"},
+    {"id": "arango", "name": "ArangoDB", "side": "python", "language": "aql"},
+]
+
+# Query language registry
+QUERY_LANGUAGES = [
+    {"id": "cypher", "name": "Cypher", "enabled": True},
+    {"id": "gql", "name": "GQL", "enabled": True},
+    {"id": "sparql", "name": "SPARQL", "enabled": True},
+    {"id": "gremlin", "name": "Gremlin", "enabled": True},
+    {"id": "graphql", "name": "GraphQL", "enabled": True},
+    {"id": "aql", "name": "AQL", "enabled": True},
+]

anywidget_graph-0.2.1/src/anywidget_graph/backends/arango.py

@@ -0,0 +1,201 @@
+"""ArangoDB database backend."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from anywidget_graph.converters.base import GraphData
+
+if TYPE_CHECKING:
+    from arango.database import StandardDatabase
+
+
+class ArangoConverter:
+    """Convert ArangoDB AQL results to graph data."""
+
+    def convert(self, result: Any) -> GraphData:
+        """Convert AQL cursor result to nodes and edges.
+
+        Parameters
+        ----------
+        result : Any
+            AQL query cursor/result.
+
+        Returns
+        -------
+        GraphData
+            Dictionary with 'nodes' and 'edges' lists.
+        """
+        nodes: dict[str, dict[str, Any]] = {}
+        edges: list[dict[str, Any]] = []
+
+        for doc in result:
+            if not isinstance(doc, dict):
+                continue
+
+            # Check if it's an edge document (_from and _to fields)
+            if "_from" in doc and "_to" in doc:
+                edge = self._edge_to_dict(doc)
+                edges.append(edge)
+            # Otherwise treat as vertex document
+            elif "_key" in doc or "_id" in doc:
+                node = self._vertex_to_dict(doc)
+                nodes[node["id"]] = node
+
+        return {"nodes": list(nodes.values()), "edges": edges}
+
+    def _vertex_to_dict(self, doc: dict[str, Any]) -> dict[str, Any]:
+        """Convert ArangoDB vertex document to node dict."""
+        # Extract ID from _key or _id
+        if "_key" in doc:
+            node_id = doc["_key"]
+        elif "_id" in doc:
+            node_id = doc["_id"].split("/")[-1]
+        else:
+            node_id = str(id(doc))
+
+        result: dict[str, Any] = {
+            "id": node_id,
+            "label": doc.get("name", doc.get("label", node_id)),
+        }
+
+        # Add non-system properties
+        for key, value in doc.items():
+            if not key.startswith("_") and key not in ("name", "label"):
+                result[key] = value
+
+        return result
+
+    def _edge_to_dict(self, doc: dict[str, Any]) -> dict[str, Any]:
+        """Convert ArangoDB edge document to edge dict."""
+        result: dict[str, Any] = {
+            "source": doc["_from"].split("/")[-1],
+            "target": doc["_to"].split("/")[-1],
+            "label": doc.get("label", doc.get("_key", "")),
+        }
+
+        # Add non-system properties
+        for key, value in doc.items():
+            if not key.startswith("_") and key not in ("label",):
+                result[key] = value
+
+        return result
+
+
+class ArangoBackend:
+    """Backend for ArangoDB multi-model database.
+
+    Parameters
+    ----------
+    db : StandardDatabase | None
+        Existing ArangoDB database connection.
+    host : str
+        ArangoDB host URL (default: "http://localhost:8529").
+    username : str
+        Username for authentication (default: "root").
+    password : str
+        Password for authentication (default: "").
+    database : str
+        Database name (default: "_system").
+
+    Example
+    -------
+    >>> from anywidget_graph.backends import ArangoBackend
+    >>> backend = ArangoBackend(
+    ...     host="http://localhost:8529",
+    ...     username="root",
+    ...     password="password",
+    ...     database="mydb",
+    ... )
+    >>> nodes, edges = backend.execute('''
+    ...     FOR v, e IN 1..2 OUTBOUND 'users/alice' GRAPH 'social'
+    ...     RETURN {vertex: v, edge: e}
+    ... ''')
+
+    Or with an existing connection:
+
+    >>> from arango import ArangoClient
+    >>> client = ArangoClient(hosts="http://localhost:8529")
+    >>> db = client.db("mydb", username="root", password="password")
+    >>> backend = ArangoBackend(db=db)
+    """
+
+    def __init__(
+        self,
+        db: StandardDatabase | None = None,
+        host: str = "http://localhost:8529",
+        username: str = "root",
+        password: str = "",
+        database: str = "_system",
+    ) -> None:
+        self._db = db
+        self._host = host
+        self._username = username
+        self._password = password
+        self._database = database
+        self._converter = ArangoConverter()
+
+    @property
+    def query_language(self) -> str:
+        """Return the default query language."""
+        return "aql"
+
+    @property
+    def db(self) -> StandardDatabase:
+        """Get or create the database connection."""
+        if self._db is None:
+            from arango import ArangoClient
+
+            client = ArangoClient(hosts=self._host)
+            self._db = client.db(
+                self._database,
+                username=self._username,
+                password=self._password,
+            )
+        return self._db
+
+    def execute(self, query: str) -> tuple[list[dict], list[dict]]:
+        """Execute AQL query and return (nodes, edges).
+
+        Parameters
+        ----------
+        query : str
+            AQL query to execute.
+
+        Returns
+        -------
+        tuple[list[dict], list[dict]]
+            Tuple of (nodes, edges) lists.
+        """
+        cursor = self.db.aql.execute(query)
+        data = self._converter.convert(cursor)
+        return data["nodes"], data["edges"]
+
+    def fetch_schema(self) -> tuple[list[dict], list[dict]]:
+        """Fetch ArangoDB schema (collections).
+
+        Returns
+        -------
+        tuple[list[dict], list[dict]]
+            Tuple of (node_collections, edge_collections).
+        """
+        node_types: list[dict[str, Any]] = []
+        edge_types: list[dict[str, Any]] = []
+
+        for coll in self.db.collections():
+            if coll["system"]:
+                continue
+
+            coll_obj = self.db.collection(coll["name"])
+            info: dict[str, Any] = {
+                "name": coll["name"],
+                "count": coll_obj.count(),
+            }
+
+            # Edge collections have type 3
+            if coll.get("type") == 3 or coll.get("type") == "edge":
+                edge_types.append(info)
+            else:
+                node_types.append(info)
+
+        return node_types, edge_types

anywidget_graph-0.2.1/src/anywidget_graph/backends/grafeo.py

@@ -0,0 +1,70 @@
+"""Grafeo database backend (Python-side execution)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from anywidget_graph.converters import (
+    get_node_id,
+    is_node,
+    is_relationship,
+    node_to_dict,
+    relationship_to_dict,
+)
+
+if TYPE_CHECKING:
+    pass
+
+
+class GrafeoBackend:
+    """Backend for Grafeo database connections."""
+
+    def __init__(self, db: Any) -> None:
+        """Initialize with a GrafeoDB instance."""
+        self._db = db
+
+    @property
+    def db(self) -> Any:
+        """Get the underlying database instance."""
+        return self._db
+
+    def execute(self, query: str) -> tuple[list[dict], list[dict]]:
+        """Execute a Cypher query and return (nodes, edges)."""
+        result = self._db.execute(query)
+        return self._process_result(result)
+
+    def fetch_schema(self) -> tuple[list[dict], list[dict]]:
+        """Fetch schema from Grafeo database."""
+        # Grafeo schema fetching would be implemented here
+        # For now, return empty schema
+        return [], []
+
+    def _process_result(self, result: Any) -> tuple[list[dict], list[dict]]:
+        """Process query results into nodes and edges."""
+        nodes: dict[str, dict] = {}
+        edges: list[dict] = []
+
+        records = list(result) if hasattr(result, "__iter__") else [result]
+
+        for record in records:
+            items = self._extract_items(record)
+            for key, value in items:
+                if is_node(value):
+                    node_id = get_node_id(value)
+                    if node_id not in nodes:
+                        nodes[node_id] = node_to_dict(value)
+                elif is_relationship(value):
+                    edges.append(relationship_to_dict(value))
+
+        return list(nodes.values()), edges
+
+    def _extract_items(self, record: Any) -> list[tuple[str, Any]]:
+        """Extract key-value items from a record."""
+        if hasattr(record, "items"):
+            items = record.items() if callable(record.items) else record.items
+            return list(items)
+        elif hasattr(record, "data"):
+            return list(record.data().items())
+        elif isinstance(record, dict):
+            return list(record.items())
+        return []

anywidget_graph-0.2.1/src/anywidget_graph/backends/ladybug.py

@@ -0,0 +1,94 @@
+"""LadybugDB database backend."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from anywidget_graph.converters.cypher import CypherConverter
+
+if TYPE_CHECKING:
+    pass
+
+
+class LadybugBackend:
+    """Backend for LadybugDB embedded graph database.
+
+    LadybugDB is an embedded graph database that supports Cypher queries.
+
+    Parameters
+    ----------
+    db : Any
+        LadybugDB database instance.
+
+    Example
+    -------
+    >>> from ladybug import LadybugDB
+    >>> db = LadybugDB()
+    >>> db.execute("CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})")
+    >>>
+    >>> from anywidget_graph.backends import LadybugBackend
+    >>> backend = LadybugBackend(db)
+    >>> nodes, edges = backend.execute("MATCH (n)-[r]->(m) RETURN n, r, m")
+    """
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        self._converter = CypherConverter()
+
+    @property
+    def query_language(self) -> str:
+        """Return the default query language."""
+        return "cypher"
+
+    @property
+    def db(self) -> Any:
+        """Get the underlying database instance."""
+        return self._db
+
+    def execute(self, query: str) -> tuple[list[dict], list[dict]]:
+        """Execute Cypher query and return (nodes, edges).
+
+        Parameters
+        ----------
+        query : str
+            Cypher query to execute.
+
+        Returns
+        -------
+        tuple[list[dict], list[dict]]
+            Tuple of (nodes, edges) lists.
+        """
+        result = self._db.execute(query)
+        data = self._converter.convert(result)
+        return data["nodes"], data["edges"]
+
+    def fetch_schema(self) -> tuple[list[dict], list[dict]]:
+        """Fetch LadybugDB schema.
+
+        Returns
+        -------
+        tuple[list[dict], list[dict]]
+            Tuple of (node_types, edge_types).
+        """
+        node_types: list[dict[str, Any]] = []
+        edge_types: list[dict[str, Any]] = []
+
+        # Try to get labels if supported
+        try:
+            labels_result = self._db.execute("CALL db.labels()")
+            for record in labels_result:
+                label = record[0] if hasattr(record, "__getitem__") else str(record)
+                node_types.append({"label": label, "properties": []})
+        except Exception:
+            pass
+
+        # Try to get relationship types if supported
+        try:
+            types_result = self._db.execute("CALL db.relationshipTypes()")
+            for record in types_result:
+                rel_type = record[0] if hasattr(record, "__getitem__") else str(record)
+                edge_types.append({"type": rel_type, "properties": []})
+        except Exception:
+            pass
+
+        return node_types, edge_types