ruff check

Author: ClaasRostock

src/dictIO/cli/dict_parser.py

@@ -210,13 +210,13 @@ def _validate_scope(
 
                 parser = Parser()
                 _scope: str = scope.strip(" []")
-                validated_scope = cast(list[K], [key.strip() for key in _scope.split(",")])
+                validated_scope = cast("list[K]", [key.strip() for key in _scope.split(",")])
                 parser.parse_values(validated_scope)
             except Exception:
                 logger.exception(f"setOptions: misspelled scope: {scope}")
         else:  # string is just a single value.
             # Store it not as string but as a (one-element) list
-            validated_scope = [cast(K, scope)]
+            validated_scope = [cast("K", scope)]
     else:  # 'scope' is neither a list nor a string -> set validated_scope to None
         validated_scope = None
     return validated_scope

src/dictIO/dict.py

@@ -90,11 +90,11 @@ def __init__(
         base_dict: MutableMapping[K, V] | None = None
 
         if isinstance(arg, Mapping):
-            base_dict = dict(cast(Mapping[K, V], arg))
+            base_dict = dict(cast("Mapping[K, V]", arg))
         elif isinstance(arg, str | os.PathLike):
             source_file = arg
         elif isinstance(arg, Iterable):
-            base_dict = dict(cast(Iterable[tuple[K, V]], arg))  # type: ignore[reportUnnecessaryCast]
+            base_dict = dict(cast("Iterable[tuple[K, V]]", arg))  # type: ignore[reportUnnecessaryCast]
 
         if base_dict:
             super().__init__(base_dict)
@@ -193,9 +193,9 @@ def fromkeys(
         SDict[_K, _V] | SDict[_K, Any | None]
             The created SDict instance.
         """
-        new_dict: SDict[_K, _V] = cast(SDict[_K, _V], cls())
+        new_dict: SDict[_K, _V] = cast("SDict[_K, _V]", cls())
         for key in iterable:
-            new_dict[key] = cast(_V, value)  # cast is safe, as `None` is within the type bounds of V
+            new_dict[key] = cast("_V", value)  # cast is safe, as `None` is within the type bounds of V
         return new_dict
 
     # TODO @CLAROS: Change return type to `Self` (from `typing`module)
@@ -380,10 +380,10 @@ def extract_variables_from_dict(dict_in: MutableMapping[_K, V]) -> None:
                     continue
                 if isinstance(value, MutableSequence):
                     # special case: item is a list, but does NOT contain a nested dict (-> e.g. a vector or matrix)
-                    variables[key] = cast(V, value)
+                    variables[key] = cast("V", value)
                 else:
                     # base case: item is a single value type
-                    value = cast(V, value)
+                    value = cast("V", value)
                     _value = _insert_expression(value=value, s_dict=self)
                     if not _value_contains_circular_reference(key, _value):
                         variables[key] = _value
@@ -542,8 +542,8 @@ def _recursive_merge(
                 and isinstance(dict_to_merge[key], Mapping)
             ):  # dict
                 self._recursive_merge(  # Recursion
-                    target_dict=cast(MutableMapping[K, V], target_dict[key]),
-                    dict_to_merge=cast(Mapping[K, V], dict_to_merge[key]),
+                    target_dict=cast("MutableMapping[K, V]", target_dict[key]),
+                    dict_to_merge=cast("Mapping[K, V]", dict_to_merge[key]),
                     overwrite=overwrite,
                 )
             else:
@@ -619,7 +619,7 @@ def include(self, dict_to_include: SDict[_K, _V]) -> None:
                 continue
             break
         # cast is safe, as `str` is within the type bounds of both K and V
-        self[cast(K, placeholder)] = cast(V, placeholder)
+        self[cast("K", placeholder)] = cast("V", placeholder)
         self.includes.update({ii: (include_directive, include_file_name, include_file_path)})
         return
 
@@ -657,18 +657,18 @@ def __or__(
         """
         new_dict: SDict[K | _K, V | _V]
         new_dict = cast(
-            SDict[K | _K, V | _V],
+            "SDict[K | _K, V | _V]",
             self.__class__(
                 cast(
-                    Mapping[K, V],
+                    "Mapping[K, V]",
                     super().__or__(other),
                 )
             ),
         )
         # update attributes
         new_dict._post_update(
             cast(
-                Mapping[K | _K, V | _V],
+                "Mapping[K | _K, V | _V]",
                 other,
             )
         )
@@ -711,11 +711,11 @@ def __ror__(
         """
         new_dict: SDict[K | _K, V | _V]
         new_dict = cast(
-            SDict[K | _K, V | _V],
-            self.__class__(super().__ror__(cast(dict[K, V], other))),
+            "SDict[K | _K, V | _V]",
+            self.__class__(super().__ror__(cast("dict[K, V]", other))),
         )
         # update attributes
-        new_dict._post_update(cast(SDict[K | _K, V | _V], self))
+        new_dict._post_update(cast("SDict[K | _K, V | _V]", self))
         new_dict._clean()
         return new_dict
 
@@ -1002,7 +1002,7 @@ def _clean_data(self, data: MutableMapping[K, V]) -> None:
                 if block_comment in unique_block_comments_on_this_level:
                     # Found doublette
                     # Remove from current level in data (the dict)
-                    del data[cast(K, _block_comment)]
+                    del data[cast("K", _block_comment)]
                     # ..AND from self.block_comments (the lookup table)
                     del self.block_comments[_id]
                 else:
@@ -1016,7 +1016,7 @@ def _clean_data(self, data: MutableMapping[K, V]) -> None:
                 if include in unique_includes_on_this_level:
                     # Found doublette
                     # Remove from current level in data (the dict)
-                    del data[cast(K, _include)]
+                    del data[cast("K", _include)]
                     # ..AND from self.includes (the lookup table)
                     del self.includes[_id]
                 else:
@@ -1030,7 +1030,7 @@ def _clean_data(self, data: MutableMapping[K, V]) -> None:
                 if line_comment in unique_line_comments_on_this_level:
                     # Found doublette
                     # Remove from current level in data (the dict)
-                    del data[cast(K, _line_comment)]
+                    del data[cast("K", _line_comment)]
                     # ..AND from self.line_comments (the lookup table)
                     del self.line_comments[_id]
                 else:
@@ -1076,12 +1076,12 @@ def _insert_expression(value: V, s_dict: SDict[K, V]) -> V:
     if not isinstance(value, str):
         return value
     if not re.search(r"EXPRESSION\d{6}", value):
-        return cast(V, value)
+        return cast("V", value)
     if match_index := re.search(r"\d{6}", value):
         index = int(match_index[0])
         _value = s_dict.expressions[index]["expression"] if index in s_dict.expressions else value
-        return cast(V, _value)
-    return cast(V, value)
+        return cast("V", _value)
+    return cast("V", value)
 
 
 def _value_contains_circular_reference(key: TKey, value: TValue) -> bool:

src/dictIO/dict_reader.py

@@ -177,7 +177,7 @@ def _merge_includes_recursive(parent_dict: SDict[K, V]) -> SDict[K, V]:
                 else:
                     parser = Parser.get_parser(source_file=path)
                     included_dict = cast(
-                        SDict[K, V],
+                        "SDict[K, V]",
                         parser.parse_file(
                             source_file=path,
                             target_dict=None,
@@ -286,10 +286,10 @@ def _eval_expressions(dict_in: SDict[K, V]) -> None:
                 eval_result: V | None = None
                 if "$" not in expression:
                     try:
-                        eval_result = cast(V, eval(expression))  # noqa: S307
+                        eval_result = cast("V", eval(expression))  # noqa: S307
                         eval_successful = True
                     except NameError:
-                        eval_result = cast(V, expression)
+                        eval_result = cast("V", expression)
                         eval_successful = True
                     except SyntaxError:
                         logger.warning(f'DictReader.(): evaluation of "{expression}" not yet possible')
@@ -338,7 +338,7 @@ def _eval_expressions(dict_in: SDict[K, V]) -> None:
             expression = item["expression"]
             while global_key := dict_in.find_global_key(query=placeholder):
                 # Substitute the placeholder with the original (or at least partly resolved) expression
-                dict_in.set_global_key(global_key, value=cast(V, expression))
+                dict_in.set_global_key(global_key, value=cast("V", expression))
         dict_in.expressions.clear()
 
         return
@@ -351,7 +351,7 @@ def _remove_comment_keys(data: M) -> M:
         with contextlib.suppress(Exception):
             for key in list(data.keys()):  # work on a copy of the keys
                 if isinstance(data[key], MutableMapping):
-                    sub_dict = cast(M, data[key])
+                    sub_dict = cast("M", data[key])
                     data.update({key: DictReader._remove_comment_keys(sub_dict)})  # recursion
                 elif re.search(pattern=remove, string=str(key)):
                     _ = data.pop(key)

src/dictIO/dict_writer.py

@@ -94,7 +94,7 @@ def write(
             )
             from dictIO import DictReader
 
-            existing_dict = cast(SDict[K, V], DictReader.read(source_file=target_file, order=order))
+            existing_dict = cast("SDict[K, V]", DictReader.read(source_file=target_file, order=order))
             existing_dict.merge(source_dict)
             source_dict = existing_dict
 

src/dictIO/formatter.py

@@ -9,16 +9,18 @@
 from copy import copy, deepcopy
 from pathlib import Path
 from re import Pattern
-from typing import Any, cast, overload
+from typing import TYPE_CHECKING, Any, cast, overload
 from xml.dom import minidom
 from xml.etree.ElementTree import Element, SubElement, register_namespace, tostring
 
 from numpy import ndarray
 
 from dictIO import SDict
-from dictIO.types import K, M, S, TKey, TSingleValue, TValue, V
 from dictIO.utils.counter import BorgCounter
 
+if TYPE_CHECKING:
+    from dictIO.types import K, M, S, TKey, TSingleValue, TValue, V
+
 __ALL__ = [
     "Formatter",
     "NativeFormatter",
@@ -192,9 +194,9 @@ def format_values(
                 item = _arg[index]
                 # ndarray -> list
                 if isinstance(item, ndarray):
-                    item = cast(list[TValue], item.tolist())
+                    item = cast("list[TValue]", item.tolist())
                 if isinstance(item, MutableMapping | MutableSequence):
-                    _arg[index] = self.format_values(cast(M | S, item))
+                    _arg[index] = self.format_values(cast("M | S", item))
                 else:
                     _arg[index] = self.format_value(item)
 
@@ -203,13 +205,13 @@ def format_values(
                 item = _arg[key]
                 # ndarray -> list
                 if isinstance(item, ndarray):
-                    item = cast(list[TValue], item.tolist())
+                    item = cast("list[TValue]", item.tolist())
                 if isinstance(item, MutableMapping | MutableSequence):
-                    _arg[key] = self.format_values(cast(M | S, item))
+                    _arg[key] = self.format_values(cast("M | S", item))
                 else:
                     _arg[key] = self.format_value(item)
 
-        return cast(M | S, _arg)
+        return cast("M | S", _arg)
 
     def format_key(
         self,
@@ -496,10 +498,10 @@ def to_string(
         sorted_data: dict[K, V] = {}
         for key, element in original_data.items():
             if type(key) is str and re.search(r"BLOCKCOMMENT\d{6}", key):
-                sorted_data[cast(K, key)] = element
+                sorted_data[cast("K", key)] = element
         for key, element in original_data.items():
             if type(key) is str and re.search(r"INCLUDE\d{6}", key):
-                sorted_data[cast(K, key)] = element
+                sorted_data[cast("K", key)] = element
         for key in sorted_data:
             del original_data[key]
         sorted_data |= original_data
@@ -559,7 +561,7 @@ def format_dict(
                 item = arg[index]
                 # ndarray -> list
                 if isinstance(item, ndarray):
-                    item = cast(list[TValue], item.tolist())
+                    item = cast("list[TValue]", item.tolist())
 
                 # nested list
                 if isinstance(item, MutableSequence):
@@ -632,7 +634,7 @@ def format_dict(
                 item = arg[key]
                 # ndarray -> list
                 if isinstance(item, ndarray):
-                    item = cast(list[TValue], item.tolist())
+                    item = cast("list[TValue]", item.tolist())
 
                 # nested dict
                 if isinstance(item, dict):
@@ -1168,20 +1170,20 @@ def to_string(
         # Check whether xml opts are contained in dict.
         # If so, read and use them
         if "_xmlOpts" in arg:
-            xml_opts = cast(MutableMapping[K, V], arg[cast(K, "_xmlOpts")])
+            xml_opts = cast("MutableMapping[K, V]", arg[cast("K", "_xmlOpts")])
             namespaces = (
-                cast(MutableMapping[str, str], xml_opts[cast(K, "_nameSpaces")])
+                cast("MutableMapping[str, str]", xml_opts[cast("K", "_nameSpaces")])
                 if "_nameSpaces" in xml_opts
                 else namespaces
             )
-            root_tag = str(xml_opts[cast(K, "_rootTag")]) if "_rootTag" in xml_opts else root_tag
+            root_tag = str(xml_opts[cast("K", "_rootTag")]) if "_rootTag" in xml_opts else root_tag
             root_attributes = (
-                cast(MutableMapping[str, str], xml_opts[cast(K, "_rootAttributes")])
+                cast("MutableMapping[str, str]", xml_opts[cast("K", "_rootAttributes")])
                 if "_rootAttributes" in xml_opts
                 else root_attributes
             )
             self.remove_node_numbering = (
-                bool(xml_opts[cast(K, "_removeNodeNumbering")])
+                bool(xml_opts[cast("K", "_removeNodeNumbering")])
                 if "_removeNodeNumbering" in xml_opts
                 else self.remove_node_numbering
             )