def get_binding(self, target: Target[InjectedT]) -> Optional[RegisteredBinding]:
if isinstance(target.type, str):
possible_target_types = list(set(
available_target.type
for available_target in self._bindings_by_target
if isinstance(available_target.type, type)
and available_target.type.__name__ == target.type
))
if len(possible_target_types) == 1:
target.type = possible_target_types[0]
elif possible_target_types:
raise NonInjectableTypeError(
f"Could not find binding for '{target.type}': multiple types with this name found")
frozen_target = FrozenTarget(target.type, target.named)
return self._bindings_by_target.get(frozen_target)
def create(self,
binding: RegisteredBinding[ProviderBinding[InjectedT]],
context: InjectionContext[InjectedT]) -> Provider[InjectedT]:
if isinstance(binding.raw_binding.bound_provider, Provider):
return binding.raw_binding.bound_provider
provider_target = Target(binding.raw_binding.bound_provider, binding.raw_binding.named)
provider_context = context.get_child_context(provider_target)
provider_provider = provider_context.get_provider()
unscoped_provider = FromProviderProvider(
provider_provider,
)
scope_context = context.get_child_context(Target(binding.raw_binding.scope))
try:
scope_provider = scope_context.get_provider()
except NoBindingFound:
raise NonInjectableTypeError(f"Could not create a provider for {binding}: they are no bindings for"
f"the scope {binding.raw_binding.scope}")
return scope_provider.get().get_scoped_provider(unscoped_provider)
def _get_parameter_provider(self,
parameter: Parameter,
current_class: Type,
context: InjectionContext[InjectedT]) -> Provider[InjectedT]:
default_value = parameter.default if parameter.default is not Parameter.empty else EMPTY
if parameter.annotation is not Parameter.empty:
if TypeChecker.is_named(parameter.annotation):
provider = self._get_provider([
Target(parameter.annotation.original_type, parameter.annotation.name, default_value)], context)
else:
provider = self._get_provider([
Target(parameter.annotation, parameter.name, default_value),
Target(parameter.annotation, None, default_value),
], context)
if provider:
return provider
if parameter.default is not Parameter.empty:
return FromInstanceProvider(parameter.default)
raise NonInjectableTypeError(f"Could not find a binding or a default value for {parameter.name}: "
f"{get_class_full_name(parameter.annotation)} required by {current_class}")
def create(self, binding: RegisteredBinding[SelfBinding[InjectedT]],
context: InjectionContext[InjectedT]) -> Provider[InjectedT]:
parameters = signature(binding.target.type.__init__).parameters
positional_providers: List[Provider] = []
args_provider: Optional[Provider[List]] = None
keyword_providers: Dict[str, Provider] = {}
# Ignore 'self'
for parameter in list(parameters.values())[1:]:
# Ignore '**kwargs'
if parameter.kind == Parameter.VAR_KEYWORD:
continue
if parameter.kind == Parameter.VAR_POSITIONAL:
# *args
args_provider = self._get_positional_parameter_provider(
parameter, binding.target.type, context)
continue
parameter_provider = self._get_parameter_provider(
parameter, binding.target.type, context)
if parameter.kind == Parameter.KEYWORD_ONLY:
# After *args
keyword_providers[parameter.name] = parameter_provider
else:
# Before *args
positional_providers.append(parameter_provider)
unscoped_provider = FromClassProvider(
binding.target.type,
positional_providers,
args_provider,
keyword_providers,
)
scope_context = context.get_child_context(
Target(binding.raw_binding.scope))
try:
scope_provider = scope_context.get_provider()
except NoBindingFound:
raise NonInjectableTypeError(
f"Could not create a provider for {binding!r}: they are no bindings for"
f" {binding.raw_binding.scope.__name__!r}")
return scope_provider.get().get_scoped_provider(unscoped_provider)
def create(self, binding: "RegisteredMultiBinding[InjectedT]",
context: InjectionContext[InjectedT]) -> Provider[InjectedT]:
item_providers = []
for sub_binding in binding.item_bindings:
new_context = context.get_child_context(
Target(sub_binding.target.type, sub_binding.target.named))
item_providers.append(
self._item_provider_factory.create(sub_binding,
new_context,
cache_provider=False))
unscoped_provider = ListProvider(item_providers)
scope_context = context.get_child_context(
Target(binding.raw_binding.scope))
try:
scope_provider = scope_context.get_provider()
except NoBindingFound:
raise NonInjectableTypeError(
f"Could not create a provider for {binding!r}: they are no bindings for"
f" {binding.raw_binding.scope.__name__!r}") from None
return scope_provider.get().get_scoped_provider(unscoped_provider)