cognite-neat 0.85.7__py3-none-any.whl → 0.85.9__py3-none-any.whl

cognite/neat/graph/extractors/_classic_cdf/_relationships.py

@@ -38,7 +38,11 @@ class RelationshipsExtractor(BaseExtractor):
         namespace: Namespace | None = None,
     ):
         return cls(
-            cast(Iterable[Relationship], client.relationships(data_set_external_ids=data_set_external_id)), namespace
+            cast(
+                Iterable[Relationship],
+                client.relationships(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
         )
 
     @classmethod
@@ -48,26 +52,25 @@ class RelationshipsExtractor(BaseExtractor):
     def extract(self) -> Iterable[Triple]:
         """Extracts an asset with the given asset_id."""
         for relationship in self.relationships:
-            yield from self._relationship2triples(relationship, self.namespace)
+            yield from self._relationship2triples(relationship)
 
-    @classmethod
-    def _relationship2triples(cls, relationship: Relationship, namespace: Namespace) -> list[Triple]:
+    def _relationship2triples(self, relationship: Relationship) -> list[Triple]:
         """Converts an asset to triples."""
 
         if relationship.external_id and relationship.source_external_id and relationship.target_external_id:
             # relationships do not have an internal id, so we generate one
-            id_ = namespace[f"Relationship_{create_sha256_hash(relationship.external_id)}"]
+            id_ = self.namespace[f"Relationship_{create_sha256_hash(relationship.external_id)}"]
 
             # Set rdf type
-            triples: list[Triple] = [(id_, RDF.type, namespace["Relationship"])]
+            triples: list[Triple] = [(id_, RDF.type, self.namespace["Relationship"])]
 
             # Set source and target types
             if source_type := relationship.source_type:
                 triples.append(
                     (
                         id_,
-                        namespace.source_type,
-                        namespace[source_type.title()],
+                        self.namespace.source_type,
+                        self.namespace[source_type.title()],
                     )
                 )
 
@@ -75,19 +78,19 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.target_type,
-                        namespace[target_type.title()],
+                        self.namespace.target_type,
+                        self.namespace[target_type.title()],
                     )
                 )
 
             # Create attributes
 
-            triples.append((id_, namespace.external_id, Literal(relationship.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(relationship.external_id)))
 
             triples.append(
                 (
                     id_,
-                    namespace.source_external_id,
+                    self.namespace.source_external_id,
                     Literal(relationship.source_external_id),
                 )
             )
@@ -95,7 +98,7 @@ class RelationshipsExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.target_external_id,
+                    self.namespace.target_external_id,
                     Literal(relationship.target_external_id),
                 )
             )
@@ -104,7 +107,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.start_time,
+                        self.namespace.start_time,
                         Literal(datetime.fromtimestamp(relationship.start_time / 1000, timezone.utc)),
                     )
                 )
@@ -113,7 +116,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.end_time,
+                        self.namespace.end_time,
                         Literal(datetime.fromtimestamp(relationship.end_time / 1000, timezone.utc)),
                     )
                 )
@@ -122,7 +125,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.created_time,
+                        self.namespace.created_time,
                         Literal(datetime.fromtimestamp(relationship.created_time / 1000, timezone.utc)),
                     )
                 )
@@ -131,7 +134,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.last_updated_time,
+                        self.namespace.last_updated_time,
                         Literal(datetime.fromtimestamp(relationship.last_updated_time / 1000, timezone.utc)),
                     )
                 )
@@ -140,7 +143,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.confidence,
+                        self.namespace.confidence,
                         Literal(relationship.confidence),
                     )
                 )
@@ -149,11 +152,23 @@ class RelationshipsExtractor(BaseExtractor):
                 for label in relationship.labels:
                     # external_id can create ill-formed URIs, so we create websafe URIs
                     # since labels do not have internal ids, we use the external_id as the id
-                    triples.append((id_, namespace.label, namespace[f"Label_{quote(label.dump()['externalId'])}"]))
+                    triples.append(
+                        (
+                            id_,
+                            self.namespace.label,
+                            self.namespace[f"Label_{quote(label.dump()['externalId'])}"],
+                        )
+                    )
 
             # Create connection
             if relationship.data_set_id:
-                triples.append((id_, namespace.dataset, namespace[f"Dataset_{relationship.data_set_id}"]))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.dataset,
+                        self.namespace[f"Dataset_{relationship.data_set_id}"],
+                    )
+                )
 
             return triples
         return []

cognite/neat/graph/extractors/_classic_cdf/_sequences.py

