File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python27/lib64/python2.7/site-packages/guppy/etc

opt / alt / python27 / lib64 / python2.7 / site-packages / guppy / etc /

📁 ..
📄 Cat.py(3.31 KB)
📄 Cat.pyc(6.63 KB)
📄 Cat.pyo(6.63 KB)
📄 Code.py(1.09 KB)
📄 Code.pyc(1.53 KB)
📄 Code.pyo(1.53 KB)
📄 Compat.py(922 B)
📄 Compat.pyc(1.11 KB)
📄 Compat.pyo(1.11 KB)
📄 ExecfileWithModuleInfo.py(1.71 KB)
📄 ExecfileWithModuleInfo.pyc(2.62 KB)
📄 ExecfileWithModuleInfo.pyo(2.62 KB)
📄 FSA.py(4.92 KB)
📄 FSA.pyc(7.35 KB)
📄 FSA.pyo(7.35 KB)
📄 Glue.py(10.84 KB)
📄 Glue.pyc(14.6 KB)
📄 Glue.pyo(14.57 KB)
📄 Help.py(7.39 KB)
📄 Help.pyc(9.76 KB)
📄 Help.pyo(9.71 KB)
📄 IterPermute.py(1.79 KB)
📄 IterPermute.pyc(2.65 KB)
📄 IterPermute.pyo(2.22 KB)
📄 KanExtension.py(16.47 KB)
📄 KanExtension.pyc(24.4 KB)
📄 KanExtension.pyo(24.3 KB)
📄 KnuthBendix.py(7.58 KB)
📄 KnuthBendix.pyc(10.37 KB)
📄 KnuthBendix.pyo(9.7 KB)
📄 OutputHandling.py(6.68 KB)
📄 OutputHandling.pyc(13.06 KB)
📄 OutputHandling.pyo(13.06 KB)
📄 RE.py(18.49 KB)
📄 RE.pyc(32.58 KB)
📄 RE.pyo(32.53 KB)
📄 RE_Rect.py(8.47 KB)
📄 RE_Rect.pyc(11.5 KB)
📄 RE_Rect.pyo(11.41 KB)
📄 Unpack.py(1.9 KB)
📄 Unpack.pyc(2.91 KB)
📄 Unpack.pyo(2.91 KB)
📄 __init__.py(163 B)
📄 __init__.pyc(791 B)
📄 __init__.pyo(791 B)
📄 cmd.py(14.66 KB)
📄 cmd.pyc(14.43 KB)
📄 cmd.pyo(14.43 KB)
📄 etc.py(1.4 KB)
📄 etc.pyc(2.14 KB)
📄 etc.pyo(2.14 KB)
📄 textView.py(3.04 KB)
📄 textView.pyc(3.46 KB)
📄 textView.pyo(3.46 KB)
📄 tkcursors.py(1.57 KB)
📄 tkcursors.pyc(2.39 KB)
📄 tkcursors.pyo(2.39 KB)
📄 xterm.py(2.03 KB)
📄 xterm.pyc(2.29 KB)
📄 xterm.pyo(2.29 KB)

Editing: Cat.py

#._cv_part guppy.etc.Cat

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 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.__getitem__ = self.__call__ = f
	self.src = src
	self.tgt = tgt
    
    def __str__(self):
	return '%s(%s, %s, %s)'%(self.__class__, self.src, self.tgt, self.__call__)

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 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 = f.keys()
	    tgt = 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

Hackfut Security File Manager

Editing: Cat.py

Upload File

Create Folder