Set mypy to a resonably strict mode and fix all errors detected by this

Bonus: F821 is now fixed by pinning a newer pyflakes version.

Author: ntninja

datastore/adapter/_support.py

@@ -11,14 +11,14 @@
 #  * https://github.com/python/mypy/issues/7790 (Associated types)
 #  * https://github.com/python/mypy/issues/7791 (Types of generic classes)
 DS = typing.TypeVar("DS", datastore.abc.BinaryDatastore,
-                    datastore.abc.ObjectDatastore[T_co])  # type: ignore[valid-type] # noqa: F821
+                    datastore.abc.ObjectDatastore[T_co])  # type: ignore[valid-type]
 DA = typing.TypeVar("DA", datastore.abc.BinaryAdapter,
-                    datastore.abc.ObjectAdapter[T_co, T_co])  # type: ignore[valid-type] # noqa: F821, E501
+                    datastore.abc.ObjectAdapter[T_co, T_co])  # type: ignore[valid-type]
 MD = typing.TypeVar("MD", datastore.util.StreamMetadata,
-                    datastore.util.ChannelMetadata)  # type: ignore[valid-type] # noqa: F821
+                    datastore.util.ChannelMetadata)
 RT = typing.TypeVar("RT", datastore.abc.ReceiveStream,
-                    datastore.abc.ReceiveChannel[T_co])  # type: ignore[valid-type] # noqa: F821
-RV = typing.TypeVar("RV", bytes, typing.List[T_co])  # type: ignore[valid-type] # noqa: F821
+                    datastore.abc.ReceiveChannel[T_co])  # type: ignore[valid-type]
+RV = typing.TypeVar("RV", bytes, typing.List[T_co])  # type: ignore[valid-type]
 
 
 # Workaround for https://github.com/python/mypy/issues/708

datastore/adapter/directory.py

@@ -188,4 +188,4 @@ async def query(self, query: datastore.Query) -> datastore.Cursor:
 		"""Returns objects matching criteria expressed in `query`.
 		DirectoryTreeDatastore uses directory entries.
 		"""
-		return query(super().directory_read(query.key))
+		return query(super().directory_read(query.key))  # type: ignore[no-any-return]

datastore/adapter/keytransform.py

@@ -54,47 +54,48 @@ class _Adapter(typing.Generic[DS, MD, RT, RV]):
 	key_transform_fn: _support.FunctionProperty[KEY_TRANSFORM_T]
 
 
-	def __init__(self, *args, key_transform: KEY_TRANSFORM_T = (lambda k: k), **kwargs):
+	def __init__(self, *args: typing.Any, key_transform: KEY_TRANSFORM_T = (lambda k: k),
+	             **kwargs: typing.Any):
 		"""Initializes KeyTransformDatastore with `keytransform` function."""
 		self.key_transform_fn = key_transform
-		super().__init__(*args, **kwargs)  # type: ignore[call-arg] # noqa: F821
+		super().__init__(*args, **kwargs)  # type: ignore[call-arg]
 
 
 	async def get(self, key: datastore.Key) -> RT:
 		"""Returns the object named by keytransform(key)."""
-		return await super().get(self.key_transform_fn(key))  # type: ignore[misc] # noqa: F821
+		return await super().get(self.key_transform_fn(key))  # type: ignore[misc, no-any-return]
 
 
 	async def get_all(self, key: datastore.Key) -> RV:
 		"""Returns the object named by keytransform(key)."""
-		return await super().get_all(self.key_transform_fn(key))  # type: ignore[misc] # noqa: F821
+		return await super().get_all(self.key_transform_fn(key))  # type: ignore[misc, no-any-return]
 
 
 	async def _put(self, key: datastore.Key, value: RT) -> None:
 		"""Stores the object names by keytransform(key)."""
-		await super()._put(self.key_transform_fn(key), value)  # type: ignore[misc] # noqa: F821
+		await super()._put(self.key_transform_fn(key), value)  # type: ignore[misc, no-any-return]
 
 
 	async def delete(self, key: datastore.Key) -> None:
 		"""Removes the object named by keytransform(key)."""
-		await super().delete(self.key_transform_fn(key))  # type: ignore[misc] # noqa: F821
+		await super().delete(self.key_transform_fn(key))  # type: ignore[misc]
 
 
 	async def contains(self, key: datastore.Key) -> bool:
 		"""Returns whether the object named by key is in this datastore."""
