linkml-store 0.1.12__tar.gz → 0.1.13__tar.gz

{linkml_store-0.1.12 → linkml_store-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml-store
-Version: 0.1.12
+Version: 0.1.13
 Summary: linkml-store
 License: MIT
 Author: Author 1
@@ -21,6 +21,7 @@ Provides-Extra: h5py
 Provides-Extra: llm
 Provides-Extra: map
 Provides-Extra: mongodb
+Provides-Extra: neo4j
 Provides-Extra: pyarrow
 Provides-Extra: renderer
 Provides-Extra: tests
@@ -28,7 +29,7 @@ Provides-Extra: validation
 Requires-Dist: black (>=24.0.0) ; extra == "tests"
 Requires-Dist: chromadb ; extra == "chromadb"
 Requires-Dist: click
-Requires-Dist: duckdb (>=0.10.1,<0.11.0)
+Requires-Dist: duckdb (>=0.10.1)
 Requires-Dist: duckdb-engine (>=0.11.2)
 Requires-Dist: fastapi ; extra == "fastapi"
 Requires-Dist: frictionless ; extra == "frictionless"
@@ -41,8 +42,11 @@ Requires-Dist: linkml_map ; extra == "map"
 Requires-Dist: linkml_renderer ; extra == "renderer"
 Requires-Dist: llm ; extra == "llm"
 Requires-Dist: matplotlib ; extra == "analytics"
+Requires-Dist: neo4j ; extra == "neo4j"
+Requires-Dist: networkx ; extra == "neo4j"
 Requires-Dist: pandas (>=2.2.1) ; extra == "analytics"
 Requires-Dist: plotly ; extra == "analytics"
+Requires-Dist: py2neo ; extra == "neo4j"
 Requires-Dist: pyarrow ; extra == "pyarrow"
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Requires-Dist: pymongo ; extra == "mongodb"

{linkml_store-0.1.12 → linkml_store-0.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "linkml-store"
-version = "0.1.12"
+version = "0.1.13"
 description = "linkml-store"
 authors = ["Author 1 <author@org.org>"]
 license = "MIT"
@@ -13,7 +13,7 @@ pydantic = "^2.0.0"
 linkml-runtime = ">=1.8.0"
 streamlit = { version = "^1.32.2", optional = true }
 sqlalchemy = "*"
-duckdb = "^0.10.1"
+duckdb = ">=0.10.1"
 duckdb-engine = ">=0.11.2"
 matplotlib = { version = "*", optional = true }
 seaborn = { version = "*", optional = true }
@@ -22,6 +22,9 @@ pystow = "^0.5.4"
 black = { version=">=24.0.0", optional = true }
 llm = { version="*", optional = true }
 pymongo = { version="*", optional = true }
+neo4j = { version="*", optional = true }
+py2neo = { version="*", optional = true }
+networkx = { version="*", optional = true }
 chromadb = { version="*", optional = true }
 pyarrow = { version="*", optional = true }
 h5py = { version="*", optional = true }
@@ -66,6 +69,7 @@ app = ["streamlit"]
 tests = ["black"]
 llm = ["llm"]
 mongodb = ["pymongo"]
+neo4j = ["neo4j", "py2neo", "networkx"]
 chromadb = ["chromadb"]
 h5py = ["h5py"]
 pyarrow = ["pyarrow"]

{linkml_store-0.1.12 → linkml_store-0.1.13}/src/linkml_store/api/client.py

@@ -11,6 +11,7 @@ from linkml_store.api.stores.chromadb.chromadb_database import ChromaDBDatabase
 from linkml_store.api.stores.duckdb.duckdb_database import DuckDBDatabase
 from linkml_store.api.stores.filesystem.filesystem_database import FileSystemDatabase
 from linkml_store.api.stores.mongodb.mongodb_database import MongoDBDatabase
+from linkml_store.api.stores.neo4j.neo4j_database import Neo4jDatabase
 from linkml_store.api.stores.solr.solr_database import SolrDatabase
 
 logger = logging.getLogger(__name__)
@@ -21,6 +22,7 @@ HANDLE_MAP = {
     "solr": SolrDatabase,
     "mongodb": MongoDBDatabase,
     "chromadb": ChromaDBDatabase,
+    "neo4j": Neo4jDatabase,
     "file": FileSystemDatabase,
 }
 

{linkml_store-0.1.12 → linkml_store-0.1.13}/src/linkml_store/api/collection.py

@@ -4,7 +4,21 @@ import hashlib
 import logging
 from collections import defaultdict
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, TextIO, Tuple, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Dict,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    TextIO,
+    Tuple,
+    Type,
+    Union,
+)
 
 import numpy as np
 from linkml_runtime import SchemaView
@@ -202,6 +216,12 @@ class Collection(Generic[DatabaseType]):
             self._materialize_derivations()
             self._initialized = True
 
+    def _pre_insert_hook(self, objs: List[OBJECT], **kwargs):
+        if self.metadata.validate_modifications:
+            errors = list(self.iter_validate_collection(objs))
+            if errors:
+                raise ValueError(f"Validation errors: {errors}")
+
     def _post_insert_hook(self, objs: List[OBJECT], **kwargs):
         self._initialized = True
         patches = [{"op": "add", "path": "/0", "value": obj} for obj in objs]
@@ -978,11 +998,14 @@ class Collection(Generic[DatabaseType]):
         patches_from_objects_lists(src_objs, tgt_objs, primary_key=primary_key)
         return patches_from_objects_lists(src_objs, tgt_objs, primary_key=primary_key)
 
-    def iter_validate_collection(self, **kwargs) -> Iterator["ValidationResult"]:
+    def iter_validate_collection(
+        self, objects: Optional[Iterable[OBJECT]] = None, **kwargs
+    ) -> Iterator["ValidationResult"]:
         """
         Validate the contents of the collection
 
         :param kwargs:
+        :param objects: objects to validate
         :return: iterator over validation results
         """
         from linkml.validator import JsonschemaValidationPlugin, Validator
@@ -992,10 +1015,24 @@ class Collection(Generic[DatabaseType]):
         cd = self.class_definition()
         if not cd:
             raise ValueError(f"Cannot find class definition for {self.target_class_name}")
+        type_designator = None
+        for att in self.parent.schema_view.class_induced_slots(cd.name):
+            if att.designates_type:
+                type_designator = att.name
         class_name = cd.name
-        for obj in self.find_iter(**kwargs):
+        if objects is None:
+            objects = self.find_iter(**kwargs)
+        for obj in objects:
             obj = clean_empties(obj)
-            yield from validator.iter_results(obj, class_name)
+            v_class_name = class_name
+            if type_designator is not None:
+                # TODO: move type designator logic to core linkml
+                this_class_name = obj.get(type_designator)
+                if this_class_name:
+                    if ":" in this_class_name:
+                        this_class_name = this_class_name.split(":")[-1]
+                    v_class_name = this_class_name
+            yield from validator.iter_results(obj, v_class_name)
 
     def commit(self):
         """

{linkml_store-0.1.12 → linkml_store-0.1.13}/src/linkml_store/api/config.py

@@ -2,6 +2,8 @@ from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
+from linkml_store.graphs.graph_map import GraphProjection
+
 
 class ConfiguredBaseModel(BaseModel, extra="forbid"):
     """
@@ -79,6 +81,14 @@ class CollectionConfig(ConfiguredBaseModel):
         description="LinkML-Map derivations",
     )
     page_size: Optional[int] = Field(default=None, description="Suggested page size (items per page) in apps and APIs")