@@ -1,3 +1,4 @@
+import json
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
@@ -20,15 +21,19 @@ class SequencesExtractor(BaseExtractor):
     Args:
         sequence (Iterable[Sequence]): An iterable of sequences.
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
     """
 
     def __init__(
         self,
         sequence: Iterable[Sequence],
         namespace: Namespace | None = None,
+        unpack_metadata: bool = True,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.sequence = sequence
+        self.unpack_metadata = unpack_metadata
 
     @classmethod
     def from_dataset(
@@ -36,50 +41,71 @@ class SequencesExtractor(BaseExtractor):
         client: CogniteClient,
         data_set_external_id: str,
         namespace: Namespace | None = None,
+        unpack_metadata: bool = True,
     ):
-        return cls(cast(Iterable[Sequence], client.sequences(data_set_external_ids=data_set_external_id)), namespace)
+        return cls(
+            cast(
+                Iterable[Sequence],
+                client.sequences(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
+            unpack_metadata,
+        )
 
     @classmethod
-    def from_file(cls, file_path: str, namespace: Namespace | None = None):
-        return cls(SequenceList.load(Path(file_path).read_text()), namespace)
+    def from_file(
+        cls,
+        file_path: str,
+        namespace: Namespace | None = None,
+        unpack_metadata: bool = True,
+    ):
+        return cls(SequenceList.load(Path(file_path).read_text()), namespace, unpack_metadata)
 
     def extract(self) -> Iterable[Triple]:
         """Extract sequences as triples."""
         for sequence in self.sequence:
-            yield from self._sequence2triples(sequence, self.namespace)
+            yield from self._sequence2triples(sequence)
 
-    @classmethod
-    def _sequence2triples(cls, sequence: Sequence, namespace: Namespace) -> list[Triple]:
-        id_ = namespace[f"Sequence_{sequence.id}"]
+    def _sequence2triples(self, sequence: Sequence) -> list[Triple]:
+        id_ = self.namespace[f"Sequence_{sequence.id}"]
 
         # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, namespace.Sequence)]
+        triples: list[Triple] = [(id_, RDF.type, self.namespace.Sequence)]
 
         # Create attributes
 
         if sequence.external_id:
-            triples.append((id_, namespace.external_id, Literal(sequence.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(sequence.external_id)))
 
         if sequence.name:
-            triples.append((id_, namespace.name, Literal(sequence.name)))
+            triples.append((id_, self.namespace.name, Literal(sequence.name)))
 
         if sequence.metadata:
-            for key, value in sequence.metadata.items():
-                if value:
-                    type_aware_value = string_to_ideal_type(value)
-                    try:
-                        triples.append((id_, namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
-                    except ValidationError:
-                        triples.append((id_, namespace[key], Literal(type_aware_value)))
+            if self.unpack_metadata:
+                for key, value in sequence.metadata.items():
+                    if value:
+                        type_aware_value = string_to_ideal_type(value)
+                        try:
+                            triples.append((id_, self.namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
+                        except ValidationError:
+                            triples.append((id_, self.namespace[key], Literal(type_aware_value)))
+            else:
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.metadata,
+                        Literal(json.dumps(sequence.metadata)),
+                    )
+                )
 
         if sequence.description:
-            triples.append((id_, namespace.description, Literal(sequence.description)))
+            triples.append((id_, self.namespace.description, Literal(sequence.description)))
 
         if sequence.created_time:
             triples.append(
                 (
                     id_,
-                    namespace.created_time,
+                    self.namespace.created_time,
                     Literal(datetime.fromtimestamp(sequence.created_time / 1000, timezone.utc)),
                 )
             )
@@ -88,15 +114,27 @@ class SequencesExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.last_updated_time,
+                    self.namespace.last_updated_time,
                     Literal(datetime.fromtimestamp(sequence.last_updated_time / 1000, timezone.utc)),
                 )
             )
 
         if sequence.data_set_id:
-            triples.append((id_, namespace.data_set_id, namespace[f"Dataset_{sequence.data_set_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.data_set_id,
+                    self.namespace[f"Dataset_{sequence.data_set_id}"],
+                )
+            )
 
         if sequence.asset_id:
-            triples.append((id_, namespace.asset, namespace[f"Asset_{sequence.asset_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.asset,
+                    self.namespace[f"Asset_{sequence.asset_id}"],
+                )
+            )
 
         return triples

cognite/neat/graph/extractors/_classic_cdf/_timeseries.py

@@ -1,3 +1,4 @@
+import json
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
@@ -20,15 +21,19 @@ class TimeSeriesExtractor(BaseExtractor):
     Args:
         timeseries (Iterable[TimeSeries]): An iterable of timeseries.
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
     """
 
     def __init__(
         self,
         timeseries: Iterable[TimeSeries],
         namespace: Namespace | None = None,
+        unpack_metadata: bool = True,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.timeseries = timeseries
+        self.unpack_metadata = unpack_metadata
 
     @classmethod
     def from_dataset(
@@ -36,65 +41,84 @@ class TimeSeriesExtractor(BaseExtractor):
         client: CogniteClient,
         data_set_external_id: str,
         namespace: Namespace | None = None,
+        unpack_metadata: bool = True,
     ):
         return cls(
-            cast(Iterable[TimeSeries], client.time_series(data_set_external_ids=data_set_external_id)), namespace
+            cast(
+                Iterable[TimeSeries],
+                client.time_series(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
+            unpack_metadata,
         )
 
     @classmethod
-    def from_file(cls, file_path: str, namespace: Namespace | None = None):
-        return cls(TimeSeriesList.load(Path(file_path).read_text()), namespace)
+    def from_file(
+        cls,
+        file_path: str,
+        namespace: Namespace | None = None,
+        unpack_metadata: bool = True,
+    ):
+        return cls(TimeSeriesList.load(Path(file_path).read_text()), namespace, unpack_metadata)
 
     def extract(self) -> Iterable[Triple]:
         """Extract timeseries as triples."""
         for timeseries in self.timeseries:
-            yield from self._timeseries2triples(timeseries, self.namespace)
+            yield from self._timeseries2triples(timeseries)
 
-    @classmethod
-    def _timeseries2triples(cls, timeseries: TimeSeries, namespace: Namespace) -> list[Triple]:
-        id_ = namespace[f"TimeSeries_{timeseries.id}"]
+    def _timeseries2triples(self, timeseries: TimeSeries) -> list[Triple]:
+        id_ = self.namespace[f"TimeSeries_{timeseries.id}"]
 
         # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, namespace.TimeSeries)]
+        triples: list[Triple] = [(id_, RDF.type, self.namespace.TimeSeries)]
 
         # Create attributes
 
         if timeseries.external_id:
-            triples.append((id_, namespace.external_id, Literal(timeseries.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(timeseries.external_id)))
 
         if timeseries.name:
-            triples.append((id_, namespace.name, Literal(timeseries.name)))
+            triples.append((id_, self.namespace.name, Literal(timeseries.name)))
 
         if timeseries.is_string:
-            triples.append((id_, namespace.is_string, Literal(timeseries.is_string)))
+            triples.append((id_, self.namespace.is_string, Literal(timeseries.is_string)))
 
         if timeseries.metadata:
-            for key, value in timeseries.metadata.items():
-                if value:
-                    type_aware_value = string_to_ideal_type(value)
-                    try:
-                        triples.append((id_, namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
-                    except ValidationError:
-                        triples.append((id_, namespace[key], Literal(type_aware_value)))
+            if self.unpack_metadata:
+                for key, value in timeseries.metadata.items():
+                    if value:
+                        type_aware_value = string_to_ideal_type(value)
+                        try:
+                            triples.append((id_, self.namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
+                        except ValidationError:
+                            triples.append((id_, self.namespace[key], Literal(type_aware_value)))
+            else:
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.metadata,
+                        Literal(json.dumps(timeseries.metadata)),
+                    )
+                )
 
         if timeseries.unit:
-            triples.append((id_, namespace.unit, Literal(timeseries.unit)))
+            triples.append((id_, self.namespace.unit, Literal(timeseries.unit)))
 
-        if namespace.is_step:
-            triples.append((id_, namespace.is_step, Literal(timeseries.is_step)))
+        if self.namespace.is_step:
+            triples.append((id_, self.namespace.is_step, Literal(timeseries.is_step)))
 
         if timeseries.description:
-            triples.append((id_, namespace.description, Literal(timeseries.description)))
+            triples.append((id_, self.namespace.description, Literal(timeseries.description)))
 
         if timeseries.security_categories:
             for category in timeseries.security_categories:
-                triples.append((id_, namespace.security_categories, Literal(category)))
+                triples.append((id_, self.namespace.security_categories, Literal(category)))
 
         if timeseries.created_time:
             triples.append(
                 (
                     id_,
-                    namespace.created_time,
+                    self.namespace.created_time,
                     Literal(datetime.fromtimestamp(timeseries.created_time / 1000, timezone.utc)),
                 )
             )
@@ -103,26 +127,50 @@ class TimeSeriesExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.last_updated_time,
+                    self.namespace.last_updated_time,
                     Literal(datetime.fromtimestamp(timeseries.last_updated_time / 1000, timezone.utc)),
                 )
             )
 
         if timeseries.legacy_name:
-            triples.append((id_, namespace.legacy_name, Literal(timeseries.legacy_name)))
+            triples.append((id_, self.namespace.legacy_name, Literal(timeseries.legacy_name)))
 
         # Create connections
         if timeseries.unit_external_id:
             # try to create connection to QUDT unit catalog
             try:
-                triples.append((id_, namespace.unit_external_id, URIRef(str(AnyHttpUrl(timeseries.unit_external_id)))))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.unit_external_id,
+                        URIRef(str(AnyHttpUrl(timeseries.unit_external_id))),
+                    )
+                )
             except ValidationError:
-                triples.append((id_, namespace.unit_external_id, Literal(timeseries.unit_external_id)))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.unit_external_id,
+                        Literal(timeseries.unit_external_id),
+                    )
+                )
 
         if timeseries.data_set_id:
