Fix annotations

Author: tomchristie

databases/backends/postgres.py

@@ -7,6 +7,7 @@
 from sqlalchemy.engine.interfaces import Dialect
 from sqlalchemy.sql import ClauseElement
 from sqlalchemy.sql.schema import Column
+from sqlalchemy.types import TypeEngine
 
 from databases.core import DatabaseURL
 from databases.interfaces import ConnectionBackend, DatabaseBackend, TransactionBackend
@@ -72,9 +73,15 @@ def __init__(
         self._row = row
         self._result_columns = result_columns
         self._dialect = dialect
-        self._column_map = {}
-        self._column_map_int = {}
-        self._column_map_full = {}
+        self._column_map = (
+            {}
+        )  # type: typing.Mapping[str, typing.Tuple[int, TypeEngine]]
+        self._column_map_int = (
+            {}
+        )  # type: typing.Mapping[int, typing.Tuple[int, TypeEngine]]
+        self._column_map_full = (
+            {}
+        )  # type: typing.Mapping[str, typing.Tuple[int, TypeEngine]]
         for idx, (column_name, _, column, datatype) in enumerate(self._result_columns):
             self._column_map[column_name] = (idx, datatype)
             self._column_map_int[idx] = (idx, datatype)

databases/core.py

@@ -6,7 +6,6 @@
 from urllib.parse import SplitResult, parse_qsl, urlsplit
 
 from sqlalchemy import text
-from sqlalchemy.engine import RowProxy
 from sqlalchemy.sql import ClauseElement
 
 from databases.importer import import_from_string
@@ -91,18 +90,21 @@ async def __aexit__(
 
     async def fetch_all(
         self, query: typing.Union[ClauseElement, str], values: dict = None
-    ) -> typing.List[RowProxy]:
+    ) -> typing.List[typing.Mapping]:
         async with self.connection() as connection:
             return await connection.fetch_all(query, values)
 
     async def fetch_one(
         self, query: typing.Union[ClauseElement, str], values: dict = None
-    ) -> RowProxy:
+    ) -> typing.Optional[typing.Mapping]:
         async with self.connection() as connection:
             return await connection.fetch_one(query, values)
 
     async def fetch_val(
-        self, query: typing.Union[ClauseElement, str], values: dict = None, column: typing.Any = 0
+        self,
+        query: typing.Union[ClauseElement, str],
+        values: dict = None,
+        column: typing.Any = 0,
     ) -> typing.Any:
         async with self.connection() as connection:
             return await connection.fetch_val(query, values, column=column)
@@ -121,7 +123,7 @@ async def execute_many(
 
     async def iterate(
         self, query: typing.Union[ClauseElement, str], values: dict = None
-    ) -> typing.AsyncGenerator[RowProxy, None]:
+    ) -> typing.AsyncGenerator[typing.Mapping, None]:
         async with self.connection() as connection:
             async for record in connection.iterate(query, values):
                 yield record
@@ -173,19 +175,22 @@ async def __aexit__(
 
     async def fetch_all(
         self, query: typing.Union[ClauseElement, str], values: dict = None
-    ) -> typing.Any:
+    ) -> typing.List[typing.Mapping]:
         return await self._connection.fetch_all(self._build_query(query, values))
 
     async def fetch_one(
         self, query: typing.Union[ClauseElement, str], values: dict = None
-    ) -> typing.Any:
+    ) -> typing.Optional[typing.Mapping]:
         return await self._connection.fetch_one(self._build_query(query, values))
 
     async def fetch_val(
-        self, query: typing.Union[ClauseElement, str], values: dict = None, column: typing.Any = 0
+        self,
+        query: typing.Union[ClauseElement, str],
+        values: dict = None,
+        column: typing.Any = 0,
     ) -> typing.Any:
         row = await self._connection.fetch_one(self._build_query(query, values))
-        return row[column]
+        return None if row is None else row[column]
 
     async def execute(
         self, query: typing.Union[ClauseElement, str], values: dict = None