asyncpg 0.28.0__tar.gz → 0.30.0__tar.gz

asyncpg-0.30.0/.flake8

@@ -0,0 +1,5 @@
+[flake8]
+select = C90,E,F,W,Y0
+ignore = E402,E731,W503,W504,E252
+exclude = .git,__pycache__,build,dist,.eggs,.github,.local,.venv*,.tox
+per-file-ignores = *.pyi: F401,F403,F405,F811,E127,E128,E203,E266,E301,E302,E305,E501,E701,E704,E741,B303,W503,W504

{asyncpg-0.28.0 → asyncpg-0.30.0}/MANIFEST.in

@@ -1,5 +1,5 @@
 recursive-include docs *.py *.rst Makefile *.css
 recursive-include examples *.py
 recursive-include tests *.py *.pem
-recursive-include asyncpg *.pyx *.pxd *.pxi *.py *.c *.h
+recursive-include asyncpg *.pyx *.pxd *.pxi *.py *.pyi *.c *.h
 include LICENSE README.rst Makefile performance.png .flake8

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: asyncpg
-Version: 0.28.0
+Version: 0.30.0
 Summary: An asyncio PostgreSQL driver
 Author-email: MagicStack Inc <hello@magic.io>
 License: Apache License, Version 2.0
@@ -14,19 +14,33 @@ 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.7
 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 :: Implementation :: CPython
 Classifier: Topic :: Database :: Front-Ends
-Requires-Python: >=3.7.0
+Requires-Python: >=3.8.0
 Description-Content-Type: text/x-rst
-Provides-Extra: test
-Provides-Extra: docs
 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"
 
 asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio
 =======================================================================
@@ -43,9 +57,10 @@ 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.7 or later and is supported for PostgreSQL
-versions 9.5 to 15.  Older PostgreSQL versions or other databases implementing
-the PostgreSQL protocol *may* work, but are not being actively tested.
+asyncpg requires Python 3.8 or later and is supported for PostgreSQL
+versions 9.5 to 17.  Other PostgreSQL versions or other databases
+implementing the PostgreSQL protocol *may* work, but are not being
+actively tested.
 
 
 Documentation
@@ -88,11 +103,18 @@ This enables asyncpg to have easy-to-use support for:
 Installation
 ------------
 
-asyncpg is available on PyPI and has no dependencies.
-Use pip to install::
+asyncpg is available on PyPI.  When not using GSSAPI/SSPI authentication it
+has no dependencies.  Use pip to install::
 
     $ pip install asyncpg
 
+If you need GSSAPI/SSPI authentication, use::
+
+    $ pip install 'asyncpg[gssauth]'
+
+For more details, please `see the documentation
+<https://magicstack.github.io/asyncpg/current/installation.html>`_.
+
 
 Basic Usage
 -----------
@@ -111,8 +133,7 @@ Basic Usage
         )
         await conn.close()
 
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(run())
+    asyncio.run(run())
 
 
 License

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

@@ -13,9 +13,10 @@ 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.7 or later and is supported for PostgreSQL
-versions 9.5 to 15.  Older PostgreSQL versions or other databases implementing
-the PostgreSQL protocol *may* work, but are not being actively tested.
+asyncpg requires Python 3.8 or later and is supported for PostgreSQL
+versions 9.5 to 17.  Other PostgreSQL versions or other databases
+implementing the PostgreSQL protocol *may* work, but are not being
+actively tested.
 
 
 Documentation
@@ -58,11 +59,18 @@ This enables asyncpg to have easy-to-use support for:
 Installation
 ------------
 
-asyncpg is available on PyPI and has no dependencies.
-Use pip to install::
+asyncpg is available on PyPI.  When not using GSSAPI/SSPI authentication it
+has no dependencies.  Use pip to install::
 
     $ pip install asyncpg
 
+If you need GSSAPI/SSPI authentication, use::
+
+    $ pip install 'asyncpg[gssauth]'
+
+For more details, please `see the documentation
+<https://magicstack.github.io/asyncpg/current/installation.html>`_.
+
 
 Basic Usage
 -----------
@@ -81,8 +89,7 @@ Basic Usage
         )
         await conn.close()
 
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(run())
+    asyncio.run(run())
 
 
 License

{asyncpg-0.28.0 → asyncpg-0.30.0}/asyncpg/__init__.py

@@ -4,6 +4,7 @@
 # This module is part of asyncpg and is released under
 # the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
 
+from __future__ import annotations
 
 from .connection import connect, Connection  # NOQA
 from .exceptions import *  # NOQA
@@ -14,6 +15,10 @@ from .types import *  # NOQA
 
 from ._version import __version__  # NOQA
 
+from . import exceptions
 
-__all__ = ('connect', 'create_pool', 'Pool', 'Record', 'Connection')
+
+__all__: tuple[str, ...] = (
+    'connect', 'create_pool', 'Pool', 'Record', 'Connection'
+)
 __all__ += exceptions.__all__ # NOQA

asyncpg-0.30.0/asyncpg/_asyncio_compat.py

@@ -0,0 +1,94 @@
+# Backports from Python/Lib/asyncio for older Pythons
+#
+# Copyright (c) 2001-2023 Python Software Foundation; All Rights Reserved
+#
+# SPDX-License-Identifier: PSF-2.0
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import sys
+import typing
+
+if typing.TYPE_CHECKING:
+    from . import compat
+
+if sys.version_info < (3, 11):
+    from async_timeout import timeout as timeout_ctx
+else:
+    from asyncio import timeout as timeout_ctx
+
+_T = typing.TypeVar('_T')
+
+
+async def wait_for(fut: compat.Awaitable[_T], timeout: float | None) -> _T:
+    """Wait for the single Future or coroutine to complete, with timeout.
+
+    Coroutine will be wrapped in Task.
+
+    Returns result of the Future or coroutine.  When a timeout occurs,
+    it cancels the task and raises TimeoutError.  To avoid the task
+    cancellation, wrap it in shield().
+
+    If the wait is cancelled, the task is also cancelled.
+
+    If the task supresses the cancellation and returns a value instead,
+    that value is returned.
+
+    This function is a coroutine.
+    """
+    # The special case for timeout <= 0 is for the following case:
+    #
+    # async def test_waitfor():
+    #     func_started = False
+    #
+    #     async def func():
+    #         nonlocal func_started
+    #         func_started = True
+    #
+    #     try:
+    #         await asyncio.wait_for(func(), 0)
+    #     except asyncio.TimeoutError:
+    #         assert not func_started
+    #     else:
+    #         assert False
+    #
+    # asyncio.run(test_waitfor())
+
+    if timeout is not None and timeout <= 0:
+        fut = asyncio.ensure_future(fut)
+
+        if fut.done():
+            return fut.result()
+
+        await _cancel_and_wait(fut)
+        try:
+            return fut.result()
+        except asyncio.CancelledError as exc:
+            raise TimeoutError from exc
+
+    async with timeout_ctx(timeout):
+        return await fut
+
+
+async def _cancel_and_wait(fut: asyncio.Future[_T]) -> None:
+    """Cancel the *fut* future or task and wait until it completes."""
+
+    loop = asyncio.get_running_loop()
+    waiter = loop.create_future()
+    cb = functools.partial(_release_waiter, waiter)
+    fut.add_done_callback(cb)
+
+    try:
+        fut.cancel()
+        # We cannot wait on *fut* directly to make
+        # sure _cancel_and_wait itself is reliably cancellable.
+        await waiter
+    finally:
+        fut.remove_done_callback(cb)
+
+
+def _release_waiter(waiter: asyncio.Future[typing.Any], *args: object) -> None:
+    if not waiter.done():
+        waiter.set_result(None)

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

@@ -117,10 +117,22 @@ class TestCase(unittest.TestCase, metaclass=TestCaseMeta):
         self.__unhandled_exceptions = []
 
     def tearDown(self):
-        if self.__unhandled_exceptions:
+        excs = []
+        for exc in self.__unhandled_exceptions:
+            if isinstance(exc, ConnectionResetError):
+                texc = traceback.TracebackException.from_exception(
+                    exc, lookup_lines=False)
+                if texc.stack[-1].name == "_call_connection_lost":
+                    # On Windows calling socket.shutdown may raise
+                    # ConnectionResetError, which happens in the
+                    # finally block of _call_connection_lost.
+                    continue
+            excs.append(exc)
+
+        if excs:
             formatted = []
 
-            for i, context in enumerate(self.__unhandled_exceptions):
+            for i, context in enumerate(excs):
                 formatted.append(self._format_loop_exception(context, i + 1))
 
             self.fail(
@@ -214,13 +226,6 @@ def _init_cluster(ClusterCls, cluster_kwargs, initdb_options=None):
     return cluster
 
 
-def _start_cluster(ClusterCls, cluster_kwargs, server_settings,
-                   initdb_options=None):
-    cluster = _init_cluster(ClusterCls, cluster_kwargs, initdb_options)
-    cluster.start(port='dynamic', server_settings=server_settings)
-    return cluster
-
-
 def _get_initdb_options(initdb_options=None):
     if not initdb_options:
         initdb_options = {}
@@ -244,8 +249,12 @@ def _init_default_cluster(initdb_options=None):
             _default_cluster = pg_cluster.RunningCluster()
         else:
             _default_cluster = _init_cluster(
-                pg_cluster.TempCluster, cluster_kwargs={},
-                initdb_options=_get_initdb_options(initdb_options))
+                pg_cluster.TempCluster,
+                cluster_kwargs={
+                    "data_dir_suffix": ".apgtest",
+                },
+                initdb_options=_get_initdb_options(initdb_options),
+            )
 
     return _default_cluster
 
@@ -262,6 +271,7 @@ def create_pool(dsn=None, *,
                 max_size=10,
                 max_queries=50000,
                 max_inactive_connection_lifetime=60.0,
+                connect=None,
                 setup=None,
                 init=None,
                 loop=None,
@@ -271,12 +281,18 @@ def create_pool(dsn=None, *,
                 **connect_kwargs):
     return pool_class(
         dsn,
-        min_size=min_size, max_size=max_size,
-        max_queries=max_queries, loop=loop, setup=setup, init=init,
+        min_size=min_size,
+        max_size=max_size,
+        max_queries=max_queries,
+        loop=loop,
+        connect=connect,
+        setup=setup,
+        init=init,
         max_inactive_connection_lifetime=max_inactive_connection_lifetime,
         connection_class=connection_class,
         record_class=record_class,
-        **connect_kwargs)
+        **connect_kwargs,
+    )
 
 
 class ClusterTestCase(TestCase):

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

@@ -10,4 +10,8 @@
 # supported platforms, publish the packages on PyPI, merge the PR
 # to the target branch, create a Git tag pointing to the commit.
 
-__version__ = '0.28.0'
+from __future__ import annotations
+
+import typing
+
+__version__: typing.Final = '0.30.0'

{asyncpg-0.28.0 → asyncpg-0.30.0}/asyncpg/cluster.py

@@ -9,9 +9,11 @@ import asyncio
 import os
 import os.path
 import platform
+import random
 import re
 import shutil
 import socket
+import string
 import subprocess
 import sys
 import tempfile
@@ -45,6 +47,29 @@ def find_available_port():
         sock.close()
 
 
+def _world_readable_mkdtemp(suffix=None, prefix=None, dir=None):
+    name = "".join(random.choices(string.ascii_lowercase, k=8))
+    if dir is None:
+        dir = tempfile.gettempdir()
+    if prefix is None:
+        prefix = tempfile.gettempprefix()
+    if suffix is None:
+        suffix = ""
+    fn = os.path.join(dir, prefix + name + suffix)
+    os.mkdir(fn, 0o755)
+    return fn
+
+
+def _mkdtemp(suffix=None, prefix=None, dir=None):
+    if _system == 'Windows' and os.environ.get("GITHUB_ACTIONS"):
+        # Due to mitigations introduced in python/cpython#118486
+        # when Python runs in a session created via an SSH connection
+        # tempfile.mkdtemp creates directories that are not accessible.
+        return _world_readable_mkdtemp(suffix, prefix, dir)
+    else:
+        return tempfile.mkdtemp(suffix, prefix, dir)
+
+
 class ClusterError(Exception):
     pass
 
@@ -122,9 +147,13 @@ class Cluster:
         else:
             extra_args = []
 
+        os.makedirs(self._data_dir, exist_ok=True)
         process = subprocess.run(
             [self._pg_ctl, 'init', '-D', self._data_dir] + extra_args,
-            stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            cwd=self._data_dir,
+        )
 
         output = process.stdout
 
@@ -199,7 +228,10 @@ class Cluster:
             process = subprocess.run(
                 [self._pg_ctl, 'start', '-D', self._data_dir,
                  '-o', ' '.join(extra_args)],
-                stdout=stdout, stderr=subprocess.STDOUT)
+                stdout=stdout,
+                stderr=subprocess.STDOUT,
+                cwd=self._data_dir,
+            )
 
             if process.returncode != 0:
                 if process.stderr:
@@ -218,7 +250,10 @@ class Cluster:
             self._daemon_process = \
                 subprocess.Popen(
                     [self._postgres, '-D', self._data_dir, *extra_args],
-                    stdout=stdout, stderr=subprocess.STDOUT)
+                    stdout=stdout,
+                    stderr=subprocess.STDOUT,
+                    cwd=self._data_dir,
+                )
 
             self._daemon_pid = self._daemon_process.pid
 
@@ -232,7 +267,10 @@ class Cluster:
 
         process = subprocess.run(
             [self._pg_ctl, 'reload', '-D', self._data_dir],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=self._data_dir,
+        )
 
         stderr = process.stderr
 
@@ -245,7 +283,10 @@ class Cluster:
         process = subprocess.run(
             [self._pg_ctl, 'stop', '-D', self._data_dir, '-t', str(wait),
              '-m', 'fast'],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=self._data_dir,
+        )
 
         stderr = process.stderr
 
@@ -583,9 +624,9 @@ class TempCluster(Cluster):
     def __init__(self, *,
                  data_dir_suffix=None, data_dir_prefix=None,
                  data_dir_parent=None, pg_config_path=None):
-        self._data_dir = tempfile.mkdtemp(suffix=data_dir_suffix,
-                                          prefix=data_dir_prefix,
-                                          dir=data_dir_parent)
+        self._data_dir = _mkdtemp(suffix=data_dir_suffix,
+                                  prefix=data_dir_prefix,
+                                  dir=data_dir_parent)
         super().__init__(self._data_dir, pg_config_path=pg_config_path)
 
 

asyncpg-0.30.0/asyncpg/compat.py

@@ -0,0 +1,88 @@
+# Copyright (C) 2016-present the asyncpg authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of asyncpg and is released under
+# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
+
+from __future__ import annotations
+
+import enum
+import pathlib
+import platform
+import typing
+import sys
+
+if typing.TYPE_CHECKING:
+    import asyncio
+
+SYSTEM: typing.Final = platform.uname().system
+
+
+if sys.platform == 'win32':
+    import ctypes.wintypes
+
+    CSIDL_APPDATA: typing.Final = 0x001a
+
+    def get_pg_home_directory() -> pathlib.Path | None:
+        # We cannot simply use expanduser() as that returns the user's
+        # home directory, whereas Postgres stores its config in
+        # %AppData% on Windows.
+        buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH)
+        r = ctypes.windll.shell32.SHGetFolderPathW(0, CSIDL_APPDATA, 0, 0, buf)
+        if r:
+            return None
+        else:
+            return pathlib.Path(buf.value) / 'postgresql'
+
+else:
+    def get_pg_home_directory() -> pathlib.Path | None:
+        try:
+            return pathlib.Path.home()
+        except (RuntimeError, KeyError):
+            return None
+
+
+async def wait_closed(stream: asyncio.StreamWriter) -> None:
+    # Not all asyncio versions have StreamWriter.wait_closed().
+    if hasattr(stream, 'wait_closed'):
+        try:
+            await stream.wait_closed()
+        except ConnectionResetError:
+            # On Windows wait_closed() sometimes propagates
+            # ConnectionResetError which is totally unnecessary.
+            pass
+
+
+if sys.version_info < (3, 12):
+    def markcoroutinefunction(c):  # type: ignore
+        pass
+else:
+    from inspect import markcoroutinefunction  # noqa: F401
+
+
+if sys.version_info < (3, 12):
+    from ._asyncio_compat import wait_for as wait_for  # noqa: F401
+else:
+    from asyncio import wait_for as wait_for  # noqa: F401
+
+
+if sys.version_info < (3, 11):
+    from ._asyncio_compat import timeout_ctx as timeout  # noqa: F401
+else:
+    from asyncio import timeout as timeout  # noqa: F401
+
+if sys.version_info < (3, 9):
+    from typing import (  # noqa: F401
+        Awaitable as Awaitable,
+    )
+else:
+    from collections.abc import (  # noqa: F401
+        Awaitable as Awaitable,
+    )
+
+if sys.version_info < (3, 11):
+    class StrEnum(str, enum.Enum):
+        __str__ = str.__str__
+        __repr__ = enum.Enum.__repr__
+else:
+    from enum import StrEnum as StrEnum  # noqa: F401