cognite-neat 0.85.6__py3-none-any.whl → 0.85.8__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/rules/exporters/_rules2ontology.py

@@ -20,7 +20,7 @@ from cognite.neat.rules.models.information import (
     InformationProperty,
     InformationRules,
 )
-from cognite.neat.utils.utils import generate_exception_report, remove_namespace
+from cognite.neat.utils.utils import generate_exception_report, remove_namespace_from_uri
 
 from ._base import BaseExporter
 from ._validation import are_properties_redefined
@@ -350,7 +350,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,
@@ -362,7 +362,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,
@@ -374,7 +374,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,
@@ -385,7 +385,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,
             )
@@ -395,7 +395,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/rules/importers/_inference2rules.py

@@ -17,7 +17,7 @@ from cognite.neat.rules.models.information import (
     InformationMetadata,
     InformationRulesInput,
 )
-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
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -36,28 +36,36 @@ class InferenceImporter(BaseImporter):
     """Infers rules from a triple store.
 
     Rules inference through analysis of knowledge graph provided in various formats.
-    Use the factory methods to create an triples store from sources such as
+    Use the factory methods to create a triple store from sources such as
     RDF files, JSON files, YAML files, XML files, or directly from a graph store.
 
     Args:
         issue_list: Issue list to store issues
         graph: Knowledge graph
         max_number_of_instance: Maximum number of instances to be used in inference
+        prefix: Prefix to be used for the inferred model
     """
 
-    def __init__(self, issue_list: IssueList, graph: Graph, max_number_of_instance: int = -1):
+    def __init__(
+        self, issue_list: IssueList, graph: Graph, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> None:
         self.issue_list = issue_list
         self.graph = graph
         self.max_number_of_instance = max_number_of_instance
+        self.prefix = prefix
 
     @classmethod
-    def from_graph_store(cls, store: NeatGraphStore, max_number_of_instance: int = -1):
+    def from_graph_store(
+        cls, store: NeatGraphStore, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         issue_list = IssueList(title="Inferred from graph store")
 
-        return cls(issue_list, store.graph, max_number_of_instance=max_number_of_instance)
+        return cls(issue_list, store.graph, max_number_of_instance=max_number_of_instance, prefix=prefix)
 
     @classmethod
-    def from_rdf_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_rdf_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         issue_list = IssueList(title=f"'{filepath.name}'")
 
         graph = Graph()
@@ -66,18 +74,24 @@ class InferenceImporter(BaseImporter):
         except Exception:
             issue_list.append(issues.fileread.FileReadError(filepath))
 
-        return cls(issue_list, graph, max_number_of_instance=max_number_of_instance)
+        return cls(issue_list, graph, max_number_of_instance=max_number_of_instance, prefix=prefix)
 
     @classmethod
-    def from_json_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_json_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @classmethod
-    def from_yaml_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_yaml_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         raise NotImplementedError("YAML file format is not supported yet.")
 
     @classmethod
-    def from_xml_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_xml_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @overload
@@ -142,7 +156,7 @@ class InferenceImporter(BaseImporter):
         for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
             self._add_uri_namespace_to_prefixes(cast(URIRef, class_uri), prefixes)
 
-            if (class_id := remove_namespace(class_uri)) in classes:
+            if (class_id := remove_namespace_from_uri(class_uri)) in classes:
                 # handles cases when class id is already present in classes
                 class_id = f"{class_id}_{len(classes)+1}"
 
@@ -164,7 +178,7 @@ class InferenceImporter(BaseImporter):
                 for property_uri, occurrence, data_type_uri, object_type_uri in self.graph.query(  # type: ignore[misc]
                     INSTANCE_PROPERTIES_DEFINITION.replace("instance_id", instance)
                 ):  # type: ignore[misc]
-                    property_id = remove_namespace(property_uri)
+                    property_id = remove_namespace_from_uri(property_uri)
                     self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
                     value_type_uri = data_type_uri if data_type_uri else object_type_uri
 
@@ -173,7 +187,7 @@ class InferenceImporter(BaseImporter):
                         continue
 
                     self._add_uri_namespace_to_prefixes(cast(URIRef, value_type_uri), prefixes)
-                    value_type_id = remove_namespace(value_type_uri)
+                    value_type_id = remove_namespace_from_uri(value_type_uri)
                     id_ = f"{class_id}:{property_id}"
 
                     definition = {
@@ -239,8 +253,7 @@ class InferenceImporter(BaseImporter):
         if Namespace(get_namespace(URI)) not in prefixes.values():
             prefixes[f"prefix-{len(prefixes)+1}"] = Namespace(get_namespace(URI))
 
-    @classmethod
-    def _default_metadata(cls):
+    def _default_metadata(self):
         return InformationMetadata(
             name="Inferred Model",
             creator="NEAT",
@@ -248,7 +261,7 @@ class InferenceImporter(BaseImporter):
             created=datetime.now(),
             updated=datetime.now(),
             description="Inferred model from knowledge graph",
-            prefix="inferred",
+            prefix=self.prefix,
             namespace=DEFAULT_NAMESPACE,
         )
 
@@ -262,12 +275,9 @@ class InferenceImporter(BaseImporter):
 
     @classmethod
     def _read_value_type_occurrence_from_comment(cls, value_type: str, comment: str) -> int:
-        return int(
-            cast(
-                re.Match,
-                re.search(
-                    rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
-                    comment,
-                ),
-            ).group(1)
-        )
+        if result := re.search(
+            rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
+            comment,
+        ):
+            return int(result.group(1))
+        return 0

cognite/neat/rules/importers/_owl2rules/_owl2classes.py

@@ -5,7 +5,7 @@ import pandas as pd
 from rdflib import OWL, Graph
 
 from cognite.neat.rules.models._base import MatchType
-from cognite.neat.utils.utils import remove_namespace
+from cognite.neat.utils.utils import remove_namespace_from_uri
 
 
 def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
@@ -68,10 +68,10 @@ def _parse_raw_dataframe(query_results: list[tuple]) -> pd.DataFrame:
     df.replace(np.nan, "", regex=True, inplace=True)
 
     df.Reference = 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["Match Type"] = len(df) * [MatchType.exact]
     df["Comment"] = len(df) * [None]
-    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/rules/importers/_owl2rules/_owl2properties.py

@@ -5,7 +5,7 @@ import pandas as pd
 from rdflib import Graph
 
 from cognite.neat.rules.models._base import MatchType
-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
 
@@ -82,12 +82,12 @@ def _parse_raw_dataframe(query_results: list[tuple]) -> pd.DataFrame:
     df.replace(np.nan, "", regex=True, inplace=True)
 
     df.Reference = df.Property
-    df.Class = df.Class.apply(lambda x: remove_namespace(x))
-    df.Property = df.Property.apply(lambda x: remove_namespace(x))
-    df["Value Type"] = df["Value 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["Value Type"] = df["Value Type"].apply(lambda x: remove_namespace_from_uri(x))
     df["Match Type"] = len(df) * [MatchType.exact]
     df["Comment"] = len(df) * [None]
-    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/utils/__init__.py

@@ -1,3 +1,3 @@
-from .utils import remove_namespace
+from .utils import remove_namespace_from_uri
 
-__all__ = ["remove_namespace"]
+__all__ = ["remove_namespace_from_uri"]