-            triples.append((id_, namespace.dataset, namespace[f"Dataset_{timeseries.data_set_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.dataset,
+                    self.namespace[f"Dataset_{timeseries.data_set_id}"],
+                )
+            )
 
         if timeseries.asset_id:
-            triples.append((id_, namespace.asset, namespace[f"Asset_{timeseries.asset_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.asset,
+                    self.namespace[f"Asset_{timeseries.asset_id}"],
+                )
+            )
 
         return triples

cognite/neat/rules/importers/_inference2rules.py

@@ -17,7 +17,11 @@ from cognite.neat.rules.models.information import (
     InformationMetadata,
     InformationRulesInput,
 )
-from cognite.neat.utils.utils import get_namespace, remove_namespace_from_uri, 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 . }
@@ -25,9 +29,21 @@ ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
 
 INSTANCES_OF_CLASS_QUERY = """SELECT ?s WHERE { ?s a <class> . }"""
 
+INSTANCE_PROPERTIES_JSON_DEFINITION = """SELECT ?property (count(?property) as ?occurrence) ?dataType ?objectType
+                                    WHERE {<instance_id> ?property ?value .
+
+                                           BIND(IF(REGEX(?value, "^\u007b(.*)\u007d$"),
+                                           <http://www.w3.org/2001/XMLSchema#json>,
+                                           datatype(?value)) AS ?dataType)
+
+                                           OPTIONAL {?value rdf:type ?objectType .}}
+                                    GROUP BY ?property ?dataType ?objectType"""
+
 INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occurrence) ?dataType ?objectType
                                     WHERE {<instance_id> ?property ?value .
+
                                            BIND(datatype(?value) AS ?dataType)
+
                                            OPTIONAL {?value rdf:type ?objectType .}}
                                     GROUP BY ?property ?dataType ?objectType"""
 
@@ -36,28 +52,57 @@ 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
+        check_for_json_string: Check if values are JSON strings
     """
 
