def test_handles_lazy(self): class A: def __init__(self, value=None): self.value = value def m(self): return self.value assert 'four' == firstmethod('m')( [A(), A(), A(), A('four'), A('five')]) assert 'four' == firstmethod('m')( [A(), A(), A(), lazy(lambda: A('four')), A('five')])
def test_firstmethod_promises(self): class A(object): def __init__(self, value=None): self.value = value def m(self): return self.value self.assertEqual("four", functional.firstmethod("m")([ A(), A(), A(), A("four"), A("five")])) self.assertEqual("four", functional.firstmethod("m")([ A(), A(), A(), promise(lambda: A("four")), A("five")]))
def test_firstmethod_handles_lazy(self): class A(object): def __init__(self, value=None): self.value = value def m(self): return self.value self.assertEqual('four', firstmethod('m')([ A(), A(), A(), A('four'), A('five')])) self.assertEqual('four', firstmethod('m')([ A(), A(), A(), lazy(lambda: A('four')), A('five')]))
def test_handles_lazy(self): class A(object): def __init__(self, value=None): self.value = value def m(self): return self.value assert 'four' == firstmethod('m')([ A(), A(), A(), A('four'), A('five')]) assert 'four' == firstmethod('m')([ A(), A(), A(), lazy(lambda: A('four')), A('five')])
def test_firstmethod_promises(self): class A(object): def __init__(self, value=None): self.value = value def m(self): return self.value self.assertEqual('four', functional.firstmethod('m')([ A(), A(), A(), A('four'), A('five')])) self.assertEqual('four', functional.firstmethod('m')([ A(), A(), A(), promise(lambda: A('four')), A('five')]))
def test_AttributeError(self): assert firstmethod('foo')([object()]) is None
def test_firstmethod_AttributeError(self): self.assertIsNone(firstmethod('foo')([object()]))
~~~~~~~~~~~~~~~~~~~~~~ Annotations is a nice term for moneky patching task classes in the configuration. This prepares and performs the annotations in the :setting:`task_annotations` setting. """ from __future__ import absolute_import, unicode_literals from celery.five import string_t from celery.utils.functional import firstmethod, mlazy from celery.utils.imports import instantiate _first_match = firstmethod('annotate') _first_match_any = firstmethod('annotate_any') __all__ = ['MapAnnotation', 'prepare', 'resolve_all'] class MapAnnotation(dict): def annotate_any(self): try: return dict(self['*']) except KeyError: pass def annotate(self, task): try: return dict(self[task.name])
celery.routes ~~~~~~~~~~~~~ Contains utilities for working with task routers, (:setting:`CELERY_ROUTES`). """ from __future__ import absolute_import from celery.exceptions import QueueNotFound from celery.five import string_t from celery.utils import lpmerge from celery.utils.functional import firstmethod, mpromise from celery.utils.imports import instantiate _first_route = firstmethod('route_for_task') class MapRoute(object): """Creates a router out of a :class:`dict`.""" def __init__(self, map): self.map = map def route_for_task(self, task, *args, **kwargs): route = self.map.get(task) if route: return dict(route) class Router(object): def __init__(self,
(:setting:`CELERY_ROUTES`). """ from __future__ import absolute_import from kombu import Queue from celery.exceptions import QueueNotFound from celery.five import string_t from celery.utils import lpmerge from celery.utils.functional import firstmethod, mlazy from celery.utils.imports import instantiate __all__ = ['MapRoute', 'Router', 'prepare'] _first_route = firstmethod('route_for_task') class MapRoute(object): """Creates a router out of a :class:`dict`.""" def __init__(self, map): self.map = map def route_for_task(self, task, *args, **kwargs): try: return dict(self.map[task]) except KeyError: pass
# -*- coding: utf-8 -*- """Task Annotations. Annotations is a nice term for monkey-patching task classes in the configuration. This prepares and performs the annotations in the :setting:`task_annotations` setting. """ from __future__ import absolute_import, unicode_literals from celery.five import string_t from celery.utils.functional import firstmethod, mlazy from celery.utils.imports import instantiate _first_match = firstmethod("annotate") _first_match_any = firstmethod("annotate_any") __all__ = ("MapAnnotation", "prepare", "resolve_all") class MapAnnotation(dict): """Annotation map: task_name => attributes.""" def annotate_any(self): try: return dict(self["*"]) except KeyError: pass def annotate(self, task): try:
~~~~~~~~~~~~~~~~~~~~~~ Annotations is a nice term for moneky patching task classes in the configuration. This prepares and performs the annotations in the :setting:`CELERY_ANNOTATIONS` setting. """ from __future__ import absolute_import from celery.five import string_t from celery.utils.functional import firstmethod, mlazy from celery.utils.imports import instantiate _first_match = firstmethod('annotate') _first_match_any = firstmethod('annotate_any') __all__ = ['MapAnnotation', 'prepare', 'resolve_all'] class MapAnnotation(dict): def annotate_any(self): try: return dict(self['*']) except KeyError: pass def annotate(self, task): try:
def test_firstmethod_AttributeError(self): self.assertIsNone(functional.firstmethod("foo")([object()]))
celery.routes ~~~~~~~~~~~~~ Contains utilities for working with task routers, (:setting:`CELERY_ROUTES`). """ from __future__ import absolute_import from celery.exceptions import QueueNotFound from celery.five import string_t from celery.utils import lpmerge from celery.utils.functional import firstmethod, mpromise from celery.utils.imports import instantiate _first_route = firstmethod("route_for_task") class MapRoute(object): """Creates a router out of a :class:`dict`.""" def __init__(self, map): self.map = map def route_for_task(self, task, *args, **kwargs): route = self.map.get(task) if route: return dict(route) class Router(object):
Contains utilities for working with task routes (:setting:`CELERY_ROUTES`). :copyright: (c) 2009 - 2012 by Ask Solem. :license: BSD, see LICENSE for more details. """ from __future__ import absolute_import from celery.exceptions import QueueNotFound from celery.utils import lpmerge from celery.utils.functional import firstmethod, mpromise from celery.utils.imports import instantiate _first_route = firstmethod("route_for_task") class MapRoute(object): """Creates a router out of a :class:`dict`.""" def __init__(self, map): self.map = map def route_for_task(self, task, *args, **kwargs): route = self.map.get(task) if route: return dict(route) class Router(object): def __init__(self,
~~~~~~~~~~~~~~~~~~~~~~ Annotations is a nice term for moneky patching task classes in the configuration. This prepares and performs the annotations in the :setting:`task_annotations` setting. """ from __future__ import absolute_import from celery.five import string_t from celery.utils.functional import firstmethod, mlazy from celery.utils.imports import instantiate _first_match = firstmethod("annotate") _first_match_any = firstmethod("annotate_any") __all__ = ["MapAnnotation", "prepare", "resolve_all"] class MapAnnotation(dict): def annotate_any(self): try: return dict(self["*"]) except KeyError: pass def annotate(self, task): try: return dict(self[task.name])