autowire package

Subpackages

• autowire.context package
  • Submodules
  • autowire.context.provider module
    • context.provider
  • autowire.context.root module
    • autowire.context.root
  • Module contents
    • autowire.context.impl
• autowire.impl package
  • Submodules
  • autowire.impl.function module
    • impl.function
  • autowire.impl.implementable module
    • impl.implementable
  • Module contents
    • impl
• autowire.resource package
  • Submodules
  • autowire.resource.function module
    • autowire.resource.function
  • autowire.resource.plain module
    • autowire.resource.plain
  • autowire.resource.utils module
    • autowire.resource.utils
  • Module contents
    • autowire.resource

Submodules

autowire.base module

autowire.base

Base definitions of autowire.

class autowire.base.BaseContext

Bases: object

find_resource_impl(resource: autowire.base.BaseResource) → autowire.base.Implementation

Find resource implementation from this context and its parents.

get_implementation(resource: autowire.base.BaseResource)

Get resource implementation from this context.

partial(*positionals, **keywords)

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

Find context that provides resource.

resolve(resource: autowire.base.BaseResource)

Resolve resource in this context.

resolve_all(resources)

Resolve resources in this context.

run(resource: autowire.base.BaseResource)

Resolve a resource just for side-effect.

It is useful when you want entry-point resource.

@resource.create
@impl.autowire('foo', foo)
@impl.autowire('bar', bar)
@impl.plain
def main(foo, bar):
    print(foo)
    print(bar)
    ...

...

if __name__ == '__main__':
    context.run(main)

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

Bases: object

Decalarative contextual resource definition.

canonical_name

Canonical name of resource.

It’s <namespace>.<name>

default_implementation

is_valid_name(name: str) → bool

Resource name validation.

class autowire.base.Implementation

Bases: object

Base implementation type

reify(resource: autowire.base.BaseResource, context: autowire.base.BaseContext)

autowire.builtins module

autowire.builtins

Builtin resources.

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

Bases: autowire.base.BaseResource

default_implementation

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

Current context resource

autowire.decorators module

autowire.decorators

Decorators for autowire.

autowire.decorators.shared(impl: autowire.impl.function.FunctionImplementation = None, *, globally=False)

Convert implementation to shared resource implementation.

Shared resource shares context 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.implement
@shared
@impl.implementation
@contextmanager
def with_dog(resource, context):
    print("Dog is entering")
    try:
        yield "🐶"
    finally:
        print("Dog leaved")

@walk.implement
@impl.implementation
@contextmanager
def with_walking(resource, 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

When set globally to True the resource will be shared globally. “Globally shared” means resource is shared in providing context.

Globally shared 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.implement
@shared(globally=True)
@impl.implementation
@contextlib.contextmanager
def with_res1(resource, context):
    with context.resolve(res2) as res1_factory:
        res1 = res1_factory()
        try:
            yield res1
        finally:
            res1.teardown()

context = Context()

child = Context(context)

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

# Get ResourceNotProvidedError, even though child context provides
# res2. Because res1 was shared globally in parent context.
with child.resolve(res1):
    ...

autowire.exc module

autowire.exc

Exception definitions.

exception autowire.exc.ResourceNotProvidedError

Bases: RuntimeError

Error for not provided resource.

autowire.helpers module

autowire.helpers

Helpers.

class autowire.helpers.GloballySharedImplementation(impl: autowire.base.Implementation)

Bases: autowire.base.Implementation

Share implementation in providing context.

See shared() for more details.

reify(resource: autowire.base.BaseResource, context: autowire.base.BaseContext)

class autowire.helpers.SharedImplementation(impl: autowire.base.Implementation)

Bases: autowire.base.Implementation

Share implementation in each contexts.

See shared() for more details.

reify(resource: autowire.base.BaseResource, context: autowire.base.BaseContext)

autowire.utils module

autowire.utils

Common utilities.

class autowire.utils.RefCounter(contextmanager)

Bases: object

Preserve context until it has any references.

decrease(exc_type, exc_value, tb)

increase()

autowire.utils.as_contextmanager(fn)

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>)

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

Context implementation.

get_implementation(resource: autowire.base.BaseResource)

Get resource implementation from this context.

provide(resource: autowire.base.BaseResource, implementation: autowire.base.Implementation = None)

Provide an implementaion for resource in this context.

context.provide(resource, implementation)

Or as a decorator

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

provided_by(resource: autowire.base.BaseResource)

Find context that provides resource.

set_implementation(resource: autowire.base.BaseResource, implementation: autowire.base.Implementation)

exception autowire.ResourceNotProvidedError

Bases: RuntimeError

Error for not provided resource.

class autowire.Resource(name, namespace)

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

Resource class of some functionalities like default implementation.

default_implementation

implement(implementation: autowire.base.Implementation)

Set implementation of implementable.