Elep

def str_as_atr(s):
    if s == '_':
        return []
    atr = []
    i = 0
    while i < len(s):
        v = s[i]
        if i + 1 < len(s) and s[i+1].isdigit():
            n = 0
            i = i + 1
            while i < len(s) and s[i].isdigit():
                n = n * 10 + int(s[i])
                i += 1
        else:
            i += 1
            n = 1
        for j in range(n):
            atr.append(v)
    return atr

def atr_as_str(atr):
    if not atr:
        return '_'
    prefl = []
    prestr = ''.join([str(x) for x in atr])
    i = 0
    while i < len(prestr):
        c = prestr[i]
        j = i+1
        while j < len(prestr) and prestr[j] == c:
            j += 1
        if j - i > 2:
            prefl.append(c)
            prefl.append(str(j-i))
        else:
            while i < j:
                prefl.append(c)
                i += 1
        i = j
    return ''.join(prefl)

def str_as_ixl(s):
    return [ord(ch)-ord('a') for ch in str_as_atr(s)]

def ixl_as_str(ixl):
    return atr_as_str([chr(ix + ord('a')) for ix in ixl])

class Paths:
    def __init__(self, mod, rp, key, extended=True, andsets=(), variant=2):
        self.mod = mod
        self._hiding_tag_ = mod._hiding_tag_
        self.key = key
        self.rp = rp
        self.extended = extended
        self.srcrow = rp.get_row(self.key)
        self.variant = variant
        self.andsetbyname = {}
        row = self.srcrow
        while row is not None:
            self.andsetbyname[row.ixlstr] = mod.Use.Anything
            row = row.parent

if isinstance(andsets, dict):
            self.andsetbyname.update(andsets)
        elif isinstance(andsets, (tuple, list)):
            row = self.srcrow
            for i, s in enumerate(andsets):
                if row is None:
                    raise ValueError('andsets argument is too long')
                if s is not None:
                    self.andsetbyname[row.ixlstr] = s
                row = row.parent
        else:
            raise TypeError('andsets argument must be dict, tuple, or list')

mod.OutputHandling.setup_printing(
            self,
            stop_only_when_told=variant >= 2)

def get_str_of_path_component_singleton(self, set):
        return set.brief.lstrip('<1 ').rstrip('>')

def source_to_target_info(self):
        src = 'Source'
        tgt = 'Target'
        via = 'Via'

row = self.srcrow
        indent = 0
        while row is not None:
            if row.parent is None:
                a = tgt
            elif row is srcrow:
                a = src
            else:
                a = via
            a = ' '*indent + a
            name = row.ixlstr
            a = a + ' ' + ' '*(8+srcrow.depth*indinc -
                               len(name)-len(a)) + name + ': '
            yield a+row.getsummary(mod.line_length-len(a))
            row = row.parent
            indent += indinc

def _oh_get_label(self):
        return 'Paths from source %r to target %r.' % (self.srcrow.ixlstr, '_')

def _oh_get_line_iter(self):
        return getattr(self, 'get_line_iter_%s' % (self.variant,))()

def _oh_get_more_state_msg(self, startindex, lastindex):
        return ''

def get_line_iter_1(self):
        # Original variant indenting from left to right

mod = self.mod

srcrow = self.srcrow
        srcset = srcrow.set

indinc = 2
        if srcrow.depth >= 10:
            indinc = 1

def genlines(row, ks, indent=0):
            par = row.parent
            for key, i, set in ks:
                sidx = '%s[%d]' % (row.ixlstr, i)

if self.extended:
                    strsing = self.get_str_of_path_component_singleton(set)
                else:
                    strsing = ''
                vline = '%s %s %s %s' % (
                    key,
                    ' '*(40-len(key) - len(sidx)),
                    sidx,
                    strsing
                )

yield vline

if par is None:
                    continue

def get_nks(key, set):
                    parset = set.referents & par.set
                    for i, p in enumerate(parset.byid.parts):
                        rels = mod.Path.relations(set.theone, p.theone)
                        for rel in rels:
                            if rel is mod.Path.identity:
                                continue
                            if rel is mod.Path.norelation:
                                k = '??'
                            else:
                                k = str(rel) % ''
                            k = ' '*(indent+indinc)+k
                            yield k, i, p

