diff --git a/orm/fields/base.py b/orm/fields/base.py index 73b3131..003d14e 100644 --- a/orm/fields/base.py +++ b/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 diff --git a/orm/fields/foreign_key.py b/orm/fields/foreign_key.py index 81398e2..839ca95 100644 --- a/orm/fields/foreign_key.py +++ b/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, - to: Type["Model"], - name: str = None, - related_name: str = None, - nullable: bool = True, - virtual: bool = False, + self, + to: Type["Model"], + name: str = None, + related_name: str = None, + nullable: bool = True, + 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: diff --git a/orm/models/metaclass.py b/orm/models/metaclass.py index 13a237c..f519791 100644 --- a/orm/models/metaclass.py +++ b/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__ - and child.get_name() not in parent_model.__fields__ + child_model_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 diff --git a/orm/queryset/query.py b/orm/queryset/query.py index 75f41f3..bf6234f 100644 --- a/orm/queryset/query.py +++ b/orm/queryset/query.py @@ -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 @@ -51,11 +51,11 @@ 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.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.ForeignKey, + ) + 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) - 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 +167,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 +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: diff --git a/orm/relations.py b/orm/relations.py index 59ec981..9df7ee7 100644 --- a/orm/relations.py +++ b/orm/relations.py @@ -38,19 +38,23 @@ class RelationshipManager: def add_relation( self, - parent: "FakePydantic", - child: "FakePydantic", - child_model_name: str, - virtual: bool = False, + parent: "FakePydantic", + child: "FakePydantic", + child_model_name: str, + virtual: bool = False, ) -> None: parent_id, child_id = parent._orm_id, child._orm_id - parent_name =parent.get_name(title=True) - child_name = child_model_name if child.get_name() != child_model_name else child.get_name()+'s' + parent_name = parent.get_name(title=True) + 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)