%PDF-
%PDF-
Mini Shell
Mini Shell
import types
import weakref
# To restore the old-style class behavior that __getattr__ also affects special
# methods.
class _AttrProxy:
_oh_proxied_classes = weakref.WeakSet({type, object})
# Don'r rely on _oh_add_proxy_attr to prime us, some clients use
# setup_printing to setup __repr__ function.
def __repr__(self):
return self.__getattr__('__repr__')()
@classmethod
def _oh_add_proxy_attr(cls, attr):
if not attr.startswith('__') or not attr.endswith('__'):
return
for scls in cls.__mro__:
if scls is object:
break
if attr in scls.__dict__:
return
if attr in ('__new__', '__init__', '__getattr__',
'__getattribute__', '__setattr__', '__delattr__',
'__str__',
):
return
def closure(attr):
def generated_function(self, *args, **kwds):
func = self.__getattr__(attr)
return func(*args, **kwds)
return generated_function
setattr(cls, attr, closure(attr))
@classmethod
def _oh_add_proxy_class(cls, base):
if base in cls._oh_proxied_classes:
return
for scls in base.__mro__:
cls._oh_proxied_classes.add(scls)
for attr, val in scls.__dict__.items():
if not isinstance(val, types.FunctionType):
continue
cls._oh_add_proxy_attr(attr)
class OutputHandler:
def __init__(self, mod, output_file):
self.mod = mod
self.output_file = output_file
class OutputBuffer:
def __init__(self, mod, opts=None):
self.mod = mod
self.strio = mod._root.io.StringIO()
if opts is None:
opts = {}
self.opts = opts
self.lines = ['']
self.line_no = 0
def getopt(self, opt):
return self.opts.get(opt)
def getvalue(self):
return '\n'.join(self.lines)
def new_line(self):
self.line_no += 1
self.lines.append('')
def write(self, s):
lines = s.split('\n')
for line in lines[:-1]:
self.write_seg(line)
self.new_line()
self.write_seg(lines[-1])
def write_seg(self, s):
self.lines[self.line_no] += s
class AllPrinter(_AttrProxy):
_oh_next_lineno = None
def __init__(self, printer):
self._oh_printer = printer
self._hiding_tag_ = printer._hiding_tag_
def __getattr__(self, attr):
return self._oh_printer.getattr(self, attr)
def __repr__(self):
return self._oh_printer.get_str(self, True)
def _oh_get_next_lineno(self):
return 0
def _oh_get_start_lineno(self):
return 0
def _oh_get_max_lines(self, max_lines):
return None
class MorePrinter(_AttrProxy):
_oh_next_lineno = None
def __init__(self, printer, previous):
self._oh_printer = printer
self._oh_previous = previous
self._hiding_tag_ = printer._hiding_tag_
def __getattr__(self, attr):
return self._oh_printer.getattr(self, attr)
def _oh_get_next_lineno(self):
next_lineno = self._oh_next_lineno
if next_lineno is None:
repr(self)
next_lineno = self._oh_next_lineno
return next_lineno
def _oh_get_start_lineno(self):
return self._oh_previous._oh_get_next_lineno()
def _oh_get_max_lines(self, max_lines):
return max_lines
class Printer:
def __init__(self, mod, client, handler,
get_line_iter=None,
max_more_lines=None,
get_num_lines=None,
get_label=None,
get_row_header=None,
get_more_msg=None,
get_more_state_msg=None,
get_empty_msg=None,
stop_only_when_told=None
):
try:
handler = handler.printer.handler
except AttributeError:
pass
if get_line_iter is None:
get_line_iter = handler._oh_get_line_iter
if max_more_lines is None:
max_more_lines = mod.max_more_lines
self.mod = mod
self._hiding_tag_ = mod._hiding_tag_
self.client = client
self.handler = handler
self.get_line_iter = get_line_iter
self.max_more_lines = max_more_lines
if get_num_lines is None:
get_num_lines = getattr(
handler, '_oh_get_num_lines', None)
if get_num_lines is not None:
self.get_num_lines = get_num_lines
if get_label is None:
get_label = getattr(
handler, '_oh_get_label', None)
if get_label is not None:
self.get_label = get_label
if get_row_header is None:
get_row_header = getattr(
handler, '_oh_get_row_header', None)
if get_row_header is not None:
self.get_row_header = get_row_header
if get_more_msg is None:
get_more_msg = getattr(
handler, '_oh_get_more_msg', None)
if get_more_msg is not None:
self.get_more_msg = get_more_msg
if get_more_state_msg is None:
get_more_state_msg = getattr(
handler, '_oh_get_more_state_msg', None)
if get_more_state_msg is not None:
self.get_more_state_msg = get_more_state_msg
if get_empty_msg is None:
get_empty_msg = getattr(
handler, '_oh_get_empty_msg', None)
if get_empty_msg is not None:
self.get_empty_msg = get_empty_msg
self.stop_only_when_told = stop_only_when_told
self.reset()
def getattr(self, mp, attr):
try:
g = getattr(self, '_get_'+attr)
except AttributeError:
return getattr(self.client, attr)
else:
return g(mp)
def line_at(self, idx):
while idx >= len(self.lines_seen):
try:
li = next(self.line_iter)
except StopIteration:
raise IndexError
else:
if isinstance(li, tuple):
cmd, line = li
if cmd == 'STOP_AFTER':
self.stop_linenos[len(self.lines_seen)] = 1
else:
line = li
self.lines_seen.append(line)
return self.lines_seen[idx]
def lines_from(self, idx=0):
line_iter = self.line_iter
if line_iter is None:
line_iter = self.line_iter = self.get_line_iter()
while 1:
try:
yield self.line_at(idx)
except IndexError:
return
idx += 1
def _get_more(self, mp):
return MorePrinter(self, mp)
def _get_all(self, mp):
return AllPrinter(self)
def _oh_get_next_lineno(self):
next_lineno = getattr(self, '_oh_next_lineno', None)
if next_lineno is None:
self.get_str_of_top()
next_lineno = self._oh_next_lineno
return next_lineno
def _get_prev(self, mp):
return mp._oh_previous
def _oh_get_start_lineno(self):
return 0
def _oh_get_max_lines(self, max_lines):
return max_lines
def _get_top(self, mp):
return self.client
def _get___repr__(self, mp):
return lambda: self.get_str(mp, False)
def get_label(self):
return None
def get_row_header(self):
return None
def get_str_of_top(self):
return self.get_str(self, True)
def get_more_state_msg(self, start_lineno, end_lineno):
num_lines = self.get_num_lines()
if num_lines is None:
of_num_lines = ''
else:
of_num_lines = ' of %d' % num_lines
return "Lines %d..%d%s. " % (start_lineno, end_lineno, of_num_lines)
def get_more_msg(self, start_lineno, end_lineno):
state_msg = self.get_more_state_msg(start_lineno, end_lineno)
return "<%sType e.g. '_.more' for more.>" % (state_msg)
def get_empty_msg(self):
return None
def get_num_lines(self):
return None
def get_str(self, printer, is_top):
def f():
_hiding_tag_ = printer._hiding_tag_
start_lineno = printer._oh_get_start_lineno()
m_max_lines = printer._oh_get_max_lines(self.max_more_lines)
ob = self.mod.output_buffer()
it = self.lines_from(start_lineno)
if is_top:
msg = self.get_label()
if msg is not None:
print(msg, file=ob)
printer._oh_next_lineno = start_lineno
try:
nxt = next(it)
except StopIteration:
msg = self.get_empty_msg()
if msg is not None:
print(msg, file=ob)
printer._oh_next_lineno = start_lineno
else:
msg = self.get_row_header()
if msg is not None:
print(msg, file=ob)
it = self.mod.itertools.chain((nxt,), it)
numlines = 0
lineno = start_lineno
for line in it:
if (m_max_lines is not None and numlines >= m_max_lines and
((not self.stop_only_when_told) or self.stop_linenos.get(lineno-1))):
try:
self.line_at(lineno+1)
except IndexError:
print(line, file=ob)
lineno += 1
break
else:
print(self.get_more_msg(start_lineno, lineno-1), file=ob)
break
numlines += 1
print(line, file=ob)
lineno += 1
printer._oh_next_lineno = lineno
return ob.getvalue().rstrip()
return self.mod.View.enter(lambda: f())
def reset(self):
self.lines_seen = []
self.stop_linenos = {}
self.line_iter = None
class _GLUECLAMP_:
_chgable_ = 'output_file', 'max_more_lines',
_preload_ = ('_hiding_tag_',)
_imports_ = (
'_parent:View',
'_root:itertools',
)
max_more_lines = 10
def _get__hiding_tag_(self): return self._parent.View._hiding_tag_
def _get_output_file(self): return self._root.sys.stdout
def more_printer(self, client, handler=None, **kwds):
if handler is None:
handler = client
printer = Printer(self, client, handler, **kwds)
_AttrProxy._oh_add_proxy_class(client.__class__)
return MorePrinter(printer, printer)
def output_buffer(self):
return OutputBuffer(self)
def output_handler(self, output_file=None):
if output_file is None:
output_file = self.output_file
return OutputHandler(self, output_file)
def setup_printing(self, client, handler=None, **kwds):
if handler is None:
handler = client
more = self.more_printer(client, handler, **kwds)
printer = more._oh_printer
client.more = more
client.all = more.all
client.printer = printer
def reprfunc(self):
return self.printer.get_str_of_top()
# Don't recreate, messes with relheap, and this is not
# under _hiding_tag_
cls = client.__class__
if '__repr__' not in cls.__dict__:
cls.__repr__ = reprfunc
def _get_stdout(self): return self._root.sys.stdout
Zerion Mini Shell 1.0