+    graph_projection: Optional[GraphProjection] = Field(
+        default=None,
+        description="Optional graph projection configuration",
+    )
+    validate_modifications: Optional[bool] = Field(
+        default=False,
+        description="Whether to validate inserts, updates, and deletes",
+    )
 
 
 class DatabaseConfig(ConfiguredBaseModel):

{linkml_store-0.1.12 → linkml_store-0.1.13}/src/linkml_store/api/database.py

@@ -505,8 +505,10 @@ class Database(ABC, Generic[CollectionType]):
         if isinstance(schema_view, str):
             schema_view = SchemaView(schema_view)
         self._schema_view = schema_view
+        # self._schema_view = SchemaView(schema_view.materialize_derived_schema())
         if not self._collections:
             return
+
         # align with induced schema
         roots = [c for c in schema_view.all_classes().values() if c.tree_root]
         if len(roots) == 0:

linkml_store-0.1.13/src/linkml_store/api/stores/neo4j/neo4j_collection.py

@@ -0,0 +1,429 @@
+import logging
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from neo4j import Driver, Session
+
+from linkml_store.api import Collection
+from linkml_store.api.collection import DEFAULT_FACET_LIMIT, OBJECT
+from linkml_store.api.queries import Query, QueryResult
+from linkml_store.graphs.graph_map import EdgeProjection, GraphProjection, NodeProjection
+
+logger = logging.getLogger(__name__)
+
+
+class DeletePolicy(Enum):
+    CASCADE = "cascade"
+    ERROR = "error"
+    STUB = "stub"
+
+
+class Neo4jCollection(Collection):
+    """
+    Adapter for collections in a Neo4j database.
+    """
+
+    # _graph_projection: Optional[GraphProjection] = None
+    delete_policy: DeletePolicy = DeletePolicy.CASCADE
+
+    @property
+    def driver(self) -> Driver:
+        return self.parent.driver
+
+    def session(self) -> Session:
+        return self.parent.session()
+
+    def _check_if_initialized(self) -> bool:
+        with self.session() as session:
+            result = session.run("MATCH (n) RETURN count(n) > 0 as exists")
+            return result.single()["exists"]
+
+    @property
+    def graph_projection(self) -> GraphProjection:
+        return self.metadata.graph_projection
+
+    @property
+    def node_projection(self) -> Optional[NodeProjection]:
+        return self.metadata.graph_projection if isinstance(self.graph_projection, NodeProjection) else None
+
+    @property
+    def edge_projection(self) -> Optional[EdgeProjection]:
+        return self.metadata.graph_projection if isinstance(self.graph_projection, EdgeProjection) else None
+
+    @property
+    def is_edge_collection(self) -> bool:
+        return isinstance(self.graph_projection, EdgeProjection)
+
+    @property
+    def category_labels_attribute(self) -> str:
+        np = self.node_projection
+        category_labels_attribute = None
+        if np:
+            category_labels_attribute = np.category_labels_attribute
+        if not category_labels_attribute:
+            category_labels_attribute = "category"
+        return category_labels_attribute
+
+    @property
+    def identifier_attribute(self) -> str:
+        gp = self.graph_projection
+        id_attribute = None
+        if gp:
+            id_attribute = gp.identifier_attribute
+        if not id_attribute:
+            id_attribute = "id"
+        return id_attribute
+
+    def _node_pattern(self, obj: Optional[OBJECT] = None, node_var="n") -> str:
+        obj = {} if obj is None else obj
+        category_labels_attribute = self.category_labels_attribute
+        categories = obj.get(category_labels_attribute or "category", [])
+        if not isinstance(categories, list):
+            categories = [categories]
+        cstr = (":" + ":".join(categories)) if categories else ""
+        return f"{node_var}{cstr}"
+
+    @property
+    def is_node_collection(self) -> bool:
+        return not self.is_edge_collection
+
+    def set_is_edge_collection(self, force=False):
+        if self.is_edge_collection:
+            return
+        if self.graph_projection and not force:
+            raise ValueError("Cannot reassign without force=True")
+        self.metadata.graph_projection = EdgeProjection()
+
+    def set_is_node_collection(self, force=False):
+        if self.is_node_collection:
+            return
+        if self.graph_projection and not force:
+            raise ValueError("Cannot reassign without force=True")
+        self.metadata.graph_projection = NodeProjection()
+
+    def _prop_clause(
+        self, obj: OBJECT, node_var: Optional[str] = None, exclude_attributes: Optional[List[str]] = None
+    ) -> str:
+        if exclude_attributes is None:
+            exclude_attributes = [self.category_labels_attribute]
+        node_prefix = node_var + "." if node_var else ""
+        terms = [f"{node_prefix}{k}: ${k}" for k in obj.keys() if k not in exclude_attributes]
+        return ", ".join(terms)
+
+    def insert(self, objs: Union[OBJECT, List[OBJECT]], **kwargs):
+        if not isinstance(objs, list):
+            objs = [objs]
+        self._pre_insert_hook(objs)
+
+        with self.session() as session:
+            for obj in objs:
+                query = self._create_insert_cypher_query(obj)
+                session.run(query, **obj)
+
+        self._post_insert_hook(objs)
+
+    def _create_insert_cypher_query(self, obj: OBJECT) -> str:
+        id_attribute = self.identifier_attribute
+        if not self.is_edge_collection:
+            logger.debug(f"Inserting node: {obj}")
+            category_labels_attribute = self.category_labels_attribute
+            node_pattern = self._node_pattern(obj)
+            props = self._prop_clause(obj, exclude_attributes=[id_attribute, category_labels_attribute])
+            return f"CREATE ({node_pattern} {{{id_attribute}: ${id_attribute}, {props}}})"
+        else:
+            logger.debug(f"Inserting edge: {obj}")
+            ep = self.edge_projection
+            if ep.predicate_attribute not in obj:
+                raise ValueError(f"Predicate attribute {ep.predicate_attribute} not found in edge {obj}.")
+            if ep.subject_attribute not in obj:
+                raise ValueError(f"Subject attribute {ep.subject_attribute} not found in edge {obj}.")
+            if ep.object_attribute not in obj:
+                raise ValueError(f"Object attribute {ep.object_attribute} not found in edge {obj}.")
+            pred = obj[ep.predicate_attribute]
+            # check if nodes present; if not, make dangling stubs
+            # TODO: decide on how this should be handled in validation if some fields are required
+            for node_id in [obj[ep.subject_attribute], obj[ep.object_attribute]]:
+                check_query = (
+                    f"MATCH (n {{{ep.identifier_attribute}: ${ep.identifier_attribute}}}) RETURN count(n) as count"
+                )
+                with self.session() as session:
+                    result = session.run(check_query, **{ep.identifier_attribute: node_id})
+                    if result.single()["count"] == 0:
+                        if self.delete_policy == DeletePolicy.STUB:
+                            stub_query = f"CREATE (n {{{ep.identifier_attribute}: ${ep.identifier_attribute}}})"
+                            session.run(stub_query, **{ep.identifier_attribute: node_id})
+                        else:
+                            raise ValueError(f"Node with identifier {node_id} not found in the database.")
+            edge_props = self._prop_clause(
+                obj, exclude_attributes=[ep.subject_attribute, ep.predicate_attribute, ep.object_attribute]
+            )
+            return f"""
+            MATCH (s {{{id_attribute}: ${ep.subject_attribute}}}), (o {{{id_attribute}: ${ep.object_attribute}}})
+            CREATE (s)-[r:{pred} {{{edge_props}}}]->(o)
+            """
+
+    def _prop_clause(self, obj: OBJECT, exclude_attributes: List[str] = None, node_var: Optional[str] = None) -> str:
+        if exclude_attributes is None:
+            exclude_attributes = []
+        node_prefix = f"{node_var}." if node_var else ""
+        terms = [f"{node_prefix}{k}: ${k}" for k in obj.keys() if k not in exclude_attributes]
+        return ", ".join(terms)
+
+    def query(self, query: Query, limit: Optional[int] = None, offset: Optional[int] = None, **kwargs) -> QueryResult:
+        cypher_query = self._build_cypher_query(query, limit, offset)
+        ca = self.category_labels_attribute
+        with self.session() as session:
+            result = session.run(cypher_query, query.where_clause)
+            if self.is_edge_collection:
+                rows = [self._edge_to_dict(record) for record in result]
+            else:
+
+                def node_to_dict(n) -> dict:
+                    d = dict(n.items())
+                    if ca:
+                        labels = list(n.labels)
+                        if labels:
+                            d[ca] = labels[0]
+                    return d
+
+                rows = [node_to_dict(record["n"]) for record in result]
+
+        # count_query = self._build_count_query(query, is_count=True)
+        count_query = self._build_cypher_query(query, is_count=True)
+        with self.session() as session:
+            count = session.run(count_query, query.where_clause).single()["count"]
+
+        return QueryResult(query=query, num_rows=count, rows=rows)
+
+    def _build_cypher_query(
+        self, query: Query, limit: Optional[int] = None, offset: Optional[int] = None, is_count=False
+    ) -> str:
+        if self.is_edge_collection:
+            ep = self.edge_projection
+            ia = ep.identifier_attribute
+            sa = ep.subject_attribute
+            pa = ep.predicate_attribute
+            oa = ep.object_attribute
+            wc = query.where_clause or {}
+            rq = "r"
+            pred = wc.get(pa, None)
+            if pred:
+                rq = f"r:{pred}"
+            sq = "s"
+            subj = wc.get(sa, None)
+            if subj:
+                sq = f"s {{{ia}: '{subj}'}}"
+            oq = "o"
+            obj = wc.get(oa, None)
+            if obj:
+                oq = f"o {{{ia}: '{obj}'}}"
+            where = {k: v for k, v in wc.items() if k not in [sa, pa, oa]}
+            cypher_query = f"""
+            MATCH ({sq})-[{rq}]->({oq})
+            {self._build_where_clause(where, 'r')}
+            """
+            if is_count:
+                cypher_query += """
+                RETURN count(r) as count
+                """
+            else:
+                cypher_query += f"""
+                RETURN r, type(r) as predicate, s.{ia} as subject, o.{ia} as object
+                """
+        else:
+            node_pattern = self._node_pattern(query.where_clause)
+            cypher_query = f"""
+            MATCH ({node_pattern})
+            {self._build_where_clause(query.where_clause)}
+            """
+            if is_count:
+                cypher_query += """
+                RETURN count(n) as count
+                """
+            else:
+                cypher_query += """
+                RETURN n
+                """
+
+        if not is_count:
+            if limit and limit >= 0:
+                cypher_query += f" LIMIT {limit}"
+            if offset and offset >= 0:
+                cypher_query += f" SKIP {offset}"
+
+        return cypher_query
+
+    def _build_where_clause(self, where_clause: Dict[str, Any], prefix: str = "n") -> str:
+        conditions = []
+        if where_clause is None:
+            return ""
+        for key, value in where_clause.items():
+            if key == self.category_labels_attribute:
+                continue
+            if isinstance(value, str):
+                conditions.append(f"{prefix}.{key} = '{value}'")
+            else:
+                conditions.append(f"{prefix}.{key} = {value}")
+
+        return "WHERE " + " AND ".join(conditions) if conditions else ""
+
+    def _edge_to_dict(self, record: Dict) -> Dict[str, Any]:
+        r = record["r"]
+        ep = self.edge_projection
+        return {
+            ep.subject_attribute: record["subject"],
+            ep.predicate_attribute: record["predicate"],
+            ep.object_attribute: record["object"],
+            **dict(r.items()),
+        }
+
+    def query_facets(
+        self,
+        where: Dict = None,
+        facet_columns: List[Union[str, Tuple[str, ...]]] = None,
+        facet_limit=DEFAULT_FACET_LIMIT,
+        **kwargs,
+    ) -> Dict[Union[str, Tuple[str, ...]], List[Tuple[Any, int]]]:
+        results = {}
+        if not facet_columns:
+            facet_columns = list(self.class_definition().attributes.keys())
+
+        category_labels_attribute = self.category_labels_attribute
+        with self.session() as session:
+            for col in facet_columns:
+                where_clause = self._build_where_clause(where) if where else ""
+                if col == category_labels_attribute:
+                    # Handle faceting on labels
+                    query = f"""
+                    MATCH (n)
+                    {where_clause}
+                    WITH labels(n) AS nodeLabels, count(*) as count
+                    UNWIND nodeLabels AS label
+                    WITH label, count
+                    ORDER BY count DESC, label
+                    LIMIT {facet_limit}
+                    RETURN label as value, count
+                    """
+                else:
+                    query = f"""
+                    MATCH (n)
+                    {where_clause}
+                    WITH n.{col} as value, count(*) as count
+                    WITH value, count
+                    ORDER BY count DESC
+                    LIMIT {facet_limit}
+                    RETURN value, count
+                    """
+                result = session.run(query)
+                results[col] = [(record["value"], record["count"]) for record in result]
+
+        return results
+
+    def delete(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> int:
+        delete_policy = self.delete_policy
+        if not isinstance(objs, list):
+            objs = [objs]
+
+        deleted_nodes = 0
+        deleted_relationships = 0
+        identifier_attribute = self.identifier_attribute
+
+        with self.session() as session:
+            for obj in objs:
+                node_pattern = self._node_pattern(obj)
+                id_value = obj[identifier_attribute]
+                where_clause = f"{{{identifier_attribute}: $id}}"
+                dn, dr = self._execute_delete(session, node_pattern, where_clause, delete_policy, id=id_value)
+                deleted_nodes += dn
+                deleted_relationships += dr
+
+        return deleted_nodes
+
+    def delete_where(self, where: Optional[Dict[str, Any]] = None, missing_ok=True, **kwargs) -> int:
+        delete_policy = self.delete_policy
+        where_clause = self._build_where_clause(where) if where else ""
+        node_pattern = self._node_pattern(where)
+
+        with self.session() as session:
+            deleted_nodes, deleted_relationships = self._execute_delete(
+                session, node_pattern, where_clause, delete_policy
+            )
+
+        if deleted_nodes == 0 and not missing_ok:
+            raise ValueError(f"No nodes found for {where}")
+
+        return deleted_nodes
+
+    def _execute_delete(
+        self, session, node_pattern: str, where_clause: str, delete_policy: DeletePolicy, **params
+    ) -> Tuple[int, int]:
+        deleted_relationships = 0
+        deleted_nodes = 0
+
+        if delete_policy == DeletePolicy.ERROR:
+            check_query = f"MATCH ({node_pattern} {where_clause})-[r]-() RETURN count(r) as rel_count"
+            result = session.run(check_query, **params)
+            if result.single()["rel_count"] > 0:
+                raise ValueError("Nodes with existing relationships found and cannot be deleted.")
+
+        if delete_policy == DeletePolicy.CASCADE:
+            rel_query = f"MATCH ({node_pattern} {where_clause})-[r]-() DELETE r"
+            result = session.run(rel_query, **params)
+            deleted_relationships = result.consume().counters.relationships_deleted
+
+        if delete_policy in [DeletePolicy.CASCADE, DeletePolicy.ERROR]:
+            node_query = f"MATCH ({node_pattern} {where_clause}) DELETE n"
+            result = session.run(node_query, **params)
+            deleted_nodes = result.consume().counters.nodes_deleted
+        elif delete_policy == DeletePolicy.STUB:
+            stub_query = f"MATCH ({node_pattern} {where_clause}) SET n.deleted = true RETURN count(n) as stub_count"
+            result = session.run(stub_query, **params)
+            deleted_nodes = result.single()["stub_count"]
+
+        return deleted_nodes, deleted_relationships
+
+    def update(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> int:
+        if not isinstance(objs, list):
+            objs = [objs]
+
+        updated_count = 0
+        with self.session() as session:
+            for obj in objs:
+                query = self._create_update_cypher_query(obj)
+                result = session.run(query, **obj)
+                updated_count += result.consume().counters.properties_set
+
+        return updated_count
+
+    def _create_update_cypher_query(self, obj: OBJECT) -> str:
+        id_attribute = self.identifier_attribute
+        category_labels_attribute = self.category_labels_attribute
+
+        # Prepare SET clause
+        set_items = [f"n.{k} = ${k}" for k in obj.keys() if k not in [id_attribute, category_labels_attribute]]
+        set_clause = ", ".join(set_items)
+
+        # Prepare labels update
+        labels_to_add = []
+        # labels_to_remove = []
+        if category_labels_attribute in obj:
+            new_labels = (
+                obj[category_labels_attribute]
+                if isinstance(obj[category_labels_attribute], list)
+                else [obj[category_labels_attribute]]
+            )
+            labels_to_add = [f":{label}" for label in new_labels]
+            # labels_to_remove = [":Label" for _ in new_labels]  # Placeholder for labels to remove
+
+        # Construct the query
+        query = f"MATCH (n {{{id_attribute}: ${id_attribute}}})\n"
+        # f labels_to_remove:
+        #    query += f"REMOVE n{' '.join(labels_to_remove)}\n"
+        if labels_to_add:
+            query += f"SET n{' '.join(labels_to_add)}\n"
+            # f"REMOVE n{' '.join(labels_to_remove)}' if labels_to_remove else ''}"
+            # f"{f'SET n{' '.join(labels_to_add)}' if labels_to_add else ''}"
+        query += f"SET {set_clause}\n"
+        query += "RETURN n"
+        print(query)
+        return query

linkml_store-0.1.13/src/linkml_store/api/stores/neo4j/neo4j_database.py

@@ -0,0 +1,154 @@
+# neo4j_database.py
+
+import logging
+from pathlib import Path
+from typing import Optional, Union
+
+from neo4j import Driver, GraphDatabase, Session
+
+from linkml_store.api import Database
+from linkml_store.api.queries import Query, QueryResult
+from linkml_store.api.stores.neo4j.neo4j_collection import Neo4jCollection
+from linkml_store.utils.format_utils import Format
+
+logger = logging.getLogger(__name__)
+
+
+class Neo4jDatabase(Database):
+    """
+    An adapter for Neo4j databases.
+    """
+
+    _driver: Driver = None
+    collection_class = Neo4jCollection
+
+    def __init__(self, handle: Optional[str] = None, **kwargs):
+        # Note: in the community editing the database must be "neo4j"
+        if handle is None:
+            handle = "bolt://localhost:7687/neo4j"
+        if handle.startswith("neo4j:"):
+            handle = handle.replace("neo4j:", "bolt:")
+        super().__init__(handle=handle, **kwargs)
+
+    @property
+    def _db_name(self) -> str:
+        if self.handle:
+            db = self.handle.split("/")[-1]
+        else:
+            db = "default"
+        return db
+
+    @property
+    def driver(self) -> Driver:
+        if self._driver is None:
+            uri, user, password = self._parse_handle()
+            self._driver = GraphDatabase.driver(uri, auth=(user, password))
+        return self._driver
+
+    def session(self) -> Session:
+        return self.driver.session(database=self._db_name)
+
+    def _parse_handle(self):
+        parts = self.handle.split("://")
+        protocol = parts[0]
+        rest = parts[1]
+
+        if "@" in rest:
+            auth, host = rest.split("@")
+            user, password = auth.split(":")
+        else:
+            host = rest
+            user, password = "neo4j", "password"  # Default credentials
+
+        uri = f"{protocol}://{host}"
+        return uri, user, password
+
+    def commit(self, **kwargs):
+        # Neo4j uses auto-commit by default for each transaction
+        pass
+
+    def close(self, **kwargs):
+        if self._driver:
+            self._driver.close()
+
+    def drop(self, **kwargs):
+        with self.driver.session() as session:
+            session.run("MATCH (n) DETACH DELETE n")
+
+    def query(self, query: Query, **kwargs) -> QueryResult:
+        if query.from_table:
+            collection = self.get_collection(query.from_table)
+            return collection.query(query, **kwargs)
+        else:
+            raise NotImplementedError(f"Querying without a table is not supported in {self.__class__.__name__}")
+
+    def init_collections(self):
+        if self._collections is None:
+            self._collections = {}
+
+        # In Neo4j, we don't have a direct equivalent to collections
+        # We'll use node labels as a proxy for collections
+        with self.driver.session() as session:
+            result = session.run("CALL db.labels()")
+            labels = [record["label"] for record in result]
+
+            for label in labels:
+                if label not in self._collections:
+                    collection = Neo4jCollection(name=label, parent=self)
+                    self._collections[label] = collection
+
+    def export_database(self, location: str, target_format: Optional[Union[str, Format]] = None, **kwargs):
+        # Neo4j doesn't have a built-in export function, so we'll implement a basic JSON export
+        if target_format == Format.JSON or target_format == "json":
+            path = Path(location)
+            with self.driver.session() as session:
+                result = session.run("MATCH (n) RETURN n")
+                nodes = [dict(record["n"].items()) for record in result]
+
+                result = session.run("MATCH ()-[r]->() RETURN r")
+                relationships = [
+                    {
+                        "type": record["r"].type,
+                        "start": record["r"].start_node.id,
+                        "end": record["r"].end_node.id,
+                        **dict(record["r"].items()),
+                    }
+                    for record in result
+                ]
+
+                data = {"nodes": nodes, "relationships": relationships}
+
+                import json
+
+                with open(path, "w") as f:
+                    json.dump(data, f)
+        else:
+            super().export_database(location, target_format=target_format, **kwargs)
+
+    def import_database(self, location: str, source_format: Optional[str] = None, **kwargs):
+        if source_format == Format.JSON or source_format == "json":
+            path = Path(location)
+            with open(path, "r") as f:
+                import json
+
+                data = json.load(f)
+
+            with self.driver.session() as session:
+                for node in data["nodes"]:
+                    labels = node.pop("labels", ["Node"])
+                    props = ", ".join([f"{k}: ${k}" for k in node.keys()])
+                    query = f"CREATE (n:{':'.join(labels)} {{{props}}})"
+                    session.run(query, **node)
+
+                for rel in data["relationships"]:
+                    # rel_type = rel.pop("type")
+                    start = rel.pop("start")
+                    end = rel.pop("end")
+                    # props = ", ".join([f"{k}: ${k}" for k in rel.keys()])
+                    query = (
+                        f"MATCH (a), (b) WHERE id(a) = {start} AND id(b) = {end} "
+                        "CREATE (a)-[r:{rel_type} {{{props}}}]->(b)"
+                    )
+                    session.run(query, **rel)
+        else:
+            super().import_database(location, source_format=source_format, **kwargs)

linkml_store-0.1.13/src/linkml_store/graphs/graph_map.py

@@ -0,0 +1,24 @@
+from abc import ABC
+from typing import Optional
+
+from pydantic import BaseModel
+
+DEFAULT_IDENTIFIER_ATTRIBUTE = "id"
+DEFAULT_CATEGORY_LABELS_ATTRIBUTE = "category"
+DEFAULT_SUBJECT_ATTRIBUTE = "subject"
+DEFAULT_PREDICATE_ATTRIBUTE = "predicate"
+DEFAULT_OBJECT_ATTRIBUTE = "object"
+
+
+class GraphProjection(BaseModel, ABC):
+    identifier_attribute: str = DEFAULT_IDENTIFIER_ATTRIBUTE
+
+
+class NodeProjection(GraphProjection):
+    category_labels_attribute: Optional[str] = DEFAULT_CATEGORY_LABELS_ATTRIBUTE
+
+
+class EdgeProjection(GraphProjection):
+    subject_attribute: str = DEFAULT_SUBJECT_ATTRIBUTE
+    predicate_attribute: str = DEFAULT_PREDICATE_ATTRIBUTE
+    object_attribute: str = DEFAULT_OBJECT_ATTRIBUTE

linkml_store-0.1.13/src/linkml_store/utils/neo4j_utils.py

@@ -0,0 +1,42 @@
+import networkx as nx
+from py2neo import Graph
+
+
+def draw_neo4j_graph(handle="bolt://localhost:7687", auth=("neo4j", None)):
+    # Connect to Neo4j
+    graph = Graph(handle, auth=auth)
+
+    # Run a Cypher query
+    query = """
+    MATCH (n)-[r]->(m)
+    RETURN n, r, m
+    LIMIT 100
+    """
+    result = graph.run(query)
+
+    # Create a NetworkX graph
+    G = nx.DiGraph()  # Use DiGraph for directed edges
+    for record in result:
+        n = record["n"]
+        m = record["m"]
+        r = record["r"]
+        G.add_node(n["name"], label=list(n.labels or ["-"])[0])
+        G.add_node(m["name"], label=list(m.labels or ["-"])[0])
+        G.add_edge(n["name"], m["name"], type=type(r).__name__)
+
+    # Draw the graph
+    pos = nx.spring_layout(G)
+
+    # Draw nodes
+    nx.draw_networkx_nodes(G, pos, node_color="lightblue", node_size=10000)
+
+    # Draw edges
+    nx.draw_networkx_edges(G, pos, edge_color="gray", arrows=True)
+
+    # Add node labels
+    node_labels = nx.get_node_attributes(G, "label")
+    nx.draw_networkx_labels(G, pos, {node: f"{node}\n({label})" for node, label in node_labels.items()}, font_size=16)
+
+    # Add edge labels
+    edge_labels = nx.get_edge_attributes(G, "type")
+    nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=16)