for line in genlines(par, get_nks(key, set), indent+indinc):
                    yield line

def get_ks():
            for i, s in enumerate(srcset.byid.parts):
                k = '[%d]  ' % i
                k = k + (' -'*20)[:36-len(k)-srcrow.depth]
                yield k, i, s

for line in genlines(srcrow, get_ks()):
            yield line
        return

def get_line_iter_2(self):
        # Newer variant

mod = self.mod

srcrow = self.srcrow

indinc = 1
        if srcrow.depth >= 10:
            indinc = 1

lno = [0]

seen = {}

indir = 1

if indir == 1:
            max_ixlstr_len = 0
            max_str_len_set = 0
            row = srcrow
            while row:
                if len(row.ixlstr) > max_ixlstr_len:
                    max_ixlstr_len = len(row.ixlstr)
                if len(str(len(row.set.nodes))) > max_str_len_set:
                    max_str_len_set = len(str(len(row.set.nodes)))
                row = row.parent

def genlines(row, part, idx):

seen[part.nodes, row.depth] = lno[0]
            sidx = row.ixlstr
            idxs = '[%d]' % idx
            if indir < 0:
                indent = (row.depth)*indinc
                sidx = '%s%s%s' % (
                    sidx, ' '*(6+indent-len(sidx)-len(idxs)), idxs)
                if row.parent is None:
                    sidx += ' == %s' % part.brief

else:
                #idxs = ('[%.'+str(max_str_len_set)+'d]')%idx
                sidx = '%s%s%s' % (sidx,
                                   ' '*(3+max_str_len_set +
                                        max_ixlstr_len-len(sidx)-len(idxs)),
                                   idxs)
                sidx += ' ' * (srcrow.depth + 1 - row.depth)
                if row.parent is not None:
                    sidx += '@'
                else:
                    sidx += '= %s' % part.brief

if row.parent is None:
                #vline += ' == %s'%self.get_str_of_path_component_singleton(part)
                vline = '%2s: %s' % (lno[0], sidx)
                lno[0] += 1
                yield ('STOP_AFTER', vline)
                return

referents = part.referents & row.parent.set & self.andsetbyname[row.parent.ixlstr]
            relations = mod.Path.relations
            iso = mod.Use.iso
            s = part.theone
            t = [(relations(s, p.theone), p.by(referents.er), i)
                 for (i, p) in enumerate(referents.byid.parts)]
            for (rels, p, i) in t:
                relstrings = []
                for rel in rels:
                    if rel is mod.Path.identity:
                        continue
                    if rel is mod.Path.norelation:
                        k = '??'
                    else:
                        k = str(rel) % ''
                    relstrings.append(k)

relsstr = ' / '.join(relstrings)
                seenlno = seen.get((p.nodes, row.parent.depth))
                vline = '%2s: %s' % (lno[0], sidx)
                lno[0] += 1
                if seenlno is not None:
                    relsstr += ' -> #%d' % seenlno
                    yield ('STOP_AFTER', vline + ' ' + relsstr)
                else:
                    yield vline + ' ' + relsstr
                    for line in genlines(row.parent, p, i):
                        yield line

for i, p in enumerate((srcrow.set & self.andsetbyname[srcrow.ixlstr]).byid.parts):
            for line in genlines(srcrow, p, i):
                yield line

class RefPatIter:
    def __init__(self, rp, start=0):
        self.rp = rp
        self._hiding_tag_ = rp._hiding_tag_
        self.ix = start

def __iter__(self):
        return self

def __next__(self):
        try:
            x = self.rp[self.ix]
        except IndexError:
            raise StopIteration
        self.ix += 1
        return x

class RefPatRow:
    def __init__(self, rp, kindset, seenline, ixl, parent):
        self.rp = rp
        self._hiding_tag_ = rp._hiding_tag_
        self.kindset = kindset
        self.kind, self.set = kindset
        assert self.set <= self.kind
        self.seenline = seenline
        self.ixl = ixl[:]
        self.parent = parent
        if parent is not None:
            self.depth = parent.depth + 1
        else:
            self.depth = 0

self.index = 0
        self.maxdepth = rp.depth
        self.max_str_len = rp.mod.line_length
        self.ixlstr = ixl_as_str(ixl)
        self.isready = 0
        self.children = []

def __str__(self):
        prestr = '%2d: %s ' % (self.index, self.ixlstr)

if self.index & 1:
            fillpat = ' ' * 100
        else:
            fillpat = '-'*100

lps = len(prestr)
        fill = fillpat[lps:9+self.depth]

if self.seenline:
            ref = '[^ %s]' % self.seenline.index
        elif self.isroot:
            ref = '[R]'
        elif self.depth > 0 and self.set <= self.rp.stopkind:
            ref = '[S]'
        elif self.depth < self.maxdepth:
            ref = '[-]'
        else:
            ref = '[+]'

prefix = '%s%s %s ' % (prestr, fill, ref)
        return '%s%s' % (prefix, self.getsummary(self.max_str_len-len(prefix)))

def getchild(self, ix):
        while ix >= len(self.children) and not self.isready:
            self.rp.generate(len(self.rp.lines))
        return self.children[ix]

def getsummary(self, max_len):
        kind, set = self.kind, self.set
        summary = set.fam.get_str_refpat(set, kind, max_len)
        return summary

class ReferencePattern:
    __doc__ = '<Help Text'
    help = """\
Methods

"""

def __init__(self, mod, set, depth, er, relimg, bf, stopkind, nocyc):
        self.mod = mod
        self._hiding_tag_ = mod._hiding_tag_
        self.View = mod.View
        self.set = set
        self.depth = depth
        self.er = er
        self.bf = bf
        self.stopkind = stopkind
        self.nocyc = nocyc
        self.is_initialized = 0

self.totcount = set.count
        self.totsize = set.indisize
        self.kind = set.kind
        self.kindset = (self.kind, self.set)
        self.relimg = relimg
        self.top = self

mod.OutputHandling.setup_printing(self)
        self.View.referrers_add_target(self)
        self.reset_nogc()
        self.is_initialized = 1

def __getattr__(self, s):
        if not self.is_initialized:
            raise AttributeError(s)

try:
            return getattr(self.__class__, s)
        except AttributeError:
            pass
        try:
            row = self.get_row_named(s)
        except ValueError:
            raise AttributeError(s)
        return row.set

def __getitem__(self, ix):
        return self.get_row_indexed(ix).set

def __iter__(self, start=0):
        return RefPatIter(self, start)

def __len__(self):
        self.generate()
        return len(self.lines)

def _oh_get_label(self):
        return 'Reference Pattern by <' + self.er.classifier.get_byname() + '>.'

def _oh_get_more_state_msg(self, startindex, lastindex):
        if self.isfullygenerated:
            msg = '%d more lines. ' % (len(self.lines) - 1-lastindex,)
        else:
            msg = ''
        return msg

def _oh_get_line_iter(self):
        it = self.iterlines(0)
        for el in it:
            yield str(el)

def generate(self, ix=None):
        while ix is None or ix < 0 or ix >= len(self.lines):
            try:
                self.lines.append(next(self.lg))
            except StopIteration:
                self.isfullygenerated = 1
                return
            self.lines[-1].index = len(self.lines) - 1

def get_row(self, key):
        try:
            [][key]
        except TypeError:
            return self.get_row_named(key)
        except IndexError:
            return self.get_row_indexed(key)

def get_row_indexed(self, ix):
        self.generate(ix)
        return self.lines[ix]

def get_row_named(self, name):
        row = self.get_row_indexed(0)
        for ix in str_as_ixl(name):
            try:
                row = row.getchild(ix)
            except IndexError:
                raise ValueError(
                    'Reference pattern has no row named %r' % name)
        return row

def iterlines(self, start=None):
        if start is None:
            start = 0
        while 1:
            try:
                yield self.get_row_indexed(start)
            except IndexError:
                return
            start += 1

