Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📄 Cat.py class Graph: def __init__(self, objects, arrows): self.objects = objects # Sequence of objects self.arrows = arrows # Map[name] ->pair(object, object) def source(self, x): return self.arrows[x][0] def target(self, x): return self.arrows[x][1] def get_dual(self): objects = self.objects arrows = dict([(arrow, (tgt, src)) for (arrow, (src, tgt)) in list(self.arrows.items())]) return self.__class__(objects, arrows) class Cat: # Category presented by a graph (with objects and generators) and relations. def __init__(self, graph, relations): # category is defined by the parameters: # graph.objects: sequenceof(O) # graph.arrows: dict mapping(A, pairof(O in objects)) # relations: sequence(pairof(sequence(A), sequence(A))) self.graph = graph self.relations = relations def get_dual(self): graph = self.graph.get_dual() relations = dual_relations(self.relations) return self.__class__(graph, relations) class Functor: def __init__(self, fo, fa, src=None, tgt=None): self.fo = adapt_function(fo) self.fa = adapt_function(fa) self.src = src self.tgt = tgt class Function: def __init__(self, map, src, tgt): f = getattr(map, '__getitem__', None) if callable(f): pass else: f = map if not callable(f): raise TypeError( 'Function: map is neither callable or indexable') self.f = f self.src = src self.tgt = tgt def __getitem__(self, args): return self.f(args) def __call__(self, args, kwargs): return self.f(args, **kwargs) def __str__(self): return '%s(%s, %s, %s)' % (self.__class__, self.src, self.tgt, self.f) def asdict(self): return dict([(x, self[x]) for x in self.src]) def items(self): return [(x, self[x]) for x in self.src] def keys(self): return list(self.src) def values(self): return [v for (k, v) in list(self.items())] class Identity(Function): def __init__(self, src): Function.__init__(lambda x: x, src, src) def check_graph(G): # Check that G is a valid graph object # with arrows that have all source and target in G.objects Gob = G.objects for a in G.arrows: if not G.source(a) in Gob: raise ValueError( 'Arrow %r has source %r not in graph objects' % (a, G.source(a))) if not G.target(a) in Gob: raise ValueError( 'Arrow %r has target %r not in graph objects' % (a, G.target(a))) def check_rules(R, G): # Check that the rules in R contain valid composing arrows in graph G coms = [] for (left, right) in R: coms.append(left) coms.append(right) for com in coms: a0 = None for a in com: if a not in G.arrows: raise ValueError( 'Arrow %r, used in a rule, is not a valid arrow' % (a,)) if a0 is not None: if G.source(a) != G.target(a0): raise ValueError('''\ Source of arrow %r (%r) does not match target of arrow %r (%r)''' % ( a, G.source(a), a0, G.target(a0))) a0 = a def check_cat(C): check_graph(C.graph) check_rules(C.relations, C.graph) def oarcat(objects, arrows, relations): return Cat(Graph(objects, arrows), relations) def adapt_function(f): if not isinstance(f, Function): if isinstance(f, dict): src = list(f.keys()) tgt = list(f.values()) else: src = None tgt = None f = Function(f, src, tgt) return f def dual_relations(relations): dual = [] for (a, b) in relations: a = list(a) b = list(b) a.reverse() b.reverse() dual.append((tuple(a), tuple(b))) return dual	3.99 KB	2026-01-20 12:58
📄 Code.py def co_code_findloadednames(co): """Find in the code of a code object, all loaded names. (by LOAD_NAME, LOAD_GLOBAL or LOAD_FAST) """ import dis from opcode import HAVE_ARGUMENT, opmap hasloadname = (opmap['LOAD_NAME'], opmap['LOAD_GLOBAL'], opmap['LOAD_FAST']) insns = dis.get_instructions(co) len_co_names = len(co.co_names) indexset = {} for insn in insns: if insn.opcode >= HAVE_ARGUMENT: if insn.opcode in hasloadname: indexset[insn.argval] = 1 if len(indexset) >= len_co_names: break for name in co.co_varnames: try: del indexset[name] except KeyError: pass return indexset def co_findloadednames(co): """Find all loaded names in a code object and all its consts of code type""" names = {} names.update(co_code_findloadednames(co)) for c in co.co_consts: if isinstance(c, type(co)): names.update(co_findloadednames(c)) return names	1.03 KB	2026-01-20 12:58
📄 Descriptor.py import functools import inspect class property_nondata: '''@property, but using non-data descriptor protocol''' def __init__(self, fget): self.fget = fget functools.update_wrapper(self, fget) def __get__(self, instance, owner=None): return self.fget(instance) class property_exp(property): '''@property, but blacklist tab completers like rlcompleter from getattr''' def __init__(self, fget, *, doc=None): super().__init__(fget) self.__doc__ = doc def __get__(self, instance, owner=None): try: frame = inspect.currentframe() try: frame = frame.f_back if frame.f_globals['__name__'] == 'rlcompleter': return None finally: del frame except Exception: pass return super().__get__(instance, owner)	903 B	2026-01-20 12:58
📄 FSA.py class FiniteAutomaton: def __init__(self, start_state, dump_state=''): self.start_state = start_state self.dump_state = dump_state self.table = {self.dump_state: {}} self.unresolved_composites = [] self.resolved_composites = [] self.composite_memo = {} self.is_updated = 1 def __setitem__(self, xxx_todo_changeme, x): (state, symbol) = xxx_todo_changeme self.table.setdefault(state, {})[symbol] = x self.is_updated = 1 def add_transition(self, state, symbol, nexts): if len(nexts) == 1: c = nexts[0] else: for n in nexts: if n not in self.table: self.table[n] = {} c = self.new_composite(nexts) self[state, symbol] = c if c not in self.table: self.table[c] = {} def get_row_items(self, state): try: x = list(self.table[state].items()) except KeyError: return () ris = [] for k, v in x: if isinstance(v, CompositeState): for vi in v: ris.append((k, vi)) else: ris.append((k, v)) return ris def make_deterministic(self): # Resolve all unresolved composite states so we become deterministic while self.unresolved_composites: composites = self.unresolved_composites self.unresolved_composites = [] for c in composites: ds = {} l = [] for a in c: for k, v in self.get_row_items(a): ds.setdefault(k, []).append(v) for k, v in list(ds.items()): for a in c: if k not in self.table[a]: v.append(self.dump_state) break for k, v in list(ds.items()): self.add_transition(c, k, v) def get_all_input_symbols(self): syms = {} for state, trans in list(self.table.items()): for k, v in trans: syms[k] = 1 return syms def get_all_states(self): return self.table def get_all_final_states(self): return {} def get_composites(self): if self.is_updated: self.make_deterministic() return list(self.composite_memo.values()) def get_transition_classes(self): # Get classes of states that have the same outgoing transitions tc = {} tck = {} for k, v in list(self.table.items()): trans = list(v.keys()) trans.sort() trans = tuple(trans) ks = tc.get(trans) if ks is None: ks = [] tc[trans] = ks ks.append(k) tck[k] = ks return tc, tck def get_minimized_dfa(self, finals): def markall(finals, tcv, table): def psrmark(l): for pq in l: if pq in PS: l1 = PS[pq] del PS[pq] if l1: psrmark(l1) PS = {} for Q in tcv: for ip, p in enumerate(Q): for q in Q[ip+1:]: if (p in finals) == (q in finals): PS[(p, q)] = () for pq in list(PS.keys()): p, q = pq dp = table[p] dq = table[q] # Now we know they contain the same symbols dps = [] for a in dp: dpa = dp[a] dqa = dq[a] if dpa is not dqa: dpadqa = (dpa, dqa) if dpadqa in PS: dps.append(dpadqa) else: dqadpa = (dqa, dpa) if dqadpa in PS: dps.append(dqadpa) else: l = PS[pq] del PS[pq] if l is not (): psrmark(l) break else: for dpadqa in dps: l = PS[dpadqa] if l is (): l = [pq] PS[dpadqa] = l else: l.append(pq) return PS def combine(QS, PQS): eqs = {} for Q in QS: for p in Q: eqs[p] = [p] for p, q in PQS: # # Combine to equivalence classes # # Now we know that p, q are combinable # ep = eqs[p] eq = eqs[q] if eq is not ep: if len(eq) > len(ep): eq, ep = ep, eq ep.extend(eq) for q in eq: eqs[q] = ep return eqs def finalize(eqs): csbyid = {} # Composite state by identity of atomic state list csbyas = {} # Composite state by atomic state i = 0 for eq in list(eqs.values()): ideq = id(eq) if ideq not in csbyid: c = 'MS%d' % i i += 1 csbyid[ideq] = eq[0], c for s in eq: csbyas[s] = c fsa = self.__class__(csbyas[self.start_state]) fsa.final_states = {} for cs0, cst in list(csbyid.values()): fsa.table[cst] = trans = {} for a, s in list(self.table[cs0].items()): trans[a] = csbyas[s] if cs0 in finals: fsa.final_states[cst] = 1 return fsa if self.is_updated: self.make_deterministic() tctck = self._tctck = self.get_transition_classes() self.is_updated = 0 else: tctck = self._tctck tc, tck = tctck tcv = list(tc.values()) PS = markall(finals, tcv, self.table) eqs = combine(tcv, PS) fsa = finalize(eqs) return fsa def new_composite(self, args): cs = CompositeState(list(dict([(arg, 1) for arg in args]).keys())) if len(cs) == 1: return args[0] try: return self.composite_memo[cs] except KeyError: self.composite_memo[cs] = cs self.unresolved_composites.append(cs) return cs def pp(self): ks = list(self.table.keys()) ks.sort() num = dict([(s, i) for i, s in enumerate(ks)]) for s in ks: k = self.table[s] print('%d: %s' % (num[s], s)) cs = list(k.keys()) cs.sort() for c in cs: v = k[c] print(' %r -> #%d: %s' % (c, num[v], v)) class CompositeState(tuple): pass	7.2 KB	2026-01-20 12:58
📄 Glue.py import re import sys import types class GlueError(Exception): pass class RecursionError(GlueError): pass class NoSuchAttributeError(GlueError): pass def ispackage(m): """ Determine if a module is a package - that means, sub-modules can be imported Currently uses that it has a file name that matches '.__init__.py[co]?$' xxx is this portable/future-safe? """ try: name = m.__file__ except AttributeError: return 0 return re.match('.__init__.py[co]?$', name) def dotname(first, last): if first and last: return '%s.%s' % (first, last) else: return first + last class Interface(object): def __init__(self, share, owner, name): self.__dict__['_share'] = share self.__dict__['_owner'] = owner self.__dict__['_name'] = name for name in share.preload: getattr(self, name) def _import(self, names): return ','.join(names) + '=' + ','.join(['self._root.%s' % name for name in names]) def __getattr__(self, name): return self._share.getattr(self, name) def __setattr__(self, name, value): return self._share.setattr(self, name, value) class Owner: def __init__(self, name): self.name = name self.galog = {} self.salog = {} self.inters = {} def log_getattr(self, cache, name): name = dotname(cache['_name'], name) self.galog[name] = 1 def log_setattr(self, name): self.salog[name] = 1 def makeInterface(self, cache, share, name): name = dotname(cache['_name'], name) if share not in self.inters: Clamp = share.Clamp if Clamp is not None and issubclass(Clamp, Interface): NewInterface = Clamp else: NewInterface = Interface self.inters[share] = NewInterface(share, self, name) return self.inters[share] def pp(self, out=None, short=0): if out is None: out = sys.stdout if not short: print('Attributes used by %s:' % self.name, file=out) print(self.name[:self.name.rindex('.')+1], file=out) complete = [] for a in self.galog: for b in self.galog: if a != b and b.startswith(a): break else: complete.append(a) complete.sort() for a in complete: print(' ', a) class Share: __slots__ = ('module', 'parent', 'name', 'Clamp', 'setable', 'chgable', 'importedfrom', 'nowrap', 'wrapattr', 'wrapping', 'data', 'owners', 'ispackage', 'recursion', 'preload') has_getattr_logging_enabled = False def __init__(self, module, parent, name, Clamp): if parent is None: parent = self root = self else: root = parent.data['_root'] self.module = module self.parent = parent self.name = name self.Clamp = Clamp self.setable = getattr(Clamp, '_setable_', ()) if not isinstance(self.setable, tuple): raise TypeError(self.message( 'the _setable_ attribute must be a tuple')) self.chgable = getattr(Clamp, '_chgable_', ()) if not isinstance(self.chgable, tuple): raise TypeError(self.message( 'the _chgable_ attribute must be a tuple')) if Clamp is not None: for attr in Clamp.__dict__: if attr.startswith('_set_'): attr = attr[len('_set_'):] if attr not in self.setable and attr not in self.chgable: raise TypeError(self.message( '%s must be in either _setable_ or _chgable_ ' 'for _set_%s to work' % (attr, attr))) imports = getattr(Clamp, '_imports_', ()) if not isinstance(imports, tuple): raise TypeError(self.message( 'the _imports_ attribute must be a tuple')) self.importedfrom = {} pres = {} parent_inter = root_inter = None for fi in imports: presuf = fi.split(':') if len(presuf) != 2: if len(presuf) > 2: s = "Too many" else: s = "No" raise SyntaxError("%s ':' in import directive %r." % (s, fi)) pre, suf = presuf pre = pre.strip() prepa = pres.get(pre) if prepa is None: hdta = pre.split('.', 1) hd = hdta[0] if hd == '_parent': if parent_inter is None: parent_inter = Owner('').makeInterface( {'_name': ''}, parent, '') hdo = parent_inter elif hd == '_root': if root_inter is None: root_inter = Owner('').makeInterface( {'_name': ''}, root, '') hdo = root_inter else: raise SyntaxError( "Module must begin with _parent or _root") if len(hdta) == 2: prepa = [hdo, hdta[1], None] else: prepa = [hdo, '', hdo] pres[pre] = prepa sufs = suf.split(',') for su in sufs: su = su.strip() im = getattr(Clamp, '_get_%s' % su, None) if im is not None: raise ValueError( 'Cant have both name (=%r) in boht importfrom and _get' % su) self.importedfrom[su] = prepa self.nowrap = getattr(Clamp, '_nowrap_', ()) if not isinstance(self.nowrap, tuple): raise TypeError(self.message( 'the _nowrap_ attribute must be a tuple')) wrapattr = getattr(Clamp, '_wrapattr_', None) if not isinstance(wrapattr, types.FunctionType) and wrapattr is not None: raise TypeError(self.message( 'the _wrapattr_ attribute must be a method')) self.wrapattr = wrapattr self.wrapping = 0 self.data = {} self.owners = {} self.ispackage = module is None or ispackage(module) self.data['_parent'] = parent self.data['_root'] = root self.data['_module'] = module self.recursion = 0 preload = getattr(Clamp, '_preload_', ()) if preload: self.preload = () inter = Owner('').makeInterface({'_name': ''}, self, '') for name in preload: getattr(inter, name) for name in preload: assert name in self.data self.preload = preload def message(self, msg): return '%s: in %r: %s' % (self.__class__, self.name, msg) def getattr(self, inter, name): owner = inter._owner cache = inter.__dict__ d = self.getattr2(inter, cache, owner, name) if name not in self.chgable: cache[name] = d return d def getattr2(self, inter, cache, owner, name): if self.has_getattr_logging_enabled: owner.log_getattr(cache, name) if name not in self.data: try: self.recursion += 1 try: if self.ispackage: try: x = self.getattr3(inter, name) except NoSuchAttributeError: x = self.getattr_package(inter, name) else: x = self.getattr3(inter, name) except NoSuchAttributeError: if name == '__repr__': return lambda: str(inter) elif name == '__str__': return lambda: '<%s interface at %s>' % (inter._name, hex(id(self))) else: x = self.getattr_module(inter, name) wrapattr = self.wrapattr if wrapattr is not None and name not in self.nowrap: assert not self.wrapping try: self.wrapping = 1 x = wrapattr(inter, x, name) finally: self.wrapping = 0 self.data[name] = x finally: self.recursion -= 1 x = self.data[name] if isinstance(x, Share): x = owner.makeInterface(cache, x, name) return x def getattr_module(self, inter, name): try: return getattr(self.module, name) except AttributeError: raise AttributeError('Module %r or its _GLUECLAMP_ has no attribute %r' % ( self.module.__name__, name)) def getattr_package(self, inter, name): try: x = __import__(self.makeName(name)) except ImportError as exc: if (exc.args[0] != 'No module named \'%s\'' % self.makeName(name) or (not self.module and name not in ('__repr__', '__str__'))): raise x = self.getattr3(inter, name) # raise AttributeError, name else: if self.module: x = self.getattr_module(inter, name) if isinstance(x, types.ModuleType): x = self.makeModule(x, name) return x def getattr3(self, inter, name): if self.recursion >= 10: raise RecursionError(name) Clamp = self.Clamp if Clamp is None: raise NoSuchAttributeError(name) try: x = getattr(Clamp, name) except AttributeError: pass else: if isinstance(x, types.FunctionType): x = types.MethodType(x, inter) return x try: im = getattr(Clamp, '_get_%s' % name) except AttributeError: pass else: owner = self.makeOwner(name) inter = Interface(self, owner, '') f = types.MethodType(im, inter) x = f() if isinstance(x, Interface): x = x.__dict__['_share'] return x if name in self.importedfrom: prepa = self.importedfrom[name] hdo, ta, pa = prepa if pa is None: pa = hdo tas = ta.split('.') for at in tas: pa = getattr(pa, at) prepa[2] = pa x = getattr(pa, name) return x gp = getattr(Clamp, '_GLUEPATH_', None) if gp is None: raise NoSuchAttributeError(name) if hasattr(gp, 'split'): gp = gp.split(',') for a in gp: a = a.strip() bs = a.split('.') ii = inter for b in bs: b = b.strip() ii = getattr(ii, b) try: x = getattr(ii, name) except AttributeError: continue else: return x raise NoSuchAttributeError(name) def makeModule(self, module, name): Clamp = getattr(module, '_GLUECLAMP_', None) return Share(module, self, module.__name__, Clamp) def makeName(self, name): if self.name: name = '%s.%s' % (self.name, name) return name def makeOwner(self, name): owner_name = self.makeName(name) owner = Owner(owner_name) self.owners[owner_name] = owner return owner def pp(self, out=sys.stdout): if not self.owners: return print('Dependencies found for %s' % self.name, file=out) print('-----------------------'+'-'len(self.name), file=out) keys = list(self.owners.keys()) keys.sort() for key in keys: lastname = key[key.rindex('.')+1:] print(lastname, file=out) self.owners[key].pp(short=1) print(file=out) def rpp(self, out=sys.stdout): self.pp(out) for k, d in list(self.data.items()): if k not in ('_root', '_parent'): if isinstance(d, Share): d.rpp() def setattr(self, inter, name, value): Clamp = self.Clamp if Clamp is None: raise ValueError( 'Can not change attribute %r because no _GLUECLAMP_ defined.' % name) setable = self.setable chgable = self.chgable if (name not in setable and name not in chgable and (not (name in self.data and self.data[name] is value))): raise ValueError("""Can not change attribute %r, because it is not in _setable_ or _chgable_.""" % name) if name in self.data and self.data[name] is not value and name not in chgable: raise ValueError("""Can not change attribute %r, because it is already set and not in _chgable_.""" % name) im = getattr(Clamp, '_set_%s' % name, None) if im is not None: im(inter, value) self.data[name] = value if name not in chgable: # This is a pain, I suppose. Should we track interfaces? inter.__dict__[name] = value class Test: def __init__(self, root): self.root = root class _GLUECLAMP_: pass def Root(): """\ Create a new guppy Root object. All functionality in the system may be accessed from this object. Modules are imported on demand when accessed. Other objects may be created or imported on demand using Guppy Glue+ directives. """ share = Share(None, None, '', None) r = Owner('').makeInterface({'_name': ''}, share, '') return r	13.68 KB	2026-01-20 12:58
📄 Help.py # -- coding: utf-8 -- import io import inspect import os THISDIR = os.path.dirname(__file__) class GuppyDoc: def __init__(self, mod, str): self.mod = mod if str is None: str = '???' str = self._substitute(str) self.str = str def __getitem__(self, idx): refs = {} refline = False for line in self.str.split('\n'): if line == 'References': refline = True continue elif not refline: continue line = line.strip() assert line.startswith('[') refstop = line.index(']') ref = line[1:refstop] refs[int(ref)] = line[refstop+1:].strip() url = refs[idx] url = self.mod.docurl(url) return self.mod.open_browser(url) def getheader(self): lines = self.str.split('\n') header = [] for line in lines: if not line: break header.append(line) return '\n'.join(header) def _substitute(self, str): rp = self.mod._root.guppy.heapy.Use.reprefix str = str.replace('$HP.', rp) return str def __repr__(self): return self.str class Lister: def __init__(self): self.output = io.StringIO() def list(self, items, columns=4, width=80): items = items[:] colw = width // columns rows = (len(items) + columns - 1) // columns for row in range(rows): for col in range(columns): i = col * rows + row if i < len(items): self.output.write(items[i]) if col < columns - 1: self.output.write(' ' + ' ' * (colw-1 - len(items[i]))) self.output.write('\n') return self def getvalue(self): return self.output.getvalue() class GuppyDir(object): def __init__(self, li, obj, mod, opts='', kwds): self.li = li self.obj = obj self.mod = mod self.opts = opts self.kwds = kwds def __call__(self, opts=None): li = self.li obj = self.obj mod = self.mod if opts is None: opts = self.opts return self.__class__(li, obj, mod, opts) def __getattr__(self, attr): return self.mod.getdoc2(self.obj, attr) def __getitem__(self, idx): return self.li[idx] def __repr__(self): opts = self.opts if 'L' in opts: r = '' for d in self.li: r += '* ' + d + ' *\n' + repr(getattr(self, d))+'\n\n' elif 'l' in opts: r = '' for d in self.li: t = getattr(self, d).getheader() if not (t.startswith(d) or t.startswith('x.'+d)): t = d r += t + '\n\n' else: r = Lister().list(self.li).getvalue().rstrip() header = self.kwds.get('header', '') if header: header += '\n' footer = self.kwds.get('footer', '') if footer: footer = '\n'+footer r = header+r+footer return r class _GLUECLAMP_: def dir(self, obj=None, opts='', kwds): try: share = obj._share except AttributeError: return self.getdir_no_share(obj, opts, kwds) clamp = share.Clamp dl = getattr(clamp, '_dir_', None) if dl is not None: dl = list(dl) else: dl = [] private = getattr(clamp, '_private_', ()) try: imports = clamp._imports_ except AttributeError: pass for imp in imports: ix = imp.find(':') if ix == -1: continue dl.append(imp[ix+1:]) for gm in dir(clamp): if gm.startswith('_get_'): dl.append(gm[5:]) else: if not gm.startswith('_'): dl.append(gm) dl = [d for d in dl if not d in private] dl.sort() return GuppyDir(dl, obj, self, opts, kwds) def getdir_no_share(self, obj, opts, kwds): dl = dir(obj) dl = [d for d in dl if not d.startswith('_')] return GuppyDir(dl, obj, self, opts, kwds) def getdoc2(self, obj, name): try: share = obj._share except AttributeError: return self.getdoc_no_share(obj, name) clamp = obj._share.Clamp try: imports = clamp._imports_ except AttributeError: pass else: for imp in imports: ix = imp.find(':') if ix == -1: pass else: if imp[ix+1:] == name: return self.getdoc_import(obj, clamp, name, imp, ix) for gm in dir(clamp): if gm.startswith('_get_') and gm[5:] == name: return self.getdoc__get_(clamp, gm) else: if name == gm: return self.getdoc_other(clamp, name) return GuppyDoc(self, '???') def getdoc_no_share(self, obj, name): try: doc = getattr(obj, '_doc_'+name) except AttributeError: pass else: return GuppyDoc(self, doc) cl = obj.__class__ p = getattr(cl, name) if isinstance(p, property): docobj = p else: docobj = getattr(obj, name) return self.getdoc_obj(docobj) def getdoc__get_(self, clamp, gm): func = getattr(clamp, gm) doc = func.__doc__ return GuppyDoc(self, doc) def getdoc_import(self, obj, clamp, name, imp, ix): doc = '' if hasattr(clamp, '_doc_'+name): doc = getattr(obj, '_doc_'+name) else: impobj = getattr(obj, imp[ix+1:]) doc = getattr(impobj, '__doc__') return GuppyDoc(self, doc) def getdoc_obj(self, obj): doc = inspect.getdoc(obj) if doc is None: doc = '???' return GuppyDoc(self, doc) def getdoc_other(self, obj, name): attr = getattr(obj, name) doc = inspect.getdoc(attr) if doc: return GuppyDoc(self, doc) try: doc = getattr(obj, '_doc_'+name) except AttributeError: doc = '' if doc is None: doc = '?' print('doc', doc) return GuppyDoc(self, doc) def docurl(self, url): url = 'https://zhuyifei1999.github.io/guppy3/'+url return url def open_browser(self, url): import webbrowser webbrowser.open(url)	6.71 KB	2026-01-20 12:58
📄 IterPermute.py from functools import reduce def iterpermute(args): args = [iter(a) for a in args] la = len(args) stopped = [0] la lens = [0] * la bufs = [[] for i in range(la)] nexts = [None] * la n = 0 while 1: anynew = 0 for i in range(la): if stopped[i]: nextval = bufs[i][n % lens[i]] else: try: nextval = next(args[i]) except StopIteration: if lens[i] == 0: # raise ValueError, 'The iterator passed in arg %d did not return any item'%i return stopped[i] = 1 nextval = bufs[i][n % lens[i]] else: anynew = 1 bufs[i].append(nextval) lens[i] += 1 nexts[i] = nextval if anynew: n += 1 yield tuple(nexts) else: break wanted = reduce(lambda x, y: xy, lens, 1) if n >= wanted: assert n == wanted return ixs = list(enumerate(lens)) ixs.sort(key=lambda x: x[1]) ixs = [ix for (ix, ln) in ixs] jxs = [0] la seen = dict([(tuple([j % lens[i] for i in ixs]), 1) for j in range(n)]) while n < wanted: t = tuple([jxs[i] for i in ixs]) if t not in seen: yield tuple([bufs[i][jxs[i]] for i in range(la)]) n += 1 for i in ixs: j = jxs[i] j = (j + 1) % lens[i] jxs[i] = j if j != 0: break def test_iterpermute(): import itertools repeat = itertools.repeat assert list(iterpermute()) == [()] assert list(iterpermute(repeat(1, 2))) == [(1,), (1,)] assert list(iterpermute(repeat(1, 1), repeat(2, 1))) == [(1, 2)] assert list(iterpermute(list(range(0, 2)), list(range(2, 3)))) == [ (0, 2), (1, 2)] assert list(iterpermute(list(range(0, 2)), list(range(2, 4)))) == [ (0, 2), (1, 3), (1, 2), (0, 3)] print(list(iterpermute(list(range(0, 2)), list(range(0, 3))))) print(list(iterpermute(list(range(0, 3)), list(range(0, 2))))) if __name__ == '__main__': test_iterpermute()	2.22 KB	2026-01-20 12:58
📄 KanExtension.py class LeftKanExtension: # Implementation of algorithms described by Brown and Heyworth (ref.251) # and Heyworth (ref.253). def __init__(self, mod, A, B, R, X, F): # External subsystem dependencies # mod.KnuthBendix # mod.FiniteAutomaton # mod.SolveFSA # mod.Cat # mod.Cat.Function # mod.Cat.Functor # mod.Cat.check_graph # mod.Cat.check_rules self.mod = mod self.Cat = mod.Cat # self.Cat.check_graph(A) self.Cat.check_graph(B) self.Cat.check_rules(R, B) # self.A = A self.B = B self.R = [(tuple(g), tuple(h)) for (g, h) in R] self.X = X self.F = F self.general_procedure() def general_procedure(self): self.initialize_tables() self.make_confluent_system() self.make_automaton() # self.make_catalogue() self.make_natural_transformation() def initialize_tables(self): self.obj_to_str_table = {} self.str_to_obj_table = {} self.make_initial_rules() def make_initial_rules(self): # Algorithm 6.1 in (251) Re = [] def add_rule(a, b): aw = self.make_word(a) bw = self.make_word(b) if aw != bw: Re.append((aw, bw)) for a in self.A.arrows: srca = self.A.source(a) tgta = self.A.target(a) XA = self.X.fo(srca) Xa = self.X.fa(a) Fa = tuple(self.F.fa(a)) Fsrca = self.F.fo(srca) Ftgta = self.F.fo(tgta) if Fa: t = Fsrca for b in Fa: srcb = self.B.source(b) if srcb != t: raise ValueError( 'Arrow [%s] with source %s does not compose with target %s' % (b, srcb, t)) t = self.B.target(b) if t != Ftgta: raise ValueError( 'Arrow %s with target %s does not compose with %s' % (Fa, t, Ftgta)) else: if Fsrca != Ftgta: raise ValueError( 'Source %s does not match target %s' % (Fsrca, Ftgta)) for x in XA: add_rule(((srca, x),) + Fa, ((tgta, Xa(x)),)) Rk = [(self.make_word(x), self.make_word(y)) for (x, y) in self.R] self.Re = Re self.Rk = Rk self.Rinit = Re + Rk def make_confluent_system(self): self.rs = self.mod.KnuthBendix(self.Rinit, delim='.') self.Rconf = self.rs.reductions def make_automaton(self): # Make nondeterministic finite automaton def target(e): if len(e) == 1 and isinstance(e[0], tuple): return self.F.fo(e[0][0]) else: return self.B.target(e[-1]) XA = [] for A in self.A.objects: for x in self.X.fo(A): XA.append(((A, x),)) follows = dict([(B, []) for B in self.B.objects]) for b, (srcb, tgtb) in list(self.B.arrows.items()): follows[srcb].append((b, tgtb)) IR = dict([(self.make_term(u), self.make_term(v)) for u, v in self.Rconf]) pplR = {} for l, r in self.Rconf: t = self.make_term(l) for i in range(1, len(t)): pplR[t[:i]] = 1 s0 = ('s0',) fsa = self.mod.FiniteAutomaton(s0) for xi in XA: if xi not in IR: fsa.add_transition(s0, xi[0], xi) for xi in XA: for b, tgtb in follows[target(xi)]: bterm = (b,) xib = xi + bterm if xib in pplR: fsa.add_transition(xi, b, xib, tgtb) elif (bterm in pplR and xib not in IR): fsa.add_transition(xi, b, bterm, tgtb) elif xib not in IR: fsa.add_transition(xi, b, tgtb) for Bi in self.B.objects: for b, tgtb in follows[Bi]: bterm = (b,) if bterm in pplR: fsa.add_transition(Bi, b, bterm, tgtb) elif bterm not in IR: fsa.add_transition(Bi, b, tgtb) for u in pplR: if u in XA: continue for b, tgtb in follows[target(u)]: bterm = (b,) ub = u + bterm if ub in pplR: fsa.add_transition(u, b, ub, tgtb) elif self.irreducible(ub): # ub not in IR: fsa.add_transition(u, b, tgtb) def get_RS(Bi): finals = {} finals[Bi] = 1 for xi in XA: if self.F.fo(xi[0][0]) == Bi: finals[xi] = 1 for u in pplR: if target(u) == Bi: finals[u] = 1 for c in fsa.get_composites(): for s in c: if s not in finals: break else: finals[c] = 1 dfa = fsa.get_minimized_dfa(finals) regexp = self.mod.SolveFSA(dfa) return RegularSet(regexp) KB = self.Cat.Function(get_RS, self.B.objects, None) Kb = self.Cat.Function( lambda a: KanAction(self.B, KB, a, target, self.irreducible, self.reduce), self.B.arrows, KanAction, ) self.KB = KB self.Kb = Kb self.K = self.Cat.Functor(KB, Kb) def make_catalogue(self): # Catalogue the elements of the sets pointed to by extension functor K, # according to algorithm described in 7.1 in (251). # Precondition: # Tables initialized and a confluent system created. # The system is assumed to be finite, otherwise we won't terminate. # Postcondition: # Functor self.K represented as: # # self.K.tabo = self.KB = dict mapping, # source: {each B in self.B.objects} # target: sets represented as lists # self.K.taba = self.Kb = dict, mapping # source: {each a in self.B.arrows} # target: tabulated function, mapping # source: KB[source of a] # target: KB[target of a] def target(e): if len(e) == 1: return self.F.fo(e[0][0]) else: return self.B.target(e[-1]) def add_element(e): if self.irreducible(e): block.append(e) KB[target(e)].append(e) else: pass KB = dict([(B, []) for B in self.B.objects]) block = [] for A in self.A.objects: for x in self.X.fo(A): add_element(((A, x),)) while block: oblock = block block = [] for e in oblock: tgt = target(e) for a in self.B.arrows: if self.B.source(a) == tgt: add_element(e + (a,)) Kb = {} for a in self.B.arrows: src = KB[self.B.source(a)] tgt = KB[self.B.target(a)] tab = dict([(s, self.reduce(s + (a,))) for s in src]) Kb[a] = self.Cat.Function(tab, src, tgt) KB = self.Cat.Function(KB, self.B.objects, list(KB.values())) Kb = self.Cat.Function(Kb, self.B.arrows, list(Kb.values())) self.KB = KB self.Kb = Kb self.K = self.Cat.Functor(KB, Kb) def make_natural_transformation(self): # Precondition: # initial tables should be initialized # self.K.fo should exist # Postcondition: # # self.nat[A] for A in self.A.objects get_nat_memo = {} def get_nat(A): if A in get_nat_memo: return get_nat_memo[A] src = self.X.fo(A) tgt = self.K.fo(self.F.fo(A)) tab = dict([(x, self.reduce(((A, x),))) for x in src]) get_nat_memo[A] = self.Cat.Function(tab, src, tgt) return get_nat_memo[A] self.nat = self.Cat.Function(get_nat, self.A.objects, None) def make_word(self, x): ots = self.obj_to_str return '.'.join([ots(e) for e in x if e != '']) def obj_to_str(self, x): otn = self.obj_to_str_table try: return otn[x] except KeyError: assert not (isinstance(x, tuple) and len(x) > 2) n = str(len(otn)) #n = '%d:%s'%(len(otn), x) #n = str(x) otn[x] = n self.str_to_obj_table[n] = x return n def str_to_obj(self, x): return self.str_to_obj_table[x] def irreducible(self, x): tx = self.make_word(x) return tx == self.rs.reduce(tx) def reduce(self, x): w = self.rs.reduce(self.make_word(x)) return self.make_term(w) def make_term(self, word): sto = self.str_to_obj_table return tuple([sto[s] for s in word.split('.') if s]) class KanAction: def __init__(self, B, KB, a, targetof, irreducible, reduce): srca = B.source(a) tgta = B.target(a) self.src = KB(srca) self.tgt = KB(tgta) self.a = a self.srca = srca self.targetof = targetof self.irreducible = irreducible self.reduce = reduce def __call__(self, s): if self.targetof(s) != self.srca: raise TypeError('''\ Target of %r (= %r) does not match source of %r (= %r)''' % ( s, self.targetof(s), self.a, self.srca)) if not self.irreducible(s): raise TypeError('''\ Argument %r is reducible to %r; and is thus not in the source set K.fo(%r)''' % ( s, self.reduce(s), self.srca)) return self.reduce(s + (self.a,)) class RegularSet: # Wraps a regular expression; # provides a set protocol for the underlying set of sequences: # o If the RE specifies a finite language, iteration over its strings # [ o set inclusion ] is_simplified = 0 def __init__(self, re): self.re = re def __iter__(self): return iter(self.uniform) def __getitem__(self, x): return self.uniform[x] def __len__(self): return len(self.uniform) def get_xs_covered(self, coverage): N = coverage X = self.re.limited(coverage) xs = X.sequni() return [tuple(x) for x in xs] def get_uniform(self): self.simplify() return self.re.sequni() uniform = property(fget=get_uniform) def simplify(self): if not self.is_simplified: self.re = self.re.simplified() self.is_simplified = 1 class ObjectTester: def __init__(self, category_tester, object, code): self.category_tester = category_tester self.functor = category_tester.functor self.object = object self.code = code def get_all_arrows(self): return self.category_tester.arrows[self.object] def get_intermediate_test_code(self): return self.code def get_python_test_source_code(self): cmap = { 'aseq': 'assert e[%r] == e[%r]', 'evalfa': 'e[%r] = fa[%r](e[%r])', 'asfo': 'assert fo[%r](e[%r])' } return '\n'.join([cmap[c[0]] % c[1:] for c in self.code]) def execode(self, arg): code = self.get_python_test_source_code() e = {'arg': arg} d = {'fa': self.functor.fa, 'fo': self.functor.fo, 'e': e, } exec(code, d) return e def intercode(self, arg): e = {'arg': arg} fa = self.functor.fa fo = self.functor.fo for c in self.code: a = c[0] if a == 'evalfa': dst, ar, src = c[1:] e[dst] = fa[ar](e[src]) elif a == 'asfo': ob, src = c[1:] if not fo[ob](e[src]): raise ValueError('Predicate failed') elif a == 'aseq': na, nb = c[1:] if e[na] != e[nb]: raise ValueError('e[%r] != e[%r]' % (na, nb)) else: raise ValueError('Invalid code: %r' % (a,)) def test(self, arg): return self.intercode(arg) class CategoryTester: def __init__(self, mod, functor, arrows, get_arrow_name=None): self.mod = mod self.cat = functor.src self.functor = functor self.arrows = arrows if get_arrow_name is not None: self.get_arrow_name = get_arrow_name def get_arrow_name(self, a): return '.'.join(a) def get_eval_arrows_code(self, object, argname): fa = self.functor.fa name = argname memo = {(): name} memolist = [((), name)] codes = [] def eval_arrow(a): if a in memo: return memo[a] a0 = a[:-1] a1 = a[-1] name = self.get_arrow_name(a) na0 = eval_arrow(a0) #codes.append('%s = fa[%r](%s)'%(name, a1, na0)) codes.append(('evalfa', name, a1, na0)) memo[a] = name memolist.append((a, name)) return name for ar in self.arrows[object]: eval_arrow(ar) return codes, memolist def get_object_tester(self, object): code = self.get_test_object_code(object) return ObjectTester(self, object, code) def get_test_inclusion_code(self, object, ml): codes = [] src = self.functor.fo.src for arrow, value in ml: ob = object if arrow: ob = self.cat.graph.target(arrow[-1]) #codes.append('assert fo[%r](%s)'%(ob, value)) if src is None or ob in src: codes.append(('asfo', ob, value)) return codes def get_test_object_code(self, object): argname = 'arg' evalcodes, memolist = self.get_eval_arrows_code(object, argname) relcodes = self.get_test_relations_code(object, memolist) incodes = self.get_test_inclusion_code(object, memolist) return evalcodes+relcodes+incodes def get_test_relations_code(self, object, memolist): codes = [] cat = self.cat fa = self.functor.fa memo = dict(memolist) def teval_arrow(ar): if ar in memo: return memo[ar] a0 = teval_arrow(ar[:-1]) name = self.get_arrow_name(ar) #codes.append('%s = fa[%r](%s)'%(name, ar[-1], a0)) codes.append(('evalfa', name, ar[-1], a0)) memo[ar] = name return name # Check that the equality relations really match up # for all arrows in old memolist, i.e. original unique arrows # which is arguably overkill sometimes?.. for a, b in cat.relations: a = tuple(a) b = tuple(b) src = cat.graph.source(a[0]) for (arr, val) in memolist: if arr: tgt = cat.graph.target(arr[-1]) else: tgt = object if src == tgt: ara = arr + a arb = arr + b if ara != arb: va = teval_arrow(ara) vb = teval_arrow(arb) assert va != vb #codes.append('assert %s == %s'%(va, vb)) codes.append(('aseq', va, vb)) return codes def test_object(self, object, value): tester = self.get_object_tester(object) tester.test(value) return tester def test_object_fail(self, object, value): try: self.test_object(object, value) except Exception: pass else: raise Exception('Exception excepted') class _GLUECLAMP_: # 'imports' def _get_KnuthBendix(self): return self._parent.KnuthBendix.KnuthBendix def _get_FiniteAutomaton(self): return self._parent.FSA.FiniteAutomaton def _get_SolveFSA(self): return self._parent.RE.SolveFSA def _get_Cat(self): return self._parent.Cat # Main exported interface is the lke method # which provides a context for the LeftKanExtension class. def lke(self, A, B, R, X, F): return LeftKanExtension(self, A, B, R, X, F) # Other functions - examples of applications of Kan extension # in alphabetic order def arrows_map(self, cat, from_objects=0, coverage=1): if from_objects: cat = cat.get_dual() A = self.Cat.Graph(cat.graph.objects, []) B = cat.graph R = cat.relations X = self.Cat.Functor(lambda x: [1], lambda x: lambda y: y) F = self.Cat.Functor(lambda x: x, lambda x: []) ke = self.lke(A, B, R, X, F) memo = {} def get_arrows(object): if object in memo: return memo[object] re = ke.K.fo[object].re.rempretup() if from_objects: re = re.reversed() if str(coverage).startswith('length'): maxlen = int(coverage[6:]) ar = [] xs = re.get_words_memo() for i in range(1, maxlen+1): ar.extend([tuple(x) for x in xs.get_words_of_length(i)]) else: re = re.limited(coverage) xs = re.sequni() ar = [tuple(x) for x in xs] memo[object] = ar return ar return self.Cat.Function( get_arrows, src=ke.K.fo.src, tgt=None ) def category_tester(self, functor, arrows=None, coverage=1): if isinstance(functor, tuple): fo, fa, src = functor if fo is None: def fo(x): return lambda y: 1 functor = self.Cat.Functor(fo, fa, src) if arrows is None: arrows = self.arrows_map( functor.src, from_objects=1, coverage=coverage) return CategoryTester(self, functor, arrows) def coequalizer(self, S0, S1, f0, f1): # Given # # S0, S1 sets (objects that can be iterated over) # f0, f1 functions from S0 to S1 # # Return a coequalizing function, # such that in the following diagram: # # S0 ===== S0 # \| \| # \| f0 \| f1 # \| \| # V V # S1 ===== S1 ==== coequalizing_function.src # \| # \| coequalizing_function # \| # V # coequalizing_function.tgt # both paths from S0 to coequalizing_function.tgt will be equivalent, # and coequalizing_function.tgt is a colimit of all such sets. # # The coequalizing_function object is callable with # an argument from S1, and has the following attributes: # .src is identical to S1 # .tgt is a set in iterable form # .asdict() returns a dict representing the mapping objects = [0, 1] arrows = {'a0': (0, 1), 'a1': (0, 1)} A = self.Cat.Graph(objects, arrows) Xo = self.Cat.Function({0: S0, 1: S1}, objects, [S0, S1]) Xa = self.Cat.Function({'a0': f0, 'a1': f1}, arrows, [f0, f1]) X = self.Cat.Functor(Xo, Xa) colimit_object, colimit_functions = self.colimit(A, X) return colimit_functions[1] def colimit(self, A, X): # According to 9.6 in (ref.251) B = self.Cat.Graph([0], {}) R = [] F = self.Cat.Functor(lambda x: 0, lambda x: ()) lka = self.lke(A, B, R, X, F) colimit_object = lka.KB[0] colimit_functions = lka.nat # Reduce elements to a smaller (but isomorphic) form # I.E since elements are all of the form # ((A, X),) # they can be reduced to the form # (A, X) # colimit_object = [x[0] for x in colimit_object] colimit_functions = dict([ (A, self.Cat.Function( dict([(a, k[0]) for (a, k) in list(cof.items())]), cof.src, colimit_object, ) ) for (A, cof) in list(colimit_functions.items())]) return colimit_object, colimit_functions def test_arrows(self, functor, object, value): # Application of arrow listing to test sequencing # Discussed in Notes Mar 9 2005 tester = self.category_tester(functor) return tester.test_object(object, value)	20.71 KB	2026-01-20 12:58
📄 KnuthBendix.py """ An implementation of the Knuth-Bendix algorithm, as described in (1), p. 143. For determining if two paths in a category are equal. The algorithm as given here, takes a set of equations in the form of a sequence: E = [(a, b), (c, d) ...] where a, b, c, d are 'paths'. Paths are given as strings, for example: E = [ ('fhk', 'gh'), ('m', 'kkm') ] means that the path 'fhk' equals 'gh' and 'm' equals 'kkm'. Each arrow in the path is here a single character. If longer arrow names are required, a delimiter string can be specified as in: kb(E, delim='.') The paths must then be given by the delimiter between each arrow; E = [ ('h_arrow.g_arrow', 'g_arrow.k_arrow') ... ] The function kb(E) returns an object, say A, which is o callable: A(a, b)->boolean determines if two paths given by a, b are equal. o has a method A.reduce(a)->pathstring, which reduces a path to normal form. An optional parameter to kb, max_iterations, determines the maximum number of iterations the algorithm should try making the reduction system 'confluent'. The algorithm is not guaranteed to terminate with a confluent system in a finite number of iterations, so if the number of iterations needed exceeds max_iterations an exception (ValueError) will be raised. The default is 100. References (1) @book{walters91categories, title={Categories and Computer Science}, author={R. F. C. Walters}, publisher={Cambridge University Press}, location={Cambridge}, year=1991} (2) @book{grimaldi94discrete, author="Ralph P. Grimaldi". title="Discrete and Combinatorial Mathematics: An Applied Introduction", publisher="Addison-Wesley", location="Readin, Massachusetts", year=1994 } """ import functools class KnuthBendix: def __init__(self, E, delim='', max_iterations=100): self.reductions = [] self.delim = delim for a, b in E: if delim: a = self.wrap_delim(a) b = self.wrap_delim(b) if self.gt(b, a): a, b = b, a self.reductions.append((a, b)) self.make_confluent(max_iterations) self.sort() def __call__(self, x, y): return self.reduce(x) == self.reduce(y) def gt(self, a, b): delim = self.delim if delim: la = len(a) lb = len(b) else: la = a.count(delim) lb = b.count(delim) if la > lb: return 1 if la < lb: return 0 return a > b def make_confluent(self, max_iterations): def add_reduction(p, q): if p != q: if self.gt(p, q): self.reductions.append((p, q)) else: self.reductions.append((q, p)) self.confluent = 0 reds_tested = {} for i in range(max_iterations): self.confluent = 1 reds = list(self.reductions) for u1, v1 in reds: for u2, v2 in reds: red = (u1, u2, u2, v2) if red in reds_tested: continue reds_tested[red] = 1 if u2 in u1: p = self.freduce(v1) i = u1.index(u2) while i >= 0: uuu = u1[:i]+v2+u1[i+len(u2):] q = self.freduce(uuu) add_reduction(p, q) i = u1.find(u2, i+1) lu1 = len(u1) for i in range(1, lu1-len(self.delim)): if u2[:lu1-i] == u1[i:]: p = self.freduce(v1 + u2[lu1-i:]) q = self.freduce(u1[:i] + v2) add_reduction(p, q) assert ('', '') not in reds # Remove redundant reductions newr = [] nullred = (self.delim, self.delim) for i, uv in enumerate(self.reductions): u, v = uv self.reductions[i] = nullred ru = self.freduce(u) rv = self.freduce(v) if ru != v and ru != rv: urv = (u, rv) newr.append(urv) self.reductions[i] = urv else: pass if len(newr) != self.reductions: assert ('', '') not in newr self.reductions = newr assert ('', '') not in self.reductions if self.confluent: break else: raise ValueError("""\ KnuthBendix.make_confluent did not terminate in %d iterations. Check your equations or specify an higher max_iterations value.' """ % max_iterations) def freduce(self, p): # This (internal) variant of reduce: # Uses the internal representaion: # Assumes p is .surrounded. by the delimiter # and returns the reduced value .surrounded. by it. # This is primarily for internal use by make_confluent while 1: q = p for uv in self.reductions: p = p.replace(uv) if q == p: break return p def reduce(self, p): # This (external) variant of reduce: # will add delim if not .surrounded. by delim # but the return value will not be surrounded by it. if self.delim: p = self.wrap_delim(p) p = self.freduce(p) if self.delim: p = p.strip(self.delim) return p def sort(self, reds=None): if reds is None: reds = self.reductions def cmp(xxx_todo_changeme, xxx_todo_changeme1): (x, _) = xxx_todo_changeme (y, __) = xxx_todo_changeme1 if self.gt(x, y): return 1 if x == y: return 0 return -1 reds.sort(key=functools.cmp_to_key(cmp)) def pp(self): printreds(self.reductions) def wrap_delim(self, p): if not p.startswith(self.delim): p = self.delim + p if not p.endswith(self.delim): p = p + self.delim return p def printreds(reds): for i, uv in enumerate(reds): print('%s\t' % (uv,), end=' ') if (i + 1) % 4 == 0: print() if (i + 1) % 4 != 0: print() def kb(E, a, *k): return KnuthBendix(E, a, **k) class _GLUECLAMP_: pass def test2(): # # The group of complex numbers {1, -1, i, -i} under multiplication; # generators and table from Example 16.13 in (2). G = ['1', '-1', 'i', '-i'] E = [('1.i', 'i'), ('i.i', '-1'), ('i.i.i', '-i'), ('i.i.i.i', '1'), ] R = kb(E, delim='.') T = [['.']+G] + [[y]+[R.reduce('%s.%s' % (y, x)) for x in G] for y in G] assert T == [ ['.', '1', '-1', 'i', '-i'], ['1', '1', '-1', 'i', '-i'], ['-1', '-1', '1', '-i', 'i'], ['i', 'i', '-i', '-1', '1'], ['-i', '-i', 'i', '1', '-1']] return R def test(): E = [('.a.', '.b.')] a = kb(E, delim='.') assert a('.a.', '.b.') E = [('fhk', 'gh'), ('m', 'kkm')] a = kb(E) p = a.reduce('fffghkkkm') q = a.reduce('ffghkm') assert p == 'ffffhm' assert q == 'fffhm' assert not a(p, q) E = [('.a.', '.b.')] a = kb(E, delim='.') p = a.reduce('aa') assert p == 'aa' p = a.reduce('.bb.') assert p == 'bb' p = a.reduce('b') assert p == 'a' E = [('.f.h.k.', '.g.h.'), ('.m.', '.k.k.m.')] a = kb(E, delim='.') p = a.reduce('.f.f.f.g.h.k.k.k.m.') q = a.reduce('.f.f.g.h.k.m.') assert p, q == ('.f.f.f.f.h.m.', '.f.f.f.h.m.') assert p == 'f.f.f.f.h.m' assert q == 'f.f.f.h.m' E = [('.f.ff.fff.', '.ffff.ff.'), ('.fffff.', '.fff.fff.fffff.')] a = kb(E, delim='.') p = a.reduce('.f.f.f.ffff.ff.fff.fff.fff.fffff.') q = a.reduce('.f.f.ffff.ff.fff.fffff.') assert p == 'f.f.f.f.ff.fffff' assert q == 'f.f.f.ff.fffff' def test3(): # From 9.3 in 251 E = [('Hcc', 'H'), ('aab', 'ba'), ('aac', 'ca'), ('cccb', 'abc'), ('caca', 'b')] a = kb(E) canon = [ ('Hb', 'Ha'), ('Haa', 'Ha'), ('Hab', 'Ha'), ('Hca', 'Hac'), ('Hcb', 'Hac'), ('Hcc', 'H'), ('aab', 'ba'), ('aac', 'ca'), ('abb', 'bb'), ('abc', 'cb'), ('acb', 'cb'), ('baa', 'ba'), ('bab', 'bb'), ('bac', 'cb'), ('bba', 'bb'), ('bca', 'cb'), ('bcb', 'bbc'), ('cab', 'cb'), ('cba', 'cb'), ('cbb', 'bbc'), ('cbc', 'bb'), ('ccb', 'bb'), ('Haca', 'Hac'), ('Hacc', 'Ha'), ('bbbb', 'bb'), ('bbbc', 'cb'), ('bbcc', 'bbb'), ('bcca', 'bb'), ('caca', 'b'), ('ccaa', 'ba'), ('ccca', 'cb'), ('cacca', 'cb') ] a.canon = canon return a	8.81 KB	2026-01-20 12:58
📄 RE.py import functools from guppy.etc.RE_Rect import chooserects from guppy.etc.IterPermute import iterpermute class InfiniteError(Exception): pass class WordsMemo: def __init__(self, re, ch): self.re = re self.ch = ch self.xs = {} self.N = 0 def get_words_of_length(self, N): # Return a list of words of length up to N if N not in self.xs: self.xs[N] = self.re.get_words_of_length_memoized(N, self) return self.xs[N] def get_words_of_length_upto(self, N): # Return all words of length up to N, in the form # [(0, <list of words of length 0>), # (1, <list of words of length 0>), # ...] xsu = [] for i in range(N+1): xs = self.get_words_of_length(i) if xs: xsu.append((i, xs)) return xsu REBASE = tuple class RE(REBASE): # Regular expression nodes # The operators are choosen to be compatible with Pythonic standards: # o sets : using \| for union # o strings, sequences : using + for concatenation. # # This differs from mathematical presentations of regular # expressions where + is the union, but it seemed more important # to not confuse the Python usage. # There are also operators for closure x, x+ that can not be # represented directly in Python expressions and these were choosen # to use a function call syntax. # The following table summarizes the operators. # RE node expr re lib mathematical name # x + y x y x y Concatenation # x \| y x \| y x + y Union # x('') x* x* Kleene closure # x('+') x+ x+ Positive closure # x('?') x? _re_special = r'.^$+?{}\[]\|()' def __add__(a, b): if isinstance(b, RE): return concat(a, b) else: return Concatenation(a, Single(b)) def __call__(a, args, *kwds): if not kwds: if args == ('',): return KleeneClosure(a) elif args == ('+',): return PositiveClosure(a) elif args == ('?',): return EpsilonOrOne(a) raise ValueError( "Argument to regular expression must be '' or '+' or '?'") def __hash__(self): return hash((self._name, tuple(self))) def __eq__(a, b): return (a._name == b._name and tuple(a) == tuple(b)) def __lt__(a, b): if a._name == b._name: return tuple(a) < tuple(b) else: return a._name < b._name def __or__(a, b): return Union(a, b) def get_num_closures(self): ns = 0 for ch in self: ns += ch.get_num_closures() return ns def get_num_syms(self): ns = 0 for ch in self: ns += ch.get_num_syms() return ns def get_sum_sym_lengths(self): ns = 0 for ch in self: ns += ch.get_sum_sym_lengths() return ns def get_words_memo(self): ch = [x.get_words_memo() for x in self] return WordsMemo(self, ch) def get_words_of_length(self, N): xs = self.get_words_memo() return xs.get_words_of_length(N) def mapchildren(self, f): return self.__class__([f(x) for x in self]) def regexpform(self): return self.mappedrepr(regexpname) def reversed(self): return self.mapchildren(lambda x: x.reversed()) def rempretup(self): def f(x): if isinstance(x, Seq): if x is not Epsilon and isinstance(x[0], tuple): ws = x[1:] return Seq(ws) else: return x return x.mapchildren(f) return f(self) def seqatoms(self): sa = [] self.apseqatoms(sa.append) return sa def sequni(self): d = {} us = [] def ap(x): if x not in d: d[x] = 1 us.append(x) self.apseq(ap) return Union(us) def shform(self, conc=' '): r = self.mappedrepr(regexpname) if conc != ' ': r = conc.join(r.split(' ')) return r def simplified(self, a, k): return self def simulform(self): def f(x): if x == '': return '()' return str(x) return self.mappedrepr(f) def regexpname(s): if s == '': return '()' special = RE._re_special ren = [] for c in str(s): if c in special+"', ": #c = r'\%s'%c c = '' ren.append(c) return ''.join(ren) class Seq(RE): _priority = 0 _name = 'Seq' def __new__(clas, symbols): if not symbols: return Epsilon return REBASE.__new__(clas, symbols) def __repr__(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(['%r' % (x,) for x in self])) def apseq(self, ap): ap(self) def apseqatoms(self, ap): for x in self: ap(Single(x)) def get_num_closures(self): return 0 def get_num_syms(self): return len(self) def get_sum_sym_lengths(self): s = 0 for x in self: s += len(str(x)) return s def get_words_memo(self): return WordsMemo(self, ()) def get_words_of_length_memoized(self, N, memo): if N == len(self): return [self] else: return [] def limited(self, N): return self def mappedrepr(self, f): if not self: return f('') return ' '.join(['%s' % (f(x),) for x in self]) def reversed(self): r = list(self) r.reverse() return self.__class__(r) def unionsplitted(self): return [self] def Single(symbol): return REBASE.__new__(Seq, (symbol,)) Epsilon = REBASE.__new__(Seq, ()) def concat(args): args = [x for x in args if x is not Epsilon] if len(args) < 2: if not args: return Epsilon return args[0] return REBASE.__new__(Concatenation, args) class Concatenation(RE): _priority = 2 _name = 'Concat' def __new__(clas, args): if len(args) < 2: if not args: return Epsilon return args[0] return REBASE.__new__(clas, args) def __repr__(self): rs = [] for ch in self: r = '%r' % (ch,) if ch._priority > self._priority: r = '(%s)' % (r,) rs.append(r) return ' + '.join(rs) def apseq(self, ap): uns = [x.sequni() for x in self] ixs = [0]len(uns) while 1: xs = [] for (i, us) in enumerate(uns): for x in us[ixs[i]]: if x is not Epsilon: xs.append(x) ap(Seq(xs)) j = 0 for j, ix in enumerate(ixs): ix += 1 if ix >= len(uns[j]): ix = 0 ixs[j] = ix if ix != 0: break else: break def apseqatoms(self, ap): for x in self: x.apseqatoms(ap) def get_words_of_length_memoized(self, N, memo): chxs = [] for ch in memo.ch: chxs.append(ch.get_words_of_length_upto(N)) xs = [] seen = {} def ads(xx, i, n): if i == len(chxs): if n == N: for toconc in iterpermute(xx): conc = simple_Concatenation(toconc) if conc not in seen: xs.append(conc) seen[conc] = 1 else: for m, x in chxs[i]: if n + m <= N: ads(xx + [x], i + 1, n + m) ads([], 0, 0) return xs def limited(self, N): return Concatenation([x.limited(N) for x in self]) def mappedrepr(self, f): rs = [] for ch in self: r = ch.mappedrepr(f) if ch._priority > self._priority: r = '(%s)' % (r,) rs.append(r) return ' '.join(rs) def reversed(self): r = [x.reversed() for x in self] r.reverse() return self.__class__(r) def simplified(self, a, k): conc = [x.simplified(a, *k) for x in self] sa = [] for c in conc: for a in c.seqatoms(): sa.append(a) return simple_Concatenation(sa) def unionsplitted(self): runs = [] uns = [] for (i, x) in enumerate(self): us = x.unionsplitted() if len(us) > 1: uns.append((i, us)) if not uns: return [self] ixs = [0]len(uns) ch = list(self) while 1: xs = [] i0 = 0 for j, (i, us) in enumerate(uns): xs.extend(ch[i0:i]) ix = ixs[j] xs.append(us[ix]) i0 = i + 1 xs.extend(ch[i0:]) runs.append(concat(xs)) j = 0 for j, ix in enumerate(ixs): ix += 1 if ix >= len(uns[j][1]): ix = 0 ixs[j] = ix if ix != 0: break else: return runs class SimplifiedConcatenation(Concatenation): def simplified(self, a, *k): return self def conclosure(conc): # Simplification noted Mar 5 2005 # Simplify ... b b ... or ... b* b ... to ... b+ ... # conc is a sequence of regular expressions seen = {} nconc = [] w0 = None for w in conc: if w0 is not None: if (w._name == '' and # Not isinstance(KleeneClosure), would catch PositiveClosure w[0] == w0): w = PositiveClosure(w0) elif (w0._name == '' and w0[0] == w): w = PositiveClosure(w) else: if w0 is not None: nconc.append(w0) w0 = w if w0 is not None: nconc.append(w0) return nconc def simple_Concatenation(conc): if len(conc) > 1: conc0 = conc conc = conclosure(conc) nconc = [] i = 0 j = 0 while i < len(conc): e = conc[i] if not isinstance(e, Seq): i += 1 nconc.append(e) continue j = i while j < len(conc): if not isinstance(conc[j], Seq): break j += 1 if j == i + 1: nconc.append(e) else: syms = [] for k in range(i, j): e = conc[k] syms.extend(list(e)) nconc.append(Seq(syms)) i = j if len(nconc) > 1: return Concatenation(nconc) elif nconc: return nconc[0] else: return Epsilon gauges = [ lambda x:x.get_num_syms(), lambda x:x.get_num_closures(), lambda x:x.get_sum_sym_lengths() ] def simpleunion(lines): choosen = chooserects(lines, gauges) have_epsilon = 0 while 1: if len(choosen) == 1 and (choosen[0].width == 0 or len(choosen[0].lines) == 1): us = [] for line in choosen[0].lines: if line: us.append(line) else: have_epsilon = 1 break us = [] for r in choosen: conc = r.get_common_part() olines = r.get_uncommons() u = simpleunion(olines) if u is not Epsilon: if r.dir == -1: conc = [u]+conc else: conc = conc + [u] if conc: us.append(conc) else: have_epsilon = 1 assert not isinstance(us[-1], str) choosen = chooserects(us, gauges) if len(us) > 1: nus = [simple_Concatenation(line) for line in us] u = SimplifiedUnion(nus) elif us: u = simple_Concatenation(us[0]) else: u = None if have_epsilon: if u is not None: u = simple_EpsilonOrOne(u) else: u = Epsilon return u class Union(RE): _priority = 3 _name = 'Union' def __new__(clas, args): return REBASE.__new__(clas, args) def __repr__(self): rs = [] for ch in self: r = '%r' % (ch,) if ch._priority > self._priority: r = '(%s)' % r rs.append(r) return ' \| '.join(rs) def apseq(self, ap): for c in self: c.apseq(ap) def apseqatoms(self, ap): for x in self: x.apseqatoms(ap) def get_words_of_length_memoized(self, N, memo): xs = [] seen = {} for ch in memo.ch: for x in ch.get_words_of_length(N): if x not in seen: seen[x] = 1 xs.append(x) return xs def limited(self, N): uni = [x.limited(N) for x in self] for i, x in enumerate(uni): if x is not self[i]: return self.__class__(uni) return self def mappedrepr(self, f): rs = [] for ch in self: r = '%s' % (ch.mappedrepr(f),) if ch._priority > self._priority: r = '(%s)' % r rs.append(r) return ' \| '.join(rs) def simplified(self, args=None, a, *k): if args is None: args = [x.simplified() for x in self.unionsplitted()] #args = [x for x in self.unionsplitted()] # Create a simplfied union # Assuming args are simplified, non-unions ch = [a.seqatoms() for a in args] return simpleunion(ch) def unionsplitted(self): us = [] for x in self: us.extend(list(x.unionsplitted())) return us class SimplifiedUnion(Union): def simplified(self, a, *k): return self class Called(RE): _priority = 1 def __new__(clas, arg): return REBASE.__new__(clas, (arg,)) def __repr__(self): ch = self[0] r = '%r' % (ch,) if ch._priority > self._priority: r = '(%s)' % r return "%s(%r)" % (r, self._name) def apseqatoms(self, ap): ap(self) def get_num_closures(self): return 1 + self[0].get_num_closures() def mappedrepr(self, f): ch = self[0] r = ch.mappedrepr(f) if (ch._priority > self._priority or isinstance(ch, Seq) and len(ch) > 1): r = '(%s)' % r return "%s%s" % (r, self._name) def simplified(self, a, *k): return self.__class__(self[0].simplified(a, *k)) class Closure(Called): def get_words_of_length_memoized(self, N, memo): if N == 0: return [Epsilon] if N == 1: return memo.ch[0].get_words_of_length(1) xs = [] seen = {} for i in range(1, N): a = memo.get_words_of_length(i) b = memo.get_words_of_length(N-i) for ai in a: for bi in b: aibi = simple_Concatenation((ai, bi)) if aibi not in seen: xs.append(aibi) seen[aibi] = 1 for x in memo.ch[0].get_words_of_length(N): if x not in seen: xs.append(x) seen[x] = 1 return xs def unionsplitted(self): return [self] class KleeneClosure(Closure): _name = '' def apseq(self, ap): raise InfiniteError( 'apseq: Regular expression is infinite: contains a Kleene Closure') def limited(self, N): if N == 0: return Epsilon cl = self[0].limited(N) uni = [] for i in range(N+1): toconc = [cl]i uni.append(Concatenation(toconc)) return Union(uni) def simplified(self, a, *k): return simple_KleeneClosure(self[0].simplified(a, *k)) def simple_KleeneClosure(x): # (b+) -> b* if x._name == '+': return simple_KleeneClosure(x[0]) return KleeneClosure(x) class PositiveClosure(Closure): _name = '+' def apseq(self, ap): raise InfiniteError( 'apseq: Regular expression is infinite: contains a Positive Closure') def apseqatoms(self, ap): self[0].apseqatoms(ap) simple_KleeneClosure(self[0]).apseqatoms(ap) def get_words_of_length_memoized(self, N, memo): if N <= 1: return memo.ch[0].get_words_of_length(N) return Closure.get_words_of_length_memoized(self, N, memo) def limited(self, N): a = self[0].limited(N) b = KleeneClosure(self[0]).limited(N) return Concatenation(a, b) class EpsilonOrOne(Called): _name = '?' def apseq(self, ap): ap(Epsilon) self[0].apseq(ap) def get_words_of_length_memoized(self, N, memo): if N == 0: return [Epsilon] return memo.ch[0].get_words_of_length(N) def limited(self, N): x = self[0].limited(N) if x is not self[0]: self = self.__class__(x) return self def simplified(self, a, k): return simple_EpsilonOrOne(self[0].simplified(a, *k)) def unionsplitted(self): return [Epsilon] + list(self[0].unionsplitted()) def simple_EpsilonOrOne(x): # (a+)? -> a if x._name == '+': return simple_KleeneClosure(x) # (a)? -> a if x._name == '': return x return EpsilonOrOne(x) class RegularSystem: def __init__(self, table, Start, final_states): self.table = table self.Start = Start self.Final = '358f0eca5c34bacdfbf6a8ac0ccf84bc' self.final_states = final_states def pp(self): def statename(state): try: name = self.names[state] except KeyError: name = str(state) return name def transname(trans): name = trans.simulform() if trans._priority > 1: name = '(%s)' % (name,) return name self.setup_names() X = self.X xs = [self.Start]+self.order xs.append(self.Final) for Xk in xs: if Xk not in X: continue print('%3s = ' % (statename(Xk),), end=' ') Tk = X[Xk] es = [] for Xj in xs: if Xj in Tk: es.append('%s %s' % (transname(Tk[Xj]), statename(Xj))) if es: print(' \| '.join(es)) else: print() def setup_equations(self): table = self.table final_states = self.final_states Final = self.Final self.X = X = {Final: {}} for Xi, transitions in list(table.items()): X[Xi] = Ti = {} for (symbol, Xj) in list(transitions.items()): Ti.setdefault(Xj, []).append(Single(symbol)) for Xj, Aij in list(Ti.items()): if len(Aij) > 1: Aij.sort() Aij = Union(Aij) else: Aij = Aij[0] Ti[Xj] = Aij if Xi in final_states: Ti[Final] = Epsilon def setup_order(self): def dists(X, start): i = 0 S = {start: i} news = [start] while news: oldnews = news news = [] i += 1 for s in oldnews: if s not in X: continue for t in X[s]: if t not in S: news.append(t) S[t] = i return S def start_distance(x): return start_dists[x] def sumt(f): memo = {} def g(x): if x in memo: return memo[x] s = 0.0 for y in X[x]: s += f(y) memo[x] = s return s return g def cmp3(x, y): # Comparison for the sorting of equation solving order # First in list = solved last if x is y: return 0 # Equations with more terms are resolved later c = len(X[y]) - len(X[x]) if c: return c # The equations with terms more distant from start node will be resolved earlier i = 0 while i < 10: # 4 was enough with tests so far at Feb 24 2005 try: f = sumdists[i] except IndexError: f = sumt(sumdists[i-1]) sumdists.append(f) c = f(x) - f(y) if c: return c i += 1 return (x > y) - (x < y) sumdists = [start_distance] X = self.X Start = self.Start Final = self.Final start_dists = dists(X, Start) order = [x for x in start_dists if x is not Start and x is not Final] order.sort(key=functools.cmp_to_key(cmp3)) self.order = order def setup_names(self): try: self.order except AttributeError: self.setup_order() self.names = {} self.names[self.Start] = 'X0' for i, s in enumerate(self.order): self.names[s] = 'X%d' % (i+1) self.names[self.Final] = 'Final' def solve(self): # Set up equation system self.setup_equations() self.setup_order() X = self.X Start = self.Start Final = self.Final todo = list(self.order) # Solve equation system while todo: Xk = todo.pop() Tk = X[Xk] if Xk in Tk: # Recursive equation # Eliminate Akk Xk, using Adler's theorem # Given: # Xk = Ak0 X0 \| ... Akk Xk \|.. Akn Xkn # we get: # Xk = Akk* (Ak0 X0 \| ... <no Xk> ... \| Akn Xn) # which we evaluate to: # Xk = Bk0 X0 \| ... Bkn Xn # where coefficients get the new values # Bki := Akk* Aki Akk = Tk[Xk] del Tk[Xk] AkkStar = Akk('*') for Xi, Aki in list(Tk.items()): Bki = AkkStar + Aki Tk[Xi] = Bki # Substitute Xk in each other equation in X # containing Xk, except eqv. Xk itself, which will not be used any more.. del X[Xk] for Xj, Tj in list(X.items()): Bjk = Tj.get(Xk) if Bjk is None: continue del Tj[Xk] for Xji, Tk_Xji in list(Tk.items()): Cji = (Bjk + Tk_Xji) Bji = Tj.get(Xji) if Bji is not None: Cji = Bji \| Cji Tj[Xji] = Cji # The equation system is now solved # The result is in Final term of Start equation return X[Start][Final] Nothing = Union() def SolveFSA(fsa): RS = RegularSystem(fsa.table, fsa.start_state, fsa.final_states) return RS.solve()	23.59 KB	2026-01-20 12:58
📄 RE_Rect.py """ Support functions for RE simplification. This module is intended for use by the RE module. It is in a separate module to keep RE itself cleaner since the algorithm, 'rectangle selection', is a quite separate part that depends on some tricky heuristics. The primary entry function is chooserects(lines, gauges) It chooses 'the best' rectangles from lines to base simplification on. A weight on atoms is given by gauges. pr() gives some example usages of chooserects. """ from guppy.sets import immbitset, mutbitset, immbitrange class Rect(object): __slots__ = 'width', 'lines', 'gainmemo', 'lnos', 'all_lines', 'common_part' def __init__(self, width, lines): self.width = width self.lines = lines assert not (width and len(lines) == 1) self.gainmemo = {} def init2(self, lnobyid, all_lines): self.all_lines = all_lines self.lnos = immbitset([lnobyid[id(line)] for line in self.lines]) self.common_part = self.get_common_part() def reducelines(self, lnos): # Reduce lines of self by removing some lines # Argument: lnos, a 'set' of line numbers to remove olnos = self.lnos lnos = olnos & ~lnos if lnos != olnos: self.lnos = lnos self.lines = [self.all_lines[lno] for lno in lnos] if len(lnos) == 1: self.width = len(self.lines[0]) def get_lines(self, pickednos=0): lines = [] for i in self.lnos & ~ pickednos: lines.append(self.all_lines[i]) return lines def __repr__(self): return '<\n dir = %d\n width = %d\n lnos = %s\n lines = %s\n>' % ( self.dir, self.width, list(self.lnos), self.lines) class LeftRect(Rect): __slots__ = () dir = 0 def get_common_part(self): return self.lines[0][:self.width] def get_uncommons(self, pickednos=0): uc = [] for line in self.get_lines(pickednos): uc.append(line[self.width:]) return uc class RightRect(Rect, object): __slots__ = () dir = -1 def get_common_part(self): lo = -self.width if lo == 0: return [] return self.lines[0][lo:] def get_uncommons(self, pickednos=0): uc = [] hi = -self.width if hi == 0: hi = None for line in self.get_lines(pickednos): uc.append(line[:hi]) return uc def sum_gauge(gauge, lst): global hits, misses if gauge is None: return len(lst) else: gain = 0 for x in lst: gain += gauge(x) return gain def cmp_gauged(xs, ys, gauges): for gauge in gauges: gx = sum_gauge(gauge, xs) gy = sum_gauge(gauge, ys) c = cmp(gx, gy) if c: return c return 0 class InducedRect: def __init__(self, s, lines, lnos): self.s = s self.width = s.width self.all_lines = s.all_lines self.lines = lines self.lnos = lnos class InducedRightRect(InducedRect, RightRect): pass class InducedLeftRect(InducedRect, LeftRect): pass def brect(lines): if len(lines) <= 1: return [LeftRect(0, lines)] newrects = [LeftRect(0, lines), RightRect(0, lines)] donerects = [] while newrects: oldrects = newrects newrects = [] for r in oldrects: width = r.width while 1: is_done = 0 d = {} pos = width ^ r.dir for line in r.lines: if width < len(line): d.setdefault(line[pos], []).append(line) else: is_done = 1 if is_done or len(d) != 1: break r.width = width = width + 1 donerects.append(r) width += 1 for k, v in list(d.items()): if len(v) > 1: new_r = r.__class__(width, v) newrects.append(new_r) return donerects def choose(rects, lines=[], gauges=[None]): def induce(r): uncommons = r.get_uncommons() if len(uncommons) < 2: return irs = [] for s in rects: if s.dir != r.dir: continue pss = [] uncs = s.get_uncommons(pickednos) lnos = s.lnos & ~pickednos assert len(uncs) == len(lnos) for unc, lno in zip(uncs, lnos): if unc in uncommons: pss.append(lno) if len(pss) == len(uncommons): pslnos = immbitset(pss) pss = [lines[lno] for lno in pss] if s.dir == -1: c = InducedRightRect else: c = InducedLeftRect ir = c(s, pss, pslnos) irs.append(ir) if irs: news.extend(irs) def overlap(r): rlnos = r.lnos tonews = [] for s in rects: if s is r: continue if s.dir != r.dir: continue slnos = s.lnos if not (slnos & rlnos): continue slnos &= ~ pickednos if not slnos: # remove continue scom = s.common_part if not scom: continue for t in rects: if t is s: continue if t.dir == s.dir: continue tlnos = t.lnos & ~pickednos if (tlnos & rlnos): continue olnos = tlnos & slnos if not olnos: continue if slnos == tlnos: continue tcom = t.common_part if not tcom: continue c = cmp_gauged(scom, tcom, gauges) if c > 0: continue break else: # s is ok tonews.append(s) rects.remove(s) news.extend(tonews) def picknext(): while 1: if news: r = news[0] del news[0] else: r = None for s in list(rects): slnos = s.lnos - pickednos if not slnos: rects.remove(s) continue sn = len(slnos) - 1 sw = s.width if r is not None: if not sw: break if not sn: continue if rwn: rmemo = r.gainmemo smemo = s.gainmemo c = 0 for gauge in gauges: try: gr = rmemo[gauge] except KeyError: gr = sum_gauge(gauge, r.common_part) rmemo[gauge] = gr gr = rn try: gs = smemo[gauge] except KeyError: gs = sum_gauge(gauge, s.common_part) smemo[gauge] = gs gs = sn c = gr - gs if c: break if c >= 0: continue r = s rlnos = slnos if not sw: break rn = sn rw = sw rwn = sn * sw if r is not None: rects.remove(r) if r is not None: r.reducelines(pickednos) if r.lnos: return r def cmpinit(x): return x.width, x.dir, x.lnos[0] if gauges[0] is None: gauges = gauges[1:] lnobyid = dict([(id(line), i) for i, line in enumerate(lines)]) orects = rects rects = list(orects) for r in rects: r.init2(lnobyid, lines) rects.sort(key=cmpinit, reverse=True) allnos = immbitrange(len(lines)) pickednos = mutbitset() pickedrects = [] news = [] while pickednos != allnos: r = picknext() pickednos \|= r.lnos pickedrects.append(r) induce(r) overlap(r) return pickedrects def chooserects(lines, gauges=[None]): rects = brect(lines) choosen = choose(rects, lines, gauges) return choosen def pr(): x = chooserects(['abc', 'ade']) x = chooserects(['abc', 'abe', 'ace', 'xby']) print(x) x = chooserects(['ab1', 'ab2', 'ac3', 'ac4']) print(x) # Case where.. (from right).. : # the total gain of two rects (bfbf+cfcf = 4) is greater than the gain of another # overlapping rect (ffff == 3), although the individual gains are less (= 2). # But in this case at least, the end result should likely become the same x = chooserects([ '1bf', '2bf', '3cf', '4cf']) print(x) # Case where it chooses twice.. x = chooserects([ 'abc', 'abd', 'bcx', 'bdy' ]) print('TW', x) # Case where it didn't choose enough rects x = ([ 'abc', 'abd', 'e' ]) print(chooserects(x)) # Case where it should prefer one side or the other # i.e. left traditionally print(chooserects(['abc', 'axc'])) # Case where it should give a width 0 rect print(chooserects(['a', ''])) # Case with overlap print(chooserects(['abcd', 'abce', 'a', 'f'])) # Case with induce print(chooserects(['abcd', 'abce', 'd', 'e'])) print(chooserects(['auvw', 'buvw', 'a', 'b'])) print(chooserects(['axuvw', 'bxuvw', 'axy', 'bxy', 'cy'])) def tmany(): for i in range(100): x = chooserects(['abc', 'abe', 'ace', 'xby'])	10.39 KB	2026-01-20 12:58
📄 __init__.py class _GLUECLAMP_: def _get_iterpermute(self): return self.IterPermute.iterpermute	87 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 cmd.py """A generic class to build line-oriented command interpreters. Interpreters constructed with this class obey the following conventions: 1. End of file on input is processed as the command 'EOF'. 2. A command is parsed out of each line by collecting the prefix composed of characters in the identchars member. 3. A command `foo' is dispatched to a method 'do_foo()'; the do_ method is passed a single argument consisting of the remainder of the line. 4. Typing an empty line repeats the last command. (Actually, it calls the method `emptyline', which may be overridden in a subclass.) 5. There is a predefined `help' method. Given an argument `topic', it calls the command `help_topic'. With no arguments, it lists all topics with defined help_ functions, broken into up to three topics; documented commands, miscellaneous help topics, and undocumented commands. 6. The command '?' is a synonym for `help'. The command '!' is a synonym for `shell', if a do_shell method exists. 7. If completion is enabled, completing commands will be done automatically, and completing of commands args is done by calling complete_foo() with arguments text, line, begidx, endidx. text is string we are matching against, all returned matches must begin with it. line is the current input line (lstripped), begidx and endidx are the beginning and end indexes of the text being matched, which could be used to provide different completion depending upon which position the argument is in. The `default' method may be overridden to intercept commands for which there is no do_ method. The `completedefault' method may be overridden to intercept completions for commands that have no complete_ method. The data member `self.ruler' sets the character used to draw separator lines in the help messages. If empty, no ruler line is drawn. It defaults to "=". If the value of `self.intro' is nonempty when the cmdloop method is called, it is printed out on interpreter startup. This value may be overridden via an optional argument to the cmdloop() method. The data members `self.doc_header', `self.misc_header', and `self.undoc_header' set the headers used for the help function's listings of documented functions, miscellaneous topics, and undocumented functions respectively. These interpreters use raw_input; thus, if the readline module is loaded, they automatically support Emacs-like command history and editing features. """ import string __all__ = ["Cmd"] PROMPT = '(Cmd) ' IDENTCHARS = string.ascii_letters + string.digits + '_' class Cmd: """A simple framework for writing line-oriented command interpreters. These are often useful for test harnesses, administrative tools, and prototypes that will later be wrapped in a more sophisticated interface. A Cmd instance or subclass instance is a line-oriented interpreter framework. There is no good reason to instantiate Cmd itself; rather, it's useful as a superclass of an interpreter class you define yourself in order to inherit Cmd's methods and encapsulate action methods. """ prompt = PROMPT identchars = IDENTCHARS ruler = '=' lastcmd = '' intro = None doc_leader = "" doc_header = "Documented commands (type help <topic>):" misc_header = "Miscellaneous help topics:" undoc_header = "Undocumented commands:" nohelp = "* No help on %s" use_rawinput = 1 def __init__(self, completekey='tab', stdin=None, stdout=None): """Instantiate a line-oriented interpreter framework. The optional argument 'completekey' is the readline name of a completion key; it defaults to the Tab key. If completekey is not None and the readline module is available, command completion is done automatically. The optional arguments stdin and stdout specify alternate input and output file objects; if not specified, sys.stdin and sys.stdout are used. """ import sys if stdin is not None: self.stdin = stdin else: self.stdin = sys.stdin if stdout is not None: self.stdout = stdout else: self.stdout = sys.stdout self.cmdqueue = [] self.completekey = completekey def cmdloop(self, intro=None): """Repeatedly issue a prompt, accept input, parse an initial prefix off the received input, and dispatch to action methods, passing them the remainder of the line as argument. """ self.preloop() if self.use_rawinput and self.completekey: try: import readline self.old_completer = readline.get_completer() readline.set_completer(self.complete) readline.parse_and_bind(self.completekey+": complete") except ImportError: pass try: if intro is not None: self.intro = intro if self.intro: self.stdout.write(str(self.intro)+"\n") stop = None while not stop: if self.cmdqueue: line = self.cmdqueue.pop(0) else: self.preinput() if self.use_rawinput: try: line = input(self.prompt) except EOFError: line = 'EOF' else: self.stdout.write(self.prompt) self.stdout.flush() line = self.stdin.readline() if not len(line): line = 'EOF' else: line = line[:-1] # chop \n line = self.postinput(line) line = self.precmd(line) stop = self.onecmd(line) stop = self.postcmd(stop, line) self.postloop() finally: if self.use_rawinput and self.completekey: try: import readline readline.set_completer(self.old_completer) except ImportError: pass def precmd(self, line): """Hook method executed just before the command line is interpreted, but after the input prompt is generated and issued. """ return line def postcmd(self, stop, line): """Hook method executed just after a command dispatch is finished.""" return stop def preinput(self): """Hook method executed just before an input line is read.""" def postinput(self, line): """Hook method executed just after an input line is read.""" return line def preloop(self): """Hook method executed once when the cmdloop() method is called.""" pass def postloop(self): """Hook method executed once when the cmdloop() method is about to return. """ pass def parseline(self, line): line = line.strip() if not line: return None, None, line elif line[0] == '?': line = 'help ' + line[1:] elif line[0] == '!': if hasattr(self, 'do_shell'): line = 'shell ' + line[1:] else: return None, None, line i, n = 0, len(line) while i < n and line[i] in self.identchars: i = i+1 cmd, arg = line[:i], line[i:].strip() return cmd, arg, line def onecmd(self, line): """Interpret the argument as though it had been typed in response to the prompt. This may be overridden, but should not normally need to be; see the precmd() and postcmd() methods for useful execution hooks. The return value is a flag indicating whether interpretation of commands by the interpreter should stop. """ cmd, arg, line = self.parseline(line) if not line: return self.emptyline() if cmd is None: return self.default(line) self.lastcmd = line if cmd == '': return self.default(line) else: try: func = getattr(self, 'do_' + cmd) except AttributeError: return self.default(line) return func(arg) def emptyline(self): """Called when an empty line is entered in response to the prompt. If this method is not overridden, it repeats the last nonempty command entered. """ if self.lastcmd: return self.onecmd(self.lastcmd) def default(self, line): """Called on an input line when the command prefix is not recognized. If this method is not overridden, it prints an error message and returns. """ self.stdout.write('* Unknown syntax: %s\n' % line) def completedefault(self, ignored): """Method called to complete an input line when no command-specific complete_() method is available. By default, it returns an empty list. """ return [] def completenames(self, text, ignored): dotext = 'do_'+text return [a[3:] for a in self.get_names() if a.startswith(dotext)] def complete(self, text, state): """Return the next possible completion for 'text'. If a command has not been entered, then complete against command list. Otherwise try to call complete_<command> to get list of completions. """ if state == 0: import readline origline = readline.get_line_buffer() line = origline.lstrip() stripped = len(origline) - len(line) begidx = readline.get_begidx() - stripped endidx = readline.get_endidx() - stripped if begidx > 0: cmd, args, foo = self.parseline(line) if cmd == '': compfunc = self.completedefault else: try: compfunc = getattr(self, 'complete_' + cmd) except AttributeError: compfunc = self.completedefault else: compfunc = self.completenames self.completion_matches = compfunc(text, line, begidx, endidx) try: return self.completion_matches[state] except IndexError: return None def get_names(self): # Inheritance says we have to look in class and # base classes; order is not important. names = [] classes = [self.__class__] while classes: aclass = classes.pop(0) if aclass.__bases__: classes = classes + list(aclass.__bases__) names = names + dir(aclass) return names def complete_help(self, args): return self.completenames(args) def do_help(self, arg): if arg: # XXX check arg syntax try: func = getattr(self, 'help_' + arg) except AttributeError: try: doc = getattr(self, 'do_' + arg).__doc__ if doc: self.stdout.write("%s\n" % str(doc)) return except AttributeError: pass self.stdout.write("%s\n" % str(self.nohelp % (arg,))) return func() else: names = self.get_names() cmds_doc = [] cmds_undoc = [] help = {} for name in names: if name[:5] == 'help_': help[name[5:]] = 1 names.sort() # There can be duplicates if routines overridden prevname = '' for name in names: if name[:3] == 'do_': if name == prevname: continue prevname = name cmd = name[3:] if cmd in help: cmds_doc.append(cmd) del help[cmd] elif getattr(self, name).__doc__: cmds_doc.append(cmd) else: cmds_undoc.append(cmd) self.stdout.write("%s\n" % str(self.doc_leader)) self.print_topics(self.doc_header, cmds_doc, 15, 80) self.print_topics(self.misc_header, list(help.keys()), 15, 80) self.print_topics(self.undoc_header, cmds_undoc, 15, 80) def print_topics(self, header, cmds, cmdlen, maxcol): if cmds: self.stdout.write("%s\n" % str(header)) if self.ruler: self.stdout.write("%s\n" % str(self.ruler len(header))) self.columnize(cmds, maxcol-1) self.stdout.write("\n") def columnize(self, list, displaywidth=80): """Display a list of strings as a compact set of columns. Each column is only as wide as necessary. Columns are separated by two spaces (one was not legible enough). """ if not list: self.stdout.write("<empty>\n") return nonstrings = [i for i in range(len(list)) if not isinstance(list[i], str)] if nonstrings: raise TypeError("list[i] not a string for i in %s" % ", ".join(map(str, nonstrings))) size = len(list) if size == 1: self.stdout.write('%s\n' % str(list[0])) return # Try every row count from 1 upwards for nrows in range(1, len(list)): ncols = (size+nrows-1) // nrows colwidths = [] totwidth = -2 for col in range(ncols): colwidth = 0 for row in range(nrows): i = row + nrowscol if i >= size: break x = list[i] colwidth = max(colwidth, len(x)) colwidths.append(colwidth) totwidth += colwidth + 2 if totwidth > displaywidth: break if totwidth <= displaywidth: break else: nrows = len(list) ncols = 1 colwidths = [0] for row in range(nrows): texts = [] for col in range(ncols): i = row + nrowscol if i >= size: x = "" else: x = list[i] texts.append(x) while texts and not texts[-1]: del texts[-1] for col in range(len(texts)): texts[col] = texts[col].ljust(colwidths[col]) self.stdout.write("%s\n" % str(" ".join(texts)))	14.72 KB	2026-01-20 12:58
📄 etc.py from io import StringIO def reptable(tb): if not tb: return 0, [] maxlens = [0]len(tb[0]) for r in tb: if r == '-': continue for i, e in enumerate(r): maxlens[i] = max(maxlens[i], len(str(e))+1) sumlens = len(maxlens) for s in maxlens: sumlens += s out = [] for r in tb: if r == '-': out.append('-'min(sumlens, 75)) else: so = '' for i, e in enumerate(r): s = str(e) if s.startswith('!>'): s = s[2:] fillright = 1 elif s.isdigit(): fillright = 1 else: fillright = 0 ml = maxlens[i]-1 fill = ' '(ml - len(s)) if fillright: s = fill + s else: s = s + fill so += s + ' ' out.append(so) return maxlens, out def ptable(tb, f=None): if f is None: import sys f = sys.stdout _, lines = reptable(tb) for line in lines: line = line.rstrip() print(line, file=f) def strtable(tb): f = StringIO() ptable(tb, f) return f.getvalue() def str2int(s, msg='Hexadecimal literal in the form [-]0x... expected'): # xxx clumsy -- there should be a builtin function for this ! if s.startswith('-'): sign = -1 s = s[1:] else: sign = 1 if not s.startswith('0x'): raise ValueError(msg) s = s[2:] if s.endswith('l') or s.endswith('L'): s = s[:-1] return int(s, 16) sign	1.66 KB	2026-01-20 12:58
📄 textView.py # Copied from idlelib/textView # - I copied it rather than imported since I didn't want # to have a dependency on idlelib, # and I can change what I may want. # For example, I removed the transient and wait window things # so a help window behaves more like a 'normal' window """Simple text browser """ from tkinter import * import tkinter.messagebox class TextViewer(Toplevel): """ simple text viewer dialog for idle """ def __init__(self, parent, title, fileName=None, data=None): """If data exists, load it into viewer, otherwise try to load file. fileName - string, should be an absoulute filename """ Toplevel.__init__(self, parent) self.configure(borderwidth=5) self.geometry("=%dx%d+%d+%d" % (625, 500, parent.winfo_rootx() + 10, parent.winfo_rooty() + 10)) # elguavas - config placeholders til config stuff completed self.bg = '#ffffff' self.fg = '#000000' self.CreateWidgets() self.title(title) # self.transient(parent) # self.grab_set() self.protocol("WM_DELETE_WINDOW", self.Ok) self.parent = parent self.textView.focus_set() # key bindings for this dialog self.bind('<Return>', self.Ok) # dismiss dialog self.bind('<Escape>', self.Ok) # dismiss dialog if data is not None: self.textView.insert(0.0, data) else: self.LoadTextFile(fileName) self.textView.config(state=DISABLED) # self.wait_window() def LoadTextFile(self, fileName): textFile = None try: textFile = open(fileName, 'r') except IOError: tkinter.messagebox.showerror(title='File Load Error', message='Unable to load file '+repr(fileName)+' .') else: self.textView.insert(0.0, textFile.read()) def CreateWidgets(self): frameText = Frame(self, relief=SUNKEN, height=700) frameButtons = Frame(self) self.buttonOk = Button(frameButtons, text='Close', command=self.Ok, takefocus=FALSE) self.scrollbarView = Scrollbar(frameText, orient=VERTICAL, takefocus=FALSE, highlightthickness=0) self.textView = Text(frameText, wrap=WORD, highlightthickness=0, fg=self.fg, bg=self.bg) self.scrollbarView.config(command=self.textView.yview) self.textView.config(yscrollcommand=self.scrollbarView.set) self.buttonOk.pack() self.scrollbarView.pack(side=RIGHT, fill=Y) self.textView.pack(side=LEFT, expand=TRUE, fill=BOTH) frameButtons.pack(side=BOTTOM, fill=X) frameText.pack(side=TOP, expand=TRUE, fill=BOTH) def Ok(self, event=None): self.destroy() if __name__ == '__main__': # test the dialog root = Tk() Button(root, text='View', command=lambda: TextViewer(root, 'Text', './textView.py')).pack() root.mainloop()	3.07 KB	2026-01-20 12:58
📄 tkcursors.py # A Tk window that shows what cursor shapes are available. # Moving the mouse over the cursor name shows the cursor in that shape. from tkinter import * def tkcursors(master=None): if master is None: root = Tk() else: root = master for i, cursor in enumerate(( 'X_cursor', 'arrow', 'based_arrow_down', 'based_arrow_up', 'boat', 'bogosity', 'bottom_left_corner', 'bottom_right_corner', 'bottom_side', 'bottom_tee', 'box_spiral', 'center_ptr', 'circle', 'clock', 'coffee_mug', 'cross', 'cross_reverse', 'crosshair', 'diamond_cross', 'dot', 'dotbox', 'double_arrow', 'draft_large', 'draft_small', 'draped_box', 'exchange', 'fleur', 'gobbler', 'gumby', 'hand1', 'hand2', 'heart', 'icon', 'iron_cross', 'left_ptr', 'left_side', 'left_tee', 'leftbutton', 'll_angle', 'lr_angle', 'man', 'middlebutton', 'mouse', 'pencil', 'pirate', 'plus', 'question_arrow', 'right_ptr', 'right_side', 'right_tee', 'rightbutton', 'rtl_logo', 'sailboat', 'sb_down_arrow', 'sb_h_double_arrow', 'sb_left_arrow', 'sb_right_arrow', 'sb_up_arrow', 'sb_v_double_arrow', 'shuttle', 'sizing', 'spider', 'spraycan', 'star', 'target', 'tcross', 'top_left_arrow', 'top_left_corner', 'top_right_corner', 'top_side', 'top_tee', 'trek', 'ul_angle', 'umbrella', 'ur_angle', 'watch', 'xterm' )): w = Label(root, text=cursor, cursor=cursor, width=20, anchor=W, relief=SUNKEN) col, row = divmod(i, 27) w.grid(row=row, column=col) if master is None: root.mainloop() if __name__ == '__main__': tkcursors()	2.13 KB	2026-01-20 12:58
📄 xterm.py # Run an xterm on current process or a forked process # Adapted from pty.py in Python 1.5.2 distribution. # The pty.fork() couldnt be used because it didn't return # the pty name needed by xterm # I couldnt import pty.py to use master_open because it didn't find termios. import os import sys import fcntl # We couldnt find termios STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO = 0, 1, 2 # Open pty master. Returns (master_fd, tty_name). SGI and Linux/BSD version. # Copied from pty.py from Python 1.5.2. /SN def master_open(): try: import sgi except ImportError: pass else: try: tty_name, master_fd = sgi._getpty(fcntl.O_RDWR, 0o666, 0) except IOError as msg: raise os.error(msg) return master_fd, tty_name for x in 'pqrstuvwxyzPQRST': for y in '0123456789abcdef': pty_name = '/dev/pty' + x + y try: fd = os.open(pty_name, fcntl.O_RDWR) except os.error: continue return (fd, '/dev/tty' + x + y) raise os.error('out of pty devices') # Open the pty slave. Acquire the controlling terminal. # Returns file descriptor. Linux version. (Should be universal? --Guido) # Copied from pty.py from Python 1.5.2. /SN def slave_open(tty_name): return os.open(tty_name, fcntl.O_RDWR) def xterm(prog=None, options=''): master_fd, tty_name = master_open() pid = os.fork() if pid: # Acquire controlling terminal. slave_fd = slave_open(tty_name) # Slave becomes stdin/stdout/stderr of child. os.dup2(slave_fd, STDIN_FILENO) os.dup2(slave_fd, STDOUT_FILENO) os.dup2(slave_fd, STDERR_FILENO) if (slave_fd > STDERR_FILENO): os.close(slave_fd) os.close(master_fd) sys.stdin.readline() # Throw away an init string from xterm if prog is not None: prog() else: os.setsid() cmd = 'xterm %s -S%s%d' % (options, tty_name[-2:], master_fd) os.system(cmd) #os.waitpid(pid, 0) return pid def forkxterm(prog=None, options=''): pid = os.fork() if pid: return pid else: os.setsid() pid = xterm(prog, options) if not pid: os._exit(0) def hello(): print('hello') while 1: pass	2.31 KB	2026-01-20 12:58

Terminal