WIP: Upgrade injector

.vscode/launch.json

@@ -57,6 +57,20 @@
         "tests/application/version_test.py"
       ]
     },
+    {
+      "name": "Test: tests/resource/transactional_guard_test.py",
+      "type": "python",
+      "request": "launch",
+      "module": "pytest",
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}/src:${workspaceFolder}/tests"
+      },
+      "args": [
+        "--capture=sys",
+        "--log-cli-level=DEBUG",
+        "tests/resource/transactional_guard_test.py"
+      ]
+    },
     {
       "name": "Test: all",
       "type": "python",

requirements.txt

@@ -5,12 +5,11 @@ click>=7.0
 enum34
 future
 Flask>=1.1
-injector==0.12.1
+injector>=0.18
 redis>=3.2
 requests>=2.22
 SQLAlchemy>=1.3,<1.4
 tox
-typing>=3.7
-Werkzeug>=0.16,<0.17
+Werkzeug>=0.16
 zsl_client
 pytest

setup.py

@@ -7,10 +7,9 @@
 requirements = [
     'flask>=1.1,<1.2',
     'future',
-    'injector==0.12.1',
+    'injector==0.18.4',
     'requests>=2.22',
     'SQLAlchemy>=1.3,<1.4',
-    'typing>=3.7',
     'Werkzeug>=0.15,<0.17',
 ]
 

src/zsl/__init__.py

@@ -10,8 +10,6 @@
 
 .. moduleauthor:: Martin Babka <[email protected]>
 """
-from __future__ import unicode_literals
-
 from flask import Config
 from injector import Module
 
@@ -24,9 +22,6 @@
 
 Zsl = ServiceApplication
 
-# placeholder for default value used in function declaration for arguments which will be injected
-Injected = None
-
 # just for autocomplete in various IDEs
 inject = inject
 Config = Config

src/zsl/__main__.py

@@ -4,8 +4,6 @@
 
 Main service module.
 """
-from __future__ import unicode_literals
-
 from zsl.interface.cli import cli
 
 if __name__ == "__main__":

src/zsl/application/containers/celery_container.py

@@ -2,7 +2,6 @@
 :mod:`zsl.application.containers.celery_container`
 --------------------------------------------------
 """
-from __future__ import unicode_literals
 
 from zsl.application.containers.core_container import CoreContainer
 from zsl.application.modules.celery_module import (CeleryCliModule, CeleryTaskQueueMainWorkerModule,

src/zsl/application/containers/container.py

@@ -2,12 +2,10 @@
 :mod:`zsl.application.containers.container`
 -------------------------------------------
 """
-from __future__ import unicode_literals
-
 import inspect
 
 
-class IoCContainer(object):
+class IoCContainer:
     """Collection of DI modules set as class attributes.
 
     This is used for declarative DI configuration, which can be easily

src/zsl/application/containers/core_container.py

@@ -2,8 +2,6 @@
 :mod:`zsl.application.containers.core_container`
 ------------------------------------------------
 """
-from __future__ import unicode_literals
-
 from zsl.application.containers.container import IoCContainer
 from zsl.application.modules.alchemy_module import AlchemyModule
 from zsl.application.modules.cache_module import RedisCacheInjectionModule

src/zsl/application/containers/gearman_container.py

@@ -2,7 +2,6 @@
 :mod:`zsl.application.containers.gearman_container`
 ---------------------------------------------------
 """
-from __future__ import unicode_literals
 
 from zsl.application.containers.core_container import CoreContainer
 from zsl.application.modules.gearman_module import GearmanModule

src/zsl/application/containers/web_container.py

@@ -2,8 +2,6 @@
 :mod:`zsl.application.containers.web_container`
 -----------------------------------------------
 """
-from __future__ import unicode_literals
-
 from zsl.application.containers.core_container import CoreContainer
 from zsl.application.modules.web.web_context_module import WebContextModule
 

src/zsl/application/error_handler.py

@@ -6,9 +6,6 @@
 an error handler for a given exception type. It also provides default
 error handlers.
 """
-from __future__ import absolute_import, division, print_function, unicode_literals
-
-from builtins import *
 from functools import wraps
 import http.client
 import logging
@@ -30,7 +27,7 @@
 
 class ErrorResponse(AppModel):
     def __init__(self, code, message):
-        super(ErrorResponse, self).__init__({})
+        super().__init__({})
         self.code = code
         self.message = message
 
@@ -54,11 +51,11 @@ def can_handle(self, e):
     def handle(self, ex):
         logger = logging.getLogger(__name__)
         logger.error(str(ex) + "\n" + traceback.format_exc())
-        logger.error("Request:\n{0}\n{1}\n".format(request.headers,
-                                                   request.data))
+        logger.error("Request:\n{}\n{}\n".format(request.headers,
+                                                 request.data))
         link = documentation_link('error_handling')
         logger.info("Provide your own error handler so that "
-                    "a better error is produced, check {0}.".format(link))
+                    "a better error is produced, check {}.".format(link))
 
         add_responder(StatusCodeResponder(http.client.INTERNAL_SERVER_ERROR))
         return ErrorResponse(self.ERROR_CODE, self.ERROR_MESSAGE)
@@ -122,9 +119,8 @@ def error_handler(f):
 
     @wraps(f)
     def error_handling_function(*args, **kwargs):
-        @inject(error_config=ErrorConfiguration)
-        def get_error_configuration(error_config):
-            # type:(ErrorConfiguration)->ErrorConfiguration
+        @inject
+        def get_error_configuration(error_config: ErrorConfiguration) -> ErrorConfiguration:
             return error_config
 
         def should_skip_handling():

src/zsl/application/initialization_context.py

@@ -7,19 +7,20 @@
 
 .. moduleauthor:: Martin Babka
 """
-from __future__ import unicode_literals
+from typing import Any, List
 
 
-class InitializationContext(object):
-    def __init__(self, unit_test=False, initializers=None):
+class InitializationContext:
+
+    def __init__(self, unit_test: bool = False, initializers: List[Any] = None):
         if not initializers:
             initializers = []
 
         self._unit_test = unit_test
         self._initializers = initializers
         self._is_initialized = False
 
-    def get_unit_testing(self):
+    def get_unit_testing(self) -> bool:
         return self._unit_test
 
     unit_testing = property(get_unit_testing)

src/zsl/application/initializers/library_initializer.py

@@ -2,9 +2,6 @@
 :mod:`zsl.application.initializers.library_initializer`
 -------------------------------------------------------
 """
-from __future__ import unicode_literals
-
-from builtins import object
 import logging
 import os
 import sys
@@ -19,11 +16,13 @@ def append_paths(path, vendor_modules):
     sys.path = new_path + sys.path
 
 
-class LibraryInitializer(object):
+class LibraryInitializer:
+    # TODO: Change to iface
+
     """Add vendor modules to current path."""
     @staticmethod
-    @inject(config=Config)
-    def initialize(config):
+    @inject
+    def initialize(config: Config) -> None:
         logging.debug("Initializing project external libraries.")
 
         external_libraries = config.get('EXTERNAL_LIBRARIES', None)
@@ -33,5 +32,5 @@ def initialize(config):
         vendor_path = external_libraries['vendor_path']
         append_paths(vendor_path, external_libraries['libs'])
 
-        logging.info("Current PYTHON_PATH={0}.".format(sys.path))
+        logging.info("Current PYTHON_PATH={}.".format(sys.path))
         logging.debug("Project external libraries initialized.")

src/zsl/application/initializers/service_initializer.py

@@ -2,30 +2,29 @@
 :mod:`zsl.application.initializers.service_initializer`
 -------------------------------------------------------
 """
-from __future__ import unicode_literals
-
-from builtins import object
 import importlib
 import logging
 
 from injector import Binder, singleton
 
-from zsl import Config, Injected, inject
+from zsl import Config, inject
 from zsl.utils.string_helper import camelcase_to_underscore
 
 
-class ServiceInitializer(object):
+class ServiceInitializer:
+    # TODO: change to iface
+
     """Add outside services to application injector."""
     @staticmethod
-    @inject(binder=Binder)
-    def _bind_service(package_name, cls_name, binder=Injected):
+    @inject
+    def _bind_service(package_name: str, cls_name: str, binder: Binder) -> None:
         """Bind service to application injector.
 
         :param package_name: service package
         :type package_name: str
         :param cls_name: service class
         :type cls_name: str
-        :param binder: current application binder, injected
+        :param binder: current application binder
         :type binder: Binder
         """
         module = importlib.import_module(package_name)
@@ -36,14 +35,14 @@ def _bind_service(package_name, cls_name, binder=Injected):
             to=binder.injector.create_object(cls),
             scope=singleton
         )
