Update flake8 (newer pyflakes handles overloads) and update variables

Author: bryanforbes

.flake8

@@ -1,4 +1,4 @@
 [flake8]
 ignore = E402,E731,W503,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,31 +15,32 @@
 import typing_extensions
 
 
-T = typing.TypeVar('T')
-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 = typing.TypeVar('_T')
+_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:
         ...
 
 
@@ -122,7 +123,7 @@ async def wait_closed(stream: asyncio.StreamWriter) -> None:
 
 
 # Workaround for https://bugs.python.org/issue37658
-async def wait_for(fut: 'asyncio.Future[T]', timeout: float) -> T:
+async def wait_for(fut: 'asyncio.Future[_T]', timeout: float) -> _T:
     if timeout is None:
         return await fut
 

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):
@@ -656,9 +657,9 @@ async def _connect_addr(
     timeout: float,
     params: _ConnectionParameters,
     config: _ClientConfiguration,
-    connection_class: typing.Type[C],
+    connection_class: typing.Type[_Connection],
     record_class: typing.Any
-) -> C:
+) -> _Connection:
     assert loop is not None
 
     if timeout <= 0:
@@ -718,10 +719,10 @@ async def _connect(
     *,
     loop: typing.Optional[asyncio.AbstractEventLoop],
     timeout: float,
-    connection_class: typing.Type[C],
+    connection_class: typing.Type[_Connection],
     record_class: typing.Any,
     **kwargs: typing.Any
-) -> C:
+) -> _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):
@@ -1082,7 +1083,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
 
@@ -1658,7 +1659,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)
@@ -1762,10 +1763,10 @@ async def _execute(
         return_status: typing_extensions.Literal[True],
         ignore_custom_codec: bool = ...,
         record_class: typing.Optional[typing.Any] = ...
-    ) -> RecordsExtraType:
+    ) -> _RecordsExtraType:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def _execute(
         self,
         query: str,
@@ -1776,10 +1777,10 @@ async def _execute(
         return_status: typing_extensions.Literal[False] = ...,
         ignore_custom_codec: bool = ...,
         record_class: typing.Optional[typing.Any] = ...
-    ) -> RecordsType:
+    ) -> _RecordsType:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def _execute(
         self,
         query: str,
@@ -1790,13 +1791,13 @@ async def _execute(
         return_status: bool,
         ignore_custom_codec: bool = ...,
         record_class: typing.Optional[typing.Any] = ...
-    ) -> typing.Union[RecordsExtraType, RecordsType]:
+    ) -> typing.Union[_RecordsExtraType, _RecordsType]:
         ...
 
     async def _execute(
         self,
         query: str,
-        args: typing.Sequence[typing.Any],  # noqa: F811, E501
+        args: typing.Sequence[typing.Any],
         limit: int,
         timeout: typing.Optional[float],
         *,
@@ -1827,10 +1828,10 @@ async def __execute(
         return_status: typing_extensions.Literal[True],
         ignore_custom_codec: bool = ...,
         record_class: typing.Optional[typing.Any] = ...
-    ) -> typing.Tuple[RecordsExtraType, '_cprotocol.PreparedStatementState']:
+    ) -> typing.Tuple[_RecordsExtraType, '_cprotocol.PreparedStatementState']:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def __execute(
         self,
         query: str,
@@ -1841,10 +1842,10 @@ async def __execute(
         return_status: typing_extensions.Literal[False] = ...,
         ignore_custom_codec: bool = ...,
         record_class: typing.Optional[typing.Any] = ...
-    ) -> typing.Tuple[RecordsType, '_cprotocol.PreparedStatementState']:
+    ) -> typing.Tuple[_RecordsType, '_cprotocol.PreparedStatementState']:
         ...
 
-    @typing.overload  # noqa: F811
+    @typing.overload
     async def __execute(
         self,
         query: str,
@@ -1856,21 +1857,21 @@ async def __execute(
         ignore_custom_codec: bool = ...,
         record_class: typing.Optional[typing.Any] = ...
     ) -> typing.Union[
-        typing.Tuple[RecordsExtraType, '_cprotocol.PreparedStatementState'],
-        typing.Tuple[RecordsType, '_cprotocol.PreparedStatementState']
+        typing.Tuple[_RecordsExtraType, '_cprotocol.PreparedStatementState'],
+        typing.Tuple[_RecordsType, '_cprotocol.PreparedStatementState']
     ]:
         ...
 
     async def __execute(
         self,
-        query: str,  # noqa: F811
+        query: str,
         args: typing.Sequence[typing.Any],
         limit: int,
         timeout: typing.Optional[float],
         *,
         return_status: bool = False,
         ignore_custom_codec: bool = False,
-        record_class: typing.Optional[typing.Any] = ...
+        record_class: typing.Optional[typing.Any] = None
     ) -> typing.Tuple[typing.Any, '_cprotocol.PreparedStatementState']:
         executor = lambda stmt, timeout: self._protocol.bind_execute(
             stmt, args, '', limit, return_status, timeout)
@@ -1995,7 +1996,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] = ...,
@@ -2010,14 +2011,14 @@ 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],
                   record_class: typing.Optional[typing.Any] = ...,
                   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,
@@ -2031,11 +2032,10 @@ 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
                   record_class: typing.Optional[typing.Any] = protocol.Record,
                   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: