semeru/code-code-MethodGeneration · Datasets at Hugging Face

signature stringlengths 8 3.44k	body stringlengths 0 1.41M	docstring stringlengths 1 122k	id stringlengths 5 17
@classmethod<EOL><INDENT>def setup_fs(cls):<DEDENT>	cls.mktemp('<STR_LIT>')<EOL>cls.mktemp('<STR_LIT:a>', '<STR_LIT:b>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.can_symlink = can_symlink()<EOL>	Setup file system.	f9541:c4:m0
def check_escape(self, arg, expected, raw=False):	if raw:<EOL><INDENT>self.assertEqual(glob.raw_escape(arg), expected)<EOL>self.assertEqual(glob.raw_escape(os.fsencode(arg)), os.fsencode(expected))<EOL><DEDENT>else:<EOL><INDENT>self.assertEqual(glob.escape(arg), expected)<EOL>self.assertEqual(glob.escape(os.fsencode(arg)), os.fsencode(expected))<EOL><DEDENT>	Verify escapes.	f9541:c5:m0
def globjoin(self, *parts):	sep = os.fsencode(self.globsep) if isinstance(parts[<NUM_LIT:0>], bytes) else self.globsep<EOL>return sep.join(list(parts))<EOL>	Joins glob path.	f9541:c6:m0
def setUp(self):	if os.sep == '<STR_LIT:/>':<EOL><INDENT>self.globsep = os.sep<EOL><DEDENT>else:<EOL><INDENT>self.globsep = r'<STR_LIT:\\>'<EOL><DEDENT>	Setup.	f9541:c6:m1
def platform():	return _PLATFORM<EOL>	Get platform.	f9542:m0
def is_case_sensitive():	return CASE_FS<EOL>	Check if case sensitive.	f9542:m1
def to_tuple(values):	return (values,) if isinstance(values, (str, bytes)) else tuple(values)<EOL>	Combine values.	f9542:m2
def norm_slash(name):	if isinstance(name, str):<EOL><INDENT>return name.replace('<STR_LIT:/>', "<STR_LIT:\\>") if not is_case_sensitive() else name<EOL><DEDENT>else:<EOL><INDENT>return name.replace(b'<STR_LIT:/>', b"<STR_LIT:\\>") if not is_case_sensitive() else name<EOL><DEDENT>	Normalize path slashes.	f9542:m3
def norm_pattern(pattern, normalize, is_raw_chars):	is_bytes = isinstance(pattern, bytes)<EOL>if not normalize and not is_raw_chars:<EOL><INDENT>return pattern<EOL><DEDENT>def norm_char(token):<EOL><INDENT>"""<STR_LIT>"""<EOL>if normalize and token in ('<STR_LIT:/>', b'<STR_LIT:/>'):<EOL><INDENT>token = br'<STR_LIT:\\>' if is_bytes else r'<STR_LIT:\\>'<EOL><DEDENT>return token<EOL><DEDENT>def norm(m):<EOL><INDENT>"""<STR_LIT>"""<EOL>if m.group(<NUM_LIT:1>):<EOL><INDENT>char = m.group(<NUM_LIT:1>)<EOL>if normalize:<EOL><INDENT>char = br'<STR_LIT>' if is_bytes else r'<STR_LIT>' if len(char) > <NUM_LIT:1> else norm_char(char)<EOL><DEDENT><DEDENT>elif m.group(<NUM_LIT:2>):<EOL><INDENT>char = norm_char(BACK_SLASH_TRANSLATION[m.group(<NUM_LIT:2>)] if is_raw_chars else m.group(<NUM_LIT:2>))<EOL><DEDENT>elif is_raw_chars and m.group(<NUM_LIT:4>):<EOL><INDENT>char = norm_char(bytes([int(m.group(<NUM_LIT:4>), <NUM_LIT:8>) & <NUM_LIT>]) if is_bytes else chr(int(m.group(<NUM_LIT:4>), <NUM_LIT:8>)))<EOL><DEDENT>elif is_raw_chars and m.group(<NUM_LIT:3>):<EOL><INDENT>char = norm_char(bytes([int(m.group(<NUM_LIT:3>)[<NUM_LIT:2>:], <NUM_LIT:16>)]) if is_bytes else chr(int(m.group(<NUM_LIT:3>)[<NUM_LIT:2>:], <NUM_LIT:16>)))<EOL><DEDENT>elif is_raw_chars and not is_bytes and m.group(<NUM_LIT:5>):<EOL><INDENT>char = norm_char(unicodedata.lookup(m.group(<NUM_LIT:5>)[<NUM_LIT:3>:-<NUM_LIT:1>]))<EOL><DEDENT>elif not is_raw_chars:<EOL><INDENT>char = m.group(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>value = m.group(<NUM_LIT:5>) if is_bytes else m.group(<NUM_LIT:6>)<EOL>pos = m.start(<NUM_LIT:5>) if is_bytes else m.start(<NUM_LIT:6>)<EOL>raise SyntaxError("<STR_LIT>" % (value, pos))<EOL><DEDENT>return char<EOL><DEDENT>return (RE_BNORM if is_bytes else RE_NORM).sub(norm, pattern)<EOL>	r""" Normalize pattern. - For windows systems we want to normalize slashes to \. - If raw string chars is enabled, we want to also convert encoded string chars to literal characters. - If `normalize` is enabled, take care to convert \/ to \\\\.	f9542:m4
def is_hidden(path):	hidden = False<EOL>f = os.path.basename(path)<EOL>if f[:<NUM_LIT:1>] in ('<STR_LIT:.>', b'<STR_LIT:.>'):<EOL><INDENT>hidden = True<EOL><DEDENT>elif _PLATFORM == '<STR_LIT>':<EOL><INDENT>FILE_ATTRIBUTE_HIDDEN = <NUM_LIT><EOL>if PY35:<EOL><INDENT>results = os.lstat(path)<EOL>hidden = bool(results.st_file_attributes & FILE_ATTRIBUTE_HIDDEN)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(path, bytes):<EOL><INDENT>attrs = ctypes.windll.kernel32.GetFileAttributesA(path)<EOL><DEDENT>else:<EOL><INDENT>attrs = ctypes.windll.kernel32.GetFileAttributesW(path)<EOL><DEDENT>hidden = attrs != -<NUM_LIT:1> and attrs & FILE_ATTRIBUTE_HIDDEN<EOL><DEDENT><DEDENT>elif _PLATFORM == "<STR_LIT>": <EOL><INDENT>results = os.lstat(path)<EOL>hidden = bool(results.st_flags & stat.UF_HIDDEN)<EOL><DEDENT>return hidden<EOL>	Check if file is hidden.	f9542:m5
def deprecated(message, stacklevel=<NUM_LIT:2>):	def _decorator(func):<EOL><INDENT>@wraps(func)<EOL>def _func(args, kwargs):<EOL><INDENT>warnings.warn(<EOL>"<STR_LIT>".format(func.__name__, message),<EOL>category=DeprecationWarning,<EOL>stacklevel=stacklevel<EOL>)<EOL>return func(args, **kwargs)<EOL><DEDENT>return _func<EOL><DEDENT>return _decorator<EOL>	Raise a `DeprecationWarning` when wrapped function/method is called. Borrowed from https://stackoverflow.com/a/48632082/866026	f9542:m6
def __init__(self, string):	self._string = string<EOL>self._index = <NUM_LIT:0><EOL>	Initialize.	f9542:c0:m0
def __iter__(self):	return self<EOL>	Iterate.	f9542:c0:m1
def __next__(self):	return self.iternext()<EOL>	Python 3 iterator compatible next.	f9542:c0:m2
def match(self, pattern):	m = pattern.match(self._string, self._index)<EOL>if m:<EOL><INDENT>self._index = m.end()<EOL><DEDENT>return m<EOL>	Perform regex match at index.	f9542:c0:m3
@property<EOL><INDENT>def index(self):<DEDENT>	return self._index<EOL>	Get current index.	f9542:c0:m4
def previous(self):	return self._string[self._index - <NUM_LIT:1>]<EOL>	Get previous char.	f9542:c0:m5
def advance(self, count):	self._index += count<EOL>	Advanced the index.	f9542:c0:m6
def rewind(self, count):	if count > self._index: <EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>self._index -= count<EOL>	Rewind index.	f9542:c0:m7
def iternext(self):	try:<EOL><INDENT>char = self._string[self._index]<EOL>self._index += <NUM_LIT:1><EOL><DEDENT>except IndexError: <EOL><INDENT>raise StopIteration<EOL><DEDENT>return char<EOL>	Iterate through characters of the string.	f9542:c0:m8
def __init__(self, **kwargs):	for k, v in kwargs.items():<EOL><INDENT>super(Immutable, self).__setattr__(k, v)<EOL><DEDENT>	Initialize.	f9542:c1:m0
def __setattr__(self, name, value):	raise AttributeError('<STR_LIT>')<EOL>	Prevent mutability.	f9542:c1:m1
def parse_version(ver, pre=False):	m = RE_VER.match(ver)<EOL>major = int(m.group('<STR_LIT>'))<EOL>minor = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>micro = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT:type>'):<EOL><INDENT>release = PRE_REL_MAP[m.group('<STR_LIT:type>')]<EOL>pre = int(m.group('<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>release = "<STR_LIT>"<EOL>pre = <NUM_LIT:0><EOL><DEDENT>dev = m.group('<STR_LIT>') if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT>'):<EOL><INDENT>dev = int(m.group('<STR_LIT>'))<EOL>release = '<STR_LIT>' + release if pre else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>dev = <NUM_LIT:0><EOL><DEDENT>post = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>return Version(major, minor, micro, release, pre, post, dev)<EOL>	Parse version into a comparable Version tuple.	f9543:m0
def __new__(cls, major, minor, micro, release="<STR_LIT>", pre=<NUM_LIT:0>, post=<NUM_LIT:0>, dev=<NUM_LIT:0>):	<EOL>for value in (major, minor, micro, pre, post):<EOL><INDENT>if not (isinstance(value, int) and value >= <NUM_LIT:0>):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>if release not in REL_MAP:<EOL><INDENT>raise ValueError("<STR_LIT>".format(release))<EOL><DEDENT>if "<STR_LIT>" < release < "<STR_LIT>":<EOL><INDENT>if pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>elif release < "<STR_LIT>":<EOL><INDENT>if release > "<STR_LIT>" and pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if pre:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>return super(Version, cls).__new__(cls, major, minor, micro, release, pre, post, dev)<EOL>	Validate version info.	f9543:c0:m0
def _is_pre(self):	return self.pre > <NUM_LIT:0><EOL>	Is prerelease.	f9543:c0:m1
def _is_dev(self):	return bool(self.release < "<STR_LIT>")<EOL>	Is development.	f9543:c0:m2
def _is_post(self):	return self.post > <NUM_LIT:0><EOL>	Is post.	f9543:c0:m3
def _get_dev_status(self):	return DEV_STATUS[self.release]<EOL>	Get development status string.	f9543:c0:m4
def _get_canonical(self):	<EOL>if self.micro == <NUM_LIT:0>:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor)<EOL><DEDENT>else:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor, self.micro)<EOL><DEDENT>if self._is_pre():<EOL><INDENT>ver += '<STR_LIT>'.format(REL_MAP[self.release], self.pre)<EOL><DEDENT>if self._is_post():<EOL><INDENT>ver += "<STR_LIT>".format(self.post)<EOL><DEDENT>if self._is_dev():<EOL><INDENT>ver += "<STR_LIT>".format(self.dev)<EOL><DEDENT>return ver<EOL>	Get the canonical output string.	f9543:c0:m5
def __init__(self, name):	self._module = sys.modules[name]<EOL>self._get_attr = getattr(self._module, '<STR_LIT>', None)<EOL>self._get_dir = getattr(self._module, '<STR_LIT>', None)<EOL>sys.modules[name] = self<EOL>	Acquire `__getattr__` and `__dir__`, but only replace module for versions less than Python 3.7.	f9543:c1:m0
def __dir__(self):	return self._get_dir() if self._get_dir else dir(self._module)<EOL>	Return the overridden `dir` if one was provided, else apply `dir` to the module.	f9543:c1:m1
def __getattr__(self, name):	try:<EOL><INDENT>return getattr(self._module, name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>if self._get_attr:<EOL><INDENT>return self._get_attr(name)<EOL><DEDENT>raise<EOL><DEDENT>	Attempt to retrieve the attribute from the module, and if missing, use the overridden function if present.	f9543:c1:m2
def __getattr__(name):	deprecated = __deprecated__.get(name)<EOL>if deprecated:<EOL><INDENT>warnings.warn(<EOL>"<STR_LIT>".format(name, deprecated[<NUM_LIT:0>]),<EOL>category=DeprecationWarning,<EOL>stacklevel=(<NUM_LIT:3> if PY37 else <NUM_LIT:4>)<EOL>)<EOL>return deprecated[<NUM_LIT:1>]<EOL><DEDENT>raise AttributeError("<STR_LIT>".format(__name__, name))<EOL>	Get attribute.	f9544:m0
def is_negative(pattern, flags):	if flags & MINUSNEGATE:<EOL><INDENT>return flags & NEGATE and pattern[<NUM_LIT:0>:<NUM_LIT:1>] in MINUS_NEGATIVE_SYM<EOL><DEDENT>else:<EOL><INDENT>return flags & NEGATE and pattern[<NUM_LIT:0>:<NUM_LIT:1>] in NEGATIVE_SYM<EOL><DEDENT>	Check if negative pattern.	f9545:m0
def expand_braces(patterns, flags):	if flags & BRACE:<EOL><INDENT>for p in ([patterns] if isinstance(patterns, (str, bytes)) else patterns):<EOL><INDENT>try:<EOL><INDENT>yield from bracex.iexpand(p, keep_escapes=True)<EOL><DEDENT>except Exception: <EOL><INDENT>yield p<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for p in ([patterns] if isinstance(patterns, (str, bytes)) else patterns):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT>	Expand braces.	f9545:m1
def get_case(flags):	if not bool(flags & CASE_FLAGS):<EOL><INDENT>case_sensitive = util.is_case_sensitive()<EOL><DEDENT>elif flags & FORCECASE:<EOL><INDENT>case_sensitive = True<EOL><DEDENT>else:<EOL><INDENT>case_sensitive = False<EOL><DEDENT>return case_sensitive<EOL>	Parse flags for case sensitivity settings.	f9545:m2
def is_unix_style(flags):	return (util.platform() != "<STR_LIT>" or (not bool(flags & REALPATH) and get_case(flags))) and not flags & _FORCEWIN<EOL>	Check if we should use Unix style.	f9545:m3
def translate(patterns, flags):	positive = []<EOL>negative = []<EOL>if isinstance(patterns, (str, bytes)):<EOL><INDENT>patterns = [patterns]<EOL><DEDENT>flags \|= _TRANSLATE<EOL>for pattern in patterns:<EOL><INDENT>for expanded in expand_braces(pattern, flags):<EOL><INDENT>(negative if is_negative(expanded, flags) else positive).append(<EOL>WcParse(expanded, flags & FLAG_MASK).parse()<EOL>)<EOL><DEDENT><DEDENT>if patterns and flags & REALPATH and negative and not positive:<EOL><INDENT>positive.append(_compile(b'<STR_LIT>' if isinstance(patterns[<NUM_LIT:0>], bytes) else '<STR_LIT>', flags))<EOL><DEDENT>return positive, negative<EOL>	Translate patterns.	f9545:m4
def split(patterns, flags):	if flags & SPLIT:<EOL><INDENT>splitted = []<EOL>for pattern in ([patterns] if isinstance(patterns, (str, bytes)) else patterns):<EOL><INDENT>splitted.extend(WcSplit(pattern, flags).split())<EOL><DEDENT>return splitted<EOL><DEDENT>else:<EOL><INDENT>return patterns<EOL><DEDENT>	Split patterns.	f9545:m5
def compile(patterns, flags):	positive = []<EOL>negative = []<EOL>if isinstance(patterns, (str, bytes)):<EOL><INDENT>patterns = [patterns]<EOL><DEDENT>for pattern in patterns:<EOL><INDENT>for expanded in expand_braces(pattern, flags):<EOL><INDENT>(negative if is_negative(expanded, flags) else positive).append(_compile(expanded, flags))<EOL><DEDENT><DEDENT>if patterns and flags & REALPATH and negative and not positive:<EOL><INDENT>positive.append(_compile(b'<STR_LIT>' if isinstance(patterns[<NUM_LIT:0>], bytes) else '<STR_LIT>', flags))<EOL><DEDENT>return WcRegexp(tuple(positive), tuple(negative), flags & REALPATH, flags & PATHNAME, flags & FOLLOW)<EOL>	Compile patterns.	f9545:m6
@functools.lru_cache(maxsize=<NUM_LIT>, typed=True)<EOL>def _compile(pattern, flags):	return re.compile(WcParse(pattern, flags & FLAG_MASK).parse())<EOL>	Compile the pattern to regex.	f9545:m7
def _fs_match(pattern, filename, sep, follow, symlinks):	matched = False<EOL>base = None<EOL>m = pattern.fullmatch(filename)<EOL>if m:<EOL><INDENT>matched = True<EOL>if not follow:<EOL><INDENT>groups = m.groups()<EOL>last = len(groups)<EOL>for i, star in enumerate(m.groups(), <NUM_LIT:1>):<EOL><INDENT>if star:<EOL><INDENT>parts = star.strip(sep).split(sep)<EOL>if base is None:<EOL><INDENT>base = filename[:m.start(i)]<EOL><DEDENT>for part in parts:<EOL><INDENT>base = os.path.join(base, part)<EOL>is_link = symlinks.get(base, None)<EOL>if is_link is not None:<EOL><INDENT>matched = not is_link<EOL><DEDENT>elif i != last or os.path.isdir(base):<EOL><INDENT>is_link = os.path.islink(base)<EOL>symlinks[base] = is_link<EOL>matched = not is_link<EOL><DEDENT>if not matched:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if matched:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return matched<EOL>	Match path against the pattern. Since `globstar` doesn't match symlinks (unless `FOLLOW` is enabled), we must look for symlinks. If we identify a symlink in a `globstar` match, we know this result should not actually match.	f9545:m8
def _match_real(filename, include, exclude, follow, symlinks):	sep = '<STR_LIT:\\>' if util.platform() == "<STR_LIT>" else '<STR_LIT:/>'<EOL>if isinstance(filename, bytes):<EOL><INDENT>sep = os.fsencode(sep)<EOL><DEDENT>if not filename.endswith(sep) and os.path.isdir(filename):<EOL><INDENT>filename += sep<EOL><DEDENT>matched = False<EOL>for pattern in include:<EOL><INDENT>if _fs_match(pattern, filename, sep, follow, symlinks):<EOL><INDENT>matched = True<EOL>break<EOL><DEDENT><DEDENT>if matched:<EOL><INDENT>matched = True<EOL>if exclude:<EOL><INDENT>for pattern in exclude:<EOL><INDENT>if _fs_match(pattern, filename, sep, follow, symlinks):<EOL><INDENT>matched = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return matched<EOL>	Match real filename includes and excludes.	f9545:m9
def _match_pattern(filename, include, exclude, real, path, follow):	if real:<EOL><INDENT>symlinks = {}<EOL>if isinstance(filename, bytes):<EOL><INDENT>curdir = os.fsencode(os.curdir)<EOL>mount = RE_BWIN_MOUNT if util.platform() == "<STR_LIT>" else RE_BMOUNT<EOL><DEDENT>else:<EOL><INDENT>curdir = os.curdir<EOL>mount = RE_WIN_MOUNT if util.platform() == "<STR_LIT>" else RE_MOUNT<EOL><DEDENT>if not mount.match(filename):<EOL><INDENT>exists = os.path.lexists(os.path.join(curdir, filename))<EOL><DEDENT>else:<EOL><INDENT>exists = os.path.lexists(filename)<EOL><DEDENT>if not exists:<EOL><INDENT>return False<EOL><DEDENT>if path:<EOL><INDENT>return _match_real(filename, include, exclude, follow, symlinks)<EOL><DEDENT><DEDENT>matched = False<EOL>for pattern in include:<EOL><INDENT>if pattern.fullmatch(filename):<EOL><INDENT>matched = True<EOL>break<EOL><DEDENT><DEDENT>if not include and exclude:<EOL><INDENT>matched = True<EOL><DEDENT>if matched:<EOL><INDENT>matched = True<EOL>if exclude:<EOL><INDENT>for pattern in exclude:<EOL><INDENT>if not pattern.fullmatch(filename):<EOL><INDENT>matched = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return matched<EOL>	Match includes and excludes.	f9545:m10
def __init__(self, pattern, flags):	self.unix = is_unix_style(flags)<EOL>self.flags = flags<EOL>self.pattern = util.norm_pattern(pattern, not self.unix, flags & RAWCHARS)<EOL>self.globstar = bool(flags & GLOBSTAR)<EOL>if is_negative(self.pattern, flags): <EOL><INDENT>self.pattern = self.pattern[<NUM_LIT:0>:<NUM_LIT:1>]<EOL><DEDENT>if flags & NEGATE:<EOL><INDENT>flags ^= NEGATE<EOL><DEDENT>self.flags = flags<EOL>self.is_bytes = isinstance(pattern, bytes)<EOL>self.extend = bool(flags & EXTMATCH)<EOL>if not self.unix:<EOL><INDENT>self.win_drive_detect = True<EOL>self.bslash_abort = True<EOL>self.sep = '<STR_LIT:\\>'<EOL><DEDENT>else:<EOL><INDENT>self.win_drive_detect = False<EOL>self.bslash_abort = False<EOL>self.sep = '<STR_LIT:/>'<EOL><DEDENT>self.re_magic = RE_MAGIC if not self.is_bytes else RE_BMAGIC<EOL>self.magic = False<EOL>	Initialize.	f9545:c3:m0
def is_magic(self, name):	return self.re_magic.search(name) is not None<EOL>	Check if name contains magic characters.	f9545:c3:m1
def _sequence(self, i):	c = next(i)<EOL>if c == '<STR_LIT:!>':<EOL><INDENT>c = next(i)<EOL><DEDENT>if c in ('<STR_LIT>', '<STR_LIT:->', '<STR_LIT:[>'):<EOL><INDENT>c = next(i)<EOL><DEDENT>while c != '<STR_LIT:]>':<EOL><INDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>raise StopIteration<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>c = next(i)<EOL><DEDENT>	Handle character group.	f9545:c3:m2
def _references(self, i, sequence=False):	value = '<STR_LIT>'<EOL>c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>if sequence and self.bslash_abort:<EOL><INDENT>raise PathNameException<EOL><DEDENT>value = c<EOL><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if sequence:<EOL><INDENT>raise PathNameException<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return value<EOL>	Handle references.	f9545:c3:m3
def parse_extend(self, c, i):	<EOL>success = True<EOL>index = i.index<EOL>list_type = c<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:(>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>while c != '<STR_LIT:)>':<EOL><INDENT>c = next(i)<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>self._references(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>success = False<EOL>c = list_type<EOL>i.rewind(i.index - index)<EOL><DEDENT>return success<EOL>	Parse extended pattern lists.	f9545:c3:m4
def store(self, value, l, dir_only):	if l and value in (b'<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>globstar = value in (b'<STR_LIT>', '<STR_LIT>') and self.globstar<EOL>magic = self.is_magic(value)<EOL>if magic:<EOL><INDENT>value = compile(value, self.flags)<EOL><DEDENT>l.append(WcGlob(value, magic, globstar, dir_only, False))<EOL>	Group patterns by literals and potential magic patterns.	f9545:c3:m5
def split(self):	split_index = []<EOL>parts = []<EOL>start = -<NUM_LIT:1><EOL>pattern = self.pattern.decode('<STR_LIT>') if self.is_bytes else self.pattern<EOL>i = util.StringIter(pattern)<EOL>iter(i)<EOL>if self.win_drive_detect:<EOL><INDENT>m = RE_WIN_PATH.match(pattern)<EOL>if m:<EOL><INDENT>drive = m.group(<NUM_LIT:0>).replace('<STR_LIT>', '<STR_LIT:\\>')<EOL>if self.is_bytes:<EOL><INDENT>drive = drive.encode('<STR_LIT>')<EOL><DEDENT>parts.append(WcGlob(drive, False, False, True, True))<EOL>start = m.end(<NUM_LIT:0>) - <NUM_LIT:1><EOL>i.advance(start + <NUM_LIT:1>)<EOL><DEDENT>elif pattern.startswith('<STR_LIT>'):<EOL><INDENT>parts.append(WcGlob(b'<STR_LIT:\\>' if self.is_bytes else '<STR_LIT:\\>', False, False, True, True))<EOL>start = <NUM_LIT:1><EOL>i.advance(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>elif not self.win_drive_detect and pattern.startswith('<STR_LIT:/>'):<EOL><INDENT>parts.append(WcGlob(b'<STR_LIT:/>' if self.is_bytes else '<STR_LIT:/>', False, False, True, True))<EOL>start = <NUM_LIT:0><EOL>i.advance(<NUM_LIT:1>)<EOL><DEDENT>for c in i:<EOL><INDENT>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>index = i.index<EOL>value = '<STR_LIT>'<EOL>try:<EOL><INDENT>value = self._references(i)<EOL>if self.bslash_abort and value == '<STR_LIT:\\>':<EOL><INDENT>split_index.append((i.index - <NUM_LIT:2>, <NUM_LIT:1>))<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL>if self.bslash_abort:<EOL><INDENT>split_index.append((i.index - <NUM_LIT:1>, <NUM_LIT:0>))<EOL><DEDENT><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>split_index.append((i.index - <NUM_LIT:1>, <NUM_LIT:0>))<EOL><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT>for split, offset in split_index:<EOL><INDENT>if self.is_bytes:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:split].encode('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:split]<EOL><DEDENT>self.store(value, parts, True)<EOL>start = split + offset<EOL><DEDENT>if start < len(pattern):<EOL><INDENT>if self.is_bytes:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:].encode('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:]<EOL><DEDENT>if value:<EOL><INDENT>self.store(value, parts, False)<EOL><DEDENT><DEDENT>if len(pattern) == <NUM_LIT:0>:<EOL><INDENT>parts.append(WcGlob(pattern.encode('<STR_LIT>') if self.is_bytes else pattern, False, False, False, False))<EOL><DEDENT>return parts<EOL>	Start parsing the pattern.	f9545:c3:m6
def __init__(self, pattern, flags):	self.pattern = pattern<EOL>self.is_bytes = isinstance(pattern, bytes)<EOL>self.pathname = bool(flags & PATHNAME)<EOL>self.extend = bool(flags & EXTMATCH)<EOL>self.unix = is_unix_style(flags)<EOL>self.bslash_abort = not self.unix<EOL>	Initialize.	f9545:c4:m0
def _sequence(self, i):	c = next(i)<EOL>if c == '<STR_LIT:!>':<EOL><INDENT>c = next(i)<EOL><DEDENT>if c in ('<STR_LIT>', '<STR_LIT:->', '<STR_LIT:[>'):<EOL><INDENT>c = next(i)<EOL><DEDENT>while c != '<STR_LIT:]>':<EOL><INDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>raise StopIteration<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>raise StopIteration<EOL><DEDENT><DEDENT>c = next(i)<EOL><DEDENT>	Handle character group.	f9545:c4:m1
def _references(self, i, sequence=False):	c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>if sequence and self.bslash_abort:<EOL><INDENT>raise PathNameException<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if sequence and self.pathname:<EOL><INDENT>raise PathNameException<EOL><DEDENT>elif self.pathname:<EOL><INDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>	Handle references.	f9545:c4:m2
def parse_extend(self, c, i):	<EOL>success = True<EOL>index = i.index<EOL>list_type = c<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:(>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>while c != '<STR_LIT:)>':<EOL><INDENT>c = next(i)<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>self._references(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>success = False<EOL>c = list_type<EOL>i.rewind(i.index - index)<EOL><DEDENT>return success<EOL>	Parse extended pattern lists.	f9545:c4:m3
def split(self):	split_index = []<EOL>parts = []<EOL>pattern = self.pattern.decode('<STR_LIT>') if self.is_bytes else self.pattern<EOL>i = util.StringIter(pattern)<EOL>iter(i)<EOL>for c in i:<EOL><INDENT>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:\|>':<EOL><INDENT>split_index.append(i.index - <NUM_LIT:1>)<EOL><DEDENT>elif c == '<STR_LIT:\\>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._references(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT>start = -<NUM_LIT:1><EOL>for split in split_index:<EOL><INDENT>p = pattern[start + <NUM_LIT:1>:split]<EOL>parts.append(p.encode('<STR_LIT>') if self.is_bytes else p)<EOL>start = split<EOL><DEDENT>if start < len(pattern):<EOL><INDENT>p = pattern[start + <NUM_LIT:1>:]<EOL>parts.append(p.encode('<STR_LIT>') if self.is_bytes else p)<EOL><DEDENT>return tuple(parts)<EOL>	Start parsing the pattern.	f9545:c4:m4
def __init__(self, pattern, flags=<NUM_LIT:0>):	self.pattern = pattern<EOL>self.braces = bool(flags & BRACE)<EOL>self.is_bytes = isinstance(pattern, bytes)<EOL>self.pathname = bool(flags & PATHNAME)<EOL>self.raw_chars = bool(flags & RAWCHARS)<EOL>self.globstar = self.pathname and bool(flags & GLOBSTAR)<EOL>self.realpath = bool(flags & REALPATH) and self.pathname<EOL>self.globstar_capture = self.realpath and not bool(flags & _TRANSLATE)<EOL>self.dot = bool(flags & DOTMATCH)<EOL>self.extend = bool(flags & EXTMATCH)<EOL>self.case_sensitive = get_case(flags)<EOL>self.in_list = False<EOL>self.flags = flags<EOL>self.inv_ext = <NUM_LIT:0><EOL>self.unix = is_unix_style(self.flags)<EOL>if not self.unix:<EOL><INDENT>self.win_drive_detect = self.pathname<EOL>self.char_avoid = (ord('<STR_LIT:\\>'), ord('<STR_LIT:/>'), ord('<STR_LIT:.>'))<EOL>self.bslash_abort = self.pathname<EOL>self.sep = '<STR_LIT:\\>'<EOL><DEDENT>else:<EOL><INDENT>self.win_drive_detect = False<EOL>self.char_avoid = (ord('<STR_LIT:/>'), ord('<STR_LIT:.>'))<EOL>self.bslash_abort = False<EOL>self.sep = '<STR_LIT:/>'<EOL><DEDENT>sep = {"<STR_LIT>": re.escape(self.sep)}<EOL>self.path_eop = _PATH_EOP % sep<EOL>self.no_dir = _NO_DIR % sep<EOL>self.seq_path = _PATH_NO_SLASH % sep<EOL>self.seq_path_dot = _PATH_NO_SLASH_DOT % sep<EOL>self.path_star = _PATH_STAR % sep<EOL>self.path_star_dot1 = _PATH_STAR_DOTMATCH % sep<EOL>self.path_star_dot2 = _PATH_STAR_NO_DOTMATCH % sep<EOL>self.path_gstar_dot1 = _PATH_GSTAR_DOTMATCH % sep<EOL>self.path_gstar_dot2 = _PATH_GSTAR_NO_DOTMATCH % sep<EOL>	Initialize.	f9545:c5:m0
def set_after_start(self):	self.after_start = True<EOL>self.dir_start = False<EOL>	Set tracker for character after the start of a directory.	f9545:c5:m1
def set_start_dir(self):	self.dir_start = True<EOL>self.after_start = False<EOL>	Set directory start.	f9545:c5:m2
def reset_dir_track(self):	self.dir_start = False<EOL>self.after_start = False<EOL>	Reset directory tracker.	f9545:c5:m3
def update_dir_state(self):	if self.dir_start and not self.after_start:<EOL><INDENT>self.set_after_start()<EOL><DEDENT>elif not self.dir_start and self.after_start:<EOL><INDENT>self.reset_dir_track()<EOL><DEDENT>	Update the directory state. If we are at the directory start, update to after start state (the character right after). If at after start, reset state.	f9545:c5:m4
def _restrict_extended_slash(self):	return self.seq_path if self.pathname else '<STR_LIT>'<EOL>	Restrict extended slash.	f9545:c5:m5
def _restrict_sequence(self):	if self.pathname:<EOL><INDENT>value = self.seq_path_dot if self.after_start and not self.dot else self.seq_path<EOL>if self.after_start:<EOL><INDENT>value = self.no_dir + value<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = _NO_DOT if self.after_start and not self.dot else "<STR_LIT>"<EOL><DEDENT>self.reset_dir_track()<EOL>return value<EOL>	Restrict sequence.	f9545:c5:m6
def _sequence_range_check(self, result, last):	removed = False<EOL>first = result[-<NUM_LIT:2>]<EOL>v1 = ord(first[<NUM_LIT:1>:<NUM_LIT:2>] if len(first) > <NUM_LIT:1> else first)<EOL>v2 = ord(last[<NUM_LIT:1>:<NUM_LIT:2>] if len(last) > <NUM_LIT:1> else last)<EOL>if v2 < v1:<EOL><INDENT>result.pop()<EOL>result.pop()<EOL>removed = True<EOL><DEDENT>else:<EOL><INDENT>result.append(last)<EOL><DEDENT>return removed<EOL>	If range backwards, remove it. A bad range will cause the regular expression to fail, so we need to remove it, but return that we removed it so the caller can know the sequence wasn't empty. Caller will have to craft a sequence that makes sense if empty at the end with either an impossible sequence for inclusive sequences or a sequence that matches everything for an exclusive sequence.	f9545:c5:m7
def _handle_posix(self, i, result, end_range):	last_posix = False<EOL>m = i.match(RE_POSIX)<EOL>if m:<EOL><INDENT>last_posix = True<EOL>if end_range and i.index - <NUM_LIT:1> >= end_range:<EOL><INDENT>result[-<NUM_LIT:1>] = '<STR_LIT:\\>' + result[-<NUM_LIT:1>]<EOL><DEDENT>posix_type = uniprops.POSIX_BYTES if self.is_bytes else uniprops.POSIX<EOL>result.append(uniprops.get_posix_property(m.group(<NUM_LIT:1>), posix_type))<EOL><DEDENT>return last_posix<EOL>	Handle posix classes.	f9545:c5:m8
def _sequence(self, i):	result = ['<STR_LIT:[>']<EOL>end_range = <NUM_LIT:0><EOL>escape_hyphen = -<NUM_LIT:1><EOL>removed = False<EOL>last_posix = False<EOL>c = next(i)<EOL>if c in ('<STR_LIT:!>', '<STR_LIT>'):<EOL><INDENT>result.append('<STR_LIT>')<EOL>c = next(i)<EOL><DEDENT>if c == '<STR_LIT:[>':<EOL><INDENT>last_posix = self._handle_posix(i, result, <NUM_LIT:0>)<EOL>if not last_posix:<EOL><INDENT>result.append(re.escape(c))<EOL><DEDENT>c = next(i)<EOL><DEDENT>elif c in ('<STR_LIT:->', '<STR_LIT:]>'):<EOL><INDENT>result.append(re.escape(c))<EOL>c = next(i)<EOL><DEDENT>while c != '<STR_LIT:]>':<EOL><INDENT>if c == '<STR_LIT:->':<EOL><INDENT>if last_posix:<EOL><INDENT>result.append('<STR_LIT:\\>' + c)<EOL>last_posix = False<EOL><DEDENT>elif i.index - <NUM_LIT:1> > escape_hyphen:<EOL><INDENT>result.append(c)<EOL>escape_hyphen = i.index + <NUM_LIT:1><EOL>end_range = i.index<EOL><DEDENT>elif end_range and i.index - <NUM_LIT:1> >= end_range:<EOL><INDENT>if self._sequence_range_check(result, '<STR_LIT:\\>' + c):<EOL><INDENT>removed = True<EOL><DEDENT>end_range = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>result.append('<STR_LIT:\\>' + c)<EOL><DEDENT>c = next(i)<EOL>continue<EOL><DEDENT>last_posix = False<EOL>if c == '<STR_LIT:[>':<EOL><INDENT>last_posix = self._handle_posix(i, result, end_range)<EOL>if last_posix:<EOL><INDENT>c = next(i)<EOL>continue<EOL><DEDENT><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>value = self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>raise StopIteration<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL>value = r'<STR_LIT:\\>'<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>raise StopIteration<EOL><DEDENT>value = c<EOL><DEDENT>elif c in SET_OPERATORS:<EOL><INDENT>value = '<STR_LIT:\\>' + c<EOL><DEDENT>else:<EOL><INDENT>value = c<EOL><DEDENT>if end_range and i.index - <NUM_LIT:1> >= end_range:<EOL><INDENT>if self._sequence_range_check(result, value):<EOL><INDENT>removed = True<EOL><DEDENT>end_range = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>result.append(value)<EOL><DEDENT>c = next(i)<EOL><DEDENT>result.append('<STR_LIT:]>')<EOL>if removed:<EOL><INDENT>value = "<STR_LIT>".join(result)<EOL>if value == '<STR_LIT>':<EOL><INDENT>result = ['<STR_LIT>' % ('<STR_LIT>' if self.is_bytes else uniprops.UNICODE_RANGE)]<EOL><DEDENT>elif value == '<STR_LIT>':<EOL><INDENT>result = ['<STR_LIT>' % ('<STR_LIT>' if self.is_bytes else uniprops.UNICODE_RANGE)]<EOL><DEDENT>else:<EOL><INDENT>result = [value]<EOL><DEDENT><DEDENT>if self.pathname or self.after_start:<EOL><INDENT>return self._restrict_sequence() + '<STR_LIT>'.join(result)<EOL><DEDENT>return '<STR_LIT>'.join(result)<EOL>	Handle character group.	f9545:c5:m9
def _references(self, i, sequence=False):	value = '<STR_LIT>'<EOL>c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>if sequence and self.bslash_abort:<EOL><INDENT>raise PathNameException<EOL><DEDENT>value = r'<STR_LIT:\\>'<EOL>if self.bslash_abort:<EOL><INDENT>if not self.in_list:<EOL><INDENT>value = self.get_path_sep() + _ONE_OR_MORE<EOL>self.set_start_dir()<EOL><DEDENT>else:<EOL><INDENT>value = self._restrict_extended_slash() + value<EOL><DEDENT><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if sequence and self.pathname:<EOL><INDENT>raise PathNameException<EOL><DEDENT>if self.pathname:<EOL><INDENT>value = r'<STR_LIT:\\>'<EOL>if self.in_list:<EOL><INDENT>value = self._restrict_extended_slash() + value<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>value = re.escape(c)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = re.escape(c)<EOL>if c == '<STR_LIT:.>' and self.after_start and self.in_list:<EOL><INDENT>self.allow_special_dir = True<EOL>self.reset_dir_track()<EOL><DEDENT><DEDENT>return value<EOL>	Handle references.	f9545:c5:m10
def _handle_star(self, i, current):	if self.pathname:<EOL><INDENT>if self.after_start and not self.dot:<EOL><INDENT>star = self.path_star_dot2<EOL>globstar = self.path_gstar_dot2<EOL><DEDENT>elif self.after_start:<EOL><INDENT>star = self.path_star_dot1<EOL>globstar = self.path_gstar_dot1<EOL><DEDENT>else:<EOL><INDENT>star = self.path_star<EOL>globstar = self.path_gstar_dot1<EOL><DEDENT>if self.globstar_capture:<EOL><INDENT>globstar = '<STR_LIT>'.format(globstar)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.after_start and not self.dot:<EOL><INDENT>star = _NO_DOT + _STAR<EOL><DEDENT>else:<EOL><INDENT>star = _STAR<EOL><DEDENT>globstar = '<STR_LIT>'<EOL><DEDENT>value = star<EOL>if self.after_start and self.globstar and not self.in_list:<EOL><INDENT>skip = False<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:>':<EOL><INDENT>i.rewind(<NUM_LIT:1>)<EOL>raise StopIteration<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>skip = True<EOL><DEDENT>if not skip:<EOL><INDENT>try:<EOL><INDENT>index = i.index<EOL>c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>value = globstar<EOL><DEDENT>except StopIteration:<EOL><INDENT>if self.sep == '<STR_LIT:\\>':<EOL><INDENT>value = globstar<EOL><DEDENT><DEDENT><DEDENT>elif c == '<STR_LIT:/>' and not self.bslash_abort:<EOL><INDENT>value = globstar<EOL><DEDENT>if value != globstar:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>value = globstar<EOL><DEDENT><DEDENT><DEDENT>if self.after_start and value != globstar:<EOL><INDENT>value = _NEED_CHAR + value<EOL>try:<EOL><INDENT>c = next(i)<EOL>while c == '<STR_LIT:>':<EOL><INDENT>c = next(i)<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>self.reset_dir_track()<EOL>if value == globstar:<EOL><INDENT>sep = _GLOBSTAR_DIV % self.get_path_sep()<EOL>if current[-<NUM_LIT:1>] != sep:<EOL><INDENT>if current[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>current[-<NUM_LIT:1>] = value<EOL><DEDENT>else:<EOL><INDENT>current[-<NUM_LIT:1>] = _NEED_SEP % self.get_path_sep()<EOL>current.append(value)<EOL><DEDENT>self.consume_path_sep(i)<EOL>current.append(sep)<EOL><DEDENT>self.set_start_dir()<EOL><DEDENT>else:<EOL><INDENT>current.append(value)<EOL><DEDENT>	Handle star.	f9545:c5:m11
def clean_up_inverse(self, current):	if not self.inv_ext:<EOL><INDENT>return<EOL><DEDENT>index = len(current) - <NUM_LIT:1><EOL>while index >= <NUM_LIT:0>:<EOL><INDENT>if isinstance(current[index], InvPlaceholder):<EOL><INDENT>content = current[index + <NUM_LIT:1>:]<EOL>content.append(_EOP if not self.pathname else self.path_eop)<EOL>current[index] = ('<STR_LIT>'.join(content)) + (_EXCLA_GROUP_CLOSE % str(current[index]))<EOL><DEDENT>index -= <NUM_LIT:1><EOL><DEDENT>self.inv_ext = <NUM_LIT:0><EOL>	Clean up current. Python doesn't have variable lookbehinds, so we have to do negative lookaheads. !(...) when converted to regular expression is atomic, so once it matches, that's it. So we use the pattern `(?:(?!(?:stuff\|to\|exclude)<x>))[^/]?)` where <x> is everything that comes after the negative group. `!(this\|that)other` --> `(?:(?!(?:this\|that)other))[^/]?)`. We have to update the list before \| in nested cases: (!(...)\|stuff). Before we close a parent `extmatch`: `(!(...))`. And of course on path separators (when path mode is on): `!(...)/stuff`. Lastly we make sure all is accounted for when finishing the pattern at the end. If there is nothing to store, we store `$`: `(?:(?!(?:this\|that)$))[^/]*?)`.	f9545:c5:m12
def parse_extend(self, c, i, current, reset_dot=False):	<EOL>temp_dir_start = self.dir_start<EOL>temp_after_start = self.after_start<EOL>temp_in_list = self.in_list<EOL>temp_inv_ext = self.inv_ext<EOL>self.in_list = True<EOL>if reset_dot:<EOL><INDENT>self.allow_special_dir = False<EOL><DEDENT>success = True<EOL>index = i.index<EOL>list_type = c<EOL>extended = []<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:(>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>while c != '<STR_LIT:)>':<EOL><INDENT>c = next(i)<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i, extended):<EOL><INDENT>pass<EOL><DEDENT>elif c == '<STR_LIT:>':<EOL><INDENT>self._handle_star(i, extended)<EOL><DEDENT>elif c == '<STR_LIT:.>' and self.after_start:<EOL><INDENT>extended.append(re.escape(c))<EOL>self.allow_special_dir = True<EOL>self.reset_dir_track()<EOL><DEDENT>elif c == '<STR_LIT:?>':<EOL><INDENT>extended.append(self._restrict_sequence() + _QMARK)<EOL><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>extended.append(self._restrict_extended_slash())<EOL><DEDENT>extended.append(re.escape(c))<EOL><DEDENT>elif c == "<STR_LIT:\|>":<EOL><INDENT>self.clean_up_inverse(extended)<EOL>extended.append(c)<EOL>if temp_after_start:<EOL><INDENT>self.set_start_dir()<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>extended.append(self._references(i))<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>extended.append(self._sequence(i))<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL>extended.append(r'<STR_LIT>')<EOL><DEDENT><DEDENT>elif c != '<STR_LIT:)>':<EOL><INDENT>extended.append(re.escape(c))<EOL><DEDENT>self.update_dir_state()<EOL><DEDENT>self.clean_up_inverse(extended)<EOL>if list_type == '<STR_LIT:?>':<EOL><INDENT>current.append(_QMARK_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:>':<EOL><INDENT>current.append(_STAR_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:+>':<EOL><INDENT>current.append(_PLUS_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:@>':<EOL><INDENT>current.append(_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:!>':<EOL><INDENT>self.inv_ext += <NUM_LIT:1><EOL>current.append(_EXCLA_GROUP % '<STR_LIT>'.join(extended))<EOL>if self.pathname:<EOL><INDENT>if not temp_after_start or self.allow_special_dir:<EOL><INDENT>star = self.path_star<EOL><DEDENT>elif temp_after_start and not self.dot:<EOL><INDENT>star = self.path_star_dot2<EOL><DEDENT>else:<EOL><INDENT>star = self.path_star_dot1<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not temp_after_start or self.dot:<EOL><INDENT>star = _STAR<EOL><DEDENT>else:<EOL><INDENT>star = _NO_DOT + _STAR<EOL><DEDENT><DEDENT>if temp_after_start:<EOL><INDENT>star = _NEED_CHAR + star<EOL><DEDENT>current.append(InvPlaceholder(star))<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>success = False<EOL>self.inv_ext = temp_inv_ext<EOL>i.rewind(i.index - index)<EOL><DEDENT>if not temp_in_list:<EOL><INDENT>self.in_list = False<EOL><DEDENT>if success:<EOL><INDENT>self.reset_dir_track()<EOL><DEDENT>else:<EOL><INDENT>self.dir_start = temp_dir_start<EOL>self.after_start = temp_after_start<EOL><DEDENT>return success<EOL>	Parse extended pattern lists.	f9545:c5:m13
def get_path_sep(self):	return re.escape(self.sep)<EOL>	Get path separator.	f9545:c5:m14
def consume_path_sep(self, i):	try:<EOL><INDENT>if self.bslash_abort:<EOL><INDENT>count = -<NUM_LIT:1><EOL>c = '<STR_LIT:\\>'<EOL>while c == '<STR_LIT:\\>':<EOL><INDENT>count += <NUM_LIT:1><EOL>c = next(i)<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL>if count > <NUM_LIT:0> and count % <NUM_LIT:2>:<EOL><INDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>c = '<STR_LIT:/>'<EOL>while c == '<STR_LIT:/>':<EOL><INDENT>c = next(i)<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT>	Consume any consecutive path separators are they count as one.	f9545:c5:m15
def root(self, pattern, current):	self.set_after_start()<EOL>i = util.StringIter(pattern)<EOL>iter(i)<EOL>root_specified = False<EOL>if self.win_drive_detect:<EOL><INDENT>m = RE_WIN_PATH.match(pattern)<EOL>if m:<EOL><INDENT>drive = m.group(<NUM_LIT:0>).replace('<STR_LIT>', '<STR_LIT:\\>')<EOL>if drive.endswith('<STR_LIT:\\>'):<EOL><INDENT>slash = True<EOL><DEDENT>drive = drive[:-<NUM_LIT:1>]<EOL>current.append(re.escape(drive))<EOL>if slash:<EOL><INDENT>current.append(self.get_path_sep() + _ONE_OR_MORE)<EOL><DEDENT>i.advance(m.end(<NUM_LIT:0>))<EOL>self.consume_path_sep(i)<EOL>root_specified = True<EOL><DEDENT>elif pattern.startswith('<STR_LIT>'):<EOL><INDENT>root_specified = True<EOL><DEDENT><DEDENT>elif not self.win_drive_detect and self.pathname and pattern.startswith('<STR_LIT:/>'):<EOL><INDENT>root_specified = True<EOL><DEDENT>if not root_specified and self.realpath:<EOL><INDENT>current.append(_NO_WIN_ROOT if self.win_drive_detect else _NO_ROOT)<EOL>current.append('<STR_LIT>')<EOL><DEDENT>for c in i:<EOL><INDENT>index = i.index<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i, current, True):<EOL><INDENT>pass<EOL><DEDENT>elif c == '<STR_LIT:*>':<EOL><INDENT>self._handle_star(i, current)<EOL><DEDENT>elif c == '<STR_LIT:?>':<EOL><INDENT>current.append(self._restrict_sequence() + _QMARK)<EOL><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>self.set_start_dir()<EOL>self.clean_up_inverse(current)<EOL>current.append(self.get_path_sep() + _ONE_OR_MORE)<EOL>self.consume_path_sep(i)<EOL><DEDENT>else:<EOL><INDENT>current.append(re.escape(c))<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:\\>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>value = self._references(i)<EOL>if self.dir_start:<EOL><INDENT>self.clean_up_inverse(current)<EOL>self.consume_path_sep(i)<EOL><DEDENT>current.append(value)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL>current.append(re.escape(c))<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>current.append(self._sequence(i))<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL>current.append(re.escape(c))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>current.append(re.escape(c))<EOL><DEDENT>self.update_dir_state()<EOL><DEDENT>self.clean_up_inverse(current)<EOL>if self.pathname:<EOL><INDENT>current.append(_PATH_TRAIL % self.get_path_sep())<EOL><DEDENT>	Start parsing the pattern.	f9545:c5:m16
def parse(self):	result = ['<STR_LIT>']<EOL>negative = False<EOL>p = util.norm_pattern(self.pattern, not self.unix, self.raw_chars)<EOL>p = p.decode('<STR_LIT>') if self.is_bytes else p<EOL>if is_negative(p, self.flags):<EOL><INDENT>negative = True<EOL>p = p[<NUM_LIT:1>:]<EOL><DEDENT>self.root(p, result)<EOL>case_flag = '<STR_LIT:i>' if not self.case_sensitive else '<STR_LIT>'<EOL>if util.PY36:<EOL><INDENT>pattern = (<EOL>r'<STR_LIT>' if negative and not self.globstar_capture else r'<STR_LIT>'<EOL>) % (case_flag, '<STR_LIT>'.join(result))<EOL><DEDENT>else:<EOL><INDENT>pattern = (<EOL>r'<STR_LIT>' if negative and not self.globstar_capture else r'<STR_LIT>'<EOL>) % (case_flag, '<STR_LIT>'.join(result))<EOL><DEDENT>if self.is_bytes:<EOL><INDENT>pattern = pattern.encode('<STR_LIT>')<EOL><DEDENT>return pattern<EOL>	Parse pattern list.	f9545:c5:m17
def __init__(self, include, exclude=None, real=False, path=False, follow=False):	super(WcRegexp, self).__init__(<EOL>_include=include,<EOL>_exclude=exclude,<EOL>_real=real,<EOL>_path=path,<EOL>_follow=follow,<EOL>_hash=hash(<EOL>(<EOL>type(self),<EOL>type(include), include,<EOL>type(exclude), exclude,<EOL>type(real), real,<EOL>type(path), path,<EOL>type(follow), follow<EOL>)<EOL>)<EOL>)<EOL>	Initialization.	f9545:c6:m0
def __hash__(self):	return self._hash<EOL>	Hash.	f9545:c6:m1
def __eq__(self, other):	return (<EOL>isinstance(other, WcRegexp) and<EOL>self._include == other._include and<EOL>self._exclude == other._exclude and<EOL>self._real == other._real and<EOL>self._path == other._path and<EOL>self._follow == other._follow<EOL>)<EOL>	Equal.	f9545:c6:m2
def __ne__(self, other):	return (<EOL>not isinstance(other, WcRegexp) or<EOL>self._include != other._include or<EOL>self._exclude != other._exclude or<EOL>self._real != other._real or<EOL>self._path != other._path or<EOL>self._follow != other._follow<EOL>)<EOL>	Equal.	f9545:c6:m3
def match(self, filename):	return _match_pattern(filename, self._include, self._exclude, self._real, self._path, self._follow)<EOL>	Match filename.	f9545:c6:m4
def parse_version(ver, pre=False):	m = RE_VER.match(ver)<EOL>major = int(m.group('<STR_LIT>'))<EOL>minor = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>micro = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT:type>'):<EOL><INDENT>release = PRE_REL_MAP[m.group('<STR_LIT:type>')]<EOL>pre = int(m.group('<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>release = "<STR_LIT>"<EOL>pre = <NUM_LIT:0><EOL><DEDENT>dev = m.group('<STR_LIT>') if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT>'):<EOL><INDENT>dev = int(m.group('<STR_LIT>'))<EOL>release = '<STR_LIT>' + release if pre else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>dev = <NUM_LIT:0><EOL><DEDENT>post = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>return Version(major, minor, micro, release, pre, post, dev)<EOL>	Parse version into a comparable Version tuple.	f9546:m0
def __new__(cls, major, minor, micro, release="<STR_LIT>", pre=<NUM_LIT:0>, post=<NUM_LIT:0>, dev=<NUM_LIT:0>):	<EOL>for value in (major, minor, micro, pre, post):<EOL><INDENT>if not (isinstance(value, int) and value >= <NUM_LIT:0>):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>if release not in REL_MAP:<EOL><INDENT>raise ValueError("<STR_LIT>".format(release))<EOL><DEDENT>if "<STR_LIT>" < release < "<STR_LIT>":<EOL><INDENT>if pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>elif release < "<STR_LIT>":<EOL><INDENT>if release > "<STR_LIT>" and pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if pre:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>return super(Version, cls).__new__(cls, major, minor, micro, release, pre, post, dev)<EOL>	Validate version info.	f9546:c0:m0
def _is_pre(self):	return self.pre > <NUM_LIT:0><EOL>	Is prerelease.	f9546:c0:m1
def _is_dev(self):	return bool(self.release < "<STR_LIT>")<EOL>	Is development.	f9546:c0:m2
def _is_post(self):	return self.post > <NUM_LIT:0><EOL>	Is post.	f9546:c0:m3
def _get_dev_status(self):	return DEV_STATUS[self.release]<EOL>	Get development status string.	f9546:c0:m4
def _get_canonical(self):	<EOL>if self.micro == <NUM_LIT:0>:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor)<EOL><DEDENT>else:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor, self.micro)<EOL><DEDENT>if self._is_pre():<EOL><INDENT>ver += '<STR_LIT>'.format(REL_MAP[self.release], self.pre)<EOL><DEDENT>if self._is_post():<EOL><INDENT>ver += "<STR_LIT>".format(self.post)<EOL><DEDENT>if self._is_dev():<EOL><INDENT>ver += "<STR_LIT>".format(self.dev)<EOL><DEDENT>return ver<EOL>	Get the canonical output string.	f9546:c0:m5
def __init__(self, args, *kwargs):	args = list(args)<EOL>self._skipped = <NUM_LIT:0><EOL>self._abort = False<EOL>self._directory = util.norm_slash(args.pop(<NUM_LIT:0>))<EOL>self.is_bytes = isinstance(self._directory, bytes)<EOL>if not self._directory:<EOL><INDENT>if self.is_bytes:<EOL><INDENT>curdir = bytes(os.curdir, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>curdir = os.curdir<EOL><DEDENT><DEDENT>else:<EOL><INDENT>curdir = self._directory<EOL><DEDENT>self.sep = os.fsencode(os.sep) if self.is_bytes else os.sep<EOL>self.base = curdir if curdir.endswith(self.sep) else curdir + self.sep<EOL>self.file_pattern = args.pop(<NUM_LIT:0>) if args else kwargs.pop('<STR_LIT>', b'<STR_LIT>' if self.is_bytes else '<STR_LIT>')<EOL>if not self.file_pattern:<EOL><INDENT>self.file_pattern = _wcparse.WcRegexp(<EOL>(re.compile(br'<STR_LIT>', re.DOTALL),) if self.is_bytes else (re.compile(r'<STR_LIT>', re.DOTALL),)<EOL>)<EOL><DEDENT>self.exclude_pattern = args.pop(<NUM_LIT:0>) if args else kwargs.pop('<STR_LIT>', b'<STR_LIT>' if self.is_bytes else '<STR_LIT>')<EOL>self.flags = (args.pop(<NUM_LIT:0>) if args else kwargs.pop('<STR_LIT>', <NUM_LIT:0>)) & FLAG_MASK<EOL>self.flags \|= _wcparse.NEGATE \| _wcparse.DOTMATCH<EOL>self.follow_links = bool(self.flags & SYMLINKS)<EOL>self.show_hidden = bool(self.flags & HIDDEN)<EOL>self.recursive = bool(self.flags & RECURSIVE)<EOL>self.dir_pathname = bool(self.flags & DIRPATHNAME)<EOL>self.file_pathname = bool(self.flags & FILEPATHNAME)<EOL>if util.platform() == "<STR_LIT>":<EOL><INDENT>self.flags \|= _wcparse._FORCEWIN<EOL><DEDENT>self.flags = self.flags & (_wcparse.FLAG_MASK ^ (SYMLINKS \| DIRPATHNAME \| FILEPATHNAME \| HIDDEN))<EOL>self.on_init(args, *kwargs)<EOL>self.file_check, self.folder_exclude_check = self._compile(self.file_pattern, self.exclude_pattern)<EOL>	Initialize the directory walker object.	f9547:c0:m0
def _compile_wildcard(self, pattern, pathname=False):	patterns = None<EOL>flags = self.flags<EOL>if pathname:<EOL><INDENT>flags \|= _wcparse.PATHNAME<EOL><DEDENT>if pattern:<EOL><INDENT>patterns = _wcparse.WcSplit(pattern, flags=flags).split()<EOL><DEDENT>return _wcparse.compile(patterns, flags) if patterns else patterns<EOL>	Compile or format the wildcard inclusion/exclusion pattern.	f9547:c0:m1
def _compile(self, file_pattern, folder_exclude_pattern):	if not isinstance(file_pattern, _wcparse.WcRegexp):<EOL><INDENT>file_pattern = self._compile_wildcard(file_pattern, self.file_pathname)<EOL><DEDENT>if not isinstance(folder_exclude_pattern, _wcparse.WcRegexp):<EOL><INDENT>folder_exclude_pattern = self._compile_wildcard(folder_exclude_pattern, self.dir_pathname)<EOL><DEDENT>return file_pattern, folder_exclude_pattern<EOL>	Compile patterns.	f9547:c0:m2
def _valid_file(self, base, name):	valid = False<EOL>fullpath = os.path.join(base, name)<EOL>if self.file_check is not None and self.compare_file(fullpath[self._base_len:] if self.file_pathname else name):<EOL><INDENT>valid = True<EOL><DEDENT>if valid and (not self.show_hidden and util.is_hidden(fullpath)):<EOL><INDENT>valid = False<EOL><DEDENT>return self.on_validate_file(base, name) if valid else valid<EOL>	Return whether a file can be searched.	f9547:c0:m3
def compare_file(self, filename):	return self.file_check.match(filename)<EOL>	Compare filename.	f9547:c0:m4
def on_validate_file(self, base, name):	return True<EOL>	Validate file override.	f9547:c0:m5
def _valid_folder(self, base, name):	valid = True<EOL>fullpath = os.path.join(base, name)<EOL>if (<EOL>not self.recursive or<EOL>(<EOL>self.folder_exclude_check is not None and<EOL>not self.compare_directory(fullpath[self._base_len:] if self.dir_pathname else name)<EOL>)<EOL>):<EOL><INDENT>valid = False<EOL><DEDENT>if valid and (not self.show_hidden and util.is_hidden(fullpath)):<EOL><INDENT>valid = False<EOL><DEDENT>return self.on_validate_directory(base, name) if valid else valid<EOL>	Return whether a folder can be searched.	f9547:c0:m6
def compare_directory(self, directory):	return not self.folder_exclude_check.match(directory + self.sep if self.dir_pathname else directory)<EOL>	Compare folder.	f9547:c0:m7
def on_init(self, args, *kwargs):		Handle custom initialization.	f9547:c0:m8
def on_validate_directory(self, base, name):	return True<EOL>	Validate folder override.	f9547:c0:m9
def on_skip(self, base, name):	return None<EOL>	On skip.	f9547:c0:m10
def on_error(self, base, name):	return None<EOL>	On error.	f9547:c0:m11
def on_match(self, base, name):	return os.path.join(base, name)<EOL>	On match.	f9547:c0:m12
def get_skipped(self):	return self._skipped<EOL>	Get number of skipped files.	f9547:c0:m13

@classmethod<EOL><INDENT>def setup_fs(cls):<DEDENT>

cls.mktemp('<STR_LIT>')<EOL>cls.mktemp('<STR_LIT:a>', '<STR_LIT:b>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.can_symlink = can_symlink()<EOL>

Setup file system.

f9541:c4:m0

def check_escape(self, arg, expected, raw=False):

if raw:<EOL><INDENT>self.assertEqual(glob.raw_escape(arg), expected)<EOL>self.assertEqual(glob.raw_escape(os.fsencode(arg)), os.fsencode(expected))<EOL><DEDENT>else:<EOL><INDENT>self.assertEqual(glob.escape(arg), expected)<EOL>self.assertEqual(glob.escape(os.fsencode(arg)), os.fsencode(expected))<EOL><DEDENT>

Verify escapes.

f9541:c5:m0

def globjoin(self, *parts):

sep = os.fsencode(self.globsep) if isinstance(parts[<NUM_LIT:0>], bytes) else self.globsep<EOL>return sep.join(list(parts))<EOL>

Joins glob path.

f9541:c6:m0

def setUp(self):

if os.sep == '<STR_LIT:/>':<EOL><INDENT>self.globsep = os.sep<EOL><DEDENT>else:<EOL><INDENT>self.globsep = r'<STR_LIT:\\>'<EOL><DEDENT>

Setup.

f9541:c6:m1

def platform():

return _PLATFORM<EOL>

Get platform.

f9542:m0

def is_case_sensitive():

return CASE_FS<EOL>

Check if case sensitive.

f9542:m1

def to_tuple(values):

return (values,) if isinstance(values, (str, bytes)) else tuple(values)<EOL>

Combine values.

f9542:m2

def norm_slash(name):

if isinstance(name, str):<EOL><INDENT>return name.replace('<STR_LIT:/>', "<STR_LIT:\\>") if not is_case_sensitive() else name<EOL><DEDENT>else:<EOL><INDENT>return name.replace(b'<STR_LIT:/>', b"<STR_LIT:\\>") if not is_case_sensitive() else name<EOL><DEDENT>

Normalize path slashes.

f9542:m3

def norm_pattern(pattern, normalize, is_raw_chars):

is_bytes = isinstance(pattern, bytes)<EOL>if not normalize and not is_raw_chars:<EOL><INDENT>return pattern<EOL><DEDENT>def norm_char(token):<EOL><INDENT>"""<STR_LIT>"""<EOL>if normalize and token in ('<STR_LIT:/>', b'<STR_LIT:/>'):<EOL><INDENT>token = br'<STR_LIT:\\>' if is_bytes else r'<STR_LIT:\\>'<EOL><DEDENT>return token<EOL><DEDENT>def norm(m):<EOL><INDENT>"""<STR_LIT>"""<EOL>if m.group(<NUM_LIT:1>):<EOL><INDENT>char = m.group(<NUM_LIT:1>)<EOL>if normalize:<EOL><INDENT>char = br'<STR_LIT>' if is_bytes else r'<STR_LIT>' if len(char) > <NUM_LIT:1> else norm_char(char)<EOL><DEDENT><DEDENT>elif m.group(<NUM_LIT:2>):<EOL><INDENT>char = norm_char(BACK_SLASH_TRANSLATION[m.group(<NUM_LIT:2>)] if is_raw_chars else m.group(<NUM_LIT:2>))<EOL><DEDENT>elif is_raw_chars and m.group(<NUM_LIT:4>):<EOL><INDENT>char = norm_char(bytes([int(m.group(<NUM_LIT:4>), <NUM_LIT:8>) & <NUM_LIT>]) if is_bytes else chr(int(m.group(<NUM_LIT:4>), <NUM_LIT:8>)))<EOL><DEDENT>elif is_raw_chars and m.group(<NUM_LIT:3>):<EOL><INDENT>char = norm_char(bytes([int(m.group(<NUM_LIT:3>)[<NUM_LIT:2>:], <NUM_LIT:16>)]) if is_bytes else chr(int(m.group(<NUM_LIT:3>)[<NUM_LIT:2>:], <NUM_LIT:16>)))<EOL><DEDENT>elif is_raw_chars and not is_bytes and m.group(<NUM_LIT:5>):<EOL><INDENT>char = norm_char(unicodedata.lookup(m.group(<NUM_LIT:5>)[<NUM_LIT:3>:-<NUM_LIT:1>]))<EOL><DEDENT>elif not is_raw_chars:<EOL><INDENT>char = m.group(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>value = m.group(<NUM_LIT:5>) if is_bytes else m.group(<NUM_LIT:6>)<EOL>pos = m.start(<NUM_LIT:5>) if is_bytes else m.start(<NUM_LIT:6>)<EOL>raise SyntaxError("<STR_LIT>" % (value, pos))<EOL><DEDENT>return char<EOL><DEDENT>return (RE_BNORM if is_bytes else RE_NORM).sub(norm, pattern)<EOL>

r""" Normalize pattern. - For windows systems we want to normalize slashes to \. - If raw string chars is enabled, we want to also convert encoded string chars to literal characters. - If `normalize` is enabled, take care to convert \/ to \\\\.

f9542:m4

def is_hidden(path):

hidden = False<EOL>f = os.path.basename(path)<EOL>if f[:<NUM_LIT:1>] in ('<STR_LIT:.>', b'<STR_LIT:.>'):<EOL><INDENT>hidden = True<EOL><DEDENT>elif _PLATFORM == '<STR_LIT>':<EOL><INDENT>FILE_ATTRIBUTE_HIDDEN = <NUM_LIT><EOL>if PY35:<EOL><INDENT>results = os.lstat(path)<EOL>hidden = bool(results.st_file_attributes & FILE_ATTRIBUTE_HIDDEN)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(path, bytes):<EOL><INDENT>attrs = ctypes.windll.kernel32.GetFileAttributesA(path)<EOL><DEDENT>else:<EOL><INDENT>attrs = ctypes.windll.kernel32.GetFileAttributesW(path)<EOL><DEDENT>hidden = attrs != -<NUM_LIT:1> and attrs & FILE_ATTRIBUTE_HIDDEN<EOL><DEDENT><DEDENT>elif _PLATFORM == "<STR_LIT>": <EOL><INDENT>results = os.lstat(path)<EOL>hidden = bool(results.st_flags & stat.UF_HIDDEN)<EOL><DEDENT>return hidden<EOL>

Check if file is hidden.

f9542:m5

def deprecated(message, stacklevel=<NUM_LIT:2>):

def _decorator(func):<EOL><INDENT>@wraps(func)<EOL>def _func(*args, **kwargs):<EOL><INDENT>warnings.warn(<EOL>"<STR_LIT>".format(func.__name__, message),<EOL>category=DeprecationWarning,<EOL>stacklevel=stacklevel<EOL>)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return _func<EOL><DEDENT>return _decorator<EOL>

Raise a `DeprecationWarning` when wrapped function/method is called. Borrowed from https://stackoverflow.com/a/48632082/866026

f9542:m6

def __init__(self, string):

self._string = string<EOL>self._index = <NUM_LIT:0><EOL>

Initialize.

f9542:c0:m0

def __iter__(self):

return self<EOL>

Iterate.

f9542:c0:m1

def __next__(self):

return self.iternext()<EOL>

Python 3 iterator compatible next.

f9542:c0:m2

def match(self, pattern):

m = pattern.match(self._string, self._index)<EOL>if m:<EOL><INDENT>self._index = m.end()<EOL><DEDENT>return m<EOL>

Perform regex match at index.

f9542:c0:m3

@property<EOL><INDENT>def index(self):<DEDENT>

return self._index<EOL>

Get current index.

f9542:c0:m4

def previous(self):

return self._string[self._index - <NUM_LIT:1>]<EOL>

Get previous char.

f9542:c0:m5

def advance(self, count):

self._index += count<EOL>

Advanced the index.

f9542:c0:m6

def rewind(self, count):

if count > self._index: <EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>self._index -= count<EOL>

Rewind index.

f9542:c0:m7

def iternext(self):

try:<EOL><INDENT>char = self._string[self._index]<EOL>self._index += <NUM_LIT:1><EOL><DEDENT>except IndexError: <EOL><INDENT>raise StopIteration<EOL><DEDENT>return char<EOL>

Iterate through characters of the string.

f9542:c0:m8

def __init__(self, **kwargs):

for k, v in kwargs.items():<EOL><INDENT>super(Immutable, self).__setattr__(k, v)<EOL><DEDENT>

Initialize.

f9542:c1:m0

def __setattr__(self, name, value):

raise AttributeError('<STR_LIT>')<EOL>

Prevent mutability.

f9542:c1:m1

def parse_version(ver, pre=False):

m = RE_VER.match(ver)<EOL>major = int(m.group('<STR_LIT>'))<EOL>minor = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>micro = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT:type>'):<EOL><INDENT>release = PRE_REL_MAP[m.group('<STR_LIT:type>')]<EOL>pre = int(m.group('<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>release = "<STR_LIT>"<EOL>pre = <NUM_LIT:0><EOL><DEDENT>dev = m.group('<STR_LIT>') if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT>'):<EOL><INDENT>dev = int(m.group('<STR_LIT>'))<EOL>release = '<STR_LIT>' + release if pre else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>dev = <NUM_LIT:0><EOL><DEDENT>post = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>return Version(major, minor, micro, release, pre, post, dev)<EOL>

Parse version into a comparable Version tuple.

f9543:m0

def __new__(cls, major, minor, micro, release="<STR_LIT>", pre=<NUM_LIT:0>, post=<NUM_LIT:0>, dev=<NUM_LIT:0>):

<EOL>for value in (major, minor, micro, pre, post):<EOL><INDENT>if not (isinstance(value, int) and value >= <NUM_LIT:0>):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>if release not in REL_MAP:<EOL><INDENT>raise ValueError("<STR_LIT>".format(release))<EOL><DEDENT>if "<STR_LIT>" < release < "<STR_LIT>":<EOL><INDENT>if pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>elif release < "<STR_LIT>":<EOL><INDENT>if release > "<STR_LIT>" and pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if pre:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>return super(Version, cls).__new__(cls, major, minor, micro, release, pre, post, dev)<EOL>

Validate version info.

f9543:c0:m0

def _is_pre(self):

return self.pre > <NUM_LIT:0><EOL>

Is prerelease.

f9543:c0:m1

def _is_dev(self):

return bool(self.release < "<STR_LIT>")<EOL>

Is development.

f9543:c0:m2

def _is_post(self):

return self.post > <NUM_LIT:0><EOL>

Is post.

f9543:c0:m3

def _get_dev_status(self):

return DEV_STATUS[self.release]<EOL>

Get development status string.

f9543:c0:m4

def _get_canonical(self):

<EOL>if self.micro == <NUM_LIT:0>:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor)<EOL><DEDENT>else:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor, self.micro)<EOL><DEDENT>if self._is_pre():<EOL><INDENT>ver += '<STR_LIT>'.format(REL_MAP[self.release], self.pre)<EOL><DEDENT>if self._is_post():<EOL><INDENT>ver += "<STR_LIT>".format(self.post)<EOL><DEDENT>if self._is_dev():<EOL><INDENT>ver += "<STR_LIT>".format(self.dev)<EOL><DEDENT>return ver<EOL>

