added mypy checks and some typehint changes to conform

ormar/relations/relation.py

@@ -9,6 +9,7 @@ from ormar.relations.relation_proxy import RelationProxy
 if TYPE_CHECKING:  # pragma no cover
     from ormar import Model
     from ormar.relations import RelationsManager
+    from ormar.models import NewBaseModel
 
 
 class RelationType(Enum):
@@ -19,24 +20,26 @@ class RelationType(Enum):
 
 class Relation:
     def __init__(
-        self,
-        manager: "RelationsManager",
-        type_: RelationType,
-        to: Type["Model"],
-        through: Type["Model"] = None,
+            self,
+            manager: "RelationsManager",
+            type_: RelationType,
+            to: Type["Model"],
+            through: Type["Model"] = None,
     ) -> None:
         self.manager = manager
-        self._owner = manager.owner
-        self._type = type_
-        self.to = to
-        self.through = through
-        self.related_models = (
+        self._owner: "Model" = manager.owner
+        self._type: RelationType = type_
+        self.to: Type["Model"] = to
+        self.through: Optional[Type["Model"]] = through
+        self.related_models: Optional[Union[RelationProxy, "Model"]] = (
             RelationProxy(relation=self)
             if type_ in (RelationType.REVERSE, RelationType.MULTIPLE)
             else None
         )
 
     def _find_existing(self, child: "Model") -> Optional[int]:
+        if not isinstance(self.related_models, RelationProxy):  # pragma nocover
+            raise ValueError("Cannot find existing models in parent relation type")
         for ind, relation_child in enumerate(self.related_models[:]):
             try:
                 if relation_child == child:
@@ -52,7 +55,7 @@ class Relation:
             self._owner.__dict__[relation_name] = child
         else:
             if self._find_existing(child) is None:
-                self.related_models.append(child)
+                self.related_models.append(child)  # type: ignore
                 rel = self._owner.__dict__.get(relation_name, [])
                 rel = rel or []
                 if not isinstance(rel, list):
@@ -60,19 +63,19 @@ class Relation:
                 rel.append(child)
                 self._owner.__dict__[relation_name] = rel
 
-    def remove(self, child: "Model") -> None:
+    def remove(self, child: Union["NewBaseModel", Type["NewBaseModel"]]) -> None:
         relation_name = self._owner.resolve_relation_name(self._owner, child)
         if self._type == RelationType.PRIMARY:
-            if self.related_models.__same__(child):
+            if self.related_models == child:
                 self.related_models = None
                 del self._owner.__dict__[relation_name]
         else:
             position = self._find_existing(child)
             if position is not None:
-                self.related_models.pop(position)
+                self.related_models.pop(position)  # type: ignore
                 del self._owner.__dict__[relation_name][position]
 
-    def get(self) -> Union[List["Model"], "Model"]:
+    def get(self) -> Optional[Union[List["Model"], "Model"]]:
         return self.related_models
 
     def __repr__(self) -> str:  # pragma no cover