switch to equals in most of the code, fix dependencies, clean tests, make all not relation fields work with type hints

ormar/relations/querysetproxy.py

@@ -28,28 +28,28 @@ class QuerysetProxy:
     def queryset(self, value: "QuerySet") -> None:
         self._queryset = value
 
-    def _assign_child_to_parent(self, child: Optional[T]) -> None:
+    def _assign_child_to_parent(self, child: Optional["T"]) -> None:
         if child:
             owner = self.relation._owner
             rel_name = owner.resolve_relation_name(owner, child)
             setattr(owner, rel_name, child)
 
-    def _register_related(self, child: Union[T, Sequence[Optional[T]]]) -> None:
+    def _register_related(self, child: Union["T", Sequence[Optional["T"]]]) -> None:
         if isinstance(child, list):
             for subchild in child:
                 self._assign_child_to_parent(subchild)
         else:
-            assert isinstance(child, Model)
+            assert isinstance(child, ormar.Model)
             self._assign_child_to_parent(child)
 
-    async def create_through_instance(self, child: T) -> None:
+    async def create_through_instance(self, child: "T") -> None:
         queryset = ormar.QuerySet(model_cls=self.relation.through)
         owner_column = self.relation._owner.get_name()
         child_column = child.get_name()
         kwargs = {owner_column: self.relation._owner, child_column: child}
         await queryset.create(**kwargs)
 
-    async def delete_through_instance(self, child: T) -> None:
+    async def delete_through_instance(self, child: "T") -> None:
         queryset = ormar.QuerySet(model_cls=self.relation.through)
         owner_column = self.relation._owner.get_name()
         child_column = child.get_name()

ormar/relations/relation.py

@@ -25,15 +25,15 @@ class Relation:
         self,
         manager: "RelationsManager",
         type_: RelationType,
-        to: Type[T],
-        through: Type[T] = None,
+        to: Type["T"],
+        through: Type["T"] = None,
     ) -> None:
         self.manager = manager
         self._owner: "Model" = manager.owner
         self._type: RelationType = type_
-        self.to: Type[T] = to
-        self.through: Optional[Type[T]] = through
-        self.related_models: Optional[Union[RelationProxy, T]] = (
+        self.to: Type["T"] = to
+        self.through: Optional[Type["T"]] = through
+        self.related_models: Optional[Union[RelationProxy, "T"]] = (
             RelationProxy(relation=self)
             if type_ in (RelationType.REVERSE, RelationType.MULTIPLE)
             else None
@@ -52,7 +52,7 @@ class Relation:
                 self.related_models.pop(ind)
         return None
 
-    def add(self, child: T) -> None:
+    def add(self, child: "T") -> None:
         relation_name = self._owner.resolve_relation_name(self._owner, child)
         if self._type == RelationType.PRIMARY:
             self.related_models = child
@@ -79,7 +79,7 @@ class Relation:
                 self.related_models.pop(position)  # type: ignore
                 del self._owner.__dict__[relation_name][position]
 
-    def get(self) -> Optional[Union[List[T], T]]:
+    def get(self) -> Optional[Union[List["T"], "T"]]:
         return self.related_models
 
     def __repr__(self) -> str:  # pragma no cover

ormar/relations/relation_manager.py

@@ -48,7 +48,7 @@ class RelationsManager:
     def __contains__(self, item: str) -> bool:
         return item in self._related_names
 
-    def get(self, name: str) -> Optional[Union[T, Sequence[T]]]:
+    def get(self, name: str) -> Optional[Union["T", Sequence["T"]]]:
         relation = self._relations.get(name, None)
         if relation is not None:
             return relation.get()