Use from import statements

Author: ZipFile

src/dependency_injector/containers.pyx

@@ -1,20 +1,22 @@
 """Containers module."""
 
-import asyncio
-import contextlib
-import copy as copy_module
-import json
-import importlib
-import inspect
+from asyncio import gather
+from contextlib import suppress
+from copy import deepcopy as copy_deepcopy
+from importlib import import_module
+from inspect import getmodule, stack as inspect_stack
+from json import load as json_load
 
 try:
     import yaml
 except ImportError:
     yaml = None
 
-from . import providers, errors
+from . import errors, providers
+
 from .providers cimport __is_future_or_coroutine
-from .wiring import wire, unwire
+
+from .wiring import unwire, wire
 
 
 class WiringConfiguration:
@@ -113,7 +115,7 @@ class DynamicContainer(Container):
 
         copied.provider_type = providers.Provider
         copied.overridden = providers.deepcopy(self.overridden, memo)
-        copied.wiring_config = copy_module.deepcopy(self.wiring_config, memo)
+        copied.wiring_config = copy_deepcopy(self.wiring_config, memo)
         copied.declarative_parent = self.declarative_parent
 
         for name, provider in providers.deepcopy(self.providers, memo).items():
@@ -301,10 +303,10 @@ class DynamicContainer(Container):
                     from_package = self.wiring_config.from_package
                 elif self.declarative_parent is not None \
                         and (self.wiring_config.modules or self.wiring_config.packages):
-                    with contextlib.suppress(Exception):
+                    with suppress(Exception):
                         from_package = _resolve_package_name_from_cls(self.declarative_parent)
                 else:
-                    with contextlib.suppress(Exception):
+                    with suppress(Exception):
                         from_package = _resolve_calling_package_name()
 
         modules = _resolve_string_imports(modules, from_package)
@@ -354,7 +356,7 @@ class DynamicContainer(Container):
                 futures.append(resource)
 
         if futures:
-            return asyncio.gather(*futures)
+            return gather(*futures)
 
     def shutdown_resources(self, resource_type=providers.BaseResource):
         """Shutdown all container resources."""
@@ -382,7 +384,7 @@ class DynamicContainer(Container):
                     result = resource.shutdown()
                     if __is_future_or_coroutine(result):
                         futures.append(result)
-                await asyncio.gather(*futures)
+                await gather(*futures)
 
         def _sync_ordered_shutdown(resources):
             while any(resource.initialized for resource in resources):
@@ -469,7 +471,7 @@ class DynamicContainer(Container):
     def from_json_schema(self, filepath):
         """Build container providers from JSON schema."""
         with open(filepath) as file:
-            schema = json.load(file)
+            schema = json_load(file)
         self.from_schema(schema)
 
     def resolve_provider_name(self, provider):
@@ -735,7 +737,7 @@ class DeclarativeContainer(Container, metaclass=DeclarativeContainerMetaClass):
         """
         container = cls.instance_type()
         container.provider_type = cls.provider_type
-        container.wiring_config = copy_module.deepcopy(cls.wiring_config)
+        container.wiring_config = copy_deepcopy(cls.wiring_config)
         container.declarative_parent = cls
 
         copied_providers = providers.deepcopy({ **cls.providers, **{"@@self@@": cls.__self__}})
@@ -924,18 +926,18 @@ cpdef bint _any_relative_string_imports_in(object modules):
 
 cpdef list _resolve_string_imports(object modules, object from_package):
     return [
-        importlib.import_module(module, from_package) if isinstance(module, str) else module
+        import_module(module, from_package) if isinstance(module, str) else module
         for module in modules
     ]
 
 
 cpdef object _resolve_calling_package_name():
-    stack = inspect.stack()
+    stack = inspect_stack()
     pre_last_frame = stack[0]
-    module = inspect.getmodule(pre_last_frame[0])
+    module = getmodule(pre_last_frame[0])
     return module.__package__
 
 
 cpdef object _resolve_package_name_from_cls(cls):
-    module = importlib.import_module(cls.__module__)
+    module = import_module(cls.__module__)
     return module.__package__

src/dependency_injector/providers.pxd

@@ -1,7 +1,7 @@
 """Providers module."""
 
-import asyncio
-import functools
+from asyncio import Future, ensure_future, gather
+from functools import partial
 
 cimport cython
 
@@ -487,18 +487,18 @@ cdef inline object __provide_keyword_args(
 
 
 cdef inline object __combine_future_injections(object injections, list future_injections):
-    future_result = asyncio.Future()
+    future_result = Future()
 
-    injections_ready = asyncio.gather(*[value for _, value in future_injections])
+    injections_ready = gather(*[value for _, value in future_injections])
     injections_ready.add_done_callback(
-        functools.partial(
+        partial(
             __async_prepare_args_kwargs_callback,
             future_result,
             injections,
             future_injections,
         ),
     )
-    asyncio.ensure_future(injections_ready)
+    ensure_future(injections_ready)
 
     return future_result
 
@@ -541,16 +541,16 @@ cdef inline object __provide_attributes(tuple attributes, int attributes_len):
 
 
 cdef inline object __async_inject_attributes(future_instance, future_attributes):
-    future_result = asyncio.Future()
+    future_result = Future()
 
-    attributes_ready = asyncio.gather(future_instance, future_attributes)
+    attributes_ready = gather(future_instance, future_attributes)
     attributes_ready.add_done_callback(
-        functools.partial(
+        partial(
             __async_inject_attributes_callback,
             future_result,
         ),
     )
-    asyncio.ensure_future(attributes_ready)
+    ensure_future(attributes_ready)
 
     return future_result
 
@@ -605,17 +605,17 @@ cdef inline object __call(
         future_args = args if is_future_args else __future_result(args)
         future_kwargs = kwargs if is_future_kwargs else __future_result(kwargs)
 
-        future_result = asyncio.Future()
+        future_result = Future()
 
-        args_kwargs_ready = asyncio.gather(future_args, future_kwargs)
+        args_kwargs_ready = gather(future_args, future_kwargs)
         args_kwargs_ready.add_done_callback(
-            functools.partial(
+            partial(
                 __async_call_callback,
                 future_result,
                 call,
             ),
         )
-        asyncio.ensure_future(args_kwargs_ready)
+        ensure_future(args_kwargs_ready)
 
         return future_result
 
@@ -630,8 +630,8 @@ cdef inline void __async_call_callback(object future_result, object call, object
         future_result.set_exception(exception)
     else:
         if __is_future_or_coroutine(result):
-            result = asyncio.ensure_future(result)
-            result.add_done_callback(functools.partial(__async_result_callback, future_result))
+            result = ensure_future(result)
+            result.add_done_callback(partial(__async_result_callback, future_result))
             return
         future_result.set_result(result)
 
@@ -712,7 +712,7 @@ cdef inline bint __iscoroutine(object obj):
 
 
 cdef inline object __future_result(object instance):
-    future_result = asyncio.Future()
+    future_result = Future()
     future_result.set_result(instance)
     return future_result