Fixed a bunch of flake8 errors

Author: sveinugu

scripts/omnipy_import.py

@@ -1,11 +1,5 @@
 def omnipy_import() -> None:
-    import omnipy
-    import omnipy._dynamic_all
-    omnipy.data
-    from omnipy import Model
-    import omnipy.data
-
-    # omnipy._dynamic_all.data
+    import omnipy._dynamic_all  # noqa: F401
 
 
 omnipy_import()

src/omnipy/_dynamic_all.py

@@ -76,7 +76,7 @@
 
     for module_name, module in _all_modules.items():
         for attr in dir(module):
-            if not attr.startswith('_') and not attr in _all_element_names:
+            if not attr.startswith('_') and attr not in _all_element_names:
                 val = getattr(module, attr)
                 if attr in _exclude_attrs:
                     continue
@@ -90,20 +90,7 @@
                     __all__.append(attr)
 
     print(f'Missing elements in omnipy.__init__(): {_all_element_names - _omnipy_all}')
-    print(
-        f'Missing elements in hardcoded __all__ in _dynamic_all(): {_omnipy_all - _all_element_names}'
-    )
+    print(f'Missing elements in hardcoded __all__ in _dynamic_all(): '
+          f'{_omnipy_all - _all_element_names}')
 
     del JobTemplateMixin
-
-# from omnipy import __all__ as prev_all
-#
-# prev_all_set = set(prev_all)
-#
-# print(f'__all__: {__all__}')
-# print(
-#     f'_all_element_names - prev_all: {[_ for _ in __all__ if _ in (_all_element_names - prev_all_set)]}'
-# )
-# print(
-#     f'prev_all - _all_element_names: {[_ for _ in prev_all if _ in (prev_all_set - _all_element_names)]}'
-# )

src/omnipy/api/protocols/private/data.py

@@ -4,7 +4,7 @@
 from omnipy.api.protocols.public.config import IsDataConfig
 
 _ObjT = TypeVar('_ObjT', bound=object)
-_ContentsT = TypeVar("_ContentsT", bound=object)
+_ContentsT = TypeVar('_ContentsT', bound=object)
 
 
 class IsDataClassCreator(Protocol[_ObjT, _ContentsT]):

src/omnipy/api/protocols/private/util.py

@@ -7,9 +7,9 @@
 _ObjContraT = TypeVar('_ObjContraT', contravariant=True, bound=object)
 _AnyKeyT = TypeVar('_AnyKeyT', contravariant=True, bound=object)
 _ValT = TypeVar('_ValT', bound=object)
-_ContentsT = TypeVar("_ContentsT", bound=object)
-_ContentCovT = TypeVar("_ContentCovT", covariant=True, bound=object)
-_ContentContraT = TypeVar("_ContentContraT", contravariant=True, bound=object)
+_ContentsT = TypeVar('_ContentsT', bound=object)
+_ContentCovT = TypeVar('_ContentCovT', covariant=True, bound=object)
+_ContentContraT = TypeVar('_ContentContraT', contravariant=True, bound=object)
 _HasContentsT = TypeVar('_HasContentsT', bound='HasContents')
 
 

src/omnipy/data/data_class_creator.py

@@ -1,6 +1,6 @@
 from abc import ABCMeta
 from contextlib import contextmanager
-from typing import Callable, ContextManager, Generic, Iterator, TypeVar
+from typing import Callable, ContextManager, Iterator
 
 from omnipy.api.protocols.private.data import IsDataClassCreator
 from omnipy.api.protocols.private.util import IsSnapshotHolder

src/omnipy/data/dataset.py

@@ -530,11 +530,13 @@ def load(self, *path_or_urls: str, by_file_suffix=False):
                     raise ValueError(f'Unsupported scheme "{parsed_url.scheme}"')
 
                 if by_file_suffix:
-                    loaded_dataset = serializer_registry.load_from_tar_file_path_based_on_file_suffix(
-                        self, tar_gz_file_path, self)
+                    loaded_dataset = \
+                        serializer_registry.load_from_tar_file_path_based_on_file_suffix(
+                            self, tar_gz_file_path, self)
                 else:
-                    loaded_dataset = serializer_registry.load_from_tar_file_path_based_on_dataset_cls(
-                        self, tar_gz_file_path, self)
+                    loaded_dataset = \
+                        serializer_registry.load_from_tar_file_path_based_on_dataset_cls(
+                            self, tar_gz_file_path, self)
                 if loaded_dataset is not None:
                     self.absorb(loaded_dataset)
                     continue

src/omnipy/data/missing.py

@@ -43,19 +43,18 @@ def parse_none_according_to_model(value: _RootT, root_model) -> _RootT:  # IsMod
             raise OmnipyNoneIsNotAllowedError()
 
     else:
-        union_variant_types = _split_outer_type_to_union_variants(outer_args)
-        flattened_union_variant_types = _flatten_two_level_tuple(union_variant_types)
+        union_variants = _split_outer_type_to_union_variants(outer_args)
+        flattened_union_variants = _flatten_two_level_tuple(union_variants)
 
-        if any(is_model_subclass(type_) or _supports_none(type_) \
-               for type_ in flattened_union_variant_types):
+        if any(is_model_subclass(tp_) or _supports_none(tp_) for tp_ in flattened_union_variants):
 
             # Fixed tuples
             if _outer_type_and_value_are_of_types(plain_outer_type, value, tuple) and outer_args:
-                return _parse_none_in_fixed_tuple(plain_outer_type, union_variant_types, value)
+                return _parse_none_in_fixed_tuple(plain_outer_type, union_variants, value)
 
             # Unions
             if is_union(plain_outer_type):
