pyright strict

Author: joente

.github/workflows/ci.yml

@@ -24,7 +24,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install pytest pycodestyle pyright websockets
+          pip install pytest pycodestyle pyright aiohttp
           if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
       - name: Run tests with pytest
         run: |

examples/bookstore/webserver.py

@@ -27,8 +27,9 @@
 """
 import asyncio
 from sys import argv
+from typing import TypedDict
 from functools import partial
-from aiohttp import web  # type: ignore
+from aiohttp import web
 from thingsdb.client import Client
 from thingsdb.room import Room, event
 
@@ -37,11 +38,14 @@
 
 bookstore = None
 
+class Book(TypedDict):
+    title: str
+
 
 class BookStore(Room):
 
     def on_init(self):
-        self.books = []
+        self.books: list[Book] = []
         self.add_book = partial(self.client.run, 'add_book')
 
     async def on_join(self):
@@ -50,7 +54,7 @@ async def on_join(self):
         """)
 
     @event('add-book')
-    def on_add_book(self, book):
+    def on_add_book(self, book: Book):
         self.books.append(book)
 
 
@@ -59,7 +63,7 @@ def on_cleanup():
     return client.wait_closed()
 
 
-async def add_book(request):
+async def add_book(request: web.Request):
     book = await request.json()
     # Use the procedure to add the book
     assert bookstore
@@ -68,17 +72,17 @@ async def add_book(request):
 
 
 # We have the books in memory, no need for a query
-async def get_books(request):
+async def get_books(request: web.Request):
     assert bookstore
     return web.json_response({
         "book_titles": [book['title'] for book in bookstore.books]
     })
 
 
-async def setup(client):
+async def setup(client: Client):
     global bookstore
 
