Inject

Warnings

• breaking `inject` v5.0 and later require Python 3.9+. If you are using an older Python version (e.g., 3.5-3.8), you must use `inject` v4.x. For Python 2.7-3.5, use `inject` v3.x.
  Fix: Upgrade your Python environment to 3.9+ or pin `inject` to an appropriate older major version (e.g., `pip install 'inject<5'` for Python 3.5-3.8).
• deprecated The `inject.param` decorator is deprecated. Use `inject.params` instead for injecting parameters into functions.
  Fix: Replace `@inject.param('dependency_name', DependencyType)` with `@inject.params(dependency_name=DependencyType)`.
• gotcha By default, `inject` attempts to implicitly instantiate a class if a binding is missing (`bind_in_runtime=True`). This can mask missing bindings and lead to hard-to-debug issues if the default constructor is called unintentionally. For stricter control, disable runtime binding.
  Fix: Call `inject.configure(config, bind_in_runtime=False)` to disable implicit runtime binding. This will cause `inject.instance()` or injection to raise an `InjectorException` immediately if a binding is not explicitly provided.
• gotcha `inject` creates objects as singletons by default. For advanced scope management (e.g., thread-local, request-local instances), you need to implement custom providers rather than relying on built-in scope management features found in some other DI frameworks.
  Fix: Define and bind custom provider functions (e.g., `binder.bind_to_provider(MyScopedDep, my_custom_scope_provider_func)`) for dependencies that require non-singleton lifetimes.

Install

• pip install inject Install latest version

Imports

• inject

  import inject

• autoparams

  from inject import autoparams

  While `import inject` and then `inject.autoparams` works, direct import is cleaner if only `autoparams` is needed.
• params

  from inject import params

  `inject.param` is deprecated; use `inject.params` for multiple or single parameter injection.
• instance

  from inject import instance

Quickstart

This quickstart demonstrates how to set up and use `inject` for dependency injection. It covers configuring bindings, requesting instances directly with `inject.instance()`, and automatically injecting parameters into functions using `@inject.autoparams` (with type hints) or explicitly with `@inject.params`.

import inject

# 1. Define services/dependencies
class Cache:
    def save(self, key, value):
        print(f"Saving to cache: {key} = {value}")

class DbInterface:
    def query(self, statement):
        print(f"Executing DB query: {statement}")
        return [f"result_for_{statement}"]

# 2. Configure bindings (once at application start)
def config(binder):
    binder.bind(Cache, Cache())
    binder.bind(DbInterface, DbInterface())

inject.configure(config)

# 3. Use dependency injection
# Method 1: Using inject.instance()
cache_instance = inject.instance(Cache)
cache_instance.save('app_init', 'initial_value')

# Method 2: Using @inject.autoparams (requires type hints)
@inject.autoparams
def process_data(data: str, cache: Cache, db: DbInterface):
    cache.save('processed', data)
    results = db.query(f"SELECT * FROM data WHERE value = '{data}'")
    print(f"Processed '{data}', results: {results}")

process_data('example_data')

# Method 3: Using @inject.params (explicitly name dependencies)
@inject.params(cache=Cache, db=DbInterface)
def report_status(message: str, cache=None, db=None):
    if cache: cache.save('status', message)
    if db: db.query(f"INSERT INTO logs VALUES ('{message}')")
    print(f"Status reported: {message}")

report_status('Application running successfully')