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 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 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 _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 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 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 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 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'))