287 lines
9.8 KiB
Python
287 lines
9.8 KiB
Python
"""
|
|
|
|
Helper functions for writing to terminals and files.
|
|
|
|
"""
|
|
|
|
|
|
import sys, os
|
|
import py
|
|
|
|
win32_and_ctypes = False
|
|
if sys.platform == "win32":
|
|
try:
|
|
import ctypes
|
|
win32_and_ctypes = True
|
|
except ImportError:
|
|
pass
|
|
|
|
def _getdimensions():
|
|
import termios,fcntl,struct
|
|
call = fcntl.ioctl(1,termios.TIOCGWINSZ,"\000"*8)
|
|
height,width = struct.unpack( "hhhh", call ) [:2]
|
|
return height, width
|
|
|
|
|
|
def get_terminal_width():
|
|
try:
|
|
height, width = _getdimensions()
|
|
except py.builtin._sysex:
|
|
raise
|
|
except:
|
|
# FALLBACK
|
|
width = int(os.environ.get('COLUMNS', 80))
|
|
else:
|
|
# XXX the windows getdimensions may be bogus, let's sanify a bit
|
|
if width < 40:
|
|
width = 80
|
|
return width
|
|
|
|
terminal_width = get_terminal_width()
|
|
|
|
# XXX unify with _escaped func below
|
|
def ansi_print(text, esc, file=None, newline=True, flush=False):
|
|
if file is None:
|
|
file = sys.stderr
|
|
text = text.rstrip()
|
|
if esc and not isinstance(esc, tuple):
|
|
esc = (esc,)
|
|
if esc and sys.platform != "win32" and file.isatty():
|
|
text = (''.join(['\x1b[%sm' % cod for cod in esc]) +
|
|
text +
|
|
'\x1b[0m') # ANSI color code "reset"
|
|
if newline:
|
|
text += '\n'
|
|
|
|
if esc and win32_and_ctypes and file.isatty():
|
|
if 1 in esc:
|
|
bold = True
|
|
esc = tuple([x for x in esc if x != 1])
|
|
else:
|
|
bold = False
|
|
esctable = {() : FOREGROUND_WHITE, # normal
|
|
(31,): FOREGROUND_RED, # red
|
|
(32,): FOREGROUND_GREEN, # green
|
|
(33,): FOREGROUND_GREEN|FOREGROUND_RED, # yellow
|
|
(34,): FOREGROUND_BLUE, # blue
|
|
(35,): FOREGROUND_BLUE|FOREGROUND_RED, # purple
|
|
(36,): FOREGROUND_BLUE|FOREGROUND_GREEN, # cyan
|
|
(37,): FOREGROUND_WHITE, # white
|
|
(39,): FOREGROUND_WHITE, # reset
|
|
}
|
|
attr = esctable.get(esc, FOREGROUND_WHITE)
|
|
if bold:
|
|
attr |= FOREGROUND_INTENSITY
|
|
STD_OUTPUT_HANDLE = -11
|
|
STD_ERROR_HANDLE = -12
|
|
if file is sys.stderr:
|
|
handle = GetStdHandle(STD_ERROR_HANDLE)
|
|
else:
|
|
handle = GetStdHandle(STD_OUTPUT_HANDLE)
|
|
oldcolors = GetConsoleInfo(handle).wAttributes
|
|
attr |= (oldcolors & 0x0f0)
|
|
SetConsoleTextAttribute(handle, attr)
|
|
file.write(text)
|
|
SetConsoleTextAttribute(handle, oldcolors)
|
|
else:
|
|
file.write(text)
|
|
|
|
if flush:
|
|
file.flush()
|
|
|
|
def should_do_markup(file):
|
|
return hasattr(file, 'isatty') and file.isatty() \
|
|
and os.environ.get('TERM') != 'dumb' \
|
|
and not (sys.platform.startswith('java') and os._name == 'nt')
|
|
|
|
class TerminalWriter(object):
|
|
_esctable = dict(black=30, red=31, green=32, yellow=33,
|
|
blue=34, purple=35, cyan=36, white=37,
|
|
Black=40, Red=41, Green=42, Yellow=43,
|
|
Blue=44, Purple=45, Cyan=46, White=47,
|
|
bold=1, light=2, blink=5, invert=7)
|
|
|
|
# XXX deprecate stringio argument
|
|
def __init__(self, file=None, stringio=False, encoding=None):
|
|
|
|
if file is None:
|
|
if stringio:
|
|
self.stringio = file = py.io.TextIO()
|
|
else:
|
|
file = py.std.sys.stdout
|
|
if hasattr(file, 'encoding'):
|
|
encoding = file.encoding
|
|
elif hasattr(file, '__call__'):
|
|
file = WriteFile(file, encoding=encoding)
|
|
self.encoding = encoding
|
|
self._file = file
|
|
self.fullwidth = get_terminal_width()
|
|
self.hasmarkup = should_do_markup(file)
|
|
|
|
def _escaped(self, text, esc):
|
|
if esc and self.hasmarkup:
|
|
text = (''.join(['\x1b[%sm' % cod for cod in esc]) +
|
|
text +'\x1b[0m')
|
|
return text
|
|
|
|
def markup(self, text, **kw):
|
|
esc = []
|
|
for name in kw:
|
|
if name not in self._esctable:
|
|
raise ValueError("unknown markup: %r" %(name,))
|
|
if kw[name]:
|
|
esc.append(self._esctable[name])
|
|
return self._escaped(text, tuple(esc))
|
|
|
|
def sep(self, sepchar, title=None, fullwidth=None, **kw):
|
|
if fullwidth is None:
|
|
fullwidth = self.fullwidth
|
|
# the goal is to have the line be as long as possible
|
|
# under the condition that len(line) <= fullwidth
|
|
if title is not None:
|
|
# we want 2 + 2*len(fill) + len(title) <= fullwidth
|
|
# i.e. 2 + 2*len(sepchar)*N + len(title) <= fullwidth
|
|
# 2*len(sepchar)*N <= fullwidth - len(title) - 2
|
|
# N <= (fullwidth - len(title) - 2) // (2*len(sepchar))
|
|
N = (fullwidth - len(title) - 2) // (2*len(sepchar))
|
|
fill = sepchar * N
|
|
line = "%s %s %s" % (fill, title, fill)
|
|
else:
|
|
# we want len(sepchar)*N <= fullwidth
|
|
# i.e. N <= fullwidth // len(sepchar)
|
|
line = sepchar * (fullwidth // len(sepchar))
|
|
# in some situations there is room for an extra sepchar at the right,
|
|
# in particular if we consider that with a sepchar like "_ " the
|
|
# trailing space is not important at the end of the line
|
|
if len(line) + len(sepchar.rstrip()) <= fullwidth:
|
|
line += sepchar.rstrip()
|
|
|
|
self.line(line, **kw)
|
|
|
|
def write(self, s, **kw):
|
|
if s:
|
|
if not isinstance(self._file, WriteFile):
|
|
s = self._getbytestring(s)
|
|
if self.hasmarkup and kw:
|
|
s = self.markup(s, **kw)
|
|
self._file.write(s)
|
|
self._file.flush()
|
|
|
|
def _getbytestring(self, s):
|
|
# XXX review this and the whole logic
|
|
if self.encoding and sys.version_info[0] < 3 and isinstance(s, unicode):
|
|
return s.encode(self.encoding)
|
|
elif not isinstance(s, str):
|
|
try:
|
|
return str(s)
|
|
except UnicodeEncodeError:
|
|
return "<print-error '%s' object>" % type(s).__name__
|
|
return s
|
|
|
|
def line(self, s='', **kw):
|
|
self.write(s, **kw)
|
|
self.write('\n')
|
|
|
|
class Win32ConsoleWriter(TerminalWriter):
|
|
def write(self, s, **kw):
|
|
if s:
|
|
oldcolors = None
|
|
if self.hasmarkup and kw:
|
|
handle = GetStdHandle(STD_OUTPUT_HANDLE)
|
|
oldcolors = GetConsoleInfo(handle).wAttributes
|
|
default_bg = oldcolors & 0x00F0
|
|
attr = default_bg
|
|
if kw.pop('bold', False):
|
|
attr |= FOREGROUND_INTENSITY
|
|
|
|
if kw.pop('red', False):
|
|
attr |= FOREGROUND_RED
|
|
elif kw.pop('blue', False):
|
|
attr |= FOREGROUND_BLUE
|
|
elif kw.pop('green', False):
|
|
attr |= FOREGROUND_GREEN
|
|
else:
|
|
attr |= FOREGROUND_BLACK # (oldcolors & 0x0007)
|
|
|
|
SetConsoleTextAttribute(handle, attr)
|
|
if not isinstance(self._file, WriteFile):
|
|
s = self._getbytestring(s)
|
|
self._file.write(s)
|
|
self._file.flush()
|
|
if oldcolors:
|
|
SetConsoleTextAttribute(handle, oldcolors)
|
|
|
|
def line(self, s="", **kw):
|
|
self.write(s+"\n", **kw)
|
|
|
|
class WriteFile(object):
|
|
def __init__(self, writemethod, encoding=None):
|
|
self.encoding = encoding
|
|
self._writemethod = writemethod
|
|
|
|
def write(self, data):
|
|
if self.encoding:
|
|
data = data.encode(self.encoding)
|
|
self._writemethod(data)
|
|
|
|
def flush(self):
|
|
return
|
|
|
|
|
|
if win32_and_ctypes:
|
|
TerminalWriter = Win32ConsoleWriter
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
|
|
# ctypes access to the Windows console
|
|
STD_OUTPUT_HANDLE = -11
|
|
STD_ERROR_HANDLE = -12
|
|
FOREGROUND_BLACK = 0x0000 # black text
|
|
FOREGROUND_BLUE = 0x0001 # text color contains blue.
|
|
FOREGROUND_GREEN = 0x0002 # text color contains green.
|
|
FOREGROUND_RED = 0x0004 # text color contains red.
|
|
FOREGROUND_WHITE = 0x0007
|
|
FOREGROUND_INTENSITY = 0x0008 # text color is intensified.
|
|
BACKGROUND_BLACK = 0x0000 # background color black
|
|
BACKGROUND_BLUE = 0x0010 # background color contains blue.
|
|
BACKGROUND_GREEN = 0x0020 # background color contains green.
|
|
BACKGROUND_RED = 0x0040 # background color contains red.
|
|
BACKGROUND_WHITE = 0x0070
|
|
BACKGROUND_INTENSITY = 0x0080 # background color is intensified.
|
|
|
|
SHORT = ctypes.c_short
|
|
class COORD(ctypes.Structure):
|
|
_fields_ = [('X', SHORT),
|
|
('Y', SHORT)]
|
|
class SMALL_RECT(ctypes.Structure):
|
|
_fields_ = [('Left', SHORT),
|
|
('Top', SHORT),
|
|
('Right', SHORT),
|
|
('Bottom', SHORT)]
|
|
class CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
|
|
_fields_ = [('dwSize', COORD),
|
|
('dwCursorPosition', COORD),
|
|
('wAttributes', wintypes.WORD),
|
|
('srWindow', SMALL_RECT),
|
|
('dwMaximumWindowSize', COORD)]
|
|
|
|
def GetStdHandle(kind):
|
|
return ctypes.windll.kernel32.GetStdHandle(kind)
|
|
|
|
SetConsoleTextAttribute = \
|
|
ctypes.windll.kernel32.SetConsoleTextAttribute
|
|
|
|
def GetConsoleInfo(handle):
|
|
info = CONSOLE_SCREEN_BUFFER_INFO()
|
|
ctypes.windll.kernel32.GetConsoleScreenBufferInfo(\
|
|
handle, ctypes.byref(info))
|
|
return info
|
|
|
|
def _getdimensions():
|
|
handle = GetStdHandle(STD_OUTPUT_HANDLE)
|
|
info = GetConsoleInfo(handle)
|
|
# Substract one from the width, otherwise the cursor wraps
|
|
# and the ending \n causes an empty line to display.
|
|
return info.dwSize.Y, info.dwSize.X - 1
|
|
|