liniting and missin type annots

ormar/models/__init__.py

@@ -1,5 +1,5 @@
-from ormar.models.newbasemodel import NewBaseModel
-from ormar.models.model import Model
-from ormar.models.metaclass import expand_reverse_relationships
+from ormar.models.newbasemodel import NewBaseModel  # noqa I100
+from ormar.models.model import Model  # noqa I100
+from ormar.models.metaclass import expand_reverse_relationships  # noqa I100
 
 __all__ = ["NewBaseModel", "Model", "expand_reverse_relationships"]

ormar/models/model.py

@@ -7,7 +7,7 @@ import ormar.queryset  # noqa I100
 from ormar.models import NewBaseModel  # noqa I100
 
 
-def group_related_list(list_):
+def group_related_list(list_: List) -> dict:
     test_dict = dict()
     grouped = itertools.groupby(list_, key=lambda x: x.split("__")[0])
     for key, group in grouped:
@@ -45,6 +45,23 @@ class Model(NewBaseModel):
         )
 
         previous_table = cls.Meta.table.name
+
+        item = cls.populate_nested_models_from_row(
+            item, row, related_models, previous_table
+        )
+        item = cls.extract_prefixed_table_columns(item, row, table_prefix)
+
+        instance = cls(**item) if item.get(cls.Meta.pkname, None) is not None else None
+        return instance
+
+    @classmethod
+    def populate_nested_models_from_row(
+        cls,
+        item: dict,
+        row: sqlalchemy.engine.ResultProxy,
+        related_models: Any,
+        previous_table: sqlalchemy.Table,
+    ) -> dict:
         for related in related_models:
             if isinstance(related_models, dict) and related_models[related]:
                 first_part, remainder = related, related_models[related]
@@ -58,14 +75,18 @@ class Model(NewBaseModel):
                 child = model_cls.from_row(row, previous_table=previous_table)
                 item[related] = child
 
+        return item
+
+    @classmethod
+    def extract_prefixed_table_columns(
+        cls, item: dict, row: sqlalchemy.engine.result.ResultProxy, table_prefix: str
+    ) -> dict:
         for column in cls.Meta.table.columns:
             if column.name not in item:
                 item[column.name] = row[
                     f'{table_prefix + "_" if table_prefix else ""}{column.name}'
                 ]
-
-        instance = cls(**item) if item.get(cls.Meta.pkname, None) is not None else None
-        return instance
+        return item
 
     async def save(self) -> "Model":
         self_fields = self._extract_model_db_fields()
@@ -85,11 +106,9 @@ class Model(NewBaseModel):
 
         self_fields = self._extract_model_db_fields()
         self_fields.pop(self.Meta.pkname)
-        expr = (
-            self.Meta.table.update()
-            .values(**self_fields)
-            .where(self.pk_column == getattr(self, self.Meta.pkname))
-        )
+        expr = self.Meta.table.update().values(**self_fields)
+        expr = expr.where(self.pk_column == getattr(self, self.Meta.pkname))
+
         await self.Meta.database.execute(expr)
         return self
 

ormar/models/modelproxy.py

@@ -1,6 +1,5 @@
-import copy
 import inspect
-from typing import List, Set, TYPE_CHECKING
+from typing import List, Optional, Set, TYPE_CHECKING
 
 import ormar
 from ormar.fields.foreign_key import ForeignKeyField
@@ -80,11 +79,12 @@ class ModelTableProxy:
         return self_fields
 
     @staticmethod
-    def resolve_relation_name(item: "Model", related: "Model"):
+    def resolve_relation_name(item: "Model", related: "Model") -> Optional[str]:
         for name, field in item.Meta.model_fields.items():
             if issubclass(field, ForeignKeyField):
-                # fastapi is creating clones of response model that's why it can be a subclass
-                # of the original one so we need to compare Meta too
+                # fastapi is creating clones of response model
+                # that's why it can be a subclass of the original model
+                # so we need to compare Meta too as this one is copied as is
                 if field.to == related.__class__ or field.to.Meta == related.Meta:
                     return name
 

ormar/models/newbasemodel.py

@@ -153,7 +153,7 @@ class NewBaseModel(pydantic.BaseModel, ModelTableProxy, metaclass=ModelMetaclass
     def pk_type(cls) -> Any:
         return cls.Meta.model_fields[cls.Meta.pkname].__type__
 
-    def remove(self, name: "Model"):
+    def remove(self, name: "Model") -> None:
         self._orm.remove_parent(self, name)
 
     def dict(  # noqa A003