cognite-neat 0.115.0__tar.gz → 0.116.0__tar.gz

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.115.0
+Version: 0.116.0
 Summary: Knowledge graph transformation
 License: Apache-2.0
 Author: Nikola Vasiljevic

cognite_neat-0.116.0/cognite/neat/_alpha.py

@@ -0,0 +1,24 @@
+import warnings
+
+
+class ExperimentalFeatureWarning(UserWarning):
+    def __init__(self, feature_name: str):
+        super().__init__(f"Experimental feature '{feature_name}' is subject to change without notice")
+
+    def warn(self) -> None:
+        warnings.warn(self, stacklevel=2)
+
+
+class ExperimentalFlags:
+    manual_rules_edit = ExperimentalFeatureWarning("enable_manual_edit")
+    same_space_properties_only_export = ExperimentalFeatureWarning("same-space-properties-only")
+    standardize_naming = ExperimentalFeatureWarning("standardize_naming")
+    standardize_space_and_version = ExperimentalFeatureWarning("standardize_space_and_version")
+    data_model_subsetting = ExperimentalFeatureWarning("data_model_subsetting")
+    core_data_model_subsetting = ExperimentalFeatureWarning("core_data_model_subsetting")
+    ontology_read = ExperimentalFeatureWarning("ontology_read")
+    imf_read = ExperimentalFeatureWarning("imf_read")
+    dexpi_read = ExperimentalFeatureWarning("dexpi_read")
+    aml_read = ExperimentalFeatureWarning("aml_read")
+    csv_read = ExperimentalFeatureWarning("csv_read")
+    to_ontology = ExperimentalFeatureWarning("to_ontology")

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_constants.py

@@ -64,6 +64,79 @@ COGNITE_SPACES = frozenset(
         "cdf_units",
     }
 )
+
+COGNITE_CORE_CONCEPTS = frozenset(
+    {
+        "CogniteFile",
+        "CogniteCubeMap",
+        "CogniteCADRevision",
+        "CognitePointCloudVolume",
+        "Cognite360ImageAnnotation",
+        "CogniteAnnotation",
+        "CogniteUnit",
+        "CogniteAsset",
+        "Cognite3DObject",
+        "Cognite3DRevision",
+        "Cognite360Image",
+        "CogniteDiagramAnnotation",
+        "Cognite360ImageCollection",
+        "Cognite360ImageStation",
+        "CognitePointCloudModel",
+        "CogniteTimeSeries",
+        "Cognite3DTransformation",
+        "CogniteEquipment",
+        "Cognite360ImageModel",
+        "CogniteAssetClass",
+        "CogniteAssetType",
+        "CogniteEquipmentType",
+        "Cognite3DModel",
+        "CogniteCADModel",
+        "CognitePointCloudRevision",
+        "CogniteCADNode",
+        "CogniteFileCategory",
+        "CogniteActivity",
+    }
+)
+
+
+COGNITE_CORE_FEATURES = frozenset(
+    {
+        "CogniteDescribable",
+        "CogniteSourceable",
+        "CogniteSourceSystem",
+        "CogniteSchedulable",
+        "CogniteVisualizable",
+    }
+)
+
+COGNITE_3D_CONCEPTS = frozenset(
+    {
+        "Cognite3DModel",
+        "Cognite3DObject",
+        "Cognite3DRevision",
+        "Cognite3DTransformation",
+        "Cognite360Image",
+        "Cognite360ImageAnnotation",
+        "Cognite360ImageCollection",
+        "Cognite360ImageModel",
+        "Cognite360ImageStation",
+        "CogniteCADModel",
+        "CogniteCADNode",
+        "CogniteCADRevision",
+        "CogniteCubeMap",
+        "CognitePointCloudModel",
+        "CognitePointCloudRevision",
+        "CognitePointCloudVolume",
+    }
+)
+
+COGNITE_ANNOTATION = frozenset(
+    {
+        "CogniteAnnotation",
+        "CogniteDiagramAnnotation",
+    }
+)
+
 DMS_LISTABLE_PROPERTY_LIMIT = 1000
 
 EXAMPLE_RULES = PACKAGE_DIRECTORY / "_rules" / "examples"

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_rules/transformers/_converters.py

