signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
@property<EOL><INDENT>def head_values(self):<DEDENT>
|
values = set()<EOL>for head in self._heads:<EOL><INDENT>values.add(head.value)<EOL><DEDENT>return values<EOL>
|
Return set of the head values
|
f299:c1:m2
|
@property<EOL><INDENT>def head_count(self):<DEDENT>
|
return len(self._heads)<EOL>
|
Get head count
|
f299:c1:m3
|
def add_head(self, head):
|
if not isinstance(head, DependencyNode):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._heads.append(head)<EOL>
|
Add head Node
|
f299:c1:m5
|
def fail(self):
|
raise ValidationError(self.message)<EOL>
|
Raise a validation error with the messsage.
|
f300:c1:m1
|
def validate(self, unused_value, unused_handler):
|
raise NotImplementedError<EOL>
|
Override this to implement validation logic.
Return the validated value or call self.fail() to raise a
ValidationError.
|
f300:c1:m2
|
def _fetch_arguments(handler, method):
|
if method.__name__ == '<STR_LIT>':<EOL><INDENT>arguments = {}<EOL>for key, value in six.iteritems(handler.request.arguments):<EOL><INDENT>if isinstance(value, list):<EOL><INDENT>arguments[key] = '<STR_LIT:U+002C>'.join(value)<EOL><DEDENT>else:<EOL><INDENT>arguments[key] = value<EOL><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>arguments = handler.get_post_arguments()<EOL><DEDENT>return arguments<EOL>
|
Get the arguments depending on the type of HTTP method.
|
f301:m0
|
def _apply_validator_chain(chain, value, handler):
|
if hasattr(chain, '<STR_LIT>'): <EOL><INDENT>chain = [chain, ]<EOL><DEDENT>for validator in chain:<EOL><INDENT>if hasattr(validator, '<STR_LIT>'):<EOL><INDENT>value = validator.validate(value, handler)<EOL><DEDENT>else:<EOL><INDENT>raise web.HTTPError(<NUM_LIT>)<EOL><DEDENT><DEDENT>return value<EOL>
|
Apply validators in sequence to a value.
|
f301:m1
|
def _parse_arguments(self, method, parameters):
|
<EOL>arguments = _fetch_arguments(self, method)<EOL>arg_dict = {}<EOL>errors = []<EOL>for key, properties in parameters:<EOL><INDENT>if key in arguments:<EOL><INDENT>value = arguments[key]<EOL>try:<EOL><INDENT>arg_dict[key] = _apply_validator_chain(<EOL>properties.get('<STR_LIT>', []), value, self)<EOL><DEDENT>except validators.ValidationError as err:<EOL><INDENT>errors.append(err)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if properties.get('<STR_LIT>', False):<EOL><INDENT>raise web.HTTPError(<EOL><NUM_LIT>,<EOL>('<STR_LIT>'<EOL>% (key, ))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>if properties.get('<STR_LIT:default>', None) is not None:<EOL><INDENT>arg_dict[key] = properties['<STR_LIT:default>']<EOL><DEDENT>else:<EOL><INDENT>arg_dict[key] = None<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if errors:<EOL><INDENT>raise web.HTTPError(<NUM_LIT>, '<STR_LIT>' % len(errors))<EOL><DEDENT>return arg_dict<EOL>
|
Parse arguments to method, returning a dictionary.
|
f301:m2
|
def parse(parameters):
|
<EOL>@decorators.include_original<EOL>def decorate(method):<EOL><INDENT>"""<STR_LIT>"""<EOL>def call(self, *args):<EOL><INDENT>"""<STR_LIT>"""<EOL>kwargs = _parse_arguments(self, method, parameters)<EOL>return method(self, *args, **kwargs)<EOL><DEDENT>return call<EOL><DEDENT>return decorate<EOL>
|
Decorator to parse parameters according to a set of criteria.
This outer method is called to set up the decorator.
Arguments:
parameters: An array of parameter declarations tuples in the format:
('<param_name>', {'validate': [<ValidatorClass>,...], <options...>})
Usage:
@chassis.util.parameters.parse([
('email', {'validators': [validators.Email], 'required': True}),
('password', {'validators': [validators.Password], 'required': True})
])
def post(self, email=None, password=None):
# Render JSON for the provided parameters
self.render_json({'email': email, 'password': password})
|
f301:m3
|
def parse_dict(parameters):
|
<EOL>@decorators.include_original<EOL>def decorate(method):<EOL><INDENT>"""<STR_LIT>"""<EOL>def call(self, *args):<EOL><INDENT>"""<STR_LIT>"""<EOL>arg_dict = _parse_arguments(self, method, parameters)<EOL>return method(self, *args, data=arg_dict)<EOL><DEDENT>return call<EOL><DEDENT>return decorate<EOL>
|
Decorator to parse parameters as a dict according to a set of criteria.
This outer method is called to set up the decorator.
Arguments:
parameters: An array of parameter declarations tuples in the format:
('<param_name>', {'validate': [<ValidatorClass>,...], <options...>})
Usage:
@chassis.util.parameters.parse_dict([
('email', {'validators': [validators.Email], 'required': True}),
('password', {'validators': [validators.Password], 'required': True})
])
def post(self, data):
# Render JSON for the provided parameters
self.render_json({'email': data['email'],
'password': data['password']})
|
f301:m4
|
def default(self, obj):
|
if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.strftime("<STR_LIT>")<EOL><DEDENT>elif hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.get_public_dict()<EOL><DEDENT>else:<EOL><INDENT>return json.JSONEncoder.default(self, obj)<EOL><DEDENT>
|
Use the default behavior unless the object to be encoded has a
`strftime` attribute.
|
f302:c0:m0
|
def include_original(dec):
|
def meta_decorator(method):<EOL><INDENT>"""<STR_LIT>"""<EOL>decorator = dec(method)<EOL>decorator._original = method<EOL>return decorator<EOL><DEDENT>return meta_decorator<EOL>
|
Decorate decorators so they include a copy of the original function.
|
f303:m0
|
def retrieve_object(cache, template, indexes):
|
keys = []<EOL>with cache as redis_connection:<EOL><INDENT>pipe = redis_connection.pipeline()<EOL>for (result_key, redis_key_template) in template.items():<EOL><INDENT>keys.append(result_key)<EOL>pipe.get(redis_key_template % indexes)<EOL><DEDENT>results = pipe.execute()<EOL><DEDENT>return None if None in results else dict(zip(keys, results))<EOL>
|
Retrieve an object from Redis using a pipeline.
Arguments:
template: a dictionary containg the keys for the object and
template strings for the corresponding redis keys. The template
string uses named string interpolation format. Example:
{
'username': 'user:$(id)s:username',
'email': 'user:$(id)s:email',
'phone': 'user:$(id)s:phone'
}
indexes: a dictionary containing the values to use to cosntruct the
redis keys: Example:
{
'id': 342
}
Returns: a dictionary with the same keys as template, but containing
the values retrieved from redis, if all the values are retrieved.
If any value is missing, returns None. Example:
{
'username': 'bob',
'email': 'bob@example.com',
'phone': '555-555-5555'
}
|
f305:m0
|
def set_object(cache, template, indexes, data):
|
<EOL>with cache as redis_connection:<EOL><INDENT>pipe = redis_connection.pipeline()<EOL>for key in set(template.keys()) & set(data.keys()):<EOL><INDENT>pipe.set(template[key] % indexes, str(data[key]))<EOL><DEDENT>pipe.execute()<EOL><DEDENT>
|
Set an object in Redis using a pipeline.
Only sets the fields that are present in both the template and the data.
Arguments:
template: a dictionary containg the keys for the object and
template strings for the corresponding redis keys. The template
string uses named string interpolation format. Example:
{
'username': 'user:%(id)s:username',
'email': 'user:%(id)s:email',
'phone': 'user:%(id)s:phone'
}
indexes: a dictionary containing the values to use to cosntruct the
redis keys: Example:
{
'id': 342
}
data: a dictionary returning the data to store. Example:
{
'username': 'bob',
'email': 'bob@example.com',
'phone': '555-555-5555'
}
|
f305:m1
|
def delete_object(cache, template, indexes):
|
with cache as redis_connection:<EOL><INDENT>pipe = redis_connection.pipeline()<EOL>for key in set(template.keys()):<EOL><INDENT>pipe.delete(template[key] % indexes)<EOL><DEDENT>pipe.execute()<EOL><DEDENT>
|
Delete an object in Redis using a pipeline.
Deletes all fields defined by the template.
Arguments:
template: a dictionary containg the keys for the object and
template strings for the corresponding redis keys. The template
string uses named string interpolation format. Example:
{
'username': 'user:%(id)s:username',
'email': 'user:%(id)s:email',
'phone': 'user:%(id)s:phone'
}
indexes: a dictionary containing the values to use to construct the
redis keys: Example:
{
'id': 342
}
|
f305:m2
|
def multi_get(cache, local_list):
|
with cache as redis_connection:<EOL><INDENT>return redis_connection.mget(local_list)<EOL><DEDENT>
|
Get multiple records by a list of keys.
Arguments:
cache:
instance of Cache
local_list:
[
'user:342:username',
'user:342:email',
'user:342:phone'
]
|
f305:m3
|
def set_value(cache, key, value):
|
with cache as redis_connection:<EOL><INDENT>return redis_connection.set(key, value)<EOL><DEDENT>
|
Set a value by key.
Arguments:
cache:
instance of Cache
key:
'user:342:username',
|
f305:m4
|
def delete_value(cache, *key):
|
with cache as redis_connection:<EOL><INDENT>return redis_connection.delete(*key)<EOL><DEDENT>
|
Delete a value by key.
Arguments:
cache:
instance of Cache
key:
'user:342:username',
|
f305:m5
|
def get_value(cache, key):
|
with cache as redis_connection:<EOL><INDENT>return redis_connection.get(key)<EOL><DEDENT>
|
Get a value by key.
Arguments:
cache:
instance of Cache
key:
'user:342:username',
|
f305:m6
|
def _close_connection(self):
|
pass<EOL>
|
Finish up.
No need to close the connection:
http://stackoverflow.com/questions/12967107/managing-connection-to-redis-from-python
|
f305:c1:m2
|
def insert(self, query, params):
|
<EOL>return<EOL>
|
Nothing to implement
|
f305:c1:m3
|
def detect_circle(nodes):
|
<EOL>if not isinstance(nodes, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>dependencies = set(nodes.keys())<EOL>traveled = []<EOL>heads = _detect_circle(nodes, dependencies, traveled)<EOL>return DependencyTree(heads)<EOL>
|
Wrapper for recursive _detect_circle function
|
f306:m0
|
def _detect_circle(nodes=None, dependencies=None, traveled=None, path=None):
|
<EOL>if nodes is None:<EOL><INDENT>nodes = {}<EOL><DEDENT>elif not isinstance(nodes, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if dependencies is None:<EOL><INDENT>return<EOL><DEDENT>elif not isinstance(dependencies, set):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if traveled is None:<EOL><INDENT>traveled = []<EOL><DEDENT>elif not isinstance(traveled, list):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if path is None:<EOL><INDENT>path = []<EOL><DEDENT>if not dependencies:<EOL><INDENT>return []<EOL><DEDENT>children = []<EOL>for name in dependencies:<EOL><INDENT>new_path = list(path)<EOL>new_path.append(name)<EOL>if name in traveled:<EOL><INDENT>raise CircularDependencyException(new_path)<EOL><DEDENT>node_children = _detect_circle(nodes=nodes,<EOL>dependencies=nodes[name],<EOL>traveled=traveled + list(name),<EOL>path=new_path)<EOL>node = DependencyNode(name)<EOL>for child in node_children:<EOL><INDENT>child.parent = node<EOL>node.add_child(child)<EOL><DEDENT>children.append(node)<EOL><DEDENT>return children<EOL>
|
Recursively iterate over nodes checking
if we've traveled to that node before.
|
f306:m1
|
def solve(nodes):
|
<EOL>if not isinstance(nodes, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return detect_circle(nodes)<EOL>
|
Solve graph into Solution
|
f306:m2
|
def is_dependency_name(name):
|
if not isinstance(name, str):<EOL><INDENT>return False<EOL><DEDENT>return name[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:@>'<EOL>
|
Returns true if of the form "@some_string
|
f306:m3
|
def __init__(self, config, scalars=None):
|
if scalars is None:<EOL><INDENT>scalars = {}<EOL><DEDENT>self._nodes = {}<EOL>self._config = config<EOL>self._factory = ServiceFactory(scalars)<EOL>self._init_nodes(config)<EOL>
|
Initialize Resolver
|
f306:c1:m0
|
@property<EOL><INDENT>def nodes(self):<DEDENT>
|
return self._nodes<EOL>
|
Return nodes
|
f306:c1:m1
|
def do(self):
|
if not self._nodes:<EOL><INDENT>return<EOL><DEDENT>node_copy = dict(self._nodes)<EOL>self._do(node_copy)<EOL>return self._factory.get_instantiated_services()<EOL>
|
Instantiate Services
|
f306:c1:m2
|
def _do(self, nodes):
|
if not isinstance(nodes, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not nodes:<EOL><INDENT>return<EOL><DEDENT>starting_num_nodes = len(nodes)<EOL>newly_instantiated = set()<EOL>for (name, dependency_set) in six.iteritems(nodes):<EOL><INDENT>if dependency_set:<EOL><INDENT>continue<EOL><DEDENT>config = self._config[name]<EOL>service = self._factory.create_from_dict(config)<EOL>self._factory.add_instantiated_service(name, service)<EOL>newly_instantiated.add(name)<EOL><DEDENT>if not newly_instantiated:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>for name in newly_instantiated:<EOL><INDENT>del nodes[name]<EOL><DEDENT>if starting_num_nodes == len(nodes):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>for (name, dependency_set) in six.iteritems(nodes):<EOL><INDENT>nodes[name] = dependency_set.difference(newly_instantiated)<EOL><DEDENT>self._do(nodes)<EOL>
|
Recursive method to instantiate services
|
f306:c1:m3
|
def _init_nodes(self, config):
|
if not isinstance(config, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for (name, conf) in six.iteritems(config):<EOL><INDENT>args = [] if '<STR_LIT:args>' not in conf else conf['<STR_LIT:args>']<EOL>kwargs = {} if '<STR_LIT>' not in conf else conf['<STR_LIT>']<EOL>dependencies = set()<EOL>arg_deps = self._get_dependencies_from_args(args)<EOL>kwarg_deps = self._get_dependencies_from_kwargs(kwargs)<EOL>dependencies.update(arg_deps)<EOL>dependencies.update(kwarg_deps)<EOL>self._nodes[name] = dependencies<EOL><DEDENT>
|
Gathers dependency sets onto _nodes
|
f306:c1:m4
|
def _get_dependencies_from_args(self, args):
|
if not isinstance(args, list):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>dependency_names = set()<EOL>for arg in args:<EOL><INDENT>new_names = self._check_arg(arg)<EOL>dependency_names.update(new_names)<EOL><DEDENT>return dependency_names<EOL>
|
Parse arguments
|
f306:c1:m5
|
def _get_dependencies_from_kwargs(self, args):
|
if not isinstance(args, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>dependency_names = set()<EOL>for arg in args.values():<EOL><INDENT>new_names = self._check_arg(arg)<EOL>dependency_names.update(new_names)<EOL><DEDENT>return dependency_names<EOL>
|
Parse keyed arguments
|
f306:c1:m6
|
def _check_arg(self, arg):
|
if isinstance(arg, list):<EOL><INDENT>return self._get_dependencies_from_args(arg)<EOL><DEDENT>elif isinstance(arg, dict):<EOL><INDENT>return self._get_dependencies_from_kwargs(arg)<EOL><DEDENT>if not is_dependency_name(arg):<EOL><INDENT>return set()<EOL><DEDENT>return set([arg[<NUM_LIT:1>:]])<EOL>
|
Check individual argument (list/tuple/string/etc)
|
f306:c1:m7
|
def is_arg_scalar(arg):
|
return arg[:<NUM_LIT:1>] == '<STR_LIT:$>'<EOL>
|
Returns true if arg starts with a dollar sign
|
f307:m0
|
def is_arg_service(arg):
|
return arg[:<NUM_LIT:1>] == '<STR_LIT:@>'<EOL>
|
Returns true if arg starts with an at symbol
|
f307:m1
|
def _check_type(name, obj, expected_type):
|
if not isinstance(obj, expected_type):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>' % (name, expected_type.__name__)<EOL>)<EOL><DEDENT>
|
Raise a TypeError if object is not of expected type
|
f307:m2
|
def _import_module(module_name):
|
fromlist = []<EOL>dot_position = module_name.rfind('<STR_LIT:.>')<EOL>if dot_position > -<NUM_LIT:1>:<EOL><INDENT>fromlist.append(<EOL>module_name[dot_position+<NUM_LIT:1>:len(module_name)]<EOL>)<EOL><DEDENT>module = __import__(module_name, globals(), locals(), fromlist, <NUM_LIT:0>)<EOL>return module<EOL>
|
Imports the module dynamically
_import_module('foo.bar') calls:
__import__('foo.bar',
globals(),
locals(),
['bar', ],
0)
|
f307:m3
|
def _verify_create_args(module_name, class_name, static):
|
<EOL>if module_name is None:<EOL><INDENT>raise InvalidServiceConfiguration(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if not static and class_name is None:<EOL><INDENT>tmpl0 = '<STR_LIT>'<EOL>tmpl1 = '<STR_LIT>'<EOL>raise InvalidServiceConfiguration((tmpl0 + tmpl1) % module_name)<EOL><DEDENT>
|
Verifies a subset of the arguments to create()
|
f307:m4
|
def create(self, module_name, class_name,<EOL>args=None, kwargs=None, factory_method=None,<EOL>factory_args=None, factory_kwargs=None, static=False,<EOL>calls=None):
|
if args is None:<EOL><INDENT>args = []<EOL><DEDENT>if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>if factory_args is None:<EOL><INDENT>factory_args = []<EOL><DEDENT>if factory_kwargs is None:<EOL><INDENT>factory_kwargs = {}<EOL><DEDENT>if static is None:<EOL><INDENT>static = False<EOL><DEDENT>_verify_create_args(module_name, class_name, static)<EOL>module = _import_module(module_name)<EOL>service_obj = self._instantiate(module, class_name,<EOL>args, kwargs, static)<EOL>if factory_method is not None:<EOL><INDENT>service_obj = self._handle_factory_method(service_obj,<EOL>factory_method,<EOL>factory_args,<EOL>factory_kwargs)<EOL><DEDENT>if calls is not None and isinstance(calls, list):<EOL><INDENT>self._handle_calls(service_obj, calls)<EOL><DEDENT>return service_obj<EOL>
|
Initializes an instance of the service
|
f307:c2:m1
|
def create_from_dict(self, dictionary):
|
<EOL>args = []<EOL>kwargs = {}<EOL>factory_method = None<EOL>factory_args = []<EOL>factory_kwargs = {}<EOL>static = False<EOL>calls = None<EOL>if '<STR_LIT:args>' in dictionary:<EOL><INDENT>args = dictionary['<STR_LIT:args>']<EOL><DEDENT>if '<STR_LIT>' in dictionary:<EOL><INDENT>kwargs = dictionary['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in dictionary:<EOL><INDENT>factory_method = dictionary['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in dictionary:<EOL><INDENT>factory_args = dictionary['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in dictionary:<EOL><INDENT>factory_kwargs = dictionary['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in dictionary:<EOL><INDENT>static = dictionary['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in dictionary:<EOL><INDENT>calls = dictionary['<STR_LIT>']<EOL><DEDENT>return self.create(<EOL>dictionary['<STR_LIT>'],<EOL>dictionary['<STR_LIT:class>'],<EOL>args=args,<EOL>kwargs=kwargs,<EOL>factory_method=factory_method,<EOL>factory_args=factory_args,<EOL>factory_kwargs=factory_kwargs,<EOL>static=static,<EOL>calls=calls<EOL>)<EOL>
|
Initializes an instance from a dictionary blueprint
|
f307:c2:m2
|
def add_instantiated_service(self, name, service):
|
self.instantiated_services[name] = service<EOL>
|
Add an instatiated service by name
|
f307:c2:m3
|
def get_instantiated_services(self):
|
return self.instantiated_services<EOL>
|
Get instantiated services
|
f307:c2:m4
|
def get_instantiated_service(self, name):
|
if name not in self.instantiated_services:<EOL><INDENT>raise UninstantiatedServiceException<EOL><DEDENT>return self.instantiated_services[name]<EOL>
|
Get instantiated service by name
|
f307:c2:m5
|
def _replace_service_arg(self, name, index, args):
|
args[index] = self.get_instantiated_service(name)<EOL>
|
Replace index in list with service
|
f307:c2:m6
|
def _replace_service_kwarg(self, key, kwarg):
|
kwarg[key] = self.get_instantiated_service(key)<EOL>
|
Replace key in dictionary with service
|
f307:c2:m7
|
def _replace_scalars_in_args(self, args):
|
_check_type('<STR_LIT:args>', args, list)<EOL>new_args = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, list):<EOL><INDENT>to_append = self._replace_scalars_in_args(arg)<EOL><DEDENT>elif isinstance(arg, dict):<EOL><INDENT>to_append = self._replace_scalars_in_kwargs(arg)<EOL><DEDENT>elif isinstance(arg, string_types):<EOL><INDENT>to_append = self._replace_scalar(arg)<EOL><DEDENT>else:<EOL><INDENT>to_append = arg<EOL><DEDENT>new_args.append(to_append)<EOL><DEDENT>return new_args<EOL>
|
Replace scalars in arguments list
|
f307:c2:m8
|
def _replace_scalars_in_kwargs(self, kwargs):
|
_check_type('<STR_LIT>', kwargs, dict)<EOL>new_kwargs = {}<EOL>for (name, value) in iteritems(kwargs):<EOL><INDENT>if isinstance(value, list):<EOL><INDENT>new_kwargs[name] = self._replace_scalars_in_args(value)<EOL><DEDENT>elif isinstance(value, dict):<EOL><INDENT>new_kwargs[name] = self._replace_scalars_in_kwargs(value)<EOL><DEDENT>elif isinstance(value, string_types):<EOL><INDENT>new_kwargs[name] = self._replace_scalar(value)<EOL><DEDENT>else:<EOL><INDENT>new_kwargs[name] = value<EOL><DEDENT><DEDENT>return new_kwargs<EOL>
|
Replace scalars in keyed arguments dictionary
|
f307:c2:m9
|
def _replace_services_in_args(self, args):
|
_check_type('<STR_LIT:args>', args, list)<EOL>new_args = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, list):<EOL><INDENT>new_args.append(self._replace_services_in_args(arg))<EOL><DEDENT>elif isinstance(arg, dict):<EOL><INDENT>new_args.append(self._replace_services_in_kwargs(arg))<EOL><DEDENT>elif isinstance(arg, string_types):<EOL><INDENT>new_args.append(self._replace_service(arg))<EOL><DEDENT>else:<EOL><INDENT>new_args.append(arg)<EOL><DEDENT><DEDENT>return new_args<EOL>
|
Replace service references in arguments list
|
f307:c2:m10
|
def _replace_services_in_kwargs(self, kwargs):
|
_check_type('<STR_LIT>', kwargs, dict)<EOL>new_kwargs = {}<EOL>for (name, value) in iteritems(kwargs):<EOL><INDENT>if isinstance(value, list):<EOL><INDENT>new_kwargs[name] = self._replace_services_in_args(value)<EOL><DEDENT>elif isinstance(value, dict):<EOL><INDENT>new_kwargs[name] = self._replace_services_in_kwargs(value)<EOL><DEDENT>elif isinstance(value, string_types):<EOL><INDENT>new_kwargs[name] = self._replace_service(value)<EOL><DEDENT>else:<EOL><INDENT>new_kwargs[name] = value<EOL><DEDENT><DEDENT>return new_kwargs<EOL>
|
Replace service references in keyed arguments dictionary
|
f307:c2:m11
|
def get_scalar_value(self, name):
|
if name not in self.scalars:<EOL><INDENT>raise InvalidServiceConfiguration(<EOL>'<STR_LIT>' % name<EOL>)<EOL><DEDENT>new_value = self.scalars.get(name)<EOL>return new_value<EOL>
|
Get scalar value by name
|
f307:c2:m12
|
def _replace_scalar(self, scalar):
|
if not is_arg_scalar(scalar):<EOL><INDENT>return scalar<EOL><DEDENT>name = scalar[<NUM_LIT:1>:]<EOL>return self.get_scalar_value(name)<EOL>
|
Replace scalar name with scalar value
|
f307:c2:m13
|
def _replace_service(self, service):
|
if not is_arg_service(service):<EOL><INDENT>return service<EOL><DEDENT>return self.get_instantiated_service(service[<NUM_LIT:1>:])<EOL>
|
Replace service name with service instance
|
f307:c2:m14
|
def _instantiate(self, module, class_name,<EOL>args=None, kwargs=None, static=None):
|
if args is None:<EOL><INDENT>args = []<EOL><DEDENT>if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>if static is None:<EOL><INDENT>static = False<EOL><DEDENT>_check_type('<STR_LIT:args>', args, list)<EOL>_check_type('<STR_LIT>', kwargs, dict)<EOL>if static and class_name is None:<EOL><INDENT>return module<EOL><DEDENT>if static and class_name is not None:<EOL><INDENT>return getattr(module, class_name)<EOL><DEDENT>service_obj = getattr(module, class_name)<EOL>args = self._replace_scalars_in_args(args)<EOL>kwargs = self._replace_scalars_in_kwargs(kwargs)<EOL>args = self._replace_services_in_args(args)<EOL>kwargs = self._replace_services_in_kwargs(kwargs)<EOL>return service_obj(*args, **kwargs)<EOL>
|
Instantiates a class if provided
|
f307:c2:m15
|
def _handle_factory_method(self, service_obj, method_name,<EOL>args=None, kwargs=None):
|
if args is None:<EOL><INDENT>args = []<EOL><DEDENT>if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>_check_type('<STR_LIT:args>', args, list)<EOL>_check_type('<STR_LIT>', kwargs, dict)<EOL>new_args = self._replace_scalars_in_args(args)<EOL>new_kwargs = self._replace_scalars_in_kwargs(kwargs)<EOL>return getattr(service_obj, method_name)(*new_args, **new_kwargs)<EOL>
|
Returns an object returned from a factory method
|
f307:c2:m16
|
def _handle_calls(self, service_obj, calls):
|
for call in calls:<EOL><INDENT>method = call.get('<STR_LIT>')<EOL>args = call.get('<STR_LIT:args>', [])<EOL>kwargs = call.get('<STR_LIT>', {})<EOL>_check_type('<STR_LIT:args>', args, list)<EOL>_check_type('<STR_LIT>', kwargs, dict)<EOL>if method is None:<EOL><INDENT>raise InvalidServiceConfiguration(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>new_args = self._replace_scalars_in_args(args)<EOL>new_kwargs = self._replace_scalars_in_kwargs(kwargs)<EOL>getattr(service_obj, method)(*new_args, **new_kwargs)<EOL><DEDENT>
|
Performs method calls on service object
|
f307:c2:m17
|
def _get_connection(self):
|
raise NotImplementedError<EOL>
|
Override this method to set up the connection.
|
f308:c1:m1
|
def _close_connection(self):
|
raise NotImplementedError<EOL>
|
Override this method to close the connection.
|
f308:c1:m2
|
def insert(self, query, params):
|
raise NotImplementedError<EOL>
|
Override this method to close the connection.
|
f308:c1:m3
|
def serialize_email_messages(messages: List[EmailMessage]):
|
return [<EOL>base64.b64encode(zlib.compress(pickle.dumps(m, protocol=<NUM_LIT:4>))).decode()<EOL>for m in messages<EOL>]<EOL>
|
Serialize EmailMessages to be passed as task argument.
Pickle is used because serializing an EmailMessage to json can be a bit
tricky and would probably break if Django modifies the structure of the
object in the future.
|
f331:m0
|
def deserialize_email_messages(messages: List[str]):
|
return [<EOL>pickle.loads(zlib.decompress(base64.b64decode(m)))<EOL>for m in messages<EOL>]<EOL>
|
Deserialize EmailMessages passed as task argument.
|
f331:m1
|
def register_sentry(raven_client, namespace: Optional[str]=None,<EOL>send_retries: bool=False):
|
@signals.job_started.connect_via(namespace)<EOL>def job_started(namespace, job, **kwargs):<EOL><INDENT>raven_client.context.activate()<EOL>raven_client.transaction.push(job.task_name)<EOL><DEDENT>@signals.job_finished.connect_via(namespace)<EOL>def job_finished(namespace, job, **kwargs):<EOL><INDENT>raven_client.transaction.pop(job.task_name)<EOL>raven_client.context.clear()<EOL><DEDENT>@signals.job_failed.connect_via(namespace)<EOL>def job_failed(namespace, job, **kwargs):<EOL><INDENT>raven_client.captureException(<EOL>extra={attr: getattr(job, attr) for attr in job.__slots__}<EOL>)<EOL><DEDENT>if send_retries:<EOL><INDENT>@signals.job_schedule_retry.connect_via(namespace)<EOL>def job_schedule_retry(namespace, job, **kwargs):<EOL><INDENT>raven_client.captureException(<EOL>extra={attr: getattr(job, attr) for attr in job.__slots__}<EOL>)<EOL><DEDENT><DEDENT>
|
Register the Sentry integration.
Exceptions making jobs fail are sent to Sentry.
:param raven_client: configured Raven client used to sent errors to Sentry
:param namespace: optionally only register the Sentry integration for a
particular Spinach :class:`Engine`
:param send_retries: whether to also send to Sentry exceptions resulting
in a job being retried
|
f332:m0
|
def register_datadog(tracer=None, namespace: Optional[str]=None,<EOL>service: str='<STR_LIT>'):
|
if tracer is None:<EOL><INDENT>from ddtrace import tracer<EOL><DEDENT>@signals.job_started.connect_via(namespace)<EOL>def job_started(namespace, job, **kwargs):<EOL><INDENT>tracer.trace(<EOL>'<STR_LIT>', service=service, span_type='<STR_LIT>',<EOL>resource=job.task_name<EOL>)<EOL><DEDENT>@signals.job_finished.connect_via(namespace)<EOL>def job_finished(namespace, job, **kwargs):<EOL><INDENT>root_span = tracer.current_root_span()<EOL>for attr in job.__slots__:<EOL><INDENT>root_span.set_tag(attr, getattr(job, attr))<EOL><DEDENT>root_span.finish()<EOL><DEDENT>@signals.job_failed.connect_via(namespace)<EOL>def job_failed(namespace, job, **kwargs):<EOL><INDENT>root_span = tracer.current_root_span()<EOL>root_span.set_traceback()<EOL><DEDENT>@signals.job_schedule_retry.connect_via(namespace)<EOL>def job_schedule_retry(namespace, job, **kwargs):<EOL><INDENT>root_span = tracer.current_root_span()<EOL>root_span.set_traceback()<EOL><DEDENT>
|
Register the Datadog integration.
Exceptions making jobs fail are sent to Sentry.
:param tracer: optionally use a custom ddtrace Tracer instead of the global
one.
:param namespace: optionally only register the Datadog integration for a
particular Spinach :class:`Engine`
:param service: Datadog service associated with the trace, defaults to
`spinach`
|
f333:m0
|
def start(self):
|
Start the broker.
Only needed by arbiter.
|
f334:c0:m2
|
|
def stop(self):
|
self._something_happened.set()<EOL>
|
Stop the broker.
Only needed by arbiter.
|
f334:c0:m3
|
@abstractmethod<EOL><INDENT>def register_periodic_tasks(self, tasks: Iterable[Task]):<DEDENT>
|
Register tasks that need to be scheduled periodically.
|
f334:c0:m7
|
|
@abstractmethod<EOL><INDENT>def inspect_periodic_tasks(self) -> List[Tuple[int, str]]:<DEDENT>
|
Get the next periodic task schedule.
Used only for debugging and during tests.
|
f334:c0:m8
|
|
@abstractmethod<EOL><INDENT>def enqueue_jobs(self, jobs: Iterable[Job]):<DEDENT>
|
Enqueue a batch of jobs.
|
f334:c0:m9
|
|
@abstractmethod<EOL><INDENT>def remove_job_from_running(self, job: Job):<DEDENT>
|
Remove a job from the list of running ones.
|
f334:c0:m10
|
|
@abstractmethod<EOL><INDENT>def get_jobs_from_queue(self, queue: str, max_jobs: int) -> List[Job]:<DEDENT>
|
Get jobs from a queue.
|
f334:c0:m11
|
|
@abstractmethod<EOL><INDENT>def move_future_jobs(self) -> int:<DEDENT>
|
Move ready jobs from the future queue to their normal queues.
:returns the number of jobs moved
|
f334:c0:m12
|
|
@abstractmethod<EOL><INDENT>def _get_next_future_job(self)-> Optional[Job]:<DEDENT>
|
Get the next future job.
|
f334:c0:m13
|
|
@property<EOL><INDENT>def next_future_job_delta(self) -> Optional[float]:<DEDENT>
|
job = self._get_next_future_job()<EOL>if not job:<EOL><INDENT>return None<EOL><DEDENT>return (job.at - datetime.now(timezone.utc)).total_seconds()<EOL>
|
Give the amount of seconds before the next future job is due.
|
f334:c0:m14
|
@property<EOL><INDENT>@abstractmethod<EOL>def next_future_periodic_delta(self) -> Optional[float]:<DEDENT>
|
Give the amount of seconds before the next periodic task is due.
|
f334:c0:m15
|
|
@abstractmethod<EOL><INDENT>def flush(self):<DEDENT>
|
Delete everything in the namespace.
|
f334:c0:m16
|
|
def enqueue_jobs(self, jobs: Iterable[Job]):
|
for job in jobs:<EOL><INDENT>if job.should_start:<EOL><INDENT>job.status = JobStatus.QUEUED<EOL>queue = self._get_queue(job.queue)<EOL>queue.put(job.serialize())<EOL><DEDENT>else:<EOL><INDENT>with self._lock:<EOL><INDENT>job.status = JobStatus.WAITING<EOL>self._future_jobs.append(job.serialize())<EOL>self._future_jobs.sort(key=lambda j: Job.deserialize(j).at)<EOL><DEDENT><DEDENT><DEDENT>self._something_happened.set()<EOL>
|
Enqueue a batch of jobs.
|
f335:c0:m2
|
def register_periodic_tasks(self, tasks: Iterable[Task]):
|
for task in tasks:<EOL><INDENT>self._scheduler.enter(<EOL>int(task.periodicity.total_seconds()),<EOL><NUM_LIT:0>,<EOL>self._schedule_periodic_task,<EOL>argument=(task,)<EOL>)<EOL><DEDENT>
|
Register tasks that need to be scheduled periodically.
|
f335:c0:m4
|
@property<EOL><INDENT>def next_future_periodic_delta(self) -> Optional[float]:<DEDENT>
|
try:<EOL><INDENT>next_event = self._scheduler.queue[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>now = time.monotonic()<EOL>next_event_time = next_event[<NUM_LIT:0>]<EOL>if next_event_time < now:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return next_event_time - now<EOL>
|
Give the amount of seconds before the next periodic task is due.
|
f335:c0:m6
|
def inspect_periodic_tasks(self) -> List[Tuple[int, str]]:
|
return [(int(e[<NUM_LIT:0>]), e[<NUM_LIT:3>][<NUM_LIT:0>].name) for e in self._scheduler.queue]<EOL>
|
Get the next periodic task schedule.
Used only for debugging and during tests.
|
f335:c0:m7
|
def get_jobs_from_queue(self, queue: str, max_jobs: int) -> List[Job]:
|
rv = list()<EOL>while len(rv) < max_jobs:<EOL><INDENT>try:<EOL><INDENT>job_json_string = self._get_queue(queue).get(block=False)<EOL><DEDENT>except Empty:<EOL><INDENT>break<EOL><DEDENT>job = Job.deserialize(job_json_string)<EOL>job.status = JobStatus.RUNNING<EOL>rv.append(job)<EOL><DEDENT>return rv<EOL>
|
Get jobs from a queue.
|
f335:c0:m9
|
def remove_job_from_running(self, job: Job):
|
self._something_happened.set()<EOL>
|
Remove a job from the list of running ones.
Easy, the memory broker doesn't track running jobs. If the broker dies
there is nothing we can do.
|
f335:c0:m11
|
def _reset(self):
|
self._subscriber_thread = None<EOL>self._must_stop = threading.Event()<EOL>self._number_periodic_tasks = <NUM_LIT:0><EOL>
|
Initialization that must happen before the broker is (re)started.
|
f336:c0:m1
|
def _load_script(self, filename: str) -> Script:
|
with open(path.join(here, '<STR_LIT>', filename), mode='<STR_LIT:rb>') as f:<EOL><INDENT>script_data = f.read()<EOL><DEDENT>rv = self._r.register_script(script_data)<EOL>if script_data.startswith(b'<STR_LIT>'):<EOL><INDENT>self._idempotency_protected_scripts.append(rv)<EOL><DEDENT>return rv<EOL>
|
Load a Lua script.
Read the Lua script file to generate its Script object. If the script
starts with a magic string, add it to the list of scripts requiring an
idempotency token to execute.
|
f336:c0:m2
|
def enqueue_jobs(self, jobs: Iterable[Job]):
|
jobs_to_queue = list()<EOL>for job in jobs:<EOL><INDENT>if job.should_start:<EOL><INDENT>job.status = JobStatus.QUEUED<EOL><DEDENT>else:<EOL><INDENT>job.status = JobStatus.WAITING<EOL><DEDENT>jobs_to_queue.append(job.serialize())<EOL><DEDENT>if jobs_to_queue:<EOL><INDENT>self._run_script(<EOL>self._enqueue_job,<EOL>self._to_namespaced(NOTIFICATIONS_KEY),<EOL>self._to_namespaced(RUNNING_JOBS_KEY.format(self._id)),<EOL>self.namespace,<EOL>self._to_namespaced(FUTURE_JOBS_KEY),<EOL>*jobs_to_queue<EOL>)<EOL><DEDENT>
|
Enqueue a batch of jobs.
|
f336:c0:m4
|
def get_jobs_from_queue(self, queue: str, max_jobs: int) -> List[Job]:
|
jobs_json_string = self._run_script(<EOL>self._get_jobs_from_queue,<EOL>self._to_namespaced(queue),<EOL>self._to_namespaced(RUNNING_JOBS_KEY.format(self._id)),<EOL>JobStatus.RUNNING.value,<EOL>max_jobs<EOL>)<EOL>jobs = json.loads(jobs_json_string.decode())<EOL>jobs = [Job.deserialize(job) for job in jobs]<EOL>return jobs<EOL>
|
Get jobs from a queue.
|
f336:c0:m7
|
def register_periodic_tasks(self, tasks: Iterable[Task]):
|
tasks = [task.serialize() for task in tasks]<EOL>self._number_periodic_tasks = len(tasks)<EOL>self._run_script(<EOL>self._register_periodic_tasks,<EOL>math.ceil(datetime.now(timezone.utc).timestamp()),<EOL>self._to_namespaced(PERIODIC_TASKS_HASH_KEY),<EOL>self._to_namespaced(PERIODIC_TASKS_QUEUE_KEY),<EOL>*tasks<EOL>)<EOL>
|
Register tasks that need to be scheduled periodically.
|
f336:c0:m13
|
def inspect_periodic_tasks(self) -> List[Tuple[int, str]]:
|
rv = self._r.zrangebyscore(<EOL>self._to_namespaced(PERIODIC_TASKS_QUEUE_KEY),<EOL>'<STR_LIT>', '<STR_LIT>', withscores=True<EOL>)<EOL>return [(int(r[<NUM_LIT:1>]), r[<NUM_LIT:0>].decode()) for r in rv]<EOL>
|
Get the next periodic task schedule.
Used only for debugging and during tests.
|
f336:c0:m14
|
@property<EOL><INDENT>def next_future_periodic_delta(self) -> Optional[float]:<DEDENT>
|
rv = self._r.zrangebyscore(<EOL>self._to_namespaced(PERIODIC_TASKS_QUEUE_KEY),<EOL>'<STR_LIT>', '<STR_LIT>', start=<NUM_LIT:0>, num=<NUM_LIT:1>, withscores=True,<EOL>score_cast_func=int<EOL>)<EOL>if not rv:<EOL><INDENT>return None<EOL><DEDENT>now = datetime.now(timezone.utc).timestamp()<EOL>next_event_time = rv[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>if next_event_time < now:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return next_event_time - now<EOL>
|
Give the amount of seconds before the next periodic task is due.
|
f336:c0:m15
|
def _reset(self):
|
self._arbiter = None<EOL>self._workers = None<EOL>self._working_queue = None<EOL>self._must_stop = threading.Event()<EOL>
|
Initialization that must happen before the arbiter is (re)started
|
f337:c0:m1
|
@property<EOL><INDENT>def namespace(self) -> str:<DEDENT>
|
return self._namespace<EOL>
|
Namespace the Engine uses.
|
f337:c0:m2
|
def attach_tasks(self, tasks: Tasks):
|
if tasks._spin is not None and tasks._spin is not self:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL><DEDENT>self._tasks.update(tasks)<EOL>tasks._spin = self<EOL>
|
Attach a set of tasks.
A task cannot be scheduled or executed before it is attached to an
Engine.
>>> tasks = Tasks()
>>> spin.attach_tasks(tasks)
|
f337:c0:m3
|
def schedule(self, task: Schedulable, *args, **kwargs):
|
at = datetime.now(timezone.utc)<EOL>return self.schedule_at(task, at, *args, **kwargs)<EOL>
|
Schedule a job to be executed as soon as possible.
:arg task: the task or its name to execute in the background
:arg args: args to be passed to the task function
:arg kwargs: kwargs to be passed to the task function
|
f337:c0:m5
|
def schedule_at(self, task: Schedulable, at: datetime, *args, **kwargs):
|
task = self._tasks.get(task)<EOL>job = Job(task.name, task.queue, at, task.max_retries, task_args=args,<EOL>task_kwargs=kwargs)<EOL>return self._broker.enqueue_jobs([job])<EOL>
|
Schedule a job to be executed in the future.
:arg task: the task or its name to execute in the background
:arg at: date at which the job should start. It is advised to pass a
timezone aware datetime to lift any ambiguity. However if a
timezone naive datetime if given, it will be assumed to
contain UTC time.
:arg args: args to be passed to the task function
:arg kwargs: kwargs to be passed to the task function
|
f337:c0:m6
|
def schedule_batch(self, batch: Batch):
|
jobs = list()<EOL>for task, at, args, kwargs in batch.jobs_to_create:<EOL><INDENT>task = self._tasks.get(task)<EOL>jobs.append(<EOL>Job(task.name, task.queue, at, task.max_retries,<EOL>task_args=args, task_kwargs=kwargs)<EOL>)<EOL><DEDENT>return self._broker.enqueue_jobs(jobs)<EOL>
|
Schedule many jobs at once.
Scheduling jobs in batches allows to enqueue them fast by avoiding
round-trips to the broker.
:arg batch: :class:`Batch` instance containing jobs to schedule
|
f337:c0:m7
|
def start_workers(self, number: int=DEFAULT_WORKER_NUMBER,<EOL>queue=DEFAULT_QUEUE, block=True,<EOL>stop_when_queue_empty=False):
|
if self._arbiter or self._workers:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self._working_queue = queue<EOL>tasks_names = '<STR_LIT:\n>'.join(<EOL>['<STR_LIT>' + task.name for task in self._tasks.tasks.values()<EOL>if task.queue == self._working_queue]<EOL>)<EOL>logger.info('<STR_LIT>',<EOL>number, self._working_queue, tasks_names)<EOL>self._broker.start()<EOL>self._workers = Workers(<EOL>num_workers=number,<EOL>namespace=self.namespace,<EOL>)<EOL>self._result_notifier = threading.Thread(<EOL>target=run_forever,<EOL>args=(self._result_notifier_func, self._must_stop, logger),<EOL>name='<STR_LIT>'.format(self.namespace)<EOL>)<EOL>self._result_notifier.start()<EOL>self._arbiter = threading.Thread(<EOL>target=run_forever,<EOL>args=(self._arbiter_func, self._must_stop, logger,<EOL>stop_when_queue_empty),<EOL>name='<STR_LIT>'.format(self.namespace)<EOL>)<EOL>self._arbiter.start()<EOL>if block:<EOL><INDENT>with handle_sigterm():<EOL><INDENT>try:<EOL><INDENT>self._arbiter.join()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>self.stop_workers()<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>
|
Start the worker threads.
:arg number: number of worker threads to launch
:arg queue: name of the queue to consume, see :doc:`queues`
:arg block: whether to block the calling thread until a signal arrives
and workers get terminated
:arg stop_when_queue_empty: automatically stop the workers when the
queue is empty. Useful mostly for one-off scripts and testing.
|
f337:c0:m9
|
def stop_workers(self, _join_arbiter=True):
|
<EOL>self._must_stop.set()<EOL>self._workers.stop()<EOL>self._result_notifier.join()<EOL>self._broker.stop()<EOL>if _join_arbiter:<EOL><INDENT>self._arbiter.join()<EOL><DEDENT>self._reset()<EOL>
|
Stop the workers and wait for them to terminate.
|
f337:c0:m10
|
def send(self, *sender, **kwargs):
|
if len(sender) == <NUM_LIT:0>:<EOL><INDENT>sender = None<EOL><DEDENT>elif len(sender) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % len(sender))<EOL><DEDENT>else:<EOL><INDENT>sender = sender[<NUM_LIT:0>]<EOL><DEDENT>if not self.receivers:<EOL><INDENT>return []<EOL><DEDENT>rv = list()<EOL>for receiver in self.receivers_for(sender):<EOL><INDENT>try:<EOL><INDENT>rv.append((receiver, receiver(sender, **kwargs)))<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception('<STR_LIT>'<EOL>'<STR_LIT>'.format(self.name))<EOL><DEDENT><DEDENT>return rv<EOL>
|
Emit this signal on behalf of `sender`, passing on kwargs.
This is an extension of `Signal.send` that changes one thing:
Exceptions raised in calling the receiver are logged but do not fail
|
f338:c0:m0
|
def task(self, func: Optional[Callable]=None, name: Optional[str]=None,<EOL>queue: Optional[str]=None, max_retries: Optional[Number]=None,<EOL>periodicity: Optional[timedelta]=None):
|
if func is None:<EOL><INDENT>return functools.partial(self.task, name=name, queue=queue,<EOL>max_retries=max_retries,<EOL>periodicity=periodicity)<EOL><DEDENT>self.add(func, name=name, queue=queue, max_retries=max_retries,<EOL>periodicity=periodicity)<EOL>func.task_name = name<EOL>return func<EOL>
|
Decorator to register a task function.
:arg name: name of the task, used later to schedule jobs
:arg queue: queue of the task, the default is used if not provided
:arg max_retries: maximum number of retries, the default is used if
not provided
:arg periodicity: for periodic tasks, delay between executions as a
timedelta
>>> tasks = Tasks()
>>> @tasks.task(name='foo')
>>> def foo():
... pass
|
f339:c1:m5
|
def add(self, func: Callable, name: Optional[str]=None,<EOL>queue: Optional[str]=None, max_retries: Optional[Number]=None,<EOL>periodicity: Optional[timedelta]=None):
|
if not name:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if name in self._tasks:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(name))<EOL><DEDENT>if queue is None:<EOL><INDENT>if self.queue:<EOL><INDENT>queue = self.queue<EOL><DEDENT>else:<EOL><INDENT>queue = const.DEFAULT_QUEUE<EOL><DEDENT><DEDENT>if max_retries is None:<EOL><INDENT>if self.max_retries:<EOL><INDENT>max_retries = self.max_retries<EOL><DEDENT>else:<EOL><INDENT>max_retries = const.DEFAULT_MAX_RETRIES<EOL><DEDENT><DEDENT>if periodicity is None:<EOL><INDENT>periodicity = self.periodicity<EOL><DEDENT>if queue and queue.startswith('<STR_LIT:_>'):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self._tasks[name] = Task(func, name, queue, max_retries, periodicity)<EOL>
|
Register a task function.
:arg func: a callable to be executed
:arg name: name of the task, used later to schedule jobs
:arg queue: queue of the task, the default is used if not provided
:arg max_retries: maximum number of retries, the default is used if
not provided
:arg periodicity: for periodic tasks, delay between executions as a
timedelta
>>> tasks = Tasks()
>>> tasks.add(lambda x: x, name='do_nothing')
|
f339:c1:m6
|
def schedule(self, task: Schedulable, *args, **kwargs):
|
self._require_attached_tasks()<EOL>self._spin.schedule(task, *args, **kwargs)<EOL>
|
Schedule a job to be executed as soon as possible.
:arg task: the task or its name to execute in the background
:arg args: args to be passed to the task function
:arg kwargs: kwargs to be passed to the task function
This method can only be used once tasks have been attached to a
Spinach :class:`Engine`.
|
f339:c1:m8
|
def schedule_at(self, task: Schedulable, at: datetime, *args, **kwargs):
|
self._require_attached_tasks()<EOL>self._spin.schedule_at(task, at, *args, **kwargs)<EOL>
|
Schedule a job to be executed in the future.
:arg task: the task or its name to execute in the background
:arg at: Date at which the job should start. It is advised to pass a
timezone aware datetime to lift any ambiguity. However if a
timezone naive datetime if given, it will be assumed to
contain UTC time.
:arg args: args to be passed to the task function
:arg kwargs: kwargs to be passed to the task function
This method can only be used once tasks have been attached to a
Spinach :class:`Engine`.
|
f339:c1:m9
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.