Python 3.13 + pyright typing

Author: sciyoshi

.github/workflows/ci.yml

@@ -12,26 +12,26 @@ jobs:
       - uses: actions/setup-python@v5
       - run: pip install uv
       - run: uv venv
-      - run: uv pip install --requirement pyproject.toml --all-extras
-      - run: .venv/bin/ruff format --check .
-      - run: .venv/bin/ruff check .
-      - run: .venv/bin/mypy asyncio_connection_pool
+      - run: uv sync --all-extras
+      - run: uv run ruff format --check .
+      - run: uv run ruff check .
+      - run: uv run pyright asyncio_connection_pool
 
   test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - run: pip install uv
       - run: uv venv
-      - run: uv pip install --editable ".[dev,datadog,aioredis]"
-      - run: .venv/bin/pytest --cov=asyncio_connection_pool --cov-branch --cov-config=.coveragerc
-      - run: .venv/bin/codecov
-        if: matrix.python-version == '3.11'
+      - run: uv sync --all-extras
+      - run: uv run pytest --cov=asyncio_connection_pool --cov-branch --cov-config=.coveragerc
+      - run: uv run codecov
+        if: matrix.python-version == '3.13'
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/release.yml

@@ -15,11 +15,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: "3.13"
       - run: pip install uv
-      - run: uv venv
-      - run: uv pip install --requirement pyproject.toml
-      - run: uv pip install setuptools setuptools-scm wheel build
-      - run: .venv/bin/python -m build --no-isolation
-      - name: Publish package distributions to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
+      - run: uv build
+      - run: uv publish

asyncio_connection_pool/__init__.py

@@ -1,8 +1,9 @@
 import asyncio
+import collections
 import inspect
 from abc import ABC, abstractmethod
 from contextlib import asynccontextmanager
-from typing import AsyncIterator, Awaitable, Generic, Optional, TypeVar
+from typing import AsyncIterator, Awaitable, Generic, Optional, TypeVar, cast
 
 __all__ = "ConnectionPool", "ConnectionStrategy"
 Conn = TypeVar("Conn")
@@ -77,7 +78,10 @@ def _total(self) -> int:
 
     @property
     def _waiters(self) -> int:
-        waiters = self.available._getters  # type: ignore
+        waiters: collections.deque[asyncio.Future[None]] = cast(
+            collections.deque[asyncio.Future[None]],
+            self.available._getters,  # type: ignore
+        )
         return sum(not (w.done() or w.cancelled()) for w in waiters)
 
     async def _connection_maker(self) -> Conn:

asyncio_connection_pool/contrib/datadog.py

@@ -1,18 +1,31 @@
 from contextlib import AsyncExitStack, asynccontextmanager
-from typing import Any, AsyncIterator, Awaitable, Coroutine, TypeVar
+from typing import Any, AsyncIterator, Awaitable, Coroutine, Optional, TypeVar
 
 from datadog.dogstatsd.base import statsd
-from ddtrace import tracer
+from ddtrace.trace import tracer
 
-from asyncio_connection_pool import ConnectionPool as _ConnectionPool
+from asyncio_connection_pool import (
+    ConnectionPool as _ConnectionPool,
+)
+from asyncio_connection_pool import (
+    ConnectionStrategy,
+)
 
 __all__ = ("ConnectionPool",)
 Conn = TypeVar("Conn")
 
 
 class ConnectionPool(_ConnectionPool[Conn]):
-    def __init__(self, service_name, *args, extra_tags=None, **kwargs):
-        super().__init__(*args, **kwargs)
+    def __init__(
+        self,
+        service_name: str,
+        *,
+        extra_tags: list[str] | None = None,
+        strategy: ConnectionStrategy[Conn],
+        max_size: int,
+        burst_limit: Optional[int] = None,
+    ):
+        super().__init__(strategy=strategy, max_size=max_size, burst_limit=burst_limit)
         self._connections_acquiring = 0
         self._service_name = service_name
         self._is_bursting = False

pyproject.toml

@@ -1,6 +1,9 @@
 [build-system]
-requires = ["setuptools", "setuptools-scm"]
-build-backend = "setuptools.build_meta"
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
 
 [project]
 name = "asyncio-connection-pool"
@@ -14,17 +17,17 @@ dependencies = []
 
 [project.optional-dependencies]
 datadog = ["ddtrace", "datadog"]
+
+[dependency-groups]
 dev = [
     "codecov~=2.1",
-    "mypy~=1.9",
+    "pyright>=1.1.396",
     "pytest~=8.1",
     "pytest-asyncio~=0.23",
     "pytest-cov~=5.0",
     "ruff~=0.4",
 ]
 
