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)