cognite-toolkit 0.6.97__py3-none-any.whl → 0.7.39__py3-none-any.whl

cognite_toolkit/_cdf_tk/storageio/selectors/_base.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 
-from cognite_toolkit._cdf_tk.constants import DATA_MANIFEST_STEM
+from cognite_toolkit._cdf_tk.constants import DATA_MANIFEST_SUFFIX
 from cognite_toolkit._cdf_tk.utils.file import safe_write, sanitize_filename, yaml_safe_dump
 from cognite_toolkit._cdf_tk.utils.text import to_sentence_case
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
@@ -41,7 +41,7 @@ class DataSelector(SelectorObject, ABC):
             directory: The directory where the YAML file will be saved.
         """
 
-        filepath = directory / f"{sanitize_filename(str(self))}.{DATA_MANIFEST_STEM}.yaml"
+        filepath = directory / f"{sanitize_filename(str(self))}{DATA_MANIFEST_SUFFIX}"
         filepath.parent.mkdir(parents=True, exist_ok=True)
         safe_write(file=filepath, content=yaml_safe_dump(self.model_dump(mode="json", by_alias=True)), encoding="utf-8")
         return filepath
@@ -66,3 +66,15 @@ class DataSelector(SelectorObject, ABC):
     def __str__(self) -> str:
         # We want to force subclasses to implement __str__
         raise NotImplementedError()
+
+    def find_data_files(self, input_dir: Path, manifest_file: Path) -> list[Path]:
+        """Find data files in the specified input directory that match this selector.
+
+        Args:
+            input_dir: The directory to search for data files.
+            manifest_file: The manifest file that describes the data files.
+        Returns:
+            A list of Paths to the data files that match this selector.
+        """
+        data_file_prefix = manifest_file.name.removesuffix(DATA_MANIFEST_SUFFIX)
+        return [file for file in input_dir.glob(f"{data_file_prefix}*") if not file.name.endswith(DATA_MANIFEST_SUFFIX)]

cognite_toolkit/_cdf_tk/storageio/selectors/_canvas.py

@@ -1,3 +1,4 @@
+import hashlib
 from abc import ABC
 from typing import Literal
 
@@ -6,3 +7,16 @@ from ._base import DataSelector
 
 class CanvasSelector(DataSelector, ABC):
     kind: Literal["IndustrialCanvas"] = "IndustrialCanvas"
+
+
+class CanvasExternalIdSelector(CanvasSelector):
+    type: Literal["canvasExternalId"] = "canvasExternalId"
+    external_ids: tuple[str, ...]
+
+    @property
+    def group(self) -> str:
+        return "Canvas"
+
+    def __str__(self) -> str:
+        hash_ = hashlib.md5(",".join(sorted(self.external_ids)).encode()).hexdigest()[:8]
+        return f"canvas_count_{len(self.external_ids)}_hash_{hash_}"

cognite_toolkit/_cdf_tk/storageio/selectors/_charts.py

@@ -1,3 +1,4 @@
+import hashlib
 from abc import ABC
 from typing import Literal
 
@@ -29,3 +30,16 @@ class AllChartsSelector(ChartSelector):
 
     def __str__(self) -> str:
         return "all"
+
+
+class ChartExternalIdSelector(ChartSelector):
+    type: Literal["chartExternalId"] = "chartExternalId"
+    external_ids: tuple[str, ...]
+
+    @property
+    def group(self) -> str:
+        return "Charts"
+
+    def __str__(self) -> str:
+        hash_ = hashlib.md5(",".join(sorted(self.external_ids)).encode()).hexdigest()[:8]
+        return f"chart_count_{len(self.external_ids)}_hash_{hash_}"

cognite_toolkit/_cdf_tk/storageio/selectors/_datapoints.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from functools import cached_property
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, ClassVar, Literal
 
 from cognite.client._proto.data_points_pb2 import (
     InstanceId,
@@ -50,9 +50,12 @@ TimeSeriesColumn = Annotated[
 ]
 
 
-class DataPointsFileSelector(DataSelector):
+class DataPointsSelector(DataSelector, ABC):
+    kind: Literal["Datapoints"] = "Datapoints"
+
+
+class DataPointsFileSelector(DataPointsSelector):
     type: Literal["datapointsFile"] = "datapointsFile"
-    kind: Literal["datapoints"] = "datapoints"
 
     timestamp_column: str
     columns: tuple[TimeSeriesColumn, ...]
@@ -67,3 +70,20 @@ class DataPointsFileSelector(DataSelector):
     @cached_property
     def id_by_column(self) -> dict[str, Column]:
         return {col.column: col for col in self.columns}
+
+
+class DataPointsDataSetSelector(DataPointsSelector):
+    required_columns: ClassVar[frozenset[str]] = frozenset({"externalId", "timestamp", "value"})
+    type: Literal["datapointsDataSet"] = "datapointsDataSet"
+
+    data_set_external_id: str
+    start: int | str | None = None
+    end: int | str | None = None
+    data_type: Literal["numeric", "string"] = "numeric"
+
+    @property
+    def group(self) -> str:
+        return f"DataSet_{self.data_set_external_id}"
+
+    def __str__(self) -> str:
+        return f"datapoints_dataset_{self.data_set_external_id}"

cognite_toolkit/_cdf_tk/storageio/selectors/_file_content.py

@@ -0,0 +1,164 @@
+import hashlib
+import json
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+from pydantic import ConfigDict, Field, field_validator, model_validator
+
+from ._base import DataSelector, SelectorObject
+from ._instances import SelectedView
+
+FILENAME_VARIABLE = "$FILENAME"
+FILEPATH = "$FILEPATH"
+
+
+class FileContentSelector(DataSelector, ABC):
+    kind: Literal["FileContent"] = "FileContent"
+
+
+class FileTemplateSelector(FileContentSelector, ABC):
+    file_directory: Path
+
+    def find_data_files(self, input_dir: Path, manifest_file: Path) -> list[Path]:
+        file_dir = input_dir / self.file_directory
+        if not file_dir.is_dir():
+            return []
+        return [file for file in file_dir.iterdir() if file.is_file()]
+
+    @abstractmethod
+    def create_instance(self, filepath: Path) -> dict[str, Any]: ...
+
+
+class FileTemplate(SelectorObject):
+    model_config = ConfigDict(extra="allow")
+
+    def create_instance(self, filename: str) -> dict[str, Any]:
+        json_str = self.model_dump_json(by_alias=True)
+        return json.loads(json_str.replace(FILENAME_VARIABLE, filename))
+
+
+class FileMetadataTemplate(FileTemplate):
+    name: str
+    external_id: str
+
+    @field_validator("name", "external_id")
+    @classmethod
+    def _validate_filename_in_fields(cls, v: str) -> str:
+        if FILENAME_VARIABLE not in v:
+            raise ValueError(
+                f"{FILENAME_VARIABLE!s} must be present in 'name' and 'external_id' fields. "
+                f"This allows for dynamic substitution based on the file name."
+            )
+        return v
+
+
+class FileMetadataTemplateSelector(FileTemplateSelector):
+    type: Literal["fileMetadataTemplate"] = "fileMetadataTemplate"
+    template: FileMetadataTemplate
+
+    @property
+    def group(self) -> str:
+        return "FileMetadata"
+
+    def __str__(self) -> str:
+        return "metadata_template"
+
+    def create_instance(self, filepath: Path) -> dict[str, Any]:
+        return self.template.create_instance(filepath.name)
+
+
+class TemplateNodeId(SelectorObject):
+    space: str
+    external_id: str
+
+    @field_validator("external_id")
+    @classmethod
+    def _validate_filename_in_fields(cls, v: str) -> str:
+        if FILENAME_VARIABLE not in v:
+            raise ValueError(
+                f"{FILENAME_VARIABLE!s} must be present in 'external_id' field. "
+                f"This allows for dynamic substitution based on the file name."
+            )
+        return v
+
+
+class FileDataModelingTemplate(FileTemplate):
+    instance_id: TemplateNodeId
+    # Name is required for FileMetadata but not for CogniteFiles. This is the same default behavior as in CDF.
+    name: str = "untitled"
+
+    @model_validator(mode="before")
+    def _move_space_external_id(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if "space" in data and "externalId" in data:
+            data["instanceId"] = {"space": data.pop("space"), "externalId": data.pop("externalId")}
+        elif "space" in data and "external_id" in data:
+            data["instance_id"] = {"space": data.pop("space"), "external_id": data.pop("external_id")}
+        return data
+
+
+class FileDataModelingTemplateSelector(FileTemplateSelector):
+    type: Literal["fileDataModelingTemplate"] = "fileDataModelingTemplate"
+    view_id: SelectedView = SelectedView(space="cdf_cdm", external_id="CogniteFile", version="v1")
+    template: FileDataModelingTemplate
+
+    @property
+    def group(self) -> str:
+        return "FileDataModeling"
+
+    def __str__(self) -> str:
+        return "data_modeling_template"
+
+    def create_instance(self, filepath: Path) -> dict[str, Any]:
+        return self.template.create_instance(filepath.name)
+
+
+class FileIdentifierDefinition(SelectorObject):
+    id_type: str
+
+
+class FileInternalID(FileIdentifierDefinition):
+    id_type: Literal["internalId"] = "internalId"
+    internal_id: int = Field(alias="id")
+
+    def __str__(self) -> str:
+        return f"internalId_{self.internal_id}"
+
+
+class FileExternalID(FileIdentifierDefinition):
+    id_type: Literal["externalId"] = "externalId"
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"externalId_{self.external_id}"
+
+
+class NodeId(SelectorObject):
+    space: str
+    external_id: str
+
+
+class FileInstanceID(FileIdentifierDefinition):
+    id_type: Literal["instanceId"] = "instanceId"
+    instance_id: NodeId
+
+    def __str__(self) -> str:
+        return f"instanceId_{self.instance_id.space}_{self.instance_id.external_id}"
+
+
+FileIdentifier = Annotated[FileInstanceID | FileExternalID | FileInternalID, Field(discriminator="id_type")]
+
+
+class FileIdentifierSelector(FileContentSelector):
+    type: Literal["fileIdentifier"] = "fileIdentifier"
+    file_directory: str = "file_content"
+    use_metadata_directory: bool = True
+    identifiers: tuple[FileIdentifier, ...]
+
+    @property
+    def group(self) -> str:
+        return "Files"
+
+    def __str__(self) -> str:
+        hash_ = hashlib.md5(",".join(sorted(str(self.identifiers))).encode()).hexdigest()[:8]
+        return f"file_{len(self.identifiers)}_identifiers_{hash_}"

cognite_toolkit/_cdf_tk/storageio/selectors/_three_d.py

@@ -0,0 +1,34 @@
+import hashlib
+from abc import ABC
+from typing import Literal
+
+from ._base import DataSelector
+
+
+class ThreeDSelector(DataSelector, ABC):
+    kind: Literal["3D"] = "3D"
+
+    @property
+    def group(self) -> str:
+        return "3DModels"
+
+
+class ThreeDModelFilteredSelector(ThreeDSelector):
+    type: Literal["3DFiltered"] = "3DFiltered"
+    model_type: Literal["Classic", "DataModel"] = "Classic"
+    published: bool | None = None
+
+    def __str__(self) -> str:
+        suffix = f"3DModels_{self.model_type}"
+        if self.published is not None:
+            return f"{suffix}_published_{self.published}"
+        return suffix
+
+
+class ThreeDModelIdSelector(ThreeDSelector):
+    type: Literal["3DId"] = "3DId"
+    ids: tuple[int, ...]
+
+    def __str__(self) -> str:
+        hash_ = hashlib.md5(",".join(sorted(map(str, self.ids))).encode()).hexdigest()[:8]
+        return f"3DModels_ids_count_{len(self.ids)}_hash_{hash_}"

cognite_toolkit/_cdf_tk/tk_warnings/other.py

@@ -136,15 +136,19 @@ class MissingCapabilityWarning(GeneralWarning):
 
 @dataclass(frozen=True)
 class ToolkitDeprecationWarning(ToolkitWarning, DeprecationWarning):
+    severity = SeverityLevel.HIGH
     message: ClassVar[str] = "The '{feature}' is deprecated and will be removed in a future version."
 
     feature: str
     alternative: str | None = None
+    removal_version: str | None = None
 
     def get_message(self) -> str:
         msg = self.message.format(feature=self.feature)
         if self.alternative:
             msg += f"\nUse {self.alternative!r} instead."
+        if self.removal_version:
+            msg += f"\nIt will be removed in version {self.removal_version}."
 
         return msg
 

cognite_toolkit/_cdf_tk/tracker.py

@@ -38,11 +38,11 @@ class Tracker:
 
     @property
     def opted_out(self) -> bool:
-        return self._opt_status == "opted-out"
+        return False
 
     @property
     def opted_in(self) -> bool:
-        return self._opt_status == "opted-in"
+        return True
 
     def track_cli_command(
         self,

cognite_toolkit/_cdf_tk/utils/cdf.py

@@ -21,7 +21,7 @@ from filelock import BaseFileLock, FileLock, Timeout
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient, ToolkitClientConfig
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawTable
 from cognite_toolkit._cdf_tk.constants import ENV_VAR_PATTERN, MAX_ROW_ITERATION_RUN_QUERY, MAX_RUN_QUERY_FREQUENCY_MIN
 from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitError,

cognite_toolkit/_cdf_tk/utils/dtype_conversion.py

@@ -20,7 +20,13 @@ from dateutil import parser
 from cognite_toolkit._cdf_tk.constants import CDF_UNIT_SPACE
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotSupported
 from cognite_toolkit._cdf_tk.utils._auxiliary import get_concrete_subclasses
-from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricType, DataType, JsonVal, PythonTypes
+from cognite_toolkit._cdf_tk.utils.useful_types import (
+    AssetCentricType,
+    AssetCentricTypeExtended,
+    DataType,
+    JsonVal,
+    PythonTypes,
+)
 
 from .collection import humanize_collection
 
@@ -35,7 +41,7 @@ def asset_centric_convert_to_primary_property(
     type_: PropertyType,
     nullable: bool,
     destination_container_property: tuple[ContainerId, str],
-    source_property: tuple[AssetCentricType, str],
+    source_property: tuple[AssetCentricTypeExtended, str],
     direct_relation_lookup: Mapping[str | int, DirectRelationReference] | None = None,
 ) -> PropertyValueWrite:
     if (source_property, destination_container_property) in SPECIAL_CONVERTER_BY_SOURCE_DESTINATION:
@@ -574,7 +580,7 @@ CONVERTER_BY_DTYPE: Mapping[str, type[_ValueConverter]] = {
     for cls_ in _ValueConverter.__subclasses__()
 }
 SPECIAL_CONVERTER_BY_SOURCE_DESTINATION: Mapping[
-    tuple[tuple[AssetCentricType, str], tuple[ContainerId, str]],
+    tuple[tuple[AssetCentricTypeExtended, str], tuple[ContainerId, str]],
     type[_SpecialCaseConverter],
 ] = {
     (subclass.source_property, subclass.destination_container_property): subclass

cognite_toolkit/_cdf_tk/utils/fileio/__init__.py

@@ -12,6 +12,7 @@ from ._readers import (
     CSVReader,
     FailedParsing,
     FileReader,
+    MultiFileReader,
     NDJsonReader,
     ParquetReader,
     YAMLReader,
@@ -45,6 +46,7 @@ __all__ = [
     "FileReader",
     "FileWriter",
     "GzipCompression",
+    "MultiFileReader",
     "NDJsonReader",
     "NDJsonWriter",
     "ParquetReader",

cognite_toolkit/_cdf_tk/utils/fileio/_base.py

@@ -14,7 +14,11 @@ T_IO = TypeVar("T_IO", bound=IO)
 
 
 class FileIO(ABC):
-    format: ClassVar[str]
+    FORMAT: ClassVar[str]
+
+    @property
+    def format(self) -> str:
+        return self.FORMAT
 
 
 @dataclass(frozen=True)

cognite_toolkit/_cdf_tk/utils/fileio/_readers.py

@@ -1,10 +1,11 @@
 import csv
 import json
+import re
 from abc import ABC, abstractmethod
 from collections import Counter, defaultdict
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from dataclasses import dataclass
-from functools import partial
+from functools import cached_property, partial
 from io import TextIOWrapper
 from pathlib import Path
 from typing import Any
@@ -37,10 +38,10 @@ class FileReader(FileIO, ABC):
     @abstractmethod
     def _read_chunks_from_file(self, file: TextIOWrapper) -> Iterator[dict[str, JsonVal]]:
         """Read chunks from the file."""
-        raise NotImplementedError("This method should be implemented in subclasses.")
+        ...
 
     @classmethod
-    def from_filepath(cls, filepath: Path) -> "FileReader":
+    def from_filepath(cls, filepath: Path) -> "type[FileReader]":
         if len(filepath.suffixes) == 0:
             raise ToolkitValueError(
                 f"File has no suffix. Available formats: {humanize_collection(FILE_READ_CLS_BY_FORMAT.keys())}."
@@ -55,33 +56,110 @@ class FileReader(FileIO, ABC):
                 )
 
         if suffix in FILE_READ_CLS_BY_FORMAT:
-            return FILE_READ_CLS_BY_FORMAT[suffix](input_file=filepath)
+            return FILE_READ_CLS_BY_FORMAT[suffix]
 
         raise ToolkitValueError(
             f"Unknown file format: {suffix}. Available formats: {humanize_collection(FILE_READ_CLS_BY_FORMAT.keys())}."
         )
 
+    @abstractmethod
+    def count(self) -> int:
+        """Count the number of chunks in the file."""
+        ...
+
+
+class MultiFileReader(FileReader):
+    """Reads multiple files and yields chunks from each file sequentially.
+
+    Args:
+        input_files (Sequence[Path]): The list of file paths to read.
+    """
+
+    PART_PATTERN = re.compile(r"part-(\d{4})$")
+
+    def __init__(self, input_files: Sequence[Path]) -> None:
+        super().__init__(input_file=input_files[0])
+        self.input_files = input_files
+
+    @cached_property
+    def reader_class(self) -> type[FileReader]:
+        """Determine the reader class based on the input files."""
+        reader_classes = Counter([FileReader.from_filepath(input_file) for input_file in self.input_files])
+        if len(reader_classes) > 1:
+            raise ToolkitValueError(
+                "All input files must be of the same format. "
+                f"Found formats: {humanize_collection([cls.FORMAT for cls in reader_classes.keys()])}."
+            )
+        return reader_classes.most_common(1)[0][0]
+
+    @property
+    def is_table(self) -> bool:
+        try:
+            return issubclass(self.reader_class, TableReader)
+        except ValueError:
+            # The input files are not a known format, so it is not a table.
+            return False
+
+    @property
+    def format(self) -> str:
+        return self.reader_class.FORMAT
+
+    def read_chunks(self) -> Iterator[dict[str, JsonVal]]:
+        for input_file in sorted(self.input_files, key=self._part_no):
+            yield from self.reader_class(input_file).read_chunks()
+
+    def _part_no(self, path: Path) -> int:
+        match = self.PART_PATTERN.search(path.stem)
+        if match:
+            return int(match.group(1))
+        return 99999
+
+    def _read_chunks_from_file(self, file: TextIOWrapper) -> Iterator[dict[str, JsonVal]]:
+        raise NotImplementedError("This method is not used in MultiFileReader.")
+
+    def count(self) -> int:
+        """Count the total number of chunks in all files."""
+        total_count = 0
+        for input_file in self.input_files:
+            reader = self.reader_class(input_file)
+            total_count += reader.count()
+        return total_count
+
 
 class NDJsonReader(FileReader):
-    format = ".ndjson"
+    FORMAT = ".ndjson"
 
     def _read_chunks_from_file(self, file: TextIOWrapper) -> Iterator[dict[str, JsonVal]]:
         for line in file:
             if stripped := line.strip():
                 yield json.loads(stripped)
 
+    def count(self) -> int:
+        """Count the number of lines (chunks) in the NDJSON file."""
+        compression = Compression.from_filepath(self.input_file)
+        with compression.open("r") as file:
+            line_count = sum(1 for line in file if line.strip())
+        return line_count
+
 
 class YAMLBaseReader(FileReader, ABC):
     def _read_chunks_from_file(self, file: TextIOWrapper) -> Iterator[dict[str, JsonVal]]:
         yield from yaml.safe_load_all(file)
 
+    def count(self) -> int:
+        """Count the number of documents (chunks) in the YAML file."""
+        compression = Compression.from_filepath(self.input_file)
+        with compression.open("r") as file:
+            doc_count = sum(1 for _ in yaml.safe_load_all(file))
+        return doc_count
+
 
 class YAMLReader(YAMLBaseReader):
-    format = ".yaml"
+    FORMAT = ".yaml"
 
 
 class YMLReader(YAMLBaseReader):
-    format = ".yml"
+    FORMAT = ".yml"
 
 
 @dataclass
@@ -171,8 +249,8 @@ class TableReader(FileReader, ABC):
 
         if not input_file.exists():
             raise ToolkitFileNotFoundError(f"File not found: {input_file.as_posix()!r}.")
-        if input_file.suffix != cls.format:
-            raise ToolkitValueError(f"Expected a {cls.format} file got a {input_file.suffix!r} file instead.")
+        if input_file.suffix != cls.FORMAT:
+            raise ToolkitValueError(f"Expected a {cls.FORMAT} file got a {input_file.suffix!r} file instead.")
 
         column_names, sample_rows = cls._read_sample_rows(input_file, sniff_rows)
         cls._check_column_names(column_names)
@@ -213,7 +291,7 @@ class TableReader(FileReader, ABC):
 class CSVReader(TableReader):
     """Reads CSV files and yields each row as a dictionary."""
 
-    format = ".csv"
+    FORMAT = ".csv"
 
     def _read_chunks_from_file(self, file: TextIOWrapper) -> Iterator[dict[str, JsonVal]]:
         if self.keep_failed_cells and self.failed_cell:
@@ -255,9 +333,16 @@ class CSVReader(TableReader):
                 raise ToolkitValueError(f"No data found in the file: {input_file.as_posix()!r}.")
         return column_names, sample_rows
 
+    def count(self) -> int:
+        """Count the number of rows in the CSV file."""
+        compression = Compression.from_filepath(self.input_file)
+        with compression.open("r") as file:
+            line_count = sum(1 for _ in file) - 1  # Subtract 1 for header
+        return line_count
+
 
 class ParquetReader(TableReader):
-    format = ".parquet"
+    FORMAT = ".parquet"
 
     def __init__(self, input_file: Path) -> None:
         # Parquet files have their own schema, so we don't need to sniff or provide one.
@@ -308,23 +393,30 @@ class ParquetReader(TableReader):
                 raise ToolkitValueError(f"No data found in the file: {input_file.as_posix()!r}.")
         return column_names, sample_rows
 
+    def count(self) -> int:
+        """Count the number of rows in the Parquet file."""
+        import pyarrow.parquet as pq
+
+        with pq.ParquetFile(self.input_file) as parquet_file:
+            return parquet_file.metadata.num_rows
+
 
 FILE_READ_CLS_BY_FORMAT: Mapping[str, type[FileReader]] = {}
 TABLE_READ_CLS_BY_FORMAT: Mapping[str, type[TableReader]] = {}
 for subclass in get_concrete_subclasses(FileReader):  # type: ignore[type-abstract]
-    if not getattr(subclass, "format", None):
+    if not getattr(subclass, "FORMAT", None):
         continue
-    if subclass.format in FILE_READ_CLS_BY_FORMAT:
+    if subclass.FORMAT in FILE_READ_CLS_BY_FORMAT:
         raise TypeError(
-            f"Duplicate file format {subclass.format!r} found for classes "
-            f"{FILE_READ_CLS_BY_FORMAT[subclass.format].__name__!r} and {subclass.__name__!r}."
+            f"Duplicate file format {subclass.FORMAT!r} found for classes "
+            f"{FILE_READ_CLS_BY_FORMAT[subclass.FORMAT].__name__!r} and {subclass.__name__!r}."
         )
     # We know we have a dict, but we want to expose FILE_READ_CLS_BY_FORMAT as a Mapping
-    FILE_READ_CLS_BY_FORMAT[subclass.format] = subclass  # type: ignore[index]
+    FILE_READ_CLS_BY_FORMAT[subclass.FORMAT] = subclass  # type: ignore[index]
     if issubclass(subclass, TableReader):
-        if subclass.format in TABLE_READ_CLS_BY_FORMAT:
+        if subclass.FORMAT in TABLE_READ_CLS_BY_FORMAT:
             raise TypeError(
-                f"Duplicate table file format {subclass.format!r} found for classes "
-                f"{TABLE_READ_CLS_BY_FORMAT[subclass.format].__name__!r} and {subclass.__name__!r}."
+                f"Duplicate table file format {subclass.FORMAT!r} found for classes "
+                f"{TABLE_READ_CLS_BY_FORMAT[subclass.FORMAT].__name__!r} and {subclass.__name__!r}."
             )
-        TABLE_READ_CLS_BY_FORMAT[subclass.format] = subclass  # type: ignore[index]
+        TABLE_READ_CLS_BY_FORMAT[subclass.FORMAT] = subclass  # type: ignore[index]