def ps_screen(full=False): screens = [p for p in psutil.process_iter() if p.name() in ['screen', 'tmux']] screens.sort(key=methodcaller('cwd')) columns = terminal_columns() table = [table_row(s, full) for s in screens] lines = tabulate(table, tablefmt='plain', numalign='left').split('\n') for screen, line in zip(screens, lines): stripped_length = len(strip_ansi(line)) if columns and stripped_length > columns: line = line[0:-(stripped_length - columns + 6)] + '...' click.echo(line) if full: for c in screen.children(): print_child(c, columns=columns) print
def _pipepager(text, cmd, color): """Page through text by feeding it to another program. Invoking a pager through this might support colors. """ import subprocess env = dict(os.environ) # If we're piping to less we might support colors under the # condition that cmd_detail = cmd.rsplit('/', 1)[-1].split() if color is None and cmd_detail[0] == 'less': less_flags = os.environ.get('LESS', '') + ' '.join(cmd_detail[1:]) if not less_flags: env['LESS'] = '-R' color = True elif 'r' in less_flags or 'R' in less_flags: color = True if not color: text = strip_ansi(text) c = subprocess.Popen(shlex.split(cmd), stdin=subprocess.PIPE, env=env) encoding = get_best_encoding(c.stdin) try: c.stdin.write(text.encode(encoding, 'replace')) c.stdin.close() except (IOError, KeyboardInterrupt): pass return c
def test_error_formatter_mixed(): assert strip_ansi( format_error_data({ "environment": [{ "message": "Object with slug or primary key bluup does not exist.", "code": "does_not_exist" }], "non_field_errors": [ 'oh', 'oh no', 'that\'s bad', { 'message': 'this is fine', 'code': 'dog_not_on_fire' }, ], })) == (''' * oh * oh no * that's bad * this is fine (code: dog_not_on_fire) environment: * Object with slug or primary key bluup does not exist. (code: does_not_exist) ''').strip()
def test_error_formatter_simple(): assert strip_ansi( format_error_data({ "environment": [{ "message": "Object with slug or primary key bluup does not exist.", "code": "does_not_exist" }] }) ) == 'environment:\n * Object with slug or primary key bluup does not exist. (code: does_not_exist)'
def _compute_col_sizes(self, data): sizes = {} # prepend data with header data = [dict(zip(self._cols, self._cols))] + data for row in data: for name, row_data in row.iteritems(): real_len = len(strip_ansi(row_data)) if name not in sizes or real_len > sizes[name]: sizes[name] = real_len # filter unknown values self._sizes = dict([(key, length + self.COL_PADDING) for key, length in sizes.iteritems() if key in self._cols])
def _tempfilepager(text, cmd, color): """Page through text by invoking a program on a temporary file.""" import tempfile filename = tempfile.mktemp() if not color: text = strip_ansi(text) encoding = get_best_encoding(sys.stdout) with open_stream(filename, 'wb')[0] as f: f.write(text.encode(encoding)) try: os.system(cmd + ' "' + filename + '"') finally: os.unlink(filename)
def print_child(p, depth=1, columns=0): output = ((' ' * depth) + click.style(str(p.pid), fg='cyan', bold=True) + ' ' + collapse_home(clean(' '.join(p.cmdline())))) stripped_length = len(strip_ansi(output)) if columns and stripped_length > columns: output = output[0:-(stripped_length - columns + 6)] + '...' click.echo(output) depth += 1 for c in p.children(): print_child(c, depth, columns)
def add_dir_entries(backup_run, filtered_dir_entries, result): total_size = sum([entry.stat.st_size for entry in filtered_dir_entries]) print(("total size:", human_filesize(total_size))) path_iterator = sorted( filtered_dir_entries, key=lambda x: x.stat.st_mtime, # sort by last modify time reverse=True # sort from newest to oldes ) # FIXME: The process bar will stuck if many small/null byte files are processed # Maybe: Change from bytes to file count and use a second bar if a big file # hash will be calculated. with tqdm(total=total_size, unit='B', unit_scale=True) as process_bar: for dir_entry in path_iterator: try: add_dir_entry(backup_run, dir_entry, process_bar, result) except Exception as err: # A unexpected error occurred. # Print and add traceback to summary log.error("Can't backup %s: %s" % (dir_entry, err)) for line in exc_plus(): log.error(strip_ansi(line))
def display_columns(self, rows: Sequence[Sequence[str]], header: Optional[List[str]] = None) -> None: """Print rows in aligned columns. :param rows: a rows of data to be displayed. :param header: a list of header strings. """ def get_aligner(align: str) -> Callable: if align == ">": return rjust if align == "^": return centerize else: return ljust sizes = list( map( lambda column: max(map(lambda x: len(strip_ansi(x)), column)), zip_longest(header or [], *rows, fillvalue=""), )) aligners = [ljust] * len(sizes) if header: aligners = [] for i, head in enumerate(header): aligners.append(get_aligner(head[0])) if head[0] in (">", "^", "<"): header[i] = head[1:] self.echo(" ".join( aligner(head, size) for aligner, head, size in zip(aligners, header, sizes))) # Print a separator self.echo(" ".join("-" * size for size in sizes)) for row in rows: self.echo(" ".join( aligner(item, size) for aligner, item, size in zip(aligners, row, sizes)))
def __call__(self, *parts, sep=" ", end="\n", flush=False): print(*parts, sep=sep, end=end, flush=flush) self.summary_file.write(sep.join([strip_ansi(str(i)) for i in parts])) self.summary_file.write(end) if flush: self.summary_file.flush()
def _str(self, data, size): str_real_len = len(strip_ansi(data)) return data + (" " * (size - str_real_len))
def centerize(text: str, length: int) -> str: """Centerize the text while ignoring ANSI controlling characters.""" space_num = length - len(strip_ansi(text)) left_space = space_num // 2 return " " * left_space + text + " " * (space_num - left_space)
def rjust(text: str, length: int) -> str: """Like str.rjust() but ignore all ANSI controlling characters.""" return " " * (length - len(strip_ansi(text))) + text
def _nullpager(stream, text, color): """Simply print unformatted text. This is the ultimate fallback.""" if not color: text = strip_ansi(text) stream.write(text)