skip to navigation
skip to content

jeni 0.3.1

jeni injects annotated dependencies

Latest Version: 0.4.1

jeni lets developers build applications and not e.g. web applications.


  1. Configure each dependency in the project (requirements.txt, config, …).
  2. Write code with natural call signatures taking those dependencies as input.
  3. Implement a Provider for each dependency, register with an Injector.

jeni runs on Python 2.7, Python 3.2 through 3.4, and pypy.


Write code as its meant to be written, without pegging function call signatures to some monolithic object that only applies to a specific runtime. This is about more than just testing. This is about composition.

jeni’s design principle is to have all annotated callables usable in a context that knows nothing about jeni. Any callable is as relevant to a fresh Python REPL as it is to an injector.


Annotations are implemented as decorators for Python2. In Python 3, either decorators or function annotations can be used for injection.

Core API


Annotate a callable with a decorator to provide data for Injectors.

Intended use:

from jeni import annotate

@annotate('foo', 'bar')
def function(foo, bar):

An Injector would then need to register providers for ‘foo’ and ‘bar’ in order to apply this function; an injector with such providers can apply the annotated function without any further information:


To get a partially applied function, to call later:

fn = injector.partial(function)

Annotation does not alter the callable’s default behavior. Call it normally:

foo, bar = 'foo', 'bar'
function(foo, bar)

On Python 2, use decorators to annotate. On Python 3, use either decorators or function annotations:

from jeni import annotate

def function(foo: 'foo', bar: 'bar'):

Since function annotations could be interpreted differently by different packages, injectors do not use function.__annotations__ directly. Functions opt in by a simple @annotate decoration. Functions with Python annotations which have not been decorated are assumed to not be decorated for injection.

(For this reason, annotating a callable with a single note where the note is a callable is not supported.)

Notes which are provided to annotate (above ‘foo’ and ‘bar’) can be any hashable object (i.e. object able to be used as a key in a dict) and is not limited to strings. If tuples are used as notes, they must be of length 2, and (‘maybe’, …) and (‘partial’, …) are reserved.


Provide a single prepared dependency.

Provider.get(self, name=None)

Implement in subclass.

Annotations in the form of 'object:name' will pass the name value to the get method of the registered Provider (in this case, the provider registered with the Injector to provide object). This get-by-name pattern is useful for providers which have a dependency which supports lookups by key (e.g. HTTP headers or records in a key-value store).


By default, does nothing. Close objects as needed in subclass.


Collects dependencies and reads annotations to inject them.


An Injector could take arguments to init, but this base does not.

An Injector subclass inherits the provider registry of its base classes, but can override any provider by re-registering notes. When organizing a project, create an Injector subclass to serve as the object to register all providers. This allows for the project to have its own namespace of registered dependencies. This registry can be customized by further subclasses, either for injecting mocks in testing or providing alternative dependencies in a different runtime:

from jeni import Injector as BaseInjector

class Injector(BaseInjector):
    "Subclass provides namespace when registering providers."

Injector.provider(cls, note, provider=None, name=False)

Register a provider, either a Provider class or a generator.

Provider class:

from jeni import Injector as BaseInjector
from jeni import Provider

class Injector(BaseInjector):

class HelloProvider(Provider):
    def get(self, name=None):
        if name is None:
            name = 'world'
        return 'Hello, {}!'.format(name)

Simple generator:

def answer():
    yield 42

If a generator supports get with a name argument:

@Injector.provider('spam', name=True)
def spam():
    count_str = yield 'spam'
    while True:
        count_str = yield 'spam' * int(count_str)

Registration can be a decorator or a direct method call:

Injector.provider('hello', HelloProvider)

Injector.factory(cls, note, fn=None)

Register a function as a provider.

Function (name support is optional):

from jeni import Injector as BaseInjector
from jeni import Provider

class Injector(BaseInjector):

def echo(name=None):
    return name

Registration can be a decorator or a direct method call:

Injector.factory('echo', echo)

Injector.value(cls, note, scalar)

Register a single value to be provided.

Supports base notes only, does not support get-by-name notes.

Injector.apply(self, fn, *a, **kw)

Fully apply annotated callable, returning callable’s result.

Injector.partial(self, fn, *a, **kw)

Partially apply annotated callable, returning a partial function.

Injector.apply_regardless(self, fn, *a, **kw)

Like apply, but applies even if callable is not annotated.

Injector.partial_regardless(self, fn, *a, **kw)

Like partial, but applies even if callable is not annotated.

Injector.get(self, note)

Resolve a single note into an object.


Close injector & injected Provider instances, including generators.

Provider close methods should not intentionally raise errors. Specifically, if a dependency has transactions, the transaction should be committed or rolled back before close is called, and not left as an operation to be called during the close phase.

Providers are closed in the reverse order in which they were opened, and each provider is only closed once. Providers are only closed if they have successfully provided a dependency via get.


Enter context-manager without with-block. See also: exit.

Useful for before- and after-hooks which cannot use a with-block.


Exit context-manager without with-block. See also: enter.

Additional API


Wrap a keyword note to record that its resolution is optional.

Normally all annotations require fulfilled dependencies, but if a keyword argument is annotated as maybe, then an injector does not pass unset dependencies on apply:

from jeni import annotate

@annotate('foo', bar=annotate.maybe('bar'))
def foobar(foo, bar=None):


Wrap a note for injection of a partially applied function.

This allows for annotated functions to be injected for composition:

from jeni import annotate

@annotate('foo', bar=annotate.maybe('bar'))
def foobar(foo, bar=None):

@annotate('foo', annotate.partial(foobar))
def bazquux(foo, fn):
    # fn: injector.partial(foobar)


Forwards getattr & getitem to enclosed injector.

If an injector has ‘hello’ registered:

from jeni import InjectorProxy
deps = InjectorProxy(injector)

Get by name can use dict-style access:



Copyright 2013-2014 Ron DuPlain <> (see AUTHORS file).

Released under the BSD License (see LICENSE file).

File Type Py Version Uploaded on Size
jeni-0.3.1.tar.bz2 (md5) Source 2014-06-28 13KB (md5) Source 2014-06-28 23KB
  • Downloads (All Versions):
  • 61 downloads in the last day
  • 336 downloads in the last week
  • 1493 downloads in the last month