asyncpg 0.30.0__tar.gz → 0.32.0__tar.gz

{asyncpg-0.30.0 → asyncpg-0.32.0}/PKG-INFO

@@ -1,46 +1,35 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: asyncpg
-Version: 0.30.0
+Version: 0.32.0
 Summary: An asyncio PostgreSQL driver
 Author-email: MagicStack Inc <hello@magic.io>
-License: Apache License, Version 2.0
+License-Expression: Apache-2.0
 Project-URL: github, https://github.com/MagicStack/asyncpg
 Keywords: database,postgres
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Topic :: Database :: Front-Ends
-Requires-Python: >=3.8.0
+Requires-Python: >=3.9.0
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-License-File: AUTHORS
 Requires-Dist: async_timeout>=4.0.3; python_version < "3.11.0"
 Provides-Extra: gssauth
 Requires-Dist: gssapi; platform_system != "Windows" and extra == "gssauth"
 Requires-Dist: sspilib; platform_system == "Windows" and extra == "gssauth"
-Provides-Extra: test
-Requires-Dist: flake8~=6.1; extra == "test"
-Requires-Dist: flake8-pyi~=24.1.0; extra == "test"
-Requires-Dist: distro~=1.9.0; extra == "test"
-Requires-Dist: uvloop>=0.15.3; (platform_system != "Windows" and python_version < "3.14.0") and extra == "test"
-Requires-Dist: gssapi; platform_system == "Linux" and extra == "test"
-Requires-Dist: k5test; platform_system == "Linux" and extra == "test"
-Requires-Dist: sspilib; platform_system == "Windows" and extra == "test"
-Requires-Dist: mypy~=1.8.0; extra == "test"
-Provides-Extra: docs
-Requires-Dist: Sphinx~=8.1.3; extra == "docs"
-Requires-Dist: sphinx_rtd_theme>=1.2.2; extra == "docs"
+Dynamic: license-file
 
 asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio
 =======================================================================
@@ -57,8 +46,8 @@ of PostgreSQL server binary protocol for use with Python's ``asyncio``
 framework.  You can read more about asyncpg in an introductory
 `blog post <http://magic.io/blog/asyncpg-1m-rows-from-postgres-to-python/>`_.
 
-asyncpg requires Python 3.8 or later and is supported for PostgreSQL
-versions 9.5 to 17.  Other PostgreSQL versions or other databases
+asyncpg requires Python 3.9 or later and is supported for PostgreSQL
+versions 9.5 to 19.  Other PostgreSQL versions or other databases
 implementing the PostgreSQL protocol *may* work, but are not being
 actively tested.
 

{asyncpg-0.30.0 → asyncpg-0.32.0}/README.rst

@@ -13,8 +13,8 @@ of PostgreSQL server binary protocol for use with Python's ``asyncio``
 framework.  You can read more about asyncpg in an introductory
 `blog post <http://magic.io/blog/asyncpg-1m-rows-from-postgres-to-python/>`_.
 
-asyncpg requires Python 3.8 or later and is supported for PostgreSQL
-versions 9.5 to 17.  Other PostgreSQL versions or other databases
+asyncpg requires Python 3.9 or later and is supported for PostgreSQL
+versions 9.5 to 19.  Other PostgreSQL versions or other databases
 implementing the PostgreSQL protocol *may* work, but are not being
 actively tested.
 

{asyncpg-0.30.0 → asyncpg-0.32.0}/asyncpg/_asyncio_compat.py

@@ -33,7 +33,7 @@ async def wait_for(fut: compat.Awaitable[_T], timeout: float | None) -> _T:
 
     If the wait is cancelled, the task is also cancelled.
 
-    If the task supresses the cancellation and returns a value instead,
+    If the task suppresses the cancellation and returns a value instead,
     that value is returned.
 
     This function is a coroutine.

{asyncpg-0.30.0 → asyncpg-0.32.0}/asyncpg/_testbase/__init__.py

@@ -101,9 +101,10 @@ class TestCase(unittest.TestCase, metaclass=TestCaseMeta):
     def setUpClass(cls):
         if os.environ.get('USE_UVLOOP'):
             import uvloop
-            asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+            loop = uvloop.new_event_loop()
+        else:
+            loop = asyncio.new_event_loop()
 
-        loop = asyncio.new_event_loop()
         asyncio.set_event_loop(None)
         cls.loop = loop
 
