cognite-neat 0.85.5__tar.gz → 0.85.7__tar.gz

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.85.5
+Version: 0.85.7
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.85.7/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.85.7"

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/app/api/routers/data_exploration.py

@@ -17,7 +17,7 @@ from cognite.neat.app.api.data_classes.rest import (
 from cognite.neat.app.api.utils.data_mapping import rdf_result_to_api_response
 from cognite.neat.app.api.utils.query_templates import query_templates
 from cognite.neat.legacy.graph.transformations import query_generator
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 from cognite.neat.workflows.steps.data_contracts import RulesData, SolutionGraph, SourceGraph
 
 router = APIRouter()
@@ -51,7 +51,7 @@ def get_datatype_properties(request: DatatypePropertyRequest):
             {
                 "id": row[rdflib.Variable("property")],
                 "count": int(row[rdflib.Variable("occurrence")]),
-                "name": remove_namespace(row[rdflib.Variable("property")]),
+                "name": remove_namespace_from_uri(row[rdflib.Variable("property")]),
             }
             for row in results["rows"]
         ]

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/graph/extractors/_classic_cdf/_assets.py

@@ -1,4 +1,4 @@
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import cast
@@ -19,15 +19,19 @@ class AssetsExtractor(BaseExtractor):
     Args:
         assets (Iterable[Asset]): An iterable of assets.
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        to_type (Callable[[Asset], str | None], optional): A function to convert an asset to a type. Defaults to None.
+            If None or if the function returns None, the asset will be set to the default type "Asset".
     """
 
     def __init__(
         self,
         assets: Iterable[Asset],
         namespace: Namespace | None = None,
+        to_type: Callable[[Asset], str | None] | None = None,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.assets = assets
+        self.to_type = to_type
 
     @classmethod
     def from_dataset(
@@ -35,29 +39,42 @@ class AssetsExtractor(BaseExtractor):
         client: CogniteClient,
         data_set_external_id: str,
         namespace: Namespace | None = None,
+        to_type: Callable[[Asset], str | None] | None = None,
     ):
-        return cls(cast(Iterable[Asset], client.assets(data_set_external_ids=data_set_external_id)), namespace)
+        return cls(cast(Iterable[Asset], client.assets(data_set_external_ids=data_set_external_id)), namespace, to_type)
 
     @classmethod
-    def from_hierarchy(cls, client: CogniteClient, root_asset_external_id: str, namespace: Namespace | None = None):
-        return cls(cast(Iterable[Asset], client.assets(asset_subtree_external_ids=root_asset_external_id)), namespace)
+    def from_hierarchy(
+        cls,
+        client: CogniteClient,
+        root_asset_external_id: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[Asset], str | None] | None = None,
+    ):
+        return cls(
+            cast(Iterable[Asset], client.assets(asset_subtree_external_ids=root_asset_external_id)), namespace, to_type
+        )
 
     @classmethod
-    def from_file(cls, file_path: str, namespace: Namespace | None = None):
-        return cls(AssetList.load(Path(file_path).read_text()), namespace)
+    def from_file(
+        cls, file_path: str, namespace: Namespace | None = None, to_type: Callable[[Asset], str] | None = None
+    ):
+        return cls(AssetList.load(Path(file_path).read_text()), namespace, to_type)
 
     def extract(self) -> Iterable[Triple]:
         """Extracts an asset with the given asset_id."""
         for asset in self.assets:
             yield from self._asset2triples(asset, self.namespace)
 
-    @classmethod
-    def _asset2triples(cls, asset: Asset, namespace: Namespace) -> list[Triple]:
+    def _asset2triples(self, asset: Asset, namespace: Namespace) -> list[Triple]:
         """Converts an asset to triples."""
         id_ = namespace[f"Asset_{asset.id}"]
 
         # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, namespace["Asset"])]
+        type_ = "Asset"
+        if self.to_type:
+            type_ = self.to_type(asset) or type_
+        triples: list[Triple] = [(id_, RDF.type, namespace[type_])]
 
         # Create attributes
         if asset.name:

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -17,7 +17,7 @@ from cognite.neat.rules.models import DMSRules, InformationRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
 from cognite.neat.rules.models.information import InformationProperty
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 from ._base import BaseExtractor
 
@@ -258,7 +258,11 @@ def _generate_mock_data_property_triples(
         # generate string
         else:
             triples.append(
-                (id_, URIRef(namespace[property_]), Literal(f"{property_}-{remove_namespace(id_).split('-')[-1]}"))
+                (
+                    id_,
+                    URIRef(namespace[property_]),
+                    Literal(f"{property_}-{remove_namespace_from_uri(id_).split('-')[-1]}"),
+                )
             )
     return triples
 

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/graph/loaders/_base.py

@@ -65,11 +65,11 @@ class CDFLoader(BaseLoader[T_Output]):
                 items.append(result)
 
             if len(items) >= self._UPLOAD_BATCH_SIZE:
-                yield self._upload_to_cdf(client, items, dry_run, issues)
+                yield from self._upload_to_cdf(client, items, dry_run, issues)
                 issues = NeatIssueList[NeatIssue]()
                 items = []
         if items:
-            yield self._upload_to_cdf(client, items, dry_run, issues)
+            yield from self._upload_to_cdf(client, items, dry_run, issues)
 
     @abstractmethod
     def _get_required_capabilities(self) -> list[Capability]:
@@ -82,5 +82,5 @@ class CDFLoader(BaseLoader[T_Output]):
         items: list[T_Output],
         dry_run: bool,
         read_issues: NeatIssueList,
-    ) -> UploadResult:
+    ) -> Iterable[UploadResult]:
         raise NotImplementedError

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -1,4 +1,3 @@
-import itertools
 import json
 from collections import defaultdict
 from collections.abc import Iterable, Sequence
@@ -263,8 +262,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         items: list[dm.InstanceApply],
         dry_run: bool,
         read_issues: NeatIssueList,
-    ) -> UploadResult:
-        result = UploadResult[InstanceId](name=type(self).__name__, issues=read_issues)
+    ) -> Iterable[UploadResult]:
         try:
             nodes = [item for item in items if isinstance(item, dm.NodeApply)]
             edges = [item for item in items if isinstance(item, dm.EdgeApply)]
@@ -276,18 +274,22 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 skip_on_version_conflict=True,
             )
         except CogniteAPIError as e:
+            result = UploadResult[InstanceId](name="Instances", issues=read_issues)
             result.error_messages.append(str(e))
             result.failed_upserted.update(item.as_id() for item in e.failed + e.unknown)
             result.created.update(item.as_id() for item in e.successful)
+            yield result
         else:
-            for instance in itertools.chain(upserted.nodes, upserted.edges):
-                if instance.was_modified and instance.created_time == instance.last_updated_time:
-                    result.created.add(instance.as_id())
-                elif instance.was_modified:
-                    result.changed.add(instance.as_id())
-                else:
-                    result.unchanged.add(instance.as_id())
-        return result
+            for instance_type, instances in {"Nodes": upserted.nodes, "Edges": upserted.edges}.items():
+                result = UploadResult[InstanceId](name=instance_type, issues=read_issues)
+                for instance in instances:  # type: ignore[attr-defined]
+                    if instance.was_modified and instance.created_time == instance.last_updated_time:
+                        result.created.add(instance.as_id())
+                    elif instance.was_modified:
+                        result.changed.add(instance.as_id())
+                    else:
+                        result.unchanged.add(instance.as_id())
+                yield result
 
 
 def _triples2dictionary(

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/graph/queries/_base.py

@@ -1,12 +1,12 @@
 import warnings
-from typing import cast
+from typing import Literal, cast, overload
 
 from rdflib import RDF, Graph, URIRef
 from rdflib.query import ResultRow
 
 from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.rules.models.information import InformationRules
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 from ._construct import build_construct_query
 
@@ -66,7 +66,7 @@ class Queries:
             result = self.graph.query(query)
 
             # We cannot include the RDF.type in case there is a neat:type property
-            return [remove_namespace(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
+            return [remove_namespace_from_uri(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
         else:
             warnings.warn("No rules found for the graph store, returning empty list.", stacklevel=2)
             return []
@@ -93,7 +93,7 @@ class Queries:
             result = self.graph.query(query)
 
             # We cannot include the RDF.type in case there is a neat:type property
-            return [remove_namespace(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
+            return [remove_namespace_from_uri(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
         else:
             warnings.warn("No rules found for the graph store, returning empty list.", stacklevel=2)
             return []
@@ -110,14 +110,24 @@ class Queries:
         query = f"SELECT ?subject ?predicate ?object WHERE {{ ?subject ?predicate ?object }} LIMIT {limit}"
         return cast(list[ResultRow], list(self.graph.query(query)))
 
-    def list_types(self, limit: int = 25) -> list[ResultRow]:
+    @overload
+    def list_types(self, remove_namespace: Literal[False] = False, limit: int = 25) -> list[ResultRow]: ...
+
+    @overload
+    def list_types(self, remove_namespace: Literal[True], limit: int = 25) -> list[str]: ...
+
+    def list_types(self, remove_namespace: bool = False, limit: int = 25) -> list[ResultRow] | list[str]:
         """List types in the graph store
 
         Args:
             limit: Max number of types to return, by default 25
