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>retur... | 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 & FIL... | 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... | 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>":... | 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():... | 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(_... | 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(patte... | 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(ex... | 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>... | 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 Non... | 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_m... | 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><DED... | 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... | 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>exce... | 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:<E... | 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 == ... | 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('<ST... | 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>exce... | 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><DE... | 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 == ... | 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>sp... | 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... | 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()<... | 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... | 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 seque... | 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(unip... | 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... | 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(... | 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 = ... | 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] = ('<S... | 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|tha... | 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:<EO... | 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:... | 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<... | 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>' i... | 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... | 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>":... | 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():... | 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... | 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><DE... | 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 s... | 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 u... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.