fix bug with infinite relation auto extraction, finish initial relations docs

orm/fields/base.py

@@ -35,7 +35,7 @@ class BaseField:
     @property
     def is_required(self) -> bool:
         return (
-                not self.nullable and not self.has_default and not self.is_auto_primary_key
+            not self.nullable and not self.has_default and not self.is_auto_primary_key
         )
 
     @property

orm/fields/foreign_key.py

@@ -25,12 +25,12 @@ def create_dummy_instance(fk: Type["Model"], pk: Any = None) -> "Model":
 
 class ForeignKey(BaseField):
     def __init__(
-            self,
+        self,
-            to: Type["Model"],
+        to: Type["Model"],
-            name: str = None,
+        name: str = None,
-            related_name: str = None,
+        related_name: str = None,
-            nullable: bool = True,
+        nullable: bool = True,
-            virtual: bool = False,
+        virtual: bool = False,
     ) -> None:
         super().__init__(nullable=nullable, name=name)
         self.virtual = virtual
@@ -50,7 +50,7 @@ class ForeignKey(BaseField):
         return to_column.get_column_type()
 
     def _extract_model_from_sequence(
-            self, value: List, child: "Model"
+        self, value: List, child: "Model"
     ) -> Union["Model", List["Model"]]:
         return [self.expand_relationship(val, child) for val in value]
 
@@ -76,10 +76,12 @@ class ForeignKey(BaseField):
 
     def register_relation(self, model: "Model", child: "Model") -> None:
         child_model_name = self.related_name or child.get_name()
-        model._orm_relationship_manager.add_relation(model, child, child_model_name, virtual=self.virtual)
+        model._orm_relationship_manager.add_relation(
+            model, child, child_model_name, virtual=self.virtual
+        )
 
     def expand_relationship(
-            self, value: Any, child: "Model"
+        self, value: Any, child: "Model"
     ) -> Optional[Union["Model", List["Model"]]]:
 
         if value is None:

orm/models/metaclass.py

@@ -28,7 +28,11 @@ def parse_pydantic_field_from_model_fields(object_dict: dict) -> Dict[str, Tuple
 
 
 def register_relation_on_build(table_name: str, field: ForeignKey, name: str) -> None:
-    child_relation_name = field.to.get_name(title=True) + "_" + (field.related_name or (name.lower() + "s"))
+    child_relation_name = (
+        field.to.get_name(title=True)
+        + "_"
+        + (field.related_name or (name.lower() + "s"))
+    )
     reverse_name = child_relation_name
     relation_name = name.lower().title() + "_" + field.to.get_name()
     relationship_manager.add_relation_type(
@@ -43,14 +47,14 @@ def expand_reverse_relationships(model: Type["Model"]) -> None:
             parent_model = model_field.to
             child = model
             if (
-                    child_model_name not in parent_model.__fields__
+                child_model_name not in parent_model.__fields__
-                    and child.get_name() not in parent_model.__fields__
+                and child.get_name() not in parent_model.__fields__
             ):
                 register_reverse_model_fields(parent_model, child, child_model_name)
 
 
 def register_reverse_model_fields(
-        model: Type["Model"], child: Type["Model"], child_model_name: str
+    model: Type["Model"], child: Type["Model"], child_model_name: str
 ) -> None:
     model.__fields__[child_model_name] = ModelField(
         name=child_model_name,
@@ -64,7 +68,7 @@ def register_reverse_model_fields(
 
 
 def sqlalchemy_columns_from_model_fields(
-        name: str, object_dict: Dict, table_name: str
+    name: str, object_dict: Dict, table_name: str
 ) -> Tuple[Optional[str], List[sqlalchemy.Column], Dict[str, BaseField]]:
     columns = []
     pkname = None

orm/queryset/query.py

@@ -20,12 +20,12 @@ class JoinParameters(NamedTuple):
 
 class Query:
     def __init__(
-            self,
+        self,
-            model_cls: Type["Model"],
+        model_cls: Type["Model"],
-            filter_clauses: List,
+        filter_clauses: List,
-            select_related: List,
+        select_related: List,
-            limit_count: int,
+        limit_count: int,
-            offset: int,
+        offset: int,
     ) -> None:
 
         self.query_offset = offset
@@ -51,11 +51,11 @@ class Query:
 
         for key in self.model_cls.__model_fields__:
             if (
-                    not self.model_cls.__model_fields__[key].nullable
+                not self.model_cls.__model_fields__[key].nullable
-                    and isinstance(
+                and isinstance(
-                self.model_cls.__model_fields__[key], orm.fields.ForeignKey,
+                    self.model_cls.__model_fields__[key], orm.fields.ForeignKey,
-            )
+                )
-                    and key not in self._select_related
+                and key not in self._select_related
             ):
                 self._select_related = [key] + self._select_related
 
@@ -97,32 +97,34 @@ 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(
             [x.startswith(prev_part_of_related) for x in self._select_related]
         )
-        already_checked = any([x.startswith(rel_part) for x in (self.auto_related + self.already_checked)])
+        already_checked = any(
+            [x.startswith(rel_part) for x in (self.auto_related + self.already_checked)]
+        )
         return (
-                       (field.virtual and parent_virtual)
+            (field.virtual and parent_virtual)
-                       or (partial_match and not already_checked)
+            or (partial_match and not already_checked)
-               ) or not nested
+        ) 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 +167,15 @@ class Query:
         return JoinParameters(prev_model, previous_alias, from_table, model_cls)
 
     def _extract_auto_required_relations(
-            self,
+        self,
-            prev_model: Type["Model"],
+        prev_model: Type["Model"],
-            rel_part: str = "",
+        rel_part: str = "",
-            nested: bool = False,
+        nested: bool = False,
-            parent_virtual: 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 +183,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,
@@ -202,7 +204,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:

orm/relations.py

@@ -38,19 +38,23 @@ class RelationshipManager:
 
     def add_relation(
         self,
-            parent: "FakePydantic",
+        parent: "FakePydantic",
-            child: "FakePydantic",
+        child: "FakePydantic",
-            child_model_name: str,
+        child_model_name: str,
-            virtual: bool = False,
+        virtual: bool = False,
     ) -> None:
         parent_id, child_id = parent._orm_id, child._orm_id
-        parent_name =parent.get_name(title=True)
+        parent_name = parent.get_name(title=True)
-        child_name = child_model_name if child.get_name() != child_model_name else child.get_name()+'s'
+        child_name = (
+            child_model_name
+            if child.get_name() != child_model_name
+            else child.get_name() + "s"
+        )
         if virtual:
             child_name, parent_name = parent_name, child.get_name()
             child_id, parent_id = parent_id, child_id
             child, parent = parent, proxy(child)
-            child_name = child_name.lower()+'s'
+            child_name = child_name.lower() + "s"
         else:
             child = proxy(child)