\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/cloudlinux/venv/lib/python3.11/site-packages/guppy/etc/

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