[feat] PEP8 Support

.circleci/config.yml

@@ -32,6 +32,7 @@ jobs:
  python3 -m venv venv
  . venv/bin/activate
  pip install -r requirements.txt
+ pip install -r dev-requirements.txt
 
  - save_cache:
  paths:
@@ -49,6 +50,12 @@ jobs:
  command: |
  . venv/bin/activate
  python test.py
+
+ - run:
+ name: Code Style Check
+ command: |
+ . venv/bin/activate
+ flake8 .
  test-3.7:
  <<: *test-template
  docker:

.flake8

@@ -0,0 +1,10 @@
+[flake8]
+ignore=E501,E401,F403,F401,F811,W293
+exclude =
+ .git,
+ __pycache__,
+ docs/source/conf.py,
+ old,
+ build,
+ dist
+ venv

dev-requirements.txt

@@ -0,0 +1 @@
+flake8

samples/benchmarks/template_engine.py

@@ -41,4 +41,3 @@ async def render():
 for _ in range(0, rounds):
  t.render({'x': b, 'y': y})
 print('Jinja2: ', time.time() - t1)
-

tests/components.py

@@ -78,8 +78,7 @@ async def home(test: TestComponent, test2: TestComponent2, name: str):
  response = await client.get('/test')
  self.assertEqual(
  response.content,
- app.components[TestComponent].name + app.components[TestComponent2].name
- + b'test'
+ app.components[TestComponent].name + app.components[TestComponent2].name + b'test'
  )
 
  def test_loaded_component_class_instead_of_instance_expects_exception(self):

vibora/client/response.py

@@ -22,12 +22,16 @@ class ResponseStatus(Enum):
 
 class Response:
 
- __slots__ = ('_connection', '_headers', '_content', '_parser', '_parser_status', '_cookies',
- '_status_code', '_decode', '_chunk_size', '_decoder', '_encoding',
- 'request', 'url')
-
- def __init__(self, url: str, connection: Connection,
- request: Request, chunk_size: int= 1 * 1024 * 1024, decode: bool=True):
+ __slots__ = ('_connection', '_headers', '_content', '_parser',
+ '_parser_status', '_cookies', '_status_code', '_decode',
+ '_chunk_size', '_decoder', '_encoding', 'request', 'url')
+
+ def __init__(self,
+ url: str,
+ connection: Connection,
+ request: Request,
+ chunk_size: int = 1 * 1024 * 1024,
+ decode: bool = True):
  self._connection = connection
  self._headers = {}
  self._content = bytearray()
@@ -52,7 +56,7 @@ def json(self, *args, loads=None, **kwargs):
  loads = json.loads
  return loads(self.content.decode(self.encoding), *args, **kwargs)
 
- def text(self, encoding: str=None) -> str:
+ def text(self, encoding: str = None) -> str:
  return self.content.decode(encoding=encoding or self.encoding)
 
  @property
@@ -62,8 +66,9 @@ def status_code(self):
  :return:
  """
  if self._parser_status == ResponseStatus.PENDING_HEADERS:
- raise Exception('Status code not loaded yet. '
- 'In streaming mode you should manually call load_headers().')
+ raise Exception(
+ 'Status code not loaded yet. '
+ 'In streaming mode you should manually call load_headers().')
  return self._status_code
 
  @property
@@ -73,8 +78,9 @@ def headers(self):
  :return:
  """
  if self._parser_status == ResponseStatus.PENDING_HEADERS:
- raise Exception('Headers not loaded yet. '
- 'In streaming mode you should manually call load_headers().')
+ raise Exception(
+ 'Headers not loaded yet. '
+ 'In streaming mode you should manually call load_headers().')
  return self._headers
 
  @property
@@ -99,7 +105,8 @@ async def cookies(self):
  if self._cookies is None:
  self._cookies = CookiesJar()
  if self._headers.get('set-cookie'):
- self._cookies.add_cookie(Cookie.from_header(self._headers['set-cookie']))
+ self._cookies.add_cookie(
+ Cookie.from_header(self._headers['set-cookie']))
  return self._cookies
 
  async def read_content(self):
@@ -114,7 +121,8 @@ async def read_content(self):
  length = int(self._headers['Content-Length'])
  if not self._decoder:
  # Skipping the HTTP parser for performance.
- self._content.extend(await self._connection.read_exactly(length))
+ self._content.extend(await
+ self._connection.read_exactly(length))
  self.on_message_complete()
  else:
  self._parser.feed(await self._connection.read_exactly(length))
