Dependency injection the Python way

# Возможные зависимости
class Db(object): pass
class Mailer(object): pass
# Внедряем зависимости в класс пользователя
class User(object):
    db = inject.attr(Db)
    mailer = inject.attr(Mailer)
    def __init__(self, name):
        self.name = name
    def register(self):
        self.db.save(self)
        self.mailer.send_welcome_email(self.name)
 # Используем в тестах inmemory базу данных и моки.
class TestUser(unittest.TestCase):
    def setUp(self):
        inject.clear_and_configure(lambda binder: binder \
            .bind(Db, InMemoryDb()) \
            .bind(Mailer, Mock()))
        self.mailer = inject.instance(Mailer)
    def test_register__should_send_welcome_email(self):
        # Пример теста.
        user = User('John Doe')
        # Регистрируем нового пользователя.
        user.register()
        # Должно отправиться письмо с приветствием.
        self.mailer.send_welcome_email.assert_called_with('John Doe')

Using

[sudo] pip install inject

# Импортируем единственный модуль.
import inject
# Описываем опциональную конфигурацию
def my_config(binder):
    binder.install(my_config2)  # Импортируем другую конфигурацию
    binder.bind(Db, RedisDb('localhost:1234'))
    binder.bind_to_provider(CurrentUser, get_current_user)
# Создаем инжектор.
inject.configure(my_config)
# Внедряем зависимости с помощью inject.instance и inject.attr
class User(object):
    db = inject.attr(Db)
    @classmethod
    def load(cls, id):
        return cls.db.load('user', id)
    def __init__(self, id):
        self.id = id
    def save(self):
        self.db.save('user', self)
def foo(bar):
    cache = inject.instance(Cache)
    cache.save('bar', bar)
# Создаем нового пользователя и сохраняем 
# во внедренную базу данных.
user = User(10)
user.save()

Types of Bindings

1. Instance bindings that always return the same object:
   

   redis = RedisCache(address='localhost:1234')
   def config(binder):
       binder.bind(Cache, redis)
   

   
   
2. Constructor bindings that create a singleton on first call:
   

   def config(binder):
       # Creates a redis cache singleton on first injection.
       binder.bind_to_constructor(Cache, lambda: RedisCache(address='localhost:1234'))
   

   
   
3. Provider bindings that are invoked each time dependencies are injected:
   

   def get_my_thread_local_cache():
       # Custom code here
       pass
   def config(binder):
       # Executes the provider on each injection.
       binder.bind_to_provider(Cache, get_my_thread_local_cache)
   

   
   
4. Runtime bindings that automatically create singletones of classes if there are no explicit bindings in the configuration for these classes. Runtime bindings greatly reduce configuration size. For example, in the code below, only the Config class has an explicit configuration:
   

   class Config(object): pass
   class Cache(object):
       config = inject.attr(Config)
   class Db(object):
       config = inject.attr(Config)
   class User(object):
       cache = inject.attr(Cache)
       db = inject.attr(Db)
       @classmethod
       def load(cls, user_id):
           return cls.cache.load('users', user_id) or cls.db.load('users', user_id)
   inject.configure(lambda binder: binder.bind(Config, load_config_file()))
   user = User.load(10)
   

   
   

Why are there no scopes (scopes?)

Conclusion