File Explorer

/proc/thread-self/root/proc/self/root/proc/1/cwd/lib64/python3.9

This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.

reprlib.py5.1 KB · 162 lines
"""Redo the builtin repr() (representation) but with limits on most sizes.""" __all__ = ["Repr", "repr", "recursive_repr"] import builtinsfrom itertools import islicefrom _thread import get_ident def recursive_repr(fillvalue='...'):    'Decorator to make a repr function return fillvalue for a recursive call'     def decorating_function(user_function):        repr_running = set()         def wrapper(self):            key = id(self), get_ident()            if key in repr_running:                return fillvalue            repr_running.add(key)            try:                result = user_function(self)            finally:                repr_running.discard(key)            return result         # Can't use functools.wraps() here because of bootstrap issues        wrapper.__module__ = getattr(user_function, '__module__')        wrapper.__doc__ = getattr(user_function, '__doc__')        wrapper.__name__ = getattr(user_function, '__name__')        wrapper.__qualname__ = getattr(user_function, '__qualname__')        wrapper.__annotations__ = getattr(user_function, '__annotations__', {})        return wrapper     return decorating_function class Repr:     def __init__(self):        self.maxlevel = 6        self.maxtuple = 6        self.maxlist = 6        self.maxarray = 5        self.maxdict = 4        self.maxset = 6        self.maxfrozenset = 6        self.maxdeque = 6        self.maxstring = 30        self.maxlong = 40        self.maxother = 30     def repr(self, x):        return self.repr1(x, self.maxlevel)     def repr1(self, x, level):        typename = type(x).__name__        if ' ' in typename:            parts = typename.split()            typename = '_'.join(parts)        if hasattr(self, 'repr_' + typename):            return getattr(self, 'repr_' + typename)(x, level)        else:            return self.repr_instance(x, level)     def _repr_iterable(self, x, level, left, right, maxiter, trail=''):        n = len(x)        if level <= 0 and n:            s = '...'        else:            newlevel = level - 1            repr1 = self.repr1            pieces = [repr1(elem, newlevel) for elem in islice(x, maxiter)]            if n > maxiter:  pieces.append('...')            s = ', '.join(pieces)            if n == 1 and trail:  right = trail + right        return '%s%s%s' % (left, s, right)     def repr_tuple(self, x, level):        return self._repr_iterable(x, level, '(', ')', self.maxtuple, ',')     def repr_list(self, x, level):        return self._repr_iterable(x, level, '[', ']', self.maxlist)     def repr_array(self, x, level):        if not x:            return "array('%s')" % x.typecode        header = "array('%s', [" % x.typecode        return self._repr_iterable(x, level, header, '])', self.maxarray)     def repr_set(self, x, level):        if not x:            return 'set()'        x = _possibly_sorted(x)        return self._repr_iterable(x, level, '{', '}', self.maxset)     def repr_frozenset(self, x, level):        if not x:            return 'frozenset()'        x = _possibly_sorted(x)        return self._repr_iterable(x, level, 'frozenset({', '})',                                   self.maxfrozenset)     def repr_deque(self, x, level):        return self._repr_iterable(x, level, 'deque([', '])', self.maxdeque)     def repr_dict(self, x, level):        n = len(x)        if n == 0: return '{}'        if level <= 0: return '{...}'        newlevel = level - 1        repr1 = self.repr1        pieces = []        for key in islice(_possibly_sorted(x), self.maxdict):            keyrepr = repr1(key, newlevel)            valrepr = repr1(x[key], newlevel)            pieces.append('%s: %s' % (keyrepr, valrepr))        if n > self.maxdict: pieces.append('...')        s = ', '.join(pieces)        return '{%s}' % (s,)     def repr_str(self, x, level):        s = builtins.repr(x[:self.maxstring])        if len(s) > self.maxstring:            i = max(0, (self.maxstring-3)//2)            j = max(0, self.maxstring-3-i)            s = builtins.repr(x[:i] + x[len(x)-j:])            s = s[:i] + '...' + s[len(s)-j:]        return s     def repr_int(self, x, level):        s = builtins.repr(x) # XXX Hope this isn't too slow...        if len(s) > self.maxlong:            i = max(0, (self.maxlong-3)//2)            j = max(0, self.maxlong-3-i)            s = s[:i] + '...' + s[len(s)-j:]        return s     def repr_instance(self, x, level):        try:            s = builtins.repr(x)            # Bugs in x.__repr__() can cause arbitrary            # exceptions -- then make up something        except Exception:            return '<%s instance at %#x>' % (x.__class__.__name__, id(x))        if len(s) > self.maxother:            i = max(0, (self.maxother-3)//2)            j = max(0, self.maxother-3-i)            s = s[:i] + '...' + s[len(s)-j:]        return s  def _possibly_sorted(x):    # Since not all sequences of items can be sorted and comparison    # functions may raise arbitrary exceptions, return an unsorted    # sequence in that case.    try:        return sorted(x)    except Exception:        return list(x) aRepr = Repr()repr = aRepr.repr