cognite-neat 0.97.2__py3-none-any.whl → 0.98.0__py3-none-any.whl

cognite/neat/_rules/importers/_dtdl2rules/dtdl_importer.py

@@ -17,7 +17,7 @@ from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers._base import BaseImporter
 from cognite.neat._rules.importers._dtdl2rules.dtdl_converter import _DTDLConverter
 from cognite.neat._rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
-from cognite.neat._rules.models import InformationInputRules, SchemaCompleteness
+from cognite.neat._rules.models import InformationInputRules
 from cognite.neat._rules.models.information import InformationInputMetadata
 from cognite.neat._utils.text import humanize_collection, to_pascal
 
@@ -31,7 +31,7 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
 
     Args:
         items (Sequence[DTDLBase]): A sequence of DTDLBase objects.
-        title (str, optional): Title of the data model. Defaults to None.
+        name (str, optional): Name of the data model. Defaults to None.
         read_issues (list[ValidationIssue], optional): A list of issues that occurred during reading. Defaults to None.
         schema (SchemaCompleteness, optional): Schema completeness. Defaults to SchemaCompleteness.partial.
 
@@ -40,14 +40,12 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
     def __init__(
         self,
         items: Sequence[DTDLBase],
-        title: str | None = None,
+        name: str | None = None,
         read_issues: list[NeatIssue] | None = None,
-        schema: SchemaCompleteness = SchemaCompleteness.partial,
     ) -> None:
         self._items = items
-        self.title = title
+        self.name = name
         self._read_issues = IssueList(read_issues)
-        self._schema_completeness = schema
 
     @classmethod
     def _from_file_content(cls, file_content: str, filepath: Path) -> Iterable[DTDLBase | NeatIssue]:
@@ -130,17 +128,16 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
         converter.convert(self._items)
 
         metadata = self._default_metadata()
-        metadata["schema"] = self._schema_completeness.value
 
-        if self.title:
-            metadata["title"] = to_pascal(self.title)
+        if self.name:
+            metadata["name"] = to_pascal(self.name)
         try:
             most_common_prefix = converter.get_most_common_prefix()
         except ValueError:
             # No prefixes are defined so we just use the default prefix...
             ...
         else:
