cognite-neat 0.98.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

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

@@ -1,39 +1,21 @@
 from collections import defaultdict
 from collections.abc import Callable, Iterable, Set
-from datetime import datetime, timezone
 from pathlib import Path
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes import Relationship, RelationshipList
-from rdflib import RDF, Literal, Namespace
+from rdflib import Namespace
 
-from cognite.neat._shared import Triple
 from cognite.neat._utils.auxiliary import create_sha256_hash
 
-from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
-from ._labels import LabelsExtractor
+from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix, T_CogniteResource
 
 
 class RelationshipsExtractor(ClassicCDFBaseExtractor[Relationship]):
-    """Extract data from Cognite Data Fusions Relationships into Neat.
-
-    Args:
-        items (Iterable[Relationship]): An iterable of items.
-        namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
-        to_type (Callable[[Relationship], str | None], optional): A function to convert an item to a type.
-            Defaults to None. If None or if the function returns None, the asset will be set to the default type.
-        total (int, optional): The total number of items to load. If passed, you will get a progress bar if rich
-            is installed. Defaults to None.
-        limit (int, optional): The maximal number of items to load. Defaults to None. This is typically used for
-            testing setup of the extractor. For example, if you are extracting 100 000 assets, you might want to
-            limit the extraction to 1000 assets to test the setup.
-        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
-            a JSON string.
-        skip_metadata_values (set[str] | frozenset[str] | None, optional): If you are unpacking metadata, then
-           values in this set will be skipped.
-    """
+    """Extract data from Cognite Data Fusions Relationships into Neat."""
 
     _default_rdf_type = "Relationship"
+    _instance_id_prefix = InstanceIdPrefix.relationship
 
     def __init__(
         self,
@@ -44,6 +26,8 @@ class RelationshipsExtractor(ClassicCDFBaseExtractor[Relationship]):
         limit: int | None = None,
         unpack_metadata: bool = True,
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
     ):
         super().__init__(
             items,
@@ -53,6 +37,8 @@ class RelationshipsExtractor(ClassicCDFBaseExtractor[Relationship]):
             limit=limit,
             unpack_metadata=unpack_metadata,
             skip_metadata_values=skip_metadata_values,
+            camel_case=camel_case,
+            as_write=as_write,
         )
         # This is used by the ClassicExtractor to log the target nodes, such
         # that it can extract them.
@@ -61,167 +47,30 @@ class RelationshipsExtractor(ClassicCDFBaseExtractor[Relationship]):
         self._target_external_ids_by_type: dict[InstanceIdPrefix, set[str]] = defaultdict(set)
 
     @classmethod
-    def from_dataset(
+    def _from_dataset(
         cls,
         client: CogniteClient,
         data_set_external_id: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Relationship], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
-        return cls(
-            client.relationships(data_set_external_ids=data_set_external_id),
-            namespace=namespace,
-            to_type=to_type,
-            limit=limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
+    ) -> tuple[int | None, Iterable[Relationship]]:
+        items = client.relationships(data_set_external_ids=data_set_external_id)
+        return None, items
 
     @classmethod
-    def from_file(
-        cls,
-        file_path: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Relationship], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
-        relationships = RelationshipList.load(Path(file_path).read_text())
-        return cls(
-            relationships,
-            namespace=namespace,
-            total=len(relationships),
-            to_type=to_type,
-            limit=limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
-
-    def _item2triples(self, relationship: Relationship) -> list[Triple]:
-        """Converts an asset to triples."""
+    def _from_hierarchy(
+        cls, client: CogniteClient, root_asset_external_id: str
+    ) -> tuple[int | None, Iterable[T_CogniteResource]]:
+        raise NotImplementedError("Relationships do not have a hierarchy.")
 
-        if relationship.external_id and relationship.source_external_id and relationship.target_external_id:
-            if self._log_target_nodes and relationship.target_type and relationship.target_external_id:
-                self._target_external_ids_by_type[InstanceIdPrefix.from_str(relationship.target_type)].add(
-                    relationship.target_external_id
-                )
-
-            # relationships do not have an internal id, so we generate one
-            id_ = self.namespace[f"{InstanceIdPrefix.relationship}{create_sha256_hash(relationship.external_id)}"]
-
-            type_ = self._get_rdf_type(relationship)
-            # Set rdf type
-            triples: list[Triple] = [(id_, RDF.type, self.namespace[type_])]
-
-            # Set source and target types
-            if source_type := relationship.source_type:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.source_type,
-                        self.namespace[source_type.title()],
-                    )
-                )
-
-            if target_type := relationship.target_type:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.target_type,
-                        self.namespace[target_type.title()],
-                    )
-                )
-
-            # Create attributes
-
-            triples.append((id_, self.namespace.external_id, Literal(relationship.external_id)))
-
-            triples.append(
-                (
-                    id_,
-                    self.namespace.source_external_id,
-                    Literal(relationship.source_external_id),
-                )
-            )
-
-            triples.append(
-                (
-                    id_,
-                    self.namespace.target_external_id,
-                    Literal(relationship.target_external_id),
-                )
-            )
-
-            if relationship.start_time:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.start_time,
-                        Literal(datetime.fromtimestamp(relationship.start_time / 1000, timezone.utc)),
-                    )
-                )
-
-            if relationship.end_time:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.end_time,
-                        Literal(datetime.fromtimestamp(relationship.end_time / 1000, timezone.utc)),
-                    )
-                )
-
-            if relationship.created_time:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.created_time,
-                        Literal(datetime.fromtimestamp(relationship.created_time / 1000, timezone.utc)),
-                    )
-                )
-
-            if relationship.last_updated_time:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.last_updated_time,
-                        Literal(datetime.fromtimestamp(relationship.last_updated_time / 1000, timezone.utc)),
-                    )
-                )
-
-            if relationship.confidence:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.confidence,
-                        Literal(relationship.confidence),
-                    )
-                )
-
-            if relationship.labels:
-                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_,
-                            self.namespace.label,
-                            self.namespace[f"{InstanceIdPrefix.label}{LabelsExtractor._label_id(label)}"],
-                        )
-                    )
+    @classmethod
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[Relationship]]:
+        relationships = RelationshipList.load(Path(file_path).read_text())
+        return len(relationships), relationships
 
-            # Create connection
-            if relationship.data_set_id:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.dataset,
-                        self.namespace[f"{InstanceIdPrefix.data_set}{relationship.data_set_id}"],
-                    )
+    def _fallback_id(self, item: Relationship) -> str | None:
+        if item.external_id and item.source_external_id and item.target_external_id:
+            if self._log_target_nodes and item.target_type and item.target_external_id:
+                self._target_external_ids_by_type[InstanceIdPrefix.from_str(item.target_type)].add(
+                    item.target_external_id
                 )
-
-            return triples
-        return []
+            return create_sha256_hash(item.external_id)
+        return None

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

@@ -1,162 +1,37 @@
-from collections.abc import Callable, Set
-from datetime import datetime, timezone
+from collections.abc import Iterable
 from pathlib import Path
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes import Sequence, SequenceFilter, SequenceList
-from rdflib import RDF, Literal, Namespace
 
-from cognite.neat._shared import Triple
-
-from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
+from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
 
 
 class SequencesExtractor(ClassicCDFBaseExtractor[Sequence]):
-    """Extract data from Cognite Data Fusions Sequences into Neat.
-
-    Args:
-        items (Iterable[Sequence]): An iterable of items.
-        namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
-        to_type (Callable[[Sequence], str | None], optional): A function to convert an item to a type.
-            Defaults to None. If None or if the function returns None, the asset will be set to the default type.
-        total (int, optional): The total number of items to load. If passed, you will get a progress bar if rich
-            is installed. Defaults to None.
-        limit (int, optional): The maximal number of items to load. Defaults to None. This is typically used for
-            testing setup of the extractor. For example, if you are extracting 100 000 assets, you might want to
-            limit the extraction to 1000 assets to test the setup.
-        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
-            a JSON string.
-        skip_metadata_values (set[str] | frozenset[str] | None, optional): If you are unpacking metadata, then
-           values in this set will be skipped.
-    """
+    """Extract data from Cognite Data Fusions Sequences into Neat."""
 
     _default_rdf_type = "Sequence"
+    _instance_id_prefix = InstanceIdPrefix.sequence
 
     @classmethod
-    def from_dataset(
-        cls,
-        client: CogniteClient,
-        data_set_external_id: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Sequence], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_dataset(cls, client: CogniteClient, data_set_external_id: str) -> tuple[int | None, Iterable[Sequence]]:
         total = client.sequences.aggregate_count(
             filter=SequenceFilter(data_set_ids=[{"externalId": data_set_external_id}])
         )
-        return cls(
-            client.sequences(data_set_external_ids=data_set_external_id),
-            total=total,
-            namespace=namespace,
-            to_type=to_type,
-            limit=limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
+        items = client.sequences(data_set_external_ids=data_set_external_id)
+        return total, items
 
     @classmethod
-    def from_hierarchy(
-        cls,
-        client: CogniteClient,
-        root_asset_external_id: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Sequence], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_hierarchy(
+        cls, client: CogniteClient, root_asset_external_id: str
+    ) -> tuple[int | None, Iterable[Sequence]]:
         total = client.sequences.aggregate_count(
             filter=SequenceFilter(asset_subtree_ids=[{"externalId": root_asset_external_id}])
         )
-
-        return cls(
-            client.sequences(asset_subtree_external_ids=[root_asset_external_id]),
-            namespace,
-            to_type,
-            total,
-            limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
+        items = client.sequences(asset_subtree_external_ids=[root_asset_external_id])
+        return total, items
 
     @classmethod
-    def from_file(
-        cls,
-        file_path: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Sequence], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[Sequence]]:
         sequences = SequenceList.load(Path(file_path).read_text())
-        return cls(
-            sequences,
-            total=len(sequences),
-            namespace=namespace,
-            to_type=to_type,
-            limit=limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
-
-    def _item2triples(self, sequence: Sequence) -> list[Triple]:
-        id_ = self.namespace[f"{InstanceIdPrefix.sequence}{sequence.id}"]
-
-        type_ = self._get_rdf_type(sequence)
-        # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, self.namespace[type_])]
-
-        # Create attributes
-
-        if sequence.external_id:
-            triples.append((id_, self.namespace.external_id, Literal(sequence.external_id)))
-
-        if sequence.name:
-            triples.append((id_, self.namespace.name, Literal(sequence.name)))
-
-        if sequence.metadata:
-            triples.extend(self._metadata_to_triples(id_, sequence.metadata))
-
-        if sequence.description:
-            triples.append((id_, self.namespace.description, Literal(sequence.description)))
-
-        if sequence.created_time:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.created_time,
-                    Literal(datetime.fromtimestamp(sequence.created_time / 1000, timezone.utc)),
-                )
-            )
-
-        if sequence.last_updated_time:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.last_updated_time,
-                    Literal(datetime.fromtimestamp(sequence.last_updated_time / 1000, timezone.utc)),
-                )
-            )
-
-        if sequence.data_set_id:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.data_set_id,
-                    self.namespace[f"{InstanceIdPrefix.data_set}{sequence.data_set_id}"],
-                )
-            )
-
-        if sequence.asset_id:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.asset,
-                    self.namespace[f"{InstanceIdPrefix.asset}{sequence.asset_id}"],
-                )
-            )
-
-        return triples
+        return len(sequences), sequences

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

@@ -1,199 +1,41 @@
-from collections.abc import Callable, Set
-from datetime import datetime, timezone
+from collections.abc import Iterable
 from pathlib import Path
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes import TimeSeries, TimeSeriesFilter, TimeSeriesList
-from pydantic import AnyHttpUrl, ValidationError
-from rdflib import RDF, Literal, Namespace, URIRef
 
-from cognite.neat._shared import Triple
-
-from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
+from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
 
 
 class TimeSeriesExtractor(ClassicCDFBaseExtractor[TimeSeries]):
-    """Extract data from Cognite Data Fusions TimeSeries into Neat.
-
-    Args:
-        items (Iterable[TimeSeries]): An iterable of items.
-        namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
-        to_type (Callable[[TimeSeries], str | None], optional): A function to convert an item to a type.
-            Defaults to None. If None or if the function returns None, the asset will be set to the default type.
-        total (int, optional): The total number of items to load. If passed, you will get a progress bar if rich
-            is installed. Defaults to None.
-        limit (int, optional): The maximal number of items to load. Defaults to None. This is typically used for
-            testing setup of the extractor. For example, if you are extracting 100 000 assets, you might want to
-            limit the extraction to 1000 assets to test the setup.
-        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
-            a JSON string.
-        skip_metadata_values (set[str] | frozenset[str] | None, optional): If you are unpacking metadata, then
-           values in this set will be skipped.
-    """
+    """Extract data from Cognite Data Fusions TimeSeries into Neat."""
 
     _default_rdf_type = "TimeSeries"
+    _instance_id_prefix = InstanceIdPrefix.time_series
 
     @classmethod
-    def from_dataset(
+    def _from_dataset(
         cls,
         client: CogniteClient,
         data_set_external_id: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[TimeSeries], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    ) -> tuple[int | None, Iterable[TimeSeries]]:
         total = client.time_series.aggregate_count(
             filter=TimeSeriesFilter(data_set_ids=[{"externalId": data_set_external_id}])
         )
-
-        return cls(
-            client.time_series(data_set_external_ids=data_set_external_id),
-            total=total,
-            namespace=namespace,
-            to_type=to_type,
-            limit=limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
+        items = client.time_series(data_set_external_ids=data_set_external_id)
+        return total, items
 
     @classmethod
-    def from_hierarchy(
-        cls,
-        client: CogniteClient,
-        root_asset_external_id: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[TimeSeries], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_hierarchy(
+        cls, client: CogniteClient, root_asset_external_id: str
+    ) -> tuple[int | None, Iterable[TimeSeries]]:
         total = client.time_series.aggregate_count(
             filter=TimeSeriesFilter(asset_subtree_ids=[{"externalId": root_asset_external_id}])
         )
-
-        return cls(
-            client.time_series(asset_external_ids=[root_asset_external_id]),
-            namespace,
-            to_type,
-            total,
-            limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
+        items = client.time_series(asset_subtree_external_ids=root_asset_external_id)
+        return total, items
 
     @classmethod
-    def from_file(
-        cls,
-        file_path: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[TimeSeries], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[TimeSeries]]:
         timeseries = TimeSeriesList.load(Path(file_path).read_text())
-        return cls(
-            timeseries,
-            total=len(timeseries),
-            namespace=namespace,
-            to_type=to_type,
-            limit=limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
-
-    def _item2triples(self, timeseries: TimeSeries) -> list[Triple]:
-        id_ = self.namespace[f"{InstanceIdPrefix.time_series}{timeseries.id}"]
-
-        # Set rdf type
-        type_ = self._get_rdf_type(timeseries)
-        triples: list[Triple] = [(id_, RDF.type, self.namespace[type_])]
-
-        # Create attributes
-        if timeseries.external_id:
-            triples.append((id_, self.namespace.external_id, Literal(timeseries.external_id)))
-
-        if timeseries.name:
-            triples.append((id_, self.namespace.name, Literal(timeseries.name)))
-
-        if timeseries.is_string:
-            triples.append((id_, self.namespace.is_string, Literal(timeseries.is_string)))
-
-        if timeseries.metadata:
-            triples.extend(self._metadata_to_triples(id_, timeseries.metadata))
-
-        if timeseries.unit:
-            triples.append((id_, self.namespace.unit, Literal(timeseries.unit)))
-
-        if self.namespace.is_step:
-            triples.append((id_, self.namespace.is_step, Literal(timeseries.is_step)))
-
-        if timeseries.description:
-            triples.append((id_, self.namespace.description, Literal(timeseries.description)))
-
-        if timeseries.security_categories:
-            for category in timeseries.security_categories:
-                triples.append((id_, self.namespace.security_categories, Literal(category)))
-
-        if timeseries.created_time:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.created_time,
-                    Literal(datetime.fromtimestamp(timeseries.created_time / 1000, timezone.utc)),
-                )
-            )
-
-        if timeseries.last_updated_time:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.last_updated_time,
-                    Literal(datetime.fromtimestamp(timeseries.last_updated_time / 1000, timezone.utc)),
-                )
-            )
-
-        if 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_,
-                        self.namespace.unit_external_id,
-                        URIRef(str(AnyHttpUrl(timeseries.unit_external_id))),
-                    )
-                )
-            except ValidationError:
-                triples.append(
-                    (
-                        id_,
-                        self.namespace.unit_external_id,
-                        Literal(timeseries.unit_external_id),
-                    )
-                )
-
-        if timeseries.data_set_id:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.dataset,
-                    self.namespace[f"{InstanceIdPrefix.data_set}{timeseries.data_set_id}"],
-                )
-            )
-
-        if timeseries.asset_id:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.asset,
-                    self.namespace[f"{InstanceIdPrefix.asset}{timeseries.asset_id}"],
-                )
-            )
-
-        return triples
+        return len(timeseries), timeseries

cognite/neat/_graph/extractors/_rdf_file.py

@@ -1,12 +1,12 @@
 from collections.abc import Iterable
 from pathlib import Path
-from typing import cast
+from typing import get_args
 
 from rdflib import URIRef
 from rdflib.util import guess_format
 
 from cognite.neat._constants import DEFAULT_BASE_URI
-from cognite.neat._graph._shared import rdflib_to_mime_types
+from cognite.neat._graph._shared import RDFTypes
 from cognite.neat._graph.extractors._base import BaseExtractor
 from cognite.neat._issues._base import IssueList
 from cognite.neat._issues.errors import FileNotFoundNeatError, FileTypeUnexpectedError
@@ -29,19 +29,18 @@ class RdfFileExtractor(BaseExtractor):
         issue_list: IssueList | None = None,
     ):
         self.issue_list = issue_list or IssueList(title=f"{filepath.name}")
-
-        self.filepath = filepath
-        self.mime_type = rdflib_to_mime_types(cast(str, guess_format(str(self.filepath))))
         self.base_uri = base_uri
+        self.filepath = filepath
+        self.format = guess_format(str(self.filepath))
 
         if not self.filepath.exists():
             self.issue_list.append(FileNotFoundNeatError(self.filepath))
 
-        if not self.mime_type:
+        if not self.format:
             self.issue_list.append(
                 FileTypeUnexpectedError(
                     self.filepath,
-                    frozenset([".rdf", ".ttl", ".nt", ".n3", ".owl", ".nq", ".trig"]),
+                    frozenset(get_args(RDFTypes)),
                 )
             )