File Manager

X7ROOT File Manager

Current Path: /opt/cloudlinux/venv/lib/python3.11/site-packages/guppy/heapy

opt / cloudlinux / venv / lib / python3.11 / site-packages / guppy / heapy /

ðŸ“ ..
ðŸ“„ Classifiers.py(45.16 KB)
ðŸ“„ Console.py(843 B)
ðŸ“„ Doc.py(7.81 KB)
ðŸ“„ ImpSet.py(870 B)
ðŸ“„ Monitor.py(14.5 KB)
ðŸ“„ OutputHandling.py(11.52 KB)
ðŸ“„ Part.py(23.25 KB)
ðŸ“„ Path.py(14.19 KB)
ðŸ“„ Prof.py(90.38 KB)
ðŸ“„ RM.py(119 B)
ðŸ“„ RefPat.py(18.18 KB)
ðŸ“„ Remote.py(15.31 KB)
ðŸ“„ RemoteConstants.py(209 B)
ðŸ“„ Spec.py(48.59 KB)
ðŸ“„ Target.py(205 B)
ðŸ“„ UniSet.py(66.5 KB)
ðŸ“„ Use.py(23.05 KB)
ðŸ“„ View.py(19.05 KB)
ðŸ“„ __init__.py(209 B)
ðŸ“ __pycache__
ðŸ“„ heapyc.cpython-311-x86_64-linux-gnu.so(154.55 KB)
ðŸ“„ pbhelp.py(17.4 KB)
ðŸ“ test

Editing: Doc.py

class Doc:  # base class
    def __mod__(self, other):
        other = self.mod.getdoc(other)
        return self.mapchildren(lambda x: x % other)

def __rmod__(self, other):
        return self.mod.getdoc(other) % self

def __str__(self):
        return self.getstr()

def __eq__(self, other):
        if not isinstance(other, self.__class__):
            return 0

return str(self) == str(other)

def __hash__(self):
        return hash(str(self))

def shortest(self):
        return self.mapchildren(lambda x: x.shortest())

class Anon(Doc):
    def __init__(self, mod, obj):
        self.mod = mod
        self.obj = obj

def getstr(self):
        return repr(self.obj)

def mapchildren(self, f):
        return self

class Source(Doc):
    def __init__(self, mod, text):
        self.mod = mod
        self.text = text

def getstr(self):
        return self.text

def mapchildren(self, f):
        return self

class Attribute(Doc):
    def __init__(self, mod, obj, name):
        self.mod = mod
        self.obj = obj
        self.name = name

def __mod__(self, other):
        if self.obj is other:
            return self.mod.rootattribute(other, self.name)
        return self.mapchildren(lambda x: x % other)

def getstr(self):
        return '%s.%s' % (self.obj.getstr(), self.name)

def mapchildren(self, f):
        return self.__class__(self.mod, f(self.obj), self.name)

class RootAttribute(Doc):
    def __init__(self, mod, obj, name):
        self.mod = mod
        self.obj = obj
        self.name = name

def getstr(self):
        return '%s' % (self.name,)

def mapchildren(self, f):
        return self

class BinaryOp(Doc):
    table = {
        'and': '&',
        'or': '|',
        'sub': '-',
        'mul': '*',
        'pow': '**',
        'lshift': '<<',
        'rshift': '>>',
    }

def __init__(self, mod, op, a, b):
        self.mod = mod
        self.op = op
        self.a = a
        self.b = b

def getstr(self):
        return '%s %s %s' % (self.a.getstr(),
                             self.table[self.op],
                             self.b.getstr())

def mapchildren(self, f):
        return self.__class__(self.mod, self.op, f(self.a), f(self.b))

class UnaryOp(Doc):
    table = {
        'invert': '~',
        'neg': '-',
        'pos': '+',
    }

def __init__(self, mod, op, a):
        self.mod = mod
        self.op = op
        self.a = a

def getstr(self):
        return '%s %s' % (self.table[self.op], self.a.getstr())

def mapchildren(self, f):
        return self.__class__(self.mod, self.op, f(self.a))

class CallFunc(Doc):
    def __init__(self, mod, obj, *args, **kwds):
        self.mod = mod
        self.obj = obj
        self.args = args
        self.kwds = kwds

def getstr(self):
        return '%s(%s%s)' % (
            self.obj.getstr(),
            ', '.join([x.getstr() for x in self.args]),
            ', '.join(['%s=%s' % (k, v.getstr()) for k, v in list(self.kwds.items())]))

def mapchildren(self, f):
        obj = f(self.obj)
        args = [f(a) for a in self.args]
        kwds = dict([(k, f(v)) for (k, v) in list(self.kwds.items())])
        return self.__class__(self.mod, obj, *args, **kwds)

class Multi(Doc):
    def __init__(self, mod, set):
        self.mod = mod
        self.str = '{%s}' % ', '.join([x.getstr() for x in set])
        self.set = set

def getstr(self):
        return self.str

def mapchildren(self, f):
        return self.__class__(self.mod, dict([(f(x), 1) for x in self.set]))

def shortest(self):
        ls = None
        for a in self.set:
            a = a.shortest()
            l = len(a.getstr())
            if ls is None or l < ls:
                ls = l
                st = a
        return st

class Root(Doc):
    def __init__(self, mod, name='<root>'):
        self.mod = mod
        self.name = name

def __call__(self, name):
        return self.__class__(self.mod, name)

def mapchildren(self, f):
        return self

def getstr(self):
        return self.name

class Tuple(Doc):
    def __init__(self, mod, *args):
        self.mod = mod
        self.args = args

def mapchildren(self, f):
        return self.__class__(self.mod, *[f(x) for x in self.args])

def getstr(self):
        x = '(%s)' % ', '.join([x.getstr() for x in self.args])
        if len(self.args) == 1:
            x = x[:-1]+',)'
        return x

class DocError(Exception):
    pass

class _GLUECLAMP_:

def add_origin(self, obj, origin):
        o = getattr(obj, '_origin_', None)
        if o is None:
            obj._origin_ = origin
        else:
            obj._origin_ = self.multi(o, origin)
        return obj

def add_wrapdict(self, obj, doc):
        wd = self.wrapdict
        o = wd.get(id(obj))
        if o is None:
            o = (obj, doc)
        else:
            o = (obj, self.multi(o[1], doc))
        wd[id(obj)] = o
        return obj

def anon(self, obj):
        return Anon(self, obj)

def attribute(self, obj, name):
        return Attribute(self, self.getdoc(obj), name)

def binop(self, op, a, b):
        return BinaryOp(self, op, self.getdoc(a), self.getdoc(b))

def callfunc(self, obj, *args, **kwds):
        getdoc = self.getdoc
        obj = getdoc(obj)
        args = [getdoc(a) for a in args]
        kwds = dict([(k, getdoc(v)) for (k, v) in list(kwds.items())])
        return CallFunc(self, obj, *args, **kwds)

def getdoc(self, obj):
        if isinstance(obj, Doc):
            return obj
        w = getattr(obj, '_origin_', None)
        if isinstance(w, Doc):
            return w
        w = self.wrapdict.get(id(obj))
        if w is not None:
            return w[1]
        if isinstance(obj, tuple):
            return self.tuple(*obj)
        return self.anon(obj)

def multi(self, a, b):
        a = self.getdoc(a)
        b = self.getdoc(b)
        if isinstance(a, Multi):
            set = a.set.copy()
            if len(set) > 4:
                return a
        else:
            set = {a: 1}
        if isinstance(b, Multi):
            set.update(b.set)
        else:
            set[b] = 1
        return Multi(self, set)

def _get_root(self):
        return Root(self)

def rootattribute(self, root, name):
        return RootAttribute(self, self.getdoc(root), name)

def source(self, text):
        return Source(self, text)

def tuple(self, *args):
        return Tuple(self, *[self.getdoc(x) for x in args])

def unop(self, op, a):
        return UnaryOp(self, op, self.getdoc(a))

def wrap(self, obj, doc):
        assert obj is not self._parent.UniSet.UniSet
        w = getattr(obj, '_derive_origin_', None)
        if w is not None:
            if getattr(w, 'im_self', None) is obj or isinstance(w, self._root.types.MethodType):
                obj = w(doc)
            elif w == 'ADD':
                obj = self.add_origin(obj, doc)
            else:
                raise DocError(
                    "Doc.wrap:  attribute '_derive_origin_' has invalid value")
        elif isinstance(obj, self._root.types.MethodType):
            obj = self.wrap_method(obj, doc)
        elif isinstance(obj, self._root.types.FunctionType):
            obj = self.wrap_function(obj, doc)
        else:
            obj = self.add_wrapdict(obj, doc)
        return obj

def _get_wrapdict(self):
        return {}

def wrap_function(mod, obj, doc):
        def f(*args, **kwds):
            r = obj(*args, **kwds)
            r = mod.wrap(r, mod.callfunc(doc, *args, **kwds))
            return r
        f._origin_ = doc
        return f

def wrap_method(mod, obj, doc):
        im_func = obj.__func__

def f(self, *args, **kwds):
            r = im_func(self, *args, **kwds)
            r = mod.wrap(r, mod.callfunc(doc, *args, **kwds))
            return r
        return mod._root.types.MethodType(f, obj.__self__)

X7ROOT File Manager

Editing: Doc.py

Upload File

Create Folder