response
stringlengths 1
33.1k
| instruction
stringlengths 22
582k
|
|---|---|
Start worker in separate process.
Yields:
celery.app.worker.Worker: worker instance. | def _start_worker_process(app,
concurrency=1,
pool='solo',
loglevel=WORKER_LOGLEVEL,
logfile=None,
**kwargs):
# type (Celery, int, str, Union[int, str], str, **Any) -> Iterable
"""Start worker in separate process.
Yields:
celery.app.worker.Worker: worker instance.
"""
from celery.apps.multi import Cluster, Node
app.set_current()
cluster = Cluster([Node('testworker1@%h')])
cluster.start()
try:
yield
finally:
cluster.stopwait() |
Setup the app to be used for starting an embedded worker. | def setup_app_for_worker(app: Celery, loglevel: Union[str, int], logfile: str) -> None:
"""Setup the app to be used for starting an embedded worker."""
app.finalize()
app.set_current()
app.set_default()
type(app.log)._setup = False
app.log.setup(loglevel=loglevel, logfile=logfile) |
Start curses monitor. | def evtop(app=None): # pragma: no cover
"""Start curses monitor."""
app = app_or_default(app)
state = app.events.State()
display = CursesMonitor(state, app)
display.init_screen()
refresher = DisplayThread(display)
refresher.start()
try:
capture_events(app, state, display)
except Exception:
refresher.shutdown = True
refresher.join()
display.resetscreen()
raise
except (KeyboardInterrupt, SystemExit):
refresher.shutdown = True
refresher.join()
display.resetscreen() |
Start event dump. | def evdump(app=None, out=sys.stdout):
"""Start event dump."""
app = app_or_default(app)
dumper = Dumper(out=out)
dumper.say('-> evdump: starting capture...')
conn = app.connection_for_read().clone()
def _error_handler(exc, interval):
dumper.say(CONNECTION_ERROR % (
conn.as_uri(), exc, humanize_seconds(interval, 'in', ' ')
))
while 1:
try:
conn.ensure_connection(_error_handler)
recv = app.events.Receiver(conn, handlers={'*': dumper.on_event})
recv.capture()
except (KeyboardInterrupt, SystemExit):
return conn and conn.close()
except conn.connection_errors + conn.channel_errors:
dumper.say('-> Connection lost, attempting reconnect') |
Create an event.
Notes:
An event is simply a dictionary: the only required field is ``type``.
A ``timestamp`` field will be set to the current time if not provided. | def Event(type, _fields=None, __dict__=dict, __now__=time.time, **fields):
"""Create an event.
Notes:
An event is simply a dictionary: the only required field is ``type``.
A ``timestamp`` field will be set to the current time if not provided.
"""
event = __dict__(_fields, **fields) if _fields else fields
if 'timestamp' not in event:
event.update(timestamp=__now__(), type=type)
else:
event['type'] = type
return event |
Get the group part of an event type name.
Example:
>>> group_from('task-sent')
'task'
>>> group_from('custom-my-event')
'custom' | def group_from(type):
"""Get the group part of an event type name.
Example:
>>> group_from('task-sent')
'task'
>>> group_from('custom-my-event')
'custom'
"""
return type.split('-', 1)[0] |
Get exchange used for sending events.
Arguments:
conn (kombu.Connection): Connection used for sending/receiving events.
name (str): Name of the exchange. Default is ``celeryev``.
Note:
The event type changes if Redis is used as the transport
(from topic -> fanout). | def get_exchange(conn, name=EVENT_EXCHANGE_NAME):
"""Get exchange used for sending events.
Arguments:
conn (kombu.Connection): Connection used for sending/receiving events.
name (str): Name of the exchange. Default is ``celeryev``.
Note:
The event type changes if Redis is used as the transport
(from topic -> fanout).
"""
ex = copy(event_exchange)
if conn.transport.driver_type == 'redis':
# quick hack for Issue #436
ex.type = 'fanout'
if name != ex.name:
ex.name = name
return ex |
Start snapshot recorder. | def evcam(camera, freq=1.0, maxrate=None, loglevel=0,
logfile=None, pidfile=None, timer=None, app=None,
**kwargs):
"""Start snapshot recorder."""
app = app_or_default(app)
if pidfile:
platforms.create_pidlock(pidfile)
app.log.setup_logging_subsystem(loglevel, logfile)
print(f'-> evcam: Taking snapshots with {camera} (every {freq} secs.)')
state = app.events.State()
cam = instantiate(camera, state, app=app, freq=freq,
maxrate=maxrate, timer=timer)
cam.install()
conn = app.connection_for_read()
recv = app.events.Receiver(conn, handlers={'*': state.event})
try:
try:
recv.capture(limit=None)
except KeyboardInterrupt:
raise SystemExit
finally:
cam.cancel()
conn.close() |
Return time when heartbeat expires. | def heartbeat_expires(timestamp, freq=60,
expire_window=HEARTBEAT_EXPIRE_WINDOW,
Decimal=Decimal, float=float, isinstance=isinstance):
"""Return time when heartbeat expires."""
# some json implementations returns decimal.Decimal objects,
# which aren't compatible with float.
freq = float(freq) if isinstance(freq, Decimal) else freq
if isinstance(timestamp, Decimal):
timestamp = float(timestamp)
return timestamp + (freq * (expire_window / 1e2)) |
Install Django fixup if settings module environment is set. | def fixup(app: "Celery", env: str = 'DJANGO_SETTINGS_MODULE') -> Optional["DjangoFixup"]:
"""Install Django fixup if settings module environment is set."""
SETTINGS_MODULE = os.environ.get(env)
if SETTINGS_MODULE and 'django' not in app.loader_cls.lower():
try:
import django
except ImportError:
warnings.warn(FixupWarning(ERR_NOT_INSTALLED))
else:
_verify_django_version(django)
return DjangoFixup(app).install()
return None |
Find module in package. | def find_related_module(package, related_name):
"""Find module in package."""
# Django 1.7 allows for specifying a class name in INSTALLED_APPS.
# (Issue #2248).
try:
# Return package itself when no related_name.
module = importlib.import_module(package)
if not related_name and module:
return module
except ModuleNotFoundError:
# On import error, try to walk package up one level.
package, _, _ = package.rpartition('.')
if not package:
raise
module_name = f'{package}.{related_name}'
try:
# Try to find related_name under package.
return importlib.import_module(module_name)
except ModuleNotFoundError as e:
import_exc_name = getattr(e, 'name', None)
# If candidate does not exist, then return None.
if import_exc_name and module_name == import_exc_name:
return
# Otherwise, raise because error probably originated from a nested import.
raise e |
Get loader class by name/alias. | def get_loader_cls(loader):
"""Get loader class by name/alias."""
return symbol_by_name(loader, LOADER_ALIASES, imp=import_from_cwd) |
Register security serializer. | def register_auth(key=None, key_password=None, cert=None, store=None,
digest=DEFAULT_SECURITY_DIGEST,
serializer='json'):
"""Register security serializer."""
s = SecureSerializer(key and PrivateKey(key, password=key_password),
cert and Certificate(cert),
store and FSCertStore(store),
digest, serializer=serializer)
registry.register('auth', s.serialize, s.deserialize,
content_type='application/data',
content_encoding='utf-8') |
Convert string to hash object of cryptography library. | def get_digest_algorithm(digest='sha256'):
"""Convert string to hash object of cryptography library."""
assert digest is not None
return getattr(hashes, digest.upper())() |
Context reraising crypto errors as :exc:`SecurityError`. | def reraise_errors(msg='{0!r}', errors=None):
"""Context reraising crypto errors as :exc:`SecurityError`."""
errors = (cryptography.exceptions,) if errors is None else errors
try:
yield
except errors as exc:
reraise(SecurityError,
SecurityError(msg.format(exc)),
sys.exc_info()[2]) |
See :meth:`@Celery.setup_security`. | def setup_security(allowed_serializers=None, key=None, key_password=None, cert=None, store=None,
digest=None, serializer='json', app=None):
"""See :meth:`@Celery.setup_security`."""
if app is None:
from celery import current_app
app = current_app._get_current_object()
_disable_insecure_serializers(allowed_serializers)
# check conf for sane security settings
conf = app.conf
if conf.task_serializer != 'auth' or conf.accept_content != ['auth']:
raise ImproperlyConfigured(SETTING_MISSING)
key = key or conf.security_key
key_password = key_password or conf.security_key_password
cert = cert or conf.security_certificate
store = store or conf.security_cert_store
digest = digest or conf.security_digest
if not (key and cert and store):
raise ImproperlyConfigured(SECURITY_SETTING_MISSING)
with open(key) as kf:
with open(cert) as cf:
register_auth(kf.read(), key_password, cf.read(), store, digest, serializer)
registry._set_default_serializer('auth') |
Wrap object into supporting the mapping interface if necessary. | def force_mapping(m):
# type: (Any) -> Mapping
"""Wrap object into supporting the mapping interface if necessary."""
if isinstance(m, (LazyObject, LazySettings)):
m = m._wrapped
return DictAttribute(m) if not isinstance(m, Mapping) else m |
In place left precedent dictionary merge.
Keeps values from `L`, if the value in `R` is :const:`None`. | def lpmerge(L, R):
# type: (Mapping, Mapping) -> Mapping
"""In place left precedent dictionary merge.
Keeps values from `L`, if the value in `R` is :const:`None`.
"""
setitem = L.__setitem__
[setitem(k, v) for k, v in R.items() if v is not None]
return L |
Context that raises an exception if process is blocking.
Uses ``SIGALRM`` to detect blocking functions. | def blockdetection(timeout):
"""Context that raises an exception if process is blocking.
Uses ``SIGALRM`` to detect blocking functions.
"""
if not timeout:
yield
else:
old_handler = signals['ALRM']
old_handler = None if old_handler == _on_blocking else old_handler
signals['ALRM'] = _on_blocking
try:
yield signals.arm_alarm(timeout)
finally:
if old_handler:
signals['ALRM'] = old_handler
signals.reset_alarm() |
Sample RSS memory usage.
Statistics can then be output by calling :func:`memdump`. | def sample_mem():
"""Sample RSS memory usage.
Statistics can then be output by calling :func:`memdump`.
"""
current_rss = mem_rss()
_mem_sample.append(current_rss)
return current_rss |
Dump memory statistics.
Will print a sample of all RSS memory samples added by
calling :func:`sample_mem`, and in addition print
used RSS memory after :func:`gc.collect`. | def memdump(samples=10, file=None): # pragma: no cover
"""Dump memory statistics.
Will print a sample of all RSS memory samples added by
calling :func:`sample_mem`, and in addition print
used RSS memory after :func:`gc.collect`.
"""
say = partial(print, file=file)
if ps() is None:
say('- rss: (psutil not installed).')
return
prev, after_collect = _memdump(samples)
if prev:
say('- rss (sample):')
for mem in prev:
say(f'- > {mem},')
say(f'- rss (end): {after_collect}.') |
Given a list `x` a sample of length ``n`` of that list is returned.
For example, if `n` is 10, and `x` has 100 items, a list of every tenth.
item is returned.
``k`` can be used as offset. | def sample(x, n, k=0):
"""Given a list `x` a sample of length ``n`` of that list is returned.
For example, if `n` is 10, and `x` has 100 items, a list of every tenth.
item is returned.
``k`` can be used as offset.
"""
j = len(x) // n
for _ in range(n):
try:
yield x[k]
except IndexError:
break
k += j |
Convert float to value suitable for humans.
Arguments:
f (float): The floating point number.
p (int): Floating point precision (default is 5). | def hfloat(f, p=5):
"""Convert float to value suitable for humans.
Arguments:
f (float): The floating point number.
p (int): Floating point precision (default is 5).
"""
i = int(f)
return i if i == f else '{0:.{p}}'.format(f, p=p) |
Convert bytes to human-readable form (e.g., KB, MB). | def humanbytes(s):
"""Convert bytes to human-readable form (e.g., KB, MB)."""
return next(
f'{hfloat(s / div if div else s)}{unit}'
for div, unit in UNITS if s >= div
) |
Return RSS memory usage as a humanized string. | def mem_rss():
"""Return RSS memory usage as a humanized string."""
p = ps()
if p is not None:
return humanbytes(_process_memory_info(p).rss) |
Return the global :class:`psutil.Process` instance.
Note:
Returns :const:`None` if :pypi:`psutil` is not installed. | def ps(): # pragma: no cover
"""Return the global :class:`psutil.Process` instance.
Note:
Returns :const:`None` if :pypi:`psutil` is not installed.
"""
global _process
if _process is None and Process is not None:
_process = Process(os.getpid())
return _process |
Return stack-trace of all active threads.
See Also:
Taken from https://gist.github.com/737056. | def cry(out=None, sepchr='=', seplen=49): # pragma: no cover
"""Return stack-trace of all active threads.
See Also:
Taken from https://gist.github.com/737056.
"""
import threading
out = WhateverIO() if out is None else out
P = partial(print, file=out)
# get a map of threads by their ID so we can print their names
# during the traceback dump
tmap = {t.ident: t for t in threading.enumerate()}
sep = sepchr * seplen
for tid, frame in sys._current_frames().items():
thread = tmap.get(tid)
if not thread:
# skip old junk (left-overs from a fork)
continue
P(f'{thread.name}')
P(sep)
traceback.print_stack(frame, file=out)
P(sep)
P('LOCAL VARIABLES')
P(sep)
pprint(frame.f_locals, stream=out)
P('\n')
return out.getvalue() |
Warn of (pending) deprecation. | def warn(description=None, deprecation=None,
removal=None, alternative=None, stacklevel=2):
"""Warn of (pending) deprecation."""
ctx = {'description': description,
'deprecation': deprecation, 'removal': removal,
'alternative': alternative}
if deprecation is not None:
w = CPendingDeprecationWarning(PENDING_DEPRECATION_FMT.format(**ctx))
else:
w = CDeprecationWarning(DEPRECATION_FMT.format(**ctx))
warnings.warn(w, stacklevel=stacklevel) |
Decorator for deprecated functions.
A deprecation warning will be emitted when the function is called.
Arguments:
deprecation (str): Version that marks first deprecation, if this
argument isn't set a ``PendingDeprecationWarning`` will be
emitted instead.
removal (str): Future version when this feature will be removed.
alternative (str): Instructions for an alternative solution (if any).
description (str): Description of what's being deprecated. | def Callable(deprecation=None, removal=None,
alternative=None, description=None):
"""Decorator for deprecated functions.
A deprecation warning will be emitted when the function is called.
Arguments:
deprecation (str): Version that marks first deprecation, if this
argument isn't set a ``PendingDeprecationWarning`` will be
emitted instead.
removal (str): Future version when this feature will be removed.
alternative (str): Instructions for an alternative solution (if any).
description (str): Description of what's being deprecated.
"""
def _inner(fun):
@wraps(fun)
def __inner(*args, **kwargs):
from .imports import qualname
warn(description=description or qualname(fun),
deprecation=deprecation,
removal=removal,
alternative=alternative,
stacklevel=3)
return fun(*args, **kwargs)
return __inner
return _inner |
Decorator for deprecated properties. | def Property(deprecation=None, removal=None,
alternative=None, description=None):
"""Decorator for deprecated properties."""
def _inner(fun):
return _deprecated_property(
fun, deprecation=deprecation, removal=removal,
alternative=alternative, description=description or fun.__name__)
return _inner |
No operation.
Takes any arguments/keyword arguments and does nothing. | def noop(*args, **kwargs):
"""No operation.
Takes any arguments/keyword arguments and does nothing.
""" |
Return the first positional argument. | def pass1(arg, *args, **kwargs):
"""Return the first positional argument."""
return arg |
Return the first element in ``it`` that ``predicate`` accepts.
If ``predicate`` is None it will return the first item that's not
:const:`None`. | def first(predicate, it):
"""Return the first element in ``it`` that ``predicate`` accepts.
If ``predicate`` is None it will return the first item that's not
:const:`None`.
"""
return next(
(v for v in evaluate_promises(it) if (
predicate(v) if predicate is not None else v is not None)),
None,
) |
Multiple dispatch.
Return a function that with a list of instances,
finds the first instance that gives a value for the given method.
The list can also contain lazy instances
(:class:`~kombu.utils.functional.lazy`.) | def firstmethod(method, on_call=None):
"""Multiple dispatch.
Return a function that with a list of instances,
finds the first instance that gives a value for the given method.
The list can also contain lazy instances
(:class:`~kombu.utils.functional.lazy`.)
"""
def _matcher(it, *args, **kwargs):
for obj in it:
try:
meth = getattr(maybe_evaluate(obj), method)
reply = (on_call(meth, *args, **kwargs) if on_call
else meth(*args, **kwargs))
except AttributeError:
pass
else:
if reply is not None:
return reply
return _matcher |
Split an iterator into chunks with `n` elements each.
Warning:
``it`` must be an actual iterator, if you pass this a
concrete sequence will get you repeating elements.
So ``chunks(iter(range(1000)), 10)`` is fine, but
``chunks(range(1000), 10)`` is not.
Example:
# n == 2
>>> x = chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 2)
>>> list(x)
[[0, 1], [2, 3], [4, 5], [6, 7], [8, 9], [10]]
# n == 3
>>> x = chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 3)
>>> list(x)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]] | def chunks(it, n):
"""Split an iterator into chunks with `n` elements each.
Warning:
``it`` must be an actual iterator, if you pass this a
concrete sequence will get you repeating elements.
So ``chunks(iter(range(1000)), 10)`` is fine, but
``chunks(range(1000), 10)`` is not.
Example:
# n == 2
>>> x = chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 2)
>>> list(x)
[[0, 1], [2, 3], [4, 5], [6, 7], [8, 9], [10]]
# n == 3
>>> x = chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 3)
>>> list(x)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
"""
for item in it:
yield [item] + list(islice(it, n - 1)) |
Pad list with default elements.
Example:
>>> first, last, city = padlist(['George', 'Costanza', 'NYC'], 3)
('George', 'Costanza', 'NYC')
>>> first, last, city = padlist(['George', 'Costanza'], 3)
('George', 'Costanza', None)
>>> first, last, city, planet = padlist(
... ['George', 'Costanza', 'NYC'], 4, default='Earth',
... )
('George', 'Costanza', 'NYC', 'Earth') | def padlist(container, size, default=None):
"""Pad list with default elements.
Example:
>>> first, last, city = padlist(['George', 'Costanza', 'NYC'], 3)
('George', 'Costanza', 'NYC')
>>> first, last, city = padlist(['George', 'Costanza'], 3)
('George', 'Costanza', None)
>>> first, last, city, planet = padlist(
... ['George', 'Costanza', 'NYC'], 4, default='Earth',
... )
('George', 'Costanza', 'NYC', 'Earth')
"""
return list(container)[:size] + [default] * (size - len(container)) |
Get attributes, ignoring attribute errors.
Like :func:`operator.itemgetter` but return :const:`None` on missing
attributes instead of raising :exc:`AttributeError`. | def mattrgetter(*attrs):
"""Get attributes, ignoring attribute errors.
Like :func:`operator.itemgetter` but return :const:`None` on missing
attributes instead of raising :exc:`AttributeError`.
"""
return lambda obj: {attr: getattr(obj, attr, None) for attr in attrs} |
Return all unique elements in ``it``, preserving order. | def uniq(it):
"""Return all unique elements in ``it``, preserving order."""
seen = set()
return (seen.add(obj) or obj for obj in it if obj not in seen) |
Yield pairs of (current, next) items in `it`.
`next` is None if `current` is the last item.
Example:
>>> list(lookahead(x for x in range(6)))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, None)] | def lookahead(it):
"""Yield pairs of (current, next) items in `it`.
`next` is None if `current` is the last item.
Example:
>>> list(lookahead(x for x in range(6)))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, None)]
"""
a, b = tee(it)
next(b, None)
return zip_longest(a, b) |
Convert iterator to an object that can be consumed multiple times.
``Regen`` takes any iterable, and if the object is an
generator it will cache the evaluated list on first access,
so that the generator can be "consumed" multiple times. | def regen(it):
"""Convert iterator to an object that can be consumed multiple times.
``Regen`` takes any iterable, and if the object is an
generator it will cache the evaluated list on first access,
so that the generator can be "consumed" multiple times.
"""
if isinstance(it, (list, tuple)):
return it
return _regen(it) |
Generate signature function from actual function. | def head_from_fun(fun: Callable[..., Any], bound: bool = False) -> str:
"""Generate signature function from actual function."""
# we could use inspect.Signature here, but that implementation
# is very slow since it implements the argument checking
# in pure-Python. Instead we use exec to create a new function
# with an empty body, meaning it has the same performance as
# as just calling a function.
is_function = inspect.isfunction(fun)
is_callable = callable(fun)
is_cython = fun.__class__.__name__ == 'cython_function_or_method'
is_method = inspect.ismethod(fun)
if not is_function and is_callable and not is_method and not is_cython:
name, fun = fun.__class__.__name__, fun.__call__
else:
name = fun.__name__
definition = FUNHEAD_TEMPLATE.format(
fun_name=name,
fun_args=_argsfromspec(inspect.getfullargspec(fun)),
fun_value=1,
)
logger.debug(definition)
namespace = {'__name__': fun.__module__}
# pylint: disable=exec-used
# Tasks are rarely, if ever, created at runtime - exec here is fine.
exec(definition, namespace)
result = namespace[name]
result._source = definition
if bound:
return partial(result, object())
return result |
Return true if function accepts arbitrary keyword arguments. | def fun_accepts_kwargs(fun):
"""Return true if function accepts arbitrary keyword arguments."""
return any(
p for p in inspect.signature(fun).parameters.values()
if p.kind == p.VAR_KEYWORD
) |
Call typ on value if val is defined. | def maybe(typ, val):
"""Call typ on value if val is defined."""
return typ(val) if val is not None else val |
Return copy of sequence seq with item added.
Returns:
Sequence: if seq is a tuple, the result will be a tuple,
otherwise it depends on the implementation of ``__add__``. | def seq_concat_item(seq, item):
"""Return copy of sequence seq with item added.
Returns:
Sequence: if seq is a tuple, the result will be a tuple,
otherwise it depends on the implementation of ``__add__``.
"""
return seq + (item,) if isinstance(seq, tuple) else seq + [item] |
Concatenate two sequences: ``a + b``.
Returns:
Sequence: The return value will depend on the largest sequence
- if b is larger and is a tuple, the return value will be a tuple.
- if a is larger and is a list, the return value will be a list, | def seq_concat_seq(a, b):
"""Concatenate two sequences: ``a + b``.
Returns:
Sequence: The return value will depend on the largest sequence
- if b is larger and is a tuple, the return value will be a tuple.
- if a is larger and is a list, the return value will be a list,
"""
# find the type of the largest sequence
prefer = type(max([a, b], key=len))
# convert the smallest list to the type of the largest sequence.
if not isinstance(a, prefer):
a = prefer(a)
if not isinstance(b, prefer):
b = prefer(b)
return a + b |
Return object name. | def qualname(obj):
"""Return object name."""
if not hasattr(obj, '__name__') and hasattr(obj, '__class__'):
obj = obj.__class__
q = getattr(obj, '__qualname__', None)
if '.' not in q:
q = '.'.join((obj.__module__, q))
return q |
Instantiate class by name.
See Also:
:func:`symbol_by_name`. | def instantiate(name, *args, **kwargs):
"""Instantiate class by name.
See Also:
:func:`symbol_by_name`.
"""
return symbol_by_name(name)(*args, **kwargs) |
Context adding the current working directory to sys.path. | def cwd_in_path():
"""Context adding the current working directory to sys.path."""
try:
cwd = os.getcwd()
except FileNotFoundError:
cwd = None
if not cwd:
yield
elif cwd in sys.path:
yield
else:
sys.path.insert(0, cwd)
try:
yield cwd
finally:
try:
sys.path.remove(cwd)
except ValueError: # pragma: no cover
pass |
Version of :func:`imp.find_module` supporting dots. | def find_module(module, path=None, imp=None):
"""Version of :func:`imp.find_module` supporting dots."""
if imp is None:
imp = import_module
with cwd_in_path():
try:
return imp(module)
except ImportError:
# Raise a more specific error if the problem is that one of the
# dot-separated segments of the module name is not a package.
if '.' in module:
parts = module.split('.')
for i, part in enumerate(parts[:-1]):
package = '.'.join(parts[:i + 1])
try:
mpart = imp(package)
except ImportError:
# Break out and re-raise the original ImportError
# instead.
break
try:
mpart.__path__
except AttributeError:
raise NotAPackage(package)
raise |
Import module, temporarily including modules in the current directory.
Modules located in the current directory has
precedence over modules located in `sys.path`. | def import_from_cwd(module, imp=None, package=None):
"""Import module, temporarily including modules in the current directory.
Modules located in the current directory has
precedence over modules located in `sys.path`.
"""
if imp is None:
imp = import_module
with cwd_in_path():
return imp(module, package=package) |
Reload module (ensuring that CWD is in sys.path). | def reload_from_cwd(module, reloader=None):
"""Reload module (ensuring that CWD is in sys.path)."""
if reloader is None:
reloader = reload
with cwd_in_path():
return reloader(module) |
Return the correct original file name of a module. | def module_file(module):
"""Return the correct original file name of a module."""
name = module.__file__
return name[:-1] if name.endswith('.pyc') else name |
Generate task name from name/module pair. | def gen_task_name(app, name, module_name):
"""Generate task name from name/module pair."""
module_name = module_name or '__main__'
try:
module = sys.modules[module_name]
except KeyError:
# Fix for manage.py shell_plus (Issue #366)
module = None
if module is not None:
module_name = module.__name__
# - If the task module is used as the __main__ script
# - we need to rewrite the module part of the task name
# - to match App.main.
if MP_MAIN_FILE and module.__file__ == MP_MAIN_FILE:
# - see comment about :envvar:`MP_MAIN_FILE` above.
module_name = '__main__'
if module_name == '__main__' and app.main:
return '.'.join([app.main, name])
return '.'.join(p for p in (module_name, name) if p) |
Parse and convert ISO-8601 string to datetime. | def parse_iso8601(datestring: str) -> datetime:
"""Parse and convert ISO-8601 string to datetime."""
warn("parse_iso8601", "v5.3", "v6", "datetime.datetime.fromisoformat or dateutil.parser.isoparse")
m = ISO8601_REGEX.match(datestring)
if not m:
raise ValueError('unable to parse date string %r' % datestring)
groups = m.groupdict()
tz = groups['timezone']
if tz == 'Z':
tz = timezone(timedelta(0))
elif tz:
m = TIMEZONE_REGEX.match(tz)
prefix, hours, minutes = m.groups()
hours, minutes = int(hours), int(minutes)
if prefix == '-':
hours = -hours
minutes = -minutes
tz = timezone(timedelta(minutes=minutes, hours=hours))
return datetime(
int(groups['year']), int(groups['month']),
int(groups['day']), int(groups['hour'] or 0),
int(groups['minute'] or 0), int(groups['second'] or 0),
int(groups['fraction'] or 0), tz
) |
Set flag signifiying that we're inside a signal handler. | def set_in_sighandler(value):
"""Set flag signifiying that we're inside a signal handler."""
global _in_sighandler
_in_sighandler = value |
Context that records that we are in a signal handler. | def in_sighandler():
"""Context that records that we are in a signal handler."""
set_in_sighandler(True)
try:
yield
finally:
set_in_sighandler(False) |
Get logger by name. | def get_logger(name):
"""Get logger by name."""
l = _get_logger(name)
if logging.root not in (l, l.parent) and l is not base_logger:
l = _using_logger_parent(base_logger, l)
return l |
Get logger for task module by name. | def get_task_logger(name):
"""Get logger for task module by name."""
if name in RESERVED_LOGGER_NAMES:
raise RuntimeError(f'Logger name {name!r} is reserved!')
return _using_logger_parent(task_logger, get_logger(name)) |
Convert level name/int to log level. | def mlevel(level):
"""Convert level name/int to log level."""
if level and not isinstance(level, numbers.Integral):
return LOG_LEVELS[level.upper()]
return level |
Return the multiprocessing logger. | def get_multiprocessing_logger():
"""Return the multiprocessing logger."""
try:
from billiard import util
except ImportError:
pass
else:
return util.get_logger() |
Reset multiprocessing logging setup. | def reset_multiprocessing_logger():
"""Reset multiprocessing logging setup."""
try:
from billiard import util
except ImportError:
pass
else:
if hasattr(util, '_logger'): # pragma: no cover
util._logger = None |
Return the :class:`kombu.Queue` being a direct route to a worker.
Arguments:
hostname (str, ~kombu.Queue): The fully qualified node name of
a worker (e.g., ``[email protected]``). If passed a
:class:`kombu.Queue` instance it will simply return
that instead. | def worker_direct(hostname: str | Queue) -> Queue:
"""Return the :class:`kombu.Queue` being a direct route to a worker.
Arguments:
hostname (str, ~kombu.Queue): The fully qualified node name of
a worker (e.g., ``[email protected]``). If passed a
:class:`kombu.Queue` instance it will simply return
that instead.
"""
if isinstance(hostname, Queue):
return hostname
return Queue(
WORKER_DIRECT_QUEUE_FORMAT.format(hostname=hostname),
WORKER_DIRECT_EXCHANGE,
hostname,
) |
Create node name from name/hostname pair. | def nodename(name: str, hostname: str) -> str:
"""Create node name from name/hostname pair."""
return NODENAME_SEP.join((name, hostname)) |
Return the nodename for this process (not a worker).
This is used for e.g. the origin task message field. | def anon_nodename(hostname: str | None = None, prefix: str = 'gen') -> str:
"""Return the nodename for this process (not a worker).
This is used for e.g. the origin task message field.
"""
return nodename(''.join([prefix, str(os.getpid())]), hostname or gethostname()) |
Split node name into tuple of name/hostname. | def nodesplit(name: str) -> tuple[None, str] | list[str]:
"""Split node name into tuple of name/hostname."""
parts = name.split(NODENAME_SEP, 1)
if len(parts) == 1:
return None, parts[0]
return parts |
Return the default nodename for this process. | def default_nodename(hostname: str) -> str:
"""Return the default nodename for this process."""
name, host = nodesplit(hostname or '')
return nodename(name or NODENAME_DEFAULT, host or gethostname()) |
Format worker node name ([email protected]). | def node_format(s: str, name: str, **extra: dict) -> str:
"""Format worker node name ([email protected])."""
shortname, host = nodesplit(name)
return host_format(s, host, shortname or NODENAME_DEFAULT, p=name, **extra) |
Format host %x abbreviations. | def host_format(s: str, host: str | None = None, name: str | None = None, **extra: dict) -> str:
"""Format host %x abbreviations."""
host = host or gethostname()
hname, _, domain = host.partition('.')
name = name or hname
keys = dict(
{
'h': host,
'n': name,
'd': domain,
'i': _fmt_process_index,
'I': _fmt_process_index_with_prefix,
},
**extra,
)
return simple_format(s, keys) |
Return the first node by MRO order that defines an attribute.
Arguments:
cls (Any): Child class to traverse.
attr (str): Name of attribute to find.
stop (Set[Any]): A set of types that if reached will stop
the search.
monkey_patched (Sequence): Use one of the stop classes
if the attributes module origin isn't in this list.
Used to detect monkey patched attributes.
Returns:
Any: The attribute value, or :const:`None` if not found. | def mro_lookup(cls, attr, stop=None, monkey_patched=None):
"""Return the first node by MRO order that defines an attribute.
Arguments:
cls (Any): Child class to traverse.
attr (str): Name of attribute to find.
stop (Set[Any]): A set of types that if reached will stop
the search.
monkey_patched (Sequence): Use one of the stop classes
if the attributes module origin isn't in this list.
Used to detect monkey patched attributes.
Returns:
Any: The attribute value, or :const:`None` if not found.
"""
stop = set() if not stop else stop
monkey_patched = [] if not monkey_patched else monkey_patched
for node in cls.mro():
if node in stop:
try:
value = node.__dict__[attr]
module_origin = value.__module__
except (AttributeError, KeyError):
pass
else:
if module_origin not in monkey_patched:
return node
return
if attr in node.__dict__:
return node |
Safe version of :func:`repr`.
Warning:
Make sure you set the maxlen argument, or it will be very slow
for recursive objects. With the maxlen set, it's often faster
than built-in repr. | def saferepr(o, maxlen=None, maxlevels=3, seen=None):
# type: (Any, int, int, Set) -> str
"""Safe version of :func:`repr`.
Warning:
Make sure you set the maxlen argument, or it will be very slow
for recursive objects. With the maxlen set, it's often faster
than built-in repr.
"""
return ''.join(_saferepr(
o, maxlen=maxlen, maxlevels=maxlevels, seen=seen
)) |
Streaming repr, yielding tokens. | def reprstream(stack: deque,
seen: Optional[Set] = None,
maxlevels: int = 3,
level: int = 0,
isinstance: Callable = isinstance) -> Iterator[Any]:
"""Streaming repr, yielding tokens."""
seen = seen or set()
append = stack.append
popleft = stack.popleft
is_in_seen = seen.__contains__
discard_from_seen = seen.discard
add_to_seen = seen.add
while stack:
lit_start = lit_end = None
it = popleft()
for val in it:
orig = val
if isinstance(val, _dirty):
discard_from_seen(val.objid)
continue
elif isinstance(val, _literal):
level += val.direction
yield val, it
elif isinstance(val, _key):
yield val, it
elif isinstance(val, Decimal):
yield _repr(val), it
elif isinstance(val, safe_t):
yield str(val), it
elif isinstance(val, chars_t):
yield _quoted(val), it
elif isinstance(val, range): # pragma: no cover
yield _repr(val), it
else:
if isinstance(val, set_t):
if not val:
yield _repr_empty_set(val), it
continue
lit_start, lit_end, val = _reprseq(
val, LIT_SET_START, LIT_SET_END, set, _chainlist,
)
elif isinstance(val, tuple):
lit_start, lit_end, val = (
LIT_TUPLE_START,
LIT_TUPLE_END_SV if len(val) == 1 else LIT_TUPLE_END,
_chainlist(val))
elif isinstance(val, dict):
lit_start, lit_end, val = (
LIT_DICT_START, LIT_DICT_END, _chaindict(val))
elif isinstance(val, list):
lit_start, lit_end, val = (
LIT_LIST_START, LIT_LIST_END, _chainlist(val))
else:
# other type of object
yield _repr(val), it
continue
if maxlevels and level >= maxlevels:
yield f'{lit_start.value}...{lit_end.value}', it
continue
objid = id(orig)
if is_in_seen(objid):
yield _recursion(orig), it
continue
add_to_seen(objid)
# Recurse into the new list/tuple/dict/etc by tacking
# the rest of our iterable onto the new it: this way
# it works similar to a linked list.
append(chain([lit_start], val, [_dirty(objid), lit_end], it))
break |
Create new exception class. | def subclass_exception(name, parent, module):
"""Create new exception class."""
return type(name, (parent,), {'__module__': module}) |
Find first pickleable exception base class.
With an exception instance, iterate over its super classes (by MRO)
and find the first super exception that's pickleable. It does
not go below :exc:`Exception` (i.e., it skips :exc:`Exception`,
:class:`BaseException` and :class:`object`). If that happens
you should use :exc:`UnpickleableException` instead.
Arguments:
exc (BaseException): An exception instance.
loads: decoder to use.
dumps: encoder to use
Returns:
Exception: Nearest pickleable parent exception class
(except :exc:`Exception` and parents), or if the exception is
pickleable it will return :const:`None`. | def find_pickleable_exception(exc, loads=pickle.loads,
dumps=pickle.dumps):
"""Find first pickleable exception base class.
With an exception instance, iterate over its super classes (by MRO)
and find the first super exception that's pickleable. It does
not go below :exc:`Exception` (i.e., it skips :exc:`Exception`,
:class:`BaseException` and :class:`object`). If that happens
you should use :exc:`UnpickleableException` instead.
Arguments:
exc (BaseException): An exception instance.
loads: decoder to use.
dumps: encoder to use
Returns:
Exception: Nearest pickleable parent exception class
(except :exc:`Exception` and parents), or if the exception is
pickleable it will return :const:`None`.
"""
exc_args = getattr(exc, 'args', [])
for supercls in itermro(exc.__class__, unwanted_base_classes):
try:
superexc = supercls(*exc_args)
loads(dumps(superexc))
except Exception: # pylint: disable=broad-except
pass
else:
return superexc |
Dynamically create an exception class. | def create_exception_cls(name, module, parent=None):
"""Dynamically create an exception class."""
if not parent:
parent = Exception
return subclass_exception(name, parent, module) |
Ensure items will serialize.
For a given list of arbitrary objects, return the object
or a string representation, safe for serialization.
Arguments:
items (Iterable[Any]): Objects to serialize.
encoder (Callable): Callable function to serialize with. | def ensure_serializable(items, encoder):
"""Ensure items will serialize.
For a given list of arbitrary objects, return the object
or a string representation, safe for serialization.
Arguments:
items (Iterable[Any]): Objects to serialize.
encoder (Callable): Callable function to serialize with.
"""
safe_exc_args = []
for arg in items:
try:
encoder(arg)
safe_exc_args.append(arg)
except Exception: # pylint: disable=broad-except
safe_exc_args.append(safe_repr(arg))
return tuple(safe_exc_args) |
Make sure exception is pickleable. | def get_pickleable_exception(exc):
"""Make sure exception is pickleable."""
try:
pickle.loads(pickle.dumps(exc))
except Exception: # pylint: disable=broad-except
pass
else:
return exc
nearest = find_pickleable_exception(exc)
if nearest:
return nearest
return UnpickleableExceptionWrapper.from_exception(exc) |
Get pickleable exception type. | def get_pickleable_etype(cls, loads=pickle.loads, dumps=pickle.dumps):
"""Get pickleable exception type."""
try:
loads(dumps(cls))
except Exception: # pylint: disable=broad-except
return Exception
else:
return cls |
Reverse of :meth:`get_pickleable_exception`. | def get_pickled_exception(exc):
"""Reverse of :meth:`get_pickleable_exception`."""
if isinstance(exc, UnpickleableExceptionWrapper):
return exc.restore()
return exc |
Convert common terms for true/false to bool.
Examples (true/false/yes/no/on/off/1/0). | def strtobool(term, table=None):
"""Convert common terms for true/false to bool.
Examples (true/false/yes/no/on/off/1/0).
"""
if table is None:
table = STRTOBOOL_DEFAULT_TABLE
if isinstance(term, str):
try:
return table[term.lower()]
except KeyError:
raise TypeError(f'Cannot coerce {term!r} to type bool')
return term |
Transform object making it suitable for json serialization. | def jsonify(obj,
builtin_types=(numbers.Real, str), key=None,
keyfilter=None,
unknown_type_filter=None):
"""Transform object making it suitable for json serialization."""
from kombu.abstract import Object as KombuDictType
_jsonify = partial(jsonify, builtin_types=builtin_types, key=key,
keyfilter=keyfilter,
unknown_type_filter=unknown_type_filter)
if isinstance(obj, KombuDictType):
obj = obj.as_dict(recurse=True)
if obj is None or isinstance(obj, builtin_types):
return obj
elif isinstance(obj, (tuple, list)):
return [_jsonify(v) for v in obj]
elif isinstance(obj, dict):
return {
k: _jsonify(v, key=k) for k, v in obj.items()
if (keyfilter(k) if keyfilter else 1)
}
elif isinstance(obj, (datetime.date, datetime.time)):
return _datetime_to_json(obj)
elif isinstance(obj, datetime.timedelta):
return str(obj)
else:
if unknown_type_filter is None:
raise ValueError(
f'Unsupported type: {type(obj)!r} {obj!r} (parent: {key})'
)
return unknown_type_filter(obj) |
Return system load average as a triple. | def load_average() -> tuple[float, ...]:
"""Return system load average as a triple."""
return _load_average() |
Convert string to list. | def str_to_list(s: str) -> list[str]:
"""Convert string to list."""
if isinstance(s, str):
return s.split(',')
return s |
Remove indentation from first line of text. | def dedent_initial(s: str, n: int = 4) -> str:
"""Remove indentation from first line of text."""
return s[n:] if s[:n] == ' ' * n else s |
Remove indentation. | def dedent(s: str, sep: str = '\n') -> str:
"""Remove indentation."""
return sep.join(dedent_initial(l) for l in s.splitlines()) |
Fill paragraphs with newlines (or custom separator). | def fill_paragraphs(s: str, width: int, sep: str = '\n') -> str:
"""Fill paragraphs with newlines (or custom separator)."""
return sep.join(fill(p, width) for p in s.split(sep)) |
Concatenate list of strings. | def join(l: list[str], sep: str = '\n') -> str:
"""Concatenate list of strings."""
return sep.join(v for v in l if v) |
Ensure text s ends in separator sep'. | def ensure_sep(sep: str, s: str, n: int = 2) -> str:
"""Ensure text s ends in separator sep'."""
return s + sep * (n - s.count(sep)) |
Abbreviate word. | def abbr(S: str, max: int, ellipsis: str | bool = '...') -> str:
"""Abbreviate word."""
if S is None:
return '???'
if len(S) > max:
return isinstance(ellipsis, str) and (
S[: max - len(ellipsis)] + ellipsis) or S[: max]
return S |
Abbreviate task name. | def abbrtask(S: str, max: int) -> str:
"""Abbreviate task name."""
if S is None:
return '???'
if len(S) > max:
module, _, cls = S.rpartition('.')
module = abbr(module, max - len(cls) - 3, False)
return module + '[.]' + cls
return S |
Indent text. | def indent(t: str, indent: int = 0, sep: str = '\n') -> str:
"""Indent text."""
return sep.join(' ' * indent + p for p in t.split(sep)) |
Truncate text to a maximum number of characters. | def truncate(s: str, maxlen: int = 128, suffix: str = '...') -> str:
"""Truncate text to a maximum number of characters."""
if maxlen and len(s) >= maxlen:
return s[:maxlen].rsplit(' ', 1)[0] + suffix
return s |
Pluralize term when n is greater than one. | def pluralize(n: float, text: str, suffix: str = 's') -> str:
"""Pluralize term when n is greater than one."""
if n != 1:
return text + suffix
return text |
Format value for printing to console. | def pretty(value: str, width: int = 80, nl_width: int = 80, sep: str = '\n', **
kw: Any) -> str:
"""Format value for printing to console."""
if isinstance(value, dict):
return f'{sep} {pformat(value, 4, nl_width)[1:]}'
elif isinstance(value, tuple):
return '{}{}{}'.format(
sep, ' ' * 4, pformat(value, width=nl_width, **kw),
)
else:
return pformat(value, width=width, **kw) |
Format string, expanding abbreviations in keys'. | def simple_format(
s: str, keys: dict[str, str | Callable],
pattern: Pattern[str] = RE_FORMAT, expand: str = r'\1') -> str:
"""Format string, expanding abbreviations in keys'."""
if s:
keys.setdefault('%', '%')
def resolve(match: Match) -> str | Any:
key = match.expand(expand)
try:
resolver = keys[key]
except KeyError:
raise ValueError(UNKNOWN_SIMPLE_FORMAT_KEY.format(key, s))
if callable(resolver):
return resolver()
return resolver
return pattern.sub(resolve, s)
return s |
Given task name, remove repeating module names.
Example:
>>> remove_repeating_from_task(
... 'tasks.add',
... 'tasks.add(2, 2), tasks.mul(3), tasks.div(4)')
'tasks.add(2, 2), mul(3), div(4)' | def remove_repeating_from_task(task_name: str, s: str) -> str:
"""Given task name, remove repeating module names.
Example:
>>> remove_repeating_from_task(
... 'tasks.add',
... 'tasks.add(2, 2), tasks.mul(3), tasks.div(4)')
'tasks.add(2, 2), mul(3), div(4)'
"""
# This is used by e.g. repr(chain), to remove repeating module names.
# - extract the module part of the task name
module = str(task_name).rpartition('.')[0] + '.'
return remove_repeating(module, s) |
Remove repeating module names from string.
Arguments:
task_name (str): Task name (full path including module),
to use as the basis for removing module names.
s (str): The string we want to work on.
Example:
>>> _shorten_names(
... 'x.tasks.add',
... 'x.tasks.add(2, 2) | x.tasks.add(4) | x.tasks.mul(8)',
... )
'x.tasks.add(2, 2) | add(4) | mul(8)' | def remove_repeating(substr: str, s: str) -> str:
"""Remove repeating module names from string.
Arguments:
task_name (str): Task name (full path including module),
to use as the basis for removing module names.
s (str): The string we want to work on.
Example:
>>> _shorten_names(
... 'x.tasks.add',
... 'x.tasks.add(2, 2) | x.tasks.add(4) | x.tasks.mul(8)',
... )
'x.tasks.add(2, 2) | add(4) | mul(8)'
"""
# find the first occurrence of substr in the string.
index = s.find(substr)
if index >= 0:
return ''.join([
# leave the first occurrence of substr untouched.
s[:index + len(substr)],
# strip seen substr from the rest of the string.
s[index + len(substr):].replace(substr, ''),
])
return s |
Context temporarily setting the default socket timeout. | def default_socket_timeout(timeout):
"""Context temporarily setting the default socket timeout."""
prev = socket.getdefaulttimeout()
socket.setdefaulttimeout(timeout)
yield
socket.setdefaulttimeout(prev) |
Release the contents of the local for the current context.
This makes it possible to use locals without a manager.
With this function one can release :class:`Local` objects as well as
:class:`StackLocal` objects. However it's not possible to
release data held by proxies that way, one always has to retain
a reference to the underlying local object in order to be able
to release it.
Example:
>>> loc = Local()
>>> loc.foo = 42
>>> release_local(loc)
>>> hasattr(loc, 'foo')
False | def release_local(local):
"""Release the contents of the local for the current context.
This makes it possible to use locals without a manager.
With this function one can release :class:`Local` objects as well as
:class:`StackLocal` objects. However it's not possible to
release data held by proxies that way, one always has to retain
a reference to the underlying local object in order to be able
to release it.
Example:
>>> loc = Local()
>>> loc.foo = 42
>>> release_local(loc)
>>> hasattr(loc, 'foo')
False
"""
local.__release_local__() |
Convert integer to timedelta, if argument is an integer. | def maybe_timedelta(delta: int) -> timedelta:
"""Convert integer to timedelta, if argument is an integer."""
if isinstance(delta, numbers.Real):
return timedelta(seconds=delta)
return delta |
Round a :class:`~datetime.datetime` to the resolution of timedelta.
If the :class:`~datetime.timedelta` is in days, the
:class:`~datetime.datetime` will be rounded to the nearest days,
if the :class:`~datetime.timedelta` is in hours the
:class:`~datetime.datetime` will be rounded to the nearest hour,
and so on until seconds, which will just return the original
:class:`~datetime.datetime`. | def delta_resolution(dt: datetime, delta: timedelta) -> datetime:
"""Round a :class:`~datetime.datetime` to the resolution of timedelta.
If the :class:`~datetime.timedelta` is in days, the
:class:`~datetime.datetime` will be rounded to the nearest days,
if the :class:`~datetime.timedelta` is in hours the
:class:`~datetime.datetime` will be rounded to the nearest hour,
and so on until seconds, which will just return the original
:class:`~datetime.datetime`.
"""
delta = max(delta.total_seconds(), 0)
resolutions = ((3, lambda x: x / 86400),
(4, lambda x: x / 3600),
(5, lambda x: x / 60))
args = dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second
for res, predicate in resolutions:
if predicate(delta) >= 1.0:
return datetime(*args[:res], tzinfo=dt.tzinfo)
return dt |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.