cognite-neat 0.97.2__tar.gz → 0.97.3__tar.gz

{cognite_neat-0.97.2 → cognite_neat-0.97.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.97.2
+Version: 0.97.3
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

{cognite_neat-0.97.2 → cognite_neat-0.97.3}/cognite/neat/_graph/queries/_base.py

@@ -42,6 +42,27 @@ class Queries:
             for res in list(self.graph.query(query_statement))
         ]
 
+    @property
+    def types(self) -> dict[URIRef, str]:
+        """Types and their short form in the graph"""
+        query = """SELECT DISTINCT ?type
+                   WHERE {?s a ?type .}"""
+        return {type_: remove_namespace_from_uri(cast(URIRef, type_)) for (type_,) in list(self.graph.query(query))}  # type: ignore[misc, index, arg-type]
+
+    def type_uri(self, type_: str) -> list[URIRef]:
+        """Get the URIRef of a type"""
+        return [k for k, v in self.types.items() if v == type_]
+
+    @property
+    def properties(self) -> dict[URIRef, str]:
+        query = """SELECT DISTINCT ?property
+               WHERE {?s ?property ?o . FILTER(?property != rdf:type)}"""
+        return {type_: remove_namespace_from_uri(cast(URIRef, type_)) for (type_,) in list(self.graph.query(query))}  # type: ignore[misc, index, arg-type]
+
+    def property_uri(self, property_: str) -> list[URIRef]:
+        """Get the URIRef of a type"""
+        return [k for k, v in self.properties.items() if v == property_]
+
     def list_instances_ids_of_class(self, class_uri: URIRef, limit: int = -1) -> list[URIRef]:
         """Get instances ids for a given class
 
@@ -101,7 +122,7 @@ class Queries:
         # We cannot include the RDF.type in case there is a neat:type property
         return [remove_namespace_from_uri(list(triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
 
-    def types_with_property(self, property_uri: URIRef) -> list[URIRef]:
+    def type_with_property(self, type_: URIRef, property_uri: URIRef) -> bool:
         """Check if a property exists in the graph store
 
         Args:
@@ -110,8 +131,8 @@ class Queries:
         Returns:
             True if property exists, False otherwise
         """
-        query = f"SELECT DISTINCT ?t WHERE {{ ?s <{property_uri}> ?o ; a ?t}} Limit 1"
-        return cast(list[URIRef], [t[0] for t in self.graph.query(query)])  # type: ignore[index]
+        query = f"SELECT ?o WHERE {{ ?s a <{type_}> ; <{property_uri}> ?o .}} Limit 1"
+        return bool(list(self.graph.query(query)))
 
     def has_namespace(self, namespace: Namespace) -> bool:
         """Check if a namespace exists in the graph store
@@ -250,7 +271,7 @@ class Queries:
             result = self.graph.query(query)
 
             # We cannot include the RDF.type in case there is a neat:type property
