File Manager

X7ROOT File Manager

Current Path: /opt/alt/python312/lib64/python3.12

opt / alt / python312 / lib64 / python3.12 /

ðŸ“ ..
ðŸ“„ LICENSE.txt(13.61 KB)
ðŸ“„ __future__.py(5.1 KB)
ðŸ“„ __hello__.py(227 B)
ðŸ“ __pycache__
ðŸ“„ _aix_support.py(3.93 KB)
ðŸ“„ _collections_abc.py(31.34 KB)
ðŸ“„ _compat_pickle.py(8.56 KB)
ðŸ“„ _compression.py(5.55 KB)
ðŸ“„ _markupbase.py(14.31 KB)
ðŸ“„ _osx_support.py(21.51 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydatetime.py(89.93 KB)
ðŸ“„ _pydecimal.py(221.96 KB)
ðŸ“„ _pyio.py(91.4 KB)
ðŸ“„ _pylong.py(10.54 KB)
ðŸ“„ _sitebuiltins.py(3.05 KB)
ðŸ“„ _strptime.py(27.73 KB)
ðŸ“„ _sysconfigdata__linux_x86_64-linux-gnu.py(74.76 KB)
ðŸ“„ _sysconfigdata_d_linux_x86_64-linux-gnu.py(74.75 KB)
ðŸ“„ _threading_local.py(7.05 KB)
ðŸ“„ _weakrefset.py(5.75 KB)
ðŸ“„ abc.py(6.38 KB)
ðŸ“„ aifc.py(33.41 KB)
ðŸ“„ antigravity.py(500 B)
ðŸ“„ argparse.py(98.78 KB)
ðŸ“„ ast.py(62.94 KB)
ðŸ“ asyncio
ðŸ“„ base64.py(20.16 KB)
ðŸ“„ bdb.py(32.79 KB)
ðŸ“„ bisect.py(3.34 KB)
ðŸ“„ bz2.py(11.57 KB)
ðŸ“„ cProfile.py(6.42 KB)
ðŸ“„ calendar.py(25.26 KB)
ðŸ“„ cgi.py(33.63 KB)
ðŸ“„ cgitb.py(12.13 KB)
ðŸ“„ chunk.py(5.37 KB)
ðŸ“„ cmd.py(14.52 KB)
ðŸ“„ code.py(10.71 KB)
ðŸ“„ codecs.py(36.01 KB)
ðŸ“„ codeop.py(5.77 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(20.03 KB)
ðŸ“ concurrent
ðŸ“ config-3.12-x86_64-linux-gnu
ðŸ“„ configparser.py(52.53 KB)
ðŸ“„ contextlib.py(26.99 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.21 KB)
ðŸ“„ copyreg.py(7.44 KB)
ðŸ“„ crypt.py(3.82 KB)
ðŸ“„ csv.py(16 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(60.63 KB)
ðŸ“„ datetime.py(268 B)
ðŸ“ dbm
ðŸ“„ decimal.py(2.74 KB)
ðŸ“„ difflib.py(81.41 KB)
ðŸ“„ dis.py(29.52 KB)
ðŸ“„ doctest.py(104.25 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(79.63 KB)
ðŸ“„ filecmp.py(10.14 KB)
ðŸ“„ fileinput.py(15.35 KB)
ðŸ“„ fnmatch.py(5.86 KB)
ðŸ“„ fractions.py(37.25 KB)
ðŸ“„ ftplib.py(33.92 KB)
ðŸ“„ functools.py(37.05 KB)
ðŸ“„ genericpath.py(5.18 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(20.82 KB)
ðŸ“„ glob.py(8.53 KB)
ðŸ“„ graphlib.py(9.42 KB)
ðŸ“„ gzip.py(24.81 KB)
ðŸ“„ hashlib.py(9.13 KB)
ðŸ“„ heapq.py(22.48 KB)
ðŸ“„ hmac.py(7.54 KB)
ðŸ“ html
ðŸ“ http
ðŸ“„ imaplib.py(52.77 KB)
ðŸ“„ imghdr.py(4.29 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(124.15 KB)
ðŸ“„ io.py(3.5 KB)
ðŸ“„ ipaddress.py(77.27 KB)
ðŸ“ json
ðŸ“„ keyword.py(1.05 KB)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.66 KB)
ðŸ“„ locale.py(76.76 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.97 KB)
ðŸ“„ mailbox.py(77.06 KB)
ðŸ“„ mailcap.py(9.11 KB)
ðŸ“„ mimetypes.py(22.5 KB)
ðŸ“„ modulefinder.py(23.14 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(6.76 KB)
ðŸ“„ nntplib.py(40.12 KB)
ðŸ“„ ntpath.py(31.11 KB)
ðŸ“„ nturl2path.py(2.32 KB)
ðŸ“„ numbers.py(11.2 KB)
ðŸ“„ opcode.py(12.87 KB)
ðŸ“„ operator.py(10.71 KB)
ðŸ“„ optparse.py(58.95 KB)
ðŸ“„ os.py(39.86 KB)
ðŸ“„ pathlib.py(49.86 KB)
ðŸ“„ pdb.py(68.66 KB)
ðŸ“„ pickle.py(65.34 KB)
ðŸ“„ pickletools.py(91.85 KB)
ðŸ“„ pipes.py(8.77 KB)
ðŸ“„ pkgutil.py(17.85 KB)
ðŸ“„ platform.py(42.38 KB)
ðŸ“„ plistlib.py(27.68 KB)
ðŸ“„ poplib.py(14.28 KB)
ðŸ“„ posixpath.py(16.89 KB)
ðŸ“„ pprint.py(23.59 KB)
ðŸ“„ profile.py(22.56 KB)
ðŸ“„ pstats.py(28.6 KB)
ðŸ“„ pty.py(5.99 KB)
ðŸ“„ py_compile.py(7.65 KB)
ðŸ“„ pyclbr.py(11.13 KB)
ðŸ“„ pydoc.py(110.86 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.23 KB)
ðŸ“„ quopri.py(7.03 KB)
ðŸ“„ random.py(33.88 KB)
ðŸ“ re
ðŸ“„ reprlib.py(6.98 KB)
ðŸ“„ rlcompleter.py(7.64 KB)
ðŸ“„ runpy.py(12.58 KB)
ðŸ“„ sched.py(6.2 KB)
ðŸ“„ secrets.py(1.94 KB)
ðŸ“„ selectors.py(19.21 KB)
ðŸ“„ shelve.py(8.36 KB)
ðŸ“„ shlex.py(13.04 KB)
ðŸ“„ shutil.py(55.43 KB)
ðŸ“„ signal.py(2.44 KB)
ðŸ“ site-packages
ðŸ“„ site.py(22.65 KB)
ðŸ“„ smtplib.py(42.52 KB)
ðŸ“„ sndhdr.py(7.27 KB)
ðŸ“„ socket.py(36.93 KB)
ðŸ“„ socketserver.py(27.41 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(231 B)
ðŸ“„ sre_constants.py(232 B)
ðŸ“„ sre_parse.py(229 B)
ðŸ“„ ssl.py(49.71 KB)
ðŸ“„ stat.py(5.36 KB)
ðŸ“„ statistics.py(49.05 KB)
ðŸ“„ string.py(11.51 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(86.67 KB)
ðŸ“„ sunau.py(18.04 KB)
ðŸ“„ symtable.py(12.18 KB)
ðŸ“„ sysconfig.py(31.1 KB)
ðŸ“„ tabnanny.py(11.27 KB)
ðŸ“„ tarfile.py(105.96 KB)
ðŸ“„ telnetlib.py(22.79 KB)
ðŸ“„ tempfile.py(31.63 KB)
ðŸ“„ textwrap.py(19.26 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(58.79 KB)
ðŸ“„ timeit.py(13.16 KB)
ðŸ“„ token.py(2.45 KB)
ðŸ“„ tokenize.py(21.06 KB)
ðŸ“ tomllib
ðŸ“„ trace.py(28.68 KB)
ðŸ“„ traceback.py(45.31 KB)
ðŸ“„ tracemalloc.py(17.62 KB)
ðŸ“„ tty.py(1.99 KB)
ðŸ“„ types.py(10.74 KB)
ðŸ“„ typing.py(116.05 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.17 KB)
ðŸ“„ uuid.py(28.96 KB)
ðŸ“ venv
ðŸ“„ warnings.py(21.4 KB)
ðŸ“„ wave.py(22.24 KB)
ðŸ“„ weakref.py(21.01 KB)
ðŸ“„ webbrowser.py(23.19 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.8 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.37 KB)
ðŸ“ zipfile
ðŸ“„ zipimport.py(27.19 KB)
ðŸ“ zoneinfo

Editing: reprlib.py

"""Redo the builtin repr() (representation) but with limits on most sizes."""

__all__ = ["Repr", "repr", "recursive_repr"]

import builtins
from itertools import islice
from _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__', {})
        wrapper.__type_params__ = getattr(user_function, '__type_params__', ())
        return wrapper

return decorating_function

class Repr:
    _lookup = {
        'tuple': 'builtins',
        'list': 'builtins',
        'array': 'array',
        'set': 'builtins',
        'frozenset': 'builtins',
        'deque': 'collections',
        'dict': 'builtins',
        'str': 'builtins',
        'int': 'builtins'
    }

def __init__(
        self, *, maxlevel=6, maxtuple=6, maxlist=6, maxarray=5, maxdict=4,
        maxset=6, maxfrozenset=6, maxdeque=6, maxstring=30, maxlong=40,
        maxother=30, fillvalue='...', indent=None,
    ):
        self.maxlevel = maxlevel
        self.maxtuple = maxtuple
        self.maxlist = maxlist
        self.maxarray = maxarray
        self.maxdict = maxdict
        self.maxset = maxset
        self.maxfrozenset = maxfrozenset
        self.maxdeque = maxdeque
        self.maxstring = maxstring
        self.maxlong = maxlong
        self.maxother = maxother
        self.fillvalue = fillvalue
        self.indent = indent

def repr(self, x):
        return self.repr1(x, self.maxlevel)

def repr1(self, x, level):
        cls = type(x)
        typename = cls.__name__

if ' ' in typename:
            parts = typename.split()
            typename = '_'.join(parts)

method = getattr(self, 'repr_' + typename, None)
        if method:
            # not defined in this class
            if typename not in self._lookup:
                return method(x, level)
            module = getattr(cls, '__module__', None)
            # defined in this class and is the module intended
            if module == self._lookup[typename]:
                return method(x, level)

return self.repr_instance(x, level)

def _join(self, pieces, level):
        if self.indent is None:
            return ', '.join(pieces)
        if not pieces:
            return ''
        indent = self.indent
        if isinstance(indent, int):
            if indent < 0:
                raise ValueError(
                    f'Repr.indent cannot be negative int (was {indent!r})'
                )
            indent *= ' '
        try:
            sep = ',\n' + (self.maxlevel - level + 1) * indent
        except TypeError as error:
            raise TypeError(
                f'Repr.indent must be a str, int or None, not {type(indent)}'
            ) from error
        return sep.join(('', *pieces, ''))[1:-len(indent) or None]

def _repr_iterable(self, x, level, left, right, maxiter, trail=''):
        n = len(x)
        if level <= 0 and n:
            s = self.fillvalue
        else:
            newlevel = level - 1
            repr1 = self.repr1
            pieces = [repr1(elem, newlevel) for elem in islice(x, maxiter)]
            if n > maxiter:
                pieces.append(self.fillvalue)
            s = self._join(pieces, level)
            if n == 1 and trail and self.indent is None:
                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 '{' + self.fillvalue + '}'
        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(self.fillvalue)
        s = self._join(pieces, level)
        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] + self.fillvalue + 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] + self.fillvalue + 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] + self.fillvalue + 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

X7ROOT File Manager

Editing: reprlib.py

Upload File

Create Folder