def test_more_unicode(self):
c = colored()
s = c.red('foo', c.blue('bar'), c.green('baz'))
assert s.no_color()
c._fold_no_color(s, 'øfoo')
c._fold_no_color('fooå', s)
c = colored().red('åfoo')
assert c._add(c, 'baræ') == '\x1b[1;31m\xe5foo\x1b[0mbar\xe6'
c2 = colored().blue('ƒƒz')
c3 = c._add(c, c2)
assert c3 == '\x1b[1;31m\xe5foo\x1b[0m\x1b[1;34m\u0192\u0192z\x1b[0m'
def execute_from_commandline(self, argv, cmd="celeryd"):
argv = list(argv) # don't modify callers argv.
# Reserve the --nosplash|--quiet|-q/--verbose options.
self.nosplash = False
self.quiet = False
self.verbose = False
self.no_color = False
if "--nosplash" in argv:
self.nosplash = argv.pop(argv.index("--nosplash"))
if "--quiet" in argv:
self.quiet = argv.pop(argv.index("--quiet"))
if "-q" in argv:
self.quiet = argv.pop(argv.index("-q"))
if "--verbose" in argv:
self.verbose = argv.pop(argv.index("--verbose"))
if "--no-color" in argv:
self.no_color = argv.pop(argv.index("--no-color"))
self.colored = term.colored(enabled=not self.no_color)
self.OK = str(self.colored.green("OK"))
self.FAILED = str(self.colored.red("FAILED"))
self.DOWN = str(self.colored.magenta("DOWN"))
self.prog_name = os.path.basename(argv.pop(0))
if len(argv) == 0 or argv[0][0] == "-":
return self.error()
try:
self.commands[argv[0]](argv[1:], cmd)
except KeyError:
self.error("Invalid command: %s" % argv[0])
return self.retcode
def __init__(
self,
loglevel=None,
logfile=None,
schedule=None,
max_interval=None,
scheduler_cls=None,
defaults=None,
socket_timeout=30,
redirect_stdouts=None,
redirect_stdouts_level=None,
**kwargs
):
"""Starts the celerybeat task scheduler."""
if defaults is None:
from celery import conf as defaults
self.defaults = defaults
self.loglevel = loglevel or defaults.CELERYBEAT_LOG_LEVEL
self.logfile = logfile or defaults.CELERYBEAT_LOG_FILE
self.schedule = schedule or defaults.CELERYBEAT_SCHEDULE_FILENAME
self.scheduler_cls = scheduler_cls or defaults.CELERYBEAT_SCHEDULER
self.max_interval = max_interval
self.socket_timeout = socket_timeout
self.colored = term.colored(enabled=defaults.CELERYD_LOG_COLOR)
self.redirect_stdouts = redirect_stdouts or defaults.REDIRECT_STDOUTS
self.redirect_stdouts_level = redirect_stdouts_level or defaults.REDIRECT_STDOUTS_LEVEL
if not isinstance(self.loglevel, int):
self.loglevel = LOG_LEVELS[self.loglevel.upper()]
def __init__(self, app=None, no_color=False, stdout=sys.stdout,
stderr=sys.stderr):
super(Command, self).__init__(app=app)
self.colored = term.colored(enabled=not no_color)
self.stdout = stdout
self.stderr = stderr
self.quiet = False
def say(self, direction, title, body=""):
if direction == "<-" and self.quiet:
return
dirstr = not self.quiet and t.bold(t.white(direction), " ") or ""
print(t.colored(dirstr, title))
if body and not self.quiet:
print(body)
def __init__(self, app, no_color=False, **kwargs):
self.app = app
self._init_manager(app, **kwargs)
if not isatty(self.stdout):
no_color = True
self.colored = colored(enabled=not no_color)
self.init_groups()
def __init__(self, app=None, no_color=False, stdout=sys.stdout, stderr=sys.stderr, show_reply=True):
super(Command, self).__init__(app=app)
self.colored = term.colored(enabled=not no_color)
self.stdout = stdout
self.stderr = stderr
self.quiet = False
if show_reply is not None:
self.show_reply = show_reply
def run_from_argv(self, prog_name, argv):
self.prog_name = prog_name
self.command = argv[0]
self.arglist = argv[1:]
self.parser = self.create_parser(self.prog_name, self.command)
options, args = self.parser.parse_args(self.arglist)
self.colored = term.colored(enabled=not options.no_color)
return self(*args, **options.__dict__)
def __init__(self, concurrency=None, loglevel=None, logfile=None,
hostname=None, discard=False, run_clockservice=False,
schedule=None, task_time_limit=None, task_soft_time_limit=None,
max_tasks_per_child=None, queues=None, events=False, db=None,
include=None, app=None, pidfile=None,
redirect_stdouts=None, redirect_stdouts_level=None,
autoscale=None, scheduler_cls=None, pool=None, **kwargs):
self.app = app = app_or_default(app)
self.concurrency = (concurrency or
app.conf.CELERYD_CONCURRENCY or
multiprocessing.cpu_count())
self.loglevel = loglevel or app.conf.CELERYD_LOG_LEVEL
self.logfile = logfile or app.conf.CELERYD_LOG_FILE
app.conf.CELERYD_LOG_COLOR = not self.logfile and isatty(sys.stderr)
self.hostname = hostname or socket.gethostname()
self.discard = discard
self.run_clockservice = run_clockservice
self.schedule = schedule or app.conf.CELERYBEAT_SCHEDULE_FILENAME
self.scheduler_cls = scheduler_cls or app.conf.CELERYBEAT_SCHEDULER
self.events = events
self.task_time_limit = (task_time_limit or
app.conf.CELERYD_TASK_TIME_LIMIT)
self.task_soft_time_limit = (task_soft_time_limit or
app.conf.CELERYD_TASK_SOFT_TIME_LIMIT)
self.max_tasks_per_child = (max_tasks_per_child or
app.conf.CELERYD_MAX_TASKS_PER_CHILD)
self.redirect_stdouts = (redirect_stdouts or
app.conf.CELERY_REDIRECT_STDOUTS)
self.redirect_stdouts_level = (redirect_stdouts_level or
app.conf.CELERY_REDIRECT_STDOUTS_LEVEL)
self.pool = (pool or app.conf.CELERYD_POOL)
self.db = db
self.use_queues = queues or []
self.queues = None
self.include = include or []
self.pidfile = pidfile
self.autoscale = None
if autoscale:
max_c, _, min_c = partition(autoscale, ",")
self.autoscale = [int(max_c), min_c and int(min_c) or 0]
self._isatty = sys.stdout.isatty()
self.colored = term.colored(enabled=app.conf.CELERYD_LOG_COLOR)
if isinstance(self.use_queues, basestring):
self.use_queues = self.use_queues.split(",")
if isinstance(self.include, basestring):
self.include = self.include.split(",")
if not isinstance(self.loglevel, int):
try:
self.loglevel = LOG_LEVELS[self.loglevel.upper()]
except KeyError:
self.die("Unknown level %r. Please use one of %s." % (
self.loglevel,
"|".join(l for l in LOG_LEVELS.keys()
if isinstance(l, basestring))))
def run_from_argv(self, prog_name, argv):
self.prog_name = prog_name
self.command = argv[0]
self.arglist = argv[1:]
self.parser = self.create_parser(self.prog_name, self.command)
options, args = self.prepare_args(*self.parser.parse_args(self.arglist))
self.colored = term.colored(enabled=not options["no_color"])
self.quiet = options.get("quiet", False)
self.show_body = options.get("show_body", True)
return self(*args, **options)
def get_command_info(self, command, indent=0, color=None):
colored = term.colored().names[color] if color else lambda x: x
obj = self.commands[command]
if obj.leaf:
return '|' + text.indent("celery %s" % colored(command), indent)
return text.join([
" ",
'|' + text.indent("celery %s --help" % colored(command), indent),
obj.list_commands(indent, "celery %s" % command, colored),
])
def list_commands(self, indent=0, colored=None):
colored = term.colored() if colored is None else colored
white = colored.white
ret = []
for cls, commands, color in command_classes:
ret.extend([
text.indent('+ {0}: '.format(white(cls)), indent), '\n'.join(
self.get_command_info(command, indent + 4, color, colored)
for command in commands), ''
])
return '\n'.join(ret).strip()
def get_command_info(self, command, indent=0, color=None):
colored = term.colored().names[color] if color else lambda x: x
obj = self.commands[command]
cmd = 'celery {0}'.format(colored(command))
if obj.leaf:
return '|' + text.indent(cmd, indent)
return text.join([
' ',
'|' + text.indent('{0} --help'.format(cmd), indent),
obj.list_commands(indent, 'celery {0}'.format(command), colored),
])
def format(self, record):
levelname = record.levelname
if self.use_color and levelname in COLORS:
record.msg = term.colored(COLORS[levelname](record.msg))
# Very ugly, but have to make sure processName is supported
# by foreign logger instances.
# (processName is always supported by Python 2.7)
if "processName" not in record.__dict__:
record.__dict__["processName"] = current_process()._name
return logging.Formatter.format(self, record)
def get_command_info(self, command, indent=0, color=None):
colored = term.colored().names[color] if color else lambda x: x
obj = self.commands[command]
cmd = 'celery {0}'.format(colored(command))
if obj.leaf:
return '|' + text.indent(cmd, indent)
return text.join([
' ',
'|' + text.indent('{0} --help'.format(cmd), indent),
obj.list_commands(indent, 'celery {0}'.format(command), colored),
])
def list_commands(self, indent=0):
white = term.colored().white
ret = []
for cls, commands, color in command_classes:
ret.extend([
text.indent("+ %s: " % white(cls), indent),
"\n".join(self.get_command_info(command, indent + 4, color)
for command in commands),
""
])
return "\n".join(ret).strip()
def list_commands(self, indent=0):
white = term.colored().white
ret = []
for cls, commands, color in command_classes:
ret.extend([
text.indent('+ {0}: '.format(white(cls)), indent),
'\n'.join(self.get_command_info(command, indent + 4, color)
for command in commands),
''
])
return '\n'.join(ret).strip()
def __init__(self, app=None, get_app=None, no_color=False,
stdout=None, stderr=None, quiet=False):
self.app = app
self.get_app = get_app or self._get_default_app
self.stdout = stdout or sys.stdout
self.stderr = stderr or sys.stderr
self.no_color = no_color
self.colored = term.colored(enabled=not self.no_color)
self.quiet = quiet
if not self.description:
self.description = self.__doc__
class ColorFormatter(CeleryColorFormatter):
"""Logging formatter that adds colors based on severity."""
#: Loglevel -> Color mapping.
COLORS = colored().names
colors = {
u'DEBUG': COLORS[u'blue'],
u'WARNING': COLORS[u'yellow'],
u'WARN': COLORS[u'yellow'],
u'ERROR': COLORS[u'red'],
u'CRITICAL': COLORS[u'magenta']
}
def run_from_argv(self, argv):
self.prog_name = os.path.basename(argv[0])
self.command = argv[1]
self.arglist = argv[2:]
self.parser = self.create_parser(self.prog_name, self.command)
options, args = self.parser.parse_args(self.arglist)
if options.loader:
os.environ["CELERY_LOADER"] = options.loader
if options.conf:
os.environ["CELERY_CONFIG_MODULE"] = options.conf
self.colored = term.colored(enabled=not options.no_color)
self(*args, **options.__dict__)
class ColorFormatter(CeleryColorFormatter):
#: Loglevel -> Color mapping.
COLORS = colored().names
colors = {
'DEBUG': COLORS['blue'],
'WARNING': COLORS['yellow'],
'WARN': COLORS['yellow'],
'ERROR': COLORS['red'],
'CRITICAL': COLORS['magenta'],
'TEST': COLORS['green'],
'TESTPLAN': COLORS['cyan']
}
def run_from_argv(self, argv):
self.prog_name = os.path.basename(argv[0])
self.command = argv[1]
self.arglist = argv[2:]
self.parser = self.create_parser(self.prog_name, self.command)
options, args = self.parser.parse_args(self.arglist)
if options.loader:
os.environ["CELERY_LOADER"] = options.loader
if options.conf:
os.environ["CELERY_CONFIG_MODULE"] = options.conf
self.colored = term.colored(enabled=not options.no_color)
self(*args, **options.__dict__)
def get_command_info(self, command, indent=0, color=None):
colored = term.colored().names[color] if color else lambda x: x
obj = self.commands[command]
cmd = "celery {0}".format(colored(command))
if obj.leaf:
return "|" + text.indent(cmd, indent)
return text.join(
[
" ",
"|" + text.indent("{0} --help".format(cmd), indent),
obj.list_commands(indent, "celery {0}".format(command), colored),
]
)
def __init__(self,
app=None,
no_color=False,
stdout=sys.stdout,
stderr=sys.stderr,
show_reply=True):
super(Command, self).__init__(app=app)
self.colored = term.colored(enabled=not no_color)
self.stdout = stdout
self.stderr = stderr
self.quiet = False
if show_reply is not None:
self.show_reply = show_reply
def list_commands(self, indent=0, colored=None):
colored = term.colored() if colored is None else colored
white = colored.white
ret = []
for cls, commands, color in command_classes:
ret.extend([
text.indent('+ {0}: '.format(white(cls)), indent),
'\n'.join(
self.get_command_info(command, indent + 4, color, colored)
for command in commands),
''
])
return '\n'.join(ret).strip()
def get_command_info(cls, command, indent=0,
color=None, colored=None, app=None):
colored = term.colored() if colored is None else colored
colored = colored.names[color] if color else lambda x: x
obj = cls.commands[command]
cmd = 'celery {0}'.format(colored(command))
if obj.leaf:
return '|' + text.indent(cmd, indent)
return text.join([
' ',
'|' + text.indent('{0} --help'.format(cmd), indent),
obj.list_commands(indent, 'celery {0}'.format(command), colored,
app=app),
])
def __init__(self, concurrency=None, loglevel=None, logfile=None,
hostname=None, discard=False, run_clockservice=False,
schedule=None, task_time_limit=None, task_soft_time_limit=None,
max_tasks_per_child=None, queues=None, events=False, db=None,
include=None, defaults=None, pidfile=None,
redirect_stdouts=None, redirect_stdouts_level=None, **kwargs):
if defaults is None:
from celery import conf
defaults = conf
self.defaults = defaults
self.concurrency = (concurrency or
defaults.CELERYD_CONCURRENCY or
multiprocessing.cpu_count())
self.loglevel = loglevel or defaults.CELERYD_LOG_LEVEL
self.logfile = logfile or defaults.CELERYD_LOG_FILE
self.hostname = hostname or socket.gethostname()
self.discard = discard
self.run_clockservice = run_clockservice
self.schedule = schedule or defaults.CELERYBEAT_SCHEDULE_FILENAME
self.events = events
self.task_time_limit = (task_time_limit or
defaults.CELERYD_TASK_TIME_LIMIT)
self.task_soft_time_limit = (task_soft_time_limit or
defaults.CELERYD_TASK_SOFT_TIME_LIMIT)
self.max_tasks_per_child = (max_tasks_per_child or
defaults.CELERYD_MAX_TASKS_PER_CHILD)
self.redirect_stdouts = (redirect_stdouts or
defaults.REDIRECT_STDOUTS)
self.redirect_stdouts_level = (redirect_stdouts_level or
defaults.REDIRECT_STDOUTS_LEVEL)
self.db = db
self.queues = queues or []
self.include = include or []
self.pidfile = pidfile
self._isatty = sys.stdout.isatty()
self.colored = term.colored(enabled=defaults.CELERYD_LOG_COLOR)
if isinstance(self.queues, basestring):
self.queues = self.queues.split(",")
if isinstance(self.include, basestring):
self.include = self.include.split(",")
if not isinstance(self.loglevel, int):
try:
self.loglevel = LOG_LEVELS[self.loglevel.upper()]
except KeyError:
self.die("Unknown level %r. Please use one of %s." % (
self.loglevel,
"|".join(l for l in LOG_LEVELS.keys()
if isinstance(l, basestring))))
def __init__(self,
addrport='',
id=None,
loglevel=logging.INFO,
logfile=None,
without_httpd=False,
numc=2,
sup_interval=None,
ready_event=None,
colored=None,
**kwargs):
self.id = id or gen_unique_id()
if isinstance(addrport, basestring):
addr, _, port = addrport.partition(':')
addrport = (addr, int(port) if port else 8000)
self.addrport = addrport
self.connection = celery.broker_connection()
self.without_httpd = without_httpd
self.logfile = logfile
self.loglevel = loglevel
self.numc = numc
self.ready_event = ready_event
self.exit_request = Event()
self.colored = colored or term.colored(enabled=False)
self.httpd = None
gSup = find_symbol(self, self.intsup_cls)
if not self.without_httpd:
self.httpd = MockSup(instantiate(self, self.httpd_cls, addrport),
signals.httpd_ready)
self.supervisor = gSup(
instantiate(self, self.supervisor_cls, sup_interval),
signals.supervisor_ready)
self.controllers = [
gSup(
instantiate(self,
self.controller_cls,
id='%s.%s' % (self.id, i),
connection=self.connection,
branch=self), signals.controller_ready)
for i in xrange(1, numc + 1)
]
c = [self.supervisor] + self.controllers + [self.httpd]
c = self.components = list(filter(None, c))
self._components_ready = dict(
zip([z.thread for z in c], [False] * len(c)))
for controller in self.controllers:
if hasattr(controller.thread, 'presence'):
self._components_ready[controller.thread.presence] = False
self._components_shutdown = dict(self._components_ready)
super(Branch, self).__init__()
def __init__(self, app,
block_timeout=30 * 60, no_color=False,
stdout=None, stderr=None):
self.app = app
self.stdout = sys.stdout if stdout is None else stdout
self.stderr = sys.stderr if stderr is None else stderr
if not isatty(self.stdout):
no_color = True
self.colored = colored(enabled=not no_color)
self.connerrors = self.app.connection().recoverable_connection_errors
self.block_timeout = block_timeout
self.progress = None
self.speaker = Speaker(file=self.stdout)
self.fbi = FBI(app)
self.init_groups()
def format(self, record):
levelname = record.levelname
if self.use_color and levelname in COLORS:
record.msg = unicode(colored().names[COLORS[levelname]](record.msg))
# Very ugly, but have to make sure processName is supported
# by foreign logger instances.
# (processName is always supported by Python 2.7)
if "processName" not in record.__dict__:
record.__dict__["processName"] = current_process()._name
t = logging.Formatter.format(self, record)
if type(t) in [types.UnicodeType]:
t = t.encode('utf-8', 'replace')
return t
def format(self, record):
levelname = record.levelname
if self.use_color and levelname in COLORS:
record.msg = unicode(colored().names[COLORS[levelname]](
record.msg))
# Very ugly, but have to make sure processName is supported
# by foreign logger instances.
# (processName is always supported by Python 2.7)
if "processName" not in record.__dict__:
record.__dict__["processName"] = current_process()._name
t = logging.Formatter.format(self, record)
if type(t) in [types.UnicodeType]:
t = t.encode('utf-8', 'replace')
return t
def __init__(self, app=None, get_app=None, no_color=False,
stdout=None, stderr=None, quiet=False, on_error=None,
on_usage_error=None):
self.app = app
self.get_app = get_app or self._get_default_app
self.stdout = stdout or sys.stdout
self.stderr = stderr or sys.stderr
self.no_color = no_color
self.colored = term.colored(enabled=not self.no_color)
self.quiet = quiet
if not self.description:
self.description = self.__doc__
if on_error:
self.on_error = on_error
if on_usage_error:
self.on_usage_error = on_usage_error
def __init__(self,
app,
block_timeout=30 * 60,
no_color=False,
stdout=None,
stderr=None):
self.app = app
self.stdout = sys.stdout if stdout is None else stdout
self.stderr = sys.stderr if stderr is None else stderr
if not isatty(self.stdout):
no_color = True
self.colored = colored(enabled=not no_color)
self.connerrors = self.app.connection().recoverable_connection_errors
self.block_timeout = block_timeout
self.progress = None
self.speaker = Speaker(file=self.stdout)
self.fbi = FBI(app)
self.init_groups()
class ExtTaskFormatter(ColorFormatter):
COLORS = colored().names
colors = {
'DEBUG': COLORS['blue'],
'WARNING': COLORS['yellow'],
'ERROR': COLORS['red'],
'CRITICAL': COLORS['magenta']
}
def format(self, record):
task = get_current_task()
if task and task.request:
name = task.name.split(u'.')[-1]
record.__dict__.update(task_id=task.request.id, task_name=name)
else:
record.__dict__.update(task_id=u'xxx', task_name=u'xxx')
#record.__dict__.setdefault('task_name', '???')
#record.__dict__.setdefault('task_id', '???')
return ColorFormatter.format(self, record)
class ColorFormatter(logging.Formatter):
#: Loglevel -> Color mapping.
COLORS = colored().names
colors = {
"DEBUG": COLORS["blue"],
"WARNING": COLORS["yellow"],
"ERROR": COLORS["red"],
"CRITICAL": COLORS["magenta"]
}
def __init__(self, msg, use_color=True):
logging.Formatter.__init__(self, msg)
self.use_color = use_color
def formatException(self, ei):
r = logging.Formatter.formatException(self, ei)
if isinstance(r, str):
return r.decode("utf-8", "replace") # Convert to unicode
return r
def format(self, record):
levelname = record.levelname
color = self.colors.get(levelname)
if self.use_color and color:
try:
record.msg = str(color(safe_str(record.msg)))
except Exception, exc:
record.msg = "<Unrepresentable %r: %r>" % (type(
record.msg), exc)
record.exc_info = sys.exc_info()
# Very ugly, but have to make sure processName is supported
# by foreign logger instances.
# (processName is always supported by Python 2.7)
if "processName" not in record.__dict__:
process_name = current_process and current_process()._name or ""
record.__dict__["processName"] = process_name
t = logging.Formatter.format(self, record)
if isinstance(t, unicode):
return t.encode("utf-8", "replace")
return t
def __init__(self, loglevel=None, logfile=None, schedule=None,
max_interval=None, scheduler_cls=None, app=None,
socket_timeout=30, redirect_stdouts=None,
redirect_stdouts_level=None, **kwargs):
"""Starts the celerybeat task scheduler."""
self.app = app = app_or_default(app)
self.loglevel = loglevel or app.conf.CELERYBEAT_LOG_LEVEL
self.logfile = logfile or app.conf.CELERYBEAT_LOG_FILE
self.schedule = schedule or app.conf.CELERYBEAT_SCHEDULE_FILENAME
self.scheduler_cls = scheduler_cls or app.conf.CELERYBEAT_SCHEDULER
self.max_interval = max_interval
self.socket_timeout = socket_timeout
self.colored = term.colored(enabled=app.conf.CELERYD_LOG_COLOR)
self.redirect_stdouts = (redirect_stdouts or
app.conf.CELERY_REDIRECT_STDOUTS)
self.redirect_stdouts_level = (redirect_stdouts_level or
app.conf.CELERY_REDIRECT_STDOUTS_LEVEL)
if not isinstance(self.loglevel, int):
self.loglevel = LOG_LEVELS[self.loglevel.upper()]
def __init__(self, addrport='', id=None, loglevel=logging.INFO,
logfile=None, without_httpd=False, numc=2, sup_interval=None,
ready_event=None, colored=None, **kwargs):
self.id = id or gen_unique_id()
if isinstance(addrport, basestring):
addr, _, port = addrport.partition(':')
addrport = (addr, int(port) if port else 8000)
self.addrport = addrport
self.connection = celery.broker_connection()
self.without_httpd = without_httpd
self.logfile = logfile
self.loglevel = loglevel
self.numc = numc
self.ready_event = ready_event
self.exit_request = Event()
self.colored = colored or term.colored(enabled=False)
self.httpd = None
gSup = find_symbol(self, self.intsup_cls)
if not self.without_httpd:
self.httpd = MockSup(instantiate(self, self.httpd_cls, addrport),
signals.httpd_ready)
self.supervisor = gSup(instantiate(self, self.supervisor_cls,
sup_interval), signals.supervisor_ready)
self.controllers = [gSup(instantiate(self, self.controller_cls,
id='%s.%s' % (self.id, i),
connection=self.connection,
branch=self),
signals.controller_ready)
for i in xrange(1, numc + 1)]
c = [self.supervisor] + self.controllers + [self.httpd]
c = self.components = list(filter(None, c))
self._components_ready = dict(zip([z.thread for z in c],
[False] * len(c)))
for controller in self.controllers:
if hasattr(controller.thread, 'presence'):
self._components_ready[controller.thread.presence] = False
self._components_shutdown = dict(self._components_ready)
super(Branch, self).__init__()
def colored(self, logfile=None):
return colored(enabled=self.supports_color(logfile))
def __init__(self, app=None, no_color=False):
self.app = app_or_default(app)
self.colored = term.colored(enabled=not no_color)
def test_colors(self):
colors = (
('black', term.BLACK),
('red', term.RED),
('green', term.GREEN),
('yellow', term.YELLOW),
('blue', term.BLUE),
('magenta', term.MAGENTA),
('cyan', term.CYAN),
('white', term.WHITE),
)
for name, key in colors:
self.assertIn(fg(30 + key), str(colored().names[name]('foo')))
self.assertTrue(str(colored().bold('f')))
self.assertTrue(str(colored().underline('f')))
self.assertTrue(str(colored().blink('f')))
self.assertTrue(str(colored().reverse('f')))
self.assertTrue(str(colored().bright('f')))
self.assertTrue(str(colored().ired('f')))
self.assertTrue(str(colored().igreen('f')))
self.assertTrue(str(colored().iyellow('f')))
self.assertTrue(str(colored().iblue('f')))
self.assertTrue(str(colored().imagenta('f')))
self.assertTrue(str(colored().icyan('f')))
self.assertTrue(str(colored().iwhite('f')))
self.assertTrue(str(colored().reset('f')))
self.assertTrue(str_t(colored().green(u'∂bar')))
self.assertTrue(
colored().red(u'éefoo') + colored().green(u'∂bar'))
self.assertEqual(
colored().red('foo').no_color(), 'foo')
self.assertTrue(
repr(colored().blue(u'åfoo')))
self.assertEqual(repr(colored()), "''")
c = colored()
s = c.red('foo', c.blue('bar'), c.green('baz'))
self.assertTrue(s.no_color())
c._fold_no_color(s, u'øfoo')
c._fold_no_color(u'fooå', s)
c = colored().red(u'åfoo')
self.assertEqual(
c._add(c, u'baræ'),
u'\x1b[1;31m\xe5foo\x1b[0mbar\xe6',
)
c2 = colored().blue(u'ƒƒz')
c3 = c._add(c, c2)
self.assertEqual(
c3,
u'\x1b[1;31m\xe5foo\x1b[0m\x1b[1;34m\u0192\u0192z\x1b[0m',
)
def test_colors(self):
colors = (
("black", term.BLACK),
("red", term.RED),
("green", term.GREEN),
("yellow", term.YELLOW),
("blue", term.BLUE),
("magenta", term.MAGENTA),
("cyan", term.CYAN),
("white", term.WHITE),
)
for name, key in colors:
self.assertIn(fg(30 + key), str(colored().names[name]("foo")))
self.assertTrue(str(colored().bold("f")))
self.assertTrue(str(colored().underline("f")))
self.assertTrue(str(colored().blink("f")))
self.assertTrue(str(colored().reverse("f")))
self.assertTrue(str(colored().bright("f")))
self.assertTrue(str(colored().ired("f")))
self.assertTrue(str(colored().igreen("f")))
self.assertTrue(str(colored().iyellow("f")))
self.assertTrue(str(colored().iblue("f")))
self.assertTrue(str(colored().imagenta("f")))
self.assertTrue(str(colored().icyan("f")))
self.assertTrue(str(colored().iwhite("f")))
self.assertTrue(str(colored().reset("f")))
self.assertTrue(str(colored().green(u"∂bar")))
self.assertTrue(colored().red(u"éefoo") + colored().green(u"∂bar"))
self.assertEqual(colored().red("foo").no_color(), "foo")
self.assertTrue(repr(colored().blue(u"åfoo")))
self.assertEqual(repr(colored()), "''")
c = colored()
s = c.red("foo", c.blue("bar"), c.green("baz"))
self.assertTrue(s.no_color())
c._fold_no_color(s, u"øfoo")
c._fold_no_color(u"fooå", s)
c = colored().red(u"åfoo")
self.assertEqual(c._add(c, u"baræ"),
u'\x1b[1;31m\xe5foo\x1b[0mbar\xe6')
c2 = colored().blue(u"ƒƒz")
c3 = c._add(c, c2)
self.assertEqual(
c3, u'\x1b[1;31m\xe5foo\x1b[0m\x1b[1;34m\u0192\u0192z\x1b[0m')
def __init__(self,
concurrency=None,
loglevel=None,
logfile=None,
hostname=None,
discard=False,
run_clockservice=False,
schedule=None,
task_time_limit=None,
task_soft_time_limit=None,
max_tasks_per_child=None,
queues=None,
events=False,
db=None,
include=None,
defaults=None,
pidfile=None,
redirect_stdouts=None,
redirect_stdouts_level=None,
scheduler_cls=None,
**kwargs):
if defaults is None:
from celery import conf
defaults = conf
self.defaults = defaults
self.concurrency = (concurrency or defaults.CELERYD_CONCURRENCY
or multiprocessing.cpu_count())
self.loglevel = loglevel or defaults.CELERYD_LOG_LEVEL
self.logfile = logfile or defaults.CELERYD_LOG_FILE
self.hostname = hostname or socket.gethostname()
self.discard = discard
self.run_clockservice = run_clockservice
self.schedule = schedule or defaults.CELERYBEAT_SCHEDULE_FILENAME
self.scheduler_cls = scheduler_cls or defaults.CELERYBEAT_SCHEDULER
self.events = events
self.task_time_limit = (task_time_limit
or defaults.CELERYD_TASK_TIME_LIMIT)
self.task_soft_time_limit = (task_soft_time_limit
or defaults.CELERYD_TASK_SOFT_TIME_LIMIT)
self.max_tasks_per_child = (max_tasks_per_child
or defaults.CELERYD_MAX_TASKS_PER_CHILD)
self.redirect_stdouts = (redirect_stdouts or defaults.REDIRECT_STDOUTS)
self.redirect_stdouts_level = (redirect_stdouts_level
or defaults.REDIRECT_STDOUTS_LEVEL)
self.db = db
self.queues = queues or []
self.include = include or []
self.pidfile = pidfile
self._isatty = sys.stdout.isatty()
self.colored = term.colored(enabled=defaults.CELERYD_LOG_COLOR)
if isinstance(self.queues, basestring):
self.queues = self.queues.split(",")
if isinstance(self.include, basestring):
self.include = self.include.split(",")
if not isinstance(self.loglevel, int):
try:
self.loglevel = LOG_LEVELS[self.loglevel.upper()]
except KeyError:
self.die(
"Unknown level %r. Please use one of %s." %
(self.loglevel, "|".join(l for l in LOG_LEVELS.keys()
if isinstance(l, basestring))))
###############################################################################
"""
Bindings for tying BPMTask events to callback celery tasks.
"""
from time import time
from functools import wraps
from celery.signals import task_prerun, task_postrun
from celery.datastructures import ExceptionInfo
from celery.utils.term import colored
from celery.log import get_default_logger
logger = get_default_logger()
c = colored()
from ws.tasks import BPMTask
def bpm_only(func):
"""
Decorator for excluding tasks that don't inherit from ws.tasks.BPMTask
Call a function only when it receives an object inherited from
:class:`ws.tasks.BPMTask` as it's 'task' argument.
"""
@wraps(func)
def wrapper(self, task, *args, **kwargs):
if isinstance(task, BPMTask):
return func(self, task=task, *args, **kwargs)
def colored(self, logfile=None, enabled=None):
return colored(enabled=self.supports_color(enabled, logfile))
def colored(self):
return term.colored(enabled=not self.no_color)
def test_unicode(self):
assert text_t(colored().green('∂bar'))
assert colored().red('éefoo') + colored().green('∂bar')
assert colored().red('foo').no_color() == 'foo'
def test_repr(self):
assert repr(colored().blue('åfoo'))
assert "''" in repr(colored())
def colored(self):
if self._colored is None:
self._colored = term.colored(enabled=not self.no_color)
return self._colored
def colored(self):
return term.colored(enabled=not self.no_color)
def colored(self):
if self._colored is None:
self._colored = term.colored(
enabled=isatty(self.stdout) and not self.no_color)
return self._colored
def __init__(self, app=None, no_color=False):
self.app = app_or_default(app)
self.colored = term.colored(enabled=not no_color)
def test_modifiers(self, name):
assert str(getattr(colored(), name)('f'))
def colored(self):
if self._colored is None:
self._colored = term.colored(enabled=not self.no_color)
return self._colored
def test_colors(self, name, color):
assert fg(30 + color) in str(colored().names[name]('foo'))
def test_colors(self):
colors = (
('black', term.BLACK),
('red', term.RED),
('green', term.GREEN),
('yellow', term.YELLOW),
('blue', term.BLUE),
('magenta', term.MAGENTA),
('cyan', term.CYAN),
('white', term.WHITE),
)
for name, key in colors:
self.assertIn(fg(30 + key), str(colored().names[name]('foo')))
self.assertTrue(str(colored().bold('f')))
self.assertTrue(str(colored().underline('f')))
self.assertTrue(str(colored().blink('f')))
self.assertTrue(str(colored().reverse('f')))
self.assertTrue(str(colored().bright('f')))
self.assertTrue(str(colored().ired('f')))
self.assertTrue(str(colored().igreen('f')))
self.assertTrue(str(colored().iyellow('f')))
self.assertTrue(str(colored().iblue('f')))
self.assertTrue(str(colored().imagenta('f')))
self.assertTrue(str(colored().icyan('f')))
self.assertTrue(str(colored().iwhite('f')))
self.assertTrue(str(colored().reset('f')))
self.assertTrue(text_t(colored().green('∂bar')))
self.assertTrue(colored().red('éefoo') + colored().green('∂bar'))
self.assertEqual(colored().red('foo').no_color(), 'foo')
self.assertTrue(repr(colored().blue('åfoo')))
self.assertIn("''", repr(colored()))
c = colored()
s = c.red('foo', c.blue('bar'), c.green('baz'))
self.assertTrue(s.no_color())
c._fold_no_color(s, 'øfoo')
c._fold_no_color('fooå', s)
c = colored().red('åfoo')
self.assertEqual(
c._add(c, 'baræ'),
'\x1b[1;31m\xe5foo\x1b[0mbar\xe6',
)
c2 = colored().blue('ƒƒz')
c3 = c._add(c, c2)
self.assertEqual(
c3,
'\x1b[1;31m\xe5foo\x1b[0m\x1b[1;34m\u0192\u0192z\x1b[0m',
)
def __init__(self, no_color=False):
self.colored = term.colored(enabled=not no_color)
