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

cognite/neat/_graph/queries/_base.py

@@ -1,4 +1,3 @@
-import warnings
 from collections import defaultdict
 from collections.abc import Iterable
 from typing import Literal, cast, overload
@@ -9,14 +8,9 @@ from rdflib.graph import DATASET_DEFAULT_GRAPH_ID
 from rdflib.query import ResultRow
 
 from cognite.neat._constants import NEAT
-from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.models.entities import ClassEntity
-from cognite.neat._rules.models.information import InformationRules
 from cognite.neat._shared import InstanceType
 from cognite.neat._utils.rdf_ import remove_instance_ids_in_batch, remove_namespace_from_uri
 
-from ._construct import build_construct_query
-
 
 class Queries:
     """Helper class for storing standard queries for the graph store."""
@@ -24,11 +18,9 @@ class Queries:
     def __init__(
         self,
         dataset: Dataset,
-        rules: dict[URIRef, InformationRules] | None = None,
         default_named_graph: URIRef | None = None,
     ):
         self.dataset = dataset
-        self.rules = rules or {}
         self.default_named_graph = default_named_graph or DATASET_DEFAULT_GRAPH_ID
 
     def graph(self, named_graph: URIRef | None = None) -> Graph:
@@ -126,38 +118,6 @@ class Queries:
         # Select queries gives an iterable of result rows
         return cast(list[ResultRow], list(self.graph(named_graph).query(query)))
 
