File Manager

X7ROOT File Manager

Current Path: /opt/alt/python313/lib64/python3.13

opt / alt / python313 / lib64 / python3.13 /

?? ..
?? LICENSE.txt(13.49 KB)
?? __future__.py(5.1 KB)
?? __hello__.py(227 B)
?? __pycache__
?? _aix_support.py(3.93 KB)
?? _android_support.py(6.73 KB)
?? _apple_support.py(2.2 KB)
?? _collections_abc.py(31.51 KB)
?? _colorize.py(2.78 KB)
?? _compat_pickle.py(8.53 KB)
?? _compression.py(5.55 KB)
?? _ios_support.py(2.61 KB)
?? _markupbase.py(14.31 KB)
?? _opcode_metadata.py(9.05 KB)
?? _osx_support.py(21.51 KB)
?? _py_abc.py(6.04 KB)
?? _pydatetime.py(89.83 KB)
?? _pydecimal.py(221.96 KB)
?? _pyio.py(91.5 KB)
?? _pylong.py(11.55 KB)
?? _pyrepl
?? _sitebuiltins.py(3.05 KB)
?? _strptime.py(28.69 KB)
?? _sysconfigdata__linux_x86_64-linux-gnu.py(65.73 KB)
?? _sysconfigdata_d_linux_x86_64-linux-gnu.py(65.71 KB)
?? _threading_local.py(4.26 KB)
?? _weakrefset.py(5.75 KB)
?? abc.py(6.38 KB)
?? antigravity.py(500 B)
?? argparse.py(99.28 KB)
?? ast.py(63.81 KB)
?? asyncio
?? base64.py(21.14 KB)
?? bdb.py(34.51 KB)
?? bisect.py(3.34 KB)
?? bz2.py(11.69 KB)
?? cProfile.py(6.48 KB)
?? calendar.py(25.47 KB)
?? cmd.py(14.96 KB)
?? code.py(12.86 KB)
?? codecs.py(36.06 KB)
?? codeop.py(5.69 KB)
?? collections
?? colorsys.py(3.97 KB)
?? compileall.py(20.18 KB)
?? concurrent
?? config-3.13-x86_64-linux-gnu
?? configparser.py(52.57 KB)
?? contextlib.py(27.15 KB)
?? contextvars.py(129 B)
?? copy.py(8.76 KB)
?? copyreg.py(7.44 KB)
?? csv.py(18.73 KB)
?? ctypes
?? curses
?? dataclasses.py(63.03 KB)
?? datetime.py(268 B)
?? dbm
?? decimal.py(2.73 KB)
?? difflib.py(81.41 KB)
?? dis.py(40 KB)
?? doctest.py(106.77 KB)
?? email
?? encodings
?? ensurepip
?? enum.py(83.57 KB)
?? filecmp.py(10.4 KB)
?? fileinput.py(15.35 KB)
?? fnmatch.py(6.04 KB)
?? fractions.py(39.08 KB)
?? ftplib.py(33.92 KB)
?? functools.py(38.21 KB)
?? genericpath.py(6.1 KB)
?? getopt.py(7.31 KB)
?? getpass.py(6.09 KB)
?? gettext.py(21.03 KB)
?? glob.py(19.26 KB)
?? graphlib.py(9.42 KB)
?? gzip.py(24.06 KB)
?? hashlib.py(9.22 KB)
?? heapq.py(22.48 KB)
?? hmac.py(7.54 KB)
?? html
?? http
?? imaplib.py(52.77 KB)
?? importlib
?? inspect.py(125.27 KB)
?? io.py(3.5 KB)
?? ipaddress.py(79.72 KB)
?? json
?? keyword.py(1.05 KB)
?? lib-dynload
?? linecache.py(7.11 KB)
?? locale.py(77.18 KB)
?? logging
?? lzma.py(13.08 KB)
?? mailbox.py(79.73 KB)
?? mimetypes.py(23.29 KB)
?? modulefinder.py(23.23 KB)
?? multiprocessing
?? netrc.py(6.76 KB)
?? ntpath.py(32.04 KB)
?? nturl2path.py(2.32 KB)
?? numbers.py(11.2 KB)
?? opcode.py(2.76 KB)
?? operator.py(10.72 KB)
?? optparse.py(58.95 KB)
?? os.py(40.66 KB)
?? pathlib
?? pdb.py(88.81 KB)
?? pickle.py(65.39 KB)
?? pickletools.py(91.85 KB)
?? pkgutil.py(17.85 KB)
?? platform.py(46.25 KB)
?? plistlib.py(29.1 KB)
?? poplib.py(14.26 KB)
?? posixpath.py(17.93 KB)
?? pprint.py(23.59 KB)
?? profile.py(22.61 KB)
?? pstats.py(28.61 KB)
?? pty.py(5.99 KB)
?? py_compile.py(7.65 KB)
?? pyclbr.py(11.13 KB)
?? pydoc.py(107.5 KB)
?? pydoc_data
?? queue.py(13.17 KB)
?? quopri.py(7.03 KB)
?? random.py(36.14 KB)
?? re
?? reprlib.py(7.02 KB)
?? rlcompleter.py(7.73 KB)
?? runpy.py(12.58 KB)
?? sched.py(6.2 KB)
?? secrets.py(1.94 KB)
?? selectors.py(19 KB)
?? shelve.py(8.6 KB)
?? shlex.py(13.04 KB)
?? shutil.py(56.12 KB)
?? signal.py(2.44 KB)
?? site-packages
?? site.py(24.97 KB)
?? smtplib.py(42.52 KB)
?? socket.py(36.87 KB)
?? socketserver.py(27.41 KB)
?? sqlite3
?? sre_compile.py(231 B)
?? sre_constants.py(232 B)
?? sre_parse.py(229 B)
?? ssl.py(51.47 KB)
?? stat.py(6 KB)
?? statistics.py(60.38 KB)
?? string.py(11.51 KB)
?? stringprep.py(12.61 KB)
?? struct.py(257 B)
?? subprocess.py(87.39 KB)
?? symtable.py(13.87 KB)
?? sysconfig
?? tabnanny.py(11.27 KB)
?? tarfile.py(111.42 KB)
?? tempfile.py(31.61 KB)
?? textwrap.py(19.47 KB)
?? this.py(1003 B)
?? threading.py(53.95 KB)
?? timeit.py(13.16 KB)
?? token.py(2.43 KB)
?? tokenize.py(21.06 KB)
?? tomllib
?? trace.py(29.03 KB)
?? traceback.py(64.96 KB)
?? tracemalloc.py(17.62 KB)
?? tty.py(1.99 KB)
?? types.py(10.94 KB)
?? typing.py(129.61 KB)
?? unittest
?? urllib
?? uuid.py(28.46 KB)
?? venv
?? warnings.py(26.32 KB)
?? wave.py(22.69 KB)
?? weakref.py(21.01 KB)
?? webbrowser.py(23.73 KB)
?? wsgiref
?? xml
?? xmlrpc
?? zipapp.py(8.42 KB)
?? zipfile
?? zipimport.py(32.12 KB)
?? zoneinfo

Editing: _android_support.py

import io
import sys
from threading import RLock
from time import sleep, time

# The maximum length of a log message in bytes, including the level marker and
# tag, is defined as LOGGER_ENTRY_MAX_PAYLOAD at
# https://cs.android.com/android/platform/superproject/+/android-14.0.0_r1:system/logging/liblog/include/log/log.h;l=71.
# Messages longer than this will be truncated by logcat. This limit has already
# been reduced at least once in the history of Android (from 4076 to 4068 between
# API level 23 and 26), so leave some headroom.
MAX_BYTES_PER_WRITE = 4000

# UTF-8 uses a maximum of 4 bytes per character, so limiting text writes to this
# size ensures that we can always avoid exceeding MAX_BYTES_PER_WRITE.
# However, if the actual number of bytes per character is smaller than that,
# then we may still join multiple consecutive text writes into binary
# writes containing a larger number of characters.
MAX_CHARS_PER_WRITE = MAX_BYTES_PER_WRITE // 4

# When embedded in an app on current versions of Android, there's no easy way to
# monitor the C-level stdout and stderr. The testbed comes with a .c file to
# redirect them to the system log using a pipe, but that wouldn't be convenient
# or appropriate for all apps. So we redirect at the Python level instead.
def init_streams(android_log_write, stdout_prio, stderr_prio):
    if sys.executable:
        return  # Not embedded in an app.

global logcat
    logcat = Logcat(android_log_write)

sys.stdout = TextLogStream(
        stdout_prio, "python.stdout", sys.stdout.fileno())
    sys.stderr = TextLogStream(
        stderr_prio, "python.stderr", sys.stderr.fileno())

class TextLogStream(io.TextIOWrapper):
    def __init__(self, prio, tag, fileno=None, **kwargs):
        # The default is surrogateescape for stdout and backslashreplace for
        # stderr, but in the context of an Android log, readability is more
        # important than reversibility.
        kwargs.setdefault("encoding", "UTF-8")
        kwargs.setdefault("errors", "backslashreplace")

