Provides the FileList class, used for poking about the filesystem
and building lists of files.
# This module should be kept compatible with Python 2.1.
__revision__
= "$Id: filelist.py,v 1.18 2004/11/10 22:23:14 loewis Exp $"
from distutils
.util
import convert_path
from distutils
.errors
import DistutilsTemplateError
, DistutilsInternalError
from distutils
import log
"""A list of files built by on exploring the filesystem and filtered by
applying various patterns to what we find there.
directory from which files will be taken -- only used if
'allfiles' not supplied to constructor
list of filenames currently being built/filtered/manipulated
complete list of files under consideration (ie. without any
# ignore argument to FileList, but keep them for backwards
def set_allfiles (self
, allfiles
):
def findall (self
, dir=os
.curdir
):
self
.allfiles
= findall(dir)
def debug_print (self
, msg
):
"""Print 'msg' to stdout if the global DEBUG (taken from the
DISTUTILS_DEBUG environment variable) flag is true.
from distutils
.debug
import DEBUG
# -- List-like methods ---------------------------------------------
def extend (self
, items
):
# Not a strict lexical sort!
sortable_files
= map(os
.path
.split
, self
.files
)
for sort_tuple
in sortable_files
:
self
.files
.append(apply(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]:
# -- "File template" methods ---------------------------------------
def _parse_template_line (self
, line
):
words
= string
.split(line
)
patterns
= dir = dir_pattern
= None
if action
in ('include', 'exclude',
'global-include', 'global-exclude'):
raise DistutilsTemplateError
, \
"'%s' expects <pattern1> <pattern2> ..." % action
patterns
= map(convert_path
, words
[1:])
elif action
in ('recursive-include', 'recursive-exclude'):
raise DistutilsTemplateError
, \
"'%s' expects <dir> <pattern1> <pattern2> ..." % action
dir = convert_path(words
[1])
patterns
= map(convert_path
, words
[2:])
elif action
in ('graft', 'prune'):
raise DistutilsTemplateError
, \
"'%s' expects a single <dir_pattern>" % action
dir_pattern
= convert_path(words
[1])
raise DistutilsTemplateError
, "unknown action '%s'" % action
return (action
, patterns
, dir, dir_pattern
)
# _parse_template_line ()
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. 'action' is always
# defined: it's the first word of the line. Which of the other
# three are defined depends on the action; it'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.
self
.debug_print("include " + string
.join(patterns
))
if not self
.include_pattern(pattern
, anchor
=1):
log
.warn("warning: no files found matching '%s'",
elif action
== 'exclude':
self
.debug_print("exclude " + string
.join(patterns
))
if not self
.exclude_pattern(pattern
, anchor
=1):
log
.warn(("warning: no previously-included files "
"found matching '%s'"), pattern
)
elif action
== 'global-include':
self
.debug_print("global-include " + string
.join(patterns
))
if not self
.include_pattern(pattern
, anchor
=0):
log
.warn(("warning: no files found matching '%s' " +
"anywhere in distribution"), pattern
)
elif action
== 'global-exclude':
self
.debug_print("global-exclude " + string
.join(patterns
))
if not self
.exclude_pattern(pattern
, anchor
=0):
log
.warn(("warning: no previously-included files matching "
"'%s' found anywhere in distribution"),
elif action
== 'recursive-include':
self
.debug_print("recursive-include %s %s" %
(dir, string
.join(patterns
)))
if not self
.include_pattern(pattern
, prefix
=dir):
log
.warn(("warning: no files found matching '%s' " +
elif action
== 'recursive-exclude':
self
.debug_print("recursive-exclude %s %s" %
(dir, string
.join(patterns
)))
if not self
.exclude_pattern(pattern
, prefix
=dir):
log
.warn(("warning: no previously-included files matching "
"'%s' found under directory '%s'"),
self
.debug_print("graft " + dir_pattern
)
if not self
.include_pattern(None, prefix
=dir_pattern
):
log
.warn("warning: no directories found matching '%s'",
self
.debug_print("prune " + dir_pattern
)
if not self
.exclude_pattern(None, prefix
=dir_pattern
):
log
.warn(("no previously-included directories found " +
"matching '%s'"), dir_pattern
)
raise DistutilsInternalError
, \
"this cannot happen: invalid action '%s'" % action
# process_template_line ()
# -- Filtering/selection methods -----------------------------------
def include_pattern (self
, pattern
,
anchor
=1, prefix
=None, is_regex
=0):
"""Select strings (presumably filenames) from 'self.files' that
match 'pattern', a Unix-style wildcard (glob) pattern. Patterns
are not quite the same as implemented by the 'fnmatch' module: '*'
and '?' match non-special characters, where "special" is platform-
dependent: slash on Unix; colon, slash, and backslash on
DOS/Windows; and colon on Mac OS.
If 'anchor' is true (the default), then the pattern match is more
stringent: "*.py" will match "foo.py" but not "foo/bar.py". If
'anchor' is false, both of these will match.
If 'prefix' is supplied, then only filenames starting with 'prefix'
(itself a pattern) and ending with 'pattern', with anything in between
them, will match. 'anchor' is ignored in this case.
If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
'pattern' is assumed to be either a string containing a regex or a
regex object -- no translation is done, the regex is just compiled
Selected strings will be added to self.files.
Return 1 if files are found.
pattern_re
= translate_pattern(pattern
, anchor
, prefix
, is_regex
)
self
.debug_print("include_pattern: applying regex r'%s'" %
# delayed loading of allfiles list
if self
.allfiles
is None:
for name
in self
.allfiles
:
if pattern_re
.search(name
):
self
.debug_print(" adding " + name
)
def exclude_pattern (self
, pattern
,
anchor
=1, prefix
=None, is_regex
=0):
"""Remove strings (presumably filenames) from 'files' that match
'pattern'. Other parameters are the same as for
'include_pattern()', above.
The list 'self.files' is modified in place.
Return 1 if files are found.
pattern_re
= translate_pattern(pattern
, anchor
, prefix
, is_regex
)
self
.debug_print("exclude_pattern: applying regex r'%s'" %
for i
in range(len(self
.files
)-1, -1, -1):
if pattern_re
.search(self
.files
[i
]):
self
.debug_print(" removing " + self
.files
[i
])
# ----------------------------------------------------------------------
def findall (dir = os
.curdir
):
"""Find all files under 'dir' and return the list of full filenames
from stat
import ST_MODE
, S_ISREG
, S_ISDIR
, S_ISLNK
if dir != os
.curdir
: # avoid the dreaded "./" syndrome
fullname
= os
.path
.join(dir, name
)
# Avoid excess stat calls -- just one will do, thank you!
elif S_ISDIR(mode
) and not S_ISLNK(mode
):
def glob_to_re (pattern
):
"""Translate a shell-like glob pattern to a regular expression; return
a string containing the regex. Differs from 'fnmatch.translate()' in
that '*' does not match "special characters" (which are
pattern_re
= fnmatch
.translate(pattern
)
# '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
# IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
# and by extension they shouldn't match such "special characters" under
# any OS. So change all non-escaped dots in the RE to match any
# character except the special characters.
# XXX currently the "special characters" are just slash -- i.e. this is
pattern_re
= re
.sub(r
'(^|[^\\])\.', r
'\1[^/]', pattern_re
)
def translate_pattern (pattern
, anchor
=1, prefix
=None, is_regex
=0):
"""Translate a shell-like wildcard pattern to a compiled regular
expression. Return the compiled regex. If 'is_regex' true,
then 'pattern' is directly compiled to a regex (if it's a string)
or just returned as-is (assumes it's a regex object).
if type(pattern
) is StringType
:
return re
.compile(pattern
)
pattern_re
= glob_to_re(pattern
)
prefix_re
= (glob_to_re(prefix
))[0:-1] # ditch trailing $
pattern_re
= "^" + os
.path
.join(prefix_re
, ".*" + pattern_re
)
else: # no prefix -- respect anchor flag
pattern_re
= "^" + pattern_re
return re
.compile(pattern_re
)