Clean Python Architecture: Decoupling Code with Dependency Injection

The Dependency Injection Pattern

Dependency Injection flips the script. Instead of a class "reaching out" to build what it needs, you "hand" the dependencies to the class. This typically happens in the __init__ method. By injecting a service that follows a specific Protocol, your class remains blissfully unaware of implementation details. It only cares that the object it receives has a send_email method.

Code Walkthrough: Before and After

The Coupled Approach

In the rigid version, an if-else block determines which service to instantiate. This grows uncontrollably as you add new providers like Mailgun.

class EmailSender:
    def send_email(self, service_type, to, subject, body):
        if service_type == "mailchimp":
            service = MailChimp(attachment=True)
        elif service_type == "sendgrid":
            service = SendGrid()
        service.send(to, subject, body)

The Injected Approach

By moving the service creation outside the class, we achieve a clean, single-purpose method.

class EmailSender:
    def __init__(self, service: EmailService):
        self.service = service

    def send_email(self, to, subject, body):
        self.service.send(to, subject, body)

Syntax and Best Practices

Use Protocol to define a contract for your services. This ensures type-safety without strict inheritance. When writing unit tests, this pattern is a lifesaver. You can inject a mock service that doesn't actually send emails, allowing you to test the EmailSender logic in isolation without dealing with Pytest monkeypatching or network calls. This leads to faster, more reliable test suites and modular code that survives architectural shifts.