\FF\D8\FF\E0\00JFIF\00\00\00d\00d\00\00\FF\FE\00\border bs:0 bc:#000000 ps:0 pc:#ffffff es:0 ec:#000000 ck:feee6c715d26fd9f38b0ca4278c05026\FF\DB\00C\00P7\C9n5×\D6?\BDê\9Ds\EBp\9F[`8m\B7)o\B5\E8\E6I\99\FE3]]A2\BA\8Cw\D6E\93\\DEv\C8\009\F2\F1NI?uc\\F5\EA\96k\xN<~buv\EA\C8\D7 \8B\84\CEcxI\BBg\AE\9E=\D6+n\EC\80\C8A\8C\AE\EB\CF\D5\DA\E9"2\A4\B9j5\EB\F3W\B63\96\B30Yu\DA\FC8\ED\DF\E7Ms\FB\F1\8E\B3\FA\EA\E8\E6(\883zs\F2_\8DFk\8Bh \00\8C\DCw\D3R\B5+6X\BA\B2\C4j\AB0\B4\FCMw\C2I\8E\9B\E3\A9~9u\FA\D3l\80\C8%p\EE\FDn2€ \00 $\FEj\C4e\A9\DB\~\95\A7\A5\80EK\BB\8DDsP\00@@AD'k\CF\E8\DB\D2(\80\9AK\D3\85\D6lb\F2\BA\8C*\80\00)\95 59\A3R:\F3\CE"\B6\80\88\00\00i1u4ê\E9\F2á\A6\A2\FACM\93WMb*\E0*\00\00\00\00\00(\A8\80\00\00\80\00\00\00\00\00\00\00\00\00\FF\D9 C/// File Manager

File Manager

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

Viewing File: 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