-[tool.setuptools_scm]
-
 [tool.ruff.lint]
 select = [
     "B",
@@ -33,7 +36,6 @@ select = [
     "EM",
     "F",
     "I",
-    "I",
     "N",
     "PT",
     "RSE",
@@ -47,22 +49,3 @@ preview = true
 
 [tool.ruff.format]
 preview = true
-
-[tool.mypy]
-ignore_missing_imports = true
-check_untyped_defs = true
-disallow_any_unimported = true
-disallow_any_decorated = true
-disallow_any_generics = true
-disallow_subclassing_any = true
-disallow_incomplete_defs = false
-disallow_untyped_decorators = true
-no_implicit_optional = true
-strict_optional = true
-warn_redundant_casts = true
-warn_unused_ignores = true
-warn_return_any = true
-warn_unreachable = true
-implicit_reexport = false
-strict_equality = true
-pretty = true

test/test_pool.py

@@ -29,7 +29,7 @@ def close_connection(self, conn):
         pass
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_valid_burst_limit(pool_cls):  # noqa: RUF029
     """Test that invalid burst_limit values cause errors (only at construction time)"""
     strategy = RandomIntStrategy()
@@ -64,7 +64,7 @@ async def inc(self):
             self.n -= 1
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_concurrent_get_connection(pool_cls):
     """Test handling several connection requests in a short time."""
 
@@ -87,12 +87,12 @@ async def connection_holder():
     await asyncio.gather(*coros)
 
     assert pool.in_use == 0
-    assert (
-        pool.available.qsize() == nworkers
-    ), f"{nworkers} connections should be allocated"
+    assert pool.available.qsize() == nworkers, (
+        f"{nworkers} connections should be allocated"
+    )
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_currently_allocating(pool_cls):
     """Test that currently_allocating is accurate."""
 
@@ -122,22 +122,22 @@ async def worker():
     await counter.wait()
     await asyncio.sleep(0)
 
-    assert (
-        pool.currently_allocating == nworkers
-    ), f"{nworkers} workers are waiting for a connection"
+    assert pool.currently_allocating == nworkers, (
+        f"{nworkers} workers are waiting for a connection"
+    )
     ev.set()  # allow the workers to get their connections
     await counter2.wait()
     assert pool.currently_allocating == 0
     assert pool.in_use == nworkers, "all workers should have their connections now"
     ev2.set()
     await asyncio.gather(*coros)
     assert pool.in_use == 0
-    assert (
-        pool.available.qsize() == nworkers
-    ), "all workers should have returned their connections"
+    assert pool.available.qsize() == nworkers, (
+        "all workers should have returned their connections"
+    )
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_burst(pool_cls):
     """Test that bursting works when enabled and doesn't when not."""
 
@@ -189,24 +189,24 @@ async def waiting_worker():
     assert pool._waiters == 1, "Worker should be waiting, we're at burst_limit already"
     burst_event.set()  # Allow worker holding burst connection to finish
     await burst_worker  # Wait for it to release the connection
-    assert (
-        not did_call_close_connection.is_set()
-    ), "Did not churn the burst connection while there was a waiter"
+    assert not did_call_close_connection.is_set(), (
+        "Did not churn the burst connection while there was a waiter"
+    )
     await coro  # Should be able to take that burst connection we created
-    assert (
-        did_call_close_connection.is_set()
-    ), "No more waiters, burst connection should be closed"
-    assert (
-        pool._total == pool.max_size
-    ), "Pool should return to max size after burst capacity is not needed"
+    assert did_call_close_connection.is_set(), (
+        "No more waiters, burst connection should be closed"
+    )
+    assert pool._total == pool.max_size, (
+        "Pool should return to max size after burst capacity is not needed"
+    )
     main_event.set()  # Allow the initial workers to exit
     await asyncio.gather(*coros)  # Wait for initial workers to exit
-    assert (
-        pool.available.qsize() == pool.max_size
-    ), "Workers should return their connections to the pool"
+    assert pool.available.qsize() == pool.max_size, (
+        "Workers should return their connections to the pool"
+    )
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_stale_connections(pool_cls):
     """Test that the pool doesn't hand out closed connections."""
 
@@ -243,12 +243,12 @@ async def worker():
         stale_connections.add(conn)
 
     async with pool.get_connection() as conn:
-        assert (
-            conn != now_stale
-        ), "Make sure connections closed by consumers are not given back out"
+        assert conn != now_stale, (
+            "Make sure connections closed by consumers are not given back out"
+        )
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_handling_cancellederror():
     making_connection = asyncio.Event()