def filter(filenames, pattern):
filtered_filenames = []
pattern = os.path.normcase(pattern)
cached_pattern = _get_cached_pattern(pattern)
if os.path is posixpath:
# normcase on posix is NOP. Optimize it away from the loop.
for filename in filenames:
if cached_pattern.match(filename):
filtered_filenames.append(filename)
else:
for filename in filenames:
norm_name = os.path.normcase(filename)
if cached_pattern.match(norm_name):
filtered_filenames.append(filename)
return filtered_filenames
python类filter()的实例源码
def find_data_files(self, package, src_dir):
"""Return filenames for package's data files in 'src_dir'"""
patterns = self._get_platform_patterns(
self.package_data,
package,
src_dir,
)
globs_expanded = map(glob, patterns)
# flatten the expanded globs into an iterable of matches
globs_matches = itertools.chain.from_iterable(globs_expanded)
glob_files = filter(os.path.isfile, globs_matches)
files = itertools.chain(
self.manifest_files.get(package, []),
glob_files,
)
return self.exclude_data_files(package, src_dir, files)
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
files = list(files)
patterns = self._get_platform_patterns(
self.exclude_package_data,
package,
src_dir,
)
match_groups = (
fnmatch.filter(files, pattern)
for pattern in patterns
)
# flatten the groups of matches into an iterable of matches
matches = itertools.chain.from_iterable(match_groups)
bad = set(matches)
keepers = (
fn
for fn in files
if fn not in bad
)
# ditch dupes
return list(_unique_everseen(keepers))
def find_data_files(self, package, src_dir):
"""Return filenames for package's data files in 'src_dir'"""
patterns = self._get_platform_patterns(
self.package_data,
package,
src_dir,
)
globs_expanded = map(glob, patterns)
# flatten the expanded globs into an iterable of matches
globs_matches = itertools.chain.from_iterable(globs_expanded)
glob_files = filter(os.path.isfile, globs_matches)
files = itertools.chain(
self.manifest_files.get(package, []),
glob_files,
)
return self.exclude_data_files(package, src_dir, files)
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
files = list(files)
patterns = self._get_platform_patterns(
self.exclude_package_data,
package,
src_dir,
)
match_groups = (
fnmatch.filter(files, pattern)
for pattern in patterns
)
# flatten the groups of matches into an iterable of matches
matches = itertools.chain.from_iterable(match_groups)
bad = set(matches)
keepers = (
fn
for fn in files
if fn not in bad
)
# ditch dupes
return list(_unique_everseen(keepers))
def find_data_files(self, package, src_dir):
"""Return filenames for package's data files in 'src_dir'"""
patterns = self._get_platform_patterns(
self.package_data,
package,
src_dir,
)
globs_expanded = map(glob, patterns)
# flatten the expanded globs into an iterable of matches
globs_matches = itertools.chain.from_iterable(globs_expanded)
glob_files = filter(os.path.isfile, globs_matches)
files = itertools.chain(
self.manifest_files.get(package, []),
glob_files,
)
return self.exclude_data_files(package, src_dir, files)
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
files = list(files)
patterns = self._get_platform_patterns(
self.exclude_package_data,
package,
src_dir,
)
match_groups = (
fnmatch.filter(files, pattern)
for pattern in patterns
)
# flatten the groups of matches into an iterable of matches
matches = itertools.chain.from_iterable(match_groups)
bad = set(matches)
keepers = (
fn
for fn in files
if fn not in bad
)
# ditch dupes
return list(_unique_everseen(keepers))
def get_songs():
matches = []
num = 0
for root, dirnames, filenames in walk(folder_to_save_data):
for filename in fnmatch.filter(filenames, '*.mp3'):
filename = join(root, filename).replace(
folder_to_save_data, '')
filename = filename.replace('.mp3', '')
if filename[0] == "/":
filename = filename[1:]
songname = filename
if songname[-12:-11] == "-":
songname = songname[:-12]
songname = re.sub(r"[\(\[].*?[\)\]]", "", songname).strip()
num += 1
matches.append({'file': filename, 'name': songname, 'id': num})
return matches
def get_files(directory, pattern, recursive=True):
""" Return the full path to all files in directory matching the specified
pattern.
Arguments:
directory (str): Directory path in which to look
pattern (str): A glob pattern for filenames
recursive (bool): Searches recursively if True
Returns:
A list of matching file paths
"""
# This yields an iterator which really speeds up looking through large, flat directories
if recursive is False:
it = glob.iglob(os.path.join(directory, pattern))
return it
# If we want to recurse, use os.walk instead
matches = list()
for root, dirnames, filenames in os.walk(directory):
matches.extend([os.path.join(root, ss) for ss in
fnmatch.filter(filenames, pattern)])
return matches
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
globs = (self.exclude_package_data.get('', [])
+ self.exclude_package_data.get(package, []))
bad = []
for pattern in globs:
bad.extend(
fnmatch.filter(
files, os.path.join(src_dir, convert_path(pattern))
)
)
bad = dict.fromkeys(bad)
seen = {}
return [
f for f in files if f not in bad
and f not in seen and seen.setdefault(f, 1) # ditch dupes
]
def get_checkpoints_from_s3_path(path):
import boto3
s3_resource = boto3.resource('s3')
bucket_name, key_name = split_s3_bucket_key(path)
bucket = s3_resource.Bucket(bucket_name)
all_objects = list(bucket.objects.filter(Prefix=key_name))
all_keys = [o.key for o in all_objects]
keys = fnmatch.filter(all_keys, S3_KEY_PATTERN)
checkpoints = []
for f in keys:
try:
file_path = os.path.join(bucket_name, f)
checkpoints.append(parse_checkpoint_s3_path(file_path))
except ValueError:
continue
return sorted(checkpoints, key=lambda cp: cp.start)
def find_data_files(self, package, src_dir):
"""Return filenames for package's data files in 'src_dir'"""
patterns = self._get_platform_patterns(
self.package_data,
package,
src_dir,
)
globs_expanded = map(glob, patterns)
# flatten the expanded globs into an iterable of matches
globs_matches = itertools.chain.from_iterable(globs_expanded)
glob_files = filter(os.path.isfile, globs_matches)
files = itertools.chain(
self.manifest_files.get(package, []),
glob_files,
)
return self.exclude_data_files(package, src_dir, files)
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
files = list(files)
patterns = self._get_platform_patterns(
self.exclude_package_data,
package,
src_dir,
)
match_groups = (
fnmatch.filter(files, pattern)
for pattern in patterns
)
# flatten the groups of matches into an iterable of matches
matches = itertools.chain.from_iterable(match_groups)
bad = set(matches)
keepers = (
fn
for fn in files
if fn not in bad
)
# ditch dupes
return list(_unique_everseen(keepers))
def find_data_files(self, package, src_dir):
"""Return filenames for package's data files in 'src_dir'"""
patterns = self._get_platform_patterns(
self.package_data,
package,
src_dir,
)
globs_expanded = map(glob, patterns)
# flatten the expanded globs into an iterable of matches
globs_matches = itertools.chain.from_iterable(globs_expanded)
glob_files = filter(os.path.isfile, globs_matches)
files = itertools.chain(
self.manifest_files.get(package, []),
glob_files,
)
return self.exclude_data_files(package, src_dir, files)
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
files = list(files)
patterns = self._get_platform_patterns(
self.exclude_package_data,
package,
src_dir,
)
match_groups = (
fnmatch.filter(files, pattern)
for pattern in patterns
)
# flatten the groups of matches into an iterable of matches
matches = itertools.chain.from_iterable(match_groups)
bad = set(matches)
keepers = (
fn
for fn in files
if fn not in bad
)
# ditch dupes
return list(_unique_everseen(keepers))
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
globs = (self.exclude_package_data.get('', [])
+ self.exclude_package_data.get(package, []))
bad = []
for pattern in globs:
bad.extend(
fnmatch.filter(
files, os.path.join(src_dir, convert_path(pattern))
)
)
bad = dict.fromkeys(bad)
seen = {}
return [
f for f in files if f not in bad
and f not in seen and seen.setdefault(f,1) # ditch dupes
]
def run_per_file(config, ignore_paths=None, path=None, config_dir=None):
ignore_paths = ignore_paths or []
path = path or os.getcwd()
cmd = run_config(config, config_dir)
print(cmd)
run_cmds = []
patterns = PATTERNS.get(config.get('language'))
paths = all_filenames_in_dir(path=path, ignore_paths=ignore_paths)
for pattern in patterns:
for filepath in fnmatch.filter(paths, pattern):
run_cmds.append(cmd + [filepath])
pool = Pool()
def result(run_cmd):
_, out = run_command(run_cmd)
return run_cmd[-1], out
output = pool.map(result, run_cmds)
return output
def ignore_patterns(*patterns):
"""Function that can be used as copytree() ignore parameter.
Patterns is a sequence of glob-style patterns
that are used to exclude files"""
def _ignore_patterns(path, names):
ignored_names = []
for pattern in patterns:
ignored_names.extend(fnmatch.filter(names, pattern))
return set(ignored_names)
return _ignore_patterns
def glob1(dirname, pattern):
if not dirname:
if isinstance(pattern, binary_type):
dirname = os.curdir.encode('ASCII')
else:
dirname = os.curdir
try:
names = os.listdir(dirname)
except OSError:
return []
return fnmatch.filter(names, pattern)
def reimport(*paths):
for p in paths:
if os.path.isfile(p):
print('Reimporting file: ' + p)
_reimport(p)
elif os.path.isdir(p):
print('Reimporting dir: ' + p)
for dir, _, files in os.walk(p):
for f in fnmatch.filter(files, '*.go'):
_reimport(dir + '/' + f)
else:
for f in glob.glob(p):
print('Reimporinting file: ' + f)
_reimport(f)
