def test_call_child(self): """Test returning of child config values.""" category = self.provider.category category_setting = self.provider.category.setting self.assertTrue(utils.is_provider(category)) self.assertTrue(utils.is_provider(category_setting)) self.assertEqual(category(), self.initial_data['category']) self.assertEqual(category_setting(), self.initial_data['category']['setting'])
def test_call_deferred_child_and_update_from(self): """Test returning of deferred child config values.""" self.provider = providers.Config() category = self.provider.category category_setting = self.provider.category.setting self.assertTrue(utils.is_provider(category)) self.assertTrue(utils.is_provider(category_setting)) self.provider.update_from(self.initial_data) self.assertEqual(category(), self.initial_data['category']) self.assertEqual(category_setting(), self.initial_data['category']['setting'])
def __new__(mcs, class_name, bases, attributes): """Declarative catalog class factory.""" cls_providers = tuple((name, provider) for name, provider in six.iteritems(attributes) if is_provider(provider)) inherited_providers = tuple((name, provider) for base in bases if is_catalog(base) for name, provider in six.iteritems( base.providers)) providers = cls_providers + inherited_providers cls = type.__new__(mcs, class_name, bases, attributes) if cls.provider_type: cls._catalog = type('DynamicCatalog', (DynamicCatalog,), dict(provider_type=cls.provider_type))() else: cls._catalog = DynamicCatalog() cls._catalog.name = '.'.join((cls.__module__, cls.__name__)) cls._catalog.bind_providers(dict(providers)) cls._cls_providers = dict(cls_providers) cls._inherited_providers = dict(inherited_providers) cls.Bundle = cls._catalog.Bundle return cls
def override(self, provider): """Override provider with another provider. :param provider: Overriding provider. :type provider: :py:class:`Provider` :raise: :py:exc:`dependency_injector.errors.Error` :return: Overriding provider. :rtype: :py:class:`Provider` """ if provider is self: raise Error('Provider {0} could not be overridden ' 'with itself'.format(self)) if not is_provider(provider): provider = Static(provider) if not self.is_overridden: self.overridden_by = (ensure_is_provider(provider),) else: self.overridden_by += (ensure_is_provider(provider),) # Disable __call__() / _provide() optimization if self.__class__.__OPTIMIZED_CALLS__: self.__call__ = self.provide = self._call_last_overriding return OverridingContext(self, provider)
def override(self, provider): """Override provider with another provider. :param provider: Overriding provider. :type provider: :py:class:`Provider` :raise: :py:exc:`dependency_injector.errors.Error` :return: Overriding provider. :rtype: :py:class:`Provider` """ if provider is self: raise Error('Provider {0} could not be overridden ' 'with itself'.format(self)) if not is_provider(provider): provider = Object(provider) self.overridden += (ensure_is_provider(provider), ) # Disable __call__() / _provide() optimization if self.__class__.__OPTIMIZED_CALLS__: self.__call__ = self.provide = self._call_last_overriding return OverridingContext(self, provider)
def test_with_class_with_getattr(self): """Test with class that has __getattr__() method implementation.""" class SomeClass(object): """Some test class with __getattr__() method implementation.""" def __getattr__(self, _): """Test implementation that just returns False.""" return False self.assertFalse(utils.is_provider(SomeClass()))
def __init__(self, injectable): """Initializer. :param injectable: Injectable value, could be provider or any other object. :type injectable: object | :py:class:`dependency_injector.providers.Provider` """ self.injectable = injectable self.call_injectable = (is_provider(injectable) and not is_delegated_provider(injectable)) super(Injection, self).__init__()
def __delattr__(cls, name): """Handle deleting of catalog attibute. Deleting of attributes works as usual, but if value of attribute is provider, this provider will be unbound from catalog. :param name: Attribute's name. :type name: str :rtype: None """ if is_provider(getattr(cls, name)): delattr(cls._catalog, name) return super(DeclarativeCatalogMetaClass, cls).__delattr__(name)
def __setattr__(self, name, value): """Set instance attribute. If value of attribute is provider, it will be added into providers dictionary. :param name: Attribute's name :type name: str :param value: Attribute's value :type value: object :rtype: None """ if utils.is_provider(value): _check_provider_type(self, value) self.providers[name] = value super(DynamicContainer, self).__setattr__(name, value)
def __setattr__(cls, name, value): """Handle setting of catalog attributes. Setting of attributes works as usual, but if value of attribute is provider, this provider will be bound to catalog. :param name: Attribute's name. :type name: str :param value: Attribute's value. :type value: :py:class:`dependency_injector.providers.Provider` | object :rtype: None """ if is_provider(value): cls.bind_provider(name, value, _set_as_attribute=False) return super(DeclarativeCatalogMetaClass, cls).__setattr__(name, value)
def __setattr__(self, name, value): """Handle setting of catalog attributes. Setting of attributes works as usual, but if value of attribute is provider, this provider will be bound to catalog. :param name: Attribute's name. :type name: str :param value: Attribute's value. :type value: :py:class:`dependency_injector.providers.Provider` | object :rtype: None """ if is_provider(value): return self.bind_provider(name, value) return super(DynamicCatalog, self).__setattr__(name, value)
def __setattr__(cls, name, value): """Set class attribute. If value of attribute is provider, it will be added into providers dictionary. :param name: Attribute's name :type name: str :param value: Attribute's value :type value: object :rtype: None """ if utils.is_provider(value): _check_provider_type(cls, value) cls.providers[name] = value cls.cls_providers[name] = value super(DeclarativeContainerMetaClass, cls).__setattr__(name, value)
def __new__(mcs, class_name, bases, attributes): """Declarative container class factory.""" cls_providers = tuple((name, provider) for name, provider in six.iteritems(attributes) if utils.is_provider(provider)) inherited_providers = tuple( (name, provider) for base in bases if utils.is_container(base) and base is not DynamicContainer for name, provider in six.iteritems(base.cls_providers)) attributes['cls_providers'] = dict(cls_providers) attributes['inherited_providers'] = dict(inherited_providers) attributes['providers'] = dict(cls_providers + inherited_providers) cls = type.__new__(mcs, class_name, bases, attributes) for provider in six.itervalues(cls.providers): _check_provider_type(cls, provider) return cls
def test_is_provider(self): """Test `is_provider` check.""" self.assertTrue(utils.is_provider(providers.Factory(Example)))
def test_is_provider(self): """Test `is_provider` check.""" self.assertTrue( utils.is_provider(providers.ThreadLocalSingleton(Example)))
def test_is_provider(self): """Test is_provider.""" self.assertTrue( utils.is_provider(providers.DelegatedThreadLocalSingleton(object)))
def test_is_provider(self): """Test is_provider.""" self.assertTrue(utils.is_provider(providers.DelegatedCallable(len)))
def test_with_object(self): """Test with object.""" self.assertFalse(utils.is_provider(object()))
def test_with_class(self): """Test with class.""" self.assertFalse(utils.is_provider(providers.Provider))
def _parse_keyword_injections(kwargs): return dict((name, arg if is_provider(arg) else Object(arg)) for name, arg in six.iteritems(kwargs))
def _parse_positional_injections(args): return tuple(arg if is_provider(arg) else Object(arg) for arg in args)
def test_with_instance(self): """Test with instance.""" self.assertTrue(utils.is_provider(providers.Provider()))
def test_is_provider(self): """Test `is_provider` check.""" self.assertTrue(utils.is_provider(self.provider))
def test_with_string(self): """Test with string.""" self.assertFalse(utils.is_provider('some_string'))
def test_is_provider(self): """Test is_provider.""" self.assertTrue(utils.is_provider( providers.DelegatedSingleton(object)))
def test_with_subclass_instance(self): """Test with subclass of provider instance.""" class SomeProvider(providers.Provider): """Some provider for test.""" self.assertTrue(utils.is_provider(SomeProvider()))
def test_is_provider(self): """Test `is_provider` check.""" self.assertTrue(utils.is_provider(providers.Class(object))) self.assertTrue(utils.is_provider(providers.Object(object()))) self.assertTrue(utils.is_provider(providers.Function(map))) self.assertTrue(utils.is_provider(providers.Value(123)))
def test_is_provider(self): """Test `is_provider` check.""" self.assertTrue(utils.is_provider(providers.Object(object())))
def test_is_provider(self): """Test `is_provider` check.""" self.assertTrue(utils.is_provider(providers.Singleton(Example)))
def test_is_provider(self): """Test is_provider.""" self.assertTrue(utils.is_provider(providers.DelegatedFactory(object)))