@@ -17,6 +17,8 @@ from rdflib import Namespace
 from cognite.neat._client import NeatClient
 from cognite.neat._client.data_classes.data_modeling import ContainerApplyDict, ViewApplyDict
 from cognite.neat._constants import (
+    COGNITE_CORE_CONCEPTS,
+    COGNITE_CORE_FEATURES,
     COGNITE_MODELS,
     COGNITE_SPACES,
     DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
@@ -1802,6 +1804,76 @@ class _DMSRulesConverter:
         )
 
 
+class _SubsetEditableCDMRules(VerifiedRulesTransformer[DMSRules, DMSRules]):
+    """Subsets editable CDM rules to only include desired set of CDM concepts.
+
+    !!! note "Platypus UI limitations"
+        This is temporal solution to enable cleaner extension of core data model,
+        assuring that Platypus UI will work correctly, including Data Model Editor,
+        Query Explorer and Search.
+    """
+
+    def __init__(self, views: set[ViewEntity]):
+        if not_in_cognite_core := {view.external_id for view in views} - COGNITE_CORE_CONCEPTS.union(
+            COGNITE_CORE_FEATURES
+        ):
+            raise NeatValueError(
+                f"Concept(s) {', '.join(not_in_cognite_core)} is/are not part of the Cognite Core Data Model. Aborting."
+            )
+
+        self._views = views
+
+    def transform(self, rules: DMSRules) -> DMSRules:
+        # should check to make sure data model is based on the editable CDM
+        # if not raise an error
+
+        subsetted_rules: dict[str, Any] = {
+            "metadata": rules.metadata.model_copy(),
+            "views": SheetList[DMSView](),
+            "properties": SheetList[DMSProperty](),
+            "containers": SheetList[DMSContainer](),
+            "enum": rules.enum,
+            "nodes": rules.nodes,
+        }
+
+        containers_to_keep = set()
+
+        if editable_views_to_keep := self._editable_views_to_keep(rules):
+            for view in rules.views:
+                if view.view in editable_views_to_keep or view.view.space in COGNITE_SPACES:
+                    subsetted_rules["views"].append(view)
+
+            for property_ in rules.properties:
+                if property_.view in editable_views_to_keep and (
+                    isinstance(property_.value_type, DataType)
+                    or isinstance(property_.value_type, DMSUnknownEntity)
+                    or (isinstance(property_.value_type, ViewEntity) and property_.value_type in editable_views_to_keep)
+                ):
+                    subsetted_rules["properties"].append(property_)
+                    if property_.container:
+                        containers_to_keep.add(property_.container)
+
+            if rules.containers:
+                for container in rules.containers:
+                    if container.container in containers_to_keep:
+                        subsetted_rules["containers"].append(container)
+            try:
+                return DMSRules.model_validate(subsetted_rules)
+            except ValidationError as e:
+                raise NeatValueError(f"Cannot subset rules: {e}") from e
+        else:
+            raise NeatValueError("Cannot subset rules: provided data model is not based on Core Data Model")
+
+    def _editable_views_to_keep(self, rules: DMSRules) -> set[ViewEntity]:
+        return {
+            view.view
+            for view in rules.views
+            if view.view.space not in COGNITE_SPACES
+            and view.implements
+            and any(implemented in self._views for implemented in view.implements)
+        }
+
+
 class SubsetDMSRules(VerifiedRulesTransformer[DMSRules, DMSRules]):
     """Subsets DMSRules to only include the specified views."""
 

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/_base.py

@@ -165,6 +165,9 @@ class NeatSession:
             neat.convert()
             ```
         """
+        self._state._raise_exception_if_condition_not_met(
+            "Convert to physical", has_dms_rules=False, has_information_rules=True
+        )
         converter = InformationToDMS(reserved_properties=reserved_properties)
 
         issues = self._state.rule_transform(converter)

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/_create.py

@@ -3,7 +3,6 @@ from typing import Literal
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
 from cognite.neat._issues import IssueList
-from cognite.neat._rules.models import DMSRules, InformationRules
 from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.transformers import (
     IncludeReferenced,
@@ -29,7 +28,7 @@ class CreateAPI:
     def enterprise_model(
         self,
         data_model_id: DataModelIdentifier,
-        org_name: str = "My",
+        org_name: str = "CopyOf",
         dummy_property: str = "GUID",
     ) -> IssueList:
         """Uses the current data model as a basis to create enterprise data model
@@ -58,7 +57,7 @@ class CreateAPI:
                 - Charts
 
         """
-        last_rules = self._get_last_rules()
+        last_rules = self._state.rule_store.last_verified_rules
         issues = self._state.rule_transform(
             ToEnterpriseModel(
                 new_model_id=data_model_id,
@@ -71,12 +70,6 @@ class CreateAPI:
             self._state.last_reference = last_rules
         return issues
 
-    def _get_last_rules(self) -> InformationRules | DMSRules | None:
-        if not self._state.rule_store.provenance:
-            return None
-        last_entity = self._state.rule_store.provenance[-1].target_entity
-        return last_entity.dms or last_entity.information
-
     def solution_model(
         self,
         data_model_id: DataModelIdentifier,
@@ -110,7 +103,7 @@ class CreateAPI:
             the containers in the solution data model space.
 
         """
-        last_rules = self._get_last_rules()
+        last_rules = self._state.rule_store.last_verified_rules
         issues = self._state.rule_transform(
             ToSolutionModel(
                 new_model_id=data_model_id,
@@ -144,7 +137,7 @@ class CreateAPI:
                 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._get_last_rules()
+        last_rules = self._state.rule_store.last_verified_rules
         view_ids, container_ids = DMSValidation(
             self._state.rule_store.last_verified_dms_rules
         ).imported_views_and_containers_ids()

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/_prepare.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from rdflib import URIRef
 
-from cognite.neat._alpha import AlphaFlags
+from cognite.neat._alpha import ExperimentalFlags
 from cognite.neat._graph.transformers import (
     ConnectionToLiteral,
     ConvertLiteral,
@@ -273,7 +273,7 @@ class DataModelPrepareAPI:
         For properties, the naming will be standardized to camelCase.
         """
         warnings.filterwarnings("default")
-        AlphaFlags.standardize_naming.warn()
+        ExperimentalFlags.standardize_naming.warn()
         return self._state.rule_transform(StandardizeNaming())
 
     def standardize_space_and_version(self) -> IssueList:
@@ -282,5 +282,5 @@ class DataModelPrepareAPI:
         This method will standardize the space and version in the data model to the Cognite standard.
         """
         warnings.filterwarnings("default")
-        AlphaFlags.standardize_space_and_version.warn()
+        ExperimentalFlags.standardize_space_and_version.warn()
         return self._state.rule_transform(StandardizeSpaceAndVersion())

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/_read.py

@@ -4,7 +4,7 @@ from typing import Any, Literal, cast
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite.neat._alpha import AlphaFlags
+from cognite.neat._alpha import ExperimentalFlags
 from cognite.neat._client import NeatClient
 from cognite.neat._constants import (
     CLASSIC_CDF_NAMESPACE,
@@ -28,7 +28,12 @@ from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import MissingCogniteClientWarning
 from cognite.neat._rules import catalog, importers
 from cognite.neat._rules.importers import BaseImporter
+from cognite.neat._rules.models.entities._single_value import ViewEntity
 from cognite.neat._rules.transformers import ClassicPrepareCore
+from cognite.neat._rules.transformers._converters import (
+    ToEnterpriseModel,
+    _SubsetEditableCDMRules,
+)
 from cognite.neat._utils.reader import NeatReader
 
 from ._state import SessionState
@@ -114,6 +119,86 @@ class CDFReadAPI(BaseReadAPI):
         importer = importers.DMSImporter.from_data_model_id(cast(NeatClient, self._state.client), data_model_id)
         return self._state.rule_import(importer)
 
+    def core_data_model(self, concepts: str | list[str]) -> IssueList:
+        """Subset the data model to the desired concepts.
+
+        Args:
+            concepts: The concepts to subset the data model to
+
+        Returns:
+            IssueList: A list of issues that occurred during the transformation.
+
+        Example:
+            Read the CogniteCore data model and reduce the data model to only the 'CogniteAsset' concept.
+            ```python
+            neat = NeatSession(CogniteClient())
+
+            neat.subset.data_model.core_data_model(concepts=["CogniteAsset", "CogniteEquipment"])
+            ```
+
+        !!! note "Bundle of actions"
+            This method is a helper method that bundles the following actions:
+            - Imports the latest version of Cognite's Core Data Model (CDM)
+            - Makes editable copy of the CDM concepts
+            - Subsets the copy to the desired concepts to desired set of concepts
+        """
+
+        concepts = concepts if isinstance(concepts, list | set) else [concepts]
+
+        self._state._raise_exception_if_condition_not_met(
+            "Subset Core Data Model",
+            empty_rules_store_required=True,
+            client_required=True,
+        )
+
+        warnings.filterwarnings("default")
+        ExperimentalFlags.core_data_model_subsetting.warn()
+
+        cdm_v1 = DataModelId.load(("cdf_cdm", "CogniteCore", "v1"))
+        importer: importers.DMSImporter = importers.DMSImporter.from_data_model_id(
+            cast(NeatClient, self._state.client), cdm_v1
+        )
+        issues = self._state.rule_import(importer)
+
+        if issues.has_errors:
+            return issues
+
+        cdm_rules = self._state.rule_store.last_verified_rules
+
+        issues.extend(
+            self._state.rule_transform(
+                ToEnterpriseModel(
+                    new_model_id=("my_space", "MyCDMSubset", "v1"),
+                    org_name="CopyOf",
+                    dummy_property="GUID",
+                    move_connections=True,
+                )
+            )
+        )
+
+        if issues.has_errors:
+            return issues
+
+        issues.extend(
+            self._state.rule_transform(
+                _SubsetEditableCDMRules(
+                    views={
+                        ViewEntity(
+                            space=cdm_v1.space,
+                            externalId=concept,
+                            version=cast(str, cdm_v1.version),
+                        )
+                        for concept in concepts
+                    }
+                )
+            )
+        )
+
+        if cdm_rules and not issues.has_errors:
+            self._state.last_reference = cdm_rules
+
+        return issues
+
     def graph(
         self,
         data_model_id: DataModelIdentifier,
@@ -361,7 +446,12 @@ class ExcelReadAPI(BaseReadAPI):
 
         if enable_manual_edit:
             warnings.filterwarnings("default")
-            AlphaFlags.manual_rules_edit.warn()
+            ExperimentalFlags.manual_rules_edit.warn()
+        else:
+            self._state._raise_exception_if_condition_not_met(
+                "Read Excel Rules",
+                empty_rules_store_required=True,
+            )
 
         return self._state.rule_import(importers.ExcelImporter(path), enable_manual_edit)
 
@@ -381,6 +471,10 @@ class YamlReadAPI(BaseReadAPI):
             neat.read.yaml("path_to_toolkit_yamls")
             ```
         """
+        self._state._raise_exception_if_condition_not_met(
+            "Read YAML data model",
+            empty_rules_store_required=True,
+        )
         reader = NeatReader.create(io)
         path = reader.materialize_path()
         importer: BaseImporter
@@ -421,7 +515,7 @@ class CSVReadAPI(BaseReadAPI):
 
     def __call__(self, io: Any, type: str, primary_key: str) -> None:
         warnings.filterwarnings("default")
-        AlphaFlags.csv_read.warn()
+        ExperimentalFlags.csv_read.warn()
 
         engine = import_engine()
         engine.set.format = "csv"
@@ -479,7 +573,7 @@ class XMLReadAPI(BaseReadAPI):
             - remove edges to nodes that do not exist in the extracted graph
         """
         warnings.filterwarnings("default")
