Update flake8 (newer pyflakes handles overloads) and update variables

Author: bryanforbes

.flake8

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

asyncpg/compat.py

@@ -15,30 +15,31 @@
 import typing_extensions
 
 
-T_co = typing.TypeVar('T_co', covariant=True)
-F = typing.TypeVar('F', bound=typing.Callable[..., typing.Any])
-F_35 = typing.TypeVar('F_35', bound=typing.Callable[
+_T_co = typing.TypeVar('_T_co', covariant=True)
+_F = typing.TypeVar('_F', bound=typing.Callable[..., typing.Any])
+_F_35 = typing.TypeVar('_F_35', bound=typing.Callable[
     ...,
     typing.Coroutine[typing.Any, typing.Any, typing.Any]
 ])
+
 PY_36 = sys.version_info >= (3, 6)
 PY_37 = sys.version_info >= (3, 7)
 SYSTEM = platform.uname().system
 
 
 if sys.version_info < (3, 5, 2):
-    def aiter_compat(func: F) -> F_35:
+    def aiter_compat(func: _F) -> _F_35:
         @functools.wraps(func)
         async def wrapper(self: typing.Any) -> typing.Any:
             return func(self)
-        return typing.cast(F_35, wrapper)
+        return typing.cast(_F_35, wrapper)
 else:
-    def aiter_compat(func: F) -> F:  # type: ignore
+    def aiter_compat(func: _F) -> _F:  # type: ignore
         return func
 
 
-class PathLike(typing_extensions.Protocol[T_co]):
-    def __fspath__(self) -> T_co:
+class PathLike(typing_extensions.Protocol[_T_co]):
+    def __fspath__(self) -> _T_co:
         ...
 
 

asyncpg/connect_utils.py

@@ -27,10 +27,10 @@
 from . import exceptions
 from . import protocol
 
-C = typing.TypeVar('C')
-P = typing.TypeVar('P', bound=asyncio.Protocol)
+_Connection = typing.TypeVar('_Connection')
+_Protocol = typing.TypeVar('_Protocol', bound=asyncio.Protocol)
 
-_TPTupleType = typing.Tuple[asyncio.WriteTransport, P]
+_TPTupleType = typing.Tuple[asyncio.WriteTransport, _Protocol]
 AddrType = typing.Union[typing.Tuple[str, int], str]
 SSLType = typing.Union[ssl_module.SSLContext,
                        typing_extensions.Literal[True]]
@@ -577,14 +577,15 @@ def connection_lost(self, exc: typing.Optional[Exception]) -> None:
             self.on_data.set_exception(exc)
 
 
-async def _create_ssl_connection(protocol_factory: typing.Callable[[], P],
+async def _create_ssl_connection(protocol_factory: typing.Callable[[],
+                                                                   _Protocol],
                                  host: str, port: int, *,
                                  loop: asyncio.AbstractEventLoop,
                                  ssl_context: typing.Union[
                                      ssl_module.SSLContext,
                                      typing_extensions.Literal[True]],
                                  ssl_is_advisory: typing.Optional[bool] =
-                                 False) -> _TPTupleType[P]:
+                                 False) -> _TPTupleType[_Protocol]:
 
     if ssl_context is True:
         ssl_context = ssl_module.create_default_context()
@@ -641,7 +642,7 @@ async def _create_ssl_connection(protocol_factory: typing.Callable[[], P],
 
         try:
             return typing.cast(
-                typing.Tuple[asyncio.WriteTransport, P],
+                typing.Tuple[asyncio.WriteTransport, _Protocol],
                 await conn_factory(sock=sock)
             )
         except (Exception, asyncio.CancelledError):
@@ -654,7 +655,8 @@ async def _connect_addr(*, addr: AddrType,
                         timeout: float,
                         params: _ConnectionParameters,
                         config: _ClientConfiguration,
-                        connection_class: typing.Type[C]) -> C:
+                        connection_class: typing.Type[_Connection]) \
+        -> _Connection:
     assert loop is not None
 
     if timeout <= 0:
@@ -717,8 +719,8 @@ async def _connect_addr(*, addr: AddrType,
 
 async def _connect(*, loop: typing.Optional[asyncio.AbstractEventLoop],
                    timeout: float,
-                   connection_class: typing.Type[C],
-                   **kwargs: typing.Any) -> C:
+                   connection_class: typing.Type[_Connection],
+                   **kwargs: typing.Any) -> _Connection:
     if loop is None:
         loop = asyncio.get_event_loop()
 

asyncpg/connection.py

@@ -35,23 +35,24 @@
     from . import types
 
 
-C = typing.TypeVar('C', bound='Connection')
-Writer = typing.Callable[[bytes],
-                         typing.Coroutine[typing.Any, typing.Any, None]]
+_Connection = typing.TypeVar('_Connection', bound='Connection')
+_Writer = typing.Callable[[bytes],
+                          typing.Coroutine[typing.Any, typing.Any, None]]
+_RecordsType = typing.List['_cprotocol.Record']
+_RecordsExtraType = typing.Tuple[_RecordsType, bytes, bool]
+_AnyCallable = typing.Callable[..., typing.Any]
+
 OutputType = typing.Union[typing.AnyStr,
                           compat.PathLike[typing.AnyStr],
                           typing.IO[typing.AnyStr],
-                          Writer]
+                          _Writer]
 SourceType = typing.Union[typing.AnyStr,
                           compat.PathLike[typing.AnyStr],
                           typing.IO[typing.AnyStr],
                           typing.AsyncIterable[bytes]]
 
 CopyFormat = typing_extensions.Literal['text', 'csv', 'binary']
 PasswordType = typing.Union[str, typing.Callable[[], str]]
-RecordsType = typing.List['_cprotocol.Record']
-RecordsExtraType = typing.Tuple[RecordsType, bytes, bool]
-AnyCallable = typing.Callable[..., typing.Any]
 
 
 class Listener(typing_extensions.Protocol):
@@ -890,7 +891,7 @@ async def _copy_out(self, copy_stmt: str,
             # output is not a path-like object
             path = None
 
-        writer = None  # type: typing.Optional[Writer]
+        writer = None  # type: typing.Optional[_Writer]
         opened_by_us = False
         run_in_executor = self._loop.run_in_executor
 
@@ -1458,7 +1459,7 @@ def _set_proxy(self, proxy: typing.Optional['_pool.PoolConnectionProxy']) \
         self._proxy = proxy
 
     def _check_listeners(self,
-                         listeners: 'typing._Collection[AnyCallable]',
+                         listeners: 'typing._Collection[_AnyCallable]',
                          listener_type: str) -> None:
         if listeners:
             count = len(listeners)
@@ -1555,24 +1556,24 @@ async def reload_schema_state(self) -> None:
     async def _execute(self, query: str, args: typing.Sequence[typing.Any],
                        limit: int, timeout: typing.Optional[float],
                        return_status: typing_extensions.Literal[True]) \
-            -> RecordsExtraType:
+            -> _RecordsExtraType:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def _execute(self, query: str, args: typing.Sequence[typing.Any],
                        limit: int, timeout: typing.Optional[float],
                        return_status: typing_extensions.Literal[False] = ...) \
-            -> RecordsType:
+            -> _RecordsType:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def _execute(self, query: str, args: typing.Sequence[typing.Any],
                        limit: int, timeout: typing.Optional[float],
                        return_status: bool) \
-            -> typing.Union[RecordsExtraType, RecordsType]:
+            -> typing.Union[_RecordsExtraType, _RecordsType]:
         ...
 
-    async def _execute(self, query: str, args: typing.Sequence[typing.Any],  # noqa: F811, E501
+    async def _execute(self, query: str, args: typing.Sequence[typing.Any],
                        limit: int, timeout: typing.Optional[float],
                        return_status: bool = False) -> typing.Any:
         with self._stmt_exclusive_section:
@@ -1584,29 +1585,29 @@ async def _execute(self, query: str, args: typing.Sequence[typing.Any],  # noqa:
     async def __execute(self, query: str, args: typing.Sequence[typing.Any],
                         limit: int, timeout: typing.Optional[float],
                         return_status: typing_extensions.Literal[True]) \
-            -> typing.Tuple[RecordsExtraType,
+            -> typing.Tuple[_RecordsExtraType,
                             '_cprotocol.PreparedStatementState']:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def __execute(self, query: str, args: typing.Sequence[typing.Any],
                         limit: int, timeout: typing.Optional[float],
                         return_status: typing_extensions.Literal[
                             False] = ...) \
-            -> typing.Tuple[RecordsType, '_cprotocol.PreparedStatementState']:
+            -> typing.Tuple[_RecordsType, '_cprotocol.PreparedStatementState']:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def __execute(self, query: str, args: typing.Sequence[typing.Any],
                         limit: int, timeout: typing.Optional[float],
                         return_status: bool) \
-            -> typing.Union[typing.Tuple[RecordsExtraType,
+            -> typing.Union[typing.Tuple[_RecordsExtraType,
                                          '_cprotocol.PreparedStatementState'],
-                            typing.Tuple[RecordsType,
+                            typing.Tuple[_RecordsType,
                                          '_cprotocol.PreparedStatementState']]:
         ...
 
-    async def __execute(self, query: str,  # noqa: F811
+    async def __execute(self, query: str,
                         args: typing.Sequence[typing.Any],
                         limit: int, timeout: typing.Optional[float],
                         return_status: bool = False) -> typing.Tuple[
@@ -1711,7 +1712,7 @@ async def connect(dsn: typing.Optional[str] = ..., *,
     ...
 
 
-@typing.overload  # noqa: F811
+@typing.overload
 async def connect(dsn: typing.Optional[str] = ..., *,
                   host: typing.Optional[connect_utils.HostType] = ...,
                   port: typing.Optional[connect_utils.PortType] = ...,
@@ -1726,13 +1727,13 @@ async def connect(dsn: typing.Optional[str] = ..., *,
                   max_cacheable_statement_size: int = ...,
                   command_timeout: typing.Optional[float] = ...,
                   ssl: typing.Optional[connect_utils.SSLType] = ...,
-                  connection_class: typing.Type[C],
+                  connection_class: typing.Type[_Connection],
                   server_settings: typing.Optional[
-                      typing.Dict[str, str]] = ...) -> C:
+                      typing.Dict[str, str]] = ...) -> _Connection:
     ...
 
 
-async def connect(dsn: typing.Optional[str] = None, *,  # noqa: F811
+async def connect(dsn: typing.Optional[str] = None, *,
                   host: typing.Optional[connect_utils.HostType] = None,
                   port: typing.Optional[connect_utils.PortType] = None,
                   user: typing.Optional[str] = None,
@@ -1746,10 +1747,9 @@ async def connect(dsn: typing.Optional[str] = None, *,  # noqa: F811
                   max_cacheable_statement_size: int = 1024 * 15,
                   command_timeout: typing.Optional[float] = None,
                   ssl: typing.Optional[connect_utils.SSLType] = None,
-                  connection_class: typing.Type[C] = \
-                  Connection,  # type: ignore
+                  connection_class: typing.Type[_Connection] = Connection,  # type: ignore  # noqa: E501
                   server_settings: typing.Optional[
-                      typing.Dict[str, str]] = None) -> C:
+                      typing.Dict[str, str]] = None) -> _Connection:
     r"""A coroutine to establish a connection to a PostgreSQL server.
 
     The connection parameters may be specified either as a connection

asyncpg/connresource.py

@@ -16,21 +16,22 @@
     from . import connection as _connection
 
 
-CR = typing.TypeVar('CR', bound='ConnectionResource')
-F = typing.TypeVar('F', bound=typing.Callable[..., typing.Any])
+_ConnectionResource = typing.TypeVar('_ConnectionResource',
+                                     bound='ConnectionResource')
+_Callable = typing.TypeVar('_Callable', bound=typing.Callable[..., typing.Any])
 
 
-def guarded(meth: F) -> F:
+def guarded(meth: _Callable) -> _Callable:
     """A decorator to add a sanity check to ConnectionResource methods."""
 
     @functools.wraps(meth)
-    def _check(self: CR,
+    def _check(self: _ConnectionResource,
                *args: typing.Any,
                **kwargs: typing.Any) -> typing.Any:
         self._check_conn_validity(meth.__name__)
         return meth(self, *args, **kwargs)
 
-    return typing.cast(F, _check)
+    return typing.cast(_Callable, _check)
 
 
 class ConnectionResource:

asyncpg/cursor.py

@@ -18,9 +18,10 @@
     from . import connection as _connection
 
 
-C = typing.TypeVar('C', bound='Cursor[typing.Any]')
-CI = typing.TypeVar('CI', bound='CursorIterator[typing.Any]')
-R = typing.TypeVar('R', bound='_cprotocol.Record')
+_Cursor = typing.TypeVar('_Cursor', bound='Cursor[typing.Any]')
+_CursorIterator = typing.TypeVar('_CursorIterator',
+                                 bound='CursorIterator[typing.Any]')
+_Record = typing.TypeVar('_Record', bound='_cprotocol.Record')
 
 
 class CursorFactory(connresource.ConnectionResource):
@@ -72,7 +73,7 @@ def __del__(self) -> None:
             self._connection._maybe_gc_stmt(self._state)
 
 
-class BaseCursor(connresource.ConnectionResource, typing.Generic[R]):
+class BaseCursor(connresource.ConnectionResource, typing.Generic[_Record]):
 
     __slots__ = ('_state', '_args', '_portal_name', '_exhausted', '_query')
 
@@ -174,7 +175,7 @@ def __del__(self) -> None:
             self._connection._maybe_gc_stmt(self._state)
 
 
-class CursorIterator(BaseCursor[R]):
+class CursorIterator(BaseCursor[_Record]):
 
     __slots__ = ('_buffer', '_prefetch', '_timeout')
 
@@ -189,17 +190,17 @@ def __init__(self, connection: '_connection.Connection', query: str,
             raise exceptions.InterfaceError(
                 'prefetch argument must be greater than zero')
 
-        self._buffer = collections.deque()  # type: typing.Deque[R]
+        self._buffer = collections.deque()  # type: typing.Deque[_Record]
         self._prefetch = prefetch
         self._timeout = timeout
 
     @compat.aiter_compat
     @connresource.guarded
-    def __aiter__(self: CI) -> CI:
+    def __aiter__(self: _CursorIterator) -> _CursorIterator:
         return self
 
     @connresource.guarded
-    async def __anext__(self) -> R:
+    async def __anext__(self) -> _Record:
         if self._state is None:
             self._state = await self._connection._get_statement(
                 self._query, self._timeout, named=True)
@@ -219,12 +220,12 @@ async def __anext__(self) -> R:
         raise StopAsyncIteration
 
 
-class Cursor(BaseCursor[R]):
+class Cursor(BaseCursor[_Record]):
     """An open *portal* into the results of a query."""
 
     __slots__ = ()
 
-    async def _init(self: C, timeout: typing.Optional[float]) -> C:
+    async def _init(self: _Cursor, timeout: typing.Optional[float]) -> _Cursor:
         if self._state is None:
             self._state = await self._connection._get_statement(
                 self._query, timeout, named=True)
@@ -235,7 +236,8 @@ async def _init(self: C, timeout: typing.Optional[float]) -> C:
 
     @connresource.guarded
     async def fetch(self, n: int, *,
-                    timeout: typing.Optional[float] = None) -> typing.List[R]:
+                    timeout: typing.Optional[float] = None) \
+            -> typing.List[_Record]:
         r"""Return the next *n* rows as a list of :class:`Record` objects.
 
         :param float timeout: Optional timeout value in seconds.
@@ -247,7 +249,7 @@ async def fetch(self, n: int, *,
             raise exceptions.InterfaceError('n must be greater than zero')
         if self._exhausted:
             return []
-        recs = await self._exec(n, timeout)  # type: typing.List[R]
+        recs = await self._exec(n, timeout)  # type: typing.List[_Record]
         if len(recs) < n:
             self._exhausted = True
         return recs
@@ -256,7 +258,7 @@ async def fetch(self, n: int, *,
     async def fetchrow(
         self, *,
         timeout: typing.Optional[float] = None
-    ) -> typing.Optional[R]:
+    ) -> typing.Optional[_Record]:
         r"""Return the next row.
 
         :param float timeout: Optional timeout value in seconds.
@@ -266,7 +268,7 @@ async def fetchrow(
         self._check_ready()
         if self._exhausted:
             return None
-        recs = await self._exec(1, timeout)  # type: typing.List[R]
+        recs = await self._exec(1, timeout)  # type: typing.List[_Record]
         if len(recs) < 1:
             self._exhausted = True
             return None