+            remove_namespace: Whether to remove the namespace from the type, by default False
 
         Returns:
             List of types
         """
         query = f"SELECT DISTINCT ?type WHERE {{ ?subject a ?type }} LIMIT {limit}"
-        return cast(list[ResultRow], list(self.graph.query(query)))
+        result = cast(list[ResultRow], list(self.graph.query(query)))
+        if remove_namespace:
+            return [remove_namespace_from_uri(res[0]) for res in result]
+        return result

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/graph/queries/_shared.py

@@ -11,7 +11,7 @@ from cognite.neat.rules.models._rdfpath import (
     Hop,
     Step,
 )
-from cognite.neat.utils.utils import remove_namespace, uri_to_short_form
+from cognite.neat.utils.utils import remove_namespace_from_uri, uri_to_short_form
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -146,7 +146,7 @@ def triples2dictionary(triples: Iterable[tuple[URIRef, URIRef, str | URIRef]]) -
         value: str
         uri: URIRef
 
-        id_, property_, value = remove_namespace(*triple)  # type: ignore[misc]
+        id_, property_, value = remove_namespace_from_uri(*triple)  # type: ignore[misc]
         uri = triple[0]
 
         if uri not in dictionary:

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/graph/extractors/_mock_graph_generator.py

@@ -20,7 +20,7 @@ from cognite.neat.legacy.rules.analysis import (
 from cognite.neat.legacy.rules.exporters._rules2rules import subset_rules
 from cognite.neat.legacy.rules.models import Rules
 from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 from ._base import BaseExtractor
 
@@ -247,7 +247,9 @@ def _generate_mock_data_property_triples(
             triples.append((id_, URIRef(namespace[property_]), Literal(numpy.float32(random.uniform(1, 1983)))))
         # generate string
         else:
-            triples.append((id_, URIRef(namespace[property_]), Literal(remove_namespace(id_).replace("-", " "))))
+            triples.append(
+                (id_, URIRef(namespace[property_]), Literal(remove_namespace_from_uri(id_).replace("-", " ")))
+            )
     return triples
 
 

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/graph/loaders/_asset_loader.py

@@ -15,7 +15,7 @@ from rdflib.query import ResultRow
 from cognite.neat.legacy.graph.stores import NeatGraphStoreBase
 from cognite.neat.legacy.rules.models import Rules
 from cognite.neat.legacy.rules.models.rules import Property
-from cognite.neat.utils import remove_namespace
+from cognite.neat.utils import remove_namespace_from_uri
 from cognite.neat.utils.utils import epoch_now_ms
 
 from ._base import CogniteLoader
@@ -166,7 +166,7 @@ class AssetLoader(CogniteLoader[AssetResource]):
             logging.debug(f"Class <{class_name}> has {len(result)} instances")
 
             for instance_uri, properties_values in groupby(result, lambda x: x[0]):
-                instance_id = remove_namespace(instance_uri)
+                instance_id = remove_namespace_from_uri(instance_uri)
                 values_by_property = self._prepare_instance_data(instance_id, properties_values)
                 try:
                     asset = self._load_asset(
@@ -195,7 +195,7 @@ class AssetLoader(CogniteLoader[AssetResource]):
                     relationships = self._load_relationships(
                         properties_by_class_name[class_name],
                         values_by_property,
-                        remove_namespace(instance_id),
+                        remove_namespace_from_uri(instance_id),
                         class_name,
                     )
                 except Exception as e:
@@ -342,11 +342,11 @@ class AssetLoader(CogniteLoader[AssetResource]):
             A dictionary with property type as key and a list of values as value.
         """
         properties_value_tuples: list[tuple[str, str]] = [
-            remove_namespace(prop, value)  # type: ignore[misc]
+            remove_namespace_from_uri(prop, value)  # type: ignore[misc]
             for _, prop, value in properties_values
         ]
         # We add an identifier which will be used as fallback for external_id