@@ -267,6 +268,7 @@ def _shutdown_cluster(cluster):
 
 
 def create_pool(dsn=None, *,
+                init_size=None,
                 min_size=10,
                 max_size=10,
                 max_queries=50000,
@@ -281,6 +283,7 @@ def create_pool(dsn=None, *,
                 **connect_kwargs):
     return pool_class(
         dsn,
+        init_size=init_size,
         min_size=min_size,
         max_size=max_size,
         max_queries=max_queries,
@@ -366,10 +369,16 @@ class ClusterTestCase(TestCase):
         self._pools = []
 
     def tearDown(self):
-        super().tearDown()
+        maintenance_tasks = []
         for pool in self._pools:
             pool.terminate()
+            if pool._maintenance_task is not None:
+                maintenance_tasks.append(pool._maintenance_task)
+        if maintenance_tasks:
+            self.loop.run_until_complete(asyncio.gather(
+                *maintenance_tasks, return_exceptions=True))
         self._pools = []
+        super().tearDown()
 
     def create_pool(self, pool_class=pg_pool.Pool,
                     connection_class=pg_connection.Connection, **kwargs):
@@ -402,7 +411,7 @@ class ProxiedClusterTestCase(ClusterTestCase):
             host = '127.0.0.1'
         cls.proxy = fuzzer.TCPFuzzingProxy(
             backend_host=host,
-            backend_port=conn_spec['port'],
+            backend_port=int(conn_spec['port']),
         )
         cls.proxy.start()
 

{asyncpg-0.30.0 → asyncpg-0.32.0}/asyncpg/_testbase/fuzzer.py

@@ -6,6 +6,7 @@
 
 
 import asyncio
+import contextlib
 import socket
 import threading
 import typing
@@ -34,6 +35,7 @@ class TCPFuzzingProxy:
         self.connections = {}
         self.sock = None
         self.listen_task = None
+        self.connection_factory = Connection
 
     async def _wait(self, work):
         work_task = asyncio.ensure_future(work)
@@ -98,11 +100,13 @@ class TCPFuzzingProxy:
         try:
             await self.listen_task
         finally:
+            tasks = list(self.connections.values())
             for c in list(self.connections):
                 c.close()
-            await asyncio.sleep(0.01)
+            await asyncio.gather(*tasks, return_exceptions=True)
             if hasattr(self.loop, 'remove_reader'):
-                self.loop.remove_reader(self.sock.fileno())
+                with contextlib.suppress(NotImplementedError):
+                    self.loop.remove_reader(self.sock.fileno())
             self.sock.close()
 
     async def listen(self):
@@ -119,7 +123,7 @@ class TCPFuzzingProxy:
             except StopServer:
                 break
 
-            conn = Connection(client_sock, backend_sock, self)
+            conn = self.connection_factory(client_sock, backend_sock, self)
             conn_task = self.loop.create_task(conn.handle())
             self.connections[conn] = conn_task
 
@@ -141,13 +145,13 @@ class TCPFuzzingProxy:
         self.restore_connectivity()
 
     def _close_connection(self, connection):
-        conn_task = self.connections.pop(connection, None)
+        conn_task = self.connections.get(connection)
         if conn_task is not None:
             conn_task.cancel()
 
     def close_all_connections(self):
         for conn in list(self.connections):
-            self.loop.call_soon_threadsafe(self._close_connection, conn)
+            self.loop.call_soon_threadsafe(conn.close)
 
 
 class Connection:
@@ -161,6 +165,27 @@ class Connection:
         self.proxy_to_backend_task = None
         self.proxy_from_backend_task = None
         self.is_closed = False
+        self.client_reader = None
+        self.client_writer = None
+
+    async def prepare(self):
+        """Optionally negotiate or inject faults before forwarding bytes."""
+        return True
+
+    async def use_client_stream(self, ssl_context=None):
+        """Wrap the accepted socket in a stream, optionally with direct TLS."""
+        self.client_reader = asyncio.StreamReader()
+        protocol = asyncio.StreamReaderProtocol(self.client_reader)
+        transport, _ = await self.loop.connect_accepted_socket(
+            lambda: protocol, self.client_sock, ssl=ssl_context)
+        self.client_writer = asyncio.StreamWriter(
+            transport, protocol, self.client_reader, self.loop)
+
+    async def start_tls(self, ssl_context):
+        writer = self.client_writer
+        writer._transport = await self.loop.start_tls(
+            writer.transport, writer._protocol, ssl_context, server_side=True)
+        writer._protocol._over_ssl = True
 
     def close(self):
         if self.is_closed:
@@ -170,48 +195,72 @@ class Connection:
 
         if self.proxy_to_backend_task is not None:
             self.proxy_to_backend_task.cancel()
-            self.proxy_to_backend_task = None
 
         if self.proxy_from_backend_task is not None:
             self.proxy_from_backend_task.cancel()
-            self.proxy_from_backend_task = None
 
         self.proxy._close_connection(self)
 
     async def handle(self):
-        self.proxy_to_backend_task = asyncio.ensure_future(
-            self.proxy_to_backend())
+        try:
+            if not await self.prepare():
+                return
 
-        self.proxy_from_backend_task = asyncio.ensure_future(
-            self.proxy_from_backend())
+            self.proxy_to_backend_task = asyncio.ensure_future(
+                self.proxy_to_backend())
+            self.proxy_from_backend_task = asyncio.ensure_future(
+                self.proxy_from_backend())
 
-        try:
             await asyncio.wait(
                 [self.proxy_to_backend_task, self.proxy_from_backend_task],
                 return_when=asyncio.FIRST_COMPLETED)
 
+        except ConnectionError:
+            pass
+
         finally:
+            # Relay completion can schedule close() while cleanup is awaiting
+            # its children. Do not let that callback cancel cleanup itself.
+            self.is_closed = True
             if self.proxy_to_backend_task is not None:
                 self.proxy_to_backend_task.cancel()
 
             if self.proxy_from_backend_task is not None:
                 self.proxy_from_backend_task.cancel()
 
+            await asyncio.gather(*(
+                task for task in (self.proxy_to_backend_task,
+                                  self.proxy_from_backend_task)
+                if task is not None
+            ), return_exceptions=True)
+
             # Asyncio fails to properly remove the readers and writers
             # when the task doing recv() or send() is cancelled, so
             # we must remove the readers and writers manually before
             # closing the sockets.
-            self.loop.remove_reader(self.client_sock.fileno())
-            self.loop.remove_writer(self.client_sock.fileno())
-            self.loop.remove_reader(self.backend_sock.fileno())
-            self.loop.remove_writer(self.backend_sock.fileno())
-
-            self.client_sock.close()
-            self.backend_sock.close()
+            sockets = [self.backend_sock]
+            if self.client_writer is None:
+                sockets.append(self.client_sock)
+            else:
+                self.client_writer.close()
+                with contextlib.suppress(ConnectionError):
+                    await self.client_writer.wait_closed()
+            for sock in sockets:
+                if sock.fileno() < 0:
+                    continue
+                # ProactorEventLoop has no reader/writer registration API.
+                with contextlib.suppress(NotImplementedError):
+                    self.loop.remove_reader(sock.fileno())
+                    self.loop.remove_writer(sock.fileno())
+                sock.close()
+            self.proxy.connections.pop(self, None)
 
     async def _read(self, sock, n):
-        read_task = asyncio.ensure_future(
-            self.loop.sock_recv(sock, n))
+        if sock is self.client_sock and self.client_reader is not None:
+            read = self.client_reader.read(n)
+        else:
+            read = self.loop.sock_recv(sock, n)
+        read_task = asyncio.ensure_future(read)
         conn_event_task = asyncio.ensure_future(
             self.connectivity_loss.wait())
 
@@ -230,10 +279,16 @@ class Connection:
                     read_task.cancel()
                 if not conn_event_task.done():
                     conn_event_task.cancel()
+                await asyncio.gather(read_task, conn_event_task,
+                                     return_exceptions=True)
 
     async def _write(self, sock, data):
-        write_task = asyncio.ensure_future(
-            self.loop.sock_sendall(sock, data))
+        if sock is self.client_sock and self.client_writer is not None:
+            self.client_writer.write(data)
+            write = self.client_writer.drain()
+        else:
+            write = self.loop.sock_sendall(sock, data)
+        write_task = asyncio.ensure_future(write)
         conn_event_task = asyncio.ensure_future(
             self.connectivity_loss.wait())
 
@@ -252,6 +307,8 @@ class Connection:
                     write_task.cancel()
                 if not conn_event_task.done():
                     conn_event_task.cancel()
+                await asyncio.gather(write_task, conn_event_task,
+                                     return_exceptions=True)
 
     async def proxy_to_backend(self):
         buf = None

{asyncpg-0.30.0 → asyncpg-0.32.0}/asyncpg/_version.py

@@ -14,4 +14,4 @@ from __future__ import annotations
 
 import typing
 
-__version__: typing.Final = '0.30.0'
+__version__: typing.Final = '0.32.0'