Mercurial > repos > shellac > sam_consensus_v3

comparison env/lib/python3.9/site-packages/setuptools/glob.py @ 0:4f3585e2f14b draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author shellac
date Mon, 22 Mar 2021 18:12:50 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:4f3585e2f14b
1 """
2 Filename globbing utility. Mostly a copy of `glob` from Python 3.5.
3
4 Changes include:
5 * `yield from` and PEP3102 `*` removed.
6 * Hidden files are not ignored.
7 """
8
9 import os
10 import re
11 import fnmatch
12
13 __all__ = ["glob", "iglob", "escape"]
14
15
16 def glob(pathname, recursive=False):
17 """Return a list of paths matching a pathname pattern.
18
19 The pattern may contain simple shell-style wildcards a la
20 fnmatch. However, unlike fnmatch, filenames starting with a
21 dot are special cases that are not matched by '*' and '?'
22 patterns.
23
24 If recursive is true, the pattern '**' will match any files and
25 zero or more directories and subdirectories.
26 """
27 return list(iglob(pathname, recursive=recursive))
28
29
30 def iglob(pathname, recursive=False):
31 """Return an iterator which yields the paths matching a pathname pattern.
32
33 The pattern may contain simple shell-style wildcards a la
34 fnmatch. However, unlike fnmatch, filenames starting with a
35 dot are special cases that are not matched by '*' and '?'
36 patterns.
37
38 If recursive is true, the pattern '**' will match any files and
39 zero or more directories and subdirectories.
40 """
41 it = _iglob(pathname, recursive)
42 if recursive and _isrecursive(pathname):
43 s = next(it) # skip empty string
44 assert not s
45 return it
46
47
48 def _iglob(pathname, recursive):
49 dirname, basename = os.path.split(pathname)
50 glob_in_dir = glob2 if recursive and _isrecursive(basename) else glob1
51
52 if not has_magic(pathname):
53 if basename:
54 if os.path.lexists(pathname):
55 yield pathname
56 else:
57 # Patterns ending with a slash should match only directories
58 if os.path.isdir(dirname):
59 yield pathname
60 return
61
62 if not dirname:
63 yield from glob_in_dir(dirname, basename)
64 return
65 # `os.path.split()` returns the argument itself as a dirname if it is a
66 # drive or UNC path. Prevent an infinite recursion if a drive or UNC path
67 # contains magic characters (i.e. r'\\?\C:').
68 if dirname != pathname and has_magic(dirname):
69 dirs = _iglob(dirname, recursive)
70 else:
71 dirs = [dirname]
72 if not has_magic(basename):
73 glob_in_dir = glob0
74 for dirname in dirs:
75 for name in glob_in_dir(dirname, basename):
76 yield os.path.join(dirname, name)
77
78
79 # These 2 helper functions non-recursively glob inside a literal directory.
80 # They return a list of basenames. `glob1` accepts a pattern while `glob0`
81 # takes a literal basename (so it only has to check for its existence).
82
83
84 def glob1(dirname, pattern):
85 if not dirname:
86 if isinstance(pattern, bytes):
87 dirname = os.curdir.encode('ASCII')
88 else:
89 dirname = os.curdir
90 try:
91 names = os.listdir(dirname)
92 except OSError:
93 return []
94 return fnmatch.filter(names, pattern)
95
96
97 def glob0(dirname, basename):
98 if not basename:
99 # `os.path.split()` returns an empty basename for paths ending with a
100 # directory separator. 'q*x/' should match only directories.
101 if os.path.isdir(dirname):
102 return [basename]
103 else:
104 if os.path.lexists(os.path.join(dirname, basename)):
105 return [basename]
106 return []
107
108
109 # This helper function recursively yields relative pathnames inside a literal
110 # directory.
111
112
113 def glob2(dirname, pattern):
114 assert _isrecursive(pattern)
115 yield pattern[:0]
116 for x in _rlistdir(dirname):
117 yield x
118
119
120 # Recursively yields relative pathnames inside a literal directory.
121 def _rlistdir(dirname):
122 if not dirname:
123 if isinstance(dirname, bytes):
124 dirname = os.curdir.encode('ASCII')
125 else:
126 dirname = os.curdir
127 try:
128 names = os.listdir(dirname)
129 except os.error:
130 return
131 for x in names:
132 yield x
133 path = os.path.join(dirname, x) if dirname else x
134 for y in _rlistdir(path):
135 yield os.path.join(x, y)
136
137
138 magic_check = re.compile('([*?[])')
139 magic_check_bytes = re.compile(b'([*?[])')
140
141
142 def has_magic(s):
143 if isinstance(s, bytes):
144 match = magic_check_bytes.search(s)
145 else:
146 match = magic_check.search(s)
147 return match is not None
148
149
150 def _isrecursive(pattern):
151 if isinstance(pattern, bytes):
152 return pattern == b'**'
153 else:
154 return pattern == '**'
155
156
157 def escape(pathname):
158 """Escape all special characters.
159 """
160 # Escaping is done by wrapping any of "*?[" between square brackets.
161 # Metacharacters do not work in the drive part and shouldn't be escaped.
162 drive, pathname = os.path.splitdrive(pathname)
163 if isinstance(pathname, bytes):
164 pathname = magic_check_bytes.sub(br'[\1]', pathname)
165 else:
166 pathname = magic_check.sub(r'[\1]', pathname)
167 return drive + pathname