-            return [remove_namespace_from_uri(cast(ResultRow, triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
+            return [remove_namespace_from_uri(cast(ResultRow, triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
         else:
             warnings.warn(
                 "No rules found for the graph store, returning empty list.",

{cognite_neat-0.97.2 → cognite_neat-0.97.3}/cognite/neat/_rules/models/dms/_validation.py

@@ -157,21 +157,6 @@ class DMSPostValidation:
                     )
                 )
 
-            # This sets the container definition for all the properties where it is not defined.
-            # This allows the user to define the container only once.
-            value_type = next(iter(value_types))
-            list_definition = next(iter(list_definitions)) if list_definitions else None
-            nullable_definition = next(iter(nullable_definitions)) if nullable_definitions else None
-            default_definition = next(iter(default_definitions)) if default_definitions else None
-            index_definition = next(iter(index_definitions)).split(",") if index_definitions else None
-            constraint_definition = next(iter(constraint_definitions)).split(",") if constraint_definitions else None
-            for _, prop in properties:
-                prop.value_type = value_type
-                prop.is_list = prop.is_list or list_definition
-                prop.nullable = prop.nullable or nullable_definition
-                prop.default = prop.default or default_definition
-                prop.index = prop.index or index_definition
-                prop.constraint = prop.constraint or constraint_definition
         self.issue_list.extend(errors)
 
     def _referenced_views_and_containers_are_existing_and_proper_size(self) -> None:

{cognite_neat-0.97.2 → cognite_neat-0.97.3}/cognite/neat/_session/_base.py

@@ -21,6 +21,7 @@ from cognite.neat._store._provenance import (
     INSTANCES_ENTITY,
     Change,
 )
+from cognite.neat._utils.auth import _CLIENT_NAME
 
 from ._inspect import InspectAPI
 from ._prepare import PrepareAPI
@@ -51,6 +52,8 @@ class NeatSession:
         self.show = ShowAPI(self._state)
         self.set = SetAPI(self._state, verbose)
         self.inspect = InspectAPI(self._state)
+        if self._client is not None and self._client._config is not None:
+            self._client._config.client_name = _CLIENT_NAME
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):
             print(f"Neat Engine {engine_version} loaded.")
 

{cognite_neat-0.97.2 → cognite_neat-0.97.3}/cognite/neat/_session/_prepare.py

@@ -12,7 +12,7 @@ from cognite.neat._rules.transformers import ReduceCogniteModel, ToCompliantEnti
 from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
-from .exceptions import intercept_session_exceptions
+from .exceptions import NeatSessionError, intercept_session_exceptions
 
 
 @intercept_session_exceptions
@@ -32,18 +32,18 @@ class InstancePrepareAPI:
 
     def make_connection_on_exact_match(
         self,
-        source: tuple[URIRef, URIRef],
-        target: tuple[URIRef, URIRef],
-        connection: URIRef | None = None,
+        source: tuple[str, str],
+        target: tuple[str, str],
+        connection: str | None = None,
         limit: int | None = 100,
     ) -> None:
         """Make connection on exact match.
 
         Args:
-            source: The source of the connection. A tuple of (rdf type, property) where
+            source: The source of the connection. A tuple of (type, property) where
                     where property is the property that should be matched on the source
                     to make the connection with the target.
-            target: The target of the connection. A tuple of (rdf type, property) where
+            target: The target of the connection. A tuple of (type, property) where
                     where property is the property that should be matched on the target
                     to make the connection with the source.
 
@@ -51,11 +51,19 @@ class InstancePrepareAPI:
                     will be made by lowercasing the target type.
             limit: The maximum number of connections to make. If None, all connections
 
+        !!! note "Make Connection on Exact Match"
+            This method will make a connection between the source and target based on the exact match:
+            (SourceType)-[sourceProperty]->(sourceValue) == (TargetType)-[targetProperty]->(targetValue)
+
+            The connection will be made by creating a new property on the source type that will contain the
+            target value, as follows:
+            (SourceType)-[connection]->(TargetType)
+
 
         """
 
-        subject_type, subject_predicate = source
-        object_type, object_predicate = target
+        subject_type, subject_predicate = self._get_type_and_property_uris(*source)
+        object_type, object_predicate = self._get_type_and_property_uris(*target)
 
         transformer = MakeConnectionOnExactMatch(
             subject_type,
@@ -68,6 +76,24 @@ class InstancePrepareAPI:
 
         self._state.instances.store.transform(transformer)
 
+    def _get_type_and_property_uris(self, type_: str, property_: str) -> tuple[URIRef, URIRef]:
+        type_uri = self._state.instances.store.queries.type_uri(type_)
+        property_uri = self._state.instances.store.queries.property_uri(property_)
+
+        if not type_uri:
+            raise NeatSessionError(f"Type {type_} does not exist in the graph.")
+        elif len(type_uri) > 1:
+            raise NeatSessionError(f"{type_} has multiple ids found in the graph: {','.join(type_uri)}.")
+
+        if not property_uri:
+            raise NeatSessionError(f"Property {property_} does not exist in the graph.")
+        elif len(type_uri) > 1:
+            raise NeatSessionError(f"{property_} has multiple ids found in the graph: {','.join(property_uri)}.")
+
+        if not self._state.instances.store.queries.type_with_property(type_uri[0], property_uri[0]):
+            raise NeatSessionError(f"Property {property_} is not defined for type {type_}. Cannot make connection")
+        return type_uri[0], property_uri[0]
+
 
 @intercept_session_exceptions
 class DataModelPrepareAPI:

cognite_neat-0.97.3/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.97.3"
+__engine__ = "^1.0.3"

{cognite_neat-0.97.2 → cognite_neat-0.97.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.97.2"
+version = "0.97.3"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.97.2/cognite/neat/_version.py

@@ -1,2 +0,0 @@
-__version__ = "0.97.2"
-__engine__ = "^1.0.3"