cognite-neat 0.121.2__tar.gz → 0.122.0__tar.gz

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.121.2
+Version: 0.122.0
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/
@@ -67,9 +67,9 @@ Description-Content-Type: text/markdown
 
 NEAT is a domain expert centric and developer friendly solution for rapid:
 
-- semantic data modeling
-- creation, transformation and enrichment of knowledge graphs
-- and ingestion of the models and graphs into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)
+- data modeling
+- extraction, transformation and loading of instances
+- and ingestion of the models and instances (i.e. knowledge graphs) into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)
 
 NEAT is using open and globally recognized standards maintained by the [World Wide Web Consortium (W3C)](https://www.w3.org/RDF/).
 NEAT represents an essential tool for creation of standardized, machine-actionable, linked and semantic (meta)data.
@@ -85,13 +85,12 @@ By mid of 2022, sheet2rdf was used in several POCs in Cognite. As Cognite's Data
 
 Presented in various forums in 2022, this approach paved the way for NEAT’s formal development in November 2022 to enable cost-saving and empowerment of Cognite customers to self-sufficiently maintain and onboard knowledge graphs to Cognite Data Fusion.
 
-
 ## Authorship
 
 ### Authors
 The plot below shows the NEAT authorship from the start until present day.
 
-![NEAT authorship](./docs/artifacts/figs/authorship.png)
+![NEAT authorship](./artifacts/figs/authorship.png)
 
 #### Current authors
 - [Nikola Vasiljević](www.linkedin.com/in/thisisnikola)
@@ -108,9 +107,17 @@ We are very grateful for the contributions made by:
 
 - [Marie Solvik Lepoutre](https://www.linkedin.com/in/mslepoutre/), who improved RDF triples projections to Cognite Data Fusion
 - [Bård Henning Tvedt](https://www.linkedin.com/in/bhtvedt/), who implemented IMF importer
+- [Hassan Gomaa](https://www.linkedin.com/in/dr-hassan-gomaa-232638121/), who extended the DEXPI extractor
 - [Kristina Tomičić](https://www.linkedin.com/in/kristina-tomicic-6bb443108/), who implemented Data Model and Instances visualization
 
 
+## Sponsors
+NEAT is developed and maintained by Cognite. We are grateful for the past support of our sponsors, who funded us to develop NEAT and to make it open source.
+
+- [Statnett](https://www.statnett.no/) - the MIMIR team ([Ola Hagen Øyan](https://www.linkedin.com/in/ola-%C3%B8yan-b0205b19/), [Olav Westeng Alstad](https://www.linkedin.com/in/olav-w-alstad-52329191/),[Andreas Kimsås](https://www.linkedin.com/in/andreas-kims%C3%A5s-964a0b2/) and [Anders Willersrud](https://www.linkedin.com/in/anders-willersrud-13a20220/)) – who supported the development of NEAT from end of 2022 to mid of 2023 and its integration with Statnett's infrastructure, where NEAT was battle-tested as a tool for non-sematic experts to define data models and transform large knowledge graphs representing the entire Norwegian power grid system. Without Statnett's support NEAT would not exist in the first place, and would not be open-source.
+- [Aker Solutions](https://www.akersolutions.com/) – the IMod Team (currently lead by [Maria Kenderkova](https://www.linkedin.com/in/maria-kenderkova/)), who funded development of NEAT from mid of 2023 till end of 2024 (multi-level and role-based data modeling, support for ontologies, IMF, DEXPI, AML,...) , as well who were early adopters and embraced NEAT and who were patient with us when things did not work so well. Aker Solutions was instrumental to elevating NEAT to a product level, and who selflessly advocate for NEAT globally.
+
+
 ## Installation
 
 ```bash
@@ -134,4 +141,4 @@ neat.read.cdf.data_model(("my_space", "MyDataModel", "v1"))
 
 ## Documentation
 
-For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)
+For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/README.md

@@ -13,9 +13,9 @@
 
 NEAT is a domain expert centric and developer friendly solution for rapid:
 
-- semantic data modeling
-- creation, transformation and enrichment of knowledge graphs
-- and ingestion of the models and graphs into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)
+- data modeling
+- extraction, transformation and loading of instances
+- and ingestion of the models and instances (i.e. knowledge graphs) into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)
 
 NEAT is using open and globally recognized standards maintained by the [World Wide Web Consortium (W3C)](https://www.w3.org/RDF/).
 NEAT represents an essential tool for creation of standardized, machine-actionable, linked and semantic (meta)data.
@@ -31,13 +31,12 @@ By mid of 2022, sheet2rdf was used in several POCs in Cognite. As Cognite's Data
 
 Presented in various forums in 2022, this approach paved the way for NEAT’s formal development in November 2022 to enable cost-saving and empowerment of Cognite customers to self-sufficiently maintain and onboard knowledge graphs to Cognite Data Fusion.
 
-
 ## Authorship
 
 ### Authors
 The plot below shows the NEAT authorship from the start until present day.
 
-![NEAT authorship](./docs/artifacts/figs/authorship.png)
+![NEAT authorship](./artifacts/figs/authorship.png)
 
 #### Current authors
 - [Nikola Vasiljević](www.linkedin.com/in/thisisnikola)
@@ -54,9 +53,17 @@ We are very grateful for the contributions made by:
 
 - [Marie Solvik Lepoutre](https://www.linkedin.com/in/mslepoutre/), who improved RDF triples projections to Cognite Data Fusion
 - [Bård Henning Tvedt](https://www.linkedin.com/in/bhtvedt/), who implemented IMF importer
+- [Hassan Gomaa](https://www.linkedin.com/in/dr-hassan-gomaa-232638121/), who extended the DEXPI extractor
 - [Kristina Tomičić](https://www.linkedin.com/in/kristina-tomicic-6bb443108/), who implemented Data Model and Instances visualization
 
 
+## Sponsors
+NEAT is developed and maintained by Cognite. We are grateful for the past support of our sponsors, who funded us to develop NEAT and to make it open source.
+
+- [Statnett](https://www.statnett.no/) - the MIMIR team ([Ola Hagen Øyan](https://www.linkedin.com/in/ola-%C3%B8yan-b0205b19/), [Olav Westeng Alstad](https://www.linkedin.com/in/olav-w-alstad-52329191/),[Andreas Kimsås](https://www.linkedin.com/in/andreas-kims%C3%A5s-964a0b2/) and [Anders Willersrud](https://www.linkedin.com/in/anders-willersrud-13a20220/)) – who supported the development of NEAT from end of 2022 to mid of 2023 and its integration with Statnett's infrastructure, where NEAT was battle-tested as a tool for non-sematic experts to define data models and transform large knowledge graphs representing the entire Norwegian power grid system. Without Statnett's support NEAT would not exist in the first place, and would not be open-source.
+- [Aker Solutions](https://www.akersolutions.com/) – the IMod Team (currently lead by [Maria Kenderkova](https://www.linkedin.com/in/maria-kenderkova/)), who funded development of NEAT from mid of 2023 till end of 2024 (multi-level and role-based data modeling, support for ontologies, IMF, DEXPI, AML,...) , as well who were early adopters and embraced NEAT and who were patient with us when things did not work so well. Aker Solutions was instrumental to elevating NEAT to a product level, and who selflessly advocate for NEAT globally.
+
+
 ## Installation
 
 ```bash
@@ -80,4 +87,4 @@ neat.read.cdf.data_model(("my_space", "MyDataModel", "v1"))
 
 ## Documentation
 
-For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)
+For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)

cognite_neat-0.122.0/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.122.0"
+__engine__ = "^2.0.4"

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_constants.py

@@ -104,7 +104,7 @@ COGNITE_CONCEPTS = (
 
 DMS_LISTABLE_PROPERTY_LIMIT = 1000
 
-EXAMPLE_RULES = PACKAGE_DIRECTORY / "core" / "_data_model" / "examples"
+EXAMPLE_DATA_MODELS = PACKAGE_DIRECTORY / "core" / "_data_model" / "examples"
 EXAMPLE_GRAPHS = PACKAGE_DIRECTORY / "core" / "_instances" / "examples"
 
 DEFAULT_SPACE_URI = "http://purl.org/cognite/space/{space}#"

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/catalog/__init__.py

@@ -1,4 +1,4 @@
-"""Shortcut to rules catalog files"""
+"""Shortcut to data model catalog"""
 
 from pathlib import Path
 

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/exporters/__init__.py

@@ -34,6 +34,6 @@ def _repr_html_() -> str:
     )._repr_html_()
 
     return (
-        "<strong>Exporter</strong> An exporter converts Neat's representation of a data model called <em>Rules</em>"
+        "<strong>Exporter</strong> An exporter converts Neat's representation of a data model"
         f" into a schema/data model for a target format.<br />{table}"
     )

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/exporters/_data_model2instance_template.py

@@ -20,8 +20,8 @@ from ._base import BaseExporter
 
 class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
     """
-    Converts Information Rules to a templated spreadsheet meant for capturing
-    instances based on class definitions in the rules.
+    Converts conceptual data model to a templated spreadsheet meant for capturing
+    instances based on concept definitions in the data model.
 
     Args:
         no_rows: number of rows for processing, by default 1000
@@ -50,30 +50,30 @@ class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
 
     def export(
         self,
-        rules: ConceptualDataModel,
+        data_model: ConceptualDataModel,
     ) -> Workbook:
         workbook = Workbook()
 
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        for class_, properties in DataModelAnalysis(rules).properties_by_id_by_concept().items():
-            workbook.create_sheet(title=class_.suffix)
+        for concept, properties in DataModelAnalysis(data_model).properties_by_id_by_concept().items():
+            workbook.create_sheet(title=concept.suffix)
 
             # Add header rows
-            workbook[class_.suffix].append(["identifier", *list(properties.keys())])
+            workbook[concept.suffix].append(["identifier", *list(properties.keys())])
 
             if self.auto_identifier_type == "uuid":
-                _add_uuid_identifiers(workbook, class_.suffix, self.no_rows)
+                _add_uuid_identifiers(workbook, concept.suffix, self.no_rows)
             else:
                 # Default to index-based identifier
-                _add_index_identifiers(workbook, class_.suffix, self.no_rows)
+                _add_index_identifiers(workbook, concept.suffix, self.no_rows)
 
             for i, property_ in enumerate(properties.values()):
                 if property_.type_ == EntityTypes.object_property and self.add_drop_down_list:
                     _add_drop_down_list(
                         workbook,
-                        class_.suffix,
+                        concept.suffix,
                         get_column_letter(i + 2),
                         self.no_rows,
                         cast(ConceptEntity, property_.value_type).suffix,
@@ -85,9 +85,9 @@ class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
 
         return workbook
 
-    def export_to_file(self, rules: ConceptualDataModel, filepath: Path) -> None:
+    def export_to_file(self, data_model: ConceptualDataModel, filepath: Path) -> None:
         """Exports graph capturing sheet to excel file."""
-        data = self.export(rules)
+        data = self.export(data_model)
         try:
             data.save(filepath)
         finally:

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/importers/__init__.py

@@ -17,7 +17,7 @@ __all__ = [
     "SubclassInferenceImporter",
 ]
 
-RulesImporters = (
+DataModelImporters = (
     OWLImporter
     | IMFImporter
     | DMSImporter
@@ -47,5 +47,5 @@ def _repr_html_() -> str:
 
     return (
         "<strong>Importer</strong> An importer reads data/schema/data model from a source"
-        f" and converts it into Neat's representation of a data model called <em>Rules</em>.<br />{table}"
+        f" and converts it into Neat's representation of a data model.<br />{table}"
     )

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/importers/_dict2data_model.py

@@ -7,7 +7,10 @@ from cognite.neat.core._data_model._shared import (
     ImportedDataModel,
     T_UnverifiedDataModel,
 )
-from cognite.neat.core._data_model.models import INPUT_RULES_BY_ROLE, RoleTypes
+from cognite.neat.core._data_model.models import (
+    UNVERIFIED_DATA_MODEL_BY_ROLE,
+    RoleTypes,
+)
 from cognite.neat.core._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat.core._issues.errors import (
     FileMissingRequiredFieldError,
@@ -44,16 +47,18 @@ class YAMLReader:
 
 
 class DictImporter(BaseImporter[T_UnverifiedDataModel]):
-    """Imports the rules from a YAML file.
+    """Imports the data model from a YAML file.
 
     Args:
         raw_data: The raw data to be imported.
 
     .. note::
 
-        YAML files are typically used for storing rules when checked into version control systems, e.g., git-history.
-        The advantage of using YAML files over Excel is that tools like git can show the differences between different
-        versions of the rules.
+        YAML files are typically used for storing data model when checked into version
+        control systems, e.g., git-history.
+        The advantage of using YAML files over Excel is that tools like git can
+        show the differences between different
+        versions of the data model.
 
     """
 
@@ -115,7 +120,7 @@ class DictImporter(BaseImporter[T_UnverifiedDataModel]):
 
         role_input = RoleTypes(metadata["role"])
         role_enum = RoleTypes(role_input)
-        data_model_cls = INPUT_RULES_BY_ROLE[role_enum]
+        data_model_cls = UNVERIFIED_DATA_MODEL_BY_ROLE[role_enum]
 
         data_model = cast(T_UnverifiedDataModel, data_model_cls.load(self.raw_data))
 

cognite_neat-0.122.0/cognite/neat/core/_data_model/importers/_rdf/__init__.py

@@ -0,0 +1,5 @@
+from ._imf2data_model import IMFImporter
+from ._inference2rdata_model import InferenceImporter, SubclassInferenceImporter
+from ._owl2data_model import OWLImporter
+
+__all__ = ["IMFImporter", "InferenceImporter", "OWLImporter", "SubclassInferenceImporter"]

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/importers/_rdf/_base.py

@@ -28,13 +28,13 @@ DEFAULT_RDF_DATA_MODEL_ID = ("neat_space", "RDFDataModel", "rdf")
 
 
 class BaseRDFImporter(BaseImporter[UnverifiedConceptualDataModel]):
-    """Baser RDF importers used for all rules importers that are using RDF as input.
+    """Baser RDF importers used for all data model importers that are using RDF as input.
 
     Args:
         issue_list: Issue list to store issues
-        graph: Knowledge graph
-        data_model_id: Data model id to be used for the imported rules
-        space: CDF Space to be used for the imported rules
+        graph: graph where instances are stored
+        data_model_id: Data model id to be used for the imported data model
+        space: CDF Space to be used for the imported data model
         language: Language for description and human readable entity names
 
 
@@ -119,18 +119,18 @@ class BaseRDFImporter(BaseImporter[UnverifiedConceptualDataModel]):
         self,
     ) -> ImportedDataModel[UnverifiedConceptualDataModel]:
         """
-        Creates `Rules` object from the data for target role.
+        Creates `ImportedDataModel` object from the data for target role.
         """
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_data_model method will return None
             self.issue_list.trigger_warnings()
             raise MultiValueError(self.issue_list.errors)
 
-        rules_dict = self._to_data_model_components()
+        data_model_dict = self._to_data_model_components()
 
-        rules = UnverifiedConceptualDataModel.load(rules_dict)
+        data_model = UnverifiedConceptualDataModel.load(data_model_dict)
         self.issue_list.trigger_warnings()
-        return ImportedDataModel(rules, {})
+        return ImportedDataModel(data_model, {})
 
     def _to_data_model_components(self) -> dict:
         raise NotImplementedError()

cognite_neat-0.121.2/cognite/neat/core/_data_model/importers/_rdf/_imf2rules.py → cognite_neat-0.122.0/cognite/neat/core/_data_model/importers/_rdf/_imf2data_model.py

@@ -1,5 +1,5 @@
 """This module performs importing of various formats to one of serializations for which
-there are loaders to TransformationRules pydantic class."""
+there are loaders to data model pydantic class."""
 
 from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
 from cognite.neat.core._data_model.importers._rdf._shared import (
@@ -75,7 +75,7 @@ PROPERTIES_QUERY = """
 
 
 class IMFImporter(BaseRDFImporter):
-    """Convert IMF Types provided as SHACL shapes to Input Rules."""
+    """Convert IMF Types provided as SHACL shapes to unverified data model."""
 
     @property
     def description(self) -> str:

cognite_neat-0.121.2/cognite/neat/core/_data_model/importers/_rdf/_inference2rules.py → cognite_neat-0.122.0/cognite/neat/core/_data_model/importers/_rdf/_inference2rdata_model.py

@@ -56,10 +56,10 @@ INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occur
 
 
 class InferenceImporter(BaseRDFImporter):
-    """Infers rules from a triple store.
+    """Infers data model from instances stored as triples.
 
-    Rules inference through analysis of knowledge graph provided in various formats.
-    Use the factory methods to create a triple store from sources such as
+    Data model inference through analysis of knowledge graph provided in various formats.
+    Use the factory methods to create triples from sources such as
     RDF files, JSON files, YAML files, XML files, or directly from a graph store.
 
     ClassVars:
@@ -151,7 +151,7 @@ class InferenceImporter(BaseRDFImporter):
         """Convert RDF graph to dictionary defining data model and prefixes of the graph
 
         Args:
-            graph: RDF graph to be converted to TransformationRules object
+            graph: RDF graph to be converted to data model
             max_number_of_instance: Max number of instances to be considered for each class
 
         Returns:
@@ -218,7 +218,7 @@ class InferenceImporter(BaseRDFImporter):
                             resource_type="Property",
                             identifier=f"{concept_id}:{property_id}",
                             property_name=property_id,
-                            default_action="Remove the property from the rules",
+                            default_action="Remove the property from the data model",
                             recommended_action="Make sure that graph is complete",
                         )
 
@@ -300,11 +300,11 @@ class _ReadProperties:
 
 
 class SubclassInferenceImporter(BaseRDFImporter):
-    """Infer subclasses from a triple store.
+    """Infer subclasses from instances stored in a triple store.
 
-    Assumes that the graph already is connected to a schema. The classes should
-    match the RDF.type of the instances in the graph, while the subclasses should
-    match the NEAT.type of the instances in the graph.
+    Assumes that the instances already are connected to a schema. The classes should
+    match the RDF.type of the instances, while the subclasses should match the NEAT.type
+    of the instances.
 
     ClassVars:
         overwrite_data_types: Mapping of data types to be overwritten. The InferenceImporter will overwrite
@@ -357,26 +357,26 @@ class SubclassInferenceImporter(BaseRDFImporter):
         self,
         issue_list: IssueList,
         graph: Graph,
-        rules: ConceptualDataModel | None = None,
+        data_model: 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:
-        if sum([1 for v in [rules, data_model_id] if v is not None]) != 1:
-            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+        if sum([1 for v in [data_model, data_model_id] if v is not None]) != 1:
+            raise ValueError("Exactly one of data model or data_model_id must be provided.")
         if data_model_id is not None:
             identifier = data_model_id
-        elif rules is not None:
-            identifier = rules.metadata.as_data_model_id().as_tuple()  # type: ignore[assignment]
+        elif data_model is not None:
+            identifier = data_model.metadata.as_data_model_id().as_tuple()  # type: ignore[assignment]
         else:
-            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+            raise ValueError("Exactly one of data model or data_model_id must be provided.")
         super().__init__(issue_list, graph, identifier, -1, non_existing_node_type, language="en")
-        self._rules = rules
+        self._data_model = data_model
 
     def _to_data_model_components(
         self,
     ) -> dict:
-        if self._rules:
-            prefixes = self._rules.prefixes.copy()
+        if self._data_model:
+            prefixes = self._data_model.prefixes.copy()
         else:
             prefixes = get_default_prefixes_and_namespaces()
 
@@ -384,9 +384,9 @@ class SubclassInferenceImporter(BaseRDFImporter):
         read_properties = self._read_class_properties_from_graph(parent_by_child)
         classes, properties = self._create_classes_properties(read_properties, prefixes)
 
-        if self._rules:
-            metadata = self._rules.metadata.model_dump()
-            default_space = self._rules.metadata.prefix
+        if self._data_model:
+            metadata = self._data_model.metadata.model_dump()
+            default_space = self._data_model.metadata.prefix
         else:
             metadata = self._default_metadata()
             default_space = metadata["space"]
@@ -400,8 +400,8 @@ class SubclassInferenceImporter(BaseRDFImporter):
     def _create_classes_properties(
         self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
     ) -> tuple[list[UnverifiedConcept], list[UnverifiedConceptualProperty]]:
-        if self._rules:
-            existing_classes = {class_.concept.suffix: class_ for class_ in self._rules.concepts}
+        if self._data_model:
+            existing_classes = {class_.concept.suffix: class_ for class_ in self._data_model.concepts}
         else:
             existing_classes = {}
         classes: list[UnverifiedConcept] = []
@@ -509,8 +509,8 @@ class SubclassInferenceImporter(BaseRDFImporter):
         for result_row in self.graph.query(self._ordered_class_query):
             type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
             count_by_type[type_uri] = instance_count_literal.toPython()
-        if self._rules:
-            analysis = DataModelAnalysis(self._rules)
+        if self._data_model:
+            analysis = DataModelAnalysis(self._data_model)
             existing_class_properties = {
                 (class_entity.suffix, prop.property_): prop
                 for class_entity, properties in analysis.properties_by_concepts(
@@ -518,7 +518,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
                 ).items()
                 for prop in properties
             }
-            existing_classes = {cls_.concept.suffix: cls_ for cls_ in self._rules.concepts}
+            existing_classes = {cls_.concept.suffix: cls_ for cls_ in self._data_model.concepts}
         else:
             existing_class_properties = {}
             existing_classes = {}

cognite_neat-0.121.2/cognite/neat/core/_data_model/importers/_rdf/_owl2rules.py → cognite_neat-0.122.0/cognite/neat/core/_data_model/importers/_rdf/_owl2data_model.py

@@ -1,5 +1,5 @@
 """This module performs importing of various formats to one of serializations for which
-there are loaders to TransformationRules pydantic class."""
+there are loaders to data model pydantic class."""
 
 from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
 from cognite.neat.core._data_model.importers._rdf._shared import (
@@ -47,20 +47,20 @@ PROPERTIES_QUERY = """
 
 
 class OWLImporter(BaseRDFImporter):
-    """Convert OWL ontology to tables/ transformation rules / Excel file.
+    """Convert OWL ontology to unverified data model.
 
         Args:
             filepath: Path to OWL ontology
 
     !!! Note
         OWL Ontologies are information models which completeness varies. As such, constructing functional
-        data model directly will often be impossible, therefore the produced Rules object will be ill formed.
-        To avoid this, neat will automatically attempt to make the imported rules compliant by adding default
+        data model directly will often be impossible, therefore the produced data model object will be ill formed.
+        To avoid this, neat will automatically attempt to make the imported data model compliant by adding default
         values for missing information, attaching dangling properties to default containers based on the
         property type, etc.
 
         One has to be aware that NEAT will be opinionated about how to make the ontology
-        compliant, and that the resulting rules may not be what you expect.
+        compliant, and that the resulting data model may not be what you expect.
 
     """
 

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/importers/_spreadsheet2data_model.py

@@ -1,7 +1,4 @@
-"""This module performs importing of graph to TransformationRules pydantic class.
-In more details, it traverses the graph and abstracts class and properties, basically
-generating a list of data_model based on which nodes that form the graph are made.
-"""
+"""This module performs importing of data model from spreadsheets."""
 
 import tempfile
 from collections import UserDict, defaultdict
@@ -20,8 +17,8 @@ from cognite.neat.core._data_model._shared import (
     T_UnverifiedDataModel,
 )
 from cognite.neat.core._data_model.models import (
-    INPUT_RULES_BY_ROLE,
-    VERIFIED_RULES_BY_ROLE,
+    UNVERIFIED_DATA_MODEL_BY_ROLE,
+    VERIFIED_DATA_MODEL_BY_ROLE,
     RoleTypes,
     SchemaCompleteness,
 )
@@ -58,8 +55,8 @@ MANDATORY_SHEETS_BY_ROLE: dict[RoleTypes, set[str]] = {
     role_type: {
         str(sheet_name)
         for sheet_name in (
-            VERIFIED_RULES_BY_ROLE.get(role_type).mandatory_fields(use_alias=True)  # type: ignore
-            if VERIFIED_RULES_BY_ROLE.get(role_type)
+            VERIFIED_DATA_MODEL_BY_ROLE.get(role_type).mandatory_fields(use_alias=True)  # type: ignore
+            if VERIFIED_DATA_MODEL_BY_ROLE.get(role_type)
             else []
         )
         if sheet_name is not None
@@ -280,7 +277,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
         original_role = user_read.role
         read_info_by_sheet = user_read.read_info_by_sheet
 
-        data_model_cls = INPUT_RULES_BY_ROLE[original_role]
+        data_model_cls = UNVERIFIED_DATA_MODEL_BY_ROLE[original_role]
         data_model = cast(T_UnverifiedDataModel, data_model_cls.load(sheets))
 
         # Delete the temporary file if it was created

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/models/__init__.py

@@ -10,18 +10,20 @@ from ._base_verified import DataModelType, ExtensionCategory, RoleTypes, SchemaC
 from .physical._unverified import UnverifiedPhysicalDataModel
 from .physical._verified import PhysicalDataModel
 
-INPUT_RULES_BY_ROLE: dict[RoleTypes, type[UnverifiedConceptualDataModel] | type[UnverifiedPhysicalDataModel]] = {
+UNVERIFIED_DATA_MODEL_BY_ROLE: dict[
+    RoleTypes, type[UnverifiedConceptualDataModel] | type[UnverifiedPhysicalDataModel]
+] = {
     RoleTypes.information: UnverifiedConceptualDataModel,
     RoleTypes.dms: UnverifiedPhysicalDataModel,
 }
-VERIFIED_RULES_BY_ROLE: dict[RoleTypes, type[ConceptualDataModel] | type[PhysicalDataModel]] = {
+VERIFIED_DATA_MODEL_BY_ROLE: dict[RoleTypes, type[ConceptualDataModel] | type[PhysicalDataModel]] = {
     RoleTypes.information: ConceptualDataModel,
     RoleTypes.dms: PhysicalDataModel,
 }
 
 
 __all__ = [
-    "INPUT_RULES_BY_ROLE",
+    "UNVERIFIED_DATA_MODEL_BY_ROLE",
     "ConceptualDataModel",
     "DMSSchema",
     "DataModelType",

{cognite_neat-0.121.2 → cognite_neat-0.122.0}/cognite/neat/core/_data_model/models/_base_unverified.py

@@ -27,29 +27,29 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-T_BaseRules = TypeVar("T_BaseRules", bound=BaseVerifiedDataModel)
-T_RuleModel = TypeVar("T_RuleModel", bound=SchemaModel)
+T_BaseDataModel = TypeVar("T_BaseDataModel", bound=BaseVerifiedDataModel)
+T_DataModel = TypeVar("T_DataModel", bound=SchemaModel)
 
 
 @dataclass
-class UnverifiedDataModel(Generic[T_BaseRules], ABC):
-    """Input rules are raw data that is not yet validated."""
+class UnverifiedDataModel(Generic[T_BaseDataModel], ABC):
+    """Input data model are raw data that is not yet validated."""
 
     @classmethod
     @abstractmethod
-    def _get_verified_cls(cls) -> type[T_BaseRules]:
+    def _get_verified_cls(cls) -> type[T_BaseDataModel]:
         raise NotImplementedError("This method should be implemented in the subclass.")
 
     @classmethod
     @overload
-    def load(cls: "type[T_InputRules]", data: dict[str, Any]) -> "T_InputRules": ...
+    def load(cls: "type[T_UnverifiedDataModel]", data: dict[str, Any]) -> "T_UnverifiedDataModel": ...
 
     @classmethod
     @overload
-    def load(cls: "type[T_InputRules]", data: None) -> None: ...
+    def load(cls: "type[T_UnverifiedDataModel]", data: None) -> None: ...
 
     @classmethod
-    def load(cls: "type[T_InputRules]", data: dict | None) -> "T_InputRules | None":
+    def load(cls: "type[T_UnverifiedDataModel]", data: dict | None) -> "T_UnverifiedDataModel | None":
         if data is None:
             return None
         return cls._load(data)
@@ -110,7 +110,7 @@ class UnverifiedDataModel(Generic[T_BaseRules], ABC):
     def _dataclass_fields(self) -> list[Field]:
         return list(fields(self))
 
-    def as_verified_data_model(self) -> T_BaseRules:
+    def as_verified_data_model(self) -> T_BaseDataModel:
         cls_ = self._get_verified_cls()
         return cls_.model_validate(self.dump())
 
@@ -127,14 +127,14 @@ class UnverifiedDataModel(Generic[T_BaseRules], ABC):
         return output
 
 
-T_InputRules = TypeVar("T_InputRules", bound=UnverifiedDataModel)
+T_UnverifiedDataModel = TypeVar("T_UnverifiedDataModel", bound=UnverifiedDataModel)
 
 
 @dataclass
-class UnverifiedComponent(ABC, Generic[T_RuleModel]):
+class UnverifiedComponent(ABC, Generic[T_DataModel]):
     @classmethod
     @abstractmethod
-    def _get_verified_cls(cls) -> type[T_RuleModel]:
+    def _get_verified_cls(cls) -> type[T_DataModel]:
         raise NotImplementedError("This method should be implemented in the subclass.")
 
     @classmethod