Wiring by string id (#403)

* Add prototype implementation * Implement wiring by string id * Fix pydocstyle errors * Refactor wiring module * Fix flake8 errors * Update changelog * Fix flake8 errors * Add example and docs

Author: rmk135

docs/main/changelog.rst

@@ -9,6 +9,7 @@ follows `Semantic versioning`_
 
 Development version
 -------------------
+- Add wiring by string id.
 - Improve error message for ``Dependency`` provider missing attribute.
 
 4.25.1

docs/wiring.rst

@@ -88,6 +88,82 @@ Also you can use ``Provide`` marker to inject a container.
  :emphasize-lines: 16-19
  :lines: 3-
 
+Strings identifiers
+-------------------
+
+You can use wiring with string identifiers. String identifier should match provider name in the container:
+
+.. literalinclude:: ../examples/wiring/example_string_id.py
+ :language: python
+ :emphasize-lines: 17
+ :lines: 3-
+
+With string identifiers you don't need to use a container to specify an injection.
+
+To specify an injection from a nested container use point ``.`` as a separator:
+
+.. code-block:: python
+
+ @inject
+ def foo(service: UserService = Provide['services.user']) -> None:
+ ...
+
+You can also use injection modifiers:
+
+.. code-block:: python
+
+ from dependency_injector.wiring import (
+ inject,
+ Provide,
+ as_int,
+ as_float,
+ as_,
+ required,
+ invariant,
+ provided,
+ )
+
+
+ @inject
+ def foo(value: int = Provide['config.option', as_int()]) -> None:
+ ...
+
+
+ @inject
+ def foo(value: float = Provide['config.option', as_float()]) -> None:
+ ...
+
+
+ @inject
+ def foo(value: Decimal = Provide['config.option', as_(Decimal)]) -> None:
+ ...
+
+ @inject
+ def foo(value: str = Provide['config.option', required()]) -> None:
+ ...
+
+ @inject
+ def foo(value: int = Provide['config.option', required().as_int()]) -> None:
+ ...
+
+
+ @inject
+ def foo(value: int = Provide['config.option', invariant('config.switch')]) -> None:
+ ...
+
+ @inject
+ def foo(value: int = Provide['service', provided().foo['bar'].call()]) -> None:
+ ...
+
+
+To inject a container use special identifier ``<container>``:
+
+.. code-block:: python
+
+ @inject
+ def foo(container: Container = Provide['<container>']) -> None:
+ ...
+
 Wiring with modules and packages
 --------------------------------
 

examples/wiring/example_string_id.py

@@ -0,0 +1,27 @@
+"""Wiring string id example."""
+
+import sys
+
+from dependency_injector import containers, providers
+from dependency_injector.wiring import inject, Provide
+
+
+class Service:
+ ...
+
+
+class Container(containers.DeclarativeContainer):
+
+ service = providers.Factory(Service)
+
+
+@inject
+def main(service: Service = Provide['service']) -> None:
+ ...
+
+
+if __name__ == '__main__':
+ container = Container()
+ container.wire(modules=[sys.modules[__name__]])
+
+ main()

src/dependency_injector/wiring.py

@@ -50,6 +50,12 @@ class GenericMeta(type):
  'wire',
  'unwire',
  'inject',
+ 'as_int',
+ 'as_float',
+ 'as_',
+ 'required',
+ 'invariant',
+ 'provided',
  'Provide',
  'Provider',
  'Closing',
@@ -85,16 +91,23 @@ def get_from_module(self, module: ModuleType) -> Iterator[Callable[..., Any]]:
 
 class ProvidersMap:
 
+ CONTAINER_STRING_ID = '<container>'
+
  def __init__(self, container):
  self._container = container
  self._map = self._create_providers_map(
  current_container=container,
- original_container=container.declarative_parent,
+ original_container=(
+ container.declarative_parent
+ if container.declarative_parent
+ else container
+ ),
  )
 
  def resolve_provider(
  self,
- provider: providers.Provider,
+ provider: Union[providers.Provider, str],
+ modifier: Optional['Modifier'] = None,
  ) -> Optional[providers.Provider]:
  if isinstance(provider, providers.Delegate):
  return self._resolve_delegate(provider)
@@ -109,14 +122,29 @@ def resolve_provider(
  return self._resolve_config_option(provider)
  elif isinstance(provider, providers.TypedConfigurationOption):
  return self._resolve_config_option(provider.option, as_=provider.provides)
+ elif isinstance(provider, str):
+ return self._resolve_string_id(provider, modifier)
  else:
  return self._resolve_provider(provider)
 
- def _resolve_delegate(
+ def _resolve_string_id(
  self,
- original: providers.Delegate,
+ id: str,
+ modifier: Optional['Modifier'] = None,
  ) -> Optional[providers.Provider]:
- return self._resolve_provider(original.provides)
+ if id == self.CONTAINER_STRING_ID:
+ return self._container.__self__
+
+ provider = self._container
+ for segment in id.split('.'):
+ try:
+ provider = getattr(provider, segment)
+ except AttributeError:
+ return None
+
+ if modifier:
+ provider = modifier.modify(provider, providers_map=self)
+ return provider
 
  def _resolve_provided_instance(
  self,
@@ -151,6 +179,12 @@ def _resolve_provided_instance(
 
  return new
 
+ def _resolve_delegate(
+ self,
+ original: providers.Delegate,
+ ) -> Optional[providers.Provider]:
+ return self._resolve_provider(original.provides)
+
  def _resolve_config_option(
  self,
  original: providers.ConfigurationOption,
@@ -184,7 +218,7 @@ def _resolve_provider(
  try:
  return self._map[original]
  except KeyError:
- pass
+ return None
 
  @classmethod
  def _create_providers_map(
@@ -381,7 +415,7 @@ def _fetch_reference_injections(
 
 def _bind_injections(fn: Callable[..., Any], providers_map: ProvidersMap) -> None:
  for injection, marker in fn.__reference_injections__.items():
- provider = providers_map.resolve_provider(marker.provider)
+ provider = providers_map.resolve_provider(marker.provider, marker.modifier)
 
  if provider is None:
  continue
@@ -516,20 +550,161 @@ def _is_declarative_container(instance: Any) -> bool:
  and getattr(instance, 'declarative_parent', None) is None)
 
 
+class Modifier:
+
+ def modify(
+ self,
+ provider: providers.ConfigurationOption,
+ providers_map: ProvidersMap,
+ ) -> providers.Provider:
+ ...
+
+
+class TypeModifier(Modifier):
+
+ def __init__(self, type_: Type):
+ self.type_ = type_
+
+ def modify(
+ self,
+ provider: providers.ConfigurationOption,
+ providers_map: ProvidersMap,
+ ) -> providers.Provider:
+ return provider.as_(self.type_)
+
+
+def as_int() -> TypeModifier:
+ """Return int type modifier."""
+ return TypeModifier(int)
+
+
+def as_float() -> TypeModifier:
+ """Return float type modifier."""
+ return TypeModifier(float)
+
+
+def as_(type_: Type) -> TypeModifier:
+ """Return custom type modifier."""
+ return TypeModifier(type_)
+
+
+class RequiredModifier(Modifier):
+
+ def __init__(self):
+ self.type_modifier = None
+
+ def as_int(self) -> 'RequiredModifier':
+ self.type_modifier = TypeModifier(int)
+ return self
+
+ def as_float(self) -> 'RequiredModifier':
+ self.type_modifier = TypeModifier(float)
+ return self
+
+ def as_(self, type_: Type) -> 'RequiredModifier':
+ self.type_modifier = TypeModifier(type_)
+ return self
+
+ def modify(
+ self,
+ provider: providers.ConfigurationOption,
+ providers_map: ProvidersMap,
+ ) -> providers.Provider:
+ provider = provider.required()
+ if self.type_modifier:
+ provider = provider.as_(self.type_modifier.type_)
+ return provider
+
+
+def required() -> RequiredModifier:
+ """Return required modifier."""
+ return RequiredModifier()
+
+
+class InvariantModifier(Modifier):
+
+ def __init__(self, id: str) -> None:
+ self.id = id
+
+ def modify(
+ self,
+ provider: providers.ConfigurationOption,
+ providers_map: ProvidersMap,
+ ) -> providers.Provider:
+ invariant_segment = providers_map.resolve_provider(self.id)
+ return provider[invariant_segment]
+
+
+def invariant(id: str) -> InvariantModifier:
+ """Return invariant modifier."""
+ return InvariantModifier(id)
+
+
+class ProvidedInstance(Modifier):
+
+ TYPE_ATTRIBUTE = 'attr'
+ TYPE_ITEM = 'item'
+ TYPE_CALL = 'call'
+
+ def __init__(self):
+ self.segments = []
+
+ def __getattr__(self, item):
+ self.segments.append((self.TYPE_ATTRIBUTE, item))
+ return self
+
+ def __getitem__(self, item):
+ self.segments.append((self.TYPE_ITEM, item))
+ return self
+
+ def call(self):
+ self.segments.append((self.TYPE_CALL, None))
+ return self
+
+ def modify(
+ self,
+ provider: providers.ConfigurationOption,
+ providers_map: ProvidersMap,
+ ) -> providers.Provider:
+ provider = provider.provided
+ for type_, value in self.segments:
+ if type_ == ProvidedInstance.TYPE_ATTRIBUTE:
+ provider = getattr(provider, value)
+ elif type_ == ProvidedInstance.TYPE_ITEM:
+ provider = provider[value]
+ elif type_ == ProvidedInstance.TYPE_CALL:
+ provider = provider.call()
+ return provider
+
+
+def provided() -> ProvidedInstance:
+ """Return provided instance modifier."""
+ return ProvidedInstance()
+
+
 class ClassGetItemMeta(GenericMeta):
  def __getitem__(cls, item):
  # Spike for Python 3.6
+ if isinstance(item, tuple):
+ return cls(*item)
  return cls(item)
 
 
 class _Marker(Generic[T], metaclass=ClassGetItemMeta):
 
- def __init__(self, provider: Union[providers.Provider, Container]) -> None:
+ def __init__(
+ self,
+ provider: Union[providers.Provider, Container, str],
+ modifier: Optional[Modifier] = None,
+ ) -> None:
  if _is_declarative_container(provider):
  provider = provider.__self__
- self.provider: providers.Provider = provider
+ self.provider = provider
+ self.modifier = modifier
 
  def __class_getitem__(cls, item) -> T:
+ if isinstance(item, tuple):
+ return cls(*item)
  return cls(item)
 
  def __call__(self) -> T: