cognite-neat 0.121.0__py3-none-any.whl → 0.121.2__py3-none-any.whl

cognite/neat/core/{_rules → _data_model}/importers/_rdf/_imf2rules.py

@@ -1,28 +1,28 @@
 """This module performs importing of various formats to one of serializations for which
 there are loaders to TransformationRules pydantic class."""
 
-from cognite.neat.core._rules.importers._rdf._base import BaseRDFImporter
-from cognite.neat.core._rules.importers._rdf._shared import (
-    parse_classes,
+from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
+from cognite.neat.core._data_model.importers._rdf._shared import (
+    parse_concepts,
     parse_properties,
 )
 
 CLASSES_QUERY = """
-    SELECT ?class_ ?name ?description ?implements
+    SELECT ?concept ?name ?description ?implements
     WHERE {{
         VALUES ?type {{ imf:BlockType imf:TerminalType imf:AttributeType }}
-        ?class_ a ?type .
+        ?concept a ?type .
 
-        OPTIONAL {{?class_ rdfs:subClassOf ?parent }}.
-        OPTIONAL {{?class_ rdfs:label|skos:prefLabel ?name }}.
-        OPTIONAL {{?class_ rdfs:comment|skos:definition ?description}}.
+        OPTIONAL {{?concept rdfs:subClassOf ?parent }}.
+        OPTIONAL {{?concept rdfs:label|skos:prefLabel ?name }}.
+        OPTIONAL {{?concept rdfs:comment|skos:definition ?description}}.
 
 
         # Add imf:Attribute as parent class when no parent is found
         BIND(IF(!bound(?parent) && ?type = imf:AttributeType, imf:Attribute, ?parent) AS ?implements)
 
         # FILTERS
-        FILTER (!isBlank(?class_))
+        FILTER (!isBlank(?concept))
         FILTER (!bound(?implements) || !isBlank(?implements))
 
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
@@ -31,13 +31,13 @@ CLASSES_QUERY = """
     """
 
 PROPERTIES_QUERY = """
-    SELECT ?class_ ?property_ ?name ?description ?value_type ?min_count ?max_count ?default
+    SELECT ?concept ?property_ ?name ?description ?value_type ?min_count ?max_count ?default
     WHERE
     {{
         # CASE 1: Handling Blocks and Terminals
         {{
             VALUES ?type {{ imf:BlockType imf:TerminalType }}
-            ?class_ a ?type ;
+            ?concept a ?type ;
                 sh:property ?propertyShape .
                 ?propertyShape sh:path ?property_ .
 
@@ -55,10 +55,10 @@ PROPERTIES_QUERY = """
 
         # CASE 2: Handling Attributes
         {{
-            ?class_ a imf:AttributeType .
+            ?concept a imf:AttributeType .
             BIND(xsd:anyURI AS ?valueShape)
             BIND(imf:predicate AS ?property_)
-            ?class_  ?property_ ?defaultURI .
+            ?concept  ?property_ ?defaultURI .
             BIND(STR(?defaultURI) AS ?default)
 
         }}
@@ -67,7 +67,7 @@ PROPERTIES_QUERY = """
         BIND(IF(BOUND(?valueShape), ?valueShape, IF(BOUND(?range) , ?range , ?valueShape)) AS ?value_type)
 
         FILTER (!isBlank(?property_))
-        FILTER (!bound(?class_) || !isBlank(?class_))
+        FILTER (!bound(?concept) || !isBlank(?concept))
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
         FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "{language}"))
     }}
@@ -81,17 +81,17 @@ class IMFImporter(BaseRDFImporter):
     def description(self) -> str:
         return f"IMF Types {self.source_name} read as unverified data model"
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
-        classes, issue_list = parse_classes(self.graph, CLASSES_QUERY, self.language, self.issue_list)
+        classes, issue_list = parse_concepts(self.graph, CLASSES_QUERY, self.language, self.issue_list)
         self.issue_list = issue_list
         properties, issue_list = parse_properties(self.graph, PROPERTIES_QUERY, self.language, self.issue_list)
         self.issue_list = issue_list
 
         components = {
             "Metadata": self._metadata,
-            "Classes": list(classes.values()) if classes else [],
+            "Concepts": list(classes.values()) if classes else [],
             "Properties": list(properties.values()) if properties else [],
         }
 

cognite/neat/core/{_rules → _data_model}/importers/_rdf/_inference2rules.py

@@ -12,19 +12,19 @@ from rdflib import Literal as RdfLiteral
 
 from cognite.neat.core._config import GLOBAL_CONFIG
 from cognite.neat.core._constants import NEAT, get_default_prefixes_and_namespaces
+from cognite.neat.core._data_model.analysis import DataModelAnalysis
+from cognite.neat.core._data_model.models import ConceptualDataModel, data_types
+from cognite.neat.core._data_model.models.conceptual import (
+    Concept,
+    ConceptualMetadata,
+    UnverifiedConcept,
+    UnverifiedConceptualProperty,
+)
+from cognite.neat.core._data_model.models.data_types import AnyURI
+from cognite.neat.core._data_model.models.entities._single_value import UnknownEntity
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.warnings import PropertyValueTypeUndefinedWarning
-from cognite.neat.core._rules.analysis import RulesAnalysis
-from cognite.neat.core._rules.models import InformationRules, data_types
-from cognite.neat.core._rules.models.data_types import AnyURI
-from cognite.neat.core._rules.models.entities._single_value import UnknownEntity
-from cognite.neat.core._rules.models.information import (
-    InformationClass,
-    InformationInputClass,
-    InformationInputProperty,
-    InformationMetadata,
-)
-from cognite.neat.core._store import NeatGraphStore
+from cognite.neat.core._store import NeatInstanceStore
 from cognite.neat.core._store._provenance import INSTANCES_ENTITY
 from cognite.neat.core._utils.collection_ import iterate_progress_bar
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
@@ -83,8 +83,8 @@ class InferenceImporter(BaseRDFImporter):
     @classmethod
     def from_graph_store(
         cls,
-        store: NeatGraphStore,
-        data_model_id: dm.DataModelId | tuple[str, str, str] = DEFAULT_INFERENCE_DATA_MODEL_ID,
+        store: NeatInstanceStore,
+        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,
         language: str = "en",
@@ -145,7 +145,7 @@ class InferenceImporter(BaseRDFImporter):
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
         """Convert RDF graph to dictionary defining data model and prefixes of the graph
@@ -158,33 +158,33 @@ class InferenceImporter(BaseRDFImporter):
             Tuple of data model and prefixes of the graph
         """
 
-        classes: dict[str, dict] = {}
+        concepts: 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(cast(URIRef, class_uri))) in classes:
+        for concept_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
+            if (concept_id := remove_namespace_from_uri(cast(URIRef, concept_uri))) in concepts:
                 # handles cases when class id is already present in classes
-                class_id = f"{class_id}_{len(classes) + 1}"
+                concept_id = f"{concept_id}_{len(concepts) + 1}"
 
-            classes[class_id] = {
-                "class_": class_id,
-                "uri": class_uri,
+            concepts[concept_id] = {
+                "concept": concept_id,
+                "uri": concept_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)
+            self._add_uri_namespace_to_prefixes(cast(URIRef, concept_uri), prefixes)
 
         instances_query = (
             INSTANCES_OF_CLASS_QUERY if self.max_number_of_instance == -1 else INSTANCES_OF_CLASS_RICHNESS_ORDERED_QUERY
         )
 
-        classes_iterable = iterate_progress_bar(classes.items(), len(classes), "Inferring classes")
+        classes_iterable = iterate_progress_bar(concepts.items(), len(concepts), "Inferring classes")
 
         # Infers all the properties of the class
-        for class_id, class_definition in classes_iterable:
+        for concept_id, class_definition in classes_iterable:
             for (  # type: ignore[misc]
                 instance,
                 _,
@@ -216,7 +216,7 @@ class InferenceImporter(BaseRDFImporter):
 
                         issue = PropertyValueTypeUndefinedWarning(
                             resource_type="Property",
-                            identifier=f"{class_id}:{property_id}",
+                            identifier=f"{concept_id}:{property_id}",
                             property_name=property_id,
                             default_action="Remove the property from the rules",
                             recommended_action="Make sure that graph is complete",
@@ -225,10 +225,10 @@ class InferenceImporter(BaseRDFImporter):
                         if issue not in self.issue_list:
                             self.issue_list.append(issue)
 
-                    id_ = f"{class_id}:{property_id}"
+                    id_ = f"{concept_id}:{property_id}"
 
                     definition = {
-                        "class_": class_id,
+                        "concept": concept_id,
                         "property_": property_id,
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
@@ -265,14 +265,14 @@ class InferenceImporter(BaseRDFImporter):
 
         return {
             "metadata": self._default_metadata(),
-            "classes": list(classes.values()),
+            "concepts": list(concepts.values()),
             "properties": list(properties.values()),
             "prefixes": prefixes,
         }
 
     def _default_metadata(self) -> dict[str, Any]:
         now = datetime.now(timezone.utc)
-        return InformationMetadata(
+        return ConceptualMetadata(
             space=self.data_model_id.space,
             external_id=self.data_model_id.external_id,
             version=cast(str, self.data_model_id.version),
@@ -357,7 +357,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
         self,
         issue_list: IssueList,
         graph: Graph,
-        rules: InformationRules | None = None,
+        rules: ConceptualDataModel | None = None,
         data_model_id: dm.DataModelId | tuple[str, str, str] | None = None,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> None:
@@ -372,7 +372,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
         super().__init__(issue_list, graph, identifier, -1, non_existing_node_type, language="en")
         self._rules = rules
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
         if self._rules:
@@ -392,20 +392,20 @@ class SubclassInferenceImporter(BaseRDFImporter):
             default_space = metadata["space"]
         return {
             "metadata": metadata,
-            "classes": [cls.dump(default_space) for cls in classes],
+            "concepts": [cls.dump(default_space) for cls in classes],
             "properties": [prop.dump(default_space) for prop in properties],
             "prefixes": prefixes,
         }
 
     def _create_classes_properties(
         self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
-    ) -> tuple[list[InformationInputClass], list[InformationInputProperty]]:
+    ) -> tuple[list[UnverifiedConcept], list[UnverifiedConceptualProperty]]:
         if self._rules:
-            existing_classes = {class_.class_.suffix: class_ for class_ in self._rules.classes}
+            existing_classes = {class_.concept.suffix: class_ for class_ in self._rules.concepts}
         else:
             existing_classes = {}
-        classes: list[InformationInputClass] = []
-        properties_by_class_suffix_by_property_id: dict[str, dict[str, InformationInputProperty]] = {}
+        classes: list[UnverifiedConcept] = []
+        properties_by_class_suffix_by_property_id: dict[str, dict[str, UnverifiedConceptualProperty]] = {}
 
         # Help for IDE
         type_uri: URIRef
@@ -429,9 +429,9 @@ class SubclassInferenceImporter(BaseRDFImporter):
                 parent_suffix = remove_namespace_from_uri(parent_uri)
                 self._add_uri_namespace_to_prefixes(parent_uri, prefixes)
                 if parent_suffix not in existing_classes:
-                    classes.append(InformationInputClass(class_=parent_suffix))
+                    classes.append(UnverifiedConcept(concept=parent_suffix))
                 else:
-                    classes.append(InformationInputClass.load(existing_classes[parent_suffix].model_dump()))
+                    classes.append(UnverifiedConcept.load(existing_classes[parent_suffix].model_dump()))
             else:
                 shared_property_uris = set()
             shared_properties: dict[URIRef, list[_ReadProperties]] = defaultdict(list)
@@ -441,16 +441,16 @@ class SubclassInferenceImporter(BaseRDFImporter):
 
                 if class_suffix not in existing_classes:
                     classes.append(
-                        InformationInputClass(
-                            class_=class_suffix,
+                        UnverifiedConcept(
+                            concept=class_suffix,
                             implements=parent_suffix,
                             instance_source=type_uri,
                         )
                     )
                 else:
-                    classes.append(InformationInputClass.load(existing_classes[class_suffix].model_dump()))
+                    classes.append(UnverifiedConcept.load(existing_classes[class_suffix].model_dump()))
 
-                properties_by_id: dict[str, InformationInputProperty] = {}
+                properties_by_id: dict[str, UnverifiedConceptualProperty] = {}
                 for property_uri, read_properties in properties_by_property_uri.items():
                     if property_uri in shared_property_uris:
                         shared_properties[property_uri].extend(read_properties)
@@ -510,20 +510,20 @@ class SubclassInferenceImporter(BaseRDFImporter):
             type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
             count_by_type[type_uri] = instance_count_literal.toPython()
         if self._rules:
-            analysis = RulesAnalysis(self._rules)
+            analysis = DataModelAnalysis(self._rules)
             existing_class_properties = {
                 (class_entity.suffix, prop.property_): prop
-                for class_entity, properties in analysis.properties_by_class(
+                for class_entity, properties in analysis.properties_by_concepts(
                     include_ancestors=True, include_different_space=True
                 ).items()
                 for prop in properties
             }
-            existing_classes = {cls_.class_.suffix: cls_ for cls_ in self._rules.classes}
+            existing_classes = {cls_.concept.suffix: cls_ for cls_ in self._rules.concepts}
         else:
             existing_class_properties = {}
             existing_classes = {}
         properties_by_class_by_subclass: list[_ReadProperties] = []
-        existing_class: InformationClass | None
+        existing_class: Concept | None
         total_instance_count = sum(count_by_type.values())
         iterable = count_by_type.items()
         if GLOBAL_CONFIG.use_iterate_bar_threshold and total_instance_count > GLOBAL_CONFIG.use_iterate_bar_threshold:
@@ -577,11 +577,11 @@ class SubclassInferenceImporter(BaseRDFImporter):
         property_uri: URIRef,
         property_id: str,
         prefixes: dict[str, Namespace],
-    ) -> InformationInputProperty:
+    ) -> UnverifiedConceptualProperty:
         first = read_properties[0]
         value_type = self._get_value_type(read_properties, prefixes)
-        return InformationInputProperty(
-            class_=class_suffix,
+        return UnverifiedConceptualProperty(
+            concept=class_suffix,
             property_=property_id,
             max_count=first.max_occurrence,
             value_type=value_type,
@@ -606,7 +606,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
 
     def _default_metadata(self) -> dict[str, Any]:
         now = datetime.now(timezone.utc)
-        return InformationMetadata(
+        return ConceptualMetadata(
             space=self.data_model_id.space,
             external_id=self.data_model_id.external_id,
             version=cast(str, self.data_model_id.version),

cognite/neat/core/{_rules → _data_model}/importers/_rdf/_owl2rules.py

@@ -1,22 +1,22 @@
 """This module performs importing of various formats to one of serializations for which
 there are loaders to TransformationRules pydantic class."""
 
-from cognite.neat.core._rules.importers._rdf._base import BaseRDFImporter
-from cognite.neat.core._rules.importers._rdf._shared import (
-    parse_classes,
+from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
+from cognite.neat.core._data_model.importers._rdf._shared import (
+    parse_concepts,
     parse_properties,
 )
 
-CLASSES_QUERY = """SELECT ?class_ ?name ?description ?implements
+CLASSES_QUERY = """SELECT ?concept  ?name ?description ?implements
         WHERE {{
 
-        ?class_ a owl:Class .
-        OPTIONAL {{?class_ rdfs:subClassOf ?implements }}.
-        OPTIONAL {{?class_ rdfs:label|skos:prefLabel ?name }}.
-        OPTIONAL {{?class_ rdfs:comment|skos:definition ?description}} .
+        ?concept  a owl:Class .
+        OPTIONAL {{?concept  rdfs:subClassOf ?implements }}.
+        OPTIONAL {{?concept  rdfs:label|skos:prefLabel ?name }}.
+        OPTIONAL {{?concept  rdfs:comment|skos:definition ?description}} .
 
 
-        FILTER (!isBlank(?class_))
+        FILTER (!isBlank(?concept ))
         FILTER (!bound(?implements) || !isBlank(?implements))
 
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
@@ -27,11 +27,11 @@ CLASSES_QUERY = """SELECT ?class_ ?name ?description ?implements
 
 PROPERTIES_QUERY = """
 
-    SELECT ?class_ ?property_ ?name ?description ?value_type ?minCount ?maxCount ?default
+    SELECT ?concept  ?property_ ?name ?description ?value_type ?minCount ?maxCount ?default
     WHERE {{
         ?property_ a ?property_Type.
         FILTER (?property_Type IN (owl:ObjectProperty, owl:DatatypeProperty ) )
-        OPTIONAL {{?property_ rdfs:domain ?class_ }}.
+        OPTIONAL {{?property_ rdfs:domain ?concept  }}.
         OPTIONAL {{?property_ rdfs:range ?value_type }}.
         OPTIONAL {{?property_ rdfs:label|skos:prefLabel ?name }}.
         OPTIONAL {{?property_ rdfs:comment|skos:definition ?description}}.
@@ -64,10 +64,10 @@ class OWLImporter(BaseRDFImporter):
 
     """
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
-        classes, issue_list = parse_classes(self.graph, CLASSES_QUERY, self.language, self.issue_list)
+        concepts, issue_list = parse_concepts(self.graph, CLASSES_QUERY, self.language, self.issue_list)
         self.issue_list = issue_list
 
         # NeatError
@@ -76,7 +76,7 @@ class OWLImporter(BaseRDFImporter):
 
         components = {
             "Metadata": self._metadata,
-            "Classes": list(classes.values()) if classes else [],
+            "Concepts": list(concepts.values()) if concepts else [],
             "Properties": list(properties.values()) if properties else [],
         }
 

cognite/neat/core/{_rules → _data_model}/importers/_rdf/_shared.py

@@ -13,18 +13,18 @@ from cognite.neat.core._issues.warnings._resources import (
 from cognite.neat.core._utils.rdf_ import convert_rdflib_content
 
 
-def parse_classes(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
-    """Parse classes from graph
+def parse_concepts(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
+    """Parse concepts from graph
 
     Args:
-        graph: Graph containing classes definitions
+        graph: Graph containing concept definitions
         language: Language to use for parsing, by default "en"
 
     Returns:
         Dataframe containing owl classes
     """
 
-    classes: dict[str, dict] = {}
+    concepts: dict[str, dict] = {}
 
     query = prepareQuery(query.format(language=language), initNs={k: v for k, v in graph.namespaces()})
     expected_keys = [str(v) for v in query.algebra._vars]
@@ -33,42 +33,42 @@ def parse_classes(graph: Graph, query: str, language: str, issue_list: IssueList
         res: dict = convert_rdflib_content(cast(ResultRow, raw).asdict(), True)
         res = {key: res.get(key, None) for key in expected_keys}
 
-        class_id = res["class_"]
+        concept_id = res["concept"]
 
         # Safeguarding against incomplete semantic definitions
         if res["implements"] and isinstance(res["implements"], BNode):
             issue_list.append(
                 ResourceRetrievalWarning(
-                    class_id,
+                    concept_id,
                     "implements",
-                    error=("Unable to determine class that is being implemented"),
+                    error=("Unable to determine concept that is being implemented"),
                 )
             )
             continue
 
-        if class_id not in classes:
-            classes[class_id] = res
+        if concept_id not in concepts:
+            concepts[concept_id] = res
         else:
             # Handling implements
-            if classes[class_id]["implements"] and isinstance(classes[class_id]["implements"], list):
-                if res["implements"] not in classes[class_id]["implements"]:
-                    classes[class_id]["implements"].append(res["implements"])
+            if concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], list):
+                if res["implements"] not in concepts[concept_id]["implements"]:
+                    concepts[concept_id]["implements"].append(res["implements"])
 
-            elif classes[class_id]["implements"] and isinstance(classes[class_id]["implements"], str):
-                classes[class_id]["implements"] = [classes[class_id]["implements"]]
+            elif concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], str):
+                concepts[concept_id]["implements"] = [concepts[concept_id]["implements"]]
 
-                if res["implements"] not in classes[class_id]["implements"]:
-                    classes[class_id]["implements"].append(res["implements"])
+                if res["implements"] not in concepts[concept_id]["implements"]:
+                    concepts[concept_id]["implements"].append(res["implements"])
             elif res["implements"]:
-                classes[class_id]["implements"] = [res["implements"]]
+                concepts[concept_id]["implements"] = [res["implements"]]
 
-            handle_meta("class_", classes, class_id, res, "name", issue_list)
-            handle_meta("class_", classes, class_id, res, "description", issue_list)
+            handle_meta("concept", concepts, concept_id, res, "name", issue_list)
+            handle_meta("concept", concepts, concept_id, res, "description", issue_list)
 
-    if not classes:
-        issue_list.append(NeatValueError("Unable to parse classes"))
+    if not concepts:
+        issue_list.append(NeatValueError("Unable to parse concepts"))
 
-    return classes, issue_list
+    return concepts, issue_list
 
 
 def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
@@ -94,12 +94,12 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
         property_id = res["property_"]
 
         # Safeguarding against incomplete semantic definitions
-        if not res["class_"] or isinstance(res["class_"], BNode):
+        if not res["concept"] or isinstance(res["concept"], BNode):
             issue_list.append(
                 ResourceRetrievalWarning(
                     property_id,
                     "property",
-                    error=("Unable to determine to what class property is being defined"),
+                    error=("Unable to determine to what concept property is being defined"),
                 )
             )
             continue
@@ -115,7 +115,7 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
             )
             continue
 
-        id_ = f"{res['class_']}.{res['property_']}"
+        id_ = f"{res['concept']}.{res['property_']}"
 
         if id_ not in properties:
             properties[id_] = res