bazarr/libs/click/_termui_impl.py

622 lines
19 KiB
Python
Raw Normal View History

2019-12-10 20:09:51 +00:00
# -*- coding: utf-8 -*-
2018-10-31 16:08:29 +00:00
"""
2019-12-10 20:09:51 +00:00
click._termui_impl
~~~~~~~~~~~~~~~~~~
2018-10-31 16:08:29 +00:00
2019-12-10 20:09:51 +00:00
This module contains implementations for the termui module. To keep the
import time of Click down, some infrequently used functionality is
placed in this module and only imported as needed.
2018-10-31 16:08:29 +00:00
2019-12-10 20:09:51 +00:00
:copyright: © 2014 by the Pallets team.
:license: BSD, see LICENSE.rst for more details.
2018-10-31 16:08:29 +00:00
"""
2019-12-10 20:09:51 +00:00
2018-10-31 16:08:29 +00:00
import os
import sys
import time
import math
2019-12-10 20:09:51 +00:00
import contextlib
2018-10-31 16:08:29 +00:00
from ._compat import _default_text_stdout, range_type, PY2, isatty, \
2019-12-10 20:09:51 +00:00
open_stream, strip_ansi, term_len, get_best_encoding, WIN, int_types, \
CYGWIN
2018-10-31 16:08:29 +00:00
from .utils import echo
from .exceptions import ClickException
if os.name == 'nt':
BEFORE_BAR = '\r'
AFTER_BAR = '\n'
else:
BEFORE_BAR = '\r\033[?25l'
AFTER_BAR = '\033[?25h\n'
def _length_hint(obj):
"""Returns the length hint of an object."""
try:
return len(obj)
except (AttributeError, TypeError):
try:
get_hint = type(obj).__length_hint__
except AttributeError:
return None
try:
hint = get_hint(obj)
except TypeError:
return None
if hint is NotImplemented or \
2019-12-10 20:09:51 +00:00
not isinstance(hint, int_types) or \
2018-10-31 16:08:29 +00:00
hint < 0:
return None
return hint
class ProgressBar(object):
def __init__(self, iterable, length=None, fill_char='#', empty_char=' ',
bar_template='%(bar)s', info_sep=' ', show_eta=True,
show_percent=None, show_pos=False, item_show_func=None,
label=None, file=None, color=None, width=30):
self.fill_char = fill_char
self.empty_char = empty_char
self.bar_template = bar_template
self.info_sep = info_sep
self.show_eta = show_eta
self.show_percent = show_percent
self.show_pos = show_pos
self.item_show_func = item_show_func
self.label = label or ''
if file is None:
file = _default_text_stdout()
self.file = file
self.color = color
self.width = width
self.autowidth = width == 0
if length is None:
length = _length_hint(iterable)
if iterable is None:
if length is None:
raise TypeError('iterable or length is required')
iterable = range_type(length)
self.iter = iter(iterable)
self.length = length
self.length_known = length is not None
self.pos = 0
self.avg = []
self.start = self.last_eta = time.time()
self.eta_known = False
self.finished = False
self.max_width = None
self.entered = False
self.current_item = None
self.is_hidden = not isatty(self.file)
self._last_line = None
2019-12-10 20:09:51 +00:00
self.short_limit = 0.5
2018-10-31 16:08:29 +00:00
def __enter__(self):
self.entered = True
self.render_progress()
return self
def __exit__(self, exc_type, exc_value, tb):
self.render_finish()
def __iter__(self):
if not self.entered:
raise RuntimeError('You need to use progress bars in a with block.')
self.render_progress()
2019-12-10 20:09:51 +00:00
return self.generator()
def is_fast(self):
return time.time() - self.start <= self.short_limit
2018-10-31 16:08:29 +00:00
def render_finish(self):
2019-12-10 20:09:51 +00:00
if self.is_hidden or self.is_fast():
2018-10-31 16:08:29 +00:00
return
self.file.write(AFTER_BAR)
self.file.flush()
@property
def pct(self):
if self.finished:
return 1.0
return min(self.pos / (float(self.length) or 1), 1.0)
@property
def time_per_iteration(self):
if not self.avg:
return 0.0
return sum(self.avg) / float(len(self.avg))
@property
def eta(self):
if self.length_known and not self.finished:
return self.time_per_iteration * (self.length - self.pos)
return 0.0
def format_eta(self):
if self.eta_known:
2019-12-10 20:09:51 +00:00
t = int(self.eta)
2018-10-31 16:08:29 +00:00
seconds = t % 60
2019-12-10 20:09:51 +00:00
t //= 60
2018-10-31 16:08:29 +00:00
minutes = t % 60
2019-12-10 20:09:51 +00:00
t //= 60
2018-10-31 16:08:29 +00:00
hours = t % 24
2019-12-10 20:09:51 +00:00
t //= 24
2018-10-31 16:08:29 +00:00
if t > 0:
days = t
return '%dd %02d:%02d:%02d' % (days, hours, minutes, seconds)
else:
return '%02d:%02d:%02d' % (hours, minutes, seconds)
return ''
def format_pos(self):
pos = str(self.pos)
if self.length_known:
pos += '/%s' % self.length
return pos
def format_pct(self):
return ('% 4d%%' % int(self.pct * 100))[1:]
2019-12-10 20:09:51 +00:00
def format_bar(self):
2018-10-31 16:08:29 +00:00
if self.length_known:
bar_length = int(self.pct * self.width)
bar = self.fill_char * bar_length
bar += self.empty_char * (self.width - bar_length)
2019-12-10 20:09:51 +00:00
elif self.finished:
bar = self.fill_char * self.width
2018-10-31 16:08:29 +00:00
else:
2019-12-10 20:09:51 +00:00
bar = list(self.empty_char * (self.width or 1))
if self.time_per_iteration != 0:
bar[int((math.cos(self.pos * self.time_per_iteration)
/ 2.0 + 0.5) * self.width)] = self.fill_char
bar = ''.join(bar)
return bar
def format_progress_line(self):
show_percent = self.show_percent
info_bits = []
if self.length_known and show_percent is None:
show_percent = not self.show_pos
2018-10-31 16:08:29 +00:00
if self.show_pos:
info_bits.append(self.format_pos())
if show_percent:
info_bits.append(self.format_pct())
if self.show_eta and self.eta_known and not self.finished:
info_bits.append(self.format_eta())
if self.item_show_func is not None:
item_info = self.item_show_func(self.current_item)
if item_info is not None:
info_bits.append(item_info)
return (self.bar_template % {
'label': self.label,
2019-12-10 20:09:51 +00:00
'bar': self.format_bar(),
2018-10-31 16:08:29 +00:00
'info': self.info_sep.join(info_bits)
}).rstrip()
def render_progress(self):
from .termui import get_terminal_size
if self.is_hidden:
2019-12-10 20:09:51 +00:00
return
2018-10-31 16:08:29 +00:00
2019-12-10 20:09:51 +00:00
buf = []
# Update width in case the terminal has been resized
if self.autowidth:
old_width = self.width
self.width = 0
clutter_length = term_len(self.format_progress_line())
new_width = max(0, get_terminal_size()[0] - clutter_length)
if new_width < old_width:
buf.append(BEFORE_BAR)
buf.append(' ' * self.max_width)
self.max_width = new_width
self.width = new_width
clear_width = self.width
if self.max_width is not None:
clear_width = self.max_width
buf.append(BEFORE_BAR)
line = self.format_progress_line()
line_len = term_len(line)
if self.max_width is None or self.max_width < line_len:
self.max_width = line_len
buf.append(line)
buf.append(' ' * (clear_width - line_len))
line = ''.join(buf)
2018-10-31 16:08:29 +00:00
# Render the line only if it changed.
2019-12-10 20:09:51 +00:00
if line != self._last_line and not self.is_fast():
2018-10-31 16:08:29 +00:00
self._last_line = line
2019-12-10 20:09:51 +00:00
echo(line, file=self.file, color=self.color, nl=False)
2018-10-31 16:08:29 +00:00
self.file.flush()
def make_step(self, n_steps):
self.pos += n_steps
if self.length_known and self.pos >= self.length:
self.finished = True
if (time.time() - self.last_eta) < 1.0:
return
self.last_eta = time.time()
2019-12-10 20:09:51 +00:00
# self.avg is a rolling list of length <= 7 of steps where steps are
# defined as time elapsed divided by the total progress through
# self.length.
if self.pos:
step = (time.time() - self.start) / self.pos
else:
step = time.time() - self.start
self.avg = self.avg[-6:] + [step]
2018-10-31 16:08:29 +00:00
self.eta_known = self.length_known
def update(self, n_steps):
self.make_step(n_steps)
self.render_progress()
def finish(self):
self.eta_known = 0
self.current_item = None
self.finished = True
2019-12-10 20:09:51 +00:00
def generator(self):
"""
Returns a generator which yields the items added to the bar during
construction, and updates the progress bar *after* the yielded block
returns.
"""
if not self.entered:
raise RuntimeError('You need to use progress bars in a with block.')
2018-10-31 16:08:29 +00:00
if self.is_hidden:
2019-12-10 20:09:51 +00:00
for rv in self.iter:
yield rv
else:
for rv in self.iter:
self.current_item = rv
yield rv
self.update(1)
2018-10-31 16:08:29 +00:00
self.finish()
self.render_progress()
2019-12-10 20:09:51 +00:00
def pager(generator, color=None):
2018-10-31 16:08:29 +00:00
"""Decide what method to use for paging through text."""
stdout = _default_text_stdout()
if not isatty(sys.stdin) or not isatty(stdout):
2019-12-10 20:09:51 +00:00
return _nullpager(stdout, generator, color)
2018-10-31 16:08:29 +00:00
pager_cmd = (os.environ.get('PAGER', None) or '').strip()
if pager_cmd:
if WIN:
2019-12-10 20:09:51 +00:00
return _tempfilepager(generator, pager_cmd, color)
return _pipepager(generator, pager_cmd, color)
2018-10-31 16:08:29 +00:00
if os.environ.get('TERM') in ('dumb', 'emacs'):
2019-12-10 20:09:51 +00:00
return _nullpager(stdout, generator, color)
2018-10-31 16:08:29 +00:00
if WIN or sys.platform.startswith('os2'):
2019-12-10 20:09:51 +00:00
return _tempfilepager(generator, 'more <', color)
2018-10-31 16:08:29 +00:00
if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
2019-12-10 20:09:51 +00:00
return _pipepager(generator, 'less', color)
2018-10-31 16:08:29 +00:00
import tempfile
fd, filename = tempfile.mkstemp()
os.close(fd)
try:
if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
2019-12-10 20:09:51 +00:00
return _pipepager(generator, 'more', color)
return _nullpager(stdout, generator, color)
2018-10-31 16:08:29 +00:00
finally:
os.unlink(filename)
2019-12-10 20:09:51 +00:00
def _pipepager(generator, cmd, color):
2018-10-31 16:08:29 +00:00
"""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
c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
env=env)
encoding = get_best_encoding(c.stdin)
try:
2019-12-10 20:09:51 +00:00
for text in generator:
if not color:
text = strip_ansi(text)
c.stdin.write(text.encode(encoding, 'replace'))
2018-10-31 16:08:29 +00:00
except (IOError, KeyboardInterrupt):
pass
2019-12-10 20:09:51 +00:00
else:
c.stdin.close()
2018-10-31 16:08:29 +00:00
# Less doesn't respect ^C, but catches it for its own UI purposes (aborting
# search or other commands inside less).
#
# That means when the user hits ^C, the parent process (click) terminates,
# but less is still alive, paging the output and messing up the terminal.
#
# If the user wants to make the pager exit on ^C, they should set
# `LESS='-K'`. It's not our decision to make.
while True:
try:
c.wait()
except KeyboardInterrupt:
pass
else:
break
2019-12-10 20:09:51 +00:00
def _tempfilepager(generator, cmd, color):
2018-10-31 16:08:29 +00:00
"""Page through text by invoking a program on a temporary file."""
import tempfile
filename = tempfile.mktemp()
2019-12-10 20:09:51 +00:00
# TODO: This never terminates if the passed generator never terminates.
text = "".join(generator)
2018-10-31 16:08:29 +00:00
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)
2019-12-10 20:09:51 +00:00
def _nullpager(stream, generator, color):
2018-10-31 16:08:29 +00:00
"""Simply print unformatted text. This is the ultimate fallback."""
2019-12-10 20:09:51 +00:00
for text in generator:
if not color:
text = strip_ansi(text)
stream.write(text)
2018-10-31 16:08:29 +00:00
class Editor(object):
def __init__(self, editor=None, env=None, require_save=True,
extension='.txt'):
self.editor = editor
self.env = env
self.require_save = require_save
self.extension = extension
def get_editor(self):
if self.editor is not None:
return self.editor
for key in 'VISUAL', 'EDITOR':
rv = os.environ.get(key)
if rv:
return rv
if WIN:
return 'notepad'
for editor in 'vim', 'nano':
if os.system('which %s >/dev/null 2>&1' % editor) == 0:
return editor
return 'vi'
def edit_file(self, filename):
import subprocess
editor = self.get_editor()
if self.env:
environ = os.environ.copy()
environ.update(self.env)
else:
environ = None
try:
c = subprocess.Popen('%s "%s"' % (editor, filename),
env=environ, shell=True)
exit_code = c.wait()
if exit_code != 0:
raise ClickException('%s: Editing failed!' % editor)
except OSError as e:
raise ClickException('%s: Editing failed: %s' % (editor, e))
def edit(self, text):
import tempfile
text = text or ''
if text and not text.endswith('\n'):
text += '\n'
fd, name = tempfile.mkstemp(prefix='editor-', suffix=self.extension)
try:
if WIN:
encoding = 'utf-8-sig'
text = text.replace('\n', '\r\n')
else:
encoding = 'utf-8'
text = text.encode(encoding)
f = os.fdopen(fd, 'wb')
f.write(text)
f.close()
timestamp = os.path.getmtime(name)
self.edit_file(name)
if self.require_save \
and os.path.getmtime(name) == timestamp:
return None
f = open(name, 'rb')
try:
rv = f.read()
finally:
f.close()
return rv.decode('utf-8-sig').replace('\r\n', '\n')
finally:
os.unlink(name)
def open_url(url, wait=False, locate=False):
import subprocess
def _unquote_file(url):
try:
import urllib
except ImportError:
import urllib
if url.startswith('file://'):
url = urllib.unquote(url[7:])
return url
if sys.platform == 'darwin':
args = ['open']
if wait:
args.append('-W')
if locate:
args.append('-R')
args.append(_unquote_file(url))
null = open('/dev/null', 'w')
try:
return subprocess.Popen(args, stderr=null).wait()
finally:
null.close()
elif WIN:
if locate:
url = _unquote_file(url)
args = 'explorer /select,"%s"' % _unquote_file(
url.replace('"', ''))
else:
args = 'start %s "" "%s"' % (
wait and '/WAIT' or '', url.replace('"', ''))
return os.system(args)
2019-12-10 20:09:51 +00:00
elif CYGWIN:
if locate:
url = _unquote_file(url)
args = 'cygstart "%s"' % (os.path.dirname(url).replace('"', ''))
else:
args = 'cygstart %s "%s"' % (
wait and '-w' or '', url.replace('"', ''))
return os.system(args)
2018-10-31 16:08:29 +00:00
try:
if locate:
url = os.path.dirname(_unquote_file(url)) or '.'
else:
url = _unquote_file(url)
c = subprocess.Popen(['xdg-open', url])
if wait:
return c.wait()
return 0
except OSError:
if url.startswith(('http://', 'https://')) and not locate and not wait:
import webbrowser
webbrowser.open(url)
return 0
return 1
def _translate_ch_to_exc(ch):
2019-12-10 20:09:51 +00:00
if ch == u'\x03':
2018-10-31 16:08:29 +00:00
raise KeyboardInterrupt()
2019-12-10 20:09:51 +00:00
if ch == u'\x04' and not WIN: # Unix-like, Ctrl+D
raise EOFError()
if ch == u'\x1a' and WIN: # Windows, Ctrl+Z
2018-10-31 16:08:29 +00:00
raise EOFError()
if WIN:
import msvcrt
2019-12-10 20:09:51 +00:00
@contextlib.contextmanager
def raw_terminal():
yield
2018-10-31 16:08:29 +00:00
def getchar(echo):
2019-12-10 20:09:51 +00:00
# The function `getch` will return a bytes object corresponding to
# the pressed character. Since Windows 10 build 1803, it will also
# return \x00 when called a second time after pressing a regular key.
#
# `getwch` does not share this probably-bugged behavior. Moreover, it
# returns a Unicode object by default, which is what we want.
#
# Either of these functions will return \x00 or \xe0 to indicate
# a special key, and you need to call the same function again to get
# the "rest" of the code. The fun part is that \u00e0 is
# "latin small letter a with grave", so if you type that on a French
# keyboard, you _also_ get a \xe0.
# E.g., consider the Up arrow. This returns \xe0 and then \x48. The
# resulting Unicode string reads as "a with grave" + "capital H".
# This is indistinguishable from when the user actually types
# "a with grave" and then "capital H".
#
# When \xe0 is returned, we assume it's part of a special-key sequence
# and call `getwch` again, but that means that when the user types
# the \u00e0 character, `getchar` doesn't return until a second
# character is typed.
# The alternative is returning immediately, but that would mess up
# cross-platform handling of arrow keys and others that start with
# \xe0. Another option is using `getch`, but then we can't reliably
# read non-ASCII characters, because return values of `getch` are
# limited to the current 8-bit codepage.
#
# Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
# is doing the right thing in more situations than with `getch`.
2018-10-31 16:08:29 +00:00
if echo:
2019-12-10 20:09:51 +00:00
func = msvcrt.getwche
else:
func = msvcrt.getwch
rv = func()
if rv in (u'\x00', u'\xe0'):
# \x00 and \xe0 are control characters that indicate special key,
# see above.
rv += func()
2018-10-31 16:08:29 +00:00
_translate_ch_to_exc(rv)
return rv
else:
import tty
import termios
2019-12-10 20:09:51 +00:00
@contextlib.contextmanager
def raw_terminal():
2018-10-31 16:08:29 +00:00
if not isatty(sys.stdin):
f = open('/dev/tty')
fd = f.fileno()
else:
fd = sys.stdin.fileno()
f = None
try:
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
2019-12-10 20:09:51 +00:00
yield fd
2018-10-31 16:08:29 +00:00
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
sys.stdout.flush()
if f is not None:
f.close()
except termios.error:
pass
2019-12-10 20:09:51 +00:00
def getchar(echo):
with raw_terminal() as fd:
ch = os.read(fd, 32)
ch = ch.decode(get_best_encoding(sys.stdin), 'replace')
if echo and isatty(sys.stdout):
sys.stdout.write(ch)
_translate_ch_to_exc(ch)
return ch