@@ -159,18 +167,22 @@ async def _release_connection(self):
 
  :return:
  """
- await self._connection.pool.release_connection(self._connection, self._parser.should_keep_alive())
+ await self._connection.pool.release_connection(
+ self._connection, self._parser.should_keep_alive())
 
- async def stream(self, chunk_size: int=1*1024*1024, chunk_timeout: int=10,
- complete_timeout: int=300):
+ async def stream(self,
+ chunk_size: int = 1 * 1024 * 1024,
+ chunk_timeout: int = 10,
+ complete_timeout: int = 300):
  """
 
  :param complete_timeout:
  :param chunk_timeout:
  :param chunk_size:
  :return:
  """
- if self._parser_status not in (ResponseStatus.PENDING_HEADERS, ResponseStatus.PENDING_BODY):
+ if self._parser_status not in (ResponseStatus.PENDING_HEADERS,
+ ResponseStatus.PENDING_BODY):
  raise StreamAlreadyConsumed
  if self._parser_status == ResponseStatus.PENDING_HEADERS:
  await wait_for(self.receive_headers(), chunk_timeout)
@@ -182,7 +194,8 @@ async def stream(self, chunk_size: int=1*1024*1024, chunk_timeout: int=10,
  bytes_to_read = min(remaining, chunk_size)
  task = self._connection.read_exactly(bytes_to_read)
  start_time = time.time()
- self._parser.feed(await wait_for(task, min(chunk_timeout, complete_timeout)))
+ self._parser.feed(await wait_for(
+ task, min(chunk_timeout, complete_timeout)))
  complete_timeout -= time.time() - start_time
  remaining -= bytes_to_read
  yield bytes(self._content)
@@ -194,9 +207,11 @@ async def stream(self, chunk_size: int=1*1024*1024, chunk_timeout: int=10,
  task = self._connection.read_until(b'\r\n')
  start_time = time.time()
  try:
- self._parser.feed(await wait_for(task, min(chunk_timeout, complete_timeout)))
+ self._parser.feed(await wait_for(
+ task, min(chunk_timeout, complete_timeout)))
  except asyncio.LimitOverrunError as error:
- self._parser.feed(await self._connection.read_exactly(error.consumed))
+ self._parser.feed(await self._connection.read_exactly(
+ error.consumed))
  complete_timeout -= time.time() - start_time
  while len(self._content) >= chunk_size:
  yield self._content[:chunk_size]
@@ -248,7 +263,12 @@ def on_message_complete(self):
  except Exception as error:
  print(error)
 
- def chunk_complete(self): pass
+ def chunk_complete(self):
+ """
+
+ :return:
+ """
+ pass
 
  def __repr__(self):
  if 400 > self.status_code >= 300:

vibora/client/websocket.py

@@ -5,12 +5,10 @@
 from vibora.websockets import FrameParser
 from .request import WebsocketRequest
 
-
 # https://websocket.org/echo.html
 
 
 class WebsocketProtocol(asyncio.Protocol):
-
  def __init__(self, transport, loop):
  self.loop = loop
  self.transport = transport
@@ -28,7 +26,6 @@ async def on_message(self, data):
 
 
 class WebsocketHandshake(asyncio.Protocol):
-
  def __init__(self, client, loop):
  self.client = client
  self.loop = loop
@@ -43,33 +40,64 @@ def connection_made(self, transport):
  :param transport:
  :return:
  """
- wr = WebsocketRequest(self.client.host, path=self.client.path, origin=self.client.origin)
- transport.write(wr.encode())
+ websocket_response = WebsocketRequest(
+ self.client.host, path=self.client.path, origin=self.client.origin)
+ transport.write(websocket_response.encode())
  self.transport = transport
  print('connected')
 
  def data_received(self, data):
+ """
+
+ :param data:
+ :return:
+ """
  self.parser.feed(data)
  print(f'Data received: {data}')
 
  def connection_lost(self, exc):
+ """
+
+ :param exc:
+ :return:
+ """
  print('The server closed the connection')
  print('Stop the event loop')
 
  # Parser Callbacks
- def on_body(self): pass
+ def on_body(self):
+ """
+
+ :return:
+ """
+ pass
 
  def on_headers_complete(self, headers, status_code):
+ """
+
+ :param headers:
+ :param status_code:
+ :return:
+ """
  self.current_status = status_code
  self.current_headers = headers
 
  def on_message_complete(self):
- self.transport.set_protocol(WebsocketProtocol(self.transport, self.loop))
+ """
+
+ :return:
+ """
+ self.transport.set_protocol(
+ WebsocketProtocol(self.transport, self.loop))
 
 
 class WebsocketClient:
-
- def __init__(self, host: str, port: int, path: str = '/', loop=None, origin: str = None):
+ def __init__(self,
+ host: str,
+ port: int,
+ path: str = '/',
+ loop=None,
+ origin: str = None):
  self.host = host
  self.port = port
  self.path = path
@@ -80,12 +108,21 @@ def __init__(self, host: str, port: int, path: str = '/', loop=None, origin: str
 
  async def connect(self):
  factory = partial(WebsocketHandshake, self, self.loop)
- await self.loop.create_connection(factory, host=self.host, port=self.port, ssl=True)
+ await self.loop.create_connection(
+ factory, host=self.host, port=self.port, ssl=True)
 
  async def send(self, msg):
  if not self.connected:
  await self.connect()
  pass
 
- async def receive(self, max_size: int = 1 * 1024 * 1024, stream: bool = False):
+ async def receive(self,
+ max_size: int = 1 * 1024 * 1024,
+ stream: bool = False):
+ """
+
+ :param max_size:
+ :param stream:
+ :return:
+ """
  pass

vibora/limits.py

@@ -1,12 +1,9 @@
-
-
 class ServerLimits:
-
  __slots__ = ('worker_timeout', 'keep_alive_timeout', 'response_timeout', 'max_body_size',
  'max_headers_size', 'write_buffer')
 
- def __init__(self, worker_timeout: int=60, keep_alive_timeout: int=30,
- max_headers_size: int=1024 * 10, write_buffer: int=419430):
+ def __init__(self, worker_timeout: int = 60, keep_alive_timeout: int = 30,
+ max_headers_size: int = 1024 * 10, write_buffer: int = 419430):
  """
 
  :param worker_timeout:
@@ -20,11 +17,10 @@ def __init__(self, worker_timeout: int=60, keep_alive_timeout: int=30,
 
 
 class RouteLimits:
-
  __slots__ = ('timeout', 'max_body_size', 'in_memory_threshold')
 
- def __init__(self, max_body_size: int=1*1024*1024, timeout: int=30,
- in_memory_threshold: int=1*1024*1024):
+ def __init__(self, max_body_size: int = 1 * 1024 * 1024, timeout: int = 30,
+ in_memory_threshold: int = 1 * 1024 * 1024):
  """
 
  :param max_body_size: