PYTHON-5257 - Turn on mypy disallow_any_generics

Author: NoahStapp

bson/json_util.py

@@ -844,7 +844,7 @@ def _encode_binary(data: bytes, subtype: int, json_options: JSONOptions) -> Any:
     return {"$binary": {"base64": base64.b64encode(data).decode(), "subType": "%02x" % subtype}}
 
 
-def _encode_datetimems(obj: Any, json_options: JSONOptions) -> dict:
+def _encode_datetimems(obj: Any, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     if (
         json_options.datetime_representation == DatetimeRepresentation.ISO8601
         and 0 <= int(obj) <= _MAX_UTC_MS
@@ -855,7 +855,7 @@ def _encode_datetimems(obj: Any, json_options: JSONOptions) -> dict:
     return {"$date": {"$numberLong": str(int(obj))}}
 
 
-def _encode_code(obj: Code, json_options: JSONOptions) -> dict:
+def _encode_code(obj: Code, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     if obj.scope is None:
         return {"$code": str(obj)}
     else:
@@ -873,7 +873,7 @@ def _encode_noop(obj: Any, dummy0: Any) -> Any:
     return obj
 
 
-def _encode_regex(obj: Any, json_options: JSONOptions) -> dict:
+def _encode_regex(obj: Any, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     flags = ""
     if obj.flags & re.IGNORECASE:
         flags += "i"
@@ -918,7 +918,7 @@ def _encode_float(obj: float, json_options: JSONOptions) -> Any:
     return obj
 
 
-def _encode_datetime(obj: datetime.datetime, json_options: JSONOptions) -> dict:
+def _encode_datetime(obj: datetime.datetime, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     if json_options.datetime_representation == DatetimeRepresentation.ISO8601:
         if not obj.tzinfo:
             obj = obj.replace(tzinfo=utc)
@@ -941,51 +941,51 @@ def _encode_datetime(obj: datetime.datetime, json_options: JSONOptions) -> dict:
     return {"$date": {"$numberLong": str(millis)}}
 
 
-def _encode_bytes(obj: bytes, json_options: JSONOptions) -> dict:
+def _encode_bytes(obj: bytes, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     return _encode_binary(obj, 0, json_options)
 
 
-def _encode_binary_obj(obj: Binary, json_options: JSONOptions) -> dict:
+def _encode_binary_obj(obj: Binary, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     return _encode_binary(obj, obj.subtype, json_options)
 
 
-def _encode_uuid(obj: uuid.UUID, json_options: JSONOptions) -> dict:
+def _encode_uuid(obj: uuid.UUID, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     if json_options.strict_uuid:
         binval = Binary.from_uuid(obj, uuid_representation=json_options.uuid_representation)
         return _encode_binary(binval, binval.subtype, json_options)
     else:
         return {"$uuid": obj.hex}
 
 
-def _encode_objectid(obj: ObjectId, dummy0: Any) -> dict:
+def _encode_objectid(obj: ObjectId, dummy0: Any) -> dict:  # type: ignore[type-arg]
     return {"$oid": str(obj)}
 
 
-def _encode_timestamp(obj: Timestamp, dummy0: Any) -> dict:
+def _encode_timestamp(obj: Timestamp, dummy0: Any) -> dict:  # type: ignore[type-arg]
     return {"$timestamp": {"t": obj.time, "i": obj.inc}}
 
 
-def _encode_decimal128(obj: Timestamp, dummy0: Any) -> dict:
+def _encode_decimal128(obj: Timestamp, dummy0: Any) -> dict:  # type: ignore[type-arg]
     return {"$numberDecimal": str(obj)}
 
 
-def _encode_dbref(obj: DBRef, json_options: JSONOptions) -> dict:
+def _encode_dbref(obj: DBRef, json_options: JSONOptions) -> dict:  # type: ignore[type-arg]
     return _json_convert(obj.as_doc(), json_options=json_options)
 
 
-def _encode_minkey(dummy0: Any, dummy1: Any) -> dict:
+def _encode_minkey(dummy0: Any, dummy1: Any) -> dict:  # type: ignore[type-arg]
     return {"$minKey": 1}
 
 
-def _encode_maxkey(dummy0: Any, dummy1: Any) -> dict:
+def _encode_maxkey(dummy0: Any, dummy1: Any) -> dict:  # type: ignore[type-arg]
     return {"$maxKey": 1}
 
 
 # Encoders for BSON types
 # Each encoder function's signature is:
 #   - obj: a Python data type, e.g. a Python int for _encode_int
 #   - json_options: a JSONOptions
-_ENCODERS: dict[Type, Callable[[Any, JSONOptions], Any]] = {
+_ENCODERS: dict[Type, Callable[[Any, JSONOptions], Any]] = {  # type: ignore[type-arg]
     bool: _encode_noop,
     bytes: _encode_bytes,
     datetime.datetime: _encode_datetime,
@@ -1056,7 +1056,7 @@ def _get_datetime_size(obj: datetime.datetime) -> int:
     return 5 + len(str(obj.time()))
 
 
-def _get_regex_size(obj: Regex) -> int:
+def _get_regex_size(obj: Regex) -> int:  # type: ignore[type-arg]
     return 18 + len(obj.pattern)
 
 

bson/typings.py

@@ -28,4 +28,4 @@
 _DocumentOut = Union[MutableMapping[str, Any], "RawBSONDocument"]
 _DocumentType = TypeVar("_DocumentType", bound=Mapping[str, Any])
 _DocumentTypeArg = TypeVar("_DocumentTypeArg", bound=Mapping[str, Any])
-_ReadableBuffer = Union[bytes, memoryview, "mmap", "array"]
+_ReadableBuffer = Union[bytes, memoryview, "mmap", "array"]  # type: ignore[type-arg]

pymongo/_asyncio_lock.py

@@ -93,7 +93,7 @@ class Lock(_ContextManagerMixin, _LoopBoundMixin):
     """
 
     def __init__(self) -> None:
-        self._waiters: Optional[collections.deque] = None
+        self._waiters: Optional[collections.deque[Any]] = None
         self._locked = False
 
     def __repr__(self) -> str:
@@ -196,7 +196,7 @@ def __init__(self, lock: Optional[Lock] = None) -> None:
         self.acquire = lock.acquire
         self.release = lock.release
 
-        self._waiters: collections.deque = collections.deque()
+        self._waiters: collections.deque[Any] = collections.deque()
 
     def __repr__(self) -> str:
         res = super().__repr__()
@@ -260,7 +260,7 @@ async def wait(self) -> bool:
             self._notify(1)
             raise
 
-    async def wait_for(self, predicate: Any) -> Coroutine:
+    async def wait_for(self, predicate: Any) -> Coroutine[Any, Any, Any]:
         """Wait until a predicate becomes true.
 
         The predicate should be a callable whose result will be

pymongo/_asyncio_task.py

@@ -24,7 +24,7 @@
 
 
 # TODO (https://jira.mongodb.org/browse/PYTHON-4981): Revisit once the underlying cause of the swallowed cancellations is uncovered
-class _Task(asyncio.Task):
+class _Task(asyncio.Task[Any]):
     def __init__(self, coro: Coroutine[Any, Any, Any], *, name: Optional[str] = None) -> None:
         super().__init__(coro, name=name)
         self._cancel_requests = 0
@@ -43,7 +43,7 @@ def cancelling(self) -> int:
         return self._cancel_requests
 
 
-def create_task(coro: Coroutine[Any, Any, Any], *, name: Optional[str] = None) -> asyncio.Task:
+def create_task(coro: Coroutine[Any, Any, Any], *, name: Optional[str] = None) -> asyncio.Task[Any]:
     if sys.version_info >= (3, 11):
         return asyncio.create_task(coro, name=name)
     return _Task(coro, name=name)

pymongo/_csot.py

@@ -68,7 +68,7 @@ def clamp_remaining(max_timeout: float) -> float:
     return min(timeout, max_timeout)
 
 
-class _TimeoutContext(AbstractContextManager):
+class _TimeoutContext(AbstractContextManager[Any]):
     """Internal timeout context manager.
 
     Use :func:`pymongo.timeout` instead::

pymongo/asynchronous/aggregation.py

@@ -46,8 +46,8 @@ class _AggregationCommand:
 
     def __init__(
         self,
-        target: Union[AsyncDatabase, AsyncCollection],
-        cursor_class: type[AsyncCommandCursor],
+        target: Union[AsyncDatabase[Any], AsyncCollection[Any]],
+        cursor_class: type[AsyncCommandCursor[Any]],
         pipeline: _Pipeline,
         options: MutableMapping[str, Any],
         explicit_session: bool,
@@ -111,12 +111,12 @@ def _cursor_namespace(self) -> str:
         """The namespace in which the aggregate command is run."""
         raise NotImplementedError
 
-    def _cursor_collection(self, cursor_doc: Mapping[str, Any]) -> AsyncCollection:
+    def _cursor_collection(self, cursor_doc: Mapping[str, Any]) -> AsyncCollection[Any]:
         """The AsyncCollection used for the aggregate command cursor."""
         raise NotImplementedError
 
     @property
-    def _database(self) -> AsyncDatabase:
+    def _database(self) -> AsyncDatabase[Any]:
         """The database against which the aggregation command is run."""
         raise NotImplementedError
 
@@ -205,7 +205,7 @@ async def get_cursor(
 
 
 class _CollectionAggregationCommand(_AggregationCommand):
-    _target: AsyncCollection
+    _target: AsyncCollection[Any]
 
     @property
     def _aggregation_target(self) -> str:
@@ -215,12 +215,12 @@ def _aggregation_target(self) -> str:
     def _cursor_namespace(self) -> str:
         return self._target.full_name
 
-    def _cursor_collection(self, cursor: Mapping[str, Any]) -> AsyncCollection:
+    def _cursor_collection(self, cursor: Mapping[str, Any]) -> AsyncCollection[Any]:
         """The AsyncCollection used for the aggregate command cursor."""
         return self._target
 
     @property
-    def _database(self) -> AsyncDatabase:
+    def _database(self) -> AsyncDatabase[Any]:
         return self._target.database
 
 
@@ -234,7 +234,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
 
 
 class _DatabaseAggregationCommand(_AggregationCommand):
-    _target: AsyncDatabase
+    _target: AsyncDatabase[Any]
 
     @property
     def _aggregation_target(self) -> int:
@@ -245,10 +245,10 @@ def _cursor_namespace(self) -> str:
         return f"{self._target.name}.$cmd.aggregate"
 
     @property
-    def _database(self) -> AsyncDatabase:
+    def _database(self) -> AsyncDatabase[Any]:
         return self._target
 
-    def _cursor_collection(self, cursor: Mapping[str, Any]) -> AsyncCollection:
+    def _cursor_collection(self, cursor: Mapping[str, Any]) -> AsyncCollection[Any]:
         """The AsyncCollection used for the aggregate command cursor."""
         # AsyncCollection level aggregate may not always return the "ns" field
         # according to our MockupDB tests. Let's handle that case for db level

pymongo/asynchronous/collection.py

@@ -581,7 +581,7 @@ async def _command(
         conn: AsyncConnection,
         command: MutableMapping[str, Any],
         read_preference: Optional[_ServerMode] = None,
-        codec_options: Optional[CodecOptions[dict[str, Any]]] = None,
+        codec_options: Optional[CodecOptions[Mapping[str, Any]]] = None,
         check: bool = True,
         allowable_errors: Optional[Sequence[Union[str, int]]] = None,
         read_concern: Optional[ReadConcern] = None,
@@ -2525,7 +2525,7 @@ async def _list_indexes(
         session: Optional[AsyncClientSession] = None,
         comment: Optional[Any] = None,
     ) -> AsyncCommandCursor[MutableMapping[str, Any]]:
-        codec_options: CodecOptions[dict[str, Any]] = CodecOptions(SON)
+        codec_options: CodecOptions[Mapping[str, Any]] = CodecOptions(SON)
         coll = cast(
             AsyncCollection[MutableMapping[str, Any]],
             self.with_options(codec_options=codec_options, read_preference=ReadPreference.PRIMARY),

pymongo/asynchronous/cursor.py

@@ -969,13 +969,15 @@ def _deepcopy(self, x: Iterable, memo: Optional[dict[int, Union[list, dict]]] =
 
     @overload
     def _deepcopy(
-        self, x: SupportsItems, memo: Optional[dict[int, Union[list, dict]]] = None
+        self,
+        x: SupportsItems,  # type: ignore[type-arg]
+        memo: Optional[dict[int, Union[list, dict]]] = None,  # type: ignore[type-arg]
     ) -> dict:  # type: ignore[type-arg]
         ...
 
     def _deepcopy(
         self,
-        x: Union[Iterable, SupportsItems],
+        x: Union[Iterable, SupportsItems],  # type: ignore[type-arg]
         memo: Optional[dict[int, Union[list, dict]]] = None,  # type: ignore[type-arg]
     ) -> Union[list[Any], dict[str, Any]]:
         """Deepcopy helper for the data dictionary or list.

pymongo/asynchronous/database.py

@@ -771,7 +771,7 @@ async def _command(
                 self._name,
                 command,
                 read_preference,
-                codec_options,
+                codec_options,  # type: ignore[arg-type]
                 check,
                 allowable_errors,
                 write_concern=write_concern,

pymongo/asynchronous/mongo_client.py

@@ -161,10 +161,10 @@
 _IS_SYNC = False
 
 _WriteOp = Union[
-    InsertOne,
+    InsertOne,  # type: ignore[type-arg]
     DeleteOne,
     DeleteMany,
-    ReplaceOne,
+    ReplaceOne,  # type: ignore[type-arg]
     UpdateOne,
     UpdateMany,
 ]
@@ -176,7 +176,7 @@ class AsyncMongoClient(common.BaseObject, Generic[_DocumentType]):
     # Define order to retrieve options from ClientOptions for __repr__.
     # No host/port; these are retrieved from TopologySettings.
     _constructor_args = ("document_class", "tz_aware", "connect")
-    _clients: weakref.WeakValueDictionary = weakref.WeakValueDictionary()
+    _clients: weakref.WeakValueDictionary = weakref.WeakValueDictionary()  # type: ignore[type-arg]
 
     def __init__(
         self,
@@ -847,7 +847,7 @@ def __init__(
 
         self._default_database_name = dbase
         self._lock = _async_create_lock()
-        self._kill_cursors_queue: list = []
+        self._kill_cursors_queue: list = []  # type: ignore[type-arg]
 
         self._encrypter: Optional[_Encrypter] = None
 
@@ -1064,7 +1064,7 @@ def _after_fork(self) -> None:
         # Reset the session pool to avoid duplicate sessions in the child process.
         self._topology._session_pool.reset()
 
-    def _duplicate(self, **kwargs: Any) -> AsyncMongoClient:
+    def _duplicate(self, **kwargs: Any) -> AsyncMongoClient:  # type: ignore[type-arg]
         args = self._init_kwargs.copy()
         args.update(kwargs)
         return AsyncMongoClient(**args)
@@ -1548,7 +1548,7 @@ def get_database(
             self, name, codec_options, read_preference, write_concern, read_concern
         )
 
-    def _database_default_options(self, name: str) -> database.AsyncDatabase:
+    def _database_default_options(self, name: str) -> database.AsyncDatabase:  # type: ignore[type-arg]
         """Get a AsyncDatabase instance with the default settings."""
         return self.get_database(
             name,
@@ -1887,7 +1887,7 @@ async def _conn_for_reads(
     async def _run_operation(
         self,
         operation: Union[_Query, _GetMore],
-        unpack_res: Callable,
+        unpack_res: Callable,  # type: ignore[type-arg]
         address: Optional[_Address] = None,
     ) -> Response:
         """Run a _Query/_GetMore operation and return a Response.
@@ -2261,7 +2261,7 @@ def _return_server_session(
     @contextlib.asynccontextmanager
     async def _tmp_session(
         self, session: Optional[client_session.AsyncClientSession], close: bool = True
-    ) -> AsyncGenerator[Optional[client_session.AsyncClientSession], None, None]:
+    ) -> AsyncGenerator[Optional[client_session.AsyncClientSession], None]:
         """If provided session is None, lend a temporary session."""
         if session is not None:
             if not isinstance(session, client_session.AsyncClientSession):
@@ -2308,8 +2308,8 @@ async def server_info(
         .. versionchanged:: 3.6
            Added ``session`` parameter.
         """
-        return cast(
-            dict,
+        return cast(  # type: ignore[redundant-cast]
+            dict[str, Any],
             await self.admin.command(
                 "buildinfo", read_preference=ReadPreference.PRIMARY, session=session
             ),
@@ -2438,7 +2438,7 @@ async def drop_database(
     @_csot.apply
     async def bulk_write(
         self,
-        models: Sequence[_WriteOp[_DocumentType]],
+        models: Sequence[_WriteOp],
         session: Optional[AsyncClientSession] = None,
         ordered: bool = True,
         verbose_results: bool = False,
@@ -2631,7 +2631,10 @@ class _MongoClientErrorHandler:
     )
 
     def __init__(
-        self, client: AsyncMongoClient, server: Server, session: Optional[AsyncClientSession]
+        self,
+        client: AsyncMongoClient,  # type: ignore[type-arg]
+        server: Server,
+        session: Optional[AsyncClientSession],
     ):
         if not isinstance(client, AsyncMongoClient):
             # This is for compatibility with mocked and subclassed types, such as in Motor.
@@ -2704,7 +2707,7 @@ class _ClientConnectionRetryable(Generic[T]):
 
     def __init__(
         self,
-        mongo_client: AsyncMongoClient,
+        mongo_client: AsyncMongoClient,  # type: ignore[type-arg]
         func: _WriteCall[T] | _ReadCall[T],
         bulk: Optional[Union[_AsyncBulk, _AsyncClientBulk]],
         operation: str,