-    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",
+        check_for_json_string: bool = False,
+    ) -> None:
         self.issue_list = issue_list
         self.graph = graph
         self.max_number_of_instance = max_number_of_instance
+        self.prefix = prefix
+        self.check_for_json_string = check_for_json_string
 
     @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",
+        check_for_json_string: bool = False,
+    ) -> "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,
+            check_for_json_string=check_for_json_string,
+        )
 
     @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",
+        check_for_json_string: bool = False,
+    ) -> "InferenceImporter":
         issue_list = IssueList(title=f"'{filepath.name}'")
 
         graph = Graph()
@@ -66,18 +111,42 @@ 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,
+            check_for_json_string=check_for_json_string,
+        )
 
     @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",
+        check_for_json_string: bool = False,
+    ) -> "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",
+        check_for_json_string: bool = False,
+    ) -> "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",
+        check_for_json_string: bool = False,
+    ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @overload
@@ -135,6 +204,7 @@ class InferenceImporter(BaseImporter):
         properties: dict[str, dict] = {}
         prefixes: dict[str, Namespace] = PREFIXES.copy()
 
+        query = INSTANCE_PROPERTIES_JSON_DEFINITION if self.check_for_json_string else INSTANCE_PROPERTIES_DEFINITION
         # Adds default namespace to prefixes
         prefixes[self._default_metadata().prefix] = self._default_metadata().namespace
 
@@ -162,7 +232,7 @@ class InferenceImporter(BaseImporter):
                 + f" LIMIT {self.max_number_of_instance}"
             ):
                 for property_uri, occurrence, data_type_uri, object_type_uri in self.graph.query(  # type: ignore[misc]
-                    INSTANCE_PROPERTIES_DEFINITION.replace("instance_id", instance)
+                    query.replace("instance_id", instance)
                 ):  # type: ignore[misc]
                     property_id = remove_namespace_from_uri(property_uri)
                     self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
@@ -239,8 +309,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 +317,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 +331,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