-        logging.debug("Created {0} binding.".format(cls))
+        logging.debug("Created {} binding.".format(cls))
 
     @staticmethod
-    @inject(config=Config)
-    def initialize(config):
+    @inject
+    def initialize(config: Config) -> None:
         """Initialize method.
 
-        :param config: current application config, injected
+        :param config: current application config
         :type config: Config
         """
         service_injection_config = config.get('SERVICE_INJECTION', ())
@@ -61,5 +60,5 @@ def initialize(config):
 
                 for cls_name in services:
                     module_name = camelcase_to_underscore(cls_name)
-                    package_name = "{0}.{1}".format(service_package, module_name)
+                    package_name = "{}.{}".format(service_package, module_name)
                     ServiceInitializer._bind_service(package_name, cls_name)

src/zsl/application/initializers/unittest_initializer.py

@@ -2,18 +2,16 @@
 :mod:`zsl.application.initializers.unittest_initializer`
 --------------------------------------------------------
 """
-from __future__ import unicode_literals
-
-from builtins import object
-
 from zsl import ApplicationContext, Config, inject
 
 
-class UnitTestInitializer(object):
+class UnitTestInitializer:
+    # TODO: Change to iface
+
     """Initializer handling the unit test settings."""
     @staticmethod
-    @inject(config=Config)
-    def initialize(config):
+    @inject
+    def initialize(config: Config) -> None:
 
         if not UnitTestInitializer.is_unit_testing():
             return
@@ -26,6 +24,6 @@ def initialize(config):
                 'TEST_DATABASE_ENGINE_PROPS']
 
     @staticmethod
-    @inject(ctx=ApplicationContext)
-    def is_unit_testing(ctx):
+    @inject
+    def is_unit_testing(ctx: ApplicationContext) -> bool:
         return ctx.unit_testing