Skip to content

roo-oliv/injectable

Repository files navigation

Injectable: Dependency Injection for Humans™

Usage Examples 🚩 | Developer Reference 👩‍💻 | Authors 👫

license GitHub license
docs Documentation
tests Build Status Coverage Status Reliability Rating Security Rating Code Style Standards
package PyPI Package latest release PyPI Wheel Supported versions Supported implementations Supported Platforms Downloads per Month

Injectable is an elegant and simple Dependency Injection framework built with Heart and designed for Humans.

from typing import Annotated, List
from injectable import Autowired, autowired
from models import Database
from messaging import Broker

class Service:
    @autowired
    def __init__(
        self,
        database: Annotated[Database, Autowired],
        brokers: Annotated[List[Broker], Autowired],
    ):
        pending = database.get_pending_messages()
        for broker in brokers:
            broker.send_pending(pending)
from abc import ABC

class Broker(ABC):
    def send_pending(messages):
        ...
from injectable import injectable

@injectable
class Database:
    ...
from messaging import Broker
from injectable import injectable

@injectable
class KafkaProducer(Broker):
    ...
from messaging import Broker
from injectable import injectable

@injectable
class SQSProducer(Broker):
    ...

Features you'll love ❤️

  • Autowiring: injection is transparent to the function. Just decorate the function with @autowired and annotate parameters with Autowired, that's it. see an example
  • Automatic dependency discovery: just call load_injection_container() at the root of your project or pass the root path as an argument. All classes decorated with @injectable will be automatically discovered and ready for injection. see reference
  • Qualifier overloading: declare as many injectables as you like for a single qualifier or extending the same base class. You can inject all of them just by specifying a typing.List to Autowired: deps: Annotated[List["qualifier"], Autowired]. see an example
  • Transparent lazy initialization: passing the argument lazy=True for Autowired will make your dependency to be initialized only when actually used, all in a transparent fashion. see an example
  • Singletons: decorate your class with @injectable(singleton=True) and only a single instance will be initialized and shared for injection. see an example
  • Namespaces: specify different namespaces for injectables as in @injectable(namespace="foo") and then just use them when annotating your parameters as in dep: Annotated[..., Autowired(namespace="foo")]. see an example
  • Linters friendly: Autowired is carefully designed to comply with static linter analysis such as PyCharm's to preserve the parameter original type hint.

These are just a few cool and carefully built features for you. Check out our docs!