-        AlphaFlags.dexpi_read.warn()
+        ExperimentalFlags.dexpi_read.warn()
 
         self._state._raise_exception_if_condition_not_met(
             "Read DEXPI file",
@@ -539,7 +633,7 @@ class XMLReadAPI(BaseReadAPI):
             - remove edges to nodes that do not exist in the extracted graph
         """
         warnings.filterwarnings("default")
-        AlphaFlags.aml_read.warn()
+        ExperimentalFlags.aml_read.warn()
 
         self._state._raise_exception_if_condition_not_met(
             "Read AML file",
@@ -599,7 +693,7 @@ class RDFReadAPI(BaseReadAPI):
             ```
         """
         warnings.filterwarnings("default")
-        AlphaFlags.ontology_read.warn()
+        ExperimentalFlags.ontology_read.warn()
 
         self._state._raise_exception_if_condition_not_met(
             "Read Ontology file",
@@ -622,7 +716,7 @@ class RDFReadAPI(BaseReadAPI):
             ```
         """
         warnings.filterwarnings("default")
-        AlphaFlags.imf_read.warn()
+        ExperimentalFlags.imf_read.warn()
 
         self._state._raise_exception_if_condition_not_met(
             "Read IMF file",
@@ -634,6 +728,10 @@ class RDFReadAPI(BaseReadAPI):
         return self._state.rule_import(importer)
 
     def instances(self, io: Any) -> IssueList:
+        self._state._raise_exception_if_condition_not_met(
+            "Read RDF Instances",
+            empty_rules_store_required=True,
+        )
         reader = NeatReader.create(io)
         self._state.instances.store.write(extractors.RdfFileExtractor(reader.materialize_path()))
         return IssueList()
@@ -674,12 +772,6 @@ class Examples:
     def __init__(self, state: SessionState) -> None:
         self._state = state
 
-    @property
-    def _get_client(self) -> NeatClient:
-        if self._state.client is None:
-            raise NeatValueError("No client provided. Please provide a client to read a data model.")
-        return self._state.client
-
     def nordic44(self) -> IssueList:
         """Reads the Nordic 44 knowledge graph into the NeatSession graph store."""
 
@@ -709,8 +801,11 @@ class Examples:
         self._state._raise_exception_if_condition_not_met(
             "Read Core Data Model example",
             empty_rules_store_required=True,
+            client_required=True,
         )
 
         cdm_v1 = DataModelId.load(("cdf_cdm", "CogniteCore", "v1"))
-        importer: importers.DMSImporter = importers.DMSImporter.from_data_model_id(self._get_client, cdm_v1)
+        importer: importers.DMSImporter = importers.DMSImporter.from_data_model_id(
+            cast(NeatClient, self._state.client), cdm_v1
+        )
         return self._state.rule_import(importer)

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/_state.py

@@ -71,14 +71,23 @@ class SessionState:
         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,
     ) -> None:
         """Set conditions for raising an error in the session that are used by various methods in the session."""
         condition = set()
         suggestion = set()
-
+        try_again = True
         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")
+            try_again = False
         if empty_rules_store_required and not self.rule_store.empty:
             condition.add(f"{activity} expects no data model in NEAT session")
             suggestion.add("Start new session")
@@ -90,7 +99,10 @@ class SessionState:
             suggestion.add("Read in instances to neat session")
 
         if condition:
-            raise NeatSessionError(". ".join(condition) + ". " + ". ".join(suggestion) + ". And try again.")
+            message = ". ".join(condition) + ". " + ". ".join(suggestion) + "."
+            if try_again:
+                message += " And try again."
+            raise NeatSessionError(message)
 
 
 class InstancesState:

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/_subset.py

@@ -1,6 +1,6 @@
 import warnings
 
-from cognite.neat._alpha import AlphaFlags
+from cognite.neat._alpha import ExperimentalFlags
 from cognite.neat._issues._base import IssueList
 from cognite.neat._rules.models.entities._single_value import ClassEntity, ViewEntity
 from cognite.neat._rules.transformers import SubsetDMSRules, SubsetInformationRules
@@ -47,7 +47,7 @@ class SubsetAPI:
             raise NeatSessionError("No rules to set the data model ID.")
 
         warnings.filterwarnings("default")
-        AlphaFlags.data_model_subsetting.warn()
+        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

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/_to.py

@@ -7,7 +7,7 @@ from typing import Any, Literal, cast, overload
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
-from cognite.neat._alpha import AlphaFlags
+from cognite.neat._alpha import ExperimentalFlags
 from cognite.neat._client._api_client import NeatClient
 from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._graph import loaders
@@ -52,7 +52,7 @@ class ToAPI:
             ```
         """
         warnings.filterwarnings("default")
-        AlphaFlags.to_ontology.warn()
+        ExperimentalFlags.to_ontology.warn()
 
         filepath = Path(io)
         if filepath.suffix != ".ttl":
@@ -145,7 +145,7 @@ class ToAPI:
 
         if include_properties == "same-space":
             warnings.filterwarnings("default")
-            AlphaFlags.same_space_properties_only_export.warn()
+            ExperimentalFlags.same_space_properties_only_export.warn()
 
         exporter = exporters.ExcelExporter(
             styling="maximal",

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_session/exceptions.py

@@ -3,7 +3,7 @@ import warnings
 from collections.abc import Callable
 from typing import Any
 
-from cognite.neat._alpha import AlphaWarning
+from cognite.neat._alpha import ExperimentalFeatureWarning
 from cognite.neat._issues.errors import CDFMissingClientError, NeatImportError
 from cognite.neat._issues.errors._external import OxigraphStorageLockedError
 from cognite.neat._issues.errors._general import NeatValueError
@@ -38,7 +38,7 @@ def _session_method_wrapper(func: Callable, cls_name: str):
             with warnings.catch_warnings(record=True) as w:
                 result = func(*args, **kwargs)
                 for warning in w:
-                    if isinstance(warning.message, AlphaWarning):
+                    if isinstance(warning.message, ExperimentalFeatureWarning):
                         print(f"{_WARNING_PREFIX} {warning.message}")
 
             return result

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/cognite/neat/_store/_rules_store.py

@@ -421,6 +421,20 @@ class NeatRulesStore:
         self._iteration_by_id[identifier] += 1
         return identifier + f"/Iteration_{self._iteration_by_id[identifier]}"
 
+    @property
+    def try_get_last_dms_rules(self) -> DMSRules | None:
+        if not self.provenance:
+            return None
+        if self.provenance[-1].target_entity.dms is None:
+            return None
+        return self.provenance[-1].target_entity.dms
+
+    @property
+    def try_get_last_information_rules(self) -> InformationRules | None:
+        if not self.provenance:
+            return None
+        return self.provenance[-1].target_entity.information
+
     @property
     def last_verified_dms_rules(self) -> DMSRules:
         if not self.provenance:
@@ -435,6 +449,13 @@ class NeatRulesStore:
             raise EmptyStore()
         return self.provenance[-1].target_entity.information
 
+    @property
+    def last_verified_rules(self) -> InformationRules | DMSRules | None:
+        if not self.provenance:
+            return None
+        last_entity = self.provenance[-1].target_entity
+        return last_entity.dms or last_entity.information
+
     @property
     def last_issues(self) -> IssueList | None:
         return self._last_issues

cognite_neat-0.116.0/cognite/neat/_version.py

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

{cognite_neat-0.115.0 → cognite_neat-0.116.0}/pyproject.toml

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

cognite_neat-0.115.0/cognite/neat/_alpha.py

@@ -1,23 +0,0 @@
-import warnings
-
-
-class AlphaWarning(UserWarning):
-    def __init__(self, feature_name: str):
-        super().__init__(f"Alpha feature '{feature_name}' is subject to change without notice")
-
-    def warn(self) -> None:
-        warnings.warn(self, stacklevel=2)
-
-
-class AlphaFlags:
-    manual_rules_edit = AlphaWarning("enable_manual_edit")
-    same_space_properties_only_export = AlphaWarning("same-space-properties-only")
-    standardize_naming = AlphaWarning("standardize_naming")
-    standardize_space_and_version = AlphaWarning("standardize_space_and_version")
-    data_model_subsetting = AlphaWarning("data_model_subsetting")
-    ontology_read = AlphaWarning("ontology_read")
-    imf_read = AlphaWarning("imf_read")
-    dexpi_read = AlphaWarning("dexpi_read")
-    aml_read = AlphaWarning("aml_read")
-    csv_read = AlphaWarning("csv_read")
-    to_ontology = AlphaWarning("to_ontology")