def linegenerator(self, xxx_todo_changeme, ixl, parent=None):
        (kind, set) = xxx_todo_changeme
        seenline = self.seensets.get(set.nodes)
        ixl = list(ixl)
        line = RefPatRow(self, (kind, set), seenline=seenline,
                         ixl=ixl, parent=parent)
        children = self.get_children(line)
        line.isroot = not children
        if seenline is None:
            self.seensets[set.nodes] = line
        if parent is not None:
            parent.children.append(line)
        yield line

depth = line.depth
        if (not seenline and depth < self.depth and
                (depth == 0 or not (set <= self.stopkind))):
            for i, cs in enumerate(children):
                ixl.append(i)
                for rl in self.linegenerator(cs, ixl, line):
                    yield rl
                ixl.pop()
        line.isready = 1

def get_children(self, line):
        (kind, set) = line.kindset
        chset = self.relimg(set)
        if self.nocyc:
            while line is not None:
                chset -= line.set
                line = line.parent
        return [(row.kind, row.set)
                for row in self.get_partition(chset, self.er).get_rows()]

def get_partition(self, set, er):
        p = self.mod.Part.partition(set, er)
        return p

def paths(self, key, **kwds):
        return Paths(self.mod, self, key, **kwds)

def reset(self):
        self.reset_nogc()
        self.printer.reset()
        self.mod._root.gc.collect()

def reset_nogc(self):
        self.isfullygenerated = 0
        self.seensets = {}
        self.lines = []
        self.lg = self.linegenerator(self.kindset, [])
        self.lastindex = None

class _GLUECLAMP_:
    _preload_ = ('_hiding_tag_',)

depth = 7
    line_length = 80

_uniset_exports = ('rp',)
    _chgable_ = ('er',
                 'depth',
                 'line_length',
                 )

# 'module imports'

_imports_ = (
        '_parent:OutputHandling',
        '_parent:Part',
        '_parent:Path',
        '_parent:UniSet',
        '_parent:Use',
        '_parent:View',
        '_parent.View:_hiding_tag_',
    )

def _get_er(self): return self.Use.Clodo

def rp(self, X, depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None,
           nocyc=False, ref=None):
        """rp(X, depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None, nocyc=False, ref=None)
Reference pattern forming.
Arguments
        X       Set of objects for which a reference pattern is sought.
        depth   The depth to which the pattern will be generated. The
                default is taken from depth of this module.
        er      The equivalence relation to partition the referrers. The default
                is Clodo.
        imdom   If true, the immediate dominators will be used instead
                of the referrers. This will take longer time to calculate,
                but may be useful to reduce the complexity of the reference
                pattern.
        bf      If true, the pattern will be printed in breadth-first
                order instead of depth-first. (Experimental.)
        src     If specified, an alternative reference source instead
                of the default root.
        stopkind
        nocyc
        ref

Description
        Return a reference pattern object based on the objects in the set X.
        The reference pattern object is of class ReferencePattern. It is
        described in XXX.
"""
        if depth is None:
            depth = self.depth
        X = self.UniSet.idset_adapt(X)
        if src is not None:
            # Creates an entire new guppy tree
            # Mostly for testing purposes -
            # can likely cause type problems generally
            src = self.UniSet.idset_adapt(src)
            self = self._root.guppy.Root().guppy.heapy.RefPat
            self.View.root = tuple(src.nodes)
            X = self.Use.idset(X.nodes)

if er is None:
            er = self.er  # NEEDS to be loaded after new Classifier created
        if imdom:
            def relimg(X): return X.imdom
        elif ref is not None:
            if ref == 'gc':
                def relimg(X): return X.referrers_gc
            elif ref == 'gcx':
                relimg = (lambda x: x.referrers_gc
                          - self._root.guppy.sets.ImmNodeSet
                          - self._parent.heapyc.NodeGraph
                          - self.View.ObservationList)
            elif ref == 'imdom':
                def relimg(X): return X.imdom
            elif callable(ref):
                relimg = ref
            else:
                raise ValueError(
                    "ref should be 'gc', 'gcx', 'imdom', or a callable")
        else:
            def relimg(X): return X.referrers
        if stopkind is None:
            stopkind = self.stopkind
        rp = ReferencePattern(self, X, depth, er, relimg, bf, stopkind, nocyc)
        return rp