super().__init__(BinaryLogStream(prio, tag, fileno), **kwargs)
        self._lock = RLock()
        self._pending_bytes = []
        self._pending_bytes_count = 0

def __repr__(self):
        return f"<TextLogStream {self.buffer.tag!r}>"

def write(self, s):
        if not isinstance(s, str):
            raise TypeError(
                f"write() argument must be str, not {type(s).__name__}")

# In case `s` is a str subclass that writes itself to stdout or stderr
        # when we call its methods, convert it to an actual str.
        s = str.__str__(s)

# We want to emit one log message per line wherever possible, so split
        # the string into lines first. Note that "".splitlines() == [], so
        # nothing will be logged for an empty string.
        with self._lock:
            for line in s.splitlines(keepends=True):
                while line:
                    chunk = line[:MAX_CHARS_PER_WRITE]
                    line = line[MAX_CHARS_PER_WRITE:]
                    self._write_chunk(chunk)

return len(s)

# The size and behavior of TextIOWrapper's buffer is not part of its public
    # API, so we handle buffering ourselves to avoid truncation.
    def _write_chunk(self, s):
        b = s.encode(self.encoding, self.errors)
        if self._pending_bytes_count + len(b) > MAX_BYTES_PER_WRITE:
            self.flush()

self._pending_bytes.append(b)
        self._pending_bytes_count += len(b)
        if (
            self.write_through
            or b.endswith(b"\n")
            or self._pending_bytes_count > MAX_BYTES_PER_WRITE
        ):
            self.flush()

def flush(self):
        with self._lock:
            self.buffer.write(b"".join(self._pending_bytes))
            self._pending_bytes.clear()
            self._pending_bytes_count = 0

# Since this is a line-based logging system, line buffering cannot be turned
    # off, i.e. a newline always causes a flush.
    @property
    def line_buffering(self):
        return True

class BinaryLogStream(io.RawIOBase):
    def __init__(self, prio, tag, fileno=None):
        self.prio = prio
        self.tag = tag
        self._fileno = fileno

def __repr__(self):
        return f"<BinaryLogStream {self.tag!r}>"

def writable(self):
        return True

def write(self, b):
        if type(b) is not bytes:
            try:
                b = bytes(memoryview(b))
            except TypeError:
                raise TypeError(
                    f"write() argument must be bytes-like, not {type(b).__name__}"
                ) from None

# Writing an empty string to the stream should have no effect.
        if b:
            logcat.write(self.prio, self.tag, b)
        return len(b)

# This is needed by the test suite --timeout option, which uses faulthandler.
    def fileno(self):
        if self._fileno is None:
            raise io.UnsupportedOperation("fileno")
        return self._fileno

# When a large volume of data is written to logcat at once, e.g. when a test
# module fails in --verbose3 mode, there's a risk of overflowing logcat's own
# buffer and losing messages. We avoid this by imposing a rate limit using the
# token bucket algorithm, based on a conservative estimate of how fast `adb
# logcat` can consume data.
MAX_BYTES_PER_SECOND = 1024 * 1024

# The logcat buffer size of a device can be determined by running `logcat -g`.
# We set the token bucket size to half of the buffer size of our current minimum
# API level, because other things on the system will be producing messages as
# well.
BUCKET_SIZE = 128 * 1024

# https://cs.android.com/android/platform/superproject/+/android-14.0.0_r1:system/logging/liblog/include/log/log_read.h;l=39
PER_MESSAGE_OVERHEAD = 28

class Logcat:
    def __init__(self, android_log_write):
        self.android_log_write = android_log_write
        self._lock = RLock()
        self._bucket_level = 0
        self._prev_write_time = time()

def write(self, prio, tag, message):
        # Encode null bytes using "modified UTF-8" to avoid them truncating the
        # message.
        message = message.replace(b"\x00", b"\xc0\x80")

with self._lock:
            now = time()
            self._bucket_level += (
                (now - self._prev_write_time) * MAX_BYTES_PER_SECOND)

# If the bucket level is still below zero, the clock must have gone
            # backwards, so reset it to zero and continue.
            self._bucket_level = max(0, min(self._bucket_level, BUCKET_SIZE))
            self._prev_write_time = now

self._bucket_level -= PER_MESSAGE_OVERHEAD + len(tag) + len(message)
            if self._bucket_level < 0:
                sleep(-self._bucket_level / MAX_BYTES_PER_SECOND)

self.android_log_write(prio, tag, message)

X7ROOT File Manager

Editing: _android_support.py

Upload File

Create Folder