<h2>Edit File - filelist.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/distutils/filelist.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;distutils.filelist

Provides the FileList class, used for poking about the filesystem
and building lists of files.
&quot;&quot;&quot;

import os, re
import fnmatch
import functools
from distutils.util import convert_path
from distutils.errors import DistutilsTemplateError, DistutilsInternalError
from distutils import log

class FileList:
    &quot;&quot;&quot;A list of files built by on exploring the filesystem and filtered by
    applying various patterns to what we find there.

    Instance attributes:
      dir
        directory from which files will be taken -- only used if
        &#039;allfiles&#039; not supplied to constructor
      files
        list of filenames currently being built/filtered/manipulated
      allfiles
        complete list of files under consideration (ie. without any
        filtering applied)
    &quot;&quot;&quot;

    def __init__(self, warn=None, debug_print=None):
        # ignore argument to FileList, but keep them for backwards
        # compatibility
        self.allfiles = None
        self.files = []

    def set_allfiles(self, allfiles):
        self.allfiles = allfiles

    def findall(self, dir=os.curdir):
        self.allfiles = findall(dir)

    def debug_print(self, msg):
        &quot;&quot;&quot;Print &#039;msg&#039; to stdout if the global DEBUG (taken from the
        DISTUTILS_DEBUG environment variable) flag is true.
        &quot;&quot;&quot;
        from distutils.debug import DEBUG
        if DEBUG:
            print(msg)

    # -- List-like methods ---------------------------------------------

    def append(self, item):
        self.files.append(item)

    def extend(self, items):
        self.files.extend(items)

    def sort(self):
        # Not a strict lexical sort!
        sortable_files = sorted(map(os.path.split, self.files))
        self.files = []
        for sort_tuple in sortable_files:
            self.files.append(os.path.join(*sort_tuple))


    # -- Other miscellaneous utility methods ---------------------------

    def remove_duplicates(self):
        # Assumes list has been sorted!
        for i in range(len(self.files) - 1, 0, -1):
            if self.files[i] == self.files[i - 1]:
                del self.files[i]


    # -- &quot;File template&quot; methods ---------------------------------------

    def _parse_template_line(self, line):
        words = line.split()
        action = words[0]

        patterns = dir = dir_pattern = None

        if action in (&#039;include&#039;, &#039;exclude&#039;,
                      &#039;global-include&#039;, &#039;global-exclude&#039;):
            if len(words) &lt; 2:
                raise DistutilsTemplateError(
                      &quot;&#039;%s&#039; expects &lt;pattern1&gt; &lt;pattern2&gt; ...&quot; % action)
            patterns = [convert_path(w) for w in words[1:]]
        elif action in (&#039;recursive-include&#039;, &#039;recursive-exclude&#039;):
            if len(words) &lt; 3:
                raise DistutilsTemplateError(
                      &quot;&#039;%s&#039; expects &lt;dir&gt; &lt;pattern1&gt; &lt;pattern2&gt; ...&quot; % action)
            dir = convert_path(words[1])
            patterns = [convert_path(w) for w in words[2:]]
        elif action in (&#039;graft&#039;, &#039;prune&#039;):
            if len(words) != 2:
                raise DistutilsTemplateError(
                      &quot;&#039;%s&#039; expects a single &lt;dir_pattern&gt;&quot; % action)
            dir_pattern = convert_path(words[1])
        else:
            raise DistutilsTemplateError(&quot;unknown action &#039;%s&#039;&quot; % action)

        return (action, patterns, dir, dir_pattern)

    def process_template_line(self, line):
        # Parse the line: split it up, make sure the right number of words
        # is there, and return the relevant words.  &#039;action&#039; is always
        # defined: it&#039;s the first word of the line.  Which of the other
        # three are defined depends on the action; it&#039;ll be either
        # patterns, (dir and patterns), or (dir_pattern).
        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)

        # OK, now we know that the action is valid and we have the
        # right number of words on the line for that action -- so we
        # can proceed with minimal error-checking.
        if action == &#039;include&#039;:
            self.debug_print(&quot;include &quot; + &#039; &#039;.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=1):
                    log.warn(&quot;warning: no files found matching &#039;%s&#039;&quot;,
                             pattern)

        elif action == &#039;exclude&#039;:
            self.debug_print(&quot;exclude &quot; + &#039; &#039;.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=1):
                    log.warn((&quot;warning: no previously-included files &quot;
                              &quot;found matching &#039;%s&#039;&quot;), pattern)

        elif action == &#039;global-include&#039;:
            self.debug_print(&quot;global-include &quot; + &#039; &#039;.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=0):
                    log.warn((&quot;warning: no files found matching &#039;%s&#039; &quot;
                              &quot;anywhere in distribution&quot;), pattern)

        elif action == &#039;global-exclude&#039;:
            self.debug_print(&quot;global-exclude &quot; + &#039; &#039;.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=0):
                    log.warn((&quot;warning: no previously-included files matching &quot;
                              &quot;&#039;%s&#039; found anywhere in distribution&quot;),
                             pattern)

        elif action == &#039;recursive-include&#039;:
            self.debug_print(&quot;recursive-include %s %s&quot; %
                             (dir, &#039; &#039;.join(patterns)))
            for pattern in patterns:
                if not self.include_pattern(pattern, prefix=dir):
                    log.warn((&quot;warning: no files found matching &#039;%s&#039; &quot;
                                &quot;under directory &#039;%s&#039;&quot;),
                             pattern, dir)

        elif action == &#039;recursive-exclude&#039;:
            self.debug_print(&quot;recursive-exclude %s %s&quot; %
                             (dir, &#039; &#039;.join(patterns)))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, prefix=dir):
                    log.warn((&quot;warning: no previously-included files matching &quot;
                              &quot;&#039;%s&#039; found under directory &#039;%s&#039;&quot;),
                             pattern, dir)

        elif action == &#039;graft&#039;:
            self.debug_print(&quot;graft &quot; + dir_pattern)
            if not self.include_pattern(None, prefix=dir_pattern):
                log.warn(&quot;warning: no directories found matching &#039;%s&#039;&quot;,
                         dir_pattern)

        elif action == &#039;prune&#039;:
            self.debug_print(&quot;prune &quot; + dir_pattern)
            if not self.exclude_pattern(None, prefix=dir_pattern):
                log.warn((&quot;no previously-included directories found &quot;
                          &quot;matching &#039;%s&#039;&quot;), dir_pattern)
        else:
            raise DistutilsInternalError(
                  &quot;this cannot happen: invalid action &#039;%s&#039;&quot; % action)


    # -- Filtering/selection methods -----------------------------------

    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
        &quot;&quot;&quot;Select strings (presumably filenames) from &#039;self.files&#039; that
        match &#039;pattern&#039;, a Unix-style wildcard (glob) pattern.  Patterns
        are not quite the same as implemented by the &#039;fnmatch&#039; module: &#039;*&#039;
        and &#039;?&#039;  match non-special characters, where &quot;special&quot; is platform-
        dependent: slash on Unix; colon, slash, and backslash on
        DOS/Windows; and colon on Mac OS.

        If &#039;anchor&#039; is true (the default), then the pattern match is more
        stringent: &quot;*.py&quot; will match &quot;foo.py&quot; but not &quot;foo/bar.py&quot;.  If
        &#039;anchor&#039; is false, both of these will match.

        If &#039;prefix&#039; is supplied, then only filenames starting with &#039;prefix&#039;
        (itself a pattern) and ending with &#039;pattern&#039;, with anything in between
        them, will match.  &#039;anchor&#039; is ignored in this case.

        If &#039;is_regex&#039; is true, &#039;anchor&#039; and &#039;prefix&#039; are ignored, and
        &#039;pattern&#039; is assumed to be either a string containing a regex or a
        regex object -- no translation is done, the regex is just compiled
        and used as-is.

        Selected strings will be added to self.files.

        Return True if files are found, False otherwise.
        &quot;&quot;&quot;
        # XXX docstring lying about what the special chars are?
        files_found = False
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print(&quot;include_pattern: applying regex r&#039;%s&#039;&quot; %
                         pattern_re.pattern)

        # delayed loading of allfiles list
        if self.allfiles is None:
            self.findall()

        for name in self.allfiles:
            if pattern_re.search(name):
                self.debug_print(&quot; adding &quot; + name)
                self.files.append(name)
                files_found = True
        return files_found


    def exclude_pattern (self, pattern,
                         anchor=1, prefix=None, is_regex=0):
        &quot;&quot;&quot;Remove strings (presumably filenames) from &#039;files&#039; that match
        &#039;pattern&#039;.  Other parameters are the same as for
        &#039;include_pattern()&#039;, above.
        The list &#039;self.files&#039; is modified in place.
        Return True if files are found, False otherwise.
        &quot;&quot;&quot;
        files_found = False
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print(&quot;exclude_pattern: applying regex r&#039;%s&#039;&quot; %
                         pattern_re.pattern)
        for i in range(len(self.files)-1, -1, -1):
            if pattern_re.search(self.files[i]):
                self.debug_print(&quot; removing &quot; + self.files[i])
                del self.files[i]
                files_found = True
        return files_found


# ----------------------------------------------------------------------
# Utility functions

def _find_all_simple(path):
    &quot;&quot;&quot;
    Find all files under &#039;path&#039;
    &quot;&quot;&quot;
    results = (
        os.path.join(base, file)
        for base, dirs, files in os.walk(path, followlinks=True)
        for file in files
    )
    return filter(os.path.isfile, results)


def findall(dir=os.curdir):
    &quot;&quot;&quot;
    Find all files under &#039;dir&#039; and return the list of full filenames.
    Unless dir is &#039;.&#039;, return full filenames with dir prepended.
    &quot;&quot;&quot;
    files = _find_all_simple(dir)
    if dir == os.curdir:
        make_rel = functools.partial(os.path.relpath, start=dir)
        files = map(make_rel, files)
    return list(files)


def glob_to_re(pattern):
    &quot;&quot;&quot;Translate a shell-like glob pattern to a regular expression; return
    a string containing the regex.  Differs from &#039;fnmatch.translate()&#039; in
    that &#039;*&#039; does not match &quot;special characters&quot; (which are
    platform-specific).
    &quot;&quot;&quot;
    pattern_re = fnmatch.translate(pattern)

    # &#039;?&#039; and &#039;*&#039; in the glob pattern become &#039;.&#039; and &#039;.*&#039; in the RE, which
    # IMHO is wrong -- &#039;?&#039; and &#039;*&#039; aren&#039;t supposed to match slash in Unix,
    # and by extension they shouldn&#039;t match such &quot;special characters&quot; under
    # any OS.  So change all non-escaped dots in the RE to match any
    # character except the special characters (currently: just os.sep).
    sep = os.sep
    if os.sep == &#039;\\&#039;:
        # we&#039;re using a regex to manipulate a regex, so we need
        # to escape the backslash twice
        sep = r&#039;\\\\&#039;
    escaped = r&#039;\1[^%s]&#039; % sep
    pattern_re = re.sub(r&#039;((?&lt;!\\)(\\\\)*)\.&#039;, escaped, pattern_re)
    return pattern_re


def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0):
    &quot;&quot;&quot;Translate a shell-like wildcard pattern to a compiled regular
    expression.  Return the compiled regex.  If &#039;is_regex&#039; true,
    then &#039;pattern&#039; is directly compiled to a regex (if it&#039;s a string)
    or just returned as-is (assumes it&#039;s a regex object).
    &quot;&quot;&quot;
    if is_regex:
        if isinstance(pattern, str):
            return re.compile(pattern)
        else:
            return pattern

    # ditch start and end characters
    start, _, end = glob_to_re(&#039;_&#039;).partition(&#039;_&#039;)

    if pattern:
        pattern_re = glob_to_re(pattern)
        assert pattern_re.startswith(start) and pattern_re.endswith(end)
    else:
        pattern_re = &#039;&#039;

    if prefix is not None:
        prefix_re = glob_to_re(prefix)
        assert prefix_re.startswith(start) and prefix_re.endswith(end)
        prefix_re = prefix_re[len(start): len(prefix_re) - len(end)]
        sep = os.sep
        if os.sep == &#039;\\&#039;:
            sep = r&#039;\\&#039;
        pattern_re = pattern_re[len(start): len(pattern_re) - len(end)]
        pattern_re = r&#039;%s\A%s%s.*%s%s&#039; % (start, prefix_re, sep, pattern_re, end)
    else:                               # no prefix -- respect anchor flag
        if anchor:
            pattern_re = r&#039;%s\A%s&#039; % (start, pattern_re[len(start):])

    return re.compile(pattern_re)
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>