Какие существуют способы внедрения зависимостей (Dependency Injection) в Python?

А, слушай, смотри, вот эта вся хуйня про внедрение зависимостей, Dependency Injection, она же DI. Это, блядь, такой паттерн, когда один объект, типа клиент, не сам себе создаёт другие объекты, которые ему нужны, а получает их готовенькими, как будто ему их подсунули. В Python это можно провернуть на раз-два, и способов — овердохуища.

1. Через конструктор (Constructor Injection) Самый, сука, популярный и правильный способ. Ты просто засовываешь всё, что нужно, прямо в __init__. Получается наглядно, понятно, и тесты писать — одно удовольствие, ёпта.

class Service:
    def do_something(self) -> str:
        return "Service is doing something."

class Client:
    def __init__(self, service: Service):
        self.service = service

    def execute(self) -> str:
        return f"Client executing: {self.service.do_something()}"

# Использование
my_service = Service()
my_client = Client(my_service)
print(my_client.execute())

2. Через сеттер (Setter Injection) Ну, это когда ты сначала создаёшь объект пустой, а потом через отдельный метод ему вдуваешь зависимость. Типа, «на, держи, пригодится». Подходит, если зависимость опциональная или появляется позже. Но, блядь, менее надёжно — можно забыть её установить и потом охуеть от ошибки.

class Service:
    def do_something(self) -> str:
        return "Service is doing something."

class Client:
    def __init__(self):
        self.service: Service = None # Типизация для ясности

    def set_service(self, service: Service):
        self.service = service

    def execute(self) -> str:
        if self.service:
            return f"Client executing: {self.service.do_something()}"
        return "Service not set."

# Использование
my_client = Client()
my_service = Service()
my_client.set_service(my_service)
print(my_client.execute())

3. Через метод (Method Injection) А это когда зависимость нужна только для одного конкретного действия. Зачем тащить её в конструктор или хранить в поле, если можно просто передать в метод и забыть? Локализация, блядь, полная.

class Service:
    def do_something(self) -> str:
        return "Service is doing something."

class Client:
    def execute_with_service(self, service: Service) -> str:
        return f"Client executing with method-injected service: {service.do_something()}"

# Использование
my_service = Service()
my_client = Client()
print(my_client.execute_with_service(my_service))

4. Через абстрактный класс/интерфейс (Interface/Abstract Class Injection) Python, конечно, не Java, но абстрактные классы из abc — это наше всё. Суть в том, что твой клиент зависит не от конкретной реализации, а от какой-то абстракции, от контракта. Это, блядь, даёт нереальную гибкость. Захотел — подсунул реальный сервис, захотел — мок для тестов, и всем похуй.

from abc import ABC, abstractmethod

class IService(ABC):
    @abstractmethod
    def do_something(self) -> str:
        pass

class RealService(IService):
    def do_something(self) -> str:
        return "Real service implementation."

class MockService(IService): # Для тестирования
    def do_something(self) -> str:
        return "Mock service implementation."

class Client:
    def __init__(self, service: IService): # Зависимость от абстракции
        self.service = service

    def execute(self) -> str:
        return f"Client executing: {self.service.do_something()}"

# Использование
real_service = RealService()
client_with_real = Client(real_service)
print(client_with_real.execute())

mock_service = MockService()
client_with_mock = Client(mock_service)
print(client_with_mock.execute())

5. С использованием DI-контейнеров (DI Containers) А вот это уже для больших, навороченных проектов, где зависимостей — как говна за баней. Вручную всё связывать — терпения ноль ебать. Поэтому берёшь контейнер, типа dependency-injector, настраиваешь ему, кто от кого зависит, а он уже сам, этот хитрожопый менеджер, всё создаёт и подсовывает куда надо. Красота, в рот меня чих-пых!

# Пример с использованием библиотеки dependency-injector
from dependency_injector import containers, providers

class Service:
    def do_something(self) -> str:
        return "Service from container."

class Client:
    def __init__(self, service: Service):
        self.service = service

    def execute(self) -> str:
        return f"Client executing: {self.service.do_something()}"

class Container(containers.DeclarativeContainer):
    # Конфигурация провайдеров
    service = providers.Singleton(Service) # Singleton - один экземпляр на все запросы
    client = providers.Factory(Client, service=service) # Factory - новый экземпляр при каждом запросе

# Использование
container = Container()
my_client = container.client() # Получаем экземпляр клиента с внедренным сервисом
print(my_client.execute())

В общем, выбирай, что тебе больше подходит. Для большинства случаев хватит и конструктора, не выёбывайся. Но если проект растёт, как грибы после дождя, то контейнер — твой лучший друг, чтобы не сойти с ума.