def execute_from_commandline():
try:
subcommand = sys.argv[1]
except IndexError:
subcommand = 'help'
commands = get_commands()
if subcommand in ('help', '--help', '-h'):
try:
cmd = commands[sys.argv[2]]
cmd.print_help(sys.argv[0], sys.argv[2])
except IndexError:
# TODO print general help
print "Usage: %s <command-name> [args]" % sys.argv[0]
print_possible_commands(commands)
except KeyError:
print "Command '%s' not found.\n" % sys.argv[2]
print_possible_commands(commands)
elif subcommand == '--version':
print eoxserver.get_version()
else:
try:
commands[subcommand].run_from_argv(sys.argv)
except KeyError:
print "Command '%s' not found.\n" % sys.argv[2]
print_possible_commands(commands)
sys.exit(1)
except CommandError, e:
print termcolors.colorize("Error: %s" % e, fg="red")
sys.exit(1)
def prompt(message, default_value=None, valid_list=None):
value = None
if valid_list is not None:
list_str = '{%s}' % '|'.join(map(str, valid_list))
message = '%s %s' % (message, list_str)
if default_value is not None:
message = '%s [default=%s]' % (message, default_value)
if supports_color():
message = colorize('[ECM] ', fg='cyan', opts=('bold', )) + colorize(
message, fg='magenta') + ' '
else:
message = '[ECM] ' + message + ' '
if valid_list is not None:
while value not in valid_list:
value = raw_input(message)
if not value:
value = default_value
else:
while not value:
value = raw_input(message)
if not value:
value = default_value
return value
def handle(self, *args, **options):
count_success = 0
count_failure = 0
videos = SignVideo.objects.all()
for video in videos:
if not options["all"] and video.optimized_video_file:
continue
self.stdout.write(f"Generating optimized version for {video}...", ending="")
self.stdout.flush()
try:
optimize_video(video)
video.save()
except ffmpeg.Error:
count_failure += 1
self.stdout.write(colorize("Error", fg="red"))
else:
count_success += 1
self.stdout.write(colorize("Done", fg="green"))
self.stdout.write(
colorize(f"Successfully processed {count_success} items.", fg="green")
)
if count_failure:
self.stdout.write(
colorize(f"Failed to process {count_failure} items.", fg="red")
)
def prompt(message, default_value=None, valid_list=None):
value = None
if valid_list is not None:
list_str = '{%s}' % '|'.join(map(str, valid_list))
message = '%s %s' % (message, list_str)
if default_value is not None:
message = '%s [default=%s]' % (message, default_value)
if supports_color():
message = colorize('[ECM] ', fg='cyan', opts=('bold',)) + colorize(message, fg='magenta') + ' '
else:
message = '[ECM] ' + message + ' '
if valid_list is not None:
while value not in valid_list:
value = raw_input(message)
if not value:
value = default_value
else:
while not value:
value = raw_input(message)
if not value:
value = default_value
return value
def show_settings(settings, action):
import guardian
from django.utils.termcolors import colorize
guardian_path = guardian.__path__[0]
msg = "django-guardian module's path: %r" % guardian_path
print(colorize(msg, fg='magenta'))
db_conf = settings.DATABASES['default']
output = []
msg = "Starting %s for db backend: %s" % (action, db_conf['ENGINE'])
embracer = '=' * len(msg)
output.append(msg)
for key in sorted(db_conf.keys()):
if key == 'PASSWORD':
value = '****************'
else:
value = db_conf[key]
line = ' %s: "%s"' % (key, value)
output.append(line)
embracer = colorize('=' * len(max(output, key=lambda s: len(s))),
fg='green',
opts=['bold'])
output = [colorize(line, fg='blue') for line in output]
output.insert(0, embracer)
output.append(embracer)
print('\n'.join(output))
def handle(self, *args, **kwargs):
"""Add the midd_webid field to all professors found in the current
Middlebury directory.
"""
if kwargs['dry_run']:
print(colorize('Dry run. Nothing will be saved.', fg='yellow'))
professors = self.get_professors_webid_email()
added = 0
for directory_prof in professors:
try:
middcourses_prof = Professor.objects.get(
email=directory_prof['email'])
middcourses_prof.midd_webid = directory_prof['webid']
if not kwargs['dry_run']:
middcourses_prof.save()
added += 1
except Professor.DoesNotExist:
pass
print(
colorize('Added webids for {} professors.'.format(added),
fg='green'))
def __call__(self, request):
request.request_start_time = time()
remote_addr = request.META.get('REMOTE_ADDR')
user = self.get_user(request)
username = user.username
request_logger.info(
colorize("{} {} {} {}".format(username, remote_addr,
request.method,
request.get_full_path()),
fg="cyan"))
self.log_body(self.chunked_to_max(request.body))
response = self.get_response(request)
response_time = time() - getattr(request, 'request_start_time', time())
resp_log = "{} sec {} {} : {}".format(response_time, request.method,
request.get_full_path(),
response.status_code)
if response.status_code in range(400, 600):
request_logger.info(colorize(resp_log, fg="magenta"))
self.log_resp_body(response, level=logging.ERROR)
else:
request_logger.info(colorize(resp_log, fg="cyan"))
self.log_resp_body(response)
return response
def print_with_color(msg: str, **kwargs):
bold = kwargs.pop('bold', False)
if bold:
opts = kwargs.setdefault('opts', [])
if 'bold' not in opts:
opts.append('bold')
pid = os.getpid()
try:
# noinspection PyPackageRequirements,PyUnresolvedReferences
import uwsgi
master = uwsgi.masterpid()
worker = uwsgi.worker_id()
mule = uwsgi.mule_id()
except ImportError:
uwsgi = None
master = 0
worker = 0
mule = 0
if mule:
print(colorize('[mule {}] {}'.format(mule, msg), **kwargs))
elif worker:
print(colorize('[worker {}] {}'.format(worker, msg), **kwargs))
elif pid == master:
print(colorize('[master] {}'.format(msg), **kwargs))
elif uwsgi:
print(colorize('[spooler {}] {}'.format(pid, msg), **kwargs))
else:
print(colorize(msg, **kwargs))
def run_tests(settings):
from django.test.utils import get_runner
from django.utils.termcolors import colorize
from django.test.utils import setup_test_environment
version = django.get_version()
if version.startswith("1.7"):
django.setup()
db_conf = settings.DATABASES['default']
setup_test_environment()
output = []
msg = "Starting tests for db backend: %s" % db_conf['ENGINE']
embracer = '=' * len(msg)
output.append(msg)
for key, value in db_conf.iteritems():
if key == 'PASSWORD':
value = '****************'
line = ' %s: "%s"' % (key, value)
output.append(line)
embracer = colorize('=' * len(max(output, key=lambda s: len(s))),
fg='green', opts=['bold'])
output = [colorize(line, fg='blue') for line in output]
output.insert(0, embracer)
output.append(embracer)
print '\n'.join(output)
TestRunner = get_runner(settings)
test_runner = TestRunner(interactive=False)
failures = test_runner.run_tests(['password_policies'])
return failures
def run_tests(settings):
from django.test.utils import get_runner
from django.utils.termcolors import colorize
db_conf = settings.DATABASES['default']
output = []
msg = "Starting tests for db backend: %s" % db_conf['ENGINE']
embracer = '=' * len(msg)
output.append(msg)
for key, value in db_conf.iteritems():
if key == 'PASSWORD':
value = '****************'
line = ' %s: "%s"' % (key, value)
output.append(line)
embracer = colorize('=' * len(max(output, key=lambda s: len(s))),
fg='green',
opts=['bold'])
output = [colorize(line, fg='blue') for line in output]
output.insert(0, embracer)
output.append(embracer)
print '\n'.join(output)
TestRunner = get_runner(settings)
test_runner = TestRunner(interactive=False)
failures = test_runner.run_tests(['auth', 'change_email'])
return failures
def handle(self, *args, **options):
for filename in glob('./wikisensei/stubs/*.json'):
if 'test_' in filename:
print(colorize(text='Ignore %s' % filename, fg='yellow'))
continue
else:
print(colorize(text=filename, fg='cyan'))
with open(filename) as f:
data = f.read()
data = json.loads(data)
app_label = data['app_label']
for instance_data in data['instances']:
model_name = instance_data['model_name']
model = apps.get_model(app_label, model_name)
queryset_data = deepcopy(instance_data['data'])
for ref in instance_data.get('refs', []):
ref_app_label = instance_data['refs'][ref].get(
'app_label', app_label)
ref_model_name = instance_data['refs'][ref][
'model_name']
ref_model = apps.get_model(ref_app_label,
ref_model_name)
ref_instance = ref_model.objects.get(
**instance_data['refs'][ref]['data'])
queryset_data[ref] = ref_instance
try:
instance = model.objects.get(**queryset_data)
print(u'✓ %s %s' %
(instance, colorize('OK', fg='green')))
except model.DoesNotExist:
instance = model.objects.create(**queryset_data)
print(u'+ %s %s' %
(instance, colorize('OK', fg='green')))
def handle(self, *arguments, **options):
self.verbosity = options['verbosity']
self.silent = options['silent']
term = self.validate_term(options['term'])
catalog = self.create_catalog(term.id)
for course in catalog:
if self.course_is_skippable(course):
continue
professors = self.get_or_create_professors(course)
course = self.get_or_create_course(course)
for professor in professors:
profcourse = ProfCourse.objects.get_or_create(
prof=professor,
course=course
)
if profcourse[1]:
self.prof_courses_added += 1
if self.verbosity > 1:
print('Added ProfCourse ({} {}, {}).'
.format(professor.first, professor.last, course.code))
if not self.silent:
print(colorize('Finished scraping term {}.'.format(options['term']), fg='green'))
print(colorize(' Added {} Courses.'.format(self.courses_added), fg='blue'))
print(colorize(' Added {} Professors.'.format(self.professors_added), fg='blue'))
print(colorize(' Added {} ProfCourses'.format(self.prof_courses_added), fg='blue'))
def show_settings(settings, action):
import guardian
from django.utils.termcolors import colorize
guardian_path = guardian.__path__[0]
msg = "django-guardian module's path: %r" % guardian_path
print(colorize(msg, fg='magenta'))
db_conf = settings.DATABASES['default']
output = []
msg = "Starting %s for db backend: %s" % (action, db_conf['ENGINE'])
embracer = '=' * len(msg)
output.append(msg)
for key in sorted(db_conf.keys()):
if key == 'PASSWORD':
value = '****************'
else:
value = db_conf[key]
line = ' %s: "%s"' % (key, value)
output.append(line)
embracer = colorize('=' * len(max(output, key=lambda s: len(s))),
fg='green', opts=['bold'])
output = [colorize(line, fg='blue') for line in output]
output.insert(0, embracer)
output.append(embracer)
print('\n'.join(output))
def run_tests(settings):
from django.test.utils import get_runner
from django.utils.termcolors import colorize
from django.test.utils import setup_test_environment
version = django.get_version()
if version.startswith("1.7"):
django.setup()
db_conf = settings.DATABASES['default']
setup_test_environment()
output = []
msg = "Starting tests for db backend: %s" % db_conf['ENGINE']
embracer = '=' * len(msg)
output.append(msg)
for key, value in db_conf.iteritems():
if key == 'PASSWORD':
value = '****************'
line = ' %s: "%s"' % (key, value)
output.append(line)
embracer = colorize('=' * len(max(output, key=lambda s: len(s))),
fg='green',
opts=['bold'])
output = [colorize(line, fg='blue') for line in output]
output.insert(0, embracer)
output.append(embracer)
print '\n'.join(output)
TestRunner = get_runner(settings)
test_runner = TestRunner(interactive=False)
failures = test_runner.run_tests(['password_policies'])
return failures
def test_colorize_fg_bg(self):
self.assertEqual(colorize(text="Test", fg="red"),
"\x1b[31mTest\x1b[0m")
self.assertEqual(colorize(text="Test", bg="red"),
"\x1b[41mTest\x1b[0m")
# Ignored kwarg.
self.assertEqual(colorize(text="Test", other="red"),
"\x1b[mTest\x1b[0m")
def debug(self, key, value):
from django.utils.termcolors import colorize
if value:
sys.stdout.write(colorize(key, fg='green'))
sys.stdout.write(": ")
sys.stdout.write(colorize(repr(value), fg='white'))
sys.stdout.write("\n")
def debug(self, key, value):
from django.utils.termcolors import colorize
if value:
sys.stdout.write(colorize(key, fg='green'))
sys.stdout.write(": ")
sys.stdout.write(colorize(repr(value), fg='white'))
sys.stdout.write("\n")
def process_response(self, request, response):
resp_log = "{} {} - {}".format(request.method, request.get_full_path(), response.status_code)
if (response.status_code in range(400, 600)):
request_logger.info(colorize(resp_log, fg="magenta"))
self.log_resp_body(response, level=logging.ERROR)
else:
request_logger.info(colorize(resp_log, fg="cyan"))
self.log_resp_body(response)
return response
def handle_ls(self):
self.stdout.write(colorize('\n=== [GYPSY] registered templates ===\n\n',
fg='green'), ending='')
output = []
for group, templates in self.template_groups:
output.append(colorize(group + ':\n ', fg='yellow'))
output.append('\n '.join(templates))
output.append('\n\n')
self.stdout.write(''.join(output), ending='')
def format(self, record):
opts = dict(i for i in vars(record).items() if i[0] in ('fg', 'bg'))
if opts:
return termcolors.colorize(logging.Formatter.format(self, record), **opts)
level_name = record.levelname
opts = self.color_map.get(level_name)
if opts:
record.levelname = termcolors.colorize(level_name, **opts)
return logging.Formatter.format(self, record)
def process_response(self, request, response):
resp_log = "{} {} - {}".format(request.method, request.get_full_path(), response.status_code)
if (response.status_code in range(400, 600)):
request_logger.info(colorize(resp_log, fg="magenta"))
self.log_resp_body(response, level=logging.ERROR)
else:
request_logger.info(colorize(resp_log, fg="cyan"))
self.log_resp_body(response)
return response
def format(self, record):
opts = dict(i for i in vars(record).items() if i[0] in ('fg', 'bg'))
if opts:
return termcolors.colorize(logging.Formatter.format(self, record),
**opts)
level_name = record.levelname
opts = self.color_map.get(level_name)
if opts:
record.levelname = termcolors.colorize(level_name, **opts)
return logging.Formatter.format(self, record)
def _walk_urlresolver(self, parent, urlresolver, lv=0):
if hasattr(urlresolver, 'url_patterns'):
for item in urlresolver.url_patterns:
current_path = parent + self._clear_regexpath(item.regex.pattern)
if startswith_in_list(current_path, self.excluded_paths):
continue
if not isinstance(item, RegexURLResolver) and getattr(item, 'name', None):
print "{indent}* {path} {name}".format(indent=(" "*lv), path=colorize(current_path, fg='green'), name=colorize(item.name, fg='magenta'))
else:
print "{indent}* {path}".format(indent=(" "*lv), path=colorize(current_path, fg='blue'))
self._walk_urlresolver(current_path, item, lv=lv+1)
def ct():
try:
cursor.execute(sql)
print colorize('[OK]', fg='green', opts=('bold',))
transaction.commit()
except Exception, (e,):
print colorize('[ERROR]', fg='red', opts=('bold', ))
print '>'*50
print e,
print '<'*50
transaction.rollback()
def set_tags(sender,
document=None,
logging_group=None,
classifier=None,
replace=False,
suggest=False,
base_url=None,
color=False,
**kwargs):
if replace:
Document.tags.through.objects.filter(document=document).exclude(
Q(tag__is_inbox_tag=True)).exclude(
Q(tag__match="")
& ~Q(tag__matching_algorithm=Tag.MATCH_AUTO)).delete()
current_tags = set(document.tags.all())
matched_tags = matching.match_tags(document, classifier)
relevant_tags = set(matched_tags) - current_tags
if suggest:
extra_tags = current_tags - set(matched_tags)
extra_tags = [
t for t in extra_tags
if t.matching_algorithm == MatchingModel.MATCH_AUTO
]
if not relevant_tags and not extra_tags:
return
if base_url:
print(
termcolors.colorize(str(document), fg='green'
) if color else str(document))
print(f"{base_url}/documents/{document.pk}")
else:
print((termcolors.colorize(str(document), fg='green'
) if color else str(document)) +
f" [{document.pk}]")
if relevant_tags:
print("Suggest tags: " + ", ".join([t.name
for t in relevant_tags]))
if extra_tags:
print("Extra tags: " + ", ".join([t.name for t in extra_tags]))
else:
if not relevant_tags:
return
message = 'Tagging "{}" with "{}"'
logger.info(message.format(document,
", ".join([t.name for t in relevant_tags])),
extra={'group': logging_group})
document.tags.add(*relevant_tags)
def set_document_type(sender,
document=None,
logging_group=None,
classifier=None,
replace=False,
use_first=True,
suggest=False,
base_url=None,
color=False,
**kwargs):
if document.document_type and not replace:
return
potential_document_type = matching.match_document_types(
document, classifier)
potential_count = len(potential_document_type)
if potential_document_type:
selected = potential_document_type[0]
else:
selected = None
if potential_count > 1:
if use_first:
logger.info(
f"Detected {potential_count} potential document types, "
f"so we've opted for {selected}",
extra={'group': logging_group})
else:
logger.info(
f"Detected {potential_count} potential document types, "
f"not assigning any document type",
extra={'group': logging_group})
return
if selected or replace:
if suggest:
if base_url:
print(
termcolors.colorize(str(document), fg='green'
) if color else str(document))
print(f"{base_url}/documents/{document.pk}")
else:
print((termcolors.colorize(str(document), fg='green'
) if color else str(document)) +
f" [{document.pk}]")
print(f"Sugest document type {selected}")
else:
logger.info(f"Assigning document type {selected} to {document}",
extra={'group': logging_group})
document.document_type = selected
document.save(update_fields=("document_type", ))
def _walk_urlresolver(self, parent, urlresolver, lv=0):
for item in urlresolver.url_patterns:
_url_name = getattr(item, 'name', None) or 'Unnamed'
current_path = parent + self._clear_regexpath(item.regex.pattern)
_current_path_display = current_path or 'No path'
if startswith_in_list(current_path, self.excluded_paths):
continue
if not isinstance(item, RegexURLResolver):
print "{indent}* {path} {name}".format(indent=(" "*lv), path=colorize(_current_path_display, fg='green'), name=colorize(_url_name, fg='magenta'))
else:
print "{indent}* {path}".format(indent=(" "*lv), path=colorize(_current_path_display, fg='blue'))
self._walk_urlresolver(current_path, item, lv=lv+1)
def make_banner(auto_transact=True, **kwargs):
logo = """
.+yhhys/`
`smmmmmmmmd:
`--.` ommmmmmmmmmm. `.--.
`odmmmmmh/ smmmhhyhdmmm- :ymmmmmdo.
-dmmmmmmmmmy .hho+++++sdo smmmmmmmmmm:
smmmmmmmmmmm: `++++++++: -mmmmmmmmmmmy
+mmmmmmmmmmmo: :+++++++.:+mmmmmmmmmmmo
+dmmmmmmmds++. .://:-``++odmmmmmmmmo
`:osyhys+++/ :+++oyhyso/`
`/shddds/``.-::-. `-::-.``/shdddy/`
-dmmmmmds++++/. ./++++sdmmmmmd:
hmmmmmmo+++++++. .++++++++dmmmmmd`
hmmmmmmo+++++++. .++++++++dmmmmmd`
-dmmmmmds++++/. ./++++sdmmmmmd:
`/shddhs/``.-::-. `-::-.``/shdddy/`
`:osyhys+++/ :+++oyhyso/`
+dmmmmmmmds++. .://:- `++odmmmmmmmmo
+mmmmmmmmmmmo: /++++++/`:+mmmmmmmmmmmo
smmmmmmmmmmm: `++++++++. -mmmmmmmmmmmy
-dmmmmmmmmmy `s++++++y/ smmmmmmmmmm:
`odmmmmmh/ hmmhyyhdmm/ :ymmmmmds.
`--.` `mmmmmmmmmmo `.--.
/mmmmmmmmh`
`+shhyo:
"""
greeting = 'Welcome to the OSF Shell. Happy hacking!'
imported_objects = format_imported_objects(**kwargs)
transaction_warning = """
*** TRANSACTION AUTOMATICALLY STARTED ***
To persist changes, run 'commit()'.
Keep in mind that changing documents will lock them.
This feature can be disabled with the '--no-transaction' flag."""
no_transaction_warning = """
*** AUTO-TRANSACTION DISABLED ***
All changes will persist. Transactions must be handled manually."""
template = """{logo}
{greeting}
{imported_objects}
{warning}
"""
if auto_transact:
warning = colorize(transaction_warning, fg='yellow')
else:
warning = colorize(no_transaction_warning, fg='red')
return template.format(
logo=colorize(logo, fg='cyan'),
greeting=colorize(greeting, opts=('bold', )),
imported_objects=imported_objects,
warning=warning,
)
def make_banner(auto_transact=True, **kwargs):
logo = """
.+yhhys/`
`smmmmmmmmd:
`--.` ommmmmmmmmmm. `.--.
`odmmmmmh/ smmmhhyhdmmm- :ymmmmmdo.
-dmmmmmmmmmy .hho+++++sdo smmmmmmmmmm:
smmmmmmmmmmm: `++++++++: -mmmmmmmmmmmy
+mmmmmmmmmmmo: :+++++++.:+mmmmmmmmmmmo
+dmmmmmmmds++. .://:-``++odmmmmmmmmo
`:osyhys+++/ :+++oyhyso/`
`/shddds/``.-::-. `-::-.``/shdddy/`
-dmmmmmds++++/. ./++++sdmmmmmd:
hmmmmmmo+++++++. .++++++++dmmmmmd`
hmmmmmmo+++++++. .++++++++dmmmmmd`
-dmmmmmds++++/. ./++++sdmmmmmd:
`/shddhs/``.-::-. `-::-.``/shdddy/`
`:osyhys+++/ :+++oyhyso/`
+dmmmmmmmds++. .://:- `++odmmmmmmmmo
+mmmmmmmmmmmo: /++++++/`:+mmmmmmmmmmmo
smmmmmmmmmmm: `++++++++. -mmmmmmmmmmmy
-dmmmmmmmmmy `s++++++y/ smmmmmmmmmm:
`odmmmmmh/ hmmhyyhdmm/ :ymmmmmds.
`--.` `mmmmmmmmmmo `.--.
/mmmmmmmmh`
`+shhyo:
"""
greeting = 'Welcome to the OSF Shell. Happy hacking!'
imported_objects = format_imported_objects(**kwargs)
transaction_warning = """
*** TRANSACTION AUTOMATICALLY STARTED ***
To persist changes, run 'commit()'.
Keep in mind that changing documents will lock them.
This feature can be disabled with the '--no-transaction' flag."""
no_transaction_warning = """
*** AUTO-TRANSACTION DISABLED ***
All changes will persist. Transactions must be handled manually."""
template = """{logo}
{greeting}
{imported_objects}
{warning}
"""
if auto_transact:
warning = colorize(transaction_warning, fg='yellow')
else:
warning = colorize(no_transaction_warning, fg='red')
return template.format(
logo=colorize(logo, fg='cyan'),
greeting=colorize(greeting, opts=('bold', )),
imported_objects=imported_objects,
warning=warning,
)
def test_colorize_opts(self):
self.assertEqual(
colorize(text='Test', opts=('bold', 'underscore')),
'\x1b[1;4mTest\x1b[0m',
)
self.assertEqual(
colorize(text='Test', opts=('blink',)),
'\x1b[5mTest\x1b[0m',
)
# Ignored opts.
self.assertEqual(
colorize(text='Test', opts=('not_an_option',)),
'\x1b[mTest\x1b[0m',
)
def test_colorize_opts(self):
self.assertEqual(
colorize(text="Test", opts=("bold", "underscore")),
"\x1b[1;4mTest\x1b[0m",
)
self.assertEqual(
colorize(text="Test", opts=("blink", )),
"\x1b[5mTest\x1b[0m",
)
# Ignored opts.
self.assertEqual(
colorize(text="Test", opts=("not_an_option", )),
"\x1b[mTest\x1b[0m",
)
def __init__(self):
self.values = [i for i in range(1, 10)]
self.winning_options = {
"g": [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
"v": [[1, 4, 7], [2, 5, 8], [3, 6, 9]],
"d": [[1, 5, 9], [3, 5, 7]]
}
self.user_values = [colorize("X", fg='red'), colorize("O", fg='blue')]
self.users = {}
self.user_value = self.user_values[0]
# self.game()
self.check_syntax_shut_up = None
def failure(self, string):
"""
Writes out a string to stdout formatted red to communicate failure.
"""
if not self.no_color:
string = colorize(string, fg="red")
self.stdout.write(string)
def success(self, string):
"""
Writes out a string to stdout formatted green to communicate success.
"""
if not self.no_color:
string = colorize(string, fg="green")
self.stdout.write(string)
def log(self, string):
"""
Writes out a string to stdout formatted to look like a standard line.
"""
if not self.no_color:
string = colorize("%s" % string, fg="white")
self.stdout.write(string)
def format(self, record):
original = self._style._fmt
self._style._fmt = colorize(
'[%(asctime)s] ', fg=self.color[record.levelno]) + '%(message)s'
result = logging.Formatter.format(self, record)
self._style._fmt = original
return result
def site_configuration(request):
try:
site = SiteConfiguration.objects.filter(activated=True)
bd_components = Component.objects.filter(
configuration=site[0].pk).order_by('number')
site_components = [
SiteComponent(component) for component in bd_components
]
contact_page_component = Component.objects.filter(
component_type='contact_page')
qualsection = CokPlaceInfo.objects.count()
confid_doc = Document.objects.filter(url_code='PRIVACY_POLICY').first()
# import pdb; pdb.set_trace()
conf = {
'site': {
'configuration': site[0],
'components': site_components,
'font_url': site[0].font.font_url,
'font_family': site[0].font.title,
'qualsection': qualsection,
'confid_doc': confid_doc
}
}
# import pdb; pdb.set_trace()
if contact_page_component:
conf['site']['contact_page'] = SiteComponent(
contact_page_component.first())
# import pdb; pdb.set_trace()
return conf
except Exception as e:
print(
colorize('###---> SITE CONFIGURATION ERROR: {}'.format(e),
bg='red'))
return {'site': {'components': None}}
def log(self, string):
"""
Writes out a string to stdout formatted to look like a standard line.
"""
if not self.no_color:
string = colorize("%s" % string, fg="white")
self.stdout.write(string)
def create_component_object(self, options):
component = Component.objects.create(**options)
print(
colorize('*** COMPONENT CREATED: {}, pk: {}'.format(
component.title, component.pk),
bg='yellow',
fg='blue'))
def log(string, color="white"):
"""
write string to stdout with color. Default color is white.
"""
sys.stdout.write(
colorize("{}\n".format(string), fg=color)
)
def failure(self, string):
"""
Writes out a string to stdout formatted red to communicate failure.
"""
if not self.no_color:
string = colorize(string, fg="red")
self.stdout.write(string)
def input_value(self, user_input):
"""Принимает ввод пользователя, выполняет проверку, вставляет значения"""
if self.check_tic_tac_toe_values(user_input) == "Error":
print("\nError: '{}' - нет такой ячейки".format(
colorize(user_input, bg="red")))
print("Повторите ввод\n")
self.print_table()
print("Где будет {}?\n".format(self.user_value))
return self.input_value(input())
user_input = int(user_input)
if self.check_empty_value(user_input) == "Error":
print("\nТут уже занято")
print("Повторите ввод\n")
self.print_table()
print("Где будет {}?\n".format(self.user_value))
return self.input_value(input())
self.values[user_input - 1] = self.user_value
for key in self.winning_options:
for id_option in range(len(self.winning_options[key])):
for value_id in range(len(
self.winning_options[key][id_option])):
if self.winning_options[key][id_option][
value_id] == user_input:
self.winning_options[key][id_option][
value_id] = self.user_value
return None
def process_response(self, request, response):
start_time = getattr(request, '_dev_render_start', 0)
view_time = getattr(request, '_dev_render_view', 0)
end_time = time.time()
if view_time:
view_duration = view_time - start_time
self.logger.info(colorize('{:.0f}ms'.format(view_duration * 1000),
fg='white'),
name='view')
render_duration = end_time - max(view_time, start_time)
self.logger.info(colorize('{:.0f}ms'.format(render_duration * 1000),
fg='white'),
name='render')
super().process_response(request, response)
def handle(self, session_id, *args, **options):
"""Extract user id from session and display username."""
try:
session = Session.objects.get(pk=session_id)
except Session.DoesNotExist:
sys.stderr.write("Hey, I know who it is, it's %s!\n" % colorize('YOU', fg='red'))
return
try:
user_id = session.get_decoded()['_auth_user_id']
user = User.objects.get(pk=user_id)
sys.stderr.write("Session is bound to user %s (%s)\n" % (colorize(user.get_full_name(), fg='green'), colorize(user.email, fg='green')))
except KeyError:
sys.stderr.write('No user id in session data\n')
except User.DoesNotExist:
sys.stderr.write('User from session data does not exist\n')
def get_data(self, datum):
"""
Returns the appropriate data for this column from the given input.
The return value will be either the attribute specified for this column
or the return value of the attr:`~horizon.tables.Column.transform`
method for this column.
"""
datum_id = self.table.get_object_id(datum)
if datum_id in self.table._data_cache[self]:
return self.table._data_cache[self][datum_id]
# Callable transformations
if callable(self.transform):
data = self.transform(datum)
# Basic object lookups
elif hasattr(datum, self.transform):
data = getattr(datum, self.transform, None)
# Dict lookups
elif isinstance(datum, collections.Iterable) and \
self.transform in datum:
data = datum.get(self.transform)
else:
if settings.DEBUG:
msg = _("The attribute %(attr)s doesn't exist on "
"%(obj)s.") % {'attr': self.transform, 'obj': datum}
msg = termcolors.colorize(msg, **PALETTE['ERROR'])
LOG.warning(msg)
data = None
for filter_func in self.filters:
data = filter_func(data)
self.table._data_cache[self][datum_id] = data
return self.table._data_cache[self][datum_id]
def info(self, main_message="", color='cyan', force=False):
self.INFOS.append((self.get_timestamp(), main_message))
message = self._fix_message(main_message)
message = colorize(message, fg=color, opts=('', ))
if self.VERBOSE or force == True:
self.output(message)
return main_message
def error(self, main_message="", raise_error=None, kill=True, color='red'):
if raise_error:
raise (raise_error('Error: ' + main_message)) from None
message = self._fix_message('Error: ' + main_message)
message = colorize(message, fg=color, opts=('bold', ))
self.output(message, kill)
return main_message
def get_raw_data(self, datum):
"""
Returns the raw data for this column, before any filters or formatting
are applied to it. This is useful when doing calculations on data in
the table.
"""
# Callable transformations
if callable(self.transform):
data = self.transform(datum)
# Basic object lookups
elif hasattr(datum, self.transform):
data = getattr(datum, self.transform, None)
# Dict lookups
elif isinstance(datum, collections.Iterable) and \
self.transform in datum:
data = datum.get(self.transform)
else:
if settings.DEBUG:
msg = _("The attribute %(attr)s doesn't exist on "
"%(obj)s.") % {
'attr': self.transform,
'obj': datum
}
msg = termcolors.colorize(msg, **PALETTE['ERROR'])
LOG.warning(msg)
data = None
return data
def print_traversal_tree(node, depth=None):
if depth is None:
print_traversal_tree(node.root_node, depth=0)
else:
if depth == 0:
colored = colorize(node.model_name, fg='black', opts=['bold'])
sys.stdout.write('{0}\n'.format(colored))
else:
sys.stdout.write('.' * depth * 4)
colored = colorize(node.model_name, fg='black', opts=['bold'])
sys.stdout.write('{0} (via {1})\n'.format(colored, node.accessor_name))
if node.children:
depth += 1
for child in node.children:
print_traversal_tree(child, depth)
def clog( self, message, args=None, color="cyan" ):
if self.Command != None:
params = []
if args != None:
for arg in args:
if arg != None:
try:
params.append(colorize(unicode(arg), fg=color))
except:
params.append(colorize("caught error", fg=color))
if params != None:
self.stderr.write(message % tuple(params))
else:
self.stderr.write(message)
else:
self.stderr.write(message)
def success(self, string):
"""
Writes out a string to stdout formatted green to communicate success.
"""
if not self.no_color:
string = colorize(string, fg="green")
self.stdout.write(string)
def header(self, string):
"""
Writes out a string to stdout formatted to look like a header.
"""
logger.debug(string)
if not getattr(self, 'no_color', None):
string = colorize(string, fg="cyan", opts=("bold",))
self.stdout.write(string)
def log(self, string):
"""
Writes out a string to stdout formatted to look like a standard line.
"""
logger.debug(string)
if not getattr(self, 'no_color', None):
string = colorize("%s" % string, fg="white")
self.stdout.write(string)
def success(self, string):
"""
Writes out a string to stdout formatted green to communicate success.
"""
logger.debug(string)
if not getattr(self, 'no_color', None):
string = colorize(string, fg="green")
self.stdout.write(string)
def warn(self, string):
"""
Writes string to stdout formatted yellow to communicate a warning.
"""
logger.warn(string)
if not getattr(self, 'no_color', None):
string = colorize(string, fg="yellow")
self.stdout.write(string)
def header(self, string):
"""
Writes out a string to stdout formatted to look like a header
that stands out among the other lines.
"""
if not self.no_color:
string = colorize(string, fg="cyan", opts=("bold",))
self.stdout.write(string)
def failure(self, string):
"""
Writes string to stdout formatted red to communicate failure.
"""
logger.error(string)
if not getattr(self, 'no_color', None):
string = colorize(string, fg="red")
self.stdout.write(string)
def process_request(self, request):
request.request_start_time = time()
remote_addr = request.META.get('REMOTE_ADDR')
user = self.get_user(request)
username = user.username
request_logger.info(colorize("{} {} {} {}".format(
username, remote_addr, request.method, request.get_full_path()), fg="cyan")
)
self.log_body(self.chunked_to_max(request.body))
def get_or_create_professors(self, course):
professors = []
for instructor in course.instructors:
# First try to get the Professor by midd_webid
try:
professor = Professor.objects.get(midd_webid=instructor.id)
professors.append(professor)
continue
except Professor.DoesNotExist:
pass
# Then try to get the Professor by email and add its midd_webid
professor_details = self.get_professor_by_id(instructor.id)
if professor_details and 'E-mail' in professor_details:
try:
professor = Professor.objects.get(email=professor_details['E-mail'])
professor.midd_webid = instructor.id
professor.save()
professors.append(professor)
continue
except Professor.DoesNotExist:
pass
# Unable to get a Professor by midd_webid or email.
# Have to create a new Professor.
if professor_details and 'E-mail' in professor_details:
email = professor_details['E-mail']
else:
if not self.silent:
print(colorize('Unable to get email for Professor {}.'
.format(instructor.name), fg='yellow'))
email = None
if professor_details and 'Department' in professor_details:
department = professor_details['Department']
else:
department = course.department.text
professor = Professor.objects.create(
midd_webid=instructor.id,
first=' '.join(instructor.name.split(' ')[:-1]),
last=instructor.name.split(' ')[-1],
email=email,
dept=Department.objects.get_or_create(name=department)[0]
)
self.professors_added += 1
if self.verbosity > 1:
print('Added Professor {}.'.format(instructor.name))
professors.append(professor)
return professors
def handle_clean(self):
self.check_output_dir(self.output_dir)
for lang, group, _ in self.iter_groups():
filename = self.get_filename(lang, group)
try:
os.remove(filename)
except OSError:
continue
self.stdout.write('cleaned %s' % colorize(os.path.relpath(filename), fg='yellow'))