-            metadata["prefix"] = most_common_prefix
+            metadata["space"] = most_common_prefix
 
         rules = InformationInputRules(
             metadata=InformationInputMetadata.load(metadata),

cognite/neat/_rules/importers/_rdf/_base.py

@@ -1,9 +1,11 @@
 from pathlib import Path
 
+from cognite.client import data_modeling as dm
 from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SH, SKOS, XSD, Graph, Namespace, URIRef
 
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import FileReadError
+from cognite.neat._issues.errors._general import NeatValueError
 from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers._base import BaseImporter
 from cognite.neat._rules.models.data_types import AnyURI
@@ -12,31 +14,38 @@ from cognite.neat._rules.models.information import (
     InformationInputRules,
 )
 from cognite.neat._store import NeatGraphStore
-from cognite.neat._utils.rdf_ import get_namespace, uri_to_short_form
+from cognite.neat._utils.rdf_ import get_namespace
 
 DEFAULT_NON_EXISTING_NODE_TYPE = AnyURI()
 
 
+DEFAULT_RDF_DATA_MODEL_ID = ("neat_space", "RDFDataModel", "rdf")
+
+
 class BaseRDFImporter(BaseImporter[InformationInputRules]):
     """Baser RDF importers used for all rules importers that are using RDF as input.
 
     Args:
         issue_list: Issue list to store issues
         graph: Knowledge graph
-        prefix: Prefix to be used for the imported rules
+        data_model_id: Data model id to be used for the imported rules
+        space: CDF Space to be used for the imported rules
     """
 
     def __init__(
         self,
         issue_list: IssueList,
         graph: Graph,
-        prefix: str,
+        data_model_id: dm.DataModelId | tuple[str, str, str],
         max_number_of_instance: int,
         non_existing_node_type: UnknownEntity | AnyURI,
     ) -> None:
         self.issue_list = issue_list
         self.graph = graph
-        self.prefix = prefix
+        self.data_model_id = dm.DataModelId.load(data_model_id)
+        if self.data_model_id.version is None:
+            raise NeatValueError("Version is required when setting a Data Model ID")
+
         self.max_number_of_instance = max_number_of_instance
         self.non_existing_node_type = non_existing_node_type
 
@@ -44,14 +53,14 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
     def from_graph_store(
         cls,
         store: NeatGraphStore,
-        prefix: str = "neat",
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_RDF_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ):
         return cls(
             IssueList(title=f"{cls.__name__} issues"),
             store.graph,
-            prefix=prefix,
+            data_model_id=data_model_id,
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
         )
@@ -60,7 +69,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
     def from_file(
         cls,
         filepath: Path,
-        prefix: str = "neat",
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_RDF_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ):
@@ -86,7 +95,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         return cls(
             issue_list,
             graph,
-            prefix=prefix,
+            data_model_id=data_model_id,
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
         )
@@ -106,32 +115,11 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
 
         rules = InformationInputRules.load(rules_dict)
 
-        self._add_transformation(rules)
-
         return ReadRules(rules, self.issue_list, {})
 
     def _to_rules_components(self) -> dict:
         raise NotImplementedError()
 
-    @classmethod
-    def _add_transformation(cls, rules: InformationInputRules) -> None:
-        rules.prefixes = {}
-
-        rules.prefixes[rules.metadata.prefix] = Namespace(rules.metadata.namespace)
-
-        class_ref_dict = {}
-        for class_ in rules.classes:
-            if class_.reference:
-                cls._add_uri_namespace_to_prefixes(URIRef(class_.reference), rules.prefixes)
-                class_ref_dict[class_.class_] = f"{uri_to_short_form(URIRef(class_.reference), rules.prefixes)}"
-
-        for property_ in rules.properties:
-            if property_.reference:
-                cls._add_uri_namespace_to_prefixes(URIRef(property_.reference), rules.prefixes)
-                if class_id := class_ref_dict.get(property_.class_, None):
-                    property_id = f"{uri_to_short_form(URIRef(property_.reference), rules.prefixes)}"
-                    property_.transformation = f"{class_id}({property_id})"
-
     @classmethod
     def _add_uri_namespace_to_prefixes(cls, URI: URIRef, prefixes: dict[str, Namespace]):
         """Add URI to prefixes dict if not already present

cognite/neat/_rules/importers/_rdf/_imf2rules/_imf2classes.py

@@ -35,7 +35,7 @@ def parse_imf_to_classes(graph: Graph, language: str = "en") -> list[dict]:
     """
 
     query = """
-    SELECT ?class ?name ?description ?parentClass ?reference ?match ?comment
+    SELECT ?class ?name ?description ?parentClass
     WHERE {
         # Finding IMF - elements
         VALUES ?type { imf:BlockType imf:TerminalType imf:AttributeType }
@@ -79,7 +79,7 @@ def parse_imf_to_classes(graph: Graph, language: str = "en") -> list[dict]:
     processed_df = make_classes_compliant(processed_df, importer="IMF")
 
     # Make Parent Class list elements into string joined with comma
-    processed_df["Parent Class"] = processed_df["Parent Class"].apply(
+    processed_df["Implements"] = processed_df["Implements"].apply(
         lambda x: ", ".join(x) if isinstance(x, list) and x else None
     )
 

cognite/neat/_rules/importers/_rdf/_imf2rules/_imf2metadata.py

@@ -1,10 +1,8 @@
-from rdflib import Namespace
-
 from cognite.neat._rules.importers._rdf._shared import make_metadata_compliant
-from cognite.neat._rules.models import RoleTypes, SchemaCompleteness
+from cognite.neat._rules.models import RoleTypes
 
 
-def parse_imf_metadata(prefix: str = "pcaimf") -> dict:
+def parse_imf_metadata(space: str = "pcaimf") -> dict:
     """Provide hardcoded IMF metadata to dict.
 
     Returns:
@@ -18,17 +16,14 @@ def parse_imf_metadata(prefix: str = "pcaimf") -> dict:
 
     raw_metadata = {
         "role": RoleTypes.information,
-        "schema": SchemaCompleteness.partial,
-        "prefix": prefix,
-        "namespace": Namespace("https://posccaesar.org/imf/"),
+        "space": space,
+        "external_id": "imf_types",
         "version": None,
         "created": None,
         "updated": None,
-        "title": "IMF_types",
+        "name": "IMF Types",
         "description": "IMF - types",
         "creator": None,
-        "rights": None,
-        "license": None,
     }
 
     return make_metadata_compliant(raw_metadata)

cognite/neat/_rules/importers/_rdf/_imf2rules/_imf2properties.py

@@ -36,8 +36,7 @@ def parse_imf_to_properties(graph: Graph, language: str = "en") -> list[dict]:
     """
 
     query = """
-    SELECT DISTINCT ?class ?property ?name ?description ?valueType ?minCount ?maxCount ?default ?reference
-    ?match ?comment ?propertyType
+    SELECT DISTINCT ?class ?property ?name ?description ?valueType ?minCount ?maxCount ?default ?propertyType
     WHERE
     {
         # Finding IMF-blocks and terminals

cognite/neat/_rules/importers/_rdf/_inference2rules.py

@@ -4,23 +4,25 @@ from datetime import datetime
 from pathlib import Path
 from typing import ClassVar, cast
 
-from rdflib import RDF, URIRef
+from cognite.client import data_modeling as dm
+from rdflib import RDF, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
 from cognite.neat._rules.models import data_types
-from cognite.neat._rules.models._base_rules import MatchType
 from cognite.neat._rules.models.data_types import AnyURI
 from cognite.neat._rules.models.entities._single_value import UnknownEntity
 from cognite.neat._rules.models.information import (
     InformationMetadata,
 )
 from cognite.neat._store import NeatGraphStore
-from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
 
 from ._base import DEFAULT_NON_EXISTING_NODE_TYPE, BaseRDFImporter
 
+DEFAULT_INFERENCE_DATA_MODEL_ID = ("neat_space", "InferredDataModel", "inferred")
+
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
                            group by ?class order by DESC(?instances)"""
@@ -65,27 +67,27 @@ class InferenceImporter(BaseRDFImporter):
     def from_graph_store(
         cls,
         store: NeatGraphStore,
-        prefix: str = "inferred",
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> "InferenceImporter":
-        return super().from_graph_store(store, prefix, max_number_of_instance, non_existing_node_type)
+        return super().from_graph_store(store, data_model_id, max_number_of_instance, non_existing_node_type)
 
     @classmethod
     def from_file(
         cls,
         filepath: Path,
-        prefix: str = "inferred",
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> "InferenceImporter":
-        return super().from_file(filepath, prefix, max_number_of_instance, non_existing_node_type)
+        return super().from_file(filepath, data_model_id, max_number_of_instance, non_existing_node_type)
 
     @classmethod
     def from_json_file(
         cls,
         filepath: Path,
-        prefix: str = "inferred",
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
@@ -94,7 +96,7 @@ class InferenceImporter(BaseRDFImporter):
     def from_yaml_file(
         cls,
         filepath: Path,
-        prefix: str = "inferred",
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("YAML file format is not supported yet.")
@@ -103,7 +105,7 @@ class InferenceImporter(BaseRDFImporter):
     def from_xml_file(
         cls,
         filepath: Path,
-        prefix: str = "inferred",
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
@@ -120,29 +122,32 @@ class InferenceImporter(BaseRDFImporter):
         Returns:
             Tuple of data model and prefixes of the graph
         """
+
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
+        prefixes: dict[str, Namespace] = {}
         count_by_value_type_by_property: dict[str, dict[str, int]] = defaultdict(Counter)
 
         # Infers all the classes in the graph
         for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
-            if (class_id := remove_namespace_from_uri(class_uri)) in classes:
+            if (class_id := remove_namespace_from_uri(cast(URIRef, class_uri))) in classes:
                 # handles cases when class id is already present in classes
                 class_id = f"{class_id}_{len(classes)+1}"
 
             classes[class_id] = {
                 "class_": class_id,
-                "reference": class_uri,
-                "match_type": MatchType.exact,
+                "uri": class_uri,
                 "comment": f"Inferred from knowledge graph, where this class has <{no_instances}> instances",
             }
 
+            self._add_uri_namespace_to_prefixes(cast(URIRef, class_uri), prefixes)
+
         # Infers all the properties of the class
         for class_id, class_definition in classes.items():
             for (instance,) in self.graph.query(  # type: ignore[misc]
-                INSTANCES_OF_CLASS_QUERY.replace("class", class_definition["reference"])
+                INSTANCES_OF_CLASS_QUERY.replace("class", class_definition["uri"])
                 if self.max_number_of_instance < 0
-                else INSTANCES_OF_CLASS_QUERY.replace("class", class_definition["reference"])
+                else INSTANCES_OF_CLASS_QUERY.replace("class", class_definition["uri"])
                 + f" LIMIT {self.max_number_of_instance}"
             ):
                 for property_uri, occurrence, data_type_uri, object_type_uri in self.graph.query(  # type: ignore[misc]
@@ -152,11 +157,13 @@ class InferenceImporter(BaseRDFImporter):
                     if property_uri == RDF.type:
                         continue
 
+                    self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
                     property_id = remove_namespace_from_uri(property_uri)
                     if isinstance(data_type_uri, URIRef):
                         data_type_uri = self.overwrite_data_types.get(data_type_uri, data_type_uri)
 
                     if value_type_uri := (data_type_uri or object_type_uri):
+                        self._add_uri_namespace_to_prefixes(cast(URIRef, value_type_uri), prefixes)
                         value_type_id = remove_namespace_from_uri(value_type_uri)
 
                     # this handles situations when property points to node that is not present in graph
@@ -181,7 +188,10 @@ class InferenceImporter(BaseRDFImporter):
                         "property_": property_id,
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
-                        "reference": property_uri,
+                        "transformation": (
+                            f"{uri_to_short_form(class_definition['uri'], prefixes)}"
+                            f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
+                        ),
                     }
 
                     count_by_value_type_by_property[id_][value_type_id] += 1
@@ -233,16 +243,18 @@ class InferenceImporter(BaseRDFImporter):
             "metadata": self._default_metadata().model_dump(),
             "classes": list(classes.values()),
             "properties": list(properties.values()),
+            "prefixes": prefixes,
         }
 
     def _default_metadata(self):
         return InformationMetadata(
+            space=self.data_model_id.space,
+            external_id=self.data_model_id.external_id,
+            version=self.data_model_id.version,
             name="Inferred Model",
             creator="NEAT",
-            version="inferred",
             created=datetime.now(),
             updated=datetime.now(),
             description="Inferred model from knowledge graph",
-            prefix=self.prefix,
             namespace=DEFAULT_NAMESPACE,
         )

cognite/neat/_rules/importers/_rdf/_owl2rules/_owl2classes.py

@@ -24,7 +24,7 @@ def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
     """
 
     query = """
-        SELECT ?class ?name ?description ?parentClass ?reference ?match ?comment
+        SELECT ?class ?name ?description ?parentClass
         WHERE {
         ?class a owl:Class .
         OPTIONAL {?class rdfs:subClassOf ?parentClass }.
@@ -51,7 +51,7 @@ def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
     processed_df = make_classes_compliant(processed_df, importer="OWL")
 
     # Make Parent Class list elements into string joined with comma
-    processed_df["Parent Class"] = processed_df["Parent Class"].apply(
+    processed_df["Implements"] = processed_df["Implements"].apply(
         lambda x: ", ".join(x) if isinstance(x, list) and x else None
     )
 

cognite/neat/_rules/importers/_rdf/_owl2rules/_owl2metadata.py

@@ -1,8 +1,8 @@
-from rdflib import Graph, Namespace
+from rdflib import Graph
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules.importers._rdf._shared import make_metadata_compliant
-from cognite.neat._rules.models import RoleTypes, SchemaCompleteness
+from cognite.neat._rules.models import RoleTypes
 from cognite.neat._utils.collection_ import remove_none_elements_from_set
 from cognite.neat._utils.rdf_ import convert_rdflib_content
 
@@ -47,21 +47,18 @@ def parse_owl_metadata(graph: Graph) -> dict:
     raw_metadata = convert_rdflib_content(
         {
             "role": RoleTypes.information,
-            "schema": SchemaCompleteness.partial,
-            "prefix": results[1].pop(),
-            "namespace": Namespace(results[0].pop()),
+            "space": results[1].pop(),
+            "external_id": "OntologyBasedDataModel",
             "version": results[2].pop(),
             "created": results[3].pop(),
             "updated": results[4].pop(),
-            "title": results[5].pop(),
+            "name": results[5].pop(),
             "description": results[6].pop(),
             "creator": (
                 ", ".join(remove_none_elements_from_set(results[7]))
                 if remove_none_elements_from_set(results[7])
                 else None
             ),
-            "rights": results[8].pop(),
-            "license": results[9].pop(),
         }
     )
 

cognite/neat/_rules/importers/_rdf/_owl2rules/_owl2properties.py

@@ -22,8 +22,7 @@ def parse_owl_properties(graph: Graph, language: str = "en") -> list[dict]:
 
     query = """
 
-    SELECT ?class ?property ?name ?description ?type ?minCount ?maxCount ?default ?reference
-     ?match ?comment ?propertyType
+    SELECT ?class ?property ?name ?description ?type ?minCount ?maxCount ?default ?propertyType
     WHERE {
         ?property a ?propertyType.
         FILTER (?propertyType IN (owl:ObjectProperty, owl:DatatypeProperty ) )