Get the canonical output string.

f9543:c0:m5

def __init__(self, name):

self._module = sys.modules[name]<EOL>self._get_attr = getattr(self._module, '<STR_LIT>', None)<EOL>self._get_dir = getattr(self._module, '<STR_LIT>', None)<EOL>sys.modules[name] = self<EOL>

Acquire `__getattr__` and `__dir__`, but only replace module for versions less than Python 3.7.

f9543:c1:m0

def __dir__(self):

return self._get_dir() if self._get_dir else dir(self._module)<EOL>

Return the overridden `dir` if one was provided, else apply `dir` to the module.

f9543:c1:m1

def __getattr__(self, name):

try:<EOL><INDENT>return getattr(self._module, name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>if self._get_attr:<EOL><INDENT>return self._get_attr(name)<EOL><DEDENT>raise<EOL><DEDENT>

Attempt to retrieve the attribute from the module, and if missing, use the overridden function if present.

f9543:c1:m2

def __getattr__(name):

deprecated = __deprecated__.get(name)<EOL>if deprecated:<EOL><INDENT>warnings.warn(<EOL>"<STR_LIT>".format(name, deprecated[<NUM_LIT:0>]),<EOL>category=DeprecationWarning,<EOL>stacklevel=(<NUM_LIT:3> if PY37 else <NUM_LIT:4>)<EOL>)<EOL>return deprecated[<NUM_LIT:1>]<EOL><DEDENT>raise AttributeError("<STR_LIT>".format(__name__, name))<EOL>

Get attribute.

f9544:m0

def is_negative(pattern, flags):

if flags & MINUSNEGATE:<EOL><INDENT>return flags & NEGATE and pattern[<NUM_LIT:0>:<NUM_LIT:1>] in MINUS_NEGATIVE_SYM<EOL><DEDENT>else:<EOL><INDENT>return flags & NEGATE and pattern[<NUM_LIT:0>:<NUM_LIT:1>] in NEGATIVE_SYM<EOL><DEDENT>

Check if negative pattern.

f9545:m0

def expand_braces(patterns, flags):

if flags & BRACE:<EOL><INDENT>for p in ([patterns] if isinstance(patterns, (str, bytes)) else patterns):<EOL><INDENT>try:<EOL><INDENT>yield from bracex.iexpand(p, keep_escapes=True)<EOL><DEDENT>except Exception: <EOL><INDENT>yield p<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for p in ([patterns] if isinstance(patterns, (str, bytes)) else patterns):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT>

Expand braces.

f9545:m1

def get_case(flags):

if not bool(flags & CASE_FLAGS):<EOL><INDENT>case_sensitive = util.is_case_sensitive()<EOL><DEDENT>elif flags & FORCECASE:<EOL><INDENT>case_sensitive = True<EOL><DEDENT>else:<EOL><INDENT>case_sensitive = False<EOL><DEDENT>return case_sensitive<EOL>

Parse flags for case sensitivity settings.

f9545:m2

def is_unix_style(flags):

return (util.platform() != "<STR_LIT>" or (not bool(flags & REALPATH) and get_case(flags))) and not flags & _FORCEWIN<EOL>

Check if we should use Unix style.

f9545:m3

def translate(patterns, flags):

positive = []<EOL>negative = []<EOL>if isinstance(patterns, (str, bytes)):<EOL><INDENT>patterns = [patterns]<EOL><DEDENT>flags |= _TRANSLATE<EOL>for pattern in patterns:<EOL><INDENT>for expanded in expand_braces(pattern, flags):<EOL><INDENT>(negative if is_negative(expanded, flags) else positive).append(<EOL>WcParse(expanded, flags & FLAG_MASK).parse()<EOL>)<EOL><DEDENT><DEDENT>if patterns and flags & REALPATH and negative and not positive:<EOL><INDENT>positive.append(_compile(b'<STR_LIT>' if isinstance(patterns[<NUM_LIT:0>], bytes) else '<STR_LIT>', flags))<EOL><DEDENT>return positive, negative<EOL>

Translate patterns.

f9545:m4

def split(patterns, flags):

if flags & SPLIT:<EOL><INDENT>splitted = []<EOL>for pattern in ([patterns] if isinstance(patterns, (str, bytes)) else patterns):<EOL><INDENT>splitted.extend(WcSplit(pattern, flags).split())<EOL><DEDENT>return splitted<EOL><DEDENT>else:<EOL><INDENT>return patterns<EOL><DEDENT>

Split patterns.

f9545:m5

def compile(patterns, flags):

positive = []<EOL>negative = []<EOL>if isinstance(patterns, (str, bytes)):<EOL><INDENT>patterns = [patterns]<EOL><DEDENT>for pattern in patterns:<EOL><INDENT>for expanded in expand_braces(pattern, flags):<EOL><INDENT>(negative if is_negative(expanded, flags) else positive).append(_compile(expanded, flags))<EOL><DEDENT><DEDENT>if patterns and flags & REALPATH and negative and not positive:<EOL><INDENT>positive.append(_compile(b'<STR_LIT>' if isinstance(patterns[<NUM_LIT:0>], bytes) else '<STR_LIT>', flags))<EOL><DEDENT>return WcRegexp(tuple(positive), tuple(negative), flags & REALPATH, flags & PATHNAME, flags & FOLLOW)<EOL>

Compile patterns.

f9545:m6

@functools.lru_cache(maxsize=<NUM_LIT>, typed=True)<EOL>def _compile(pattern, flags):

return re.compile(WcParse(pattern, flags & FLAG_MASK).parse())<EOL>

Compile the pattern to regex.

f9545:m7

def _fs_match(pattern, filename, sep, follow, symlinks):

matched = False<EOL>base = None<EOL>m = pattern.fullmatch(filename)<EOL>if m:<EOL><INDENT>matched = True<EOL>if not follow:<EOL><INDENT>groups = m.groups()<EOL>last = len(groups)<EOL>for i, star in enumerate(m.groups(), <NUM_LIT:1>):<EOL><INDENT>if star:<EOL><INDENT>parts = star.strip(sep).split(sep)<EOL>if base is None:<EOL><INDENT>base = filename[:m.start(i)]<EOL><DEDENT>for part in parts:<EOL><INDENT>base = os.path.join(base, part)<EOL>is_link = symlinks.get(base, None)<EOL>if is_link is not None:<EOL><INDENT>matched = not is_link<EOL><DEDENT>elif i != last or os.path.isdir(base):<EOL><INDENT>is_link = os.path.islink(base)<EOL>symlinks[base] = is_link<EOL>matched = not is_link<EOL><DEDENT>if not matched:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if matched:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return matched<EOL>

Match path against the pattern. Since `globstar` doesn't match symlinks (unless `FOLLOW` is enabled), we must look for symlinks. If we identify a symlink in a `globstar` match, we know this result should not actually match.

f9545:m8

def _match_real(filename, include, exclude, follow, symlinks):

sep = '<STR_LIT:\\>' if util.platform() == "<STR_LIT>" else '<STR_LIT:/>'<EOL>if isinstance(filename, bytes):<EOL><INDENT>sep = os.fsencode(sep)<EOL><DEDENT>if not filename.endswith(sep) and os.path.isdir(filename):<EOL><INDENT>filename += sep<EOL><DEDENT>matched = False<EOL>for pattern in include:<EOL><INDENT>if _fs_match(pattern, filename, sep, follow, symlinks):<EOL><INDENT>matched = True<EOL>break<EOL><DEDENT><DEDENT>if matched:<EOL><INDENT>matched = True<EOL>if exclude:<EOL><INDENT>for pattern in exclude:<EOL><INDENT>if _fs_match(pattern, filename, sep, follow, symlinks):<EOL><INDENT>matched = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return matched<EOL>

Match real filename includes and excludes.

f9545:m9

def _match_pattern(filename, include, exclude, real, path, follow):

if real:<EOL><INDENT>symlinks = {}<EOL>if isinstance(filename, bytes):<EOL><INDENT>curdir = os.fsencode(os.curdir)<EOL>mount = RE_BWIN_MOUNT if util.platform() == "<STR_LIT>" else RE_BMOUNT<EOL><DEDENT>else:<EOL><INDENT>curdir = os.curdir<EOL>mount = RE_WIN_MOUNT if util.platform() == "<STR_LIT>" else RE_MOUNT<EOL><DEDENT>if not mount.match(filename):<EOL><INDENT>exists = os.path.lexists(os.path.join(curdir, filename))<EOL><DEDENT>else:<EOL><INDENT>exists = os.path.lexists(filename)<EOL><DEDENT>if not exists:<EOL><INDENT>return False<EOL><DEDENT>if path:<EOL><INDENT>return _match_real(filename, include, exclude, follow, symlinks)<EOL><DEDENT><DEDENT>matched = False<EOL>for pattern in include:<EOL><INDENT>if pattern.fullmatch(filename):<EOL><INDENT>matched = True<EOL>break<EOL><DEDENT><DEDENT>if not include and exclude:<EOL><INDENT>matched = True<EOL><DEDENT>if matched:<EOL><INDENT>matched = True<EOL>if exclude:<EOL><INDENT>for pattern in exclude:<EOL><INDENT>if not pattern.fullmatch(filename):<EOL><INDENT>matched = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return matched<EOL>

Match includes and excludes.

f9545:m10

def __init__(self, pattern, flags):

self.unix = is_unix_style(flags)<EOL>self.flags = flags<EOL>self.pattern = util.norm_pattern(pattern, not self.unix, flags & RAWCHARS)<EOL>self.globstar = bool(flags & GLOBSTAR)<EOL>if is_negative(self.pattern, flags): <EOL><INDENT>self.pattern = self.pattern[<NUM_LIT:0>:<NUM_LIT:1>]<EOL><DEDENT>if flags & NEGATE:<EOL><INDENT>flags ^= NEGATE<EOL><DEDENT>self.flags = flags<EOL>self.is_bytes = isinstance(pattern, bytes)<EOL>self.extend = bool(flags & EXTMATCH)<EOL>if not self.unix:<EOL><INDENT>self.win_drive_detect = True<EOL>self.bslash_abort = True<EOL>self.sep = '<STR_LIT:\\>'<EOL><DEDENT>else:<EOL><INDENT>self.win_drive_detect = False<EOL>self.bslash_abort = False<EOL>self.sep = '<STR_LIT:/>'<EOL><DEDENT>self.re_magic = RE_MAGIC if not self.is_bytes else RE_BMAGIC<EOL>self.magic = False<EOL>

Initialize.

f9545:c3:m0

def is_magic(self, name):

return self.re_magic.search(name) is not None<EOL>

Check if name contains magic characters.

f9545:c3:m1

def _sequence(self, i):

c = next(i)<EOL>if c == '<STR_LIT:!>':<EOL><INDENT>c = next(i)<EOL><DEDENT>if c in ('<STR_LIT>', '<STR_LIT:->', '<STR_LIT:[>'):<EOL><INDENT>c = next(i)<EOL><DEDENT>while c != '<STR_LIT:]>':<EOL><INDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>raise StopIteration<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>c = next(i)<EOL><DEDENT>

Handle character group.

f9545:c3:m2

def _references(self, i, sequence=False):

value = '<STR_LIT>'<EOL>c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>if sequence and self.bslash_abort:<EOL><INDENT>raise PathNameException<EOL><DEDENT>value = c<EOL><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if sequence:<EOL><INDENT>raise PathNameException<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return value<EOL>

Handle references.

f9545:c3:m3

def parse_extend(self, c, i):

<EOL>success = True<EOL>index = i.index<EOL>list_type = c<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:(>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>while c != '<STR_LIT:)>':<EOL><INDENT>c = next(i)<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>self._references(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>success = False<EOL>c = list_type<EOL>i.rewind(i.index - index)<EOL><DEDENT>return success<EOL>

Parse extended pattern lists.

f9545:c3:m4

def store(self, value, l, dir_only):

if l and value in (b'<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>globstar = value in (b'<STR_LIT>', '<STR_LIT>') and self.globstar<EOL>magic = self.is_magic(value)<EOL>if magic:<EOL><INDENT>value = compile(value, self.flags)<EOL><DEDENT>l.append(WcGlob(value, magic, globstar, dir_only, False))<EOL>

Group patterns by literals and potential magic patterns.

f9545:c3:m5

def split(self):

split_index = []<EOL>parts = []<EOL>start = -<NUM_LIT:1><EOL>pattern = self.pattern.decode('<STR_LIT>') if self.is_bytes else self.pattern<EOL>i = util.StringIter(pattern)<EOL>iter(i)<EOL>if self.win_drive_detect:<EOL><INDENT>m = RE_WIN_PATH.match(pattern)<EOL>if m:<EOL><INDENT>drive = m.group(<NUM_LIT:0>).replace('<STR_LIT>', '<STR_LIT:\\>')<EOL>if self.is_bytes:<EOL><INDENT>drive = drive.encode('<STR_LIT>')<EOL><DEDENT>parts.append(WcGlob(drive, False, False, True, True))<EOL>start = m.end(<NUM_LIT:0>) - <NUM_LIT:1><EOL>i.advance(start + <NUM_LIT:1>)<EOL><DEDENT>elif pattern.startswith('<STR_LIT>'):<EOL><INDENT>parts.append(WcGlob(b'<STR_LIT:\\>' if self.is_bytes else '<STR_LIT:\\>', False, False, True, True))<EOL>start = <NUM_LIT:1><EOL>i.advance(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>elif not self.win_drive_detect and pattern.startswith('<STR_LIT:/>'):<EOL><INDENT>parts.append(WcGlob(b'<STR_LIT:/>' if self.is_bytes else '<STR_LIT:/>', False, False, True, True))<EOL>start = <NUM_LIT:0><EOL>i.advance(<NUM_LIT:1>)<EOL><DEDENT>for c in i:<EOL><INDENT>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>index = i.index<EOL>value = '<STR_LIT>'<EOL>try:<EOL><INDENT>value = self._references(i)<EOL>if self.bslash_abort and value == '<STR_LIT:\\>':<EOL><INDENT>split_index.append((i.index - <NUM_LIT:2>, <NUM_LIT:1>))<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL>if self.bslash_abort:<EOL><INDENT>split_index.append((i.index - <NUM_LIT:1>, <NUM_LIT:0>))<EOL><DEDENT><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>split_index.append((i.index - <NUM_LIT:1>, <NUM_LIT:0>))<EOL><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT>for split, offset in split_index:<EOL><INDENT>if self.is_bytes:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:split].encode('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:split]<EOL><DEDENT>self.store(value, parts, True)<EOL>start = split + offset<EOL><DEDENT>if start < len(pattern):<EOL><INDENT>if self.is_bytes:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:].encode('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>value = pattern[start + <NUM_LIT:1>:]<EOL><DEDENT>if value:<EOL><INDENT>self.store(value, parts, False)<EOL><DEDENT><DEDENT>if len(pattern) == <NUM_LIT:0>:<EOL><INDENT>parts.append(WcGlob(pattern.encode('<STR_LIT>') if self.is_bytes else pattern, False, False, False, False))<EOL><DEDENT>return parts<EOL>

Start parsing the pattern.

f9545:c3:m6

def __init__(self, pattern, flags):

self.pattern = pattern<EOL>self.is_bytes = isinstance(pattern, bytes)<EOL>self.pathname = bool(flags & PATHNAME)<EOL>self.extend = bool(flags & EXTMATCH)<EOL>self.unix = is_unix_style(flags)<EOL>self.bslash_abort = not self.unix<EOL>

Initialize.

f9545:c4:m0

def _sequence(self, i):

c = next(i)<EOL>if c == '<STR_LIT:!>':<EOL><INDENT>c = next(i)<EOL><DEDENT>if c in ('<STR_LIT>', '<STR_LIT:->', '<STR_LIT:[>'):<EOL><INDENT>c = next(i)<EOL><DEDENT>while c != '<STR_LIT:]>':<EOL><INDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>raise StopIteration<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>raise StopIteration<EOL><DEDENT><DEDENT>c = next(i)<EOL><DEDENT>

Handle character group.

f9545:c4:m1

def _references(self, i, sequence=False):

c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>if sequence and self.bslash_abort:<EOL><INDENT>raise PathNameException<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if sequence and self.pathname:<EOL><INDENT>raise PathNameException<EOL><DEDENT>elif self.pathname:<EOL><INDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>

Handle references.

f9545:c4:m2

def parse_extend(self, c, i):

<EOL>success = True<EOL>index = i.index<EOL>list_type = c<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:(>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>while c != '<STR_LIT:)>':<EOL><INDENT>c = next(i)<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>self._references(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>success = False<EOL>c = list_type<EOL>i.rewind(i.index - index)<EOL><DEDENT>return success<EOL>

Parse extended pattern lists.

f9545:c4:m3

def split(self):

split_index = []<EOL>parts = []<EOL>pattern = self.pattern.decode('<STR_LIT>') if self.is_bytes else self.pattern<EOL>i = util.StringIter(pattern)<EOL>iter(i)<EOL>for c in i:<EOL><INDENT>if self.extend and c in EXT_TYPES and self.parse_extend(c, i):<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:|>':<EOL><INDENT>split_index.append(i.index - <NUM_LIT:1>)<EOL><DEDENT>elif c == '<STR_LIT:\\>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._references(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>self._sequence(i)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT><DEDENT>start = -<NUM_LIT:1><EOL>for split in split_index:<EOL><INDENT>p = pattern[start + <NUM_LIT:1>:split]<EOL>parts.append(p.encode('<STR_LIT>') if self.is_bytes else p)<EOL>start = split<EOL><DEDENT>if start < len(pattern):<EOL><INDENT>p = pattern[start + <NUM_LIT:1>:]<EOL>parts.append(p.encode('<STR_LIT>') if self.is_bytes else p)<EOL><DEDENT>return tuple(parts)<EOL>

Start parsing the pattern.

f9545:c4:m4

def __init__(self, pattern, flags=<NUM_LIT:0>):

self.pattern = pattern<EOL>self.braces = bool(flags & BRACE)<EOL>self.is_bytes = isinstance(pattern, bytes)<EOL>self.pathname = bool(flags & PATHNAME)<EOL>self.raw_chars = bool(flags & RAWCHARS)<EOL>self.globstar = self.pathname and bool(flags & GLOBSTAR)<EOL>self.realpath = bool(flags & REALPATH) and self.pathname<EOL>self.globstar_capture = self.realpath and not bool(flags & _TRANSLATE)<EOL>self.dot = bool(flags & DOTMATCH)<EOL>self.extend = bool(flags & EXTMATCH)<EOL>self.case_sensitive = get_case(flags)<EOL>self.in_list = False<EOL>self.flags = flags<EOL>self.inv_ext = <NUM_LIT:0><EOL>self.unix = is_unix_style(self.flags)<EOL>if not self.unix:<EOL><INDENT>self.win_drive_detect = self.pathname<EOL>self.char_avoid = (ord('<STR_LIT:\\>'), ord('<STR_LIT:/>'), ord('<STR_LIT:.>'))<EOL>self.bslash_abort = self.pathname<EOL>self.sep = '<STR_LIT:\\>'<EOL><DEDENT>else:<EOL><INDENT>self.win_drive_detect = False<EOL>self.char_avoid = (ord('<STR_LIT:/>'), ord('<STR_LIT:.>'))<EOL>self.bslash_abort = False<EOL>self.sep = '<STR_LIT:/>'<EOL><DEDENT>sep = {"<STR_LIT>": re.escape(self.sep)}<EOL>self.path_eop = _PATH_EOP % sep<EOL>self.no_dir = _NO_DIR % sep<EOL>self.seq_path = _PATH_NO_SLASH % sep<EOL>self.seq_path_dot = _PATH_NO_SLASH_DOT % sep<EOL>self.path_star = _PATH_STAR % sep<EOL>self.path_star_dot1 = _PATH_STAR_DOTMATCH % sep<EOL>self.path_star_dot2 = _PATH_STAR_NO_DOTMATCH % sep<EOL>self.path_gstar_dot1 = _PATH_GSTAR_DOTMATCH % sep<EOL>self.path_gstar_dot2 = _PATH_GSTAR_NO_DOTMATCH % sep<EOL>

Initialize.

f9545:c5:m0

def set_after_start(self):

self.after_start = True<EOL>self.dir_start = False<EOL>

Set tracker for character after the start of a directory.

f9545:c5:m1

def set_start_dir(self):

self.dir_start = True<EOL>self.after_start = False<EOL>

Set directory start.

f9545:c5:m2

def reset_dir_track(self):

self.dir_start = False<EOL>self.after_start = False<EOL>

Reset directory tracker.

f9545:c5:m3

def update_dir_state(self):

if self.dir_start and not self.after_start:<EOL><INDENT>self.set_after_start()<EOL><DEDENT>elif not self.dir_start and self.after_start:<EOL><INDENT>self.reset_dir_track()<EOL><DEDENT>

Update the directory state. If we are at the directory start, update to after start state (the character right after). If at after start, reset state.

f9545:c5:m4

def _restrict_extended_slash(self):

return self.seq_path if self.pathname else '<STR_LIT>'<EOL>

Restrict extended slash.

f9545:c5:m5

def _restrict_sequence(self):

if self.pathname:<EOL><INDENT>value = self.seq_path_dot if self.after_start and not self.dot else self.seq_path<EOL>if self.after_start:<EOL><INDENT>value = self.no_dir + value<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = _NO_DOT if self.after_start and not self.dot else "<STR_LIT>"<EOL><DEDENT>self.reset_dir_track()<EOL>return value<EOL>

Restrict sequence.

f9545:c5:m6

def _sequence_range_check(self, result, last):

removed = False<EOL>first = result[-<NUM_LIT:2>]<EOL>v1 = ord(first[<NUM_LIT:1>:<NUM_LIT:2>] if len(first) > <NUM_LIT:1> else first)<EOL>v2 = ord(last[<NUM_LIT:1>:<NUM_LIT:2>] if len(last) > <NUM_LIT:1> else last)<EOL>if v2 < v1:<EOL><INDENT>result.pop()<EOL>result.pop()<EOL>removed = True<EOL><DEDENT>else:<EOL><INDENT>result.append(last)<EOL><DEDENT>return removed<EOL>

If range backwards, remove it. A bad range will cause the regular expression to fail, so we need to remove it, but return that we removed it so the caller can know the sequence wasn't empty. Caller will have to craft a sequence that makes sense if empty at the end with either an impossible sequence for inclusive sequences or a sequence that matches everything for an exclusive sequence.

f9545:c5:m7

def _handle_posix(self, i, result, end_range):

last_posix = False<EOL>m = i.match(RE_POSIX)<EOL>if m:<EOL><INDENT>last_posix = True<EOL>if end_range and i.index - <NUM_LIT:1> >= end_range:<EOL><INDENT>result[-<NUM_LIT:1>] = '<STR_LIT:\\>' + result[-<NUM_LIT:1>]<EOL><DEDENT>posix_type = uniprops.POSIX_BYTES if self.is_bytes else uniprops.POSIX<EOL>result.append(uniprops.get_posix_property(m.group(<NUM_LIT:1>), posix_type))<EOL><DEDENT>return last_posix<EOL>

Handle posix classes.

f9545:c5:m8

def _sequence(self, i):

result = ['<STR_LIT:[>']<EOL>end_range = <NUM_LIT:0><EOL>escape_hyphen = -<NUM_LIT:1><EOL>removed = False<EOL>last_posix = False<EOL>c = next(i)<EOL>if c in ('<STR_LIT:!>', '<STR_LIT>'):<EOL><INDENT>result.append('<STR_LIT>')<EOL>c = next(i)<EOL><DEDENT>if c == '<STR_LIT:[>':<EOL><INDENT>last_posix = self._handle_posix(i, result, <NUM_LIT:0>)<EOL>if not last_posix:<EOL><INDENT>result.append(re.escape(c))<EOL><DEDENT>c = next(i)<EOL><DEDENT>elif c in ('<STR_LIT:->', '<STR_LIT:]>'):<EOL><INDENT>result.append(re.escape(c))<EOL>c = next(i)<EOL><DEDENT>while c != '<STR_LIT:]>':<EOL><INDENT>if c == '<STR_LIT:->':<EOL><INDENT>if last_posix:<EOL><INDENT>result.append('<STR_LIT:\\>' + c)<EOL>last_posix = False<EOL><DEDENT>elif i.index - <NUM_LIT:1> > escape_hyphen:<EOL><INDENT>result.append(c)<EOL>escape_hyphen = i.index + <NUM_LIT:1><EOL>end_range = i.index<EOL><DEDENT>elif end_range and i.index - <NUM_LIT:1> >= end_range:<EOL><INDENT>if self._sequence_range_check(result, '<STR_LIT:\\>' + c):<EOL><INDENT>removed = True<EOL><DEDENT>end_range = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>result.append('<STR_LIT:\\>' + c)<EOL><DEDENT>c = next(i)<EOL>continue<EOL><DEDENT>last_posix = False<EOL>if c == '<STR_LIT:[>':<EOL><INDENT>last_posix = self._handle_posix(i, result, end_range)<EOL>if last_posix:<EOL><INDENT>c = next(i)<EOL>continue<EOL><DEDENT><DEDENT>if c == '<STR_LIT:\\>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>value = self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>raise StopIteration<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL>value = r'<STR_LIT:\\>'<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>raise StopIteration<EOL><DEDENT>value = c<EOL><DEDENT>elif c in SET_OPERATORS:<EOL><INDENT>value = '<STR_LIT:\\>' + c<EOL><DEDENT>else:<EOL><INDENT>value = c<EOL><DEDENT>if end_range and i.index - <NUM_LIT:1> >= end_range:<EOL><INDENT>if self._sequence_range_check(result, value):<EOL><INDENT>removed = True<EOL><DEDENT>end_range = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>result.append(value)<EOL><DEDENT>c = next(i)<EOL><DEDENT>result.append('<STR_LIT:]>')<EOL>if removed:<EOL><INDENT>value = "<STR_LIT>".join(result)<EOL>if value == '<STR_LIT>':<EOL><INDENT>result = ['<STR_LIT>' % ('<STR_LIT>' if self.is_bytes else uniprops.UNICODE_RANGE)]<EOL><DEDENT>elif value == '<STR_LIT>':<EOL><INDENT>result = ['<STR_LIT>' % ('<STR_LIT>' if self.is_bytes else uniprops.UNICODE_RANGE)]<EOL><DEDENT>else:<EOL><INDENT>result = [value]<EOL><DEDENT><DEDENT>if self.pathname or self.after_start:<EOL><INDENT>return self._restrict_sequence() + '<STR_LIT>'.join(result)<EOL><DEDENT>return '<STR_LIT>'.join(result)<EOL>

Handle character group.

f9545:c5:m9

def _references(self, i, sequence=False):

value = '<STR_LIT>'<EOL>c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>if sequence and self.bslash_abort:<EOL><INDENT>raise PathNameException<EOL><DEDENT>value = r'<STR_LIT:\\>'<EOL>if self.bslash_abort:<EOL><INDENT>if not self.in_list:<EOL><INDENT>value = self.get_path_sep() + _ONE_OR_MORE<EOL>self.set_start_dir()<EOL><DEDENT>else:<EOL><INDENT>value = self._restrict_extended_slash() + value<EOL><DEDENT><DEDENT><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if sequence and self.pathname:<EOL><INDENT>raise PathNameException<EOL><DEDENT>if self.pathname:<EOL><INDENT>value = r'<STR_LIT:\\>'<EOL>if self.in_list:<EOL><INDENT>value = self._restrict_extended_slash() + value<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>value = re.escape(c)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = re.escape(c)<EOL>if c == '<STR_LIT:.>' and self.after_start and self.in_list:<EOL><INDENT>self.allow_special_dir = True<EOL>self.reset_dir_track()<EOL><DEDENT><DEDENT>return value<EOL>

Handle references.

f9545:c5:m10

def _handle_star(self, i, current):

if self.pathname:<EOL><INDENT>if self.after_start and not self.dot:<EOL><INDENT>star = self.path_star_dot2<EOL>globstar = self.path_gstar_dot2<EOL><DEDENT>elif self.after_start:<EOL><INDENT>star = self.path_star_dot1<EOL>globstar = self.path_gstar_dot1<EOL><DEDENT>else:<EOL><INDENT>star = self.path_star<EOL>globstar = self.path_gstar_dot1<EOL><DEDENT>if self.globstar_capture:<EOL><INDENT>globstar = '<STR_LIT>'.format(globstar)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.after_start and not self.dot:<EOL><INDENT>star = _NO_DOT + _STAR<EOL><DEDENT>else:<EOL><INDENT>star = _STAR<EOL><DEDENT>globstar = '<STR_LIT>'<EOL><DEDENT>value = star<EOL>if self.after_start and self.globstar and not self.in_list:<EOL><INDENT>skip = False<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:*>':<EOL><INDENT>i.rewind(<NUM_LIT:1>)<EOL>raise StopIteration<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>skip = True<EOL><DEDENT>if not skip:<EOL><INDENT>try:<EOL><INDENT>index = i.index<EOL>c = next(i)<EOL>if c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>self._references(i, True)<EOL><DEDENT>except PathNameException:<EOL><INDENT>value = globstar<EOL><DEDENT>except StopIteration:<EOL><INDENT>if self.sep == '<STR_LIT:\\>':<EOL><INDENT>value = globstar<EOL><DEDENT><DEDENT><DEDENT>elif c == '<STR_LIT:/>' and not self.bslash_abort:<EOL><INDENT>value = globstar<EOL><DEDENT>if value != globstar:<EOL><INDENT>i.rewind(i.index - index)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>value = globstar<EOL><DEDENT><DEDENT><DEDENT>if self.after_start and value != globstar:<EOL><INDENT>value = _NEED_CHAR + value<EOL>try:<EOL><INDENT>c = next(i)<EOL>while c == '<STR_LIT:*>':<EOL><INDENT>c = next(i)<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>self.reset_dir_track()<EOL>if value == globstar:<EOL><INDENT>sep = _GLOBSTAR_DIV % self.get_path_sep()<EOL>if current[-<NUM_LIT:1>] != sep:<EOL><INDENT>if current[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>current[-<NUM_LIT:1>] = value<EOL><DEDENT>else:<EOL><INDENT>current[-<NUM_LIT:1>] = _NEED_SEP % self.get_path_sep()<EOL>current.append(value)<EOL><DEDENT>self.consume_path_sep(i)<EOL>current.append(sep)<EOL><DEDENT>self.set_start_dir()<EOL><DEDENT>else:<EOL><INDENT>current.append(value)<EOL><DEDENT>

Handle star.

f9545:c5:m11

def clean_up_inverse(self, current):

if not self.inv_ext:<EOL><INDENT>return<EOL><DEDENT>index = len(current) - <NUM_LIT:1><EOL>while index >= <NUM_LIT:0>:<EOL><INDENT>if isinstance(current[index], InvPlaceholder):<EOL><INDENT>content = current[index + <NUM_LIT:1>:]<EOL>content.append(_EOP if not self.pathname else self.path_eop)<EOL>current[index] = ('<STR_LIT>'.join(content)) + (_EXCLA_GROUP_CLOSE % str(current[index]))<EOL><DEDENT>index -= <NUM_LIT:1><EOL><DEDENT>self.inv_ext = <NUM_LIT:0><EOL>

Clean up current. Python doesn't have variable lookbehinds, so we have to do negative lookaheads. !(...) when converted to regular expression is atomic, so once it matches, that's it. So we use the pattern `(?:(?!(?:stuff|to|exclude)<x>))[^/]*?)` where <x> is everything that comes after the negative group. `!(this|that)other` --> `(?:(?!(?:this|that)other))[^/]*?)`. We have to update the list before | in nested cases: *(!(...)|stuff). Before we close a parent `extmatch`: `*(!(...))`. And of course on path separators (when path mode is on): `!(...)/stuff`. Lastly we make sure all is accounted for when finishing the pattern at the end. If there is nothing to store, we store `$`: `(?:(?!(?:this|that)$))[^/]*?)`.

f9545:c5:m12

def parse_extend(self, c, i, current, reset_dot=False):

<EOL>temp_dir_start = self.dir_start<EOL>temp_after_start = self.after_start<EOL>temp_in_list = self.in_list<EOL>temp_inv_ext = self.inv_ext<EOL>self.in_list = True<EOL>if reset_dot:<EOL><INDENT>self.allow_special_dir = False<EOL><DEDENT>success = True<EOL>index = i.index<EOL>list_type = c<EOL>extended = []<EOL>try:<EOL><INDENT>c = next(i)<EOL>if c != '<STR_LIT:(>':<EOL><INDENT>raise StopIteration<EOL><DEDENT>while c != '<STR_LIT:)>':<EOL><INDENT>c = next(i)<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i, extended):<EOL><INDENT>pass<EOL><DEDENT>elif c == '<STR_LIT:*>':<EOL><INDENT>self._handle_star(i, extended)<EOL><DEDENT>elif c == '<STR_LIT:.>' and self.after_start:<EOL><INDENT>extended.append(re.escape(c))<EOL>self.allow_special_dir = True<EOL>self.reset_dir_track()<EOL><DEDENT>elif c == '<STR_LIT:?>':<EOL><INDENT>extended.append(self._restrict_sequence() + _QMARK)<EOL><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>extended.append(self._restrict_extended_slash())<EOL><DEDENT>extended.append(re.escape(c))<EOL><DEDENT>elif c == "<STR_LIT:|>":<EOL><INDENT>self.clean_up_inverse(extended)<EOL>extended.append(c)<EOL>if temp_after_start:<EOL><INDENT>self.set_start_dir()<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:\\>':<EOL><INDENT>try:<EOL><INDENT>extended.append(self._references(i))<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>subindex = i.index<EOL>try:<EOL><INDENT>extended.append(self._sequence(i))<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - subindex)<EOL>extended.append(r'<STR_LIT>')<EOL><DEDENT><DEDENT>elif c != '<STR_LIT:)>':<EOL><INDENT>extended.append(re.escape(c))<EOL><DEDENT>self.update_dir_state()<EOL><DEDENT>self.clean_up_inverse(extended)<EOL>if list_type == '<STR_LIT:?>':<EOL><INDENT>current.append(_QMARK_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:*>':<EOL><INDENT>current.append(_STAR_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:+>':<EOL><INDENT>current.append(_PLUS_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:@>':<EOL><INDENT>current.append(_GROUP % '<STR_LIT>'.join(extended))<EOL><DEDENT>elif list_type == '<STR_LIT:!>':<EOL><INDENT>self.inv_ext += <NUM_LIT:1><EOL>current.append(_EXCLA_GROUP % '<STR_LIT>'.join(extended))<EOL>if self.pathname:<EOL><INDENT>if not temp_after_start or self.allow_special_dir:<EOL><INDENT>star = self.path_star<EOL><DEDENT>elif temp_after_start and not self.dot:<EOL><INDENT>star = self.path_star_dot2<EOL><DEDENT>else:<EOL><INDENT>star = self.path_star_dot1<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not temp_after_start or self.dot:<EOL><INDENT>star = _STAR<EOL><DEDENT>else:<EOL><INDENT>star = _NO_DOT + _STAR<EOL><DEDENT><DEDENT>if temp_after_start:<EOL><INDENT>star = _NEED_CHAR + star<EOL><DEDENT>current.append(InvPlaceholder(star))<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>success = False<EOL>self.inv_ext = temp_inv_ext<EOL>i.rewind(i.index - index)<EOL><DEDENT>if not temp_in_list:<EOL><INDENT>self.in_list = False<EOL><DEDENT>if success:<EOL><INDENT>self.reset_dir_track()<EOL><DEDENT>else:<EOL><INDENT>self.dir_start = temp_dir_start<EOL>self.after_start = temp_after_start<EOL><DEDENT>return success<EOL>

Parse extended pattern lists.

f9545:c5:m13

def get_path_sep(self):

return re.escape(self.sep)<EOL>

Get path separator.

f9545:c5:m14

def consume_path_sep(self, i):

try:<EOL><INDENT>if self.bslash_abort:<EOL><INDENT>count = -<NUM_LIT:1><EOL>c = '<STR_LIT:\\>'<EOL>while c == '<STR_LIT:\\>':<EOL><INDENT>count += <NUM_LIT:1><EOL>c = next(i)<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL>if count > <NUM_LIT:0> and count % <NUM_LIT:2>:<EOL><INDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>c = '<STR_LIT:/>'<EOL>while c == '<STR_LIT:/>':<EOL><INDENT>c = next(i)<EOL><DEDENT>i.rewind(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT>

Consume any consecutive path separators are they count as one.

f9545:c5:m15

def root(self, pattern, current):

self.set_after_start()<EOL>i = util.StringIter(pattern)<EOL>iter(i)<EOL>root_specified = False<EOL>if self.win_drive_detect:<EOL><INDENT>m = RE_WIN_PATH.match(pattern)<EOL>if m:<EOL><INDENT>drive = m.group(<NUM_LIT:0>).replace('<STR_LIT>', '<STR_LIT:\\>')<EOL>if drive.endswith('<STR_LIT:\\>'):<EOL><INDENT>slash = True<EOL><DEDENT>drive = drive[:-<NUM_LIT:1>]<EOL>current.append(re.escape(drive))<EOL>if slash:<EOL><INDENT>current.append(self.get_path_sep() + _ONE_OR_MORE)<EOL><DEDENT>i.advance(m.end(<NUM_LIT:0>))<EOL>self.consume_path_sep(i)<EOL>root_specified = True<EOL><DEDENT>elif pattern.startswith('<STR_LIT>'):<EOL><INDENT>root_specified = True<EOL><DEDENT><DEDENT>elif not self.win_drive_detect and self.pathname and pattern.startswith('<STR_LIT:/>'):<EOL><INDENT>root_specified = True<EOL><DEDENT>if not root_specified and self.realpath:<EOL><INDENT>current.append(_NO_WIN_ROOT if self.win_drive_detect else _NO_ROOT)<EOL>current.append('<STR_LIT>')<EOL><DEDENT>for c in i:<EOL><INDENT>index = i.index<EOL>if self.extend and c in EXT_TYPES and self.parse_extend(c, i, current, True):<EOL><INDENT>pass<EOL><DEDENT>elif c == '<STR_LIT:*>':<EOL><INDENT>self._handle_star(i, current)<EOL><DEDENT>elif c == '<STR_LIT:?>':<EOL><INDENT>current.append(self._restrict_sequence() + _QMARK)<EOL><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>if self.pathname:<EOL><INDENT>self.set_start_dir()<EOL>self.clean_up_inverse(current)<EOL>current.append(self.get_path_sep() + _ONE_OR_MORE)<EOL>self.consume_path_sep(i)<EOL><DEDENT>else:<EOL><INDENT>current.append(re.escape(c))<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:\\>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>value = self._references(i)<EOL>if self.dir_start:<EOL><INDENT>self.clean_up_inverse(current)<EOL>self.consume_path_sep(i)<EOL><DEDENT>current.append(value)<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL>current.append(re.escape(c))<EOL><DEDENT><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>index = i.index<EOL>try:<EOL><INDENT>current.append(self._sequence(i))<EOL><DEDENT>except StopIteration:<EOL><INDENT>i.rewind(i.index - index)<EOL>current.append(re.escape(c))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>current.append(re.escape(c))<EOL><DEDENT>self.update_dir_state()<EOL><DEDENT>self.clean_up_inverse(current)<EOL>if self.pathname:<EOL><INDENT>current.append(_PATH_TRAIL % self.get_path_sep())<EOL><DEDENT>

Start parsing the pattern.

f9545:c5:m16

def parse(self):

result = ['<STR_LIT>']<EOL>negative = False<EOL>p = util.norm_pattern(self.pattern, not self.unix, self.raw_chars)<EOL>p = p.decode('<STR_LIT>') if self.is_bytes else p<EOL>if is_negative(p, self.flags):<EOL><INDENT>negative = True<EOL>p = p[<NUM_LIT:1>:]<EOL><DEDENT>self.root(p, result)<EOL>case_flag = '<STR_LIT:i>' if not self.case_sensitive else '<STR_LIT>'<EOL>if util.PY36:<EOL><INDENT>pattern = (<EOL>r'<STR_LIT>' if negative and not self.globstar_capture else r'<STR_LIT>'<EOL>) % (case_flag, '<STR_LIT>'.join(result))<EOL><DEDENT>else:<EOL><INDENT>pattern = (<EOL>r'<STR_LIT>' if negative and not self.globstar_capture else r'<STR_LIT>'<EOL>) % (case_flag, '<STR_LIT>'.join(result))<EOL><DEDENT>if self.is_bytes:<EOL><INDENT>pattern = pattern.encode('<STR_LIT>')<EOL><DEDENT>return pattern<EOL>

Parse pattern list.

f9545:c5:m17

def __init__(self, include, exclude=None, real=False, path=False, follow=False):

super(WcRegexp, self).__init__(<EOL>_include=include,<EOL>_exclude=exclude,<EOL>_real=real,<EOL>_path=path,<EOL>_follow=follow,<EOL>_hash=hash(<EOL>(<EOL>type(self),<EOL>type(include), include,<EOL>type(exclude), exclude,<EOL>type(real), real,<EOL>type(path), path,<EOL>type(follow), follow<EOL>)<EOL>)<EOL>)<EOL>

Initialization.

f9545:c6:m0

def __hash__(self):

return self._hash<EOL>

Hash.

f9545:c6:m1

def __eq__(self, other):

return (<EOL>isinstance(other, WcRegexp) and<EOL>self._include == other._include and<EOL>self._exclude == other._exclude and<EOL>self._real == other._real and<EOL>self._path == other._path and<EOL>self._follow == other._follow<EOL>)<EOL>

Equal.

f9545:c6:m2

def __ne__(self, other):

return (<EOL>not isinstance(other, WcRegexp) or<EOL>self._include != other._include or<EOL>self._exclude != other._exclude or<EOL>self._real != other._real or<EOL>self._path != other._path or<EOL>self._follow != other._follow<EOL>)<EOL>

Equal.

f9545:c6:m3

def match(self, filename):

return _match_pattern(filename, self._include, self._exclude, self._real, self._path, self._follow)<EOL>

Match filename.

f9545:c6:m4

def parse_version(ver, pre=False):

m = RE_VER.match(ver)<EOL>major = int(m.group('<STR_LIT>'))<EOL>minor = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>micro = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT:type>'):<EOL><INDENT>release = PRE_REL_MAP[m.group('<STR_LIT:type>')]<EOL>pre = int(m.group('<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>release = "<STR_LIT>"<EOL>pre = <NUM_LIT:0><EOL><DEDENT>dev = m.group('<STR_LIT>') if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT>'):<EOL><INDENT>dev = int(m.group('<STR_LIT>'))<EOL>release = '<STR_LIT>' + release if pre else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>dev = <NUM_LIT:0><EOL><DEDENT>post = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>return Version(major, minor, micro, release, pre, post, dev)<EOL>

Parse version into a comparable Version tuple.

f9546:m0

def __new__(cls, major, minor, micro, release="<STR_LIT>", pre=<NUM_LIT:0>, post=<NUM_LIT:0>, dev=<NUM_LIT:0>):

<EOL>for value in (major, minor, micro, pre, post):<EOL><INDENT>if not (isinstance(value, int) and value >= <NUM_LIT:0>):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>if release not in REL_MAP:<EOL><INDENT>raise ValueError("<STR_LIT>".format(release))<EOL><DEDENT>if "<STR_LIT>" < release < "<STR_LIT>":<EOL><INDENT>if pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>elif release < "<STR_LIT>":<EOL><INDENT>if release > "<STR_LIT>" and pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if pre:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>return super(Version, cls).__new__(cls, major, minor, micro, release, pre, post, dev)<EOL>

Validate version info.

f9546:c0:m0

def _is_pre(self):

return self.pre > <NUM_LIT:0><EOL>

Is prerelease.

f9546:c0:m1

def _is_dev(self):

return bool(self.release < "<STR_LIT>")<EOL>

Is development.

f9546:c0:m2

def _is_post(self):

return self.post > <NUM_LIT:0><EOL>

Is post.

f9546:c0:m3

def _get_dev_status(self):

return DEV_STATUS[self.release]<EOL>

Get development status string.

f9546:c0:m4

def _get_canonical(self):

<EOL>if self.micro == <NUM_LIT:0>:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor)<EOL><DEDENT>else:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor, self.micro)<EOL><DEDENT>if self._is_pre():<EOL><INDENT>ver += '<STR_LIT>'.format(REL_MAP[self.release], self.pre)<EOL><DEDENT>if self._is_post():<EOL><INDENT>ver += "<STR_LIT>".format(self.post)<EOL><DEDENT>if self._is_dev():<EOL><INDENT>ver += "<STR_LIT>".format(self.dev)<EOL><DEDENT>return ver<EOL>

Get the canonical output string.

f9546:c0:m5

def __init__(self, *args, **kwargs):

args = list(args)<EOL>self._skipped = <NUM_LIT:0><EOL>self._abort = False<EOL>self._directory = util.norm_slash(args.pop(<NUM_LIT:0>))<EOL>self.is_bytes = isinstance(self._directory, bytes)<EOL>if not self._directory:<EOL><INDENT>if self.is_bytes:<EOL><INDENT>curdir = bytes(os.curdir, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>curdir = os.curdir<EOL><DEDENT><DEDENT>else:<EOL><INDENT>curdir = self._directory<EOL><DEDENT>self.sep = os.fsencode(os.sep) if self.is_bytes else os.sep<EOL>self.base = curdir if curdir.endswith(self.sep) else curdir + self.sep<EOL>self.file_pattern = args.pop(<NUM_LIT:0>) if args else kwargs.pop('<STR_LIT>', b'<STR_LIT>' if self.is_bytes else '<STR_LIT>')<EOL>if not self.file_pattern:<EOL><INDENT>self.file_pattern = _wcparse.WcRegexp(<EOL>(re.compile(br'<STR_LIT>', re.DOTALL),) if self.is_bytes else (re.compile(r'<STR_LIT>', re.DOTALL),)<EOL>)<EOL><DEDENT>self.exclude_pattern = args.pop(<NUM_LIT:0>) if args else kwargs.pop('<STR_LIT>', b'<STR_LIT>' if self.is_bytes else '<STR_LIT>')<EOL>self.flags = (args.pop(<NUM_LIT:0>) if args else kwargs.pop('<STR_LIT>', <NUM_LIT:0>)) & FLAG_MASK<EOL>self.flags |= _wcparse.NEGATE | _wcparse.DOTMATCH<EOL>self.follow_links = bool(self.flags & SYMLINKS)<EOL>self.show_hidden = bool(self.flags & HIDDEN)<EOL>self.recursive = bool(self.flags & RECURSIVE)<EOL>self.dir_pathname = bool(self.flags & DIRPATHNAME)<EOL>self.file_pathname = bool(self.flags & FILEPATHNAME)<EOL>if util.platform() == "<STR_LIT>":<EOL><INDENT>self.flags |= _wcparse._FORCEWIN<EOL><DEDENT>self.flags = self.flags & (_wcparse.FLAG_MASK ^ (SYMLINKS | DIRPATHNAME | FILEPATHNAME | HIDDEN))<EOL>self.on_init(*args, **kwargs)<EOL>self.file_check, self.folder_exclude_check = self._compile(self.file_pattern, self.exclude_pattern)<EOL>

Initialize the directory walker object.

f9547:c0:m0

def _compile_wildcard(self, pattern, pathname=False):

patterns = None<EOL>flags = self.flags<EOL>if pathname:<EOL><INDENT>flags |= _wcparse.PATHNAME<EOL><DEDENT>if pattern:<EOL><INDENT>patterns = _wcparse.WcSplit(pattern, flags=flags).split()<EOL><DEDENT>return _wcparse.compile(patterns, flags) if patterns else patterns<EOL>

Compile or format the wildcard inclusion/exclusion pattern.

f9547:c0:m1

def _compile(self, file_pattern, folder_exclude_pattern):

if not isinstance(file_pattern, _wcparse.WcRegexp):<EOL><INDENT>file_pattern = self._compile_wildcard(file_pattern, self.file_pathname)<EOL><DEDENT>if not isinstance(folder_exclude_pattern, _wcparse.WcRegexp):<EOL><INDENT>folder_exclude_pattern = self._compile_wildcard(folder_exclude_pattern, self.dir_pathname)<EOL><DEDENT>return file_pattern, folder_exclude_pattern<EOL>

Compile patterns.

f9547:c0:m2

def _valid_file(self, base, name):

valid = False<EOL>fullpath = os.path.join(base, name)<EOL>if self.file_check is not None and self.compare_file(fullpath[self._base_len:] if self.file_pathname else name):<EOL><INDENT>valid = True<EOL><DEDENT>if valid and (not self.show_hidden and util.is_hidden(fullpath)):<EOL><INDENT>valid = False<EOL><DEDENT>return self.on_validate_file(base, name) if valid else valid<EOL>

Return whether a file can be searched.

f9547:c0:m3

def compare_file(self, filename):

return self.file_check.match(filename)<EOL>

Compare filename.

f9547:c0:m4

def on_validate_file(self, base, name):

return True<EOL>

Validate file override.

f9547:c0:m5

def _valid_folder(self, base, name):

valid = True<EOL>fullpath = os.path.join(base, name)<EOL>if (<EOL>not self.recursive or<EOL>(<EOL>self.folder_exclude_check is not None and<EOL>not self.compare_directory(fullpath[self._base_len:] if self.dir_pathname else name)<EOL>)<EOL>):<EOL><INDENT>valid = False<EOL><DEDENT>if valid and (not self.show_hidden and util.is_hidden(fullpath)):<EOL><INDENT>valid = False<EOL><DEDENT>return self.on_validate_directory(base, name) if valid else valid<EOL>

Return whether a folder can be searched.

f9547:c0:m6

def compare_directory(self, directory):

return not self.folder_exclude_check.match(directory + self.sep if self.dir_pathname else directory)<EOL>

Compare folder.

f9547:c0:m7

def on_init(self, *args, **kwargs):

Handle custom initialization.

f9547:c0:m8

def on_validate_directory(self, base, name):

return True<EOL>

Validate folder override.

f9547:c0:m9

def on_skip(self, base, name):

return None<EOL>

On skip.

f9547:c0:m10

def on_error(self, base, name):

return None<EOL>

On error.

f9547:c0:m11

def on_match(self, base, name):

return os.path.join(base, name)<EOL>

On match.

f9547:c0:m12

def get_skipped(self):

return self._skipped<EOL>

Get number of skipped files.

f9547:c0:m13