-    await client.connect('playground.thingsdb.net', '9400')
+    await client.connect('playground.thingsdb.net', 9400)
     await client.authenticate(THINGSDB_AUTH_TOKEN)
 
     bookstore = BookStore("""//ti

pyproject.toml

@@ -1,2 +1,3 @@
 [tool.pyright]
-typeCheckingMode = "basic"
+typeCheckingMode = "strict"
+reportPrivateUsage = "none"

requirements.txt

@@ -1,4 +1,3 @@
-msgpack>=0.6.2
-deprecation
-# Optional package:
-# websockets
+msgpack
+msgpack-types  # optional
+websockets  # optional

setup.py

@@ -50,7 +50,6 @@
     ],
     install_requires=[
         'msgpack',
-        'deprecation'
     ],
     keywords='database connector',
 

thingsdb/__init__.py

@@ -1 +1 @@
-from .version import __version__
+from .version import __version__  # type: ignore  # noqa: F401

thingsdb/client/__init__.py

@@ -1,2 +1,2 @@
-from .client import Client
-from .package import set_package_fail_file
+from .client import Client  # type: ignore  # noqa: F401
+from .package import set_package_fail_file  # type: ignore  # noqa: F401

thingsdb/client/baseprotocol.py

@@ -108,7 +108,9 @@ class Err(enum.IntEnum):
     Err.EX_INTERNAL: InternalError,
 }
 
-_PROTO_RESPONSE_MAP = {
+_PROTO_RESPONSE_MAP: dict[
+        Proto,
+        Callable[[asyncio.Future[None], Any], None]] = {
     Proto.RES_PING: lambda f, d: f.set_result(None),
     Proto.RES_OK: lambda f, d: f.set_result(None),
     Proto.RES_DATA: lambda f, d: f.set_result(d),
@@ -127,24 +129,28 @@ class Err(enum.IntEnum):
 )
 
 
-def proto_unknown(f, d):
-    f.set_exception(TypeError('unknown package type received ({})'.format(d)))
+def proto_unknown(f: asyncio.Future[None], d: Any):
+    f.set_exception(TypeError(f'unknown package type received ({d})'))
 
 
 class BaseProtocol:
     def __init__(
             self,
             on_connection_lost: Callable[[asyncio.Protocol, Exception], None],
             on_event: Callable[[Package], None],):
-        self._requests = {}
+        self._requests: dict[
+            int,
+            tuple[
+                asyncio.Future[Any],
+                asyncio.Task[None] | None]] = {}
         self._pid = 0
         self._on_connection_lost = on_connection_lost
         self._on_event = on_event
 
     async def _timer(self, pid: int, timeout: int) -> None:
         await asyncio.sleep(timeout)
         try:
-            future, task = self._requests.pop(pid)
+            future, _task = self._requests.pop(pid)
         except KeyError:
             logging.error(f'Timed out package Id not found: {pid}')
             return None
@@ -194,9 +200,12 @@ def write(
         self._pid += 1
         self._pid %= 0x10000  # pid is handled as uint16_t
 
-        data = data if is_bin else b'' if data is None else \
+        data = (   # type: ignore
+            data if is_bin else b'' if data is None else \
             msgpack.packb(data, use_bin_type=True)
+        )
 
+        assert isinstance(data, bytes)
         header = Package.st_package.pack(
             len(data),
             self._pid,
@@ -208,7 +217,7 @@ def write(
         task = asyncio.ensure_future(
             self._timer(self._pid, timeout)) if timeout else None
 
-        future = asyncio.Future()
+        future: asyncio.Future[None] = asyncio.Future()
         self._requests[self._pid] = (future, task)
         return future
 

thingsdb/client/client.py

@@ -1,16 +1,20 @@
+from __future__ import annotations
 import asyncio
 import logging
 import random
 import ssl
 import time
 from collections import defaultdict
 from ssl import SSLContext, PROTOCOL_TLS
-from typing import Any
+from typing import Any, TYPE_CHECKING
 from concurrent.futures import CancelledError
 from .buildin import Buildin
 from .protocol import Proto, Protocol, ProtocolWS
 from ..exceptions import NodeError, AuthError
 from ..util import strip_code
+if TYPE_CHECKING:
+    from ..room.roombase import RoomBase
+    from ..client.package import Package
 
 
 class Client(Buildin):
@@ -54,7 +58,7 @@ def __init__(
         self._scope = '@t'  # default to thingsdb scope
         self._pool_idx = 0
         self._reconnecting = False
-        self._rooms = dict()
+        self._rooms: dict[int, RoomBase] = dict()
         self._rooms_lock = asyncio.Lock()
 
         if ssl is True:
@@ -64,7 +68,7 @@ def __init__(
         else:
             self._ssl = ssl
 
-    def get_rooms(self):
+    def get_rooms(self) -> tuple[RoomBase, ...]:
         """Can be used to get the rooms which are joined.
 
         Returns:
@@ -185,12 +189,18 @@ def connect_pool(
         assert self._reconnecting is False
         assert len(pool), 'pool must contain at least one node'
         if len(auth) == 1:
-            auth = auth[0]  # type: ignore
+            _auth = auth[0]  # token or tuple[str, str]
+        elif len(auth) == 2 and \
+                isinstance(auth[0], str) and \
+                isinstance(auth[1], str):
+            _auth = (auth[0], auth[1])  # username/password
+        else:
+            raise TypeError('wrong or missing authentication arguments')
 
         self._pool = tuple((
             (address, 9200) if isinstance(address, str) else address
             for address in pool))
-        self._auth = self._auth_check(auth)
+        self._auth = self._auth_check(_auth)
         self._pool_idx = random.randint(0, len(pool) - 1)
         fut = self.reconnect()
         if fut is None:
@@ -291,8 +301,15 @@ async def authenticate(
                 wait forever on a response. Defaults to 5.
         """
         if len(auth) == 1:
-            auth = auth[0]  # type: ignore
-        self._auth = self._auth_check(auth)
+            _auth = auth[0]  # token or tuple[str, str]
+        elif len(auth) == 2 and \
+                isinstance(auth[0], str) and \
+                isinstance(auth[1], str):
+            _auth = (auth[0], auth[1])  # username/password
+        else:
+            raise TypeError('wrong or missing authentication arguments')
+
+        self._auth = self._auth_check(_auth)
         await self._authenticate(timeout)
 
     def query(
@@ -568,7 +585,7 @@ def _leave(self, *ids: int | str,
         return self._write_pkg(Proto.REQ_LEAVE, [scope, *ids])  # type: ignore
 
     @staticmethod
-    def _auth_check(auth):
+    def _auth_check(auth: str | tuple[str, str]) -> str | tuple[str, str]:
         assert ((
             isinstance(auth, (list, tuple)) and
             len(auth) == 2 and
@@ -583,7 +600,7 @@ def _auth_check(auth):
         return auth
 
     @staticmethod
-    def _is_websocket_host(host):
+    def _is_websocket_host(host: str) -> bool:
         return host.startswith('ws://') or host.startswith('wss://')
 
     async def _connect(self, timeout: int | None = 5):
@@ -615,7 +632,7 @@ async def _connect(self, timeout: int | None = 5):
             self._pool_idx += 1
             self._pool_idx %= len(self._pool)
 
-    async def _on_room(self, room_id, pkg):
+    async def _on_room(self, room_id: int, pkg: Package):
         async with self._rooms_lock:
             try:
                 room = self._rooms[room_id]
@@ -628,8 +645,9 @@ async def _on_room(self, room_id, pkg):
                 if isinstance(task, asyncio.Task):
                     await task
 
-    def _on_event(self, pkg):
+    def _on_event(self, pkg: Package):
         if pkg.tp == Proto.ON_NODE_STATUS:
+            assert pkg.data is not None
             status, node_id = pkg.data['status'], pkg.data['id']
 
             if self._reconnect and status == 'SHUTTING_DOWN':
@@ -654,7 +672,7 @@ def _on_event(self, pkg):
             asyncio.ensure_future(self._on_room(room_id, pkg),
                                   loop=self.get_event_loop())
 
-    def _on_connection_lost(self, protocol, exc):
+    def _on_connection_lost(self, protocol: asyncio.Protocol, exc: Exception):
         if self._protocol is not protocol:
             return
         self._protocol = None
@@ -695,20 +713,23 @@ async def _reconnect_loop(self):
         finally:
             self._reconnecting = False
 
-    def _ping(self, timeout):
-        return self._write(Proto.REQ_PING, timeout=timeout)
+    async def _ping(self, timeout: int | None):
+        return await self._write(Proto.REQ_PING, timeout=timeout)
 
-    def _authenticate(self, timeout):
-        return self._write(Proto.REQ_AUTH, data=self._auth, timeout=timeout)
+    async def _authenticate(self, timeout: int | None) -> asyncio.Future[Any]:
+        return await self._write(
+            Proto.REQ_AUTH,
+            data=self._auth,
+            timeout=timeout)
 
     async def _rejoin(self):
         if not self._rooms:
             return  # do nothig if no rooms are used
 
         # re-arrange the rooms per scope to combine joins in a less requests
-        scopes = defaultdict(list)
+        scopes: dict[str, list[int]] = defaultdict(list)
         for room in self._rooms.values():
-            if room.id:
+            if room.id and room.scope:
                 scopes[room.scope].append(room.id)
 
         # join request per scope, each for one or more rooms

thingsdb/client/package.py

@@ -1,6 +1,7 @@
 import struct
 import msgpack
 import logging
+from typing import Any
 
 
 _fail_file = ''
@@ -30,7 +31,7 @@ def __init__(self, barray: bytearray | bytes) -> None:
         self.length, self.pid, self.tp, self.checkbit = \
             self.__class__.st_package.unpack_from(barray, offset=0)
         self.total = self.__class__.st_package.size + self.length
-        self.data = None
+        self.data: Any = None
 
     def _handle_fail_file(self, message: bytes):
         if _fail_file: