123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167 |
- """
- Filename globbing utility. Mostly a copy of `glob` from Python 3.5.
- Changes include:
- * `yield from` and PEP3102 `*` removed.
- * Hidden files are not ignored.
- """
- import os
- import re
- import fnmatch
- __all__ = ["glob", "iglob", "escape"]
- def glob(pathname, recursive=False):
- """Return a list of paths matching a pathname pattern.
- The pattern may contain simple shell-style wildcards a la
- fnmatch. However, unlike fnmatch, filenames starting with a
- dot are special cases that are not matched by '*' and '?'
- patterns.
- If recursive is true, the pattern '**' will match any files and
- zero or more directories and subdirectories.
- """
- return list(iglob(pathname, recursive=recursive))
- def iglob(pathname, recursive=False):
- """Return an iterator which yields the paths matching a pathname pattern.
- The pattern may contain simple shell-style wildcards a la
- fnmatch. However, unlike fnmatch, filenames starting with a
- dot are special cases that are not matched by '*' and '?'
- patterns.
- If recursive is true, the pattern '**' will match any files and
- zero or more directories and subdirectories.
- """
- it = _iglob(pathname, recursive)
- if recursive and _isrecursive(pathname):
- s = next(it) # skip empty string
- assert not s
- return it
- def _iglob(pathname, recursive):
- dirname, basename = os.path.split(pathname)
- glob_in_dir = glob2 if recursive and _isrecursive(basename) else glob1
- if not has_magic(pathname):
- if basename:
- if os.path.lexists(pathname):
- yield pathname
- else:
- # Patterns ending with a slash should match only directories
- if os.path.isdir(dirname):
- yield pathname
- return
- if not dirname:
- yield from glob_in_dir(dirname, basename)
- return
- # `os.path.split()` returns the argument itself as a dirname if it is a
- # drive or UNC path. Prevent an infinite recursion if a drive or UNC path
- # contains magic characters (i.e. r'\\?\C:').
- if dirname != pathname and has_magic(dirname):
- dirs = _iglob(dirname, recursive)
- else:
- dirs = [dirname]
- if not has_magic(basename):
- glob_in_dir = glob0
- for dirname in dirs:
- for name in glob_in_dir(dirname, basename):
- yield os.path.join(dirname, name)
- # These 2 helper functions non-recursively glob inside a literal directory.
- # They return a list of basenames. `glob1` accepts a pattern while `glob0`
- # takes a literal basename (so it only has to check for its existence).
- def glob1(dirname, pattern):
- if not dirname:
- if isinstance(pattern, bytes):
- dirname = os.curdir.encode('ASCII')
- else:
- dirname = os.curdir
- try:
- names = os.listdir(dirname)
- except OSError:
- return []
- return fnmatch.filter(names, pattern)
- def glob0(dirname, basename):
- if not basename:
- # `os.path.split()` returns an empty basename for paths ending with a
- # directory separator. 'q*x/' should match only directories.
- if os.path.isdir(dirname):
- return [basename]
- else:
- if os.path.lexists(os.path.join(dirname, basename)):
- return [basename]
- return []
- # This helper function recursively yields relative pathnames inside a literal
- # directory.
- def glob2(dirname, pattern):
- assert _isrecursive(pattern)
- yield pattern[:0]
- for x in _rlistdir(dirname):
- yield x
- # Recursively yields relative pathnames inside a literal directory.
- def _rlistdir(dirname):
- if not dirname:
- if isinstance(dirname, bytes):
- dirname = os.curdir.encode('ASCII')
- else:
- dirname = os.curdir
- try:
- names = os.listdir(dirname)
- except os.error:
- return
- for x in names:
- yield x
- path = os.path.join(dirname, x) if dirname else x
- for y in _rlistdir(path):
- yield os.path.join(x, y)
- magic_check = re.compile('([*?[])')
- magic_check_bytes = re.compile(b'([*?[])')
- def has_magic(s):
- if isinstance(s, bytes):
- match = magic_check_bytes.search(s)
- else:
- match = magic_check.search(s)
- return match is not None
- def _isrecursive(pattern):
- if isinstance(pattern, bytes):
- return pattern == b'**'
- else:
- return pattern == '**'
- def escape(pathname):
- """Escape all special characters.
- """
- # Escaping is done by wrapping any of "*?[" between square brackets.
- # Metacharacters do not work in the drive part and shouldn't be escaped.
- drive, pathname = os.path.splitdrive(pathname)
- if isinstance(pathname, bytes):
- pathname = magic_check_bytes.sub(br'[\1]', pathname)
- else:
- pathname = magic_check.sub(r'[\1]', pathname)
- return drive + pathname
|