Elep

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