autowire package

Submodules

autowire.base module

autowire.base

Base definitions of autowire.

class autowire.base.BaseContext[source]

Bases: object

find_resource_impl(resource: autowire.base.BaseResource)[source]

Find resource implementation from this context and its parents.

get_implementation(resource: autowire.base.BaseResource)[source]

Get resource implementation from this context.

partial(*positionals, **keywords)[source]

New function with partial application of the given resources.

@context.partial(foo_resource, bar=bar_resource)
def func(foo, baz, *, bar=None):
    print(foo)
    print(bar)
    print(baz)

func('Bar')
# Output:
# Foo
# Bar
# Baz
provided_by(resource: autowire.base.BaseResource) → autowire.base.BaseContext[source]

Find context that provides resource.

resolve(resource: autowire.base.BaseResource)[source]

Resolve resource in this context.

resolve_all(resources)[source]

Resolve resources in this context.

class autowire.base.BaseResource(name: str, namespace: str) → None[source]

Bases: object

Decalarative contextual resource definition.

canonical_name

Canonical name of resource.

It’s <namespace>.<name>

default_implementation
is_valid_name(name: str) → bool[source]

Resource name validation.

autowire.builtins module

autowire.builtins

Builtin resources.

class autowire.builtins.ContextResource(name: str, namespace: str) → None[source]

Bases: autowire.base.BaseResource

default_implementation
class autowire.builtins.ThisResource(name: str, namespace: str) → None[source]

Bases: autowire.base.BaseResource

default_implementation
autowire.builtins.context = ContextResource('context', 'autowire.builtins')

Current context resource

autowire.builtins.this = ThisResource('this', 'autowire.builtins')

Get resource it self as resource

autowire.decorators module

autowire.decorators

Decorators for autowire.

autowire.decorators.autowired(*dependencies: autowire.base.BaseResource)[source]

Convert a plain function to resource implementation with dependencies. It changes interface of decorated function to implementation interface.

autowire.exc module

autowire.exc

Exception definitions.

exception autowire.exc.ResourceNotProvidedError[source]

Bases: RuntimeError

Error for not provided resource.

autowire.helpers module

autowire.helpers

Helpers.

autowire.helpers.autowired(fn, *dependencies: autowire.base.BaseResource)[source]

Convert plain contextmanager to resource implementation by autowiring dependencies.

foo = Resource('foo', __name__)
bar = Resource('bar', __name__)

@contextlib.contextmanager
def with_foo(bar):
    value = baz(bar)
    try:
        yield value
    finally:
        value.teardown()

impl = autowired(with_foo, bar)  # Convert to implementation.
foo.impl(impl)
autowire.helpers.globally_shared(impl)[source]

Convert implementation to globally shared resource implementation. Which “globally shared” means resource is shared in providing context.

Shared resource shares contexxt using reference counting. When you try to resolve shared resource that already resolve but not teared down, It brings previously resolved resouce.

The resource will be tied into resource’s providing context. It means that children’s context will not be able to be used in this resource.

res1 = Resource('res1', __name__)
res2 = Resource('res2', __name__)

@res2.impl
@globally_shared
@contextlib.contextmanager
def with_res1(context):
    with context.resolve(res2) as res1_factory:
        res1 = res1_factory.create_res1()
        try:
            yield res1
        finally:
            res1.teardown()

context = Context()

child = Context(context)

@child.autowired(res2)
def with_res2():
    yield ...

# Get ResourceNotProvidedError, even though child provides res2.
# Because res1 was shared in parent context.
with child.resolve(res1):
    ...
autowire.helpers.shared(impl)[source]

Convert implementation to shared resource implementation.

Shared resource shares contexxt using reference counting. When you try to resolve shared resource that already resolve but not teared down, It brings previously resolved resouce.

from contextlib import contextmanager

from autowire import Context, Resource
from autowire.decorators import shared

dog = Resource('dog', __name__)
walk = Resource('walk', __name__)

@dog.impl
@shared
@contextmanager
def with_dog(context):
    print("Dog is entering")
    try:
        yield "🐶"
    finally:
        print("Dog leaved")

@walk.impl
@contextmanager
def with_walking(context):
    with context.resolve(dog) as dog_value:
        yield "Walking with {}".format(dog_value)

context = Context()

with context.resolve(walk) as message:
    print(message)
    with context.resolve(dog) as dog_value:
        print("Feeding {}".format(dog_value))

# Output:
# Dog is entering
# Walking with 🐶
# Feeding 🐶
# Dog leaved

autowire.utils module

autowire.utils

Common utilities.

class autowire.utils.RefCounter(contextmanager)[source]

Bases: object

Preserve context until it has any references.

decrease(exc_type, exc_value, tb)[source]
increase()[source]
autowire.utils.apply_decorators(fn, decorators)[source]

Apply multiple decorators at once.

autowire.utils.as_contextmanager(fn)[source]

Convert to context manager.

@as_contextmanager
def foo(name):
    return 'Hello, {}'.format(name)

is equivalent to

@contextlib.contextmanager
def foo(name):
    yield 'Hello, {}'.format(name)

Module contents

class autowire.Context(parent: autowire.base.BaseContext = <autowire.context.root._RootContext object>)[source]

Bases: autowire.base.BaseContext, autowire.context.provider.ImplementationConsumer

Context implementation.

get_implementation(resource: autowire.base.BaseResource)[source]

Get resource implementation from this context.

provide(resource: autowire.base.BaseResource)[source]

Resource resource’s implementation provider which is Implementable

@autowired(context.provide(resource), dependency1, dependency2)
@contextlib.contextmanager
def create_resource(dependency1, dependency2):
    yield dependency1.make_resource(dependency2)

__call__ method is alias for this method

@autowired(context(resource), dependency1, dependency2)
@contextlib.contextmanager
def create_resource(dependency1, dependency2):
    yield dependency1.make_resource(dependency2)
provided_by(resource: autowire.base.BaseResource)[source]

Find context that provides resource.

set_implementation(resource: autowire.base.BaseResource, implementation: typing.Callable[[autowire.base.BaseContext], typing.Any])[source]
class autowire.Resource(name, namespace)[source]

Bases: autowire.base.BaseResource, autowire.impl.types.Implementable

Resource class of some functionalities like default implementation.

default_implementation
implement(implementation: typing.Callable[[autowire.base.BaseContext], typing.Any])[source]

Set implementation of implementable.

exception autowire.ResourceNotProvidedError[source]

Bases: RuntimeError

Error for not provided resource.