format

Author: linkmluser

src/linkml_store/api/collection.py

@@ -4,8 +4,21 @@
 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, \
-    Iterable
+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
@@ -985,7 +998,9 @@ def diff(self, other: "Collection", **kwargs) -> List[PatchDict]:
         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, objects: Optional[Iterable[OBJECT]] = None, **kwargs) -> Iterator["ValidationResult"]:
+    def iter_validate_collection(
+        self, objects: Optional[Iterable[OBJECT]] = None, **kwargs
+    ) -> Iterator["ValidationResult"]:
         """
         Validate the contents of the collection
 
@@ -1001,7 +1016,7 @@ def iter_validate_collection(self, objects: Optional[Iterable[OBJECT]] = None, *
         if not cd:
             raise ValueError(f"Cannot find class definition for {self.target_class_name}")
         type_designator = None
-        for att in cd.attributes.values():
+        for att in self.parent.schema_view.class_induced_slots(cd.name):
             if att.designates_type:
                 type_designator = att.name
         class_name = cd.name
@@ -1014,7 +1029,7 @@ def iter_validate_collection(self, objects: Optional[Iterable[OBJECT]] = 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:
+                    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)

src/linkml_store/api/database.py

@@ -504,8 +504,8 @@ def set_schema_view(self, schema_view: Union[str, Path, SchemaView]):
             schema_view = str(schema_view)
         if isinstance(schema_view, str):
             schema_view = SchemaView(schema_view)
-        # self._schema_view = schema_view
-        self._schema_view = SchemaView(schema_view.materialize_derived_schema())
+        self._schema_view = schema_view
+        # self._schema_view = SchemaView(schema_view.materialize_derived_schema())
         if not self._collections:
             return
 
@@ -531,7 +531,6 @@ def set_schema_view(self, schema_view: Union[str, Path, SchemaView]):
                         coll = self._collections[slot.name]
                         coll.metadata.type = slot.range
 
-
     def load_schema_view(self, path: Union[str, Path]):
         """
         Load a schema view from a file.

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

@@ -7,7 +7,7 @@
 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 GraphProjection, EdgeProjection, NodeProjection
+from linkml_store.graphs.graph_map import EdgeProjection, GraphProjection, NodeProjection
 
 logger = logging.getLogger(__name__)
 
@@ -35,7 +35,7 @@ def session(self) -> Session:
 
     def _check_if_initialized(self) -> bool:
         with self.session() as session:
-            result = session.run(f"MATCH (n) RETURN count(n) > 0 as exists")
+            result = session.run("MATCH (n) RETURN count(n) > 0 as exists")
             return result.single()["exists"]
 
     @property
@@ -101,7 +101,9 @@ def set_is_node_collection(self, force=False):
             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:
+    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 ""
@@ -141,7 +143,9 @@ def _create_insert_cypher_query(self, obj: OBJECT) -> str:
             # 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"
+                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:
@@ -150,11 +154,9 @@ def _create_insert_cypher_query(self, obj: OBJECT) -> str:
                             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
-            ])
+            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)
@@ -175,13 +177,15 @@ def query(self, query: Query, limit: Optional[int] = None, offset: Optional[int]
             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)
@@ -191,7 +195,9 @@ def node_to_dict(n) -> dict:
 
         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:
+    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
@@ -247,8 +253,7 @@ def _build_cypher_query(self, query: Query, limit: Optional[int] = None, offset:
 
         return cypher_query
 
-
-    def _build_where_clause(self, where_clause: Dict[str, Any], prefix: str = 'n') -> str:
+    def _build_where_clause(self, where_clause: Dict[str, Any], prefix: str = "n") -> str:
         conditions = []
         if where_clause is None:
             return ""
@@ -269,15 +274,15 @@ def _edge_to_dict(self, record: Dict) -> Dict[str, Any]:
             ep.subject_attribute: record["subject"],
             ep.predicate_attribute: record["predicate"],
             ep.object_attribute: record["object"],
-            **dict(r.items())
+            **dict(r.items()),
         }
 
     def query_facets(
-            self,
-            where: Dict = None,
-            facet_columns: List[Union[str, Tuple[str, ...]]] = None,
-            facet_limit=DEFAULT_FACET_LIMIT,
-            **kwargs,
+        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:
@@ -334,23 +339,24 @@ def delete(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> int:
 
         return deleted_nodes
 
-    def delete_where(self, where: Optional[Dict[str, Any]] = None,
-                     missing_ok=True, **kwargs) -> int:
+    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)
+            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]:
+    def _execute_delete(
+        self, session, node_pattern: str, where_clause: str, delete_policy: DeletePolicy, **params
+    ) -> Tuple[int, int]:
         deleted_relationships = 0
         deleted_nodes = 0
 
@@ -376,7 +382,6 @@ def _execute_delete(self, session, node_pattern: str, where_clause: str, delete_
 
         return deleted_nodes, deleted_relationships
 
-
     def update(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> int:
         if not isinstance(objs, list):
             objs = [objs]
@@ -393,30 +398,32 @@ def update(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> int:
     def _create_update_cypher_query(self, obj: OBJECT) -> str:
         id_attribute = self.identifier_attribute
         category_labels_attribute = self.category_labels_attribute
-        node_pattern = self._node_pattern(obj)
 
         # 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 = []
+        # 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]]
+            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 = [f":Label" for _ in new_labels]  # Placeholder for labels to remove
+            # 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"
-        #if labels_to_remove:
+        # 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 ''}"
+            # 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
+        return query

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

@@ -1,10 +1,10 @@
 # neo4j_database.py
 
 import logging
-from typing import Optional, Union, List, Dict, Any
 from pathlib import Path
+from typing import Optional, Union
 
-from neo4j import GraphDatabase, Driver, Session
+from neo4j import Driver, GraphDatabase, Session
 
 from linkml_store.api import Database
 from linkml_store.api.queries import Query, QueryResult
@@ -107,22 +107,30 @@ def export_database(self, location: str, target_format: Optional[Union[str, Form
 
                 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]
+                    {
+                        "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:
+
+                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:
+            with open(path, "r") as f:
                 import json
+
                 data = json.load(f)
 
             with self.driver.session() as session:
@@ -133,11 +141,14 @@ def import_database(self, location: str, source_format: Optional[str] = None, **
                     session.run(query, **node)
 
                 for rel in data["relationships"]:
-                    rel_type = rel.pop("type")
+                    # 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)"
+                    # 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)
+            super().import_database(location, source_format=source_format, **kwargs)

src/linkml_store/graphs/graph_map.py

@@ -1,5 +1,5 @@
 from abc import ABC
-from typing import List, Optional
+from typing import Optional
 
 from pydantic import BaseModel
 
@@ -17,6 +17,7 @@ class GraphProjection(BaseModel, ABC):
 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

src/linkml_store/utils/neo4j_utils.py

@@ -1,5 +1,6 @@
-from py2neo import Graph
 import networkx as nx
+from py2neo import Graph
+
 
 def draw_neo4j_graph(handle="bolt://localhost:7687", auth=("neo4j", None)):
     # Connect to Neo4j
@@ -16,26 +17,26 @@ def draw_neo4j_graph(handle="bolt://localhost:7687", auth=("neo4j", None)):
     # 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__)
+        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)
+    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)
+    nx.draw_networkx_edges(G, pos, edge_color="gray", arrows=True)
 
     # Add node labels
-    node_labels = nx.get_node_attributes(G, 'label')
+    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)
+    edge_labels = nx.get_edge_attributes(G, "type")
+    nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=16)