-		return await super().contains(self.key_transform_fn(key))  # type: ignore[misc] # noqa: F821
+		return await super().contains(self.key_transform_fn(key))  # type: ignore[misc, no-any-return]
 
 
 	async def stat(self, key: datastore.Key) -> MD:
 		"""Returns the metadata of the object named by keytransform(key)."""
-		return await super().stat(self.key_transform_fn(key))  # type: ignore[misc] # noqa: F821
+		return await super().stat(self.key_transform_fn(key))  # type: ignore[misc, no-any-return]
 
 
 	async def query(self, query: datastore.Query) -> datastore.Cursor:
 		"""Returns a sequence of objects matching criteria expressed in `query`"""
 		query = query.copy()
 		query.key = self.key_transform_fn(query.key)
-		return await super().query(query)  # type: ignore[misc] # noqa: F821
+		return await super().query(query)  # type: ignore[misc, no-any-return]
 
 
 class BinaryAdapter(
@@ -147,7 +148,7 @@ class _LowercaseKeyAdapter(_Adapter[DS, MD, RT, RV], typing.Generic[DS, MD, RT,
 	"""
 	__slots__ = ()
 
-	def __init__(self, *args, **kwargs):
+	def __init__(self, *args: typing.Any, **kwargs: typing.Any):
 		"""Initializes KeyTransformDatastore with `key_transform` function."""
 		super().__init__(*args, key_transform=self.lowercase_key, **kwargs)
 
@@ -209,7 +210,8 @@ class _NamespaceAdapter(_Adapter[DS, MD, RT, RV], typing.Generic[DS, MD, RT, RV]
 
 	namespace: datastore.Key
 
-	def __init__(self, namespace: typing.Union[str, datastore.Key], *args, **kwargs):
+	def __init__(self, namespace: typing.Union[str, datastore.Key],
+	             *args: typing.Any, **kwargs: typing.Any):
 		"""Initializes NamespaceDatastore with `key` namespace."""
 		self.namespace = datastore.Key(namespace)
 		super().__init__(*args, key_transform = self.namespace_key, **kwargs)
@@ -280,11 +282,11 @@ def _default_keyfn(key: datastore.Key) -> str:
 		return key.name
 
 
-	def __init__(self, *args,
+	def __init__(self, *args: typing.Any,
 	             depth: int = None,
 	             length: int = None,
 	             key_fn: typing.Callable[[datastore.Key], str] = None,
-	             **kwargs):
+	             **kwargs: typing.Any):
 		"""Initializes KeyTransformDatastore with keytransform function.
 
 		Arguments

datastore/adapter/logging.py

@@ -23,17 +23,18 @@ class _Adapter(typing.Generic[DS, MD, RT, RV]):
 	logger: logging.Logger
 
 
-	def __init__(self, *args, logger: logging.Logger = ROOT_LOGGER, **kwargs):
+	def __init__(self, *args: typing.Any, logger: logging.Logger = ROOT_LOGGER,
+	             **kwargs: typing.Any):
 		self.logger = logger
-		super().__init__(*args, **kwargs)  # type: ignore[call-arg] # noqa: F821
+		super().__init__(*args, **kwargs)  # type: ignore[call-arg]
 
 
 	async def get(self, key: datastore.Key) -> RT:
 		"""Return the object named by key or None if it does not exist.
 		   LoggingDatastore logs the access.
 		"""
 		self.logger.info('%s: get %s', self, key)
-		value = await super().get(key)  # type: ignore[misc] # noqa: F821
+		value: RT = await super().get(key)  # type: ignore[misc]
 		self.logger.debug('%s: %s', self, value)
 		return value
 
@@ -43,7 +44,7 @@ async def get_all(self, key: datastore.Key) -> RV:
 		   LoggingDatastore logs the access.
 		"""
 		self.logger.info('%s: get %s', self, key)
-		value = await super().get_all(key)  # type: ignore[misc] # noqa: F821
+		value: RV = await super().get_all(key)  # type: ignore[misc]
 		self.logger.debug('%s: %s', self, value)
 		return value
 
@@ -54,31 +55,31 @@ async def _put(self, key: datastore.Key, value: RT) -> None:
 		"""
 		self.logger.info('%s: put %s', self, key)
 		self.logger.debug('%s: %s', self, value)
-		await super()._put(key, value)  # type: ignore[misc] # noqa: F821
+		await super()._put(key, value)  # type: ignore[misc]
 
 
 	async def delete(self, key: datastore.Key) -> None:
 		"""Removes the object named by `key`.
 		   LoggingDatastore logs the access.
 		"""
 		self.logger.info('%s: delete %s', self, key)
-		await super().delete(key)  # type: ignore[misc] # noqa: F821
+		await super().delete(key)  # type: ignore[misc]
 
 
 	async def contains(self, key: datastore.Key) -> bool:
 		"""Returns whether the object named by `key` exists.
 		   LoggingDatastore logs the access.
 		"""
 		self.logger.info('%s: contains %s', self, key)
-		return await super().contains(key)  # type: ignore[misc] # noqa: F821
+		return await super().contains(key)  # type: ignore[misc, no-any-return]
 
 
 	async def stat(self, key: datastore.Key) -> MD:
 		"""Returns the metadata of the object named by `key`.
 		   LoggingDatastore logs the access.
 		"""
 		self.logger.info('%s: stat %s', self, key)
-		metadata = await super().stat(key)  # type: ignore[misc] # noqa: F821
+		metadata: MD = await super().stat(key)  # type: ignore[misc]
 		self.logger.debug('%s: %s', self, metadata)
 		return metadata
 
@@ -88,7 +89,7 @@ async def query(self, query: datastore.Query) -> datastore.Cursor:
 		   LoggingDatastore logs the access.
 		"""
 		self.logger.info('%s: query %s', self, query)
-		return await super().query(query)  # type: ignore[misc] # noqa: F821
+		return await super().query(query)  # type: ignore[misc, no-any-return]
 
 
 class BinaryAdapter(

datastore/adapter/mount.py

@@ -12,24 +12,21 @@
 ]
 
 
+mount_item_t = typing.Tuple['mount_tree_t[DS]', typing.Optional[DS]]
+
+
+class mount_tree_t(typing.Dict[str, mount_item_t[DS]]):
+	...
+
 
 class _Adapter(typing.Generic[DS, MD, RT, RV]):
 	__slots__ = ()
 
-	# Cannot represent recursive types yet (https://github.com/python/mypy/issues/731)
-	MOUNTS_T = typing.Dict[  # type: ignore[misc] # noqa: F821
-		str,
-		typing.Tuple[
-			"_Adapter.MOUNTS_T",  # type: ignore[misc] # noqa: F821
-			typing.Optional[DS]  # type: ignore[misc] # noqa: F821
-		]
-	]
-	
-	mounts: MOUNTS_T
+	mounts: mount_tree_t[DS]
 
 
-	def __init__(self, *args, **kwargs):
-		self.mounts = {}
+	def __init__(self, *args: typing.Any, **kwargs: typing.Any):
+		self.mounts = mount_tree_t()
 
 
 	def _find_mountpoint(self, key: datastore.Key) \
@@ -56,21 +53,21 @@ async def get(self, key: datastore.Key) -> RT:
 		ds, subkey = self._find_mountpoint(key)
 		if ds is None:
 			raise KeyError(key)
-		return await ds.get(subkey)  # type: ignore[return-value] # noqa: F723
+		return await ds.get(subkey)  # type: ignore[return-value]
 
 
 	async def get_all(self, key: datastore.Key) -> RV:
 		ds, subkey = self._find_mountpoint(key)
 		if ds is None:
 			raise KeyError(key)
-		return await ds.get_all(subkey)  # type: ignore[return-value] # noqa: F723
+		return await ds.get_all(subkey)  # type: ignore[return-value]
 
 
 	async def _put(self, key: datastore.Key, value: RT) -> None:
 		ds, subkey = self._find_mountpoint(key)
 		if ds is None:
 			raise RuntimeError(f"Cannot put key {key}: No datastore mounted at this path")
-		await ds.put(subkey, value)  # type: ignore[arg-type] # noqa: F821
+		await ds.put(subkey, value)
 
 
 	async def delete(self, key: datastore.Key) -> None:
@@ -91,7 +88,7 @@ async def stat(self, key: datastore.Key) -> MD:
 		ds, subkey = self._find_mountpoint(key)
 		if ds is None:
 			raise KeyError(key)
-		return await ds.stat(subkey)  # type: ignore[return-value] # noqa: F723
+		return await ds.stat(subkey)  # type: ignore[return-value]
 
 
 	def mount(self, prefix: datastore.Key, ds: DS) -> None:
@@ -100,13 +97,13 @@ def mount(self, prefix: datastore.Key, ds: DS) -> None:
 		If a datastore is already mounted at the given key a :exc:`KeyError` is
 		raised.
 		"""
-		current:  _Adapter.MOUNTS_T = self.mounts
-		previous: _Adapter.MOUNTS_T
+		current:  mount_tree_t[DS] = self.mounts
+		previous: mount_tree_t[DS]
 
 		# Walk and create all parent key parts
 		for part in map(str, prefix.list):
 			if part not in current:
-				current[part] = ({}, None)
+				current[part] = (mount_tree_t(), None)
 			previous = current
 			current  = current[part][0]
 
@@ -126,10 +123,10 @@ def unmount(self, prefix: datastore.Key) -> DS:
 		The returned datastore is not closed; it is the callers responsibility
 		to ensure this by using ``await m.unmount(key).aclose()`` or similar.
 		"""
-		current: _Adapter.MOUNTS_T = self.mounts
+		current: mount_tree_t[DS] = self.mounts
 
 		# Walk and create all parent key parts
-		visited: typing.List[_Adapter.MOUNTS_T] = []
+		visited: typing.List[mount_tree_t[DS]] = []
 		for part in map(str, prefix.list):
 			if part not in current:
 				raise KeyError(prefix)
@@ -160,10 +157,10 @@ def unmount_all(self) -> typing.List[DS]:
 		unmounted: typing.List[DS] = []
 
 		# Start at mount hierarchy root
-		current: _Adapter.MOUNTS_T = self.mounts
+		current: mount_tree_t[DS] = self.mounts
 
 		# Walk and create all parent key parts
-		stack: typing.List[_Adapter.MOUNTS_T] = []
+		stack: typing.List[mount_tree_t[DS]] = []
 		while len(self.mounts) > 0 or len(stack) > 0:
 			try:
 				# Pop item from submounts map

datastore/adapter/sharded.py

@@ -45,17 +45,17 @@ def get_sharded_datastore(self, key: datastore.Key) -> DS:
 
 	async def get(self, key: datastore.Key) -> RT:
 		"""Return the object named by key from the corresponding datastore."""
-		return await self.get_sharded_datastore(key).get(key)  # type: ignore[return-value] # noqa: F723
+		return await self.get_sharded_datastore(key).get(key)  # type: ignore[return-value]
 
 
 	async def get_all(self, key: datastore.Key) -> RV:
 		"""Return the object named by key from the corresponding datastore."""
-		return await self.get_sharded_datastore(key).get_all(key)  # type: ignore[return-value] # noqa: F723, E501
+		return await self.get_sharded_datastore(key).get_all(key)  # type: ignore[return-value]
 
 
 	async def _put(self, key: datastore.Key, value: RT) -> None:
 		"""Stores the object to the corresponding datastore."""
-		await self.get_sharded_datastore(key).put(key, value)  # type: ignore[arg-type] # noqa: F821
+		await self.get_sharded_datastore(key).put(key, value)
 
 
 	async def delete(self, key: datastore.Key) -> None:
@@ -70,7 +70,7 @@ async def contains(self, key: datastore.Key) -> bool:
 
 	async def stat(self, key: datastore.Key) -> MD:
 		"""Return the metadata of the object named by key from the corresponding datastore."""
-		return await self.get_sharded_datastore(key).stat(key)  # type: ignore[return-value] # noqa: F723
+		return await self.get_sharded_datastore(key).stat(key)  # type: ignore[return-value]
 
 
 	async def query(self, query: datastore.Query) -> datastore.Cursor:
@@ -80,7 +80,7 @@ async def query(self, query: datastore.Query) -> datastore.Cursor:
 		return cursor
 
 
-	def _shard_query_generator(self, query):
+	def _shard_query_generator(self, query):  # type: ignore  #FIXME: broken
 		"""A generator that queries each shard in sequence."""
 		shard_query = query.copy()