some types

aiosonic/connection.py

@@ -26,7 +26,7 @@
 
 class Connection:
     """Connection class."""
-    def __init__(self, connector: TCPConnector):
+    def __init__(self, connector: TCPConnector) -> None:
         self.connector = connector
         self.reader: Optional[StreamReader] = None
         self.writer: Optional[StreamWriter] = None
@@ -43,7 +43,7 @@ async def connect(self,
                       verify: bool,
                       ssl_context: SSLContext,
                       timeouts: Timeouts,
-                      http2: bool = False):
+                      http2: bool = False) -> None:
         """Connet with timeout."""
         try:
             await wait_for(self._connect(urlparsed, verify,
@@ -54,7 +54,7 @@ async def connect(self,
             raise ConnectTimeout()
 
     async def _connect(self, urlparsed: ParseResult, verify: bool,
-                       ssl_context: SSLContext, http2: bool):
+                       ssl_context: SSLContext, http2: bool) -> None:
         """Get reader and writer."""
         if not urlparsed.hostname:
             raise HttpParsingError('missing hostname')
@@ -90,7 +90,7 @@ def is_closing():
             self.temp_key = key
             await self._connection_made()
 
-    async def _connection_made(self):
+    async def _connection_made(self) -> None:
         tls_conn = self.writer.get_extra_info('ssl_object')
         if not tls_conn:
             return
@@ -104,7 +104,7 @@ async def _connection_made(self):
             self.h2conn = h2.connection.H2Connection()
             self.h2handler = Http2Handler(self)
 
-    def keep_alive(self):
+    def keep_alive(self) -> None:
         """Check if keep alive."""
         self.keep = True
 
@@ -116,7 +116,7 @@ async def __aenter__(self):
         """Get connection from pool."""
         return self
 
-    async def __aexit__(self, exc_type, exc, tb):
+    async def __aexit__(self, exc_type: None, exc: None, tb: None) -> None:
         """Release connection."""
         if self.keep and not exc:
             self.key = self.temp_key
@@ -131,19 +131,19 @@ async def __aexit__(self, exc_type, exc, tb):
             if self.h2handler:
                 self.h2handler.cleanup()
 
-    async def release(self):
+    async def release(self) -> None:
         """Release connection."""
         await self.connector.release(self)
 
     @property
     def timeouts(self) -> Timeouts:
         return self.connector.timeouts
 
-    def __del__(self):
+    def __del__(self) -> None:
         """Cleanup."""
         self.close(True)
 
-    def close(self, check_closing=False):
+    def close(self, check_closing: bool=False) -> None:
         """Close connection if opened."""
         if self.writer:
             is_closing = getattr(self.writer, 'is_closing',

aiosonic/connectors.py

@@ -2,19 +2,14 @@
 
 from asyncio import wait_for
 from asyncio import sleep as asyncio_sleep
-from asyncio import StreamReader
-from asyncio import StreamWriter
-import ssl
 from ssl import SSLContext
 from typing import Coroutine
-from typing import Optional
 from urllib.parse import ParseResult
 
-#import h2.connection (unused)
+# import h2.connection (unused)
 from hyperframe.frame import SettingsFrame
 
-#from concurrent import futures (unused)
-from aiosonic.exceptions import ConnectTimeout
+# from concurrent import futures (unused)
 from aiosonic.exceptions import ConnectionPoolAcquireTimeout
 from aiosonic.exceptions import TimeoutException
 from aiosonic.pools import SmartPool
@@ -54,7 +49,7 @@ async def acquire(self, urlparsed: ParseResult):
 
         try:
             return await wait_for(self.pool.acquire(urlparsed),
-                                          self.timeouts.pool_acquire)
+                                  self.timeouts.pool_acquire)
         except TimeoutException:
             raise ConnectionPoolAcquireTimeout()
 

aiosonic/pools.py

@@ -4,6 +4,7 @@
 from asyncio import Semaphore
 from asyncio import Queue
 
+
 class CyclicQueuePool:
     """Cyclic queue pool of connections."""
     def __init__(self, connector, pool_size, connection_cls):
@@ -53,7 +54,7 @@ async def acquire(self, urlparsed: ParseResult = None):
                     return item
         return self.pool.pop()
 
-    def release(self, conn):
+    def release(self, conn) -> None:
         """Release connection."""
         self.pool.add(conn)
         self.sem.release()
@@ -62,7 +63,7 @@ def is_all_free(self):
         """Indicates if all pool is free."""
         return self.pool_size == self.sem._value
 
-    async def cleanup(self):
+    async def cleanup(self) -> None:
         """Get all conn and close them, this method let this pool unusable."""
         for count in range(self.pool_size):
             conn = await self.acquire()

aiosonic/timeout.py

@@ -7,7 +7,7 @@ def __init__(self,
                  sock_connect: Optional[float] = 5,
                  sock_read: Optional[float] = 30,
                  pool_acquire: Optional[float] = None,
-                 request_timeout: Optional[float] = 60):
+                 request_timeout: Optional[float] = 60) -> None:
         """Timeouts.
 
         Arguments:

aiosonic/utils.py

@@ -1,7 +1,8 @@
 """Utils."""
+from typing import Callable
 
 
-def cache_decorator(size=512):
+def cache_decorator(size: int=512) -> Callable:
     """Dummy cache decorator."""
     _cache = {}