def test_classmethod(self):
class A:
@classmethod
def f(cls, x):
return x
fun = head_from_fun(A.f, bound=False)
assert fun(A, 1) == 1
fun = head_from_fun(A.f, bound=True)
assert fun(1) == 1
def test_classmethod(self):
class A(object):
@classmethod
def f(cls, x):
return x
fun = head_from_fun(A.f, bound=False)
assert fun(A, 1) == 1
fun = head_from_fun(A.f, bound=True)
assert fun(1) == 1
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(fun.__name__, (base,), dict({
'app': self,
'name': name,
'run': run,
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__annotations__': fun.__annotations__,
'__header__': staticmethod(head_from_fun(fun, bound=bind)),
'__wrapped__': run}, **options))()
# for some reason __qualname__ cannot be set in type()
# so we have to set it here.
try:
task.__qualname__ = fun.__qualname__
except AttributeError:
pass
self._tasks[task.name] = task
task.bind(self) # connects task to this app
add_autoretry_behaviour(task, **options)
else:
task = self._tasks[name]
return task
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(
fun.__name__, (base, ),
dict(
{
'app': self,
'name': name,
'run': run,
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__header__': staticmethod(
head_from_fun(fun, bound=bind)),
'__wrapped__': run
}, **options))()
self._tasks[task.name] = task
task.bind(self) # connects task to this app
else:
task = self._tasks[name]
return task
def test_from_fun(self):
def f(x, y, kwarg=1):
pass
g = head_from_fun(f)
with pytest.raises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(
fun.__name__, (base, ),
dict(
{
'app': self,
'name': name,
'run': run,
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__header__': staticmethod(
head_from_fun(fun, bound=bind)),
'__wrapped__': run
}, **options))()
# for some reason __qualname__ cannot be set in type()
# so we have to set it here.
try:
task.__qualname__ = fun.__qualname__
except AttributeError:
pass
self._tasks[task.name] = task
task.bind(self) # connects task to this app
autoretry_for = tuple(options.get('autoretry_for', ()))
retry_kwargs = options.get('retry_kwargs', {})
retry_backoff = int(options.get('retry_backoff', False))
retry_backoff_max = int(options.get('retry_backoff_max', 600))
retry_jitter = options.get('retry_jitter', True)
if autoretry_for and not hasattr(task, '_orig_run'):
@wraps(task.run)
def run(*args, **kwargs):
try:
return task._orig_run(*args, **kwargs)
except autoretry_for as exc:
if retry_backoff:
retry_kwargs['countdown'] = \
get_exponential_backoff_interval(
factor=retry_backoff,
retries=task.request.retries,
maximum=retry_backoff_max,
full_jitter=retry_jitter)
raise task.retry(exc=exc, **retry_kwargs)
task._orig_run, task.run = task.run, run
else:
task = self._tasks[name]
return task
def test_regression_3678(self):
local = {}
fun = ('def f(foo, *args, bar=""):' ' return foo, args, bar')
exec(fun, {}, local)
g = head_from_fun(local['f'])
g(1)
g(1, 2, 3, 4, bar=100)
with pytest.raises(TypeError):
g(bar=100)
def test_from_cls(self):
class X(object):
def __call__(x, y, kwarg=1):
pass
g = head_from_fun(X())
with self.assertRaises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def test_from_cls(self):
class X(object):
def __call__(x, y, kwarg=1):
pass
g = head_from_fun(X())
with self.assertRaises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def test_from_cls(self):
class X(object):
def __call__(x, y, kwarg=1): # noqa
pass
g = head_from_fun(X())
with pytest.raises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def test_regression_3678(self):
local = {}
fun = ('def f(foo, *args, bar="", **kwargs):'
' return foo, args, bar')
exec(fun, {}, local)
g = head_from_fun(local['f'])
g(1)
g(1, 2, 3, 4, bar=100)
with pytest.raises(TypeError):
g(bar=100)
def test_from_fun_with_hints(self):
local = {}
fun = ('def f_hints(x: int, y: int, kwarg: int=1):' ' pass')
exec(fun, {}, local)
f_hints = local['f_hints']
g = head_from_fun(f_hints)
with pytest.raises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def test_from_fun_with_hints(self):
local = {}
fun = ('def f_hints(x: int, y: int, kwarg: int=1):'
' pass')
exec(fun, {}, local)
f_hints = local['f_hints']
g = head_from_fun(f_hints)
with pytest.raises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(fun.__name__, (base,), dict({
'app': self,
'name': name,
'run': run,
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__header__': staticmethod(head_from_fun(fun, bound=bind)),
'__wrapped__': run}, **options))()
# for some reason __qualname__ cannot be set in type()
# so we have to set it here.
try:
task.__qualname__ = fun.__qualname__
except AttributeError:
pass
self._tasks[task.name] = task
task.bind(self) # connects task to this app
autoretry_for = tuple(options.get('autoretry_for', ()))
retry_kwargs = options.get('retry_kwargs', {})
retry_backoff = int(options.get('retry_backoff', False))
retry_backoff_max = int(options.get('retry_backoff_max', 600))
retry_jitter = options.get('retry_jitter', True)
if autoretry_for and not hasattr(task, '_orig_run'):
@wraps(task.run)
def run(*args, **kwargs):
try:
return task._orig_run(*args, **kwargs)
except autoretry_for as exc:
if retry_backoff:
retry_kwargs['countdown'] = \
get_exponential_backoff_interval(
factor=retry_backoff,
retries=task.request.retries,
maximum=retry_backoff_max,
full_jitter=retry_jitter)
raise task.retry(exc=exc, **retry_kwargs)
task._orig_run, task.run = task.run, run
else:
task = self._tasks[name]
return task
def test_from_fun_forced_kwargs(self):
local = {}
fun = ('def f_kwargs(*, a, b="b", c=None):' ' return')
exec(fun, {}, local)
f_kwargs = local['f_kwargs']
g = head_from_fun(f_kwargs)
with pytest.raises(TypeError):
g(1)
g(a=1)
g(a=1, b=2)
g(a=1, b=2, c=3)
def test_from_fun_forced_kwargs(self):
local = {}
fun = ('def f_kwargs(*, a, b="b", c=None):'
' return')
exec(fun, {}, local)
f_kwargs = local['f_kwargs']
g = head_from_fun(f_kwargs)
with pytest.raises(TypeError):
g(1)
g(a=1)
g(a=1, b=2)
g(a=1, b=2, c=3)
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError("Contract breach: app not finalized")
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(
fun.__name__,
(base,),
dict(
{
"app": self,
"name": name,
"run": run,
"_decorated": True,
"__doc__": fun.__doc__,
"__module__": fun.__module__,
"__header__": staticmethod(head_from_fun(fun, bound=bind)),
"__wrapped__": run,
},
**options
),
)()
# for some reason __qualname__ cannot be set in type()
# so we have to set it here.
try:
task.__qualname__ = fun.__qualname__
except AttributeError:
pass
self._tasks[task.name] = task
task.bind(self) # connects task to this app
autoretry_for = tuple(options.get("autoretry_for", ()))
retry_kwargs = options.get("retry_kwargs", {})
if autoretry_for and not hasattr(task, "_orig_run"):
@wraps(task.run)
def run(*args, **kwargs):
try:
return task._orig_run(*args, **kwargs)
except autoretry_for as exc:
raise task.retry(exc=exc, **retry_kwargs)
task._orig_run, task.run = task.run, run
else:
task = self._tasks[name]
return task
def test_from_fun_with_hints(self):
local = {}
fun = ('def f_hints(x: int, y: int, kwarg: int=1):' ' pass')
try:
exec(fun, {}, local)
except SyntaxError:
# py2
return
f_hints = local['f_hints']
g = head_from_fun(f_hints)
with self.assertRaises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def test_from_fun_with_hints(self):
local = {}
fun = ('def f_hints(x: int, y: int, kwarg: int=1):'
' pass')
try:
exec(fun, {}, local)
except SyntaxError:
# py2
return
f_hints = local['f_hints']
g = head_from_fun(f_hints)
with self.assertRaises(TypeError):
g(1)
g(1, 2)
g(1, 2, kwarg=3)
def wrap(cls, f: types.FunctionType, kwargs):
name = kwargs.pop("name")
bind = kwargs.get("bind", False)
task = type(
name, (cls, ), {
'name': name,
'run': f,
'_decorated': True,
'__doc__': f.__doc__,
'__module__': f.__module__,
'__annotations__': f.__annotations__,
'__header__': staticmethod(head_from_fun(f, bound=bind)),
'__wrapped__': f,
})
task.__qualname__ = f.__qualname__
return task()
def test_kwonly_required_args(self):
local = {}
fun = ('def f_kwargs_required(*, a="a", b, c=None):' ' return')
exec(fun, {}, local)
f_kwargs_required = local['f_kwargs_required']
g = head_from_fun(f_kwargs_required)
with pytest.raises(TypeError):
g(1)
with pytest.raises(TypeError):
g(a=1)
with pytest.raises(TypeError):
g(c=1)
with pytest.raises(TypeError):
g(a=2, c=1)
g(b=3)
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(
fun.__name__, (base, ),
dict(
{
'app': self,
'name': name,
'run': run,
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__header__': staticmethod(
head_from_fun(fun, bound=bind)),
'__wrapped__': run
}, **options))()
self._tasks[task.name] = task
task.bind(self) # connects task to this app
autoretry_for = tuple(options.get('autoretry_for', ()))
retry_kwargs = options.get('retry_kwargs', {})
if autoretry_for and not hasattr(task, '_orig_run'):
@wraps(task.run)
def run(*args, **kwargs):
try:
return task._orig_run(*args, **kwargs)
except autoretry_for as exc:
raise task.retry(exc=exc, **retry_kwargs)
task._orig_run, task.run = task.run, run
else:
task = self._tasks[name]
return task
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
task = type(fun.__name__, (base, ), dict({
'app': self,
'name': name,
'run': fun if bind else staticmethod(fun),
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__header__': staticmethod(head_from_fun(fun)),
'__wrapped__': fun}, **options))()
self._tasks[task.name] = task
task.bind(self) # connects task to this app
else:
task = self._tasks[name]
return task
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(fun.__name__, (base,), dict({
'app': self,
'name': name,
'run': run,
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__header__': staticmethod(head_from_fun(fun, bound=bind)),
'__wrapped__': run}, **options))()
self._tasks[task.name] = task
task.bind(self) # connects task to this app
autoretry_for = tuple(options.get('autoretry_for', ()))
retry_kwargs = options.get('retry_kwargs', {})
if autoretry_for and not hasattr(task, '_orig_run'):
@wraps(task.run)
def run(*args, **kwargs):
try:
return task._orig_run(*args, **kwargs)
except autoretry_for as exc:
raise task.retry(exc=exc, **retry_kwargs)
task._orig_run, task.run = task.run, run
else:
task = self._tasks[name]
return task
