refactor(pool): use non-string typing annotations

diff --git a/psycopg_pool/psycopg_pool/null_pool.py b/psycopg_pool/psycopg_pool/null_pool.py
index 6d39e82d9b465034f6c4e2c6b68f4b5831dbb0c7..09f66bda5b350ec3fb82ce1b9a7686ef964cc162 100644 (file)
--- a/psycopg_pool/psycopg_pool/null_pool.py
+++ b/psycopg_pool/psycopg_pool/null_pool.py
@@ -4,6 +4,8 @@ Psycopg null connection pools
 
 # Copyright (C) 2022 The Psycopg Team
 
+from __future__ import annotations
+
 import logging
 from typing import Any, cast, Dict, Optional, overload, Tuple, Type
 
@@ -45,7 +47,7 @@ class _BaseNullConnectionPool:
 class NullConnectionPool(_BaseNullConnectionPool, ConnectionPool[CT]):
     @overload
     def __init__(
-        self: "NullConnectionPool[Connection[TupleRow]]",
+        self: NullConnectionPool[Connection[TupleRow]],
         conninfo: str = "",
         *,
         open: bool = ...,
@@ -67,7 +69,7 @@ class NullConnectionPool(_BaseNullConnectionPool, ConnectionPool[CT]):
 
     @overload
     def __init__(
-        self: "NullConnectionPool[CT]",
+        self: NullConnectionPool[CT],
         conninfo: str = "",
         *,
         open: bool = ...,

diff --git a/psycopg_pool/psycopg_pool/null_pool_async.py b/psycopg_pool/psycopg_pool/null_pool_async.py
index 5cf4b09975aaa80c6890231f6cda308305b87aea..b60370c53b48780ad8b94ba7a8beb413d83c9028 100644 (file)
--- a/psycopg_pool/psycopg_pool/null_pool_async.py
+++ b/psycopg_pool/psycopg_pool/null_pool_async.py
@@ -4,6 +4,8 @@ psycopg asynchronous null connection pool
 
 # Copyright (C) 2022 The Psycopg Team
 
+from __future__ import annotations
+
 import logging
 from typing import Any, cast, Dict, Optional, overload, Type
 
@@ -24,7 +26,7 @@ logger = logging.getLogger("psycopg.pool")
 class AsyncNullConnectionPool(_BaseNullConnectionPool, AsyncConnectionPool[ACT]):
     @overload
     def __init__(
-        self: "AsyncNullConnectionPool[AsyncConnection[TupleRow]]",
+        self: AsyncNullConnectionPool[AsyncConnection[TupleRow]],
         conninfo: str = "",
         *,
         open: bool = ...,
@@ -46,7 +48,7 @@ class AsyncNullConnectionPool(_BaseNullConnectionPool, AsyncConnectionPool[ACT])
 
     @overload
     def __init__(
-        self: "AsyncNullConnectionPool[ACT]",
+        self: AsyncNullConnectionPool[ACT],
         conninfo: str = "",
         *,
         open: bool = ...,

diff --git a/psycopg_pool/psycopg_pool/pool.py b/psycopg_pool/psycopg_pool/pool.py
index 77fc78ee647d2e2520057eb52bfce257564d1e1c..b50e9b44e31fb3196e202552bed548d06e357df3 100644 (file)
--- a/psycopg_pool/psycopg_pool/pool.py
+++ b/psycopg_pool/psycopg_pool/pool.py
@@ -4,6 +4,8 @@ psycopg synchronous connection pool
 
 # Copyright (C) 2021 The Psycopg Team
 
+from __future__ import annotations
+
 import logging
 import threading
 from abc import ABC, abstractmethod
@@ -36,7 +38,7 @@ class ConnectionPool(Generic[CT], BasePool):
 
     @overload
     def __init__(
-        self: "ConnectionPool[Connection[TupleRow]]",
+        self: ConnectionPool[Connection[TupleRow]],
         conninfo: str = "",
         *,
         open: bool = ...,
@@ -58,7 +60,7 @@ class ConnectionPool(Generic[CT], BasePool):
 
     @overload
     def __init__(
-        self: "ConnectionPool[CT]",
+        self: ConnectionPool[CT],
         conninfo: str = "",
         *,
         open: bool = ...,
@@ -106,14 +108,14 @@ class ConnectionPool(Generic[CT], BasePool):
         self._reconnect_failed = reconnect_failed
 
         self._lock = Lock()
-        self._waiting = Deque["WaitingClient[CT]"]()
+        self._waiting = Deque[WaitingClient[CT]]()
 
         # to notify that the pool is full
         self._pool_full_event: Optional[Event] = None
 
         self._sched = Scheduler()
         self._sched_runner: Optional[threading.Thread] = None
-        self._tasks: "Queue[MaintenanceTask]" = Queue()
+        self._tasks: Queue[MaintenanceTask] = Queue()
         self._workers: List[threading.Thread] = []
 
         super().__init__(
@@ -385,7 +387,7 @@ class ConnectionPool(Generic[CT], BasePool):
 
     def _stop_workers(
         self,
-        waiting_clients: Sequence["WaitingClient[CT]"] = (),
+        waiting_clients: Sequence[WaitingClient[CT]] = (),
         connections: Sequence[CT] = (),
         timeout: float | None = None,
     ) -> None:
@@ -488,16 +490,16 @@ class ConnectionPool(Generic[CT], BasePool):
 
         self._reconnect_failed(self)
 
-    def run_task(self, task: "MaintenanceTask") -> None:
+    def run_task(self, task: MaintenanceTask) -> None:
         """Run a maintenance task in a worker thread."""
         self._tasks.put_nowait(task)
 
-    def schedule_task(self, task: "MaintenanceTask", delay: float) -> None:
+    def schedule_task(self, task: MaintenanceTask, delay: float) -> None:
         """Run a maintenance task in a worker thread in the future."""
         self._sched.enter(delay, task.tick)
 
     @classmethod
-    def worker(cls, q: "Queue[MaintenanceTask]") -> None:
+    def worker(cls, q: Queue[MaintenanceTask]) -> None:
         """Runner to execute pending maintenance task.
 
         The function is designed to run as a separate thread.
@@ -803,7 +805,7 @@ class WaitingClient(Generic[CT]):
 class MaintenanceTask(ABC):
     """A task to run asynchronously to maintain the pool state."""
 
-    def __init__(self, pool: "ConnectionPool[Any]"):
+    def __init__(self, pool: ConnectionPool[Any]):
         self.pool = ref(pool)
 
     def __repr__(self) -> str:
@@ -841,40 +843,40 @@ class MaintenanceTask(ABC):
         pool.run_task(self)
 
     @abstractmethod
-    def _run(self, pool: "ConnectionPool[Any]") -> None:
+    def _run(self, pool: ConnectionPool[Any]) -> None:
         ...
 
 
 class StopWorker(MaintenanceTask):
     """Signal the maintenance thread to terminate."""
 
-    def _run(self, pool: "ConnectionPool[Any]") -> None:
+    def _run(self, pool: ConnectionPool[Any]) -> None:
         pass
 
 
 class AddConnection(MaintenanceTask):
     def __init__(
         self,
-        pool: "ConnectionPool[Any]",
-        attempt: Optional["ConnectionAttempt"] = None,
+        pool: ConnectionPool[Any],
+        attempt: Optional[ConnectionAttempt] = None,
         growing: bool = False,
     ):
         super().__init__(pool)
         self.attempt = attempt
         self.growing = growing
 
-    def _run(self, pool: "ConnectionPool[Any]") -> None:
+    def _run(self, pool: ConnectionPool[Any]) -> None:
         pool._add_connection(self.attempt, growing=self.growing)
 
 
 class ReturnConnection(MaintenanceTask):
     """Clean up and return a connection to the pool."""
 
-    def __init__(self, pool: "ConnectionPool[Any]", conn: CT):
+    def __init__(self, pool: ConnectionPool[Any], conn: CT):
         super().__init__(pool)
         self.conn = conn
 
-    def _run(self, pool: "ConnectionPool[Any]") -> None:
+    def _run(self, pool: ConnectionPool[Any]) -> None:
         pool._return_connection(self.conn)
 
 
@@ -885,7 +887,7 @@ class ShrinkPool(MaintenanceTask):
     in the pool.
     """
 
-    def _run(self, pool: "ConnectionPool[Any]") -> None:
+    def _run(self, pool: ConnectionPool[Any]) -> None:
         # Reschedule the task now so that in case of any error we don't lose
         # the periodic run.
         pool.schedule_task(self, pool.max_idle)

diff --git a/psycopg_pool/psycopg_pool/pool_async.py b/psycopg_pool/psycopg_pool/pool_async.py
index c223664e50ddd356ce0536603e7e9787f85e716e..1f8dc9bcc4808b7f69b2c446ead4eded5d5e188c 100644 (file)
--- a/psycopg_pool/psycopg_pool/pool_async.py
+++ b/psycopg_pool/psycopg_pool/pool_async.py
@@ -4,6 +4,8 @@ psycopg asynchronous connection pool
 
 # Copyright (C) 2021 The Psycopg Team
 
+from __future__ import annotations
+
 import asyncio
 import logging
 from abc import ABC, abstractmethod
@@ -37,7 +39,7 @@ class AsyncConnectionPool(Generic[ACT], BasePool):
 
     @overload
     def __init__(
-        self: "AsyncConnectionPool[AsyncConnection[TupleRow]]",
+        self: AsyncConnectionPool[AsyncConnection[TupleRow]],
         conninfo: str = "",
         *,
         open: bool = ...,
@@ -59,7 +61,7 @@ class AsyncConnectionPool(Generic[ACT], BasePool):
 
     @overload
     def __init__(
-        self: "AsyncConnectionPool[ACT]",
+        self: AsyncConnectionPool[ACT],
         conninfo: str = "",
         *,
         open: bool = ...,
@@ -109,9 +111,9 @@ class AsyncConnectionPool(Generic[ACT], BasePool):
         # asyncio objects, created on open to attach them to the right loop.
         self._lock: ALock
         self._sched: AsyncScheduler
-        self._tasks: AQueue["MaintenanceTask"]
+        self._tasks: AQueue[MaintenanceTask]
 
-        self._waiting = Deque["AsyncClient[ACT]"]()
+        self._waiting = Deque[AsyncClient[ACT]]()
 
         # to notify that the pool is full
         self._pool_full_event: Optional[AEvent] = None
@@ -396,7 +398,7 @@ class AsyncConnectionPool(Generic[ACT], BasePool):
 
     async def _stop_workers(
         self,
-        waiting_clients: Sequence["AsyncClient[ACT]"] = (),
+        waiting_clients: Sequence[AsyncClient[ACT]] = (),
         connections: Sequence[ACT] = (),
         timeout: float | None = None,
     ) -> None:
@@ -502,16 +504,16 @@ class AsyncConnectionPool(Generic[ACT], BasePool):
         else:
             self._reconnect_failed(self)
 
-    def run_task(self, task: "MaintenanceTask") -> None:
+    def run_task(self, task: MaintenanceTask) -> None:
         """Run a maintenance task in a worker."""
         self._tasks.put_nowait(task)
 
-    async def schedule_task(self, task: "MaintenanceTask", delay: float) -> None:
+    async def schedule_task(self, task: MaintenanceTask, delay: float) -> None:
         """Run a maintenance task in a worker in the future."""
         await self._sched.enter(delay, task.tick)
 
     @classmethod
-    async def worker(cls, q: AQueue["MaintenanceTask"]) -> None:
+    async def worker(cls, q: AQueue[MaintenanceTask]) -> None:
         """Runner to execute pending maintenance task.
 
         The function is designed to run as a task.
@@ -819,7 +821,7 @@ class AsyncClient(Generic[ACT]):
 class MaintenanceTask(ABC):
     """A task to run asynchronously to maintain the pool state."""
 
-    def __init__(self, pool: "AsyncConnectionPool[Any]"):
+    def __init__(self, pool: AsyncConnectionPool[Any]):
         self.pool = ref(pool)
 
     def __repr__(self) -> str:
@@ -857,40 +859,40 @@ class MaintenanceTask(ABC):
         pool.run_task(self)
 
     @abstractmethod
-    async def _run(self, pool: "AsyncConnectionPool[Any]") -> None:
+    async def _run(self, pool: AsyncConnectionPool[Any]) -> None:
         ...
 
 
 class StopWorker(MaintenanceTask):
     """Signal the maintenance worker to terminate."""
 
-    async def _run(self, pool: "AsyncConnectionPool[Any]") -> None:
+    async def _run(self, pool: AsyncConnectionPool[Any]) -> None:
         pass
 
 
 class AddConnection(MaintenanceTask):
     def __init__(
         self,
-        pool: "AsyncConnectionPool[Any]",
-        attempt: Optional["ConnectionAttempt"] = None,
+        pool: AsyncConnectionPool[Any],
+        attempt: Optional[ConnectionAttempt] = None,
         growing: bool = False,
     ):
         super().__init__(pool)
         self.attempt = attempt
         self.growing = growing
 
-    async def _run(self, pool: "AsyncConnectionPool[Any]") -> None:
+    async def _run(self, pool: AsyncConnectionPool[Any]) -> None:
         await pool._add_connection(self.attempt, growing=self.growing)
 
 
 class ReturnConnection(MaintenanceTask):
     """Clean up and return a connection to the pool."""
 
-    def __init__(self, pool: "AsyncConnectionPool[Any]", conn: ACT):
+    def __init__(self, pool: AsyncConnectionPool[Any], conn: ACT):
         super().__init__(pool)
         self.conn = conn
 
-    async def _run(self, pool: "AsyncConnectionPool[Any]") -> None:
+    async def _run(self, pool: AsyncConnectionPool[Any]) -> None:
         await pool._return_connection(self.conn)
 
 
@@ -901,7 +903,7 @@ class ShrinkPool(MaintenanceTask):
     in the pool.
     """
 
-    async def _run(self, pool: "AsyncConnectionPool[Any]") -> None:
+    async def _run(self, pool: AsyncConnectionPool[Any]) -> None:
         # Reschedule the task now so that in case of any error we don't lose
         # the periodic run.
         await pool.schedule_task(self, pool.max_idle)
@@ -916,14 +918,11 @@ class Schedule(MaintenanceTask):
     """
 
     def __init__(
-        self,
-        pool: "AsyncConnectionPool[Any]",
-        task: MaintenanceTask,
-        delay: float,
+        self, pool: AsyncConnectionPool[Any], task: MaintenanceTask, delay: float
     ):
         super().__init__(pool)
         self.task = task
         self.delay = delay
 
-    async def _run(self, pool: "AsyncConnectionPool[Any]") -> None:
+    async def _run(self, pool: AsyncConnectionPool[Any]) -> None:
         await pool.schedule_task(self.task, self.delay)