-                return _parse_none_in_union(flattened_union_variant_types, value)
+                return _parse_none_in_union(flattened_union_variants, value)
 
     return value
 
@@ -81,8 +80,9 @@ def _supports_none(type_: TypeForm) -> bool:
 
 
 def _outer_type_and_value_are_of_types(plain_outer_type, value, *types):
-    return any(lenient_issubclass(plain_outer_type, type_) and lenient_isinstance(value, type_) \
-               for type_ in types)
+    return any(
+        lenient_issubclass(plain_outer_type, type_) and lenient_isinstance(value, type_)
+        for type_ in types)
 
 
 def _parse_none_in_mutable_sequence_or_tuple(plain_outer_type, inner_val_type, value):
@@ -101,7 +101,8 @@ def _parse_none_in_mapping(plain_outer_type, outer_type_args, inner_val_type, va
         plain_outer_type, Mapping) and outer_type_args else Undefined
     inner_key_union_types = _split_to_union_variants(inner_key_type)
 
-    if any(is_model_subclass(_) or _supports_none(_) \
+    if any(
+            is_model_subclass(_) or _supports_none(_)
             for _ in chain(inner_key_union_types, inner_val_union_types)):
         return plain_outer_type({
             _parse_none_in_types(inner_key_union_types) if key is None else key:

src/omnipy/data/model.py

@@ -160,7 +160,10 @@ def default_factory() -> _RootT:
         return default_factory
 
     @classmethod
-    def _get_default_value_from_model(cls, model: type[_RootT] | TypeForm | TypeVar) -> _RootT:
+    def _get_default_value_from_model(  # noqa: C901
+            cls,
+            model: type[_RootT] | TypeForm | TypeVar,
+    ) -> _RootT:
         model = get_default_if_typevar(model)
         origin_type = get_origin(model)
         args = get_args(model)
@@ -322,7 +325,7 @@ def set_orig_model(cls, orig_model: type[_RootT]) -> None:
 
     # TODO: Allow e.g. Model[str](Model[int](5)) == Model[str](Model[int](5).contents).
     #       Should then work the same as dataset
-    def __init__(
+    def __init__(  # noqa: C901
         self,
         value: Any | UndefinedType = Undefined,
         *,
@@ -509,9 +512,9 @@ def _prepare_reset_solution_take_snapshot_if_needed(
         snapshot_taken = False
         if self.config.interactive_mode:
             # TODO: Lazy snapshotting causes unneeded double validation for data that is later
-            #       validated for snapshot. Perhaps add a dirty flag to snapshot that can be used to
-            #       determine if re-validation is needed? This can also help avoid equality tests, which
-            #       might be expensive for large data structures.
+            #       validated for snapshot. Perhaps add a dirty flag to snapshot that can be used
+            #       to determine if re-validation is needed? This can also help avoid equality
+            #       tests, which might be expensive for large data structures.
             needs_pre_validation = (not self.has_snapshot()
                                     or not self.contents_validated_according_to_snapshot())
             if needs_pre_validation:
@@ -622,7 +625,7 @@ def snapshot_differs_from_model(self, model: 'Model') -> bool:
 
     def contents_validated_according_to_snapshot(self) -> bool:
         needs_validation = self.snapshot_differs_from_model(self) \
-                           or not self.snapshot_taken_of_same_model(self)
+            or not self.snapshot_taken_of_same_model(self)
         return not needs_validation
 
     def _take_snapshot_of_validated_contents(self) -> None:
@@ -878,7 +881,12 @@ def _call_special_method_and_return_self_if_inplace(*inner_args: object,
 
         return ret
 
-    def _call_special_method(self, name: str, *args: object, **kwargs: object) -> object:
+    def _call_special_method(  # noqa: C901
+            self,
+            name: str,
+            *args: object,
+            **kwargs: object,
+    ) -> object:
         contents = self._get_real_contents()
         has_add_method = hasattr(contents, '__add__')
         has_radd_method = hasattr(contents, '__radd__')
@@ -1027,12 +1035,14 @@ def _get_convert_element_value_model_generator(
             self, elements: Iterable | None) -> Callable[..., Generator]:
         def _convert_element_value_model_generator(elements=elements):
             for el in elements:
-                yield (el[0],
-                       self._convert_to_model_if_reasonable(
-                           el[1],
-                           level_up=True,
-                           level_up_arg_idx=1,
-                       ))
+                yield (
+                    el[0],
+                    self._convert_to_model_if_reasonable(
+                        el[1],
+                        level_up=True,
+                        level_up_arg_idx=1,
+                    ),
+                )
 
         return _convert_element_value_model_generator
 
@@ -1142,7 +1152,6 @@ def _validate_contents(ret: Any):
                                                     reset_solution)
 
         if attr in ('values', 'items'):
-            level_up_arg_idx: int | slice
             match attr:
                 case 'values':
                     _model_generator = self._get_convert_full_element_model_generator(

src/omnipy/data/param.py

@@ -21,7 +21,7 @@ def __init__(cls, name: str, bases: tuple[type, ...], namespace: dict[str, objec
         default_vals = {}
         for field in model_cls.__fields__.values():
             if field.default_factory is not None:
-                raise ValueError(f"Default factory is not supported for Params classes")
+                raise ValueError('Default factory is not supported for Params classes')
 
             default_vals[field.name] = field.get_default()
             if default_vals[field.name] is None and not field.allow_none:

src/omnipy/data/selector.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Iterable, Mapping, MutableMapping, TypeAlias
+from typing import Iterable, MutableMapping, TypeAlias
 
 from typing_extensions import TypeVar