Example #1
0
def _pdnQASIDVq2V():
    Injector()
def _jbfjlQveNjrZ(arg):
    # Let notation.
    Injector.let(func=arg)
Example #3
0
def _zlZoLka31ndk():
    return Injector(foo=1)
Example #4
0
def _e34b88041f64():
    def eq(self, other):
        pass  # pragma: no cover

    Injector(__eq__=eq)
Example #5
0
def _uf0ibIiz0aIl(A, B, C, D):
    return Injector(a=A, b=B, c=C, d=D)
Example #6
0
def _f9c50c81e8c9():
    Foo = Injector(x=1)

    Foo.test
Example #7
0
def _pHfF0rbEjCsV():
    Container = Injector(x=1)
    Container.foo = 1
def c039a81e8dce(Foo, Bar):
    """Let notation chain."""

    Summator = Injector.let(foo=Foo).let(bar=Bar)

    Summator.foo
Example #9
0
def jbfjlQveNjrZ(arg):
    """Let notation."""

    Injector.let(func=arg)
Example #10
0
def nVlMKQghCDAQ(arg):
    """Let notation."""

    Injector.let(method=arg)
def e4b38a38de7e(Foo):
    """Let notation."""

    Summator = Injector.let(foo=Foo)

    Summator.foo
def d701f88a5c42(Foo, Bar, Baz):
    """Let notation chain."""

    Summator = Injector.let(foo=Foo).let(bar=Bar).let(baz=Baz)

    Summator.foo
def c729e6952fee(Foo, Bar, Baz):
    """Let notation."""

    Summator = Injector.let(foo=Foo, bar=Bar, baz=Baz)

    Summator.foo
Example #14
0
def _nVlMKQghCDAQ(arg):
    # Let notation.
    Injector.let(method=arg)
Example #15
0
def _jShuBfttg97c():
    Container = Injector(foo=1)
    del Container.foo
Example #16
0
def b54832f696e9(Foo, Bar):
    """Let notation."""

    Summator = Injector.let(foo=Foo, bar=Bar)

    Summator.foo
Example #17
0
def test_task_arguments(celery_app, code):
    """
    Allow task decorator arguments customization through `Injector`
    subclass attributes.
    """

    class Foo(object):

        def __call__(self, a, b):
            return a + b

    class Bar(object):

        def __init__(self, foo, task, args, kwargs):
            self.foo = foo
            self.task = task
            self.args = args
            self.kwargs = kwargs

        def do(self):
            one = self.args[0]
            two = self.kwargs["two"]
            assert isinstance(self.task, MyTask)
            return self.foo(one, two)

    class MyTask(Task):
        pass

    code(
        celery_app,
        Injector.let(
            foo=Foo,
            bar=Bar,
            base_class=MyTask,
            bind=True,
            typing=False,
            max_retries=1,
            default_retry_delay=1,
            rate_limit="100/h",
            ignore_result=True,
            trail=False,
            send_events=False,
            store_errors_even_if_ignored=True,
            serializer="yaml",
            time_limit=500,
            soft_time_limit=250,
            track_started=True,
            acks_late=True,
            reject_on_worker_lost=True,
            throws=(ValueError, AttributeError),
        ),
    )

    task_instance = celery_app.tasks["foo.bar.baz"]
    assert task_instance(1, two=2) == 3
    assert isinstance(task_instance, MyTask)
    assert task_instance.typing is False
    assert task_instance.max_retries == 1
    assert task_instance.default_retry_delay == 1
    assert task_instance.rate_limit == "100/h"
    assert task_instance.ignore_result is True
    assert task_instance.trail is False
    assert task_instance.send_events is False
    assert task_instance.store_errors_even_if_ignored is True
    assert task_instance.serializer == "yaml"
    assert task_instance.time_limit == 500
    assert task_instance.soft_time_limit == 250
    assert task_instance.track_started is True
    assert task_instance.acks_late is True
    assert task_instance.reject_on_worker_lost is True
    assert task_instance.throws == (ValueError, AttributeError)