-    def triples_of_type_instances(
-        self, rdf_type: str | URIRef, named_graph: URIRef | None = None
-    ) -> list[tuple[str, str, str]]:
-        """Get all triples of a given type.
-
-        Args:
-            rdf_type: Type URI to query
-            named_graph: Named graph to query over, default None (default graph)
-        """
-        named_graph = named_graph or self.default_named_graph
-        if isinstance(rdf_type, URIRef):
-            rdf_uri = rdf_type
-        elif isinstance(rdf_type, str) and self.rules and self.rules.get(named_graph):
-            rdf_uri = self.rules[named_graph].metadata.namespace[rdf_type]
-        else:
-            warnings.warn(
-                "Unknown namespace. Please either provide a URIRef or set the rules of the store.",
-                stacklevel=2,
-            )
-            return []
-
-        query = (
-            "SELECT ?instance ?prop ?value "
-            f"WHERE {{ ?instance a <{rdf_uri}> . ?instance ?prop ?value . }} "
-            "order by ?instance"
-        )
-
-        result = self.graph(named_graph).query(query)
-
-        # We cannot include the RDF.type in case there is a neat:type property
-        return [remove_namespace_from_uri(list(triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
-
     def type_with_property(self, type_: URIRef, property_uri: URIRef, named_graph: URIRef | None = None) -> bool:
         """Check if a property exists in the graph store
 
@@ -205,9 +165,8 @@ class Queries:
     def describe(
         self,
         instance_id: URIRef,
-        instance_type: str | None = None,
+        instance_type: URIRef | None = None,
         property_renaming_config: dict | None = None,
-        property_types: dict[str, EntityTypes] | None = None,
         named_graph: URIRef | None = None,
     ) -> tuple[str, dict[str | InstanceType, list[str]]] | None:
         """DESCRIBE instance for a given class from the graph store
@@ -216,7 +175,6 @@ class Queries:
             instance_id: Instance id for which we want to generate query
             instance_type: Type of the instance, default None (will be inferred from triples)
             property_renaming_config: Dictionary to rename properties, default None (no renaming)
-            property_types: Dictionary of property types, default None (helper for removal of namespace)
             named_graph: Named graph to query over, default None (default graph)
 
 
@@ -261,7 +219,9 @@ class Queries:
             else:
                 # guarding against multiple rdf:type values as this is not allowed in CDF
                 if RDF.type not in property_values:
-                    property_values[RDF.type].append(instance_type if instance_type else value)
+                    property_values[RDF.type].append(
+                        remove_namespace_from_uri(instance_type, validation="prefix") if instance_type else value
+                    )
                 else:
                     # we should not have multiple rdf:type values
                     continue
@@ -273,52 +233,6 @@ class Queries:
         else:
             return None
 
-    def construct_instances_of_class(
-        self,
-        class_: str,
-        properties_optional: bool = True,
-        instance_id: URIRef | None = None,
-        named_graph: URIRef | None = None,
-    ) -> list[tuple[str, str, str]]:
-        """CONSTRUCT instances for a given class from the graph store
-
-        Args:
-            class_: Class entity for which we want to generate query
-            properties_optional: Whether to make all properties optional, default True
-            instance_ids: List of instance ids to filter on, default None (all)
-            named_graph: Named graph to query over, default None (default graph
-
-        Returns:
-            List of triples for instances of the given class
-        """
-        named_graph = named_graph or self.default_named_graph
-        if (
-            self.rules
-            and self.rules.get(named_graph)
-            and (
-                query := build_construct_query(
-                    class_=ClassEntity(
-                        prefix=self.rules[named_graph].metadata.prefix,
-                        suffix=class_,
-                    ),
-                    graph=self.graph(named_graph),
-                    rules=self.rules[named_graph],
-                    properties_optional=properties_optional,
-                    instance_id=instance_id,
-                )
-            )
-        ):
-            result = self.graph(named_graph).query(query)
-
-            # We cannot include the RDF.type in case there is a neat:type property
-            return [remove_namespace_from_uri(cast(ResultRow, triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
-        else:
-            warnings.warn(
-                "No rules found for the graph store, returning empty list.",
-                stacklevel=2,
-            )
-            return []
-
     def list_triples(self, limit: int = 25, named_graph: URIRef | None = None) -> list[ResultRow]:
         """List triples in the graph store
 
@@ -346,7 +260,7 @@ class Queries:
     def list_types(
         self,
         remove_namespace: bool = False,
-        limit: int = 25,
+        limit: int | None = 25,
         named_graph: URIRef | None = None,
     ) -> list[ResultRow] | list[str]:
         """List types in the graph store
@@ -358,7 +272,9 @@ class Queries:
         Returns:
             List of types
         """
-        query = f"SELECT DISTINCT ?type WHERE {{ ?subject a ?type }} LIMIT {limit}"
+        query = "SELECT DISTINCT ?type WHERE { ?subject a ?type }"
+        if limit is not None:
+            query += f" LIMIT {limit}"
         result = cast(list[ResultRow], list(self.graph(named_graph).query(query)))
         if remove_namespace:
             return [remove_namespace_from_uri(res[0]) for res in result]
@@ -438,3 +354,23 @@ class Queries:
             result[remove_namespace_from_uri(instance)] = remove_namespace_from_uri(types.split(","))
 
         return result
+
+    def count_of_type(self, class_uri: URIRef, named_graph: URIRef | None = None) -> int:
+        query = f"SELECT (COUNT(?instance) AS ?instanceCount) WHERE {{ ?instance a <{class_uri}> }}"
+        return int(next(iter(self.graph(named_graph).query(query)))[0])  # type: ignore[arg-type, index]
+
+    def list_instances_ids_by_space(
+        self, space_property: URIRef, named_graph: URIRef | None = None
+    ) -> Iterable[tuple[URIRef, str]]:
+        """Returns instance ids by space"""
+        query = f"""SELECT DISTINCT ?instance ?space
+                   WHERE {{?instance <{space_property}> ?space}}"""
+
+        for result in cast(Iterable[ResultRow], self.graph(named_graph).query(query)):
+            instance_id, space = cast(tuple[URIRef, URIRef | RdfLiteral], result)
+            if isinstance(space, URIRef):
+                yield instance_id, remove_namespace_from_uri(space)
+            elif isinstance(space, RdfLiteral):
+                yield instance_id, str(space.toPython())
+            else:
+                yield instance_id, str(space)

cognite/neat/_graph/transformers/__init__.py

@@ -16,12 +16,11 @@ from ._prune_graph import (
     PruneInstancesOfUnknownType,
     PruneTypes,
 )
-from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
+from ._rdfpath import MakeConnectionOnExactMatch
 from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SetType, SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
-    "AddSelfReferenceProperty",
     "AssetEventConnector",
     "AssetFileConnector",
     "AssetRelationshipConnector",
@@ -49,7 +48,6 @@ Transformers = (
     | AssetFileConnector
     | AssetEventConnector
     | AssetRelationshipConnector
-    | AddSelfReferenceProperty
     | SplitMultiValueProperty
     | RelationshipAsEdgeTransformer
     | MakeConnectionOnExactMatch

cognite/neat/_graph/transformers/_rdfpath.py

@@ -1,59 +1,12 @@
 from typing import cast
 from urllib.parse import quote
 
-from rdflib import Graph, Namespace, URIRef
+from rdflib import Namespace, URIRef
 from rdflib.query import ResultRow
 
-from cognite.neat._rules.analysis import InformationAnalysis
-from cognite.neat._rules.models._rdfpath import RDFPath, SingleProperty
-from cognite.neat._rules.models.information import InformationRules
 from cognite.neat._utils.rdf_ import get_namespace, remove_namespace_from_uri
 
-from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
-
-
-class ReduceHopTraversal(BaseTransformer):
-    """ReduceHopTraversal is a transformer that reduces the number of hops to direct connection."""
-
-    ...
-
-
-# TODO: Standardise
-class AddSelfReferenceProperty(BaseTransformer):
-    description: str = "Adds property that contains id of reference to all references of given class in Rules"
-    _use_only_once: bool = True
-    _need_changes = frozenset({})
-    _ref_template: str = """SELECT ?s WHERE {{?s a <{type_}>}}"""
-
-    def __init__(
-        self,
-        rules: InformationRules,
-    ):
-        self.rules = rules
-        self.properties = InformationAnalysis(rules).all_reference_transformations()
-
-    def transform(self, graph: Graph) -> None:
-        for property_ in self.properties:
-            prefix = property_.instance_source.traversal.class_.prefix
-            suffix = property_.instance_source.traversal.class_.suffix
-
-            namespace = self.rules.prefixes[prefix] if prefix in self.rules.prefixes else self.rules.metadata.namespace
-
-            for (reference,) in graph.query(self._ref_template.format(type_=namespace[suffix])):  # type: ignore [misc]
-                graph.add(
-                    (
-                        reference,
-                        self.rules.metadata.namespace[property_.property_],
-                        reference,
-                    )
-                )
-
-            traversal = SingleProperty.from_string(
-                class_=property_.view.id,
-                property_=f"{self.rules.metadata.prefix}:{property_.property_}",
-            )
-
-            property_.instance_source = RDFPath(traversal=traversal)
+from ._base import BaseTransformerStandardised, RowTransformationOutput
 
 
 class MakeConnectionOnExactMatch(BaseTransformerStandardised):

cognite/neat/_issues/__init__.py

@@ -2,24 +2,19 @@
 as some helper classes to handle them like NeatIssueList"""
 
 from ._base import (
-    DefaultWarning,
     IssueList,
     MultiValueError,
     NeatError,
     NeatIssue,
-    NeatIssueList,
     NeatWarning,
-    catch_issues,
-    catch_warnings,
 )
+from ._contextmanagers import catch_issues, catch_warnings
 
 __all__ = [
-    "DefaultWarning",
     "IssueList",
     "MultiValueError",
     "NeatError",
     "NeatIssue",
-    "NeatIssueList",
     "NeatWarning",
     "catch_issues",
     "catch_warnings",

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]