improves code quality (#2)

* improves code quality

* adds missing dependencies

* adds flake8 test to Azure Pipelines

Author: RobertoPrevato

.flake8

@@ -0,0 +1,6 @@
+[flake8]
+exclude = __pycache__,built,build,venv
+ignore = E203, E266, W503
+max-line-length = 88
+max-complexity = 18
+select = B,C,E,F,W,T4,B9

.github/workflows/build.yml

@@ -0,0 +1,72 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - master
+      - ci
+  pull_request:
+    branches:
+      - '*'
+
+env:
+  PROJECT_NAME: essentials
+
+jobs:
+  build:
+    runs-on: ubuntu-18.04
+    strategy:
+      matrix:
+        python-version: [3.7, 3.8]
+
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 9
+        submodules: false
+
+    - name: Use Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - uses: actions/cache@v1
+      id: depcache
+      with:
+        path: deps
+        key: requirements-pip-${{ matrix.python-version }}-${{ hashFiles('requirements.txt') }}
+
+    - name: Download dependencies
+      if: steps.depcache.outputs.cache-hit != 'true'
+      run: |
+        pip download --dest=deps -r requirements.txt
+
+    - name: Install dependencies
+      run: |
+        pip install -U --no-index --find-links=deps deps/*
+
+    - name: Run tests
+      run: |
+        flake8 && pytest --doctest-modules --junitxml=junit/pytest-results-${{ matrix.python-version }}.xml --cov=$PROJECT_NAME --cov-report=xml tests/
+
+    - name: Upload pytest test results
+      uses: actions/upload-artifact@master
+      with:
+        name: pytest-results-${{ matrix.python-version }}
+        path: junit/pytest-results-${{ matrix.python-version }}.xml
+      if: always()
+
+    - name: Install distribution dependencies
+      run: pip install --upgrade twine setuptools wheel
+      if: matrix.python-version == 3.8
+
+    - name: Create distribution package
+      run: python setup.py sdist bdist_wheel
+      if: matrix.python-version == 3.8
+
+    - name: Upload distribution package
+      uses: actions/upload-artifact@master
+      with:
+        name: dist-package-${{ matrix.python-version }}
+        path: dist
+      if: matrix.python-version == 3.8

.gitignore

@@ -105,4 +105,5 @@ venv.bak/
 
 built/
 
-.idea
+.idea
+.vscode

azure-pipelines.yml

@@ -26,11 +26,14 @@ steps:
     pip install -r requirements.txt
   displayName: 'Install dependencies'
 
+- script: flake8
+  displayName: Flake8 test
+
 - script: |
     pip install pytest pytest-asyncio pytest-cov
     pip install https://github.com/RobertoPrevato/pytest-azurepipelines/archive/css_styles.zip
     python -m pytest tests/ --cov essentials --cov-report html
-  displayName: 'pytest'
+  displayName: Run pytest tests
 
 - script: |
     pip install --upgrade twine setuptools wheel

essentials.code-workspace

@@ -0,0 +1,28 @@
+{
+  "folders": [
+    {
+      "path": "."
+    }
+  ],
+  "settings": {
+    "python.testing.pytestArgs": [
+      "."
+    ],
+    "files.trimTrailingWhitespace": true,
+    "files.trimFinalNewlines": true,
+    "python.testing.unittestEnabled": false,
+    "python.testing.nosetestsEnabled": false,
+    "python.testing.pytestEnabled": true,
+    "python.linting.pylintEnabled": false,
+    "python.linting.flake8Enabled": true,
+    "python.linting.mypyEnabled": true,
+    "python.linting.enabled": true,
+    "[python]": {
+        "editor.tabSize": 4,
+        "editor.rulers": [
+            88,
+            100
+        ]
+    }
+  }
+}

essentials/decorators/__init__.py

@@ -1,23 +1,28 @@
 from functools import wraps
 from inspect import iscoroutinefunction
 from typing import Type
-from .retry import retry, CatchException, OnException
+from .retry import retry, CatchException, OnException  # noqa
 
 
-def exception_handle(exception_type: Type[Exception], catch_exceptions_types: CatchException = None):
+def exception_handle(
+    exception_type: Type[Exception],
+    catch_exceptions_types: CatchException = None
+):
     """
-    Wraps a given function to catch all exceptions that might happen during its execution, and
-    rethrow new exceptions of the given type.
+    Wraps a given function to catch all exceptions that might happen during
+    its execution, and rethrow new exceptions of the given type.
 
-    :param exception_type: the desired type of exception, that should throw the decorated function in case of exception.
-    :param catch_exceptions_types: the types of exception to be catched (defaults to Exception)
-    :return:
+    :param exception_type: the desired type of exception,
+                           to be thrown in case of exception.
+    :param catch_exceptions_types: the types of exception to be
+                                   catched (defaults to Exception)
     """
     if not catch_exceptions_types:
         catch_exceptions_types = Exception
 
     def decorator(fn):
         if iscoroutinefunction(fn):
+
             @wraps(fn)
             async def async_wrapper(*args, **kwargs):
                 try:
@@ -33,5 +38,7 @@ def wrapper(*args, **kwargs):
                 return fn(*args, **kwargs)
             except catch_exceptions_types as exp:
                 raise exception_type(exp)
+
         return wrapper
+
     return decorator

essentials/decorators/logs.py

@@ -1,12 +1,11 @@
 import logging
-import reprlib
-from uuid import uuid4
-from logging import Logger
-from typing import Optional, Callable
 from functools import wraps
-from essentials.diagnostics import StopWatch
 from inspect import iscoroutinefunction
+from logging import Logger
+from typing import Callable, Optional
+from uuid import uuid4
 
+from essentials.diagnostics import StopWatch
 
 IdFactory = Callable[[], str]
 
@@ -15,22 +14,24 @@ def _default_id_factory():
     return str(uuid4())
 
 
-def log(logger: Optional[Logger] = None,
-        id_factory: Optional[IdFactory] = None,
-        log_arguments: bool = False,
-        log_return_value: bool = False,
-        level=logging.INFO,
-        call_msg='%s; called; call id: %s',
-        call_msg_with_input='%s; called; call id: %s; args: %s; kwargs: %s',
-        completed_msg='%s; completed; call id: %s; elapsed %s ms',
-        completed_msg_with_output='%s; completed; call id: %s; elapsed %s ms; output: %s',
-        exc_message='%s; unhandled exception; call id: %s; elapsed %s ms'):
+def log(
+    logger: Optional[Logger] = None,
+    id_factory: Optional[IdFactory] = None,
+    log_arguments: bool = False,
+    log_return_value: bool = False,
+    level=logging.INFO,
+    call_msg="%s; called; call id: %s",
+    call_msg_with_input="%s; called; call id: %s; args: %s; kwargs: %s",
+    completed_msg="%s; completed; call id: %s; elapsed %s ms",
+    completed_msg_with_output="%s; completed; call id: %s; elapsed %s ms; output: %s",
+    exc_message="%s; unhandled exception; call id: %s; elapsed %s ms",
+):
 
     if not id_factory:
         id_factory = _default_id_factory
 
     if logger is None:
-        logger = logging.getLogger(f'fn_calls')
+        logger = logging.getLogger(f"fn_calls")
 
     def before(name, fn, args, kwargs):
         function_call_id = id_factory()
@@ -44,19 +45,31 @@ def before(name, fn, args, kwargs):
 
     def on_exception(name, stop_watch, exc, function_call_id):
         stop_watch.stop()
-        logger.exception(exc_message, name, function_call_id, stop_watch.elapsed_ms, exc_info=exc)
+        logger.exception(
+            exc_message, name, function_call_id, stop_watch.elapsed_ms, exc_info=exc
+        )
 
     def after(name, stop_watch, function_call_id, value):
         if log_return_value:
-            logger.log(level, completed_msg_with_output, name, function_call_id, stop_watch.elapsed_ms, value)
+            logger.log(
+                level,
+                completed_msg_with_output,
+                name,
+                function_call_id,
+                stop_watch.elapsed_ms,
+                value,
+            )
         else:
-            logger.log(level, completed_msg, name, function_call_id, stop_watch.elapsed_ms)
+            logger.log(
+                level, completed_msg, name, function_call_id, stop_watch.elapsed_ms
+            )
 
     def log_decorator(fn):
         nonlocal logger
-        name = fn.__module__ + '.' + fn.__name__
+        name = fn.__module__ + "." + fn.__name__
 
         if iscoroutinefunction(fn):
+
             @wraps(fn)
             async def async_wrapper(*args, **kwargs):
                 function_call_id = before(name, fn, args, kwargs)
@@ -88,4 +101,5 @@ def wrapper(*args, **kwargs):
             return value
 
         return wrapper
+
     return log_decorator

essentials/decorators/retry.py

@@ -9,12 +9,14 @@
 OnException = Optional[Callable[[Type[Exception], int], None]]
 
 
-def _get_retry_async_wrapper(fn,
-                             times: int,
-                             delay: float,
-                             catch_exceptions_types: CatchException,
-                             on_exception: OnException,
-                             loop):
+def _get_retry_async_wrapper(
+    fn,
+    times: int,
+    delay: float,
+    catch_exceptions_types: CatchException,
+    on_exception: OnException,
+    loop,
+):
     @wraps(fn)
     async def async_wrapper(*args, **kwargs):
         attempt = 0
@@ -39,22 +41,21 @@ async def async_wrapper(*args, **kwargs):
     return async_wrapper
 
 
-def retry(times: int = 3,
-          delay: Optional[float] = 0.1,
-          catch_exceptions_types: CatchException = None,
-          on_exception: OnException = None,
-          loop=None):
+def retry(
+    times: int = 3,
+    delay: Optional[float] = 0.1,
+    catch_exceptions_types: CatchException = None,
+    on_exception: OnException = None,
+    loop=None,
+):
     if catch_exceptions_types is None:
         catch_exceptions_types = Exception
 
     def retry_decorator(fn):
         if iscoroutinefunction(fn):
-            return _get_retry_async_wrapper(fn,
-                                            times,
-                                            delay,
-                                            catch_exceptions_types,
-                                            on_exception,
-                                            loop)
+            return _get_retry_async_wrapper(
+                fn, times, delay, catch_exceptions_types, on_exception, loop
+            )
 
         @wraps(fn)
         def wrapper(*args, **kwargs):
@@ -73,5 +74,7 @@ def wrapper(*args, **kwargs):
 
                     if delay is not None:
                         time.sleep(delay)
+
         return wrapper
+
     return retry_decorator

essentials/diagnostics.py

@@ -1,26 +1,28 @@
-"""Timer class, edited from: Python Cookbook, 3rd Edition by Brian K. Jones, David Beazley"""
+"""
+Timer class, edited from: Python Cookbook,
+3rd Edition by Brian K. Jones, David Beazley
+"""
 import time
 
 
 class StopWatch:
-
     def __init__(self, func=time.perf_counter):
         self._elapsed_s = 0.0
         self._func = func
         self._start = None
 
     def __repr__(self):
-        return f'<StopWatch elapsed s.: {self.elapsed_s}>'
+        return f"<StopWatch elapsed s.: {self.elapsed_s}>"
 
     def start(self):
         if self._start is not None:
-            raise RuntimeError('StopWatch already running')
+            raise RuntimeError("StopWatch already running")
 
         self._start = self._func()
 
     def stop(self):
         if self._start is None:
-            raise RuntimeError('StopWatch not running')
+            raise RuntimeError("StopWatch not running")
 
         self._elapsed_s += self._func() - self._start