cognite-neat 0.109.4__py3-none-any.whl → 0.111.0__py3-none-any.whl

cognite/neat/_issues/_base.py

@@ -1,15 +1,12 @@
 import inspect
 import sys
 import warnings
-from abc import ABC
-from collections.abc import Collection, Hashable, Iterable, Iterator, Sequence
-from contextlib import contextmanager
+from collections.abc import Collection, Hashable, Iterable, Sequence
 from dataclasses import dataclass, fields
 from functools import total_ordering
 from pathlib import Path
 from types import UnionType
 from typing import Any, ClassVar, Literal, TypeAlias, TypeVar, get_args, get_origin
-from warnings import WarningMessage
 
 import pandas as pd
 from cognite.client.data_classes.data_modeling import (
@@ -18,11 +15,8 @@ from cognite.client.data_classes.data_modeling import (
     PropertyId,
     ViewId,
 )
-from pydantic import ValidationError
-from pydantic_core import ErrorDetails
 
-from cognite.neat._utils.spreadsheet import SpreadsheetRead
-from cognite.neat._utils.text import humanize_collection, to_camel, to_snake
+from cognite.neat._utils.text import humanize_collection, to_camel_case, to_snake_case
 
 if sys.version_info < (3, 11):
     from exceptiongroup import ExceptionGroup
@@ -32,11 +26,10 @@ else:
 
 
 __all__ = [
-    "DefaultWarning",
+    "IssueList",
     "MultiValueError",
     "NeatError",
     "NeatIssue",
-    "NeatIssueList",
     "NeatWarning",
 ]
 
@@ -113,7 +106,7 @@ class NeatIssue:
         """Return a dictionary representation of the issue."""
         variables = vars(self)
         output = {
-            to_camel(key): self._dump_value(value)
+            to_camel_case(key): self._dump_value(value)
             for key, value in variables.items()
             if not (value is None or key.startswith("_"))
         }
@@ -153,7 +146,7 @@ class NeatIssue:
         if "NeatIssue" not in data:
             raise NeatValueError("The data does not contain a NeatIssue key.")
         issue_type = data.pop("NeatIssue")
-        args = {to_snake(key): value for key, value in data.items()}
+        args = {to_snake_case(key): value for key, value in data.items()}
         if issue_type in _NEAT_ERRORS_BY_NAME:
             return cls._load_values(_NEAT_ERRORS_BY_NAME[issue_type], args)
         elif issue_type in _NEAT_WARNINGS_BY_NAME:
@@ -210,212 +203,42 @@ class NeatIssue:
             return NotImplemented
         return (type(self).__name__, self.as_message()) == (type(other).__name__, other.as_message())
 
+    def __str__(self) -> str:
+        return self.as_message()
+
 
 @dataclass(unsafe_hash=True)
 class NeatError(NeatIssue, Exception):
     """This is the base class for all exceptions (errors) used in Neat."""
 
-    @classmethod
-    def from_errors(cls, errors: "list[ErrorDetails | NeatError]", **kwargs) -> "list[NeatError]":
-        """Convert a list of pydantic errors to a list of Error instances.
-
-        This is intended to be overridden in subclasses to handle specific error types.
-        """
-        all_errors: list[NeatError] = []
-        read_info_by_sheet = kwargs.get("read_info_by_sheet")
-
-        for error in errors:
-            if (
-                isinstance(error, dict)
-                and error["type"] == "is_instance_of"
-                and error["loc"][1] == "is-instance[SheetList]"
-            ):
-                # Skip the error for SheetList, as it is not relevant for the user. This is an
-                # internal class used to have helper methods for a lists as .to_pandas()
-                continue
-
-            neat_error: NeatError | None = None
-            if isinstance(error, dict) and isinstance(ctx := error.get("ctx"), dict) and "error" in ctx:
-                neat_error = ctx["error"]
-            elif isinstance(error, NeatError | MultiValueError):
-                neat_error = error
-
-            loc = error["loc"] if isinstance(error, dict) else tuple()
-            if isinstance(neat_error, MultiValueError):
-                all_errors.extend([cls._adjust_error(e, loc, read_info_by_sheet) for e in neat_error.errors])
-            elif isinstance(neat_error, NeatError):
-                all_errors.append(cls._adjust_error(neat_error, loc, read_info_by_sheet))
-            elif isinstance(error, dict) and len(loc) >= 4 and read_info_by_sheet:
-                all_errors.append(RowError.from_pydantic_error(error, read_info_by_sheet))
-            elif isinstance(error, dict):
-                all_errors.append(DefaultPydanticError.from_pydantic_error(error))
-            else:
-                # This is unreachable. However, in case it turns out to be reachable, we want to know about it.
-                raise ValueError(f"Unsupported error type: {error}")
-        return all_errors
-
-    @classmethod
-    def _adjust_error(
-        cls, error: "NeatError", loc: tuple[str | int, ...], read_info_by_sheet: dict[str, SpreadsheetRead] | None
-    ) -> "NeatError":
-        from .errors._wrapper import MetadataValueError
-
-        if read_info_by_sheet:
-            cls._adjust_row_numbers(error, read_info_by_sheet)
-        if len(loc) == 2 and isinstance(loc[0], str) and loc[0].casefold() == "metadata":
-            return MetadataValueError(field_name=str(loc[1]), error=error)
-        return error
-
-    @staticmethod
-    def _adjust_row_numbers(caught_error: "NeatError", read_info_by_sheet: dict[str, SpreadsheetRead]) -> None:
-        from cognite.neat._issues.errors._properties import PropertyDefinitionDuplicatedError
-        from cognite.neat._issues.errors._resources import ResourceNotDefinedError
-
-        reader = read_info_by_sheet.get("Properties", SpreadsheetRead())
-
-        if isinstance(caught_error, PropertyDefinitionDuplicatedError) and caught_error.location_name == "rows":
-            adjusted_row_number = (
-                tuple(
-                    reader.adjusted_row_number(row_no) if isinstance(row_no, int) else row_no
-                    for row_no in caught_error.locations or []
-                )
-                or None
-            )
-            # The error is frozen, so we have to use __setattr__ to change the row number
-            object.__setattr__(caught_error, "locations", adjusted_row_number)
-        elif isinstance(caught_error, RowError):
-            # Adjusting the row number to the actual row number in the spreadsheet
-            new_row = reader.adjusted_row_number(caught_error.row)
-            # The error is frozen, so we have to use __setattr__ to change the row number
-            object.__setattr__(caught_error, "row", new_row)
-        elif isinstance(caught_error, ResourceNotDefinedError):
-            if isinstance(caught_error.row_number, int) and caught_error.sheet_name == "Properties":
-                new_row = reader.adjusted_row_number(caught_error.row_number)
-                object.__setattr__(caught_error, "row_number", new_row)
-
-
-@dataclass(unsafe_hash=True)
-class DefaultPydanticError(NeatError, ValueError):
-    """{type}: {msg} [loc={loc}]"""
-
-    type: str
-    loc: tuple[int | str, ...]
-    msg: str
-
-    @classmethod
-    def from_pydantic_error(cls, error: ErrorDetails) -> "NeatError":
-        loc = error["loc"]
-        if len(loc) >= 2 and isinstance(loc[0], str) and loc[0].casefold() == "metadata":
-            from .errors._general import NeatValueError
-            from .errors._wrapper import MetadataValueError
-
-            return MetadataValueError(
-                field_name=str(loc[1]), error=NeatValueError(f"{error['msg']} got '{error['input']}'")
-            )
-
-        return cls(
-            type=error["type"],
-            loc=error["loc"],
-            msg=error["msg"],
-        )
-
-    def as_message(self, include_type: bool = True) -> str:
-        if self.loc and len(self.loc) == 1:
-            return f"{self.loc[0]} sheet: {self.msg}"
-        elif self.loc and len(self.loc) == 2:
-            return f"{self.loc[0]} sheet field/column <{self.loc[1]}>: {self.msg}"
-        else:
-            return self.msg
-
-
-@dataclass(unsafe_hash=True)
-class RowError(NeatError, ValueError):
-    """In {sheet_name}, row={row}, column={column}: {msg}. [type={type}, input_value={input}]"""
-
-    extra = "For further information visit {url}"
-
-    sheet_name: str
-    column: str
-    row: int
-    type: str
-    msg: str
-    input: Any
-    url: str | None = None
-
-    @classmethod
-    def from_pydantic_error(
-        cls,
-        error: ErrorDetails,
-        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
-    ) -> Self:
-        sheet_name, _, row, column, *__ = error["loc"]
-        reader = (read_info_by_sheet or {}).get(str(sheet_name), SpreadsheetRead())
-        return cls(
-            sheet_name=str(sheet_name),
-            column=str(column),
-            row=reader.adjusted_row_number(int(row)),
-            type=error["type"],
-            msg=error["msg"],
-            input=error.get("input"),
-            url=str(url) if (url := error.get("url")) else None,
-        )
-
-    def as_message(self, include_type: bool = True) -> str:
-        input_str = str(self.input) if self.input is not None else ""
-        input_str = input_str[:50] + "..." if len(input_str) > 50 else input_str
-        output = (
-            f"In {self.sheet_name}, row={self.row}, column={self.column}: {self.msg}. "
-            f"[type={self.type}, input_value={input_str}]"
-        )
-        if self.url:
-            output += f" For further information visit {self.url}"
-        return output
+    ...
 
 
 @dataclass(unsafe_hash=True)
 class NeatWarning(NeatIssue, UserWarning):
     """This is the base class for all warnings used in Neat."""
 
-    @classmethod
-    def from_warning(cls, warning: WarningMessage) -> "NeatWarning":
-        """Create a NeatWarning from a WarningMessage."""
-        return DefaultWarning.from_warning_message(warning)
-
-
-@dataclass(unsafe_hash=True)
-class DefaultWarning(NeatWarning):
-    """{category}: {warning}"""
-
-    extra = "Source: {source}"
+    ...
 
-    warning: str
-    category: str
-    source: str | None = None
 
-    @classmethod
-    def from_warning_message(cls, warning: WarningMessage) -> NeatWarning:
-        if isinstance(warning.message, NeatWarning):
-            return warning.message
-
-        return cls(
-            warning=str(warning.message),
-            category=warning.category.__name__,
-            source=warning.source,
-        )
+class MultiValueError(ValueError):
+    """This is a container for multiple errors.
 
-    def as_message(self, include_type: bool = True) -> str:
-        return str(self.warning)
+    It is used in the pydantic field_validator/model_validator to collect multiple errors, which
+    can then be caught in a try-except block and returned as an IssueList.
 
+    """
 
-T_NeatIssue = TypeVar("T_NeatIssue", bound=NeatIssue)
+    def __init__(self, errors: Sequence[NeatIssue]):
+        self.errors = IssueList(errors)
 
 
-class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
+class IssueList(list, Sequence[NeatIssue]):
     """This is a generic list of NeatIssues."""
 
     def __init__(
         self,
-        issues: Sequence[T_NeatIssue] | None = None,
+        issues: Sequence[NeatIssue] | None = None,
         title: str | None = None,
         action: str | None = None,
         hint: str | None = None,
@@ -462,36 +285,17 @@ class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
 
     def trigger_warnings(self) -> None:
         """Trigger all warnings in this list."""
-        for warning in [issue for issue in self if isinstance(issue, NeatWarning)]:
+        for warning in self.warnings:
             warnings.warn(warning, stacklevel=2)
 
     def to_pandas(self) -> pd.DataFrame:
         """Return a pandas DataFrame representation of this list."""
         return pd.DataFrame([issue.dump() for issue in self])
 
-    def _repr_html_(self) -> str | None:
-        return self.to_pandas()._repr_html_()  # type: ignore[operator]
-
-    def as_exception(self) -> "MultiValueError":
+    def as_exception(self) -> MultiValueError:
         """Return a MultiValueError with all the errors in this list."""
         return MultiValueError(self.errors)
 
-
-class MultiValueError(ValueError):
-    """This is a container for multiple errors.
-
-    It is used in the pydantic field_validator/model_validator to collect multiple errors, which
-    can then be caught in a try-except block and returned as an IssueList.
-
-    """
-
-    def __init__(self, errors: Sequence[NeatIssue]):
-        self.errors = list(errors)
-
-
-class IssueList(NeatIssueList[NeatIssue]):
-    """This is a list of NeatIssues."""
-
     def _repr_html_(self) -> str | None:
         if self.action and not self:
             header = f"Success: {self.action}"
@@ -530,38 +334,3 @@ def _get_subclasses(cls_: type[T_Cls], include_base: bool = False) -> Iterable[t
     for s in cls_.__subclasses__():
         yield s
         yield from _get_subclasses(s, False)
-
-
-@contextmanager
-def catch_warnings() -> Iterator[IssueList]:
-    """Catch warnings and append them to the issues list."""
-    issues = IssueList()
-    with warnings.catch_warnings(record=True) as warning_logger:
-        warnings.simplefilter("always")
-        try:
-            yield issues
-        finally:
-            if warning_logger:
-                issues.extend([NeatWarning.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]
-
-
-@contextmanager
-def catch_issues(error_args: dict[str, Any] | None = None) -> Iterator[IssueList]:
-    """This is an internal help function to handle issues and warnings.
-
-    Args:
-        error_args: Additional arguments to pass to the error class. The only use case as of (2025-01-03) is to pass
-            the read_info_by_sheet to the error class such that the row numbers can be adjusted to match the source
-            spreadsheet.
-
-    Returns:
-        IssueList: The list of issues.
-
-    """
-    with catch_warnings() as issues:
-        try:
-            yield issues
-        except ValidationError as e:
-            issues.extend(NeatError.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
-        except (NeatError, MultiValueError) as e:
-            issues.extend(NeatError.from_errors([e], **(error_args or {})))  # type: ignore[arg-type, list-item]

cognite/neat/_issues/_contextmanagers.py

@@ -0,0 +1,46 @@
+import warnings
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+from pydantic import ValidationError
+
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
+
+from ._base import IssueList, MultiValueError, NeatError
+from ._factory import from_pydantic_errors, from_warning
+
+
+@contextmanager
+def catch_warnings() -> Iterator[IssueList]:
+    """Catch warnings and append them to the issues list."""
+    issues = IssueList()
+    with warnings.catch_warnings(record=True) as warning_logger:
+        warnings.simplefilter("always")
+        try:
+            yield issues
+        finally:
+            if warning_logger:
+                issues.extend([from_warning(warning) for warning in warning_logger])
+
+
+@contextmanager
+def catch_issues(read_info_by_sheet: dict[str, SpreadsheetRead] | None = None) -> Iterator[IssueList]:
+    """This is an internal help function to handle issues and warnings.
+
+    Args:
+        read_info_by_sheet (dict[str, SpreadsheetRead]): The read information by sheet. This is used to adjust
+            the row numbers in the errors/warnings.
+
+    Returns:
+        IssueList: The list of issues.
+
+    """
+    with catch_warnings() as issues:
+        try:
+            yield issues
+        except ValidationError as e:
+            issues.extend(from_pydantic_errors(e.errors(), read_info_by_sheet))
+        except NeatError as single:
+            issues.append(single)
+        except MultiValueError as multi:
+            issues.extend(multi.errors)

cognite/neat/_issues/_factory.py

@@ -0,0 +1,69 @@
+from typing import cast
+from warnings import WarningMessage
+
+from pydantic_core import ErrorDetails
+
+from cognite.neat._issues._base import NeatError, NeatWarning
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
+
+from .errors import NeatValueError, SpreadsheetError
+from .warnings import NeatValueWarning
+
+
+def from_pydantic_errors(
+    errors: list[ErrorDetails], read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
+) -> list[NeatError]:
+    read_info_by_sheet = read_info_by_sheet or {}
+    return [
+        _from_pydantic_error(error, read_info_by_sheet)
+        for error in errors
+        # Skip the error for SheetList, as it is not relevant for the user. This is an
+        # internal class used to have helper methods for a lists as .to_pandas()
+        if not (error["type"] == "is_instance_of" and error["loc"][1] == "is-instance[SheetList]")
+    ]
+
+
+def from_warning(warning: WarningMessage) -> NeatWarning:
+    if isinstance(warning.message, NeatWarning):
+        return warning.message
+    message = f"{warning.category.__name__}: {warning.message!s}"
+    if warning.source:
+        message += f" Source: {warning.source}"
+    return NeatValueWarning(message)
+
+
+def _from_pydantic_error(error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead]) -> NeatError:
+    neat_error = _create_neat_value_error(error)
+    location = error["loc"]
+
+    # only errors caused in model_validate will have location information
+    if location:
+        return SpreadsheetError.create(location, neat_error, read_info_by_sheet.get(cast(str, location[0])))
+
+    # errors that occur while for example parsing spreadsheet in input rules
+    # will not have location information so we return neat_error as is
+    # this is workaround until more elegant solution is found
+    return neat_error
+
+
+def _create_neat_value_error(error: ErrorDetails) -> NeatValueError:
+    if (ctx := error.get("ctx")) and (neat_error := ctx.get("error")) and isinstance(neat_error, NeatError):
+        # Is already a NeatError
+        return neat_error
+    return _pydantic_to_neat_error(error)
+
+
+def _pydantic_to_neat_error(error: ErrorDetails) -> NeatValueError:
+    error_type = error["type"]
+    input_value = error["input"]
+    match error_type:
+        # See https://docs.pydantic.dev/latest/errors/validation_errors/ for all possible error types:
+        case error_type if error_type.endswith("_type") | error_type.endswith("_parsing"):
+            if input_value is None:
+                return NeatValueError("value is missing.")
+            expected_type = error_type.removesuffix("_type").removesuffix("_parsing")
+            return NeatValueError(f"Expected a {expected_type} type, got {input_value!r}")
+        case _:
+            # The above cases overwrite the human-readable message from pydantic.
+            # Motivation for overwriting is that pydantic is developer-oriented and while neat is SME-oriented.
+            return NeatValueError(f"{error['msg']} got '{input_value}'")

cognite/neat/_issues/errors/__init__.py

@@ -1,8 +1,9 @@
-from cognite.neat._issues._base import DefaultPydanticError, NeatError, RowError, _get_subclasses
+from cognite.neat._issues._base import NeatError, _get_subclasses
 
 from ._external import (
     AuthorizationError,
     CDFMissingClientError,
+    CDFMissingResourcesError,
     FileMissingRequiredFieldError,
     FileNotAFileError,
     FileNotFoundNeatError,
@@ -31,12 +32,24 @@ from ._resources import (
     ResourceNotFoundError,
     ResourceRetrievalError,
 )
-from ._wrapper import MetadataValueError
+from ._wrapper import (
+    ClassValueError,
+    ContainerValueError,
+    EnumValueError,
+    MetadataValueError,
+    NodeValueError,
+    PropertyValueError,
+    SpreadsheetError,
+    ViewValueError,
+)
 
 __all__ = [
     "AuthorizationError",
     "CDFMissingClientError",
-    "DefaultPydanticError",
+    "CDFMissingResourcesError",
+    "ClassValueError",
+    "ContainerValueError",
+    "EnumValueError",
     "FileMissingRequiredFieldError",
     "FileNotAFileError",
     "FileNotFoundNeatError",
@@ -48,12 +61,14 @@ __all__ = [
     "NeatTypeError",
     "NeatValueError",
     "NeatYamlError",
+    "NodeValueError",
     "OxigraphStorageLockedError",
     "PropertyDefinitionDuplicatedError",
     "PropertyDefinitionError",
     "PropertyMappingDuplicatedError",
     "PropertyNotFoundError",
     "PropertyTypeNotSupportedError",
+    "PropertyValueError",
     "RegexViolationError",
     "ResourceChangedError",
     "ResourceConversionError",
@@ -65,7 +80,8 @@ __all__ = [
     "ResourceNotFoundError",
     "ResourceRetrievalError",
     "ReversedConnectionNotFeasibleError",
-    "RowError",
+    "SpreadsheetError",
+    "ViewValueError",
 ]
 
 _NEAT_ERRORS_BY_NAME = {error.__name__: error for error in _get_subclasses(NeatError, include_base=True)}

cognite/neat/_issues/errors/_external.py

@@ -80,3 +80,10 @@ class CDFMissingClientError(NeatError, RuntimeError):
     """CDF client is required: {reason}"""
 
     reason: str
+
+
+@dataclass(unsafe_hash=True)
+class CDFMissingResourcesError(NeatError, RuntimeError):
+    """Following CDF resources are missing: {resources}"""
+
+    resources: str

cognite/neat/_issues/errors/_wrapper.py

@@ -1,11 +1,89 @@
+from abc import ABC
 from dataclasses import dataclass
+from typing import ClassVar, cast
 
 from cognite.neat._issues import NeatError
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
 
 
 @dataclass(unsafe_hash=True)
-class MetadataValueError(NeatError, ValueError):
-    """Field {field_name} - {error}"""
+class SpreadsheetError(NeatError, ValueError, ABC):
+    """In row {row}: {error}"""
 
-    field_name: str
+    _name: ClassVar[str] = ""
     error: NeatError
+
+    @classmethod
+    def create(
+        cls, location: tuple[int | str, ...], error: NeatError, spreadsheet: SpreadsheetRead | None = None
+    ) -> "SpreadsheetError":
+        spreadsheet_name = cast(str, location[0])
+        if spreadsheet_name not in ERROR_CLS_BY_SPREADSHEET_NAME:
+            # This happens for the metadata sheet, which are individual fields
+            return MetadataValueError(error, field_name=spreadsheet_name)
+
+        error_cls = ERROR_CLS_BY_SPREADSHEET_NAME[spreadsheet_name]
+        row, column = cast(tuple[int, str], location[2:4])
+
+        if spreadsheet:
+            row = spreadsheet.adjusted_row_number(row)
+
+        return error_cls(
+            row=row,
+            error=error,
+            column=column,
+        )
+
+
+@dataclass(unsafe_hash=True)
+class SpreadsheetListError(SpreadsheetError, ABC):
+    """In row {row}, column '{column}': {error}"""
+
+    row: int
+    column: str
+
+
+@dataclass(unsafe_hash=True)
+class MetadataValueError(SpreadsheetError):
+    """In field {field_name}: {error}"""
+
+    _type: ClassVar[str] = "Metadata"
+    field_name: str
+
+
+@dataclass(unsafe_hash=True)
+class ViewValueError(SpreadsheetListError):
+    _name = "Views"
+
+
+@dataclass(unsafe_hash=True)
+class ContainerValueError(SpreadsheetListError):
+    _name = "Containers"
+
+
+@dataclass(unsafe_hash=True)
+class PropertyValueError(SpreadsheetListError):
+    _name = "Properties"
+
+
+@dataclass(unsafe_hash=True)
+class ClassValueError(SpreadsheetListError):
+    _name = "Classes"
+
+
+@dataclass(unsafe_hash=True)
+class EnumValueError(SpreadsheetListError):
+    _name = "Enum"
+
+
+@dataclass(unsafe_hash=True)
+class NodeValueError(SpreadsheetListError):
+    _name = "Nodes"
+
+
+ERROR_CLS_BY_SPREADSHEET_NAME = {cls_._name: cls_ for cls_ in SpreadsheetListError.__subclasses__()}
+
+# Efficient way to set docstring for all classes
+for _cls in ERROR_CLS_BY_SPREADSHEET_NAME.values():
+    _cls.__doc__ = SpreadsheetListError.__doc__
+del _cls

cognite/neat/_issues/formatters.py

@@ -3,7 +3,7 @@ import xml.etree.ElementTree as ET
 from abc import ABC, abstractmethod
 from pathlib import Path
 
-from ._base import NeatError, NeatIssueList, NeatWarning
+from ._base import IssueList, NeatError, NeatWarning
 
 __all__ = ["FORMATTER_BY_NAME", "BasicHTML", "Formatter"]
 
@@ -13,14 +13,14 @@ class Formatter(ABC):
     default_file_prefix: str = "validation_report"
 
     @abstractmethod
-    def create_report(self, issues: NeatIssueList) -> str:
+    def create_report(self, issues: IssueList) -> str:
         raise NotImplementedError()
 
     @property
     def default_file_name(self) -> str:
         return f"{self.default_file_prefix}_{type(self).__name__.lower()}{self.file_suffix}"
 
-    def write_to_file(self, issues: NeatIssueList, file_or_dir_path: Path | None = None) -> None:
+    def write_to_file(self, issues: IssueList, file_or_dir_path: Path | None = None) -> None:
         if file_or_dir_path is None:
             file_or_dir_path = Path(self.default_file_name)
         elif file_or_dir_path.is_dir():
@@ -41,7 +41,7 @@ class BasicHTML(Formatter):
         self._doc = ET.Element("html")
         self._body = ET.SubElement(self._doc, "body")
 
-    def create_report(self, issues: NeatIssueList) -> str:
+    def create_report(self, issues: IssueList) -> str:
         errors = [issue for issue in issues if isinstance(issue, NeatError)]
         warnings_ = [issue for issue in issues if isinstance(issue, NeatWarning)]
         self._doc.clear()