File Manager

X7ROOT File Manager

Current Path: /opt/alt/python311/lib64/python3.11

opt / alt / python311 / lib64 / python3.11 /

ðŸ“ ..
ðŸ“„ LICENSE.txt(13.61 KB)
ðŸ“„ __future__.py(5.1 KB)
ðŸ“„ __hello__.py(227 B)
ðŸ“ __pycache__
ðŸ“„ _aix_support.py(3.31 KB)
ðŸ“„ _bootsubprocess.py(2.61 KB)
ðŸ“„ _collections_abc.py(29.49 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)
ðŸ“„ _pydecimal.py(223.83 KB)
ðŸ“„ _pyio.py(91.99 KB)
ðŸ“„ _sitebuiltins.py(3.05 KB)
ðŸ“„ _strptime.py(24.58 KB)
ðŸ“„ _sysconfigdata__linux_x86_64-linux-gnu.py(57.28 KB)
ðŸ“„ _sysconfigdata_d_linux_x86_64-linux-gnu.py(56.52 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(97.93 KB)
ðŸ“„ ast.py(60 KB)
ðŸ“„ asynchat.py(11.3 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.83 KB)
ðŸ“„ base64.py(20.55 KB)
ðŸ“„ bdb.py(31.7 KB)
ðŸ“„ bisect.py(3.06 KB)
ðŸ“„ bz2.py(11.57 KB)
ðŸ“„ cProfile.py(6.21 KB)
ðŸ“„ calendar.py(24.15 KB)
ðŸ“„ cgi.py(33.63 KB)
ðŸ“„ cgitb.py(12.13 KB)
ðŸ“„ chunk.py(5.37 KB)
ðŸ“„ cmd.py(14.52 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(36.28 KB)
ðŸ“„ codeop.py(5.77 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(19.78 KB)
ðŸ“ concurrent
ðŸ“ config-3.11-x86_64-linux-gnu
ðŸ“„ configparser.py(54.36 KB)
ðŸ“„ contextlib.py(26.77 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.48 KB)
ðŸ“„ copyreg.py(7.5 KB)
ðŸ“„ crypt.py(3.82 KB)
ðŸ“„ csv.py(15.65 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(57.1 KB)
ðŸ“„ datetime.py(89.68 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(81.36 KB)
ðŸ“„ dis.py(28.23 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(103.81 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(77.72 KB)
ðŸ“„ filecmp.py(9.94 KB)
ðŸ“„ fileinput.py(15.35 KB)
ðŸ“„ fnmatch.py(5.86 KB)
ðŸ“„ fractions.py(28 KB)
ðŸ“„ ftplib.py(34.98 KB)
ðŸ“„ functools.py(37.51 KB)
ðŸ“„ genericpath.py(4.86 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(20.82 KB)
ðŸ“„ glob.py(8.53 KB)
ðŸ“„ graphlib.py(9.43 KB)
ðŸ“„ gzip.py(23.51 KB)
ðŸ“„ hashlib.py(11.49 KB)
ðŸ“„ heapq.py(22.48 KB)
ðŸ“„ hmac.py(7.54 KB)
ðŸ“ html
ðŸ“ http
ðŸ“„ imaplib.py(53.92 KB)
ðŸ“„ imghdr.py(3.86 KB)
ðŸ“„ imp.py(10.36 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(120.53 KB)
ðŸ“„ io.py(4.22 KB)
ðŸ“„ ipaddress.py(77.27 KB)
ðŸ“ json
ðŸ“„ keyword.py(1.04 KB)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.52 KB)
ðŸ“„ locale.py(77.24 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.97 KB)
ðŸ“„ mailbox.py(76.98 KB)
ðŸ“„ mailcap.py(9.15 KB)
ðŸ“„ mimetypes.py(22.42 KB)
ðŸ“„ modulefinder.py(23.14 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(6.77 KB)
ðŸ“„ nntplib.py(40.12 KB)
ðŸ“„ ntpath.py(29.51 KB)
ðŸ“„ nturl2path.py(2.82 KB)
ðŸ“„ numbers.py(10.11 KB)
ðŸ“„ opcode.py(10.2 KB)
ðŸ“„ operator.py(10.71 KB)
ðŸ“„ optparse.py(58.95 KB)
ðŸ“„ os.py(38.6 KB)
ðŸ“„ pathlib.py(47.43 KB)
ðŸ“„ pdb.py(62.68 KB)
ðŸ“„ pickle.py(63.61 KB)
ðŸ“„ pickletools.py(91.66 KB)
ðŸ“„ pipes.py(8.77 KB)
ðŸ“„ pkgutil.py(24.06 KB)
ðŸ“„ platform.py(41.3 KB)
ðŸ“„ plistlib.py(27.69 KB)
ðŸ“„ poplib.py(14.84 KB)
ðŸ“„ posixpath.py(16.61 KB)
ðŸ“„ pprint.py(24.01 KB)
ðŸ“„ profile.py(22.36 KB)
ðŸ“„ pstats.py(28.67 KB)
ðŸ“„ pty.py(6.17 KB)
ðŸ“„ py_compile.py(7.65 KB)
ðŸ“„ pyclbr.py(11.13 KB)
ðŸ“„ pydoc.py(110.02 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.23 KB)
ðŸ“„ quopri.py(7.11 KB)
ðŸ“„ random.py(31.41 KB)
ðŸ“ re
ðŸ“„ reprlib.py(5.31 KB)
ðŸ“„ rlcompleter.py(7.64 KB)
ðŸ“„ runpy.py(12.85 KB)
ðŸ“„ sched.py(6.2 KB)
ðŸ“„ secrets.py(1.98 KB)
ðŸ“„ selectors.py(19.21 KB)
ðŸ“„ shelve.py(8.36 KB)
ðŸ“„ shlex.py(13.18 KB)
ðŸ“„ shutil.py(55.19 KB)
ðŸ“„ signal.py(2.44 KB)
ðŸ“ site-packages
ðŸ“„ site.py(22.45 KB)
ðŸ“„ smtpd.py(30.44 KB)
ðŸ“„ smtplib.py(44.37 KB)
ðŸ“„ sndhdr.py(7.27 KB)
ðŸ“„ socket.py(36.68 KB)
ðŸ“„ socketserver.py(26.94 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(231 B)
ðŸ“„ sre_constants.py(232 B)
ðŸ“„ sre_parse.py(229 B)
ðŸ“„ ssl.py(53.03 KB)
ðŸ“„ stat.py(5.36 KB)
ðŸ“„ statistics.py(46.59 KB)
ðŸ“„ string.py(11.51 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(86.65 KB)
ðŸ“„ sunau.py(18.05 KB)
ðŸ“„ symtable.py(10.13 KB)
ðŸ“„ sysconfig.py(29.6 KB)
ðŸ“„ tabnanny.py(11.05 KB)
ðŸ“„ tarfile.py(105.35 KB)
ðŸ“„ telnetlib.py(22.75 KB)
ðŸ“„ tempfile.py(31.13 KB)
ðŸ“„ textwrap.py(19.26 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(56.87 KB)
ðŸ“„ timeit.py(13.21 KB)
ðŸ“„ token.py(2.33 KB)
ðŸ“„ tokenize.py(25.72 KB)
ðŸ“ tomllib
ðŸ“„ trace.py(28.51 KB)
ðŸ“„ traceback.py(39.6 KB)
ðŸ“„ tracemalloc.py(17.62 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ types.py(9.83 KB)
ðŸ“„ typing.py(118.12 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.17 KB)
ðŸ“„ uuid.py(26.95 KB)
ðŸ“ venv
ðŸ“„ warnings.py(20.62 KB)
ðŸ“„ wave.py(21.31 KB)
ðŸ“„ weakref.py(21.01 KB)
ðŸ“„ webbrowser.py(24.56 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.84 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(91.59 KB)
ðŸ“„ zipimport.py(30.17 KB)
ðŸ“ zoneinfo

Editing: fnmatch.py

"""Filename matching with shell patterns.

fnmatch(FILENAME, PATTERN) matches according to the local convention.
fnmatchcase(FILENAME, PATTERN) always takes case in account.

The functions operate by translating the pattern into a regular
expression.  They cache the compiled regular expressions for speed.

The function translate(PATTERN) returns a regular expression
corresponding to PATTERN.  (It does not compile it.)
"""
import os
import posixpath
import re
import functools

__all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]

def fnmatch(name, pat):
    """Test whether FILENAME matches PATTERN.

Patterns are Unix shell style:

*       matches everything
    ?       matches any single character
    [seq]   matches any character in seq
    [!seq]  matches any char not in seq

An initial period in FILENAME is not special.
    Both FILENAME and PATTERN are first case-normalized
    if the operating system requires it.
    If you don't want this, use fnmatchcase(FILENAME, PATTERN).
    """
    name = os.path.normcase(name)
    pat = os.path.normcase(pat)
    return fnmatchcase(name, pat)

@functools.lru_cache(maxsize=32768, typed=True)
def _compile_pattern(pat):
    if isinstance(pat, bytes):
        pat_str = str(pat, 'ISO-8859-1')
        res_str = translate(pat_str)
        res = bytes(res_str, 'ISO-8859-1')
    else:
        res = translate(pat)
    return re.compile(res).match

def filter(names, pat):
    """Construct a list from those elements of the iterable NAMES that match PAT."""
    result = []
    pat = os.path.normcase(pat)
    match = _compile_pattern(pat)
    if os.path is posixpath:
        # normcase on posix is NOP. Optimize it away from the loop.
        for name in names:
            if match(name):
                result.append(name)
    else:
        for name in names:
            if match(os.path.normcase(name)):
                result.append(name)
    return result

def fnmatchcase(name, pat):
    """Test whether FILENAME matches PATTERN, including case.

This is a version of fnmatch() which doesn't case-normalize
    its arguments.
    """
    match = _compile_pattern(pat)
    return match(name) is not None

def translate(pat):
    """Translate a shell PATTERN to a regular expression.

There is no way to quote meta-characters.
    """

STAR = object()
    res = []
    add = res.append
    i, n = 0, len(pat)
    while i < n:
        c = pat[i]
        i = i+1
        if c == '*':
            # compress consecutive `*` into one
            if (not res) or res[-1] is not STAR:
                add(STAR)
        elif c == '?':
            add('.')
        elif c == '[':
            j = i
            if j < n and pat[j] == '!':
                j = j+1
            if j < n and pat[j] == ']':
                j = j+1
            while j < n and pat[j] != ']':
                j = j+1
            if j >= n:
                add('\\[')
            else:
                stuff = pat[i:j]
                if '-' not in stuff:
                    stuff = stuff.replace('\\', r'\\')
                else:
                    chunks = []
                    k = i+2 if pat[i] == '!' else i+1
                    while True:
                        k = pat.find('-', k, j)
                        if k < 0:
                            break
                        chunks.append(pat[i:k])
                        i = k+1
                        k = k+3
                    chunk = pat[i:j]
                    if chunk:
                        chunks.append(chunk)
                    else:
                        chunks[-1] += '-'
                    # Remove empty ranges -- invalid in RE.
                    for k in range(len(chunks)-1, 0, -1):
                        if chunks[k-1][-1] > chunks[k][0]:
                            chunks[k-1] = chunks[k-1][:-1] + chunks[k][1:]
                            del chunks[k]
                    # Escape backslashes and hyphens for set difference (--).
                    # Hyphens that create ranges shouldn't be escaped.
                    stuff = '-'.join(s.replace('\\', r'\\').replace('-', r'\-')
                                     for s in chunks)
                # Escape set operations (&&, ~~ and ||).
                stuff = re.sub(r'([&~|])', r'\\\1', stuff)
                i = j+1
                if not stuff:
                    # Empty range: never match.
                    add('(?!)')
                elif stuff == '!':
                    # Negated empty range: match any character.
                    add('.')
                else:
                    if stuff[0] == '!':
                        stuff = '^' + stuff[1:]
                    elif stuff[0] in ('^', '['):
                        stuff = '\\' + stuff
                    add(f'[{stuff}]')
        else:
            add(re.escape(c))
    assert i == n

# Deal with STARs.
    inp = res
    res = []
    add = res.append
    i, n = 0, len(inp)
    # Fixed pieces at the start?
    while i < n and inp[i] is not STAR:
        add(inp[i])
        i += 1
    # Now deal with STAR fixed STAR fixed ...
    # For an interior `STAR fixed` pairing, we want to do a minimal
    # .*? match followed by `fixed`, with no possibility of backtracking.
    # Atomic groups ("(?>...)") allow us to spell that directly.
    # Note: people rely on the undocumented ability to join multiple
    # translate() results together via "|" to build large regexps matching
    # "one of many" shell patterns.
    while i < n:
        assert inp[i] is STAR
        i += 1
        if i == n:
            add(".*")
            break
        assert inp[i] is not STAR
        fixed = []
        while i < n and inp[i] is not STAR:
            fixed.append(inp[i])
            i += 1
        fixed = "".join(fixed)
        if i == n:
            add(".*")
            add(fixed)
        else:
            add(f"(?>.*?{fixed})")
    assert i == n
    res = "".join(res)
    return fr'(?s:{res})\Z'

X7ROOT File Manager

Editing: fnmatch.py

Upload File

Create Folder