clean code

orm/queryset/query.py

@@ -1,9 +1,9 @@
-from typing import NamedTuple, Type, List, Tuple, TYPE_CHECKING
+from typing import List, NamedTuple, TYPE_CHECKING, Tuple, Type
 
 import sqlalchemy
 from sqlalchemy import text
 
-import orm
+import orm  # noqa I100
 from orm import ForeignKey
 from orm.fields import BaseField
 
@@ -20,12 +20,12 @@ class JoinParameters(NamedTuple):
 
 class Query:
     def __init__(
-            self,
-            model_cls: Type["Model"],
-            filter_clauses: List,
-            select_related: List,
-            limit_count: int,
-            offset: int,
+        self,
+        model_cls: Type["Model"],
+        filter_clauses: List,
+        select_related: List,
+        limit_count: int,
+        offset: int,
     ) -> None:
 
         self.query_offset = offset
@@ -50,12 +50,12 @@ class Query:
 
         for key in self.model_cls.__model_fields__:
             if (
-                    not self.model_cls.__model_fields__[key].nullable
-                    and isinstance(
-                self.model_cls.__model_fields__[key],
-                orm.fields.foreign_key.ForeignKey,
-            )
-                    and key not in self._select_related
+                not self.model_cls.__model_fields__[key].nullable
+                and isinstance(
+                    self.model_cls.__model_fields__[key],
+                    orm.fields.foreign_key.ForeignKey,
+                )
+                and key not in self._select_related
             ):
                 self._select_related = [key] + self._select_related
 
@@ -97,12 +97,12 @@ class Query:
 
     @staticmethod
     def _field_is_a_foreign_key_and_no_circular_reference(
-            field: BaseField, field_name: str, rel_part: str
+        field: BaseField, field_name: str, rel_part: str
     ) -> bool:
         return isinstance(field, ForeignKey) and field_name not in rel_part
 
     def _field_qualifies_to_deeper_search(
-            self, field: ForeignKey, parent_virtual: bool, nested: bool, rel_part: str
+        self, field: ForeignKey, parent_virtual: bool, nested: bool, rel_part: str
     ) -> bool:
         prev_part_of_related = "__".join(rel_part.split("__")[:-1])
         partial_match = any(
@@ -110,19 +110,19 @@ class Query:
         )
         already_checked = any([x.startswith(rel_part) for x in self.auto_related])
         return (
-                       (field.virtual and parent_virtual)
-                       or (partial_match and not already_checked)
-               ) or not nested
+            (field.virtual and parent_virtual)
+            or (partial_match and not already_checked)
+        ) or not nested
 
     def on_clause(
-            self, previous_alias: str, alias: str, from_clause: str, to_clause: str,
+        self, previous_alias: str, alias: str, from_clause: str, to_clause: str,
     ) -> text:
         left_part = f"{alias}_{to_clause}"
         right_part = f"{previous_alias + '_' if previous_alias else ''}{from_clause}"
         return text(f"{left_part}={right_part}")
 
     def _build_join_parameters(
-            self, part: str, join_params: JoinParameters
+        self, part: str, join_params: JoinParameters
     ) -> JoinParameters:
         model_cls = join_params.model_cls.__model_fields__[part].to
         to_table = model_cls.__table__.name
@@ -165,15 +165,15 @@ class Query:
         return JoinParameters(prev_model, previous_alias, from_table, model_cls)
 
     def _extract_auto_required_relations(
-            self,
-            prev_model: Type["Model"],
-            rel_part: str = "",
-            nested: bool = False,
-            parent_virtual: bool = False,
+        self,
+        prev_model: Type["Model"],
+        rel_part: str = "",
+        nested: bool = False,
+        parent_virtual: bool = False,
     ) -> None:
         for field_name, field in prev_model.__model_fields__.items():
             if self._field_is_a_foreign_key_and_no_circular_reference(
-                    field, field_name, rel_part
+                field, field_name, rel_part
             ):
                 rel_part = field_name if not rel_part else rel_part + "__" + field_name
                 if not field.nullable:
@@ -181,7 +181,7 @@ class Query:
                         self.auto_related.append("__".join(rel_part.split("__")[:-1]))
                     rel_part = ""
                 elif self._field_qualifies_to_deeper_search(
-                        field, parent_virtual, nested, rel_part
+                    field, parent_virtual, nested, rel_part
                 ):
                     self._extract_auto_required_relations(
                         prev_model=field.to,
@@ -201,7 +201,7 @@ class Query:
             self._select_related = new_joins + self.auto_related
 
     def _apply_expression_modifiers(
-            self, expr: sqlalchemy.sql.select
+        self, expr: sqlalchemy.sql.select
     ) -> sqlalchemy.sql.select:
         if self.filter_clauses:
             if len(self.filter_clauses) == 1: