File Manager

X7ROOT File Manager

Current Path: /opt/alt/python37/lib64/python3.7

opt / alt / python37 / lib64 / python3.7 /

ðŸ“ ..
ðŸ“„ __future__.py(4.98 KB)
ðŸ“„ __phello__.foo.py(64 B)
ðŸ“ __pycache__
ðŸ“„ _bootlocale.py(1.76 KB)
ðŸ“„ _collections_abc.py(25.8 KB)
ðŸ“„ _compat_pickle.py(8.54 KB)
ðŸ“„ _compression.py(5.21 KB)
ðŸ“„ _dummy_thread.py(5.89 KB)
ðŸ“„ _markupbase.py(14.26 KB)
ðŸ“„ _osx_support.py(19.14 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydecimal.py(223.33 KB)
ðŸ“„ _pyio.py(89.47 KB)
ðŸ“„ _sitebuiltins.py(3.04 KB)
ðŸ“„ _strptime.py(24.91 KB)
ðŸ“„ _sysconfigdata_dm_linux_x86_64-linux-gnu.py(30.59 KB)
ðŸ“„ _sysconfigdata_m_linux_x86_64-linux-gnu.py(27.93 KB)
ðŸ“„ _threading_local.py(7.04 KB)
ðŸ“„ _weakrefset.py(5.55 KB)
ðŸ“„ abc.py(5.45 KB)
ðŸ“„ aifc.py(32.04 KB)
ðŸ“„ antigravity.py(477 B)
ðŸ“„ argparse.py(93.14 KB)
ðŸ“„ ast.py(12.54 KB)
ðŸ“„ asynchat.py(11.06 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.65 KB)
ðŸ“„ base64.py(19.92 KB)
ðŸ“„ bdb.py(30.99 KB)
ðŸ“„ binhex.py(13.63 KB)
ðŸ“„ bisect.py(2.5 KB)
ðŸ“„ bz2.py(12.12 KB)
ðŸ“„ cProfile.py(6.11 KB)
ðŸ“„ calendar.py(24.24 KB)
ðŸ“„ cgi.py(34.23 KB)
ðŸ“„ cgitb.py(11.74 KB)
ðŸ“„ chunk.py(5.31 KB)
ðŸ“„ cmd.py(14.51 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(35.76 KB)
ðŸ“„ codeop.py(6.13 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(13.46 KB)
ðŸ“ concurrent
ðŸ“ config-3.7m
ðŸ“„ configparser.py(53.01 KB)
ðŸ“„ contextlib.py(24.18 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.65 KB)
ðŸ“„ copyreg.py(6.85 KB)
ðŸ“„ crypt.py(3.27 KB)
ðŸ“„ csv.py(15.8 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(48.36 KB)
ðŸ“„ datetime.py(84.52 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(82.42 KB)
ðŸ“„ dis.py(19.42 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(102.11 KB)
ðŸ“„ dummy_threading.py(2.75 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(34.22 KB)
ðŸ“„ filecmp.py(9.6 KB)
ðŸ“„ fileinput.py(14.28 KB)
ðŸ“„ fnmatch.py(3.96 KB)
ðŸ“„ formatter.py(14.79 KB)
ðŸ“„ fractions.py(23.2 KB)
ðŸ“„ ftplib.py(34.78 KB)
ðŸ“„ functools.py(32.16 KB)
ðŸ“„ genericpath.py(4.8 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(21.45 KB)
ðŸ“„ glob.py(5.51 KB)
ðŸ“„ gzip.py(20.15 KB)
ðŸ“„ hashlib.py(9.31 KB)
ðŸ“„ heapq.py(22.48 KB)
ðŸ“„ hmac.py(6.36 KB)
ðŸ“ html
ðŸ“ http
ðŸ“ idlelib
ðŸ“„ imaplib.py(52.04 KB)
ðŸ“„ imghdr.py(3.71 KB)
ðŸ“„ imp.py(10.29 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(114.88 KB)
ðŸ“„ io.py(3.43 KB)
ðŸ“„ ipaddress.py(71.85 KB)
ðŸ“ json
ðŸ“„ keyword.py(2.2 KB)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.21 KB)
ðŸ“„ locale.py(76.36 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.68 KB)
ðŸ“„ macpath.py(5.98 KB)
ðŸ“„ mailbox.py(76.81 KB)
ðŸ“„ mailcap.py(8.85 KB)
ðŸ“„ mimetypes.py(20.99 KB)
ðŸ“„ modulefinder.py(22.5 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(5.44 KB)
ðŸ“„ nntplib.py(42.08 KB)
ðŸ“„ ntpath.py(21.82 KB)
ðŸ“„ nturl2path.py(2.52 KB)
ðŸ“„ numbers.py(10 KB)
ðŸ“„ opcode.py(5.69 KB)
ðŸ“„ operator.py(10.61 KB)
ðŸ“„ optparse.py(58.96 KB)
ðŸ“„ os.py(37.01 KB)
ðŸ“„ pathlib.py(49.15 KB)
ðŸ“„ pdb.py(61.04 KB)
ðŸ“„ pickle.py(56.63 KB)
ðŸ“„ pickletools.py(89.08 KB)
ðŸ“„ pipes.py(8.71 KB)
ðŸ“„ pkgutil.py(20.96 KB)
ðŸ“„ platform.py(45.89 KB)
ðŸ“„ plistlib.py(29.99 KB)
ðŸ“„ poplib.py(14.61 KB)
ðŸ“„ posixpath.py(15.4 KB)
ðŸ“„ pprint.py(20.39 KB)
ðŸ“„ profile.py(21.97 KB)
ðŸ“„ pstats.py(26.67 KB)
ðŸ“„ pty.py(4.65 KB)
ðŸ“„ py_compile.py(7.81 KB)
ðŸ“„ pyclbr.py(14.78 KB)
ðŸ“„ pydoc.py(103.39 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.09 KB)
ðŸ“„ quopri.py(7.09 KB)
ðŸ“„ random.py(26.91 KB)
ðŸ“„ re.py(14.95 KB)
ðŸ“„ reprlib.py(5.14 KB)
ðŸ“„ rlcompleter.py(6.93 KB)
ðŸ“„ runpy.py(11.68 KB)
ðŸ“„ sched.py(6.29 KB)
ðŸ“„ secrets.py(1.99 KB)
ðŸ“„ selectors.py(18.13 KB)
ðŸ“„ shelve.py(8.33 KB)
ðŸ“„ shlex.py(12.79 KB)
ðŸ“„ shutil.py(40.97 KB)
ðŸ“„ signal.py(2.07 KB)
ðŸ“ site-packages
ðŸ“„ site.py(21.07 KB)
ðŸ“„ smtpd.py(33.91 KB)
ðŸ“„ smtplib.py(43.4 KB)
ðŸ“„ sndhdr.py(6.92 KB)
ðŸ“„ socket.py(26.83 KB)
ðŸ“„ socketserver.py(26.29 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(26.24 KB)
ðŸ“„ sre_constants.py(7.01 KB)
ðŸ“„ sre_parse.py(38.24 KB)
ðŸ“„ ssl.py(44.43 KB)
ðŸ“„ stat.py(5.26 KB)
ðŸ“„ statistics.py(20.17 KB)
ðŸ“„ string.py(11.29 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(70.95 KB)
ðŸ“„ sunau.py(17.94 KB)
ðŸ“„ symbol.py(2.09 KB)
ðŸ“„ symtable.py(7.11 KB)
ðŸ“„ sysconfig.py(23.87 KB)
ðŸ“„ tabnanny.py(11.15 KB)
ðŸ“„ tarfile.py(90.5 KB)
ðŸ“„ telnetlib.py(22.59 KB)
ðŸ“„ tempfile.py(26.1 KB)
ðŸ“ test
ðŸ“„ textwrap.py(18.95 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(48.13 KB)
ðŸ“„ timeit.py(13.18 KB)
ðŸ“„ token.py(3.67 KB)
ðŸ“„ tokenize.py(26.4 KB)
ðŸ“„ trace.py(28.23 KB)
ðŸ“„ traceback.py(22.89 KB)
ðŸ“„ tracemalloc.py(16.68 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ types.py(9.67 KB)
ðŸ“„ typing.py(55.12 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.11 KB)
ðŸ“„ uuid.py(28.83 KB)
ðŸ“ venv
ðŸ“„ warnings.py(19.61 KB)
ðŸ“„ wave.py(17.8 KB)
ðŸ“„ weakref.py(21 KB)
ðŸ“„ webbrowser.py(23.16 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.77 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(79.19 KB)

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=256, 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):
    """Return the subset of the list 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.
    """

i, n = 0, len(pat)
    res = ''
    while i < n:
        c = pat[i]
        i = i+1
        if c == '*':
            res = res + '.*'
        elif c == '?':
            res = res + '.'
        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:
                res = res + '\\['
            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
                    chunks.append(pat[i:j])
                    # 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 stuff[0] == '!':
                    stuff = '^' + stuff[1:]
                elif stuff[0] in ('^', '['):
                    stuff = '\\' + stuff
                res = '%s[%s]' % (res, stuff)
        else:
            res = res + re.escape(c)
    return r'(?s:%s)\Z' % res

X7ROOT File Manager

Editing: fnmatch.py

Upload File

Create Folder