Fix lint issues

Author: abhinavsingh

proxy/core/connection/connection.py

@@ -12,15 +12,15 @@
 from abc import ABC, abstractmethod
 from typing import List, Union, Optional
 
-from .leak import Leakage
 from .types import tcpConnectionTypes
 from ...common.types import TcpOrTlsSocket
+from ...common.leakage import Leakage
 from ...common.constants import DEFAULT_BUFFER_SIZE, DEFAULT_MAX_SEND_SIZE
 
 
 logger = logging.getLogger(__name__)
 
-EMPTY_MV = memoryview(b"")
+EMPTY_MV = memoryview(b'')
 
 class TcpConnectionUninitializedException(Exception):
     pass
@@ -76,10 +76,10 @@ def recv(
         data: bytes = self.connection.recv(buffer_size)
         size = len(data)
         if self._recv_leakage is not None:
-            self._recv_leakage.putback(buffer_size - size)
+            self._recv_leakage.release(buffer_size - size)
         if size == 0:
             return None
-        logger.debug("received %d bytes from %s" % (size, self.tag))
+        logger.debug('received %d bytes from %s' % (size, self.tag))
         logger.info(data)
         return memoryview(data)
 
@@ -118,10 +118,10 @@ def flush(self, max_send_size: Optional[int] = None) -> int:
             try:
                 sent = self.send(mv[:allowed_bytes])
                 if self._flush_leakage is not None:
-                    self._flush_leakage.putback(allowed_bytes - sent)
+                    self._flush_leakage.release(allowed_bytes - sent)
             except BlockingIOError:
                 logger.warning(
-                    "BlockingIOError when trying send to {0}".format(self.tag)
+                    'BlockingIOError when trying send to {0}'.format(self.tag),
                 )
                 del mv
                 return 0
@@ -133,7 +133,7 @@ def flush(self, max_send_size: Optional[int] = None) -> int:
         else:
             self.buffer[0] = mv[sent:]
         # if sent > 0:
-        logger.debug("flushed %d bytes to %s" % (sent, self.tag))
+        logger.debug('flushed %d bytes to %s' % (sent, self.tag))
         logger.info(mv[:sent].tobytes())
         del mv
         return sent

proxy/core/connection/leak.py

@@ -41,15 +41,15 @@ def work(self, *args: Any) -> None:
             publisher_id=self.__class__.__qualname__,
         )
         try:
-            logger.debug("Initializing work#{0}".format(fileno))
+            logger.debug('Initializing work#{0}'.format(fileno))
             self.works[fileno].initialize()
             self._total += 1
         except Exception as e:
             logger.exception(   # pragma: no cover
                 'Exception occurred during initialization',
                 exc_info=e,
             )
-            self._cleanup(fileno, "error")
+            self._cleanup(fileno, 'error')
 
     @property
     @abstractmethod

proxy/core/work/fd/fd.py

@@ -318,15 +318,15 @@ def _cleanup_inactive(self) -> None:
             if self.works[work_id].is_inactive():
                 inactive_works.append(work_id)
         for work_id in inactive_works:
-            self._cleanup(work_id, "inactive")
+            self._cleanup(work_id, 'inactive')
 
     # TODO: HttpProtocolHandler.shutdown can call flush which may block
     def _cleanup(self, work_id: int, reason: str) -> None:
         if work_id in self.registered_events_by_work_ids:
             assert self.selector
             for fileno in self.registered_events_by_work_ids[work_id]:
                 logger.debug(
-                    "fd#{0} unregistered by work#{1}, reason: {2}".format(
+                    'fd#{0} unregistered by work#{1}, reason: {2}'.format(
                         fileno,
                         work_id,
                         reason,
@@ -400,7 +400,7 @@ async def _run_once(self) -> bool:
                 teardown = True
             finally:
                 if teardown:
-                    self._cleanup(work_id, "teardown")
+                    self._cleanup(work_id, 'teardown')
                     # self.cleanup(int(task.get_name()))
         # logger.debug(
         #     "Done executing works, {0} pending, {1} registered".format(

proxy/core/work/threadless.py

@@ -32,7 +32,7 @@ def client(
     conn_close: bool = True,
     scheme: bytes = HTTPS_PROTO,
     timeout: float = DEFAULT_TIMEOUT,
-    content_type: bytes = b"application/x-www-form-urlencoded",
+    content_type: bytes = b'application/x-www-form-urlencoded',
     verify: bool = False,
 ) -> Optional[HttpParser]:
     """HTTP Client"""

proxy/http/client.py

@@ -86,7 +86,7 @@ def handle_request(self, request: HttpParser) -> None:
                         )
                         needs_upstream = True
                         logger.debug(
-                            "Starting connection to upstream {0}".format(self.choice)
+                            'Starting connection to upstream {0}'.format(self.choice),
                         )
                         break
                 # Dynamic routes
@@ -99,21 +99,21 @@ def handle_request(self, request: HttpParser) -> None:
                             needs_upstream = True
                             self._upstream_proxy_pass = str(self.choice)
                             logger.debug(
-                                "Starting connection to upstream {0}".format(choice)
+                                'Starting connection to upstream {0}'.format(choice),
                             )
                         elif isinstance(choice, memoryview):
                             self.client.queue(choice)
                             self._upstream_proxy_pass = '{0} bytes'.format(len(choice))
-                            logger.debug("Sending raw response to client")
+                            logger.debug('Sending raw response to client')
                         else:
                             self.upstream = choice
                             self._upstream_proxy_pass = '{0}:{1}'.format(
                                 *self.upstream.addr,
                             )
                             logger.debug(
-                                "Using existing connection to upstream {0}".format(
-                                    self.upstream.addr
-                                )
+                                'Using existing connection to upstream {0}'.format(
+                                    self.upstream.addr,
+                                ),
                             )
                         break
                 else:

proxy/http/server/reverse.py

@@ -918,7 +918,7 @@ def test_byte_by_byte(self) -> None:
         ]
         response.parse(memoryview(request[0]))
         self.assertEqual(response.state, httpParserStates.RCVING_BODY)
-        self.assertEqual(response.code, b"200")
+        self.assertEqual(response.code, b'200')
         for byte in (bytes([b]) for b in request[1]):
             response.parse(memoryview(byte))
         self.assertEqual(response.state, httpParserStates.COMPLETE)