From aa080543d0e739950afb7ba350ffabf064f96e01 Mon Sep 17 00:00:00 2001
From: Tyler Goodlet <jgbt@protonmail.com>
Date: Thu, 1 Jul 2021 14:52:52 -0400
Subject: [PATCH] Mypy fixes to enforce uid tuple

---
 tractor/_actor.py | 23 ++++++++++++++---------
 tractor/_ipc.py   | 18 ++++++++++--------
 2 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/tractor/_actor.py b/tractor/_actor.py
index bc723e6..ee7a1d8 100644
--- a/tractor/_actor.py
+++ b/tractor/_actor.py
@@ -287,7 +287,7 @@ class Actor:
         enable_modules: List[str] = [],
         uid: str = None,
         loglevel: str = None,
-        arbiter_addr: Optional[Tuple[str, int]] = (None, None),
+        arbiter_addr: Optional[Tuple[str, int]] = None,
         spawn_method: Optional[str] = None
     ) -> None:
         """This constructor is called in the parent actor **before** the spawning
@@ -317,7 +317,8 @@ class Actor:
         # TODO: consider making this a dynamically defined
         # @dataclass once we get py3.7
         self.loglevel = loglevel
-        self._arb_addr = tuple(arbiter_addr)
+
+        self._arb_addr = arbiter_addr or (None, None)
 
         # marked by the process spawning backend at startup
         # will be None for the parent most process started manually
@@ -796,7 +797,8 @@ class Actor:
                         # XXX: msgspec doesn't support serializing tuples
                         # so just cash manually here since it's what our
                         # internals expect.
-                        self._arb_addr = tuple(value)
+                        address: Tuple[str, int] = value
+                        self._arb_addr = value
 
                     else:
                         setattr(self, attr, value)
@@ -1171,6 +1173,7 @@ class Actor:
     async def _do_handshake(
         self,
         chan: Channel
+
     ) -> Tuple[str, str]:
         """Exchange (name, UUIDs) identifiers as the first communication step.
 
@@ -1178,10 +1181,10 @@ class Actor:
         parlance.
         """
         await chan.send(self.uid)
-        uid: Tuple[str, str] = tuple(await chan.recv())
+        uid: Tuple[str, str] = await chan.recv()
 
-        # if not isinstance(uid, tuple):
-        #     raise ValueError(f"{uid} is not a valid uid?!")
+        if not isinstance(uid, tuple):
+            raise ValueError(f"{uid} is not a valid uid?!")
 
         chan.uid = uid
         log.runtime(f"Handshake with actor {uid}@{chan.raddr} complete")
@@ -1246,10 +1249,12 @@ class Arbiter(Actor):
         return sockaddrs
 
     async def register_actor(
-        self, uid: Tuple[str, str], sockaddr: Tuple[str, int]
+        self,
+        uid: Tuple[str, str],
+        sockaddr: Tuple[str, str]
+
     ) -> None:
-        uid = tuple(uid)
-        name, uuid = uid
+        name, uuid = tuple(uid)
         self._registry[uid] = tuple(sockaddr)
 
         # pop and signal all waiter events
diff --git a/tractor/_ipc.py b/tractor/_ipc.py
index 6af1fc6..0ed8b8e 100644
--- a/tractor/_ipc.py
+++ b/tractor/_ipc.py
@@ -160,7 +160,7 @@ class MsgspecTCPStream(MsgpackTCPStream):
 
             size, = struct.unpack("<I", header)
 
-            log.trace(f'received header {size}')
+            log.trace(f'received header {size}')  # type: ignore
 
             msg_bytes = await self.recv_stream.receive_exactly(size)
 
@@ -170,11 +170,11 @@ class MsgspecTCPStream(MsgpackTCPStream):
     async def send(self, data: Any) -> None:
         async with self._send_lock:
 
-            bytes_data = self.encode(data)
+            bytes_data: bytes = self.encode(data)
 
             # supposedly the fastest says,
             # https://stackoverflow.com/a/54027962
-            size: int = struct.pack("<I", len(bytes_data))
+            size: bytes = struct.pack("<I", len(bytes_data))
 
             return await self.stream.send_all(size + bytes_data)
 
@@ -197,17 +197,17 @@ class Channel:
         self._recon_seq = on_reconnect
         self._autorecon = auto_reconnect
 
+        stream_serializer_type = MsgpackTCPStream
+
         try:
             # if installed load the msgspec transport since it's faster
             import msgspec  # noqa
-            stream_serializer_type: type = MsgspecTCPStream
-
+            stream_serializer_type = MsgspecTCPStream
         except ImportError:
-            stream_serializer_type: type = MsgpackTCPStream
+            pass
 
         self.stream_serializer_type = stream_serializer_type
-        self.msgstream: Optional[type] = stream_serializer_type(
-            stream) if stream else None
+        self.msgstream = stream_serializer_type(stream) if stream else None
 
         if self.msgstream and destaddr:
             raise ValueError(
@@ -215,8 +215,10 @@ class Channel:
             )
 
         self._destaddr = self.msgstream.raddr if self.msgstream else destaddr
+
         # set after handshake - always uid of far end
         self.uid: Optional[Tuple[str, str]] = None
+
         # set if far end actor errors internally
         self._exc: Optional[Exception] = None
         self._agen = self._aiter_recv()