cognite-neat 0.121.1__py3-none-any.whl → 0.122.0__py3-none-any.whl

cognite/neat/session/_state/README.md

@@ -1,7 +1,7 @@
 # NeatState
 
 **IN DEVELOPMENT**
-The neat state controls the `NeatGraphStore` and `NeatRuleStore`. It is implementing a state machine pattern
+The neat state controls the `NeatInstanceStore` and `NeatGraphStore`. It is implementing a state machine pattern
 to ensure valid state transitions. The diagram below shows the state machine:
 
 ```mermaid

cognite/neat/session/_state.py

@@ -5,13 +5,13 @@ from rdflib import URIRef
 
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._data_model.importers import BaseImporter, InferenceImporter
-from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
 from cognite.neat.core._data_model.transformers import (
-    VerifiedRulesTransformer,
+    VerifiedDataModelTransformer,
 )
 from cognite.neat.core._instances.extractors import KnowledgeGraphExtractor
 from cognite.neat.core._issues import IssueList
-from cognite.neat.core._store import NeatGraphStore, NeatRulesStore
+from cognite.neat.core._store import NeatDataModelStore, NeatInstanceStore
 from cognite.neat.core._utils.upload import UploadResultList
 
 from .exceptions import NeatSessionError, _session_method_wrapper
@@ -25,31 +25,31 @@ class SessionState:
         client: NeatClient | None = None,
     ) -> None:
         self.instances = InstancesState(store_type, storage_path=storage_path)
-        self.rule_store = NeatRulesStore()
-        self.last_reference: DMSRules | ConceptualDataModel | None = None
+        self.data_model_store = NeatDataModelStore()
+        self.last_reference: PhysicalDataModel | ConceptualDataModel | None = None
         self.client = client
         self.quoted_source_identifiers = False
 
-    def rule_transform(self, *transformer: VerifiedRulesTransformer) -> IssueList:
+    def rule_transform(self, *transformer: VerifiedDataModelTransformer) -> IssueList:
         if not transformer:
             raise NeatSessionError("No transformers provided.")
-        start = self.rule_store.provenance[-1].target_entity.display_name
-        issues = self.rule_store.transform(*transformer)
-        last_entity = self.rule_store.provenance[-1].target_entity
+        start = self.data_model_store.provenance[-1].target_entity.display_name
+        issues = self.data_model_store.transform(*transformer)
+        last_entity = self.data_model_store.provenance[-1].target_entity
         issues.action = f"{start} → {last_entity.display_name}"
         issues.hint = "Use the .inspect.issues() for more details."
         return issues
 
     def rule_import(self, importer: BaseImporter, enable_manual_edit: bool = False) -> IssueList:
-        issues = self.rule_store.import_rules(
+        issues = self.data_model_store.import_data_model(
             importer,
             client=self.client,
             enable_manual_edit=enable_manual_edit,
         )
-        if self.rule_store.empty:
+        if self.data_model_store.empty:
             result = "failed"
         else:
-            result = self.rule_store.provenance[-1].target_entity.display_name
+            result = self.data_model_store.provenance[-1].target_entity.display_name
         if isinstance(importer, InferenceImporter):
             issues.action = f"Inferred {result}"
         else:
@@ -60,19 +60,19 @@ class SessionState:
 
     def write_graph(self, extractor: KnowledgeGraphExtractor) -> IssueList:
         extract_issues = self.instances.store.write(extractor)
-        issues = self.rule_store.import_graph(extractor)
+        issues = self.data_model_store.import_graph(extractor)
         issues.extend(extract_issues)
         return issues
 
     def _raise_exception_if_condition_not_met(
         self,
         activity: str,
-        empty_rules_store_required: bool = False,
+        empty_data_model_store_required: bool = False,
         empty_instances_store_required: bool = False,
         instances_required: bool = False,
         client_required: bool = False,
-        has_information_rules: bool | None = None,
-        has_dms_rules: bool | None = None,
+        has_conceptual_data_model: bool | None = None,
+        has_physical_data_model: bool | None = None,
     ) -> None:
         """Set conditions for raising an error in the session that are used by various methods in the session."""
         condition = set()
@@ -81,14 +81,14 @@ class SessionState:
         if client_required and not self.client:
             condition.add(f"{activity} expects a client in NEAT session")
             suggestion.add("Please provide a client")
-        if has_information_rules is True and self.rule_store.try_get_last_information_rules is None:
-            condition.add(f"{activity} expects information rules in NEAT session")
-            suggestion.add("Read in information rules to neat session")
-        if has_dms_rules is False and self.rule_store.try_get_last_dms_rules is not None:
-            condition.add(f"{activity} expects no DMS data model in NEAT session")
-            suggestion.add("You already have a DMS data model in the session")
+        if has_conceptual_data_model is True and self.data_model_store.try_get_last_conceptual_data_model is None:
+            condition.add(f"{activity} expects conceptual data model in NEAT session")
+            suggestion.add("Read in conceptual data model to neat session")
+        if has_physical_data_model is False and self.data_model_store.try_get_last_physical_data_model is not None:
+            condition.add(f"{activity} expects no physical data model in NEAT session")
+            suggestion.add("You already have a physical data model in the session")
             try_again = False
-        if empty_rules_store_required and not self.rule_store.empty:
+        if empty_data_model_store_required and not self.data_model_store.empty:
             condition.add(f"{activity} expects no data model in NEAT session")
             suggestion.add("Start new session")
         if empty_instances_store_required and not self.instances.empty:
@@ -121,18 +121,18 @@ class InstancesState:
         self.neat_prefix_by_type_uri: dict[URIRef, str] = {}
 
         # Ensure that error handling is done in the constructor
-        self.store: NeatGraphStore = _session_method_wrapper(self._create_store, "NeatSession")()
+        self.store: NeatInstanceStore = _session_method_wrapper(self._create_store, "NeatSession")()
 
         if self.storage_path:
             print("Remember to close neat session .close() once you are done to avoid oxigraph lock.")
 
-    def _create_store(self) -> NeatGraphStore:
+    def _create_store(self) -> NeatInstanceStore:
         if self.store_type == "oxigraph":
             if self.storage_path:
                 self.storage_path.mkdir(parents=True, exist_ok=True)
-            return NeatGraphStore.from_oxi_local_store(storage_dir=self.storage_path)
+            return NeatInstanceStore.from_oxi_local_store(storage_dir=self.storage_path)
         else:
-            return NeatGraphStore.from_memory_store()
+            return NeatInstanceStore.from_memory_store()
 
     @property
     def empty(self) -> bool:

cognite/neat/session/_subset.py

@@ -1,10 +1,13 @@
 import warnings
 
 from cognite.neat.core._data_model.models.entities._single_value import (
-    ClassEntity,
+    ConceptEntity,
     ViewEntity,
 )
-from cognite.neat.core._data_model.transformers import SubsetDMSRules, SubsetInformationRules
+from cognite.neat.core._data_model.transformers import (
+    SubsetConceptualDataModel,
+    SubsetPhysicalDataModel,
+)
 from cognite.neat.core._issues._base import IssueList
 from cognite.neat.session._experimental import ExperimentalFlags
 
@@ -46,14 +49,14 @@ class SubsetAPI:
             neat.subset.data_model("CogniteAsset")
             ```
         """
-        if self._state.rule_store.empty:
-            raise NeatSessionError("No rules to set the data model ID.")
+        if self._state.data_model_store.empty:
+            raise NeatSessionError("No data model to set the data model ID.")
 
         warnings.filterwarnings("default")
         ExperimentalFlags.data_model_subsetting.warn()
 
-        dms = self._state.rule_store.provenance[-1].target_entity.dms
-        information = self._state.rule_store.provenance[-1].target_entity.information
+        dms = self._state.data_model_store.provenance[-1].target_entity.physical
+        information = self._state.data_model_store.provenance[-1].target_entity.conceptual
 
         if dms:
             views = {
@@ -65,16 +68,16 @@ class SubsetAPI:
                 for concept in concepts
             }
 
-            issues = self._state.rule_transform(SubsetDMSRules(views=views))
+            issues = self._state.rule_transform(SubsetPhysicalDataModel(views=views))
             if not issues:
-                after = len(self._state.rule_store.last_verified_dms_rules.views)
+                after = len(self._state.data_model_store.last_verified_physical_data_model.views)
 
         elif information:
-            classes = {ClassEntity(prefix=information.metadata.space, suffix=concept) for concept in concepts}
+            classes = {ConceptEntity(prefix=information.metadata.space, suffix=concept) for concept in concepts}
 
-            issues = self._state.rule_transform(SubsetInformationRules(classes=classes))
+            issues = self._state.rule_transform(SubsetConceptualDataModel(concepts=classes))
             if not issues:
-                after = len(self._state.rule_store.last_verified_information_rules.classes)
+                after = len(self._state.data_model_store.last_verified_conceptual_data_model.concepts)
 
         else:
             raise NeatSessionError("Something went terrible wrong. Please contact the neat team.")

cognite/neat/session/_template.py

@@ -4,18 +4,18 @@ from typing import Any, Literal
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
 from cognite.neat.core._constants import BASE_MODEL
-from cognite.neat.core._data_model._shared import ReadRules
+from cognite.neat.core._data_model._shared import ImportedDataModel
 from cognite.neat.core._data_model.exporters import ExcelExporter
 from cognite.neat.core._data_model.importers import ExcelImporter
 from cognite.neat.core._data_model.models import UnverifiedConceptualDataModel
 from cognite.neat.core._data_model.models._base_verified import RoleTypes
-from cognite.neat.core._data_model.models.dms import DMSValidation
+from cognite.neat.core._data_model.models.physical import PhysicalValidation
 from cognite.neat.core._data_model.transformers import (
     AddCogniteProperties,
     IncludeReferenced,
     ToDataProductModel,
     ToEnterpriseModel,
-    VerifiedRulesTransformer,
+    VerifiedDataModelTransformer,
 )
 from cognite.neat.core._issues import IssueList, catch_issues
 from cognite.neat.core._utils.reader import NeatReader, PathReader
@@ -69,7 +69,7 @@ class TemplateAPI:
                 - Charts
 
         """
-        last_rules = self._state.rule_store.last_verified_rules
+        last_dm = self._state.data_model_store.last_verified_data_model
         issues = self._state.rule_transform(
             ToEnterpriseModel(
                 new_model_id=data_model_id,
@@ -78,8 +78,8 @@ class TemplateAPI:
                 move_connections=True,
             )
         )
-        if last_rules and not issues.has_errors:
-            self._state.last_reference = last_rules
+        if last_dm and not issues.has_errors:
+            self._state.last_reference = last_dm
         return issues
 
     def data_product_model(
@@ -105,11 +105,11 @@ class TemplateAPI:
                 If you set same-space, only the properties of the views in the same space as the data model
                 will be included.
         """
-        last_rules = self._state.rule_store.last_verified_rules
-        view_ids, container_ids = DMSValidation(
-            self._state.rule_store.last_verified_dms_rules
+        last_dm = self._state.data_model_store.last_verified_data_model
+        view_ids, container_ids = PhysicalValidation(
+            self._state.data_model_store.last_verified_physical_data_model
         ).imported_views_and_containers_ids()
-        transformers: list[VerifiedRulesTransformer] = []
+        transformers: list[VerifiedDataModelTransformer] = []
         client = self._state.client
         if (view_ids or container_ids) and client is None:
             raise NeatSessionError(
@@ -123,8 +123,8 @@ class TemplateAPI:
         transformers.append(ToDataProductModel(new_model_id=data_model_id, include=include))
 
         issues = self._state.rule_transform(*transformers)
-        if last_rules and not issues.has_errors:
-            self._state.last_reference = last_rules
+        if last_dm and not issues.has_errors:
+            self._state.last_reference = last_dm
         return issues
 
     def conceptual_model(
@@ -185,22 +185,24 @@ class TemplateAPI:
             output_path = Path(output)
 
         with catch_issues() as issues:
-            read: ReadRules[UnverifiedConceptualDataModel] = ExcelImporter(path).to_rules()
-            if read.rules is not None:
-                # If rules are None there will be issues that are already caught.
-                if not isinstance(read.rules, UnverifiedConceptualDataModel):
-                    raise NeatSessionError(f"The input {reader.name} must contain an InformationInputRules object. ")
+            read: ImportedDataModel[UnverifiedConceptualDataModel] = ExcelImporter(path).to_data_model()
+            if read.unverified_data_model is not None:
+                # If data model arise None there will be issues that are already caught.
+                if not isinstance(read.unverified_data_model, UnverifiedConceptualDataModel):
+                    raise NeatSessionError(
+                        f"The input {reader.name} must contain an UnverifiedConceptualDataModel object. "
+                    )
                 if self._state.client is None:
                     raise NeatSessionError("Client must be set in the session to run the extension.")
                 modified = AddCogniteProperties(self._state.client, dummy_property).transform(read)
-                if modified.rules is not None:
-                    # If rules are None there will be issues that are already caught.
-                    info = modified.rules.as_verified_rules()
+                if modified.unverified_data_model is not None:
+                    # If data model is None there will be issues that are already caught.
+                    info = modified.unverified_data_model.as_verified_data_model()
 
                     ExcelExporter(styling="maximal").export_to_file(info, output_path)
         issues.action = "Created extension template"
 
         # Adding issues to the state in the rule store
         if issues:
-            self._state.rule_store._last_issues = issues
+            self._state.data_model_store._last_issues = issues
         return issues

cognite/neat/session/_to.py

@@ -10,10 +10,10 @@ from cognite.neat.core._client._api_client import NeatClient
 from cognite.neat.core._constants import COGNITE_MODELS
 from cognite.neat.core._data_model import exporters
 from cognite.neat.core._data_model._constants import PATTERNS
-from cognite.neat.core._data_model._shared import VerifiedRules
+from cognite.neat.core._data_model._shared import VerifiedDataModel
 from cognite.neat.core._data_model.importers import DMSImporter
-from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
-from cognite.neat.core._data_model.models.dms import DMSMetadata
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
+from cognite.neat.core._data_model.models.physical import PhysicalMetadata
 from cognite.neat.core._instances import loaders
 from cognite.neat.core._issues import IssueList, NeatIssue, catch_issues
 from cognite.neat.core._utils.upload import UploadResultList
@@ -25,8 +25,8 @@ from .exceptions import NeatSessionError, session_class_wrapper
 
 @session_class_wrapper
 class ToAPI:
-    """API used to write the contents of a NeatSession to a specified destination. For instance writing information
-    rules or DMS rules to a NEAT rules Excel spreadsheet, or writing a verified data model to CDF.
+    """API used to write the contents of a NeatSession to a specified destination. For instance writing
+    conceptual or physical data model to a NEAT formatted Excel spreadsheet, or writing a verified data model to CDF.
 
     """
 
@@ -58,7 +58,7 @@ class ToAPI:
             filepath = filepath.with_suffix(".ttl")
 
         exporter = exporters.OWLExporter()
-        self._state.rule_store.export_to_file(exporter, Path(io))
+        self._state.data_model_store.export_to_file(exporter, Path(io))
         return None
 
     def excel(
@@ -81,10 +81,10 @@ class ToAPI:
             add_empty_rows: If True, empty rows will be added between each component. Defaults to False.
 
         Example:
-            Export information model to excel rules sheet
+            Export conceptual data model to an Excel file
             ```python
-            information_rules_file_name = "information_rules.xlsx"
-            neat.to.excel(information_rules_file_name)
+            conceptual_dm_file_name = "conceptual_data_model.xlsx"
+            neat.to.excel(conceptual_dm_file_name)
             ```
 
         Example:
@@ -98,8 +98,8 @@ class ToAPI:
                 data_model_id=("sp_doctrino_space", "ExtensionCore", "v1"),
                 org_name="MyOrg",
             )
-            dms_rules_file_name = "dms_rules.xlsx"
-            neat.to.excel(dms_rules_file_name, include_reference=True)
+            physical_dm_file_name = "physical_dm.xlsx"
+            neat.to.excel(physical_dm_file_name, include_reference=True)
             ```
 
         Example:
@@ -110,36 +110,36 @@ class ToAPI:
             neat = NeatSession(client)
 
             neat.read.cdf(("my_space", "ISA95Model", "v5"))
-            dms_rules_file_name = "dms_rules.xlsx"
-            neat.to.excel(dms_rules_file_name, include_reference=("cdf_cdm", "CogniteCore", "v1"))
+            physical_dm_file_name = "physical_dm.xlsx"
+            neat.to.excel(physical_dm_file_name, include_reference=("cdf_cdm", "CogniteCore", "v1"))
         """
-        reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None
+        reference_data_model_with_prefix: tuple[VerifiedDataModel, str] | None = None
         include_properties = include_properties.strip().lower()
 
         if include_reference is not False:
             if include_reference is True and self._state.last_reference is not None:
-                ref_rules: ConceptualDataModel | DMSRules | None = self._state.last_reference
+                ref_data_model: ConceptualDataModel | PhysicalDataModel | None = self._state.last_reference
             elif include_reference is True:
-                ref_rules = None
+                ref_data_model = None
             else:
                 if not self._state.client:
                     raise NeatSessionError("No client provided!")
-                ref_rules = None
+                ref_data_model = None
                 with catch_issues() as issues:
-                    ref_read = DMSImporter.from_data_model_id(self._state.client, include_reference).to_rules()
-                    if ref_read.rules is not None:
-                        ref_rules = ref_read.rules.as_verified_rules()
-                if ref_rules is None or issues.has_errors:
+                    ref_read = DMSImporter.from_data_model_id(self._state.client, include_reference).to_data_model()
+                    if ref_read.unverified_data_model is not None:
+                        ref_data_model = ref_read.unverified_data_model.as_verified_data_model()
+                if ref_data_model is None or issues.has_errors:
                     issues.action = f"Read {include_reference}"
                     return issues
-            if ref_rules is not None:
+            if ref_data_model is not None:
                 prefix = "Ref"
                 if (
-                    isinstance(ref_rules.metadata, DMSMetadata)
-                    and ref_rules.metadata.as_data_model_id() in COGNITE_MODELS
+                    isinstance(ref_data_model.metadata, PhysicalMetadata)
+                    and ref_data_model.metadata.as_data_model_id() in COGNITE_MODELS
                 ):
                     prefix = "CDM"
-                reference_rules_with_prefix = ref_rules, prefix
+                reference_data_model_with_prefix = ref_data_model, prefix
 
         if include_properties == "same-space":
             warnings.filterwarnings("default")
@@ -147,11 +147,11 @@ class ToAPI:
 
         exporter = exporters.ExcelExporter(
             styling="maximal",
-            reference_rules_with_prefix=reference_rules_with_prefix,
+            reference_data_model_with_prefix=reference_data_model_with_prefix,
             add_empty_rows=add_empty_rows,
             include_properties=include_properties,  # type: ignore
         )
-        self._state.rule_store.export_to_file(exporter, Path(io))
+        self._state.data_model_store.export_to_file(exporter, Path(io))
         return None
 
     def session(self, io: Any) -> None:
@@ -216,7 +216,7 @@ class ToAPI:
         Example:
             Export to yaml file in the case of "neat" format
             ```python
-            your_yaml_file_name = "neat_rules.yaml"
+            your_yaml_file_name = "neat_dm.yaml"
             neat.to.yaml(your_yaml_file_name, format="neat")
             ```
 
@@ -238,9 +238,9 @@ class ToAPI:
         if format == "neat":
             exporter = exporters.YAMLExporter()
             if io is None:
-                return self._state.rule_store.export(exporter)
+                return self._state.data_model_store.export(exporter)
 
-            self._state.rule_store.export_to_file(exporter, Path(io))
+            self._state.data_model_store.export_to_file(exporter, Path(io))
         elif format == "toolkit":
             if io is None or not isinstance(io, str | Path):
                 raise NeatSessionError(
@@ -250,7 +250,7 @@ class ToAPI:
             user_path = Path(io)
             if user_path.suffix == "" and not user_path.exists():
                 user_path.mkdir(parents=True)
-            self._state.rule_store.export_to_file(
+            self._state.data_model_store.export_to_file(
                 exporters.DMSExporter(remove_cdf_spaces=skip_system_spaces), user_path
             )
         else:
@@ -310,10 +310,10 @@ class CDFToAPI:
         )
 
         client = cast(NeatClient, self._state.client)
-        dms_rules = self._state.rule_store.last_verified_dms_rules
-        instance_space = instance_space or f"{dms_rules.metadata.space}_instances"
+        physical_data_model = self._state.data_model_store.last_verified_physical_data_model
+        instance_space = instance_space or f"{physical_data_model.metadata.space}_instances"
 
-        if instance_space and instance_space == dms_rules.metadata.space:
+        if instance_space and instance_space == physical_data_model.metadata.space:
             raise NeatSessionError("Space for instances must be different from the data model space.")
         elif not PATTERNS.space_compliance.match(str(instance_space)):
             raise NeatSessionError("Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
@@ -322,8 +322,8 @@ class CDFToAPI:
             client.data_modeling.spaces.apply(dm.SpaceApply(space=instance_space))
 
         loader = loaders.DMSLoader(
-            self._state.rule_store.last_verified_dms_rules,
-            self._state.rule_store.last_verified_information_rules,
+            self._state.data_model_store.last_verified_physical_data_model,
+            self._state.data_model_store.last_verified_conceptual_data_model,
             self._state.instances.store,
             instance_space=instance_space,
             client=client,
@@ -375,7 +375,7 @@ class CDFToAPI:
 
         exporter = exporters.DMSExporter(existing=existing, drop_data=drop_data)
 
-        result = self._state.rule_store.export_to_cdf(exporter, cast(NeatClient, self._state.client), dry_run)
+        result = self._state.data_model_store.export_to_cdf(exporter, cast(NeatClient, self._state.client), dry_run)
         print("You can inspect the details with the .inspect.outcome.data_model(...) method.")
         return result
 
@@ -418,17 +418,17 @@ class ToPythonAPI:
             instances = neat.to._python.instances(space_from_property="dataSetId")
             ```
         """
-        dms_rules = self._state.rule_store.last_verified_dms_rules
-        instance_space = instance_space or f"{dms_rules.metadata.space}_instances"
+        physical_data_model = self._state.data_model_store.last_verified_physical_data_model
+        instance_space = instance_space or f"{physical_data_model.metadata.space}_instances"
 
-        if instance_space and instance_space == dms_rules.metadata.space:
+        if instance_space and instance_space == physical_data_model.metadata.space:
             raise NeatSessionError("Space for instances must be different from the data model space.")
         elif not PATTERNS.space_compliance.match(str(instance_space)):
             raise NeatSessionError(f"Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
 
         loader = loaders.DMSLoader(
-            self._state.rule_store.last_verified_dms_rules,
-            self._state.rule_store.last_verified_information_rules,
+            self._state.data_model_store.last_verified_physical_data_model,
+            self._state.data_model_store.last_verified_conceptual_data_model,
             self._state.instances.store,
             instance_space=instance_space,
             space_property=space_from_property,

{cognite_neat-0.121.1.dist-info → cognite_neat-0.122.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.121.1
+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/)