-        properties_value_tuples.append((self._identifier, remove_namespace(instance_id)))
+        properties_value_tuples.append((self._identifier, remove_namespace_from_uri(instance_id)))
         values_by_property: dict[str, str | list[str]] = {}
         for prop, values in groupby(sorted(properties_value_tuples), lambda x: x[0]):
             values_list: list[str] = [value for _, value in values]  # type: ignore[misc, has-type]

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/graph/loaders/core/rdf_to_assets.py

@@ -18,7 +18,7 @@ from rdflib.term import URIRef
 from cognite.neat.legacy.graph.loaders.core.models import AssetTemplate
 from cognite.neat.legacy.graph.stores import NeatGraphStoreBase
 from cognite.neat.legacy.rules.models.rules import Property, Rules
-from cognite.neat.utils.utils import chunker, datetime_utc_now, remove_namespace, retry_decorator
+from cognite.neat.utils.utils import chunker, datetime_utc_now, remove_namespace_from_uri, retry_decorator
 
 if sys.version_info >= (3, 11):
     from datetime import UTC
@@ -320,13 +320,13 @@ def _list2dict(class_instance: list) -> dict[str, Any]:
 
     class_instance_dict: dict[str, Any] = {}
     for property_value_pair in class_instance:
-        property_ = remove_namespace(property_value_pair[0])
+        property_ = remove_namespace_from_uri(property_value_pair[0])
 
         # Remove namespace from URIRef values, otherwise convert Literal to string
         # ideally this should react upon property type provided in sheet
         # however Assets only support string values
         value = (
-            remove_namespace(property_value_pair[1])
+            remove_namespace_from_uri(property_value_pair[1])
             if isinstance(property_value_pair[1], URIRef)
             else str(property_value_pair[1])
         )
@@ -440,7 +440,7 @@ def rdf2assets(
                 progress_counter += 1
             except Exception as ValidationError:
                 logging.error(
-                    f"Skipping class <{class_}> instance <{remove_namespace(str(instance_id))}>, "
+                    f"Skipping class <{class_}> instance <{remove_namespace_from_uri(str(instance_id))}>, "
                     f"reason:\n{ValidationError}\n"
                 )
                 if stop_on_exception:

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/graph/loaders/core/rdf_to_relationships.py

@@ -14,7 +14,7 @@ from cognite.neat.legacy.graph.loaders.core.models import RelationshipDefinition
 from cognite.neat.legacy.graph.loaders.core.rdf_to_assets import _categorize_cdf_assets
 from cognite.neat.legacy.graph.stores import NeatGraphStoreBase
 from cognite.neat.legacy.rules.models.rules import Rules
-from cognite.neat.utils.utils import chunker, datetime_utc_now, epoch_now_ms, remove_namespace, retry_decorator
+from cognite.neat.utils.utils import chunker, datetime_utc_now, epoch_now_ms, remove_namespace_from_uri, retry_decorator
 
 
 def define_relationships(rules: Rules, data_set_id: int, stop_on_exception: bool = False) -> RelationshipDefinitions:
@@ -150,7 +150,7 @@ def rdf2relationships(
             relationship_data_frame.rename(columns={0: "source_external_id", 1: "target_external_id"}, inplace=True)
 
             # removes namespace
-            relationship_data_frame = relationship_data_frame.map(remove_namespace)  # type: ignore[operator]
+            relationship_data_frame = relationship_data_frame.map(remove_namespace_from_uri)  # type: ignore[operator]
 
             # adding prefix
             if relationship_external_id_prefix:

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/graph/transformations/query_generator/sparql.py

@@ -21,7 +21,7 @@ from cognite.neat.legacy.rules.models.rdfpath import (
     parse_traversal,
 )
 from cognite.neat.legacy.rules.models.rules import Rules
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 
 def _generate_prefix_header(prefixes: dict[str, Namespace] = PREFIXES) -> str:
@@ -529,7 +529,7 @@ def triples2dictionary(triples: Iterable[tuple[URIRef, URIRef, str | URIRef]]) -
         property_: str
         value: str
         uri: URIRef
-        id_, property_, value = remove_namespace(*triple)  # type: ignore[misc]
+        id_, property_, value = remove_namespace_from_uri(*triple)  # type: ignore[misc]
         uri = triple[0]
 
         if uri not in dictionary:

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/graph/transformations/transformer.py

@@ -24,7 +24,7 @@ from cognite.neat.legacy.rules.models.rdfpath import (
     parse_rule,
 )
 from cognite.neat.legacy.rules.models.rules import Rules
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 prom_total_proc_rules_g = Gauge("neat_total_processed_rules", "Number of processed rules", ["state"])
 rules_processing_timing_metric = Gauge(
@@ -228,7 +228,7 @@ def domain2app_knowledge_graph(
                 # in the target graph then we should remove namespace from the object URI and store it as literal
                 if isinstance(rule.traversal, AllReferences) and rule_definition.property_type == "DatatypeProperty":
                     instance_df[EntityTypes.object] = instance_df[EntityTypes.object].apply(
-                        lambda x: Literal(remove_namespace(x))
+                        lambda x: Literal(remove_namespace_from_uri(x))
                     )
 
                 if isinstance(rule, RawLookup):

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/rules/exporters/_rules2ontology.py

@@ -14,7 +14,7 @@ from cognite.neat.legacy.rules.exporters._base import BaseExporter
 from cognite.neat.legacy.rules.exporters._validation import are_properties_redefined
 from cognite.neat.legacy.rules.models.rules import Class, Metadata, Property, Rules
 from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
-from cognite.neat.utils.utils import generate_exception_report, remove_namespace
+from cognite.neat.utils.utils import generate_exception_report, remove_namespace_from_uri
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -322,7 +322,7 @@ class OWLProperty(OntologyModel):
         if len(v) > 1:
             warnings.warn(
                 exceptions.OntologyMultiTypeProperty(
-                    remove_namespace(info.data["id_"]), [remove_namespace(t) for t in v]
+                    remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
                 ).message,
                 category=exceptions.OntologyMultiTypeProperty,
                 stacklevel=2,
@@ -334,7 +334,7 @@ class OWLProperty(OntologyModel):
         if len(v) > 1:
             warnings.warn(
                 exceptions.OntologyMultiRangeProperty(
-                    remove_namespace(info.data["id_"]), [remove_namespace(t) for t in v]
+                    remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
                 ).message,
                 category=exceptions.OntologyMultiRangeProperty,
                 stacklevel=2,
@@ -346,7 +346,7 @@ class OWLProperty(OntologyModel):
         if len(v) > 1:
             warnings.warn(
                 exceptions.OntologyMultiDomainProperty(
-                    remove_namespace(info.data["id_"]), [remove_namespace(t) for t in v]
+                    remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
                 ).message,
                 category=exceptions.OntologyMultiDomainProperty,
                 stacklevel=2,
@@ -357,7 +357,7 @@ class OWLProperty(OntologyModel):
     def has_multi_name(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiLabeledProperty(remove_namespace(info.data["id_"]), v).message,
+                exceptions.OntologyMultiLabeledProperty(remove_namespace_from_uri(info.data["id_"]), v).message,
                 category=exceptions.OntologyMultiLabeledProperty,
                 stacklevel=2,
             )
@@ -367,7 +367,7 @@ class OWLProperty(OntologyModel):
     def has_multi_comment(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiDefinitionProperty(remove_namespace(info.data["id_"])).message,
+                exceptions.OntologyMultiDefinitionProperty(remove_namespace_from_uri(info.data["id_"])).message,
                 category=exceptions.OntologyMultiDefinitionProperty,
                 stacklevel=2,
             )

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/rules/importers/_graph2rules.py

@@ -14,7 +14,7 @@ from cognite.neat.constants import PREFIXES
 from cognite.neat.legacy.rules import exceptions
 from cognite.neat.legacy.rules.exporters._rules2rules import to_dms_name
 from cognite.neat.legacy.rules.models.tables import Tables
-from cognite.neat.utils.utils import get_namespace, remove_namespace, uri_to_short_form
+from cognite.neat.utils.utils import get_namespace, remove_namespace_from_uri, uri_to_short_form
 
 from ._base import BaseImporter
 
@@ -173,7 +173,7 @@ def _graph_to_data_model_dict(graph: Graph, max_number_of_instance: int = -1) ->
 
     for class_ in _get_class_ids(graph):
         _add_uri_namespace_to_prefixes(class_, prefixes)
-        class_name = remove_namespace(class_)
+        class_name = remove_namespace_from_uri(class_)
 
         if class_name in data_model:
             warnings.warn(
@@ -187,7 +187,7 @@ def _graph_to_data_model_dict(graph: Graph, max_number_of_instance: int = -1) ->
 
         for instance in _get_class_instance_ids(graph, class_, max_number_of_instance):
             for property_, occurrence, data_type, object_type in _define_instance_properties(graph, instance):
-                property_name = remove_namespace(property_)
+                property_name = remove_namespace_from_uri(property_)
                 _add_uri_namespace_to_prefixes(property_, prefixes)
 
                 type_ = data_type if data_type else object_type
@@ -196,7 +196,7 @@ def _graph_to_data_model_dict(graph: Graph, max_number_of_instance: int = -1) ->
                 if not type_:
                     continue
 
-                type_name = remove_namespace(type_)
+                type_name = remove_namespace_from_uri(type_)
                 _add_uri_namespace_to_prefixes(type_, prefixes)
 
                 if property_name not in data_model[class_name]["properties"]:

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/rules/importers/_owl2rules/_owl2classes.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from rdflib import OWL, Graph
 
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 
 def parse_owl_classes(graph: Graph, make_compliant: bool = False, language: str = "en") -> pd.DataFrame:
@@ -84,10 +84,10 @@ def _parse_raw_dataframe(query_results: list[tuple]) -> pd.DataFrame:
     df.replace(np.nan, "", regex=True, inplace=True)
 
     df.Source = df.Class
-    df.Class = df.Class.apply(lambda x: remove_namespace(x))
+    df.Class = df.Class.apply(lambda x: remove_namespace_from_uri(x))
     df["Source Entity Name"] = df.Class
     df["Match"] = len(df) * ["exact"]
-    df["Parent Class"] = df["Parent Class"].apply(lambda x: remove_namespace(x))
+    df["Parent Class"] = df["Parent Class"].apply(lambda x: remove_namespace_from_uri(x))
 
     return df
 

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/legacy/rules/importers/_owl2rules/_owl2properties.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from rdflib import Graph
 
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 from ._owl2classes import _data_type_property_class, _object_property_class, _thing_class
 
@@ -92,12 +92,12 @@ def _parse_raw_dataframe(query_results: list[tuple]) -> pd.DataFrame:
     df.replace(np.nan, "", regex=True, inplace=True)
 
     df.Source = df.Property
-    df.Class = df.Class.apply(lambda x: remove_namespace(x))
-    df.Property = df.Property.apply(lambda x: remove_namespace(x))
-    df.Type = df.Type.apply(lambda x: remove_namespace(x))
+    df.Class = df.Class.apply(lambda x: remove_namespace_from_uri(x))
+    df.Property = df.Property.apply(lambda x: remove_namespace_from_uri(x))
+    df.Type = df.Type.apply(lambda x: remove_namespace_from_uri(x))
     df["Source Entity Name"] = df.Property
     df["Match Type"] = len(df) * ["exact"]
-    df["_property_type"] = df["_property_type"].apply(lambda x: remove_namespace(x))
+    df["_property_type"] = df["_property_type"].apply(lambda x: remove_namespace_from_uri(x))
 
     return df
 

cognite_neat-0.85.7/cognite/neat/rules/analysis/__init__.py

@@ -0,0 +1,6 @@
+from ._information_rules import (
+    AssetArchitectRulesAnalysis,
+    InformationArchitectRulesAnalysis,
+)
+
+__all__ = ["InformationArchitectRulesAnalysis", "AssetArchitectRulesAnalysis"]

{cognite_neat-0.85.5 → cognite_neat-0.85.7}/cognite/neat/rules/analysis/_base.py

@@ -1,15 +1,9 @@
-import sys
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.models.entities import ClassEntity
 
-if sys.version_info >= (3, 11):
-    from enum import StrEnum
-else:
-    from backports.strenum import StrEnum
-
 T_Rules = TypeVar("T_Rules", bound=Rules)
 
 
@@ -17,9 +11,3 @@ class BaseAnalysis(ABC, Generic[T_Rules]):
     @abstractmethod
     def subset_rules(self, desired_classes: set[ClassEntity]) -> T_Rules:
         raise NotImplementedError()
-
-
-class DataModelingScenario(StrEnum):
-    from_scratch = "from scratch"
-    build_solution = "build solution"
-    extend_reference = "extend reference"