Commit ⋅ facelessuser/wcmatch

@@ -4,6 +4,7 @@

Loading

import stat
import copyreg
from . import util
from typing import Pattern, Tuple, AnyStr, Optional, Generic, Any, Dict, cast

# `O_DIRECTORY` may not always be defined
DIR_FLAGS = os.O_RDONLY | getattr(os, 'O_DIRECTORY', 0)

@@ -21,22 +22,39 @@

Loading

)


class _Match:
class _Match(Generic[AnyStr]):
    """Match the given pattern."""

    def __init__(self, filename, include, exclude, real, path, follow):
    def __init__(
        self,
        filename: AnyStr,
        include: Tuple[Pattern[AnyStr], ...],
        exclude: Optional[Tuple[Pattern[AnyStr], ...]],
        real: bool,
        path: bool,
        follow: bool
    ) -> None:
        """Initialize."""

        self.filename = filename
        self.include = include
        self.exclude = exclude
        self.filename = filename  # type: AnyStr
        self.include = include  # type: Tuple[Pattern[AnyStr], ...]
        self.exclude = exclude  # type: Optional[Tuple[Pattern[AnyStr], ...]]
        self.real = real
        self.path = path
        self.follow = follow
        self.is_bytes = isinstance(self.filename, bytes)
        self.ptype = util.BYTES if self.is_bytes else util.UNICODE

    def _fs_match(self, pattern, filename, is_dir, sep, follow, symlinks, root, dir_fd):
        self.ptype = util.BYTES if isinstance(self.filename, bytes) else util.UNICODE

    def _fs_match(
        self,
        pattern: Pattern[AnyStr],
        filename: AnyStr,
        is_dir: bool,
        sep: AnyStr,
        follow: bool,
        symlinks: Dict[Tuple[Optional[int], AnyStr], bool],
        root: AnyStr,
        dir_fd: Optional[int]
    ) -> bool:
        """
        Match path against the pattern.


@@ -98,12 +116,19 @@

Loading

                    matched = False
        return matched

    def _match_real(self, symlinks, root, dir_fd):
    def _match_real(
        self,
        symlinks: Dict[Tuple[Optional[int], AnyStr], bool],
        root: AnyStr,
        dir_fd: Optional[int]
    ) -> bool:
        """Match real filename includes and excludes."""

        sep = '\\' if util.platform() == "windows" else '/'
        temp = '\\' if util.platform() == "windows" else '/'
        if isinstance(self.filename, bytes):
            sep = os.fsencode(sep)
            sep = os.fsencode(temp)
        else:
            sep = temp

        is_dir = self.filename.endswith(sep)
        try:

@@ -140,11 +165,14 @@

Loading


        return matched

    def match(self, root_dir=None, dir_fd=None):
    def match(self, root_dir: Optional[AnyStr] = None, dir_fd: Optional[int] = None) -> bool:
        """Match."""

        if self.real:
            root = root_dir if root_dir else (b'.' if self.is_bytes else '.')
            if isinstance(self.filename, bytes):
                root = root_dir if root_dir is not None else b'.'  # type: AnyStr
            else:
                root = root_dir if root_dir is not None else '.'

            if dir_fd is not None and not SUPPORT_DIR_FD:
                dir_fd = None

@@ -163,9 +191,8 @@

Loading

                    )
                )

            is_abs = (
                RE_WIN_MOUNT if util.platform() == "windows" else RE_MOUNT
            )[self.ptype].match(self.filename) is not None
            re_mount = cast(Pattern[AnyStr], (RE_WIN_MOUNT if util.platform() == "windows" else RE_MOUNT)[self.ptype])
            is_abs = re_mount.match(self.filename) is not None

            if is_abs:
                exists = os.path.lexists(self.filename)

@@ -180,7 +207,7 @@

Loading

                    exists = True

            if exists:
                symlinks = {}
                symlinks = {}  # type: Dict[Tuple[Optional[int], AnyStr], bool]
                return self._match_real(symlinks, root, dir_fd)
            else:
                return False

@@ -201,15 +228,29 @@

Loading

        return matched


class WcRegexp(util.Immutable):
class WcRegexp(util.Immutable, Generic[AnyStr]):
    """File name match object."""

    _include: Tuple[Pattern[AnyStr], ...]
    _exclude: Optional[Tuple[Pattern[AnyStr], ...]]
    _real: bool
    _path: bool
    _follow: bool
    _hash: int

    __slots__ = ("_include", "_exclude", "_real", "_path", "_follow", "_hash")

    def __init__(self, include, exclude=None, real=False, path=False, follow=False):
    def __init__(
        self,
        include: Tuple[Pattern[AnyStr], ...],
        exclude: Optional[Tuple[Pattern[AnyStr], ...]] = None,
        real: bool = False,
        path: bool = False,
        follow: bool = False
    ):
        """Initialization."""

        super(WcRegexp, self).__init__(
        super().__init__(
            _include=include,
            _exclude=exclude,
            _real=real,

@@ -227,17 +268,17 @@

Loading

            )
        )

    def __hash__(self):
    def __hash__(self) -> int:
        """Hash."""

        return self._hash

    def __len__(self):
    def __len__(self) -> int:
        """Length."""

        return len(self._include) + (len(self._exclude) if self._exclude is not None else 0)

    def __eq__(self, other):
    def __eq__(self, other: Any) -> bool:
        """Equal."""

        return (

@@ -249,7 +290,7 @@

Loading

            self._follow == other._follow
        )

    def __ne__(self, other):
    def __ne__(self, other: Any) -> bool:
        """Equal."""

        return (

@@ -261,7 +302,7 @@

Loading

            self._follow != other._follow
        )

    def match(self, filename, root_dir=None, dir_fd=None):
    def match(self, filename: AnyStr, root_dir: Optional[AnyStr] = None, dir_fd: Optional[int] = None) -> bool:
        """Match filename."""

        return _Match(

@@ -277,7 +318,7 @@

Loading

        )


def _pickle(p):
def _pickle(p):  # type: ignore[no-untyped-def]
    return WcRegexp, (p._include, p._exclude, p._real, p._path, p._follow)



@@ -7,6 +7,7 @@

Loading

import unicodedata
from functools import wraps
import warnings
from typing import Any, Callable, Tuple, AnyStr, Match, Pattern, Optional, cast

PY37 = (3, 7) <= sys.version_info
PY310 = (3, 10) <= sys.version_info

@@ -64,25 +65,19 @@

Loading

    _PLATFORM = "linux"


def platform():
def platform() -> str:
    """Get platform."""

    return _PLATFORM


def is_case_sensitive():
def is_case_sensitive() -> bool:
    """Check if case sensitive."""

    return CASE_FS


def to_tuple(values):
    """Combine values."""

    return (values,) if isinstance(values, (str, bytes)) else tuple(values)


def norm_pattern(pattern, normalize, is_raw_chars, ignore_escape=False):
def norm_pattern(pattern: AnyStr, normalize: Optional[bool], is_raw_chars: bool, ignore_escape: bool = False) -> AnyStr:
    r"""
    Normalize pattern.


@@ -92,59 +87,68 @@

Loading

    - If `normalize` is enabled, take care to convert \/ to \\\\.
    """

    is_bytes = isinstance(pattern, bytes)
    if isinstance(pattern, bytes):
        is_bytes = True
        slash = b'\\'
        multi_slash = slash * 4
        pat = RE_BNORM
    else:
        is_bytes = False
        slash = '\\'
        multi_slash = slash * 4
        pat = RE_NORM

    if not normalize and not is_raw_chars and not ignore_escape:
        return pattern

    def norm(m):
    def norm(m: Match[AnyStr]) -> AnyStr:
        """Normalize the pattern."""

        if m.group(1):
            char = m.group(1)
            if normalize:
                char = br'\\\\' if is_bytes else r'\\\\' if len(char) > 1 else char
            if normalize and len(char) > 1:
                char = multi_slash
        elif m.group(2):
            char = BACK_SLASH_TRANSLATION[m.group(2)] if is_raw_chars else m.group(2)
            char = cast(AnyStr, BACK_SLASH_TRANSLATION[m.group(2)] if is_raw_chars else m.group(2))
        elif is_raw_chars and m.group(4):
            char = bytes([int(m.group(4), 8) & 0xFF]) if is_bytes else chr(int(m.group(4), 8))
            char = cast(AnyStr, bytes([int(m.group(4), 8) & 0xFF]) if is_bytes else chr(int(m.group(4), 8)))
        elif is_raw_chars and m.group(3):
            char = bytes([int(m.group(3)[2:], 16)]) if is_bytes else chr(int(m.group(3)[2:], 16))
            char = cast(AnyStr, bytes([int(m.group(3)[2:], 16)]) if is_bytes else chr(int(m.group(3)[2:], 16)))
        elif is_raw_chars and not is_bytes and m.group(5):
            char = unicodedata.lookup(m.group(5)[3:-1])
            char = unicodedata.lookup(m.group(5)[3:-1])  # type: ignore[assignment]
        elif not is_raw_chars or m.group(5 if is_bytes else 6):
            char = m.group(0)
            if ignore_escape:
                char = (b'\\' if is_bytes else '\\') + char
                char = slash + char
        else:
            value = m.group(6) if is_bytes else m.group(7)
            pos = m.start(6) if is_bytes else m.start(7)
            raise SyntaxError("Could not convert character value {} at position {:d}".format(value, pos))
            raise SyntaxError("Could not convert character value {!r} at position {:d}".format(value, pos))
        return char

    return (RE_BNORM if is_bytes else RE_NORM).sub(norm, pattern)
    return pat.sub(norm, pattern)


class StringIter(object):
class StringIter:
    """Preprocess replace tokens."""

    def __init__(self, string):
    def __init__(self, string: str) -> None:
        """Initialize."""

        self._string = string
        self._index = 0

    def __iter__(self):
    def __iter__(self) -> "StringIter":
        """Iterate."""

        return self

    def __next__(self):
    def __next__(self) -> str:
        """Python 3 iterator compatible next."""

        return self.iternext()

    def match(self, pattern):
    def match(self, pattern: Pattern[str]) -> Optional[Match[str]]:
        """Perform regex match at index."""

        m = pattern.match(self._string, self._index)

@@ -153,22 +157,22 @@

Loading

        return m

    @property
    def index(self):
    def index(self) -> int:
        """Get current index."""

        return self._index

    def previous(self):  # pragma: no cover
    def previous(self) -> str:  # pragma: no cover
        """Get previous char."""

        return self._string[self._index - 1]

    def advance(self, count):  # pragma: no cover
    def advance(self, count: int) -> None:  # pragma: no cover
        """Advanced the index."""

        self._index += count

    def rewind(self, count):
    def rewind(self, count: int) -> None:
        """Rewind index."""

        if count > self._index:  # pragma: no cover

@@ -176,7 +180,7 @@

Loading


        self._index -= count

    def iternext(self):
    def iternext(self) -> str:
        """Iterate through characters of the string."""

        try:

@@ -188,24 +192,24 @@

Loading

        return char


class Immutable(object):
class Immutable:
    """Immutable."""

    __slots__ = tuple()
    __slots__: Tuple[Any, ...] = tuple()

    def __init__(self, **kwargs):
    def __init__(self, **kwargs: Any) -> None:
        """Initialize."""

        for k, v in kwargs.items():
            super(Immutable, self).__setattr__(k, v)

    def __setattr__(self, name, value):  # pragma: no cover
    def __setattr__(self, name: str, value: Any) -> None:  # pragma: no cover
        """Prevent mutability."""

        raise AttributeError('Class is immutable!')


def is_hidden(path):
def is_hidden(path: AnyStr) -> bool:
    """Check if file is hidden."""

    hidden = False

@@ -213,19 +217,19 @@

Loading

    if f[:1] in ('.', b'.'):
        # Count dot file as hidden on all systems
        hidden = True
    elif _PLATFORM == 'windows':
    elif sys.platform == 'win32':
        # On Windows, look for `FILE_ATTRIBUTE_HIDDEN`
        FILE_ATTRIBUTE_HIDDEN = 0x2
        results = os.lstat(path)
        FILE_ATTRIBUTE_HIDDEN = 0x2
        hidden = bool(results.st_file_attributes & FILE_ATTRIBUTE_HIDDEN)
    elif _PLATFORM == "osx":  # pragma: no cover
    elif sys.platform == "darwin":  # pragma: no cover
        # On macOS, look for `UF_HIDDEN`
        results = os.lstat(path)
        hidden = bool(results.st_flags & stat.UF_HIDDEN)
    return hidden


def deprecated(message, stacklevel=2):  # pragma: no cover
def deprecated(message: str, stacklevel: int = 2) -> Callable[..., Any]:  # pragma: no cover
    """
    Raise a `DeprecationWarning` when wrapped function/method is called.


@@ -236,9 +240,9 @@

Loading

            pass
    """

    def _wrapper(func):
    def _wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
        @wraps(func)
        def _deprecated_func(*args, **kwargs):
        def _deprecated_func(*args: Any, **kwargs: Any) -> Any:
            warnings.warn(
                f"'{func.__name__}' is deprecated. {message}",
                category=DeprecationWarning,

@@ -249,7 +253,7 @@

Loading

    return _wrapper


def warn_deprecated(message, stacklevel=2):  # pragma: no cover
def warn_deprecated(message: str, stacklevel: int = 2) -> None:  # pragma: no cover
    """Warn deprecated."""

    warnings.warn(

@@ -21,5 +21,3 @@

Loading

IN THE SOFTWARE.
"""
from .__meta__ import __version_info__, __version__  # noqa: F401

__all__ = tuple()

@@ -27,6 +27,7 @@

Loading

from . import util
from . import posix
from . _wcmatch import WcRegexp
from typing import List, Tuple, AnyStr, Iterable, Pattern, Generic, Optional, Set, Sequence, Union, cast

UNICODE_RANGE = '\u0000-\U0010ffff'
ASCII_RANGE = '\x00-\xff'

@@ -298,7 +299,16 @@

Loading

    """Pattern limit exception."""


def escape(pattern, unix=None, pathname=True, raw=False):
def to_str_sequence(patterns: Union[str, bytes, Sequence[AnyStr]]) -> Sequence[AnyStr]:
    """Return a simple string sequence."""

    if isinstance(patterns, (str, bytes)):
        return cast(Sequence[AnyStr], [patterns])
    else:
        return patterns


def escape(pattern: AnyStr, unix: Optional[bool] = None, pathname: bool = True, raw: bool = False) -> AnyStr:
    """
    Escape.


@@ -309,17 +319,17 @@

Loading

    """

    if isinstance(pattern, bytes):
        drive_pat = RE_WIN_DRIVE[util.BYTES]
        magic = RE_MAGIC_ESCAPE[util.BYTES]
        drive_magic = RE_WIN_DRIVE_MAGIC[util.BYTES]
        drive_pat = cast(Pattern[AnyStr], RE_WIN_DRIVE[util.BYTES])
        magic = cast(Pattern[AnyStr], RE_MAGIC_ESCAPE[util.BYTES])
        drive_magic = cast(Pattern[AnyStr], RE_WIN_DRIVE_MAGIC[util.BYTES])
        replace = br'\\\1'
        slash = b'\\'
        double_slash = b'\\\\'
        drive = b''
    else:
        drive_pat = RE_WIN_DRIVE[util.UNICODE]
        magic = RE_MAGIC_ESCAPE[util.UNICODE]
        drive_magic = RE_WIN_DRIVE_MAGIC[util.UNICODE]
        drive_pat = cast(Pattern[AnyStr], RE_WIN_DRIVE[util.UNICODE])
        magic = cast(Pattern[AnyStr], RE_MAGIC_ESCAPE[util.UNICODE])
        drive_magic = cast(Pattern[AnyStr], RE_WIN_DRIVE_MAGIC[util.UNICODE])
        replace = r'\\\1'
        slash = '\\'
        double_slash = '\\\\'

@@ -345,7 +355,11 @@

Loading

    return drive + magic.sub(replace, pattern)


def _get_win_drive(pattern, regex=False, case_sensitive=False):
def _get_win_drive(
    pattern: str,
    regex: bool = False,
    case_sensitive: bool = False
) -> Tuple[bool, Optional[str], bool, int]:
    """Get Windows drive."""

    drive = None

@@ -392,47 +406,56 @@

Loading

    return root_specified, drive, slash, end


def _get_magic_symbols(ptype, unix, flags):
def _get_magic_symbols(pattern: AnyStr, unix: bool, flags: int) -> Tuple[Set[AnyStr], Set[AnyStr]]:
    """Get magic symbols."""

    if ptype == util.BYTES:
        slash = b'\\'
    if isinstance(pattern, bytes):
        ptype = util.BYTES
        slash = b'\\'  # type: AnyStr
    else:
        ptype = util.UNICODE
        slash = '\\'

    magic = set()
    magic_drive = set() if unix else set(slash)
    magic = set()  # type: Set[AnyStr]
    if unix:
        magic_drive = set()  # type: Set[AnyStr]
    else:
        magic_drive = set([slash])

    magic |= MAGIC_DEF[ptype]
    magic |= cast(Set[AnyStr], MAGIC_DEF[ptype])
    if flags & BRACE:
        magic |= MAGIC_BRACE[ptype]
        magic_drive |= MAGIC_BRACE[ptype]
        magic |= cast(Set[AnyStr], MAGIC_BRACE[ptype])
        magic_drive |= cast(Set[AnyStr], MAGIC_BRACE[ptype])
    if flags & SPLIT:
        magic |= MAGIC_SPLIT[ptype]
        magic_drive |= MAGIC_SPLIT[ptype]
        magic |= cast(Set[AnyStr], MAGIC_SPLIT[ptype])
        magic_drive |= cast(Set[AnyStr], MAGIC_SPLIT[ptype])
    if flags & GLOBTILDE:
        magic |= MAGIC_TILDE[ptype]
        magic |= cast(Set[AnyStr], MAGIC_TILDE[ptype])
    if flags & EXTMATCH:
        magic |= MAGIC_EXTMATCH[ptype]
        magic |= cast(Set[AnyStr], MAGIC_EXTMATCH[ptype])
    if flags & NEGATE:
        if flags & MINUSNEGATE:
            magic |= MAGIC_MINUS_NEGATE[ptype]
            magic |= cast(Set[AnyStr], MAGIC_MINUS_NEGATE[ptype])
        else:
            magic |= MAGIC_NEGATE[ptype]
            magic |= cast(Set[AnyStr], MAGIC_NEGATE[ptype])

    return magic, magic_drive


def is_magic(pattern, flags=0):
def is_magic(pattern: AnyStr, flags: int = 0) -> bool:
    """Check if pattern is magic."""

    magical = False
    unix = is_unix_style(flags)

    ptype = util.BYTES if isinstance(pattern, bytes) else util.UNICODE
    drive_pat = RE_WIN_DRIVE[ptype]
    if isinstance(pattern, bytes):
        ptype = util.BYTES
    else:
        ptype = util.UNICODE

    drive_pat = cast(Pattern[AnyStr], RE_WIN_DRIVE[ptype])

    magic, magic_drive = _get_magic_symbols(ptype, unix, flags)
    magic, magic_drive = _get_magic_symbols(pattern, unix, flags)
    is_path = flags & PATHNAME

    length = 0

@@ -456,18 +479,18 @@

Loading

    return magical


def is_negative(pattern, flags):
def is_negative(pattern: AnyStr, flags: int) -> bool:
    """Check if negative pattern."""

    if flags & MINUSNEGATE:
        return flags & NEGATE and pattern[0:1] in MINUS_NEGATIVE_SYM
        return bool(flags & NEGATE and pattern[0:1] in MINUS_NEGATIVE_SYM)
    elif flags & EXTMATCH:
        return flags & NEGATE and pattern[0:1] in NEGATIVE_SYM and pattern[1:2] not in ROUND_BRACKET
        return bool(flags & NEGATE and pattern[0:1] in NEGATIVE_SYM and pattern[1:2] not in ROUND_BRACKET)
    else:
        return flags & NEGATE and pattern[0:1] in NEGATIVE_SYM
        return bool(flags & NEGATE and pattern[0:1] in NEGATIVE_SYM)


def tilde_pos(pattern, flags):
def tilde_pos(pattern: AnyStr, flags: int) -> int:
    """Is user folder."""

    pos = -1

@@ -482,7 +505,7 @@

Loading

    return pos


def expand_braces(patterns, flags, limit):
def expand_braces(patterns: AnyStr, flags: int, limit: int) -> Iterable[AnyStr]:
    """Expand braces."""

    if flags & BRACE:

@@ -502,24 +525,24 @@

Loading

            yield p


def expand_tilde(pattern, is_unix, flags):
def expand_tilde(pattern: AnyStr, is_unix: bool, flags: int) -> AnyStr:
    """Expand tilde."""

    pos = tilde_pos(pattern, flags)

    if pos > -1:
        string_type = util.BYTES if isinstance(pattern, bytes) else util.UNICODE
        tilde = TILDE_SYM[string_type]
        re_tilde = RE_WIN_TILDE[string_type] if not is_unix else RE_TILDE[string_type]
        tilde = cast(AnyStr, TILDE_SYM[string_type])
        re_tilde = cast(Pattern[AnyStr], RE_WIN_TILDE[string_type] if not is_unix else RE_TILDE[string_type])
        m = re_tilde.match(pattern, pos)
        if m:
            expanded = os.path.expanduser(m.group(0))
            if not expanded.startswith(tilde) and os.path.exists(expanded):
                pattern = (pattern[0] if pos else pattern[0:0]) + escape(expanded, is_unix) + pattern[m.end(0):]
                pattern = (pattern[0:1] if pos else pattern[0:0]) + escape(expanded, is_unix) + pattern[m.end(0):]
    return pattern


def expand(pattern, flags, limit):
def expand(pattern: AnyStr, flags: int, limit: int) -> Iterable[AnyStr]:
    """Expand and normalize."""

    for expanded in expand_braces(pattern, flags, limit):

@@ -527,7 +550,7 @@

Loading

            yield expand_tilde(splitted, is_unix_style(flags), flags)


def is_case_sensitive(flags):
def is_case_sensitive(flags: int) -> bool:
    """Is case sensitive."""

    if bool(flags & FORCEWIN):

@@ -539,7 +562,7 @@

Loading

    return case_sensitive


def get_case(flags):
def get_case(flags: int) -> bool:
    """Parse flags for case sensitivity settings."""

    if not bool(flags & CASE_FLAGS):

@@ -551,13 +574,13 @@

Loading

    return case_sensitive


def escape_drive(drive, case):
def escape_drive(drive: str, case: bool) -> str:
    """Escape drive."""

    return '(?i:{})'.format(re.escape(drive)) if case else re.escape(drive)


def is_unix_style(flags):
def is_unix_style(flags: int) -> bool:
    """Check if we should use Unix style."""

    return (

@@ -569,13 +592,15 @@

Loading

    )


def translate(patterns, flags, limit=PATTERN_LIMIT):
def translate(
    patterns: Sequence[AnyStr],
    flags: int,
    limit: int = PATTERN_LIMIT
) -> Tuple[List[AnyStr], List[AnyStr]]:
    """Translate patterns."""

    positive = []
    negative = []
    if isinstance(patterns, (str, bytes)):
        patterns = [patterns]
    positive = []  # type: List[AnyStr]
    negative = []  # type: List[AnyStr]

    flags = (flags | _TRANSLATE) & FLAG_MASK
    is_unix = is_unix_style(flags)

@@ -585,7 +610,7 @@

Loading

        current_limit = limit
        total = 0
        for pattern in patterns:
            pattern = util.norm_pattern(pattern, not is_unix, flags & RAWCHARS)
            pattern = util.norm_pattern(pattern, not is_unix, bool(flags & RAWCHARS))
            count = 0
            for count, expanded in enumerate(expand(pattern, flags, current_limit), 1):
                total += 1

@@ -601,20 +626,22 @@

Loading

    except bracex.ExpansionLimitException:
        raise PatternLimitException("Pattern limit exceeded the limit of {:d}".format(limit))

    if patterns and negative and not positive:
    if patterns is not None and negative and not positive:
        if flags & NEGATEALL:
            default = b'**' if isinstance(patterns[0], bytes) else '**'
            positive.append(WcParse(default, flags | (GLOBSTAR if flags & PATHNAME else 0)).parse())
            positive.append(
                WcParse(default, flags | (GLOBSTAR if flags & PATHNAME else 0)).parse()
            )

    if patterns and flags & NODIR:
        index = util.BYTES if isinstance(patterns[0], bytes) else util.UNICODE
        exclude = _NO_NIX_DIR[index] if is_unix else _NO_WIN_DIR[index]
        exclude = cast(AnyStr, _NO_NIX_DIR[index] if is_unix else _NO_WIN_DIR[index])
        negative.append(exclude)

    return positive, negative


def split(pattern, flags):
def split(pattern: AnyStr, flags: int) -> Iterable[AnyStr]:
    """Split patterns."""

    if flags & SPLIT:

@@ -623,13 +650,15 @@

Loading

        yield pattern


def compile(patterns, flags, limit=PATTERN_LIMIT):  # noqa A001
def compile(  # noqa: A001
    patterns: Sequence[AnyStr],
    flags: int,
    limit: int = PATTERN_LIMIT
) -> WcRegexp[AnyStr]:
    """Compile patterns."""

    positive = []
    negative = []
    if isinstance(patterns, (str, bytes)):
        patterns = [patterns]
    positive = []  # type: List[Pattern[AnyStr]]
    negative = []  # type: List[Pattern[AnyStr]]

    is_unix = is_unix_style(flags)
    seen = set()

@@ -638,7 +667,7 @@

Loading

        current_limit = limit
        total = 0
        for pattern in patterns:
            pattern = util.norm_pattern(pattern, not is_unix, flags & RAWCHARS)
            pattern = util.norm_pattern(pattern, not is_unix, bool(flags & RAWCHARS))
            count = 0
            for count, expanded in enumerate(expand(pattern, flags, current_limit), 1):
                total += 1

@@ -654,39 +683,41 @@

Loading

    except bracex.ExpansionLimitException:
        raise PatternLimitException("Pattern limit exceeded the limit of {:d}".format(limit))

    if patterns and negative and not positive:
    if patterns is not None and negative and not positive:
        if flags & NEGATEALL:
            default = b'**' if isinstance(patterns[0], bytes) else '**'
            positive.append(_compile(default, flags | (GLOBSTAR if flags & PATHNAME else 0)))

    if patterns and flags & NODIR:
    if patterns is not None and flags & NODIR:
        ptype = util.BYTES if isinstance(patterns[0], bytes) else util.UNICODE
        negative.append(RE_NO_DIR[ptype] if is_unix else RE_WIN_NO_DIR[ptype])
        negative.append(cast(Pattern[AnyStr], RE_NO_DIR[ptype] if is_unix else RE_WIN_NO_DIR[ptype]))

    return WcRegexp(tuple(positive), tuple(negative), flags & REALPATH, flags & PATHNAME, flags & FOLLOW)
    return WcRegexp(
        tuple(positive), tuple(negative),
        bool(flags & REALPATH), bool(flags & PATHNAME), bool(flags & FOLLOW)
    )


@functools.lru_cache(maxsize=256, typed=True)
def _compile(pattern, flags):
def _compile(pattern: AnyStr, flags: int) -> Pattern[AnyStr]:
    """Compile the pattern to regex."""

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


class WcSplit(object):
class WcSplit(Generic[AnyStr]):
    """Class that splits patterns on |."""

    def __init__(self, pattern, flags):
    def __init__(self, pattern: AnyStr, flags: int) -> None:
        """Initialize."""

        self.pattern = pattern
        self.is_bytes = isinstance(pattern, bytes)
        self.pattern = pattern  # type: AnyStr
        self.pathname = bool(flags & PATHNAME)
        self.extend = bool(flags & EXTMATCH)
        self.unix = is_unix_style(flags)
        self.bslash_abort = not self.unix

    def _sequence(self, i):
    def _sequence(self, i: util.StringIter) -> None:
        """Handle character group."""

        c = next(i)

@@ -707,7 +738,7 @@

Loading

                    raise StopIteration
            c = next(i)

    def _references(self, i, sequence=False):
    def _references(self, i: util.StringIter, sequence: bool = False) -> None:
        """Handle references."""

        c = next(i)

@@ -723,7 +754,7 @@

Loading

            # \a, \b, \c, etc.
            pass

    def parse_extend(self, c, i):
    def parse_extend(self, c: str, i: util.StringIter) -> bool:
        """Parse extended pattern lists."""

        # Start list parsing

@@ -759,14 +790,12 @@

Loading


        return success

    def split(self):
        """Start parsing the pattern."""

        pattern = self.pattern.decode('latin-1') if self.is_bytes else self.pattern
    def _split(self, pattern: str) -> Iterable[str]:
        """Split the pattern."""

        start = -1
        i = util.StringIter(pattern)
        iter(i)

        for c in i:
            if self.extend and c in EXT_TYPES and self.parse_extend(c, i):
                continue

@@ -774,7 +803,7 @@

Loading

            if c == '|':
                split = i.index - 1
                p = pattern[start + 1:split]
                yield p.encode('latin-1') if self.is_bytes else p
                yield p
                start = split
            elif c == '\\':
                index = i.index

@@ -790,17 +819,25 @@

Loading

                    i.rewind(i.index - index)

        if start < len(pattern):
            p = pattern[start + 1:]
            yield p.encode('latin-1') if self.is_bytes else p
            yield pattern[start + 1:]

    def split(self) -> Iterable[AnyStr]:
        """Split the pattern."""

        if isinstance(self.pattern, bytes):
            for p in self._split(self.pattern.decode('latin-1')):
                yield p.encode('latin-1')
        else:
            yield from self._split(self.pattern)


class WcParse(object):
class WcParse(Generic[AnyStr]):
    """Parse the wildcard pattern."""

    def __init__(self, pattern, flags=0):
    def __init__(self, pattern: AnyStr, flags: int = 0) -> None:
        """Initialize."""

        self.pattern = pattern
        self.pattern = pattern  # type: AnyStr
        self.no_abs = bool(flags & _NOABSOLUTE)
        self.braces = bool(flags & BRACE)
        self.is_bytes = isinstance(pattern, bytes)

@@ -827,7 +864,7 @@

Loading

        self.unix = is_unix_style(self.flags)
        if not self.unix:
            self.win_drive_detect = self.pathname
            self.char_avoid = (ord('\\'), ord('/'), ord('.'))
            self.char_avoid = (ord('\\'), ord('/'), ord('.'))  # type: Tuple[int, ...]
            self.bslash_abort = self.pathname
            sep = {"sep": re.escape('\\/')}
        else:

@@ -851,25 +888,25 @@

Loading

        else:
            self.need_char = _NEED_CHAR

    def set_after_start(self):
    def set_after_start(self) -> None:
        """Set tracker for character after the start of a directory."""

        self.after_start = True
        self.dir_start = False

    def set_start_dir(self):
    def set_start_dir(self) -> None:
        """Set directory start."""

        self.dir_start = True
        self.after_start = False

    def reset_dir_track(self):
    def reset_dir_track(self) -> None:
        """Reset directory tracker."""

        self.dir_start = False
        self.after_start = False

    def update_dir_state(self):
    def update_dir_state(self) -> None:
        """
        Update the directory state.


@@ -883,12 +920,12 @@

Loading

        elif not self.dir_start and self.after_start:
            self.reset_dir_track()

    def _restrict_extended_slash(self):
    def _restrict_extended_slash(self) -> str:
        """Restrict extended slash."""

        return self.seq_path if self.pathname else ''

    def _restrict_sequence(self):
    def _restrict_sequence(self) -> str:
        """Restrict sequence."""

        if self.pathname:

@@ -901,7 +938,7 @@

Loading


        return value

    def _sequence_range_check(self, result, last):
    def _sequence_range_check(self, result: List[str], last: str) -> bool:
        """
        If range backwards, remove it.


@@ -926,7 +963,7 @@

Loading

            result.append(last)
        return removed

    def _handle_posix(self, i, result, end_range):
    def _handle_posix(self, i: util.StringIter, result: List[str], end_range: int) -> bool:
        """Handle posix classes."""

        last_posix = False

@@ -941,7 +978,7 @@

Loading

            result.append(posix.get_posix_property(m.group(1), self.is_bytes))
        return last_posix

    def _sequence(self, i):
    def _sequence(self, i: util.StringIter) -> str:
        """Handle character group."""

        result = ['[']

@@ -1043,7 +1080,7 @@

Loading


        return ''.join(result)

    def _references(self, i, sequence=False):
    def _references(self, i: util.StringIter, sequence: bool = False) -> str:
        """Handle references."""

        value = ''

@@ -1083,7 +1120,7 @@

Loading


        return value

    def _handle_dot(self, i, current):
    def _handle_dot(self, i: util.StringIter, current: List[str]) -> None:
        """Handle dot."""

        is_current = True

@@ -1133,7 +1170,7 @@

Loading

        else:
            current.append(re.escape('.'))

    def _handle_star(self, i, current):
    def _handle_star(self, i: util.StringIter, current: List[str]) -> None:
        """Handle star."""

        if self.pathname:

@@ -1227,7 +1264,7 @@

Loading

        else:
            current.append(value)

    def clean_up_inverse(self, current, nested=False):
    def clean_up_inverse(self, current: List[str], nested: bool = False) -> None:
        """
        Clean up current.


@@ -1258,7 +1295,7 @@

Loading

            index -= 1
        self.inv_ext = 0

    def parse_extend(self, c, i, current, reset_dot=False):
    def parse_extend(self, c: str, i: util.StringIter, current: List[str], reset_dot: bool = False) -> bool:
        """Parse extended pattern lists."""

        # Save state

@@ -1277,7 +1314,7 @@

Loading

        success = True
        index = i.index
        list_type = c
        extended = []
        extended = []  # type: List[str]

        try:
            c = next(i)

@@ -1382,7 +1419,7 @@

Loading


        return success

    def consume_path_sep(self, i):
    def consume_path_sep(self, i: util.StringIter) -> None:
        """Consume any consecutive path separators as they count as one."""

        try:

@@ -1407,12 +1444,12 @@

Loading

        except StopIteration:
            pass

    def root(self, pattern, current):
    def root(self, pattern: str, current: List[str]) -> None:
        """Start parsing the pattern."""

        self.set_after_start()
        i = util.StringIter(pattern)
        iter(i)

        root_specified = False
        if self.win_drive_detect:
            root_specified, drive, slash, end = _get_win_drive(pattern, True, self.case_sensitive)

@@ -1491,21 +1528,18 @@

Loading

        if self.pathname:
            current.append(_PATH_TRAIL.format(self.sep))

    def parse(self):
        """Parse pattern list."""
    def _parse(self, p: str) -> str:
        """Parse pattern."""

        result = ['']
        prepend = ['']
        self.negative = False

        p = self.pattern
        self.negative = False

        if is_negative(p, self.flags):
            self.negative = True
            p = p[1:]

        p = p.decode('latin-1') if self.is_bytes else p

        if self.negative:
            # TODO: Do we prevent `NODOTDIR` for negative patterns?
            self.globstar_capture = False

@@ -1559,7 +1593,14 @@

Loading

            # Strip out unnecessary regex comments
            pattern = pattern.replace('(?#)', '')

        if self.is_bytes:
            pattern = pattern.encode('latin-1')
        return pattern

    def parse(self) -> AnyStr:
        """Parse pattern list."""

        if isinstance(self.pattern, bytes):
            pattern = self._parse(self.pattern.decode('latin-1')).encode('latin-1')
        else:
            pattern = self._parse(self.pattern)

        return pattern

@@ -21,6 +21,7 @@

Loading

IN THE SOFTWARE.
"""
from . import _wcparse
from typing import Tuple, List, AnyStr, Iterable, Union, Sequence

__all__ = (
    "CASE", "EXTMATCH", "IGNORECASE", "RAWCHARS",

@@ -59,7 +60,7 @@

Loading

)


def _flag_transform(flags):
def _flag_transform(flags: int) -> int:
    """Transform flags to glob defaults."""

    # Enabling both cancels out

@@ -69,14 +70,25 @@

Loading

    return (flags & FLAG_MASK)


def translate(patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):
def translate(
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    limit: int = _wcparse.PATTERN_LIMIT
) -> Tuple[List[AnyStr], List[AnyStr]]:
    """Translate `fnmatch` pattern."""

    flags = _flag_transform(flags)
    return _wcparse.translate(patterns, flags, limit)
    return _wcparse.translate(_wcparse.to_str_sequence(patterns), flags, limit)


def fnmatch(filename, patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):
def fnmatch(
    filename: AnyStr,
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    limit: int = _wcparse.PATTERN_LIMIT
) -> bool:
    """
    Check if filename matches pattern.


@@ -85,16 +97,22 @@

Loading

    """

    flags = _flag_transform(flags)
    return _wcparse.compile(patterns, flags, limit).match(filename)
    return bool(_wcparse.compile(_wcparse.to_str_sequence(patterns), flags, limit).match(filename))


def filter(filenames, patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):  # noqa A001
def filter(  # noqa A001
    filenames: Iterable[AnyStr],
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    limit: int = _wcparse.PATTERN_LIMIT
) -> List[AnyStr]:
    """Filter names using pattern."""

    matches = []

    flags = _flag_transform(flags)
    obj = _wcparse.compile(patterns, flags, limit)
    obj = _wcparse.compile(_wcparse.to_str_sequence(patterns), flags, limit)

    for filename in filenames:
        if obj.match(filename):

@@ -102,13 +120,13 @@

Loading

    return matches


def escape(pattern):
def escape(pattern: AnyStr) -> AnyStr:
    """Escape."""

    return _wcparse.escape(pattern, pathname=False)


def is_magic(pattern, *, flags=0):
def is_magic(pattern: AnyStr, *, flags: int = 0) -> bool:
    """Check if the pattern is likely to be magic."""

    flags = _flag_transform(flags)

@@ -25,9 +25,14 @@

Loading

import re
import functools
from collections import namedtuple
import bracex
from . import _wcparse
from . import _wcmatch
from . import util
from typing import (
    Optional, Iterator, Iterable, List, AnyStr, Union, Generic,
    Tuple, Pattern, Callable, Any, Set, Sequence, cast
)

__all__ = (
    "CASE", "IGNORECASE", "RAWCHARS", "DOTGLOB", "DOTMATCH",

@@ -102,19 +107,18 @@

Loading

    _NOABSOLUTE
)

_RE_PATHLIB_DOT_NORM = [
_RE_PATHLIB_DOT_NORM = (
    re.compile(r'(?:((?<=^)|(?<=/))\.(?:/|$))+'),
    re.compile(br'(?:((?<=^)|(?<=/))\.(?:/|$))+')
)  # type: Tuple[Pattern[str], Pattern[bytes]]

]

_RE_WIN_PATHLIB_DOT_NORM = [
_RE_WIN_PATHLIB_DOT_NORM = (
    re.compile(r'(?:((?<=^)|(?<=[\\/]))\.(?:[\\/]|$))+'),
    re.compile(br'(?:((?<=^)|(?<=[\\/]))\.(?:[\\/]|$))+')
]
)  # type: Tuple[Pattern[str], Pattern[bytes]]


def _flag_transform(flags):
def _flag_transform(flags: int) -> int:
    """Transform flags to glob defaults."""

    # Enabling both cancels out

@@ -135,11 +139,13 @@

Loading

    return flags


class _GlobPart(namedtuple('_GlobPart', ['pattern', 'is_magic', 'is_globstar', 'dir_only', 'is_drive'])):
class _GlobPart(
    namedtuple('_GlobPart', ['pattern', 'is_magic', 'is_globstar', 'dir_only', 'is_drive']),
):
    """File Glob."""


class _GlobSplit(object):
class _GlobSplit(Generic[AnyStr]):
    """
    Split glob pattern on "magic" file and directories.


@@ -166,12 +172,12 @@

Loading


    """

    def __init__(self, pattern, flags):
    def __init__(self, pattern: AnyStr, flags: int) -> None:
        """Initialize."""

        self.pattern = pattern  # type: AnyStr
        self.unix = _wcparse.is_unix_style(flags)
        self.flags = flags
        self.pattern = pattern
        self.no_abs = bool(flags & _wcparse._NOABSOLUTE)
        self.globstar = bool(flags & GLOBSTAR)
        self.matchbase = bool(flags & MATCHBASE)

@@ -185,7 +191,6 @@

Loading

        if flags & NEGATE:
            flags ^= NEGATE
        self.flags = flags
        self.is_bytes = isinstance(pattern, bytes)
        self.extend = bool(flags & EXTMATCH)
        if not self.unix:
            self.win_drive_detect = True

@@ -197,10 +202,9 @@

Loading

            self.sep = '/'
        # Once split, Windows file names will never have `\\` in them,
        # so we can use the Unix magic detect
        ptype = util.BYTES if self.is_bytes else util.UNICODE
        self.magic_symbols = _wcparse._get_magic_symbols(ptype, self.unix, self.flags)[0]
        self.magic_symbols = _wcparse._get_magic_symbols(pattern, self.unix, self.flags)[0]  # type: Set[AnyStr]

    def is_magic(self, name):
    def is_magic(self, name: AnyStr) -> bool:
        """Check if name contains magic characters."""

        for c in self.magic_symbols:

@@ -208,7 +212,7 @@

Loading

                return True
        return False

    def _sequence(self, i):
    def _sequence(self, i: util.StringIter) -> None:
        """Handle character group."""

        c = next(i)

@@ -228,7 +232,7 @@

Loading

                raise StopIteration
            c = next(i)

    def _references(self, i, sequence=False):
    def _references(self, i: util.StringIter, sequence: bool = False) -> str:
        """Handle references."""

        value = ''

@@ -249,7 +253,7 @@

Loading

            pass
        return value

    def parse_extend(self, c, i):
    def parse_extend(self, c: str, i: util.StringIter) -> bool:
        """Parse extended pattern lists."""

        # Start list parsing

@@ -285,7 +289,7 @@

Loading


        return success

    def store(self, value, l, dir_only):
    def store(self, value: AnyStr, l: List[_GlobPart], dir_only: bool) -> None:
        """Group patterns by literals and potential magic patterns."""

        if l and value in (b'', ''):

@@ -294,39 +298,43 @@

Loading

        globstar = value in (b'**', '**') and self.globstar
        magic = self.is_magic(value)
        if magic:
            value = _wcparse._compile(value, self.flags)
            v = cast(Pattern[AnyStr], _wcparse._compile(value, self.flags))  # type: Union[Pattern[AnyStr], AnyStr]
        else:
            v = value
        if globstar and l and l[-1].is_globstar:
            l[-1] = _GlobPart(value, magic, globstar, dir_only, False)
            l[-1] = _GlobPart(v, magic, globstar, dir_only, False)
        else:
            l.append(_GlobPart(value, magic, globstar, dir_only, False))
            l.append(_GlobPart(v, magic, globstar, dir_only, False))

    def split(self):
    def split(self) -> List[_GlobPart]:
        """Start parsing the pattern."""

        split_index = []
        parts = []
        start = -1

        pattern = self.pattern.decode('latin-1') if self.is_bytes else self.pattern
        if isinstance(self.pattern, bytes):
            is_bytes = True
            pattern = self.pattern.decode('latin-1')
        else:
            is_bytes = False
            pattern = self.pattern

        i = util.StringIter(pattern)
        iter(i)

        # Detect and store away windows drive as a literal
        if self.win_drive_detect:
            root_specified, drive, slash, end = _wcparse._get_win_drive(pattern)
            if drive is not None:
                if self.is_bytes:
                    drive = drive.encode('latin-1')
                parts.append(_GlobPart(drive, False, False, True, True))
                parts.append(_GlobPart(drive.encode('latin-1') if is_bytes else drive, False, False, True, True))
                start = end - 1
                i.advance(start)
            elif drive is None and root_specified:
                parts.append(_GlobPart(b'\\' if self.is_bytes else '\\', False, False, True, True))
                parts.append(_GlobPart(b'\\' if is_bytes else '\\', False, False, True, True))
                start = 1
                i.advance(2)
        elif not self.win_drive_detect and pattern.startswith('/'):
            parts.append(_GlobPart(b'/' if self.is_bytes else '/', False, False, True, True))
            parts.append(_GlobPart(b'/' if is_bytes else '/', False, False, True, True))
            start = 0
            i.advance(1)


@@ -353,30 +361,24 @@

Loading

                    i.rewind(i.index - index)

        for split, offset in split_index:
            if self.is_bytes:
                value = pattern[start + 1:split].encode('latin-1')
            else:
                value = pattern[start + 1:split]
            self.store(value, parts, True)
            value = pattern[start + 1:split]
            self.store(cast(AnyStr, value.encode('latin-1') if is_bytes else value), parts, True)
            start = split + offset

        if start < len(pattern):
            if self.is_bytes:
                value = pattern[start + 1:].encode('latin-1')
            else:
                value = pattern[start + 1:]
            value = pattern[start + 1:]
            if value:
                self.store(value, parts, False)
                self.store(cast(AnyStr, value.encode('latin-1') if is_bytes else value), parts, False)

        if len(pattern) == 0:
            parts.append(_GlobPart(pattern.encode('latin-1') if self.is_bytes else pattern, False, False, False, False))
            parts.append(_GlobPart(pattern.encode('latin-1') if is_bytes else pattern, False, False, False, False))

        if (
            (self.extmatchbase and not parts[0].is_drive) or
            (self.matchbase and len(parts) == 1 and not parts[0].dir_only)
        ):
            self.globstar = True
            parts.insert(0, _GlobPart(b'**' if self.is_bytes else '**', True, True, True, False))
            parts.insert(0, _GlobPart(b'**' if is_bytes else '**', True, True, True, False))

        if self.no_abs and parts and parts[0].is_drive:
            raise ValueError('The pattern must be a relative path pattern')

@@ -384,75 +386,92 @@

Loading

        return parts


class Glob(object):
class Glob(Generic[AnyStr]):
    """Glob patterns."""

    def __init__(self, pattern, flags=0, root_dir=None, dir_fd=None, limit=_wcparse.PATTERN_LIMIT):
    def __init__(
        self,
        pattern: Union[str, bytes, Sequence[AnyStr]],
        flags: int = 0,
        root_dir: Optional[Union[AnyStr, 'os.PathLike[AnyStr]']] = None,
        dir_fd: Optional[int] = None,
        limit: int = _wcparse.PATTERN_LIMIT
    ) -> None:
        """Initialize the directory walker object."""

        self.seen = set()
        self.is_bytes = isinstance(pattern[0], bytes)
        self.current = b'.' if self.is_bytes else '.'
        self.dir_fd = dir_fd if SUPPORT_DIR_FD else None
        self.root_dir = os.fspath(root_dir) if root_dir is not None else self.current
        self.nounique = bool(flags & NOUNIQUE)
        self.mark = bool(flags & MARK)
        pats = _wcparse.to_str_sequence(pattern)

        self.pattern = []  # type: List[List[_GlobPart]]
        self.npatterns = []  # type: List[Pattern[AnyStr]]
        self.seen = set()  # type: Set[AnyStr]
        self.dir_fd = dir_fd if SUPPORT_DIR_FD else None  # type: Optional[int]
        self.nounique = bool(flags & NOUNIQUE)  # type: bool
        self.mark = bool(flags & MARK)  # type: bool
        # Only scan for `.` and `..` if it is specifically requested.
        self.scandotdir = flags & SCANDOTDIR
        self.scandotdir = bool(flags & SCANDOTDIR)  # type: bool
        if self.mark:
            flags ^= MARK
        self.negateall = bool(flags & NEGATEALL)
        self.negateall = bool(flags & NEGATEALL)  # type: bool
        if self.negateall:
            flags ^= NEGATEALL
        self.nodir = bool(flags & NODIR)
        self.nodir = bool(flags & NODIR)  # type: bool
        if self.nodir:
            flags ^= NODIR
        self.pathlib = bool(flags & _PATHLIB)
        self.pathlib = bool(flags & _PATHLIB)  # type: bool
        if self.pathlib:
            flags ^= _PATHLIB
        # Right to left searching is only for matching
        if flags & _RTL:  # pragma: no cover
            flags ^= _RTL
        self.flags = _flag_transform(flags | REALPATH)
        self.negate_flags = self.flags
        self.flags = _flag_transform(flags | REALPATH)  # type: int
        self.negate_flags = self.flags  # type: int
        if not self.scandotdir and not self.flags & NODOTDIR:
            self.flags |= NODOTDIR
        self.raw_chars = bool(self.flags & RAWCHARS)
        self.follow_links = bool(self.flags & FOLLOW)
        self.dot = bool(self.flags & DOTMATCH)
        self.unix = not bool(self.flags & FORCEWIN)
        self.negate = bool(self.flags & NEGATE)
        self.globstar = bool(self.flags & GLOBSTAR)
        self.braces = bool(self.flags & BRACE)
        self.matchbase = bool(self.flags & MATCHBASE)
        self.case_sensitive = _wcparse.get_case(self.flags)
        self.specials = (b'.', b'..') if self.is_bytes else ('.', '..')
        self.empty = b'' if self.is_bytes else ''
        self.stars = b'**' if self.is_bytes else '**'
        self.limit = limit
        if self.flags & FORCEWIN:
            self.sep = b'\\' if self.is_bytes else '\\'
            self.seps = (b'/' if self.is_bytes else '/', self.sep)
            self.re_pathlib_norm = _RE_WIN_PATHLIB_DOT_NORM[util.BYTES if self.is_bytes else util.UNICODE]
            self.re_no_dir = _wcparse.RE_WIN_NO_DIR[util.BYTES if self.is_bytes else util.UNICODE]
        self.raw_chars = bool(self.flags & RAWCHARS)  # type: bool
        self.follow_links = bool(self.flags & FOLLOW)  # type: bool
        self.dot = bool(self.flags & DOTMATCH)  # type: bool
        self.unix = not bool(self.flags & FORCEWIN)  # type: bool
        self.negate = bool(self.flags & NEGATE)  # type: bool
        self.globstar = bool(self.flags & GLOBSTAR)  # type: bool
        self.braces = bool(self.flags & BRACE)  # type: bool
        self.matchbase = bool(self.flags & MATCHBASE)  # type: bool
        self.case_sensitive = _wcparse.get_case(self.flags)  # type: bool
        self.limit = limit  # type: int

        forcewin = self.flags & FORCEWIN
        if isinstance(pats[0], bytes):
            ptype = util.BYTES
            self.current = b'.'  # type: AnyStr
            self.specials = (b'.', b'..')  # type: Tuple[AnyStr, ...]
            self.empty = b''  # type: AnyStr
            self.stars = b'**'  # type: AnyStr
            self.sep = b'\\' if forcewin else b'/'  # type: AnyStr
            self.seps = (b'/', self.sep) if forcewin else (self.sep,)  # type: Tuple[AnyStr, ...]
            self.re_pathlib_norm = cast(Pattern[AnyStr], _RE_WIN_PATHLIB_DOT_NORM[ptype])  # type: Pattern[AnyStr]
            self.re_no_dir = cast(Pattern[AnyStr], _wcparse.RE_WIN_NO_DIR[ptype])  # type: Pattern[AnyStr]
        else:
            self.sep = b'/' if self.is_bytes else '/'
            self.seps = (self.sep,)
            self.re_pathlib_norm = _RE_PATHLIB_DOT_NORM[util.BYTES if self.is_bytes else util.UNICODE]
            self.re_no_dir = _wcparse.RE_NO_DIR[util.BYTES if self.is_bytes else util.UNICODE]
        self._parse_patterns(pattern)

        if (
            (self.is_bytes and not isinstance(self.root_dir, bytes)) or
            (not self.is_bytes and not isinstance(self.root_dir, str))
        ):
            ptype = util.UNICODE
            self.current = '.'
            self.specials = ('.', '..')
            self.empty = ''
            self.stars = '**'
            self.sep = '\\' if forcewin else '/'
            self.seps = ('/', self.sep) if forcewin else (self.sep,)
            self.re_pathlib_norm = cast(Pattern[AnyStr], _RE_WIN_PATHLIB_DOT_NORM[ptype])
            self.re_no_dir = cast(Pattern[AnyStr], _wcparse.RE_WIN_NO_DIR[ptype])

        temp = os.fspath(root_dir) if root_dir is not None else self.current
        if not isinstance(temp, type(pats[0])):
            raise TypeError(
                'Pattern and root_dir should be of the same type, not {} and {}'.format(
                    type(pattern[0]), type(self.root_dir)
                    type(pats[0]), type(temp)
                )
            )

    def _iter_patterns(self, patterns):
        self.root_dir = temp  # type: AnyStr
        self._parse_patterns(pats)

    def _iter_patterns(self, patterns: Sequence[AnyStr]) -> Iterator[Tuple[bool, AnyStr]]:
        """Iterate expanded patterns."""

        seen = set()

@@ -482,22 +501,20 @@

Loading

                    current_limit -= count
                    if current_limit < 1:
                        current_limit = 1
        except _wcparse.bracex.ExpansionLimitException:
        except bracex.ExpansionLimitException:
            raise _wcparse.PatternLimitException(
                "Pattern limit exceeded the limit of {:d}".format(self.limit)
            )

    def _parse_patterns(self, patterns):
    def _parse_patterns(self, patterns: Sequence[AnyStr]) -> None:
        """Parse patterns."""

        self.pattern = []
        self.npatterns = []
        for is_neg, p in self._iter_patterns(patterns):
            if is_neg:
                # Treat the inverse pattern as a normal pattern if it matches, we will exclude.
                # This is faster as compiled patterns usually compare the include patterns first,
                # and then the exclude, but glob will already know it wants to include the file.
                self.npatterns.append(_wcparse._compile(p, self.negate_flags))
                self.npatterns.append(cast(Pattern[AnyStr], _wcparse._compile(p, self.negate_flags)))
            else:
                self.pattern.append(_GlobSplit(p, self.flags).split())


@@ -519,22 +536,22 @@

Loading

        ):
            self.nounique = True

    def _is_hidden(self, name):
    def _is_hidden(self, name: AnyStr) -> bool:
        """Check if is file hidden."""

        return not self.dot and name[0:1] == self.specials[0]

    def _is_this(self, name):
    def _is_this(self, name: AnyStr) -> bool:
        """Check if "this" directory `.`."""

        return name == self.specials[0] or name == self.sep

    def _is_parent(self, name):
    def _is_parent(self, name: AnyStr) -> bool:
        """Check if `..`."""

        return name == self.specials[1]

    def _match_excluded(self, filename, is_dir):
    def _match_excluded(self, filename: AnyStr, is_dir: bool) -> bool:
        """Check if file should be excluded."""

        if is_dir and not filename.endswith(self.sep):

@@ -548,21 +565,21 @@

Loading


        return matched

    def _is_excluded(self, path, is_dir):
    def _is_excluded(self, path: AnyStr, is_dir: bool) -> bool:
        """Check if file is excluded."""

        return self.npatterns and self._match_excluded(path, is_dir)
        return bool(self.npatterns and self._match_excluded(path, is_dir))

    def _match_literal(self, a, b=None):
    def _match_literal(self, a: AnyStr, b: Optional[AnyStr] = None) -> bool:
        """Match two names."""

        return a.lower() == b if not self.case_sensitive else a == b

    def _get_matcher(self, target):
    def _get_matcher(self, target: Optional[Union[AnyStr, Pattern[AnyStr]]]) -> Optional[Callable[..., Any]]:
        """Get deep match."""

        if target is None:
            matcher = None
            matcher = None  # type: Optional[Callable[..., Any]]
        elif isinstance(target, (str, bytes)):
            # Plain text match
            if not self.case_sensitive:

@@ -575,7 +592,7 @@

Loading

            matcher = target.match
        return matcher

    def _lexists(self, path):
    def _lexists(self, path: AnyStr) -> bool:
        """Check if file exists."""

        if not self.dir_fd:

@@ -587,7 +604,7 @@

Loading

        else:
            return True

    def prepend_base(self, path):
    def prepend_base(self, path: AnyStr) -> AnyStr:
        """Join path to base if pattern is not absolute."""

        if self.is_abs_pattern:

@@ -595,13 +612,13 @@

Loading

        else:
            return os.path.join(self.root_dir, path)

    def _iter(self, curdir, dir_only, deep):
    def _iter(self, curdir: Optional[AnyStr], dir_only: bool, deep: bool) -> Iterator[Tuple[AnyStr, bool, bool, bool]]:
        """Iterate the directory."""

        try:
            fd = None
            fd = None  # type: Optional[int]
            if self.is_abs_pattern and curdir:
                scandir = curdir
                scandir = curdir  # type: Union[AnyStr, int]
            elif self.dir_fd is not None:
                fd = scandir = os.open(
                    os.path.join(self.root_dir, curdir) if curdir else self.root_dir,

@@ -616,10 +633,10 @@

Loading

                yield special, True, True, False

            try:
                with os.scandir(scandir) as scan:
                with os.scandir(scandir) as scan:  # type: ignore[type-var]
                    for f in scan:
                        try:
                            hidden = self._is_hidden(f.name)
                            hidden = self._is_hidden(f.name)  # type: ignore[arg-type]
                            is_dir = f.is_dir()
                            if is_dir:
                                is_link = f.is_symlink()

@@ -627,7 +644,7 @@

Loading

                                # We don't care if a file is a link
                                is_link = False
                            if (not dir_only or is_dir):
                                yield f.name, is_dir, hidden, is_link
                                yield f.name, is_dir, hidden, is_link  # type: ignore[misc]
                        except OSError:  # pragma: no cover
                            pass
            finally:

@@ -637,7 +654,13 @@

Loading

        except OSError:  # pragma: no cover
            pass

    def _glob_dir(self, curdir, matcher, dir_only=False, deep=False):
    def _glob_dir(
        self,
        curdir: AnyStr,
        matcher: Optional[Callable[..., Any]],
        dir_only: bool = False,
        deep: bool = False
    ) -> Iterator[Tuple[AnyStr, bool]]:
        """Recursive directory glob."""

        files = list(self._iter(curdir, dir_only, deep))

@@ -655,7 +678,7 @@

Loading

            if deep and not hidden and is_dir and follow:
                yield from self._glob_dir(path, matcher, dir_only, deep)

    def _glob(self, curdir, this, rest):
    def _glob(self, curdir: AnyStr, part: _GlobPart, rest: List[_GlobPart]) -> Iterator[Tuple[AnyStr, bool]]:
        """
        Handle glob flow.


@@ -669,10 +692,10 @@

Loading

        - `globstar` `**`.
        """

        is_magic = this.is_magic
        dir_only = this.dir_only
        target = this.pattern
        is_globstar = this.is_globstar
        is_magic = part.is_magic
        dir_only = part.dir_only
        target = part.pattern
        is_globstar = part.is_globstar

        if is_magic and is_globstar:
            # Glob star directory `**`.

@@ -730,7 +753,7 @@

Loading

                else:
                    yield path, is_dir

    def _get_starting_paths(self, curdir, dir_only):
    def _get_starting_paths(self, curdir: AnyStr, dir_only: bool) -> List[Tuple[AnyStr, bool]]:
        """
        Get the starting location.


@@ -751,7 +774,7 @@

Loading

            results = [(curdir, True)]
        return results

    def is_unique(self, path):
    def is_unique(self, path: AnyStr) -> bool:
        """Test if path is unique."""

        if self.nounique:

@@ -763,20 +786,20 @@

Loading

            unique = True
        return unique

    def _pathlib_norm(self, path):
    def _pathlib_norm(self, path: AnyStr) -> AnyStr:
        """Normalize path as `pathlib` does."""

        path = self.re_pathlib_norm.sub(self.empty, path)
        return path[:-1] if len(path) > 1 and path[-1:] in self.seps else path

    def format_path(self, path, is_dir, dir_only):
    def format_path(self, path: AnyStr, is_dir: bool, dir_only: bool) -> Iterator[AnyStr]:
        """Format path."""

        path = os.path.join(path, self.empty) if dir_only or (self.mark and is_dir) else path
        if self.is_unique(self._pathlib_norm(path) if self.pathlib else path):
            yield path

    def glob(self):
    def glob(self) -> Iterator[AnyStr]:
        """Starts off the glob iterator."""

        curdir = self.current

@@ -829,26 +852,56 @@

Loading

                            yield from self.format_path(match, is_dir, dir_only)


def iglob(patterns, *, flags=0, root_dir=None, dir_fd=None, limit=_wcparse.PATTERN_LIMIT):
def iglob(
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    root_dir: Optional[Union[AnyStr, 'os.PathLike[AnyStr]']] = None,
    dir_fd: Optional[int] = None,
    limit: int = _wcparse.PATTERN_LIMIT
) -> Iterator[AnyStr]:
    """Glob."""

    yield from Glob(util.to_tuple(patterns), flags, root_dir, dir_fd, limit).glob()
    if not isinstance(patterns, (str, bytes)) and not patterns:
        return

    yield from Glob(patterns, flags, root_dir, dir_fd, limit).glob()


def glob(patterns, *, flags=0, root_dir=None, dir_fd=None, limit=_wcparse.PATTERN_LIMIT):
def glob(
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    root_dir: Optional[Union[AnyStr, 'os.PathLike[AnyStr]']] = None,
    dir_fd: Optional[int] = None,
    limit: int = _wcparse.PATTERN_LIMIT
) -> List[AnyStr]:
    """Glob."""

    return list(iglob(patterns, flags=flags, root_dir=root_dir, dir_fd=dir_fd, limit=limit))


def translate(patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):
def translate(
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    limit: int = _wcparse.PATTERN_LIMIT
) -> Tuple[List[AnyStr], List[AnyStr]]:
    """Translate glob pattern."""

    flags = _flag_transform(flags)
    return _wcparse.translate(patterns, flags, limit)


def globmatch(filename, patterns, *, flags=0, root_dir=None, dir_fd=None, limit=_wcparse.PATTERN_LIMIT):
    return _wcparse.translate(_wcparse.to_str_sequence(patterns), flags, limit)


def globmatch(
    filename: Union[AnyStr, 'os.PathLike[AnyStr]'],
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    root_dir: Optional[Union[AnyStr, 'os.PathLike[AnyStr]']] = None,
    dir_fd: Optional[int] = None,
    limit: int = _wcparse.PATTERN_LIMIT
) -> bool:
    """
    Check if filename matches pattern.


@@ -856,45 +909,79 @@

Loading

    but if `case_sensitive` is set, respect that instead.
    """

    if root_dir is not None:
        root_dir = os.fspath(root_dir)
    pats = _wcparse.to_str_sequence(patterns)

    # Shortcut out if we have no patterns
    if not pats:
        return False

    ptype = type(pats[0])
    rdir = os.fspath(root_dir) if root_dir is not None else root_dir
    flags = _flag_transform(flags)
    filename = os.fspath(filename)
    return _wcparse.compile(patterns, flags, limit).match(filename, root_dir, dir_fd)
    fname = os.fspath(filename)

    # Ensure types are not mismatched
    if (rdir is not None and not isinstance(rdir, ptype)):
        raise TypeError(
            "Pattern type of '{}' does not match the resolved type of '{}' of the root dir".format(ptype, type(rdir))
        )

    return bool(_wcparse.compile(pats, flags, limit).match(fname, rdir, dir_fd))


def globfilter(
    filenames: Iterable[Union[AnyStr, 'os.PathLike[AnyStr]']],
    patterns: Union[str, bytes, Sequence[AnyStr]],
    *,
    flags: int = 0,
    root_dir: Optional[Union[AnyStr, 'os.PathLike[AnyStr]']] = None,
    dir_fd: Optional[int] = None,
    limit: int = _wcparse.PATTERN_LIMIT
) -> List[Union[AnyStr, 'os.PathLike[AnyStr]']]:
    """Filter names using pattern."""

    pats = _wcparse.to_str_sequence(patterns)

def globfilter(filenames, patterns, *, flags=0, root_dir=None, dir_fd=None, limit=_wcparse.PATTERN_LIMIT):
    """Filter names using pattern."""
    # Shortcut out if we have no patterns
    if not pats:
        return []

    ptype = type(pats[0])
    rdir = os.fspath(root_dir) if root_dir is not None else root_dir

    if root_dir is not None:
        root_dir = os.fspath(root_dir)
    # Ensure types are not mismatched
    if (rdir is not None and not isinstance(rdir, ptype)):
        raise TypeError(
            "Pattern type of '{}' does not match the resolved type of '{}' of the root dir".format(ptype, type(rdir))
        )

    matches = []
    matches = []  # type: List[Union[AnyStr, 'os.PathLike[AnyStr]']]
    flags = _flag_transform(flags)
    obj = _wcparse.compile(patterns, flags, limit)
    obj = _wcparse.compile(pats, flags, limit)

    for filename in filenames:
        temp = os.fspath(filename)
        if obj.match(temp, root_dir, dir_fd):
        if obj.match(temp, rdir, dir_fd):
            matches.append(filename)
    return matches


@util.deprecated("This function will be removed in 9.0.")
def raw_escape(pattern, unix=None, raw_chars=True):
def raw_escape(pattern: AnyStr, unix: Optional[bool] = None, raw_chars: bool = True) -> AnyStr:
    """Apply raw character transform before applying escape."""

    return _wcparse.escape(util.norm_pattern(pattern, False, raw_chars, True), unix=unix, pathname=True, raw=True)
    return _wcparse.escape(
        util.norm_pattern(pattern, False, raw_chars, True), unix=unix, pathname=True, raw=True
    )


def escape(pattern, unix=None):
def escape(pattern: AnyStr, unix: Optional[bool] = None) -> AnyStr:
    """Escape."""

    return _wcparse.escape(pattern, unix=unix)


def is_magic(pattern, *, flags=0):
def is_magic(pattern: AnyStr, *, flags: int = 0) -> bool:
    """Check if the pattern is likely to be magic."""

    flags = _flag_transform(flags)

@@ -62,7 +62,7 @@

Loading

}


def get_posix_property(value, limit_ascii=False):
def get_posix_property(value: str, limit_ascii: bool = False) -> str:
    """Retrieve the POSIX category."""

    try:

@@ -80,7 +80,11 @@

Loading


    """

    def __new__(cls, major, minor, micro, release="final", pre=0, post=0, dev=0):
    def __new__(
        cls,
        major: int, minor: int, micro: int, release: str = "final",
        pre: int = 0, post: int = 0, dev: int = 0
    ) -> "Version":
        """Validate version info."""

        # Ensure all parts are positive integers.

@@ -116,27 +120,27 @@

Loading


        return super(Version, cls).__new__(cls, major, minor, micro, release, pre, post, dev)

    def _is_pre(self):
    def _is_pre(self) -> bool:
        """Is prerelease."""

        return self.pre > 0
        return bool(self.pre > 0)

    def _is_dev(self):
    def _is_dev(self) -> bool:
        """Is development."""

        return bool(self.release < "alpha")

    def _is_post(self):
    def _is_post(self) -> bool:
        """Is post."""

        return self.post > 0
        return bool(self.post > 0)

    def _get_dev_status(self):  # pragma: no cover
    def _get_dev_status(self) -> str:  # pragma: no cover
        """Get development status string."""

        return DEV_STATUS[self.release]

    def _get_canonical(self):
    def _get_canonical(self) -> str:
        """Get the canonical output string."""

        # Assemble major, minor, micro version and append `pre`, `post`, or `dev` if needed..

@@ -154,7 +158,7 @@

Loading

        return ver


def parse_version(ver):
def parse_version(ver: str) -> Version:
    """Parse version into a comparable Version tuple."""

    m = RE_VER.match(ver)

@@ -189,5 +193,5 @@

Loading

    return Version(major, minor, micro, release, pre, post, dev)


__version_info__ = Version(8, 2, 0, "final")
__version_info__ = Version(8, 3, 0, "final")
__version__ = __version_info__._get_canonical()

@@ -23,7 +23,10 @@

Loading

import os
import re
from . import _wcparse
from . import _wcmatch
from . import util
from typing import Optional, Any, Iterator, List, Generic, AnyStr


__all__ = (
    "CASE", "IGNORECASE", "RAWCHARS", "FILEPATHNAME", "DIRPATHNAME", "PATHNAME",

@@ -78,104 +81,62 @@

Loading

)


class _Mixin:  # pragma: no cover
    """
    DO NOT USE: Provide temporary methods to allow temporary, backwards compatibility for Rummage.

    This is only a temporary solution to transition Rummage to a new way of overriding `glob`
    style patterns with regular expressions (which is a niche need and not publicly supported).
    It is advised to stick to the public, documented API. Anything else you use, you use at your
    own risk.

    Wildcard Match was originally written inside Rummage and moved out at a later point to be its
    own library. The regular expression override of file patterns was something that didn't make
    much sense in Wildcard match as a standalone project. The old way Rummage used to override the
    file/folder checks was hacked in and was messy as it was based on internal knowledge of how
    `WcMatch` worked.

    NEW WAY:
    We've provided a cleaner easier way to do this moving forward, and if we ever made the knowledge
    of this public, this is the way we'd do it. If either `file_check` or `folder_exclude_check` is
    initialized prior to us compiling the checks, we will skip compilation. This would happen in
    `on_init`. Un-compiled patterns are stored in `pattern_file` and `pattern_folder_exclude`.

    OLD WAY:
    The reason we need these functions below is because the old way looked to see if `file_pattern`
    or `exclude_pattern` already had a compiled object, and then would replace them with compiled
    objects using the pattern that was already contained within. Rummage avoided recompiling
    objects that were already compiled, but this was messy.
    """

    @property
    def file_pattern(self):
        """DO NOT USE: only provided for Rummage backwards compatibility, and will be remove in the future."""

        return _wcparse.WcRegexp(tuple()) if not self.pattern_file else self.pattern_file

    @property
    def exclude_pattern(self):
        """DO NOT USE: only provided for Rummage backwards compatibility, and will be remove in the future."""

        return _wcparse.WcRegexp(tuple()) if not self.pattern_folder_exclude else self.pattern_folder_exclude

    @file_pattern.setter
    def file_pattern(self, value):
        """DO NOT USE: only provided for Rummage backwards compatibility, and will be remove in the future."""

        self.file_check = value

    @exclude_pattern.setter
    def exclude_pattern(self, value):
        """DO NOT USE: only provided for Rummage backwards compatibility, and will be remove in the future."""

        self.folder_exclude_check = value


class WcMatch(_Mixin):
class WcMatch(Generic[AnyStr]):
    """Finds files by wildcard."""

    def __init__(self, root_dir, file_pattern=None, exclude_pattern=None, flags=0, limit=_wcparse.PATHNAME, **kwargs):
    def __init__(
        self,
        root_dir: AnyStr,
        file_pattern: Optional[AnyStr] = None,
        exclude_pattern: Optional[AnyStr] = None,
        flags: int = 0,
        limit: int = _wcparse.PATHNAME,
        **kwargs: Any
    ):
        """Initialize the directory walker object."""

        self.is_bytes = isinstance(root_dir, bytes)
        self._directory = self._norm_slash(root_dir)  # type: AnyStr
        self._abort = False
        self._skipped = 0
        self._parse_flags(flags)
        self._directory = self._norm_slash(root_dir)
        self._sep = os.fsencode(os.sep) if self.is_bytes else os.sep
        self._root_dir = self._add_sep(self._get_cwd(), True)
        self._sep = os.fsencode(os.sep) if isinstance(root_dir, bytes) else os.sep  # type: AnyStr
        self._root_dir = self._add_sep(self._get_cwd(), True)  # type: AnyStr
        self.limit = limit
        self.pattern_file = file_pattern if file_pattern else self._directory[0:0]
        self.pattern_folder_exclude = exclude_pattern if exclude_pattern else self._directory[0:0]
        self.file_check = None
        self.folder_exclude_check = None
        empty = os.fsencode('') if isinstance(root_dir, bytes) else ''
        self.pattern_file = file_pattern if file_pattern is not None else empty  # type: AnyStr
        self.pattern_folder_exclude = exclude_pattern if exclude_pattern is not None else empty  # type: AnyStr
        self.file_check = None  # type: Optional[_wcmatch.WcRegexp[AnyStr]]
        self.folder_exclude_check = None  # type: Optional[_wcmatch.WcRegexp[AnyStr]]
        self.on_init(**kwargs)
        self._compile(self.pattern_file, self.pattern_folder_exclude)

    def _norm_slash(self, name):
    def _norm_slash(self, name: AnyStr) -> AnyStr:
        """Normalize path slashes."""

        if self.is_bytes:
            return name.replace(b'/', b"\\") if not util.is_case_sensitive() else name
        if util.is_case_sensitive():
            return name
        elif isinstance(name, bytes):
            return name.replace(b'/', b"\\")
        else:
            return name.replace('/', "\\") if not util.is_case_sensitive() else name
            return name.replace('/', "\\")

    def _add_sep(self, path, check=False):
    def _add_sep(self, path: AnyStr, check: bool = False) -> AnyStr:
        """Add separator."""

        return (path + self._sep) if not check or not path.endswith(self._sep) else path

    def _get_cwd(self):
    def _get_cwd(self) -> AnyStr:
        """Get current working directory."""

        if self._directory:
            return self._directory
        elif self.is_bytes:
        elif isinstance(self._directory, bytes):
            return bytes(os.curdir, 'ASCII')
        else:
            return os.curdir

    def _parse_flags(self, flags):
    def _parse_flags(self, flags: int) -> None:
        """Parse flags."""

        self.flags = flags & FLAG_MASK

@@ -190,7 +151,7 @@

Loading

            self.flags |= _FORCEWIN
        self.flags = self.flags & (_wcparse.FLAG_MASK ^ MATCHBASE)

    def _compile_wildcard(self, pattern, pathname=False):
    def _compile_wildcard(self, pattern: AnyStr, pathname: bool = False) -> Optional[_wcmatch.WcRegexp[AnyStr]]:
        """Compile or format the wildcard inclusion/exclusion pattern."""

        flags = self.flags

@@ -199,14 +160,14 @@

Loading

            if self.matchbase:
                flags |= MATCHBASE

        return _wcparse.compile(pattern, flags, self.limit) if pattern else None
        return _wcparse.compile([pattern], flags, self.limit) if pattern else None

    def _compile(self, file_pattern, folder_exclude_pattern):
    def _compile(self, file_pattern: AnyStr, folder_exclude_pattern: AnyStr) -> None:
        """Compile patterns."""

        if self.file_check is None:
            if not file_pattern:
                self.file_check = _wcparse.WcRegexp(
                self.file_check = _wcmatch.WcRegexp(
                    (re.compile(br'^.*$' if isinstance(file_pattern, bytes) else r'^.*$', re.DOTALL),)
                )
            else:

@@ -214,11 +175,11 @@

Loading


        if self.folder_exclude_check is None:
            if not folder_exclude_pattern:
                self.folder_exclude_check = _wcparse.WcRegexp(tuple())
                self.folder_exclude_check = _wcmatch.WcRegexp(tuple())
            else:
                self.folder_exclude_check = self._compile_wildcard(folder_exclude_pattern, self.dir_pathname)

    def _valid_file(self, base, name):
    def _valid_file(self, base: AnyStr, name: AnyStr) -> bool:
        """Return whether a file can be searched."""

        valid = False

@@ -229,17 +190,17 @@

Loading

            valid = False
        return self.on_validate_file(base, name) if valid else valid

    def compare_file(self, filename):
    def compare_file(self, filename: AnyStr) -> bool:
        """Compare filename."""

        return self.file_check.match(filename)
        return self.file_check.match(filename)  # type: ignore[union-attr]

    def on_validate_file(self, base, name):
    def on_validate_file(self, base: AnyStr, name: AnyStr) -> bool:
        """Validate file override."""

        return True

    def _valid_folder(self, base, name):
    def _valid_folder(self, base: AnyStr, name: AnyStr) -> bool:
        """Return whether a folder can be searched."""

        valid = True

@@ -247,7 +208,7 @@

Loading

        if (
            not self.recursive or
            (
                len(self.folder_exclude_check) and
                self.folder_exclude_check and
                not self.compare_directory(fullpath[self._base_len:] if self.dir_pathname else name)
            )
        ):

@@ -256,58 +217,60 @@

Loading

            valid = False
        return self.on_validate_directory(base, name) if valid else valid

    def compare_directory(self, directory):
    def compare_directory(self, directory: AnyStr) -> bool:
        """Compare folder."""

        return not self.folder_exclude_check.match(self._add_sep(directory) if self.dir_pathname else directory)
        return not self.folder_exclude_check.match(  # type: ignore[union-attr]
            self._add_sep(directory) if self.dir_pathname else directory
        )

    def on_init(self, **kwargs):
    def on_init(self, **kwargs: Any) -> None:
        """Handle custom initialization."""

    def on_validate_directory(self, base, name):
    def on_validate_directory(self, base: AnyStr, name: AnyStr) -> bool:
        """Validate folder override."""

        return True

    def on_skip(self, base, name):
    def on_skip(self, base: AnyStr, name: AnyStr) -> Any:
        """On skip."""

        return None

    def on_error(self, base, name):
    def on_error(self, base: AnyStr, name: AnyStr) -> Any:
        """On error."""

        return None

    def on_match(self, base, name):
    def on_match(self, base: AnyStr, name: AnyStr) -> Any:
        """On match."""

        return os.path.join(base, name)

    def on_reset(self):
    def on_reset(self) -> None:
        """On reset."""

    def get_skipped(self):
    def get_skipped(self) -> int:
        """Get number of skipped files."""

        return self._skipped

    def kill(self):
    def kill(self) -> None:
        """Abort process."""

        self._abort = True

    def is_aborted(self):
    def is_aborted(self) -> bool:
        """Check if process has been aborted."""

        return self._abort

    def reset(self):
    def reset(self) -> None:
        """Revive class from a killed state."""

        self._abort = False

    def _walk(self):
    def _walk(self) -> Iterator[Any]:
        """Start search for valid files."""

        self._base_len = len(self._root_dir)

@@ -353,12 +316,12 @@

Loading

                    if self.is_aborted():
                        break

    def match(self):
    def match(self) -> List[Any]:
        """Run the directory walker."""

        return list(self.imatch())

    def imatch(self):
    def imatch(self) -> Iterator[Any]:
        """Run the directory walker as iterator."""

        self.on_reset()

@@ -4,6 +4,7 @@

Loading

from . import glob
from . import _wcparse
from . import util
from typing import Iterable, Any, Union, Sequence, cast

__all__ = (
    "CASE", "IGNORECASE", "RAWCHARS", "DOTGLOB", "DOTMATCH",

@@ -68,67 +69,19 @@

Loading

)


class Path(pathlib.Path):
    """Special pathlike object (which accesses the filesystem) that uses our own glob methods."""

    __slots__ = ()

    def __new__(cls, *args, **kwargs):
        """New."""

        if cls is Path:
            cls = WindowsPath if os.name == 'nt' else PosixPath
        if util.PY310:
            self = cls._from_parts(args)
        else:
            self = cls._from_parts(args, init=False)
        if not self._flavour.is_supported:
            raise NotImplementedError("Cannot instantiate {!r} on your system".format(cls.__name__))
        if not util.PY310:
            self._init()
        return self

    def glob(self, patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):
        """
        Search the file system.

        `GLOBSTAR` is enabled by default in order match the default behavior of `pathlib`.

        """

        if self.is_dir():
            scandotdir = flags & SCANDOTDIR
            flags = self._translate_flags(flags | _NOABSOLUTE) | ((_PATHLIB | SCANDOTDIR) if scandotdir else _PATHLIB)
            for filename in glob.iglob(patterns, flags=flags, root_dir=str(self), limit=limit):
                yield self.joinpath(filename)

    def rglob(self, patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):
        """
        Recursive glob.

        This uses the same recursive logic that the default `pathlib` object uses.
        Folders and files are essentially matched from right to left.

        `GLOBSTAR` is enabled by default in order match the default behavior of `pathlib`.

        """

        yield from self.glob(patterns, flags=flags | _EXTMATCHBASE, limit=limit)


class PurePath(pathlib.PurePath):
    """Special pure pathlike object that uses our own glob methods."""

    __slots__ = ()

    def __new__(cls, *args):
    def __new__(cls, *args: str) -> 'PurePath':
        """New."""

        if cls is PurePath:
            cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
        return cls._from_parts(args)
        return cast('PurePath', cls._from_parts(args))  # type: ignore[attr-defined]

    def _translate_flags(self, flags):
    def _translate_flags(self, flags: int) -> int:
        """Translate flags for the current `pathlib` object."""

        flags = (flags & FLAG_MASK) | _PATHNAME

@@ -144,7 +97,7 @@

Loading

            flags |= _FORCEUNIX
        return flags

    def _translate_path(self):
    def _translate_path(self) -> str:
        """Translate the object to a path string and ensure trailing slash for non-pure paths that are directories."""

        sep = ''

@@ -154,7 +107,13 @@

Loading


        return name + sep

    def match(self, patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):
    def match(
        self,
        patterns: Union[str, Sequence[str]],
        *,
        flags: int = 0,
        limit: int = _wcparse.PATTERN_LIMIT
    ) -> bool:
        """
        Match patterns using `globmatch`, but also using the same right to left logic that the default `pathlib` uses.


@@ -167,7 +126,13 @@

Loading


        return self.globmatch(patterns, flags=flags | _RTL, limit=limit)

    def globmatch(self, patterns, *, flags=0, limit=_wcparse.PATTERN_LIMIT):
    def globmatch(
        self,
        patterns: Union[str, Sequence[str]],
        *,
        flags: int = 0,
        limit: int = _wcparse.PATTERN_LIMIT
    ) -> bool:
        """
        Match patterns using `globmatch`, but without the right to left logic that the default `pathlib` uses.


@@ -183,17 +148,79 @@

Loading

183	148		)
184	149
185	150
	151	+	class Path(pathlib.Path):
	152	+	"""Special pathlike object (which accesses the filesystem) that uses our own glob methods."""
	153	+
	154	+	__slots__ = ()
	155	+
	156	+	def __new__(cls, args: str, *kwargs: Any) -> 'Path':
	157	+	"""New."""
	158	+
	159	+	if cls is Path:
	160	+	cls = WindowsPath if os.name == 'nt' else PosixPath
	161	+	if util.PY310:
	162	+	self = cls._from_parts(args) # type: ignore[attr-defined]
	163	+	else:
	164	+	self = cls._from_parts(args, init=False) # type: ignore[attr-defined]
	165	+	if not self._flavour.is_supported:
	166	+	raise NotImplementedError("Cannot instantiate {!r} on your system".format(cls.__name__))
	167	+	if not util.PY310:
	168	+	self._init()
	169	+	return cast('Path', self)
	170	+
	171	+	def glob( # type: ignore[override]
	172	+	self,
	173	+	patterns: Union[str, Sequence[str]],
	174	+	*,
	175	+	flags: int = 0,
	176	+	limit: int = _wcparse.PATTERN_LIMIT
	177	+	) -> Iterable['Path']:
	178	+	"""
	179	+	Search the file system.
	180	+
	181	+	`GLOBSTAR` is enabled by default in order match the default behavior of `pathlib`.
	182	+
	183	+	"""
	184	+
	185	+	if self.is_dir():
	186	+	scandotdir = flags & SCANDOTDIR
	187	+	flags = self._translate_flags( # type: ignore[attr-defined]
	188	+	flags \| _NOABSOLUTE
	189	+	) \| ((_PATHLIB \| SCANDOTDIR) if scandotdir else _PATHLIB)
	190	+	for filename in glob.iglob(patterns, flags=flags, root_dir=str(self), limit=limit):
	191	+	yield self.joinpath(filename)
	192	+
	193	+	def rglob( # type: ignore[override]
	194	+	self,
	195	+	patterns: Union[str, Sequence[str]],
	196	+	*,
	197	+	flags: int = 0,
	198	+	limit: int = _wcparse.PATTERN_LIMIT
	199	+	) -> Iterable['Path']:
	200	+	"""
	201	+	Recursive glob.
	202	+
	203	+	This uses the same recursive logic that the default `pathlib` object uses.
	204	+	Folders and files are essentially matched from right to left.
	205	+
	206	+	`GLOBSTAR` is enabled by default in order match the default behavior of `pathlib`.
	207	+
	208	+	"""
	209	+
	210	+	yield from self.glob(patterns, flags=flags \| _EXTMATCHBASE, limit=limit)
	211	+
	212	+
186	213		class PurePosixPath(PurePath):
187	214		"""Pure Posix path."""
188	215
189		-	_flavour = pathlib._posix_flavour
	216	+	_flavour = pathlib._posix_flavour # type: ignore[attr-defined]
190	217		__slots__ = ()
191	218
192	219
193	220		class PureWindowsPath(PurePath):
194	221		"""Pure Windows path."""
195	222
196		-	_flavour = pathlib._windows_flavour
	223	+	_flavour = pathlib._windows_flavour # type: ignore[attr-defined]
197	224		__slots__ = ()
198	225
199	226

227	268		)
228	269		)
229	270
230		-	def __hash__(self):
	271	+	def __hash__(self) -> int:
231	272		"""Hash."""
232	273
233	274		return self._hash
234	275
235		-	def __len__(self):
	276	+	def __len__(self) -> int:
236	277		"""Length."""
237	278
238	279		return len(self._include) + (len(self._exclude) if self._exclude is not None else 0)
239	280
240		-	def __eq__(self, other):
	281	+	def __eq__(self, other: Any) -> bool:
241	282		"""Equal."""
242	283
243	284		return (

261	302		self._follow != other._follow
262	303		)
263	304
264		-	def match(self, filename, root_dir=None, dir_fd=None):
	305	+	def match(self, filename: AnyStr, root_dir: Optional[AnyStr] = None, dir_fd: Optional[int] = None) -> bool:
265	306		"""Match filename."""
266	307
267	308		return _Match(

277	318		)
278	319
279	320
280		-	def _pickle(p):
	321	+	def _pickle(p): # type: ignore[no-untyped-def]
281	322		return WcRegexp, (p._include, p._exclude, p._real, p._path, p._follow)
282	323
283	324

345	355		return drive + magic.sub(replace, pattern)
346	356
347	357
348		-	def _get_win_drive(pattern, regex=False, case_sensitive=False):
	358	+	def _get_win_drive(
	359	+	pattern: str,
	360	+	regex: bool = False,
	361	+	case_sensitive: bool = False
	362	+	) -> Tuple[bool, Optional[str], bool, int]:
349	363		"""Get Windows drive."""
350	364
351	365		drive = None

392	406		return root_specified, drive, slash, end
393	407
394	408
395		-	def _get_magic_symbols(ptype, unix, flags):
	409	+	def _get_magic_symbols(pattern: AnyStr, unix: bool, flags: int) -> Tuple[Set[AnyStr], Set[AnyStr]]:
396	410		"""Get magic symbols."""
397	411
398		-	if ptype == util.BYTES:
399		-	slash = b'\\'
	412	+	if isinstance(pattern, bytes):
	413	+	ptype = util.BYTES
	414	+	slash = b'\\' # type: AnyStr
400	415		else:
	416	+	ptype = util.UNICODE
401	417		slash = '\\'
402	418
403		-	magic = set()
404		-	magic_drive = set() if unix else set(slash)
	419	+	magic = set() # type: Set[AnyStr]
	420	+	if unix:
	421	+	magic_drive = set() # type: Set[AnyStr]
	422	+	else:
	423	+	magic_drive = set([slash])
405	424
406		-	magic \|= MAGIC_DEF[ptype]
	425	+	magic \|= cast(Set[AnyStr], MAGIC_DEF[ptype])
407	426		if flags & BRACE:
408		-	magic \|= MAGIC_BRACE[ptype]
409		-	magic_drive \|= MAGIC_BRACE[ptype]
	427	+	magic \|= cast(Set[AnyStr], MAGIC_BRACE[ptype])
	428	+	magic_drive \|= cast(Set[AnyStr], MAGIC_BRACE[ptype])
410	429		if flags & SPLIT:
411		-	magic \|= MAGIC_SPLIT[ptype]
412		-	magic_drive \|= MAGIC_SPLIT[ptype]
	430	+	magic \|= cast(Set[AnyStr], MAGIC_SPLIT[ptype])
	431	+	magic_drive \|= cast(Set[AnyStr], MAGIC_SPLIT[ptype])
413	432		if flags & GLOBTILDE:
414		-	magic \|= MAGIC_TILDE[ptype]
	433	+	magic \|= cast(Set[AnyStr], MAGIC_TILDE[ptype])
415	434		if flags & EXTMATCH:
416		-	magic \|= MAGIC_EXTMATCH[ptype]
	435	+	magic \|= cast(Set[AnyStr], MAGIC_EXTMATCH[ptype])
417	436		if flags & NEGATE:
418	437		if flags & MINUSNEGATE:
419		-	magic \|= MAGIC_MINUS_NEGATE[ptype]
	438	+	magic \|= cast(Set[AnyStr], MAGIC_MINUS_NEGATE[ptype])
420	439		else:
421		-	magic \|= MAGIC_NEGATE[ptype]
	440	+	magic \|= cast(Set[AnyStr], MAGIC_NEGATE[ptype])
422	441
423	442		return magic, magic_drive
424	443
425	444
426		-	def is_magic(pattern, flags=0):
	445	+	def is_magic(pattern: AnyStr, flags: int = 0) -> bool:
427	446		"""Check if pattern is magic."""
428	447
429	448		magical = False
430	449		unix = is_unix_style(flags)
431	450
432		-	ptype = util.BYTES if isinstance(pattern, bytes) else util.UNICODE
433		-	drive_pat = RE_WIN_DRIVE[ptype]
	451	+	if isinstance(pattern, bytes):
	452	+	ptype = util.BYTES
	453	+	else:
	454	+	ptype = util.UNICODE
	455	+
	456	+	drive_pat = cast(Pattern[AnyStr], RE_WIN_DRIVE[ptype])
434	457
435		-	magic, magic_drive = _get_magic_symbols(ptype, unix, flags)
	458	+	magic, magic_drive = _get_magic_symbols(pattern, unix, flags)
436	459		is_path = flags & PATHNAME
437	460
438	461		length = 0

4	4		import stat
5	5		import copyreg
6	6		from . import util
	7	+	from typing import Pattern, Tuple, AnyStr, Optional, Generic, Any, Dict, cast
7	8
8	9		# `O_DIRECTORY` may not always be defined
9	10		DIR_FLAGS = os.O_RDONLY \| getattr(os, 'O_DIRECTORY', 0)

21	22		)
22	23
23	24
24		-	class _Match:
	25	+	class _Match(Generic[AnyStr]):
25	26		"""Match the given pattern."""
26	27
27		-	def __init__(self, filename, include, exclude, real, path, follow):
	28	+	def __init__(
	29	+	self,
	30	+	filename: AnyStr,
	31	+	include: Tuple[Pattern[AnyStr], ...],
	32	+	exclude: Optional[Tuple[Pattern[AnyStr], ...]],
	33	+	real: bool,
	34	+	path: bool,
	35	+	follow: bool
	36	+	) -> None:
28	37		"""Initialize."""
29	38
30		-	self.filename = filename
31		-	self.include = include
32		-	self.exclude = exclude
	39	+	self.filename = filename # type: AnyStr
	40	+	self.include = include # type: Tuple[Pattern[AnyStr], ...]
	41	+	self.exclude = exclude # type: Optional[Tuple[Pattern[AnyStr], ...]]
33	42		self.real = real
34	43		self.path = path
35	44		self.follow = follow
36		-	self.is_bytes = isinstance(self.filename, bytes)
37		-	self.ptype = util.BYTES if self.is_bytes else util.UNICODE
38		-
39		-	def _fs_match(self, pattern, filename, is_dir, sep, follow, symlinks, root, dir_fd):
	45	+	self.ptype = util.BYTES if isinstance(self.filename, bytes) else util.UNICODE
	46	+
	47	+	def _fs_match(
	48	+	self,
	49	+	pattern: Pattern[AnyStr],
	50	+	filename: AnyStr,
	51	+	is_dir: bool,
	52	+	sep: AnyStr,
	53	+	follow: bool,
	54	+	symlinks: Dict[Tuple[Optional[int], AnyStr], bool],
	55	+	root: AnyStr,
	56	+	dir_fd: Optional[int]
	57	+	) -> bool:
40	58		"""
41	59		Match path against the pattern.
42	60

98	116		matched = False
99	117		return matched
100	118
101		-	def _match_real(self, symlinks, root, dir_fd):
	119	+	def _match_real(
	120	+	self,
	121	+	symlinks: Dict[Tuple[Optional[int], AnyStr], bool],
	122	+	root: AnyStr,
	123	+	dir_fd: Optional[int]
	124	+	) -> bool:
102	125		"""Match real filename includes and excludes."""
103	126
104		-	sep = '\\' if util.platform() == "windows" else '/'
	127	+	temp = '\\' if util.platform() == "windows" else '/'
105	128		if isinstance(self.filename, bytes):
106		-	sep = os.fsencode(sep)
	129	+	sep = os.fsencode(temp)
	130	+	else:
	131	+	sep = temp
107	132
108	133		is_dir = self.filename.endswith(sep)
109	134		try:

140	165
141	166		return matched
142	167
143		-	def match(self, root_dir=None, dir_fd=None):
	168	+	def match(self, root_dir: Optional[AnyStr] = None, dir_fd: Optional[int] = None) -> bool:
144	169		"""Match."""
145	170
146	171		if self.real:
147		-	root = root_dir if root_dir else (b'.' if self.is_bytes else '.')
	172	+	if isinstance(self.filename, bytes):
	173	+	root = root_dir if root_dir is not None else b'.' # type: AnyStr
	174	+	else:
	175	+	root = root_dir if root_dir is not None else '.'
148	176
149	177		if dir_fd is not None and not SUPPORT_DIR_FD:
150	178		dir_fd = None

163	191		)
164	192		)
165	193
166		-	is_abs = (
167		-	RE_WIN_MOUNT if util.platform() == "windows" else RE_MOUNT
168		-	)[self.ptype].match(self.filename) is not None
	194	+	re_mount = cast(Pattern[AnyStr], (RE_WIN_MOUNT if util.platform() == "windows" else RE_MOUNT)[self.ptype])
	195	+	is_abs = re_mount.match(self.filename) is not None
169	196
170	197		if is_abs:
171	198		exists = os.path.lexists(self.filename)

180	207		exists = True
181	208
182	209		if exists:
183		-	symlinks = {}
	210	+	symlinks = {} # type: Dict[Tuple[Optional[int], AnyStr], bool]
184	211		return self._match_real(symlinks, root, dir_fd)
185	212		else:
186	213		return False

201	228		return matched
202	229
203	230
204		-	class WcRegexp(util.Immutable):
	231	+	class WcRegexp(util.Immutable, Generic[AnyStr]):
205	232		"""File name match object."""
206	233
	234	+	_include: Tuple[Pattern[AnyStr], ...]
	235	+	_exclude: Optional[Tuple[Pattern[AnyStr], ...]]
	236	+	_real: bool
	237	+	_path: bool
	238	+	_follow: bool
	239	+	_hash: int
	240	+
207	241		__slots__ = ("_include", "_exclude", "_real", "_path", "_follow", "_hash")
208	242
209		-	def __init__(self, include, exclude=None, real=False, path=False, follow=False):
	243	+	def __init__(
	244	+	self,
	245	+	include: Tuple[Pattern[AnyStr], ...],
	246	+	exclude: Optional[Tuple[Pattern[AnyStr], ...]] = None,
	247	+	real: bool = False,
	248	+	path: bool = False,
	249	+	follow: bool = False
	250	+	):
210	251		"""Initialization."""
211	252
212		-	super(WcRegexp, self).__init__(
	253	+	super().__init__(
213	254		_include=include,
214	255		_exclude=exclude,
215	256		_real=real,

249	290		self._follow == other._follow
250	291		)
251	292
252		-	def __ne__(self, other):
	293	+	def __ne__(self, other: Any) -> bool:
253	294		"""Equal."""
254	295
255	296		return (

7	7		import unicodedata
8	8		from functools import wraps
9	9		import warnings
	10	+	from typing import Any, Callable, Tuple, AnyStr, Match, Pattern, Optional, cast
10	11
11	12		PY37 = (3, 7) <= sys.version_info
12	13		PY310 = (3, 10) <= sys.version_info

64	65		_PLATFORM = "linux"
65	66
66	67
67		-	def platform():
	68	+	def platform() -> str:
68	69		"""Get platform."""
69	70
70	71		return _PLATFORM
71	72
72	73
73		-	def is_case_sensitive():
	74	+	def is_case_sensitive() -> bool:
74	75		"""Check if case sensitive."""
75	76
76	77		return CASE_FS
77	78
78	79
79		-	def to_tuple(values):
80		-	"""Combine values."""
81		-
82		-	return (values,) if isinstance(values, (str, bytes)) else tuple(values)
83		-
84		-
85		-	def norm_pattern(pattern, normalize, is_raw_chars, ignore_escape=False):
	80	+	def norm_pattern(pattern: AnyStr, normalize: Optional[bool], is_raw_chars: bool, ignore_escape: bool = False) -> AnyStr:
86	81		r"""
87	82		Normalize pattern.
88	83

92	87		- If `normalize` is enabled, take care to convert \/ to \\\\.
93	88		"""
94	89
95		-	is_bytes = isinstance(pattern, bytes)
	90	+	if isinstance(pattern, bytes):
	91	+	is_bytes = True
	92	+	slash = b'\\'
	93	+	multi_slash = slash * 4
	94	+	pat = RE_BNORM
	95	+	else:
	96	+	is_bytes = False
	97	+	slash = '\\'
	98	+	multi_slash = slash * 4
	99	+	pat = RE_NORM
96	100
97	101		if not normalize and not is_raw_chars and not ignore_escape:
98	102		return pattern
99	103
100		-	def norm(m):
	104	+	def norm(m: Match[AnyStr]) -> AnyStr:
101	105		"""Normalize the pattern."""
102	106
103	107		if m.group(1):
104	108		char = m.group(1)
105		-	if normalize:
106		-	char = br'\\\\' if is_bytes else r'\\\\' if len(char) > 1 else char
	109	+	if normalize and len(char) > 1:
	110	+	char = multi_slash
107	111		elif m.group(2):
108		-	char = BACK_SLASH_TRANSLATION[m.group(2)] if is_raw_chars else m.group(2)
	112	+	char = cast(AnyStr, BACK_SLASH_TRANSLATION[m.group(2)] if is_raw_chars else m.group(2))
109	113		elif is_raw_chars and m.group(4):
110		-	char = bytes([int(m.group(4), 8) & 0xFF]) if is_bytes else chr(int(m.group(4), 8))
	114	+	char = cast(AnyStr, bytes([int(m.group(4), 8) & 0xFF]) if is_bytes else chr(int(m.group(4), 8)))
111	115		elif is_raw_chars and m.group(3):
112		-	char = bytes([int(m.group(3)[2:], 16)]) if is_bytes else chr(int(m.group(3)[2:], 16))
	116	+	char = cast(AnyStr, bytes([int(m.group(3)[2:], 16)]) if is_bytes else chr(int(m.group(3)[2:], 16)))
113	117		elif is_raw_chars and not is_bytes and m.group(5):
114		-	char = unicodedata.lookup(m.group(5)[3:-1])
	118	+	char = unicodedata.lookup(m.group(5)[3:-1]) # type: ignore[assignment]
115	119		elif not is_raw_chars or m.group(5 if is_bytes else 6):
116	120		char = m.group(0)
117	121		if ignore_escape:
118		-	char = (b'\\' if is_bytes else '\\') + char
	122	+	char = slash + char
119	123		else:
120	124		value = m.group(6) if is_bytes else m.group(7)
121	125		pos = m.start(6) if is_bytes else m.start(7)
122		-	raise SyntaxError("Could not convert character value {} at position {:d}".format(value, pos))
	126	+	raise SyntaxError("Could not convert character value {!r} at position {:d}".format(value, pos))
123	127		return char
124	128
125		-	return (RE_BNORM if is_bytes else RE_NORM).sub(norm, pattern)
	129	+	return pat.sub(norm, pattern)
126	130
127	131
128		-	class StringIter(object):
	132	+	class StringIter:
129	133		"""Preprocess replace tokens."""
130	134
131		-	def __init__(self, string):
	135	+	def __init__(self, string: str) -> None:
132	136		"""Initialize."""
133	137
134	138		self._string = string
135	139		self._index = 0
136	140
137		-	def __iter__(self):
	141	+	def __iter__(self) -> "StringIter":
138	142		"""Iterate."""
139	143
140	144		return self
141	145
142		-	def __next__(self):
	146	+	def __next__(self) -> str:
143	147		"""Python 3 iterator compatible next."""
144	148
145	149		return self.iternext()
146	150
147		-	def match(self, pattern):
	151	+	def match(self, pattern: Pattern[str]) -> Optional[Match[str]]:
148	152		"""Perform regex match at index."""
149	153
150	154		m = pattern.match(self._string, self._index)

153	157		return m
154	158
155	159		@property
156		-	def index(self):
	160	+	def index(self) -> int:
157	161		"""Get current index."""
158	162
159	163		return self._index
160	164
161		-	def previous(self): # pragma: no cover
	165	+	def previous(self) -> str: # pragma: no cover
162	166		"""Get previous char."""
163	167
164	168		return self._string[self._index - 1]
165	169
166		-	def advance(self, count): # pragma: no cover
	170	+	def advance(self, count: int) -> None: # pragma: no cover
167	171		"""Advanced the index."""
168	172
169	173		self._index += count
170	174
171		-	def rewind(self, count):
	175	+	def rewind(self, count: int) -> None:
172	176		"""Rewind index."""
173	177
174	178		if count > self._index: # pragma: no cover

176	180
177	181		self._index -= count
178	182
179		-	def iternext(self):
	183	+	def iternext(self) -> str:
180	184		"""Iterate through characters of the string."""
181	185
182	186		try:

188	192		return char
189	193
190	194
191		-	class Immutable(object):
	195	+	class Immutable:
192	196		"""Immutable."""
193	197
194		-	__slots__ = tuple()
	198	+	__slots__: Tuple[Any, ...] = tuple()
195	199
196		-	def __init__(self, **kwargs):
	200	+	def __init__(self, **kwargs: Any) -> None:
197	201		"""Initialize."""
198	202
199	203		for k, v in kwargs.items():
200	204		super(Immutable, self).__setattr__(k, v)
201	205
202		-	def __setattr__(self, name, value): # pragma: no cover
	206	+	def __setattr__(self, name: str, value: Any) -> None: # pragma: no cover
203	207		"""Prevent mutability."""
204	208
205	209		raise AttributeError('Class is immutable!')
206	210
207	211
208		-	def is_hidden(path):
	212	+	def is_hidden(path: AnyStr) -> bool:
209	213		"""Check if file is hidden."""
210	214
211	215		hidden = False

213	217		if f[:1] in ('.', b'.'):
214	218		# Count dot file as hidden on all systems
215	219		hidden = True
216		-	elif _PLATFORM == 'windows':
	220	+	elif sys.platform == 'win32':
217	221		# On Windows, look for `FILE_ATTRIBUTE_HIDDEN`
218		-	FILE_ATTRIBUTE_HIDDEN = 0x2
219	222		results = os.lstat(path)
	223	+	FILE_ATTRIBUTE_HIDDEN = 0x2
220	224		hidden = bool(results.st_file_attributes & FILE_ATTRIBUTE_HIDDEN)
221		-	elif _PLATFORM == "osx": # pragma: no cover
	225	+	elif sys.platform == "darwin": # pragma: no cover
222	226		# On macOS, look for `UF_HIDDEN`
223	227		results = os.lstat(path)
224	228		hidden = bool(results.st_flags & stat.UF_HIDDEN)
225	229		return hidden
226	230
227	231
228		-	def deprecated(message, stacklevel=2): # pragma: no cover
	232	+	def deprecated(message: str, stacklevel: int = 2) -> Callable[..., Any]: # pragma: no cover
229	233		"""
230	234		Raise a `DeprecationWarning` when wrapped function/method is called.
231	235

236	240		pass
237	241		"""
238	242
239		-	def _wrapper(func):
	243	+	def _wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
240	244		@wraps(func)
241		-	def _deprecated_func(args, *kwargs):
	245	+	def _deprecated_func(args: Any, *kwargs: Any) -> Any:
242	246		warnings.warn(
243	247		f"'{func.__name__}' is deprecated. {message}",
244	248		category=DeprecationWarning,

249	253		return _wrapper
250	254
251	255
252		-	def warn_deprecated(message, stacklevel=2): # pragma: no cover
	256	+	def warn_deprecated(message: str, stacklevel: int = 2) -> None: # pragma: no cover
253	257		"""Warn deprecated."""
254	258
255	259		warnings.warn(

21	21		IN THE SOFTWARE.
22	22		"""
23	23		from .__meta__ import __version_info__, __version__ # noqa: F401
24		-
25		-	__all__ = tuple()

27	27		from . import util
28	28		from . import posix
29	29		from . _wcmatch import WcRegexp
	30	+	from typing import List, Tuple, AnyStr, Iterable, Pattern, Generic, Optional, Set, Sequence, Union, cast
30	31
31	32		UNICODE_RANGE = '\u0000-\U0010ffff'
32	33		ASCII_RANGE = '\x00-\xff'

298	299		"""Pattern limit exception."""
299	300
300	301
301		-	def escape(pattern, unix=None, pathname=True, raw=False):
	302	+	def to_str_sequence(patterns: Union[str, bytes, Sequence[AnyStr]]) -> Sequence[AnyStr]:
	303	+	"""Return a simple string sequence."""
	304	+
	305	+	if isinstance(patterns, (str, bytes)):
	306	+	return cast(Sequence[AnyStr], [patterns])
	307	+	else:
	308	+	return patterns
	309	+
	310	+
	311	+	def escape(pattern: AnyStr, unix: Optional[bool] = None, pathname: bool = True, raw: bool = False) -> AnyStr:
302	312		"""
303	313		Escape.
304	314

Updating our web app

309	319		"""
310	320
311	321		if isinstance(pattern, bytes):
312		-	drive_pat = RE_WIN_DRIVE[util.BYTES]
313		-	magic = RE_MAGIC_ESCAPE[util.BYTES]
314		-	drive_magic = RE_WIN_DRIVE_MAGIC[util.BYTES]
	322	+	drive_pat = cast(Pattern[AnyStr], RE_WIN_DRIVE[util.BYTES])
	323	+	magic = cast(Pattern[AnyStr], RE_MAGIC_ESCAPE[util.BYTES])
	324	+	drive_magic = cast(Pattern[AnyStr], RE_WIN_DRIVE_MAGIC[util.BYTES])
315	325		replace = br'\\\1'
316	326		slash = b'\\'
317	327		double_slash = b'\\\\'
318	328		drive = b''
319	329		else:
320		-	drive_pat = RE_WIN_DRIVE[util.UNICODE]
321		-	magic = RE_MAGIC_ESCAPE[util.UNICODE]
322		-	drive_magic = RE_WIN_DRIVE_MAGIC[util.UNICODE]
	330	+	drive_pat = cast(Pattern[AnyStr], RE_WIN_DRIVE[util.UNICODE])
	331	+	magic = cast(Pattern[AnyStr], RE_MAGIC_ESCAPE[util.UNICODE])
	332	+	drive_magic = cast(Pattern[AnyStr], RE_WIN_DRIVE_MAGIC[util.UNICODE])
323	333		replace = r'\\\1'
324	334		slash = '\\'
325	335		double_slash = '\\\\'

456	479		return magical
457	480
458	481
459		-	def is_negative(pattern, flags):
	482	+	def is_negative(pattern: AnyStr, flags: int) -> bool:
460	483		"""Check if negative pattern."""
461	484
462	485		if flags & MINUSNEGATE:
463		-	return flags & NEGATE and pattern[0:1] in MINUS_NEGATIVE_SYM
	486	+	return bool(flags & NEGATE and pattern[0:1] in MINUS_NEGATIVE_SYM)
464	487		elif flags & EXTMATCH:
465		-	return flags & NEGATE and pattern[0:1] in NEGATIVE_SYM and pattern[1:2] not in ROUND_BRACKET
	488	+	return bool(flags & NEGATE and pattern[0:1] in NEGATIVE_SYM and pattern[1:2] not in ROUND_BRACKET)
466	489		else:
467		-	return flags & NEGATE and pattern[0:1] in NEGATIVE_SYM
	490	+	return bool(flags & NEGATE and pattern[0:1] in NEGATIVE_SYM)
468	491
469	492
470		-	def tilde_pos(pattern, flags):
	493	+	def tilde_pos(pattern: AnyStr, flags: int) -> int:
471	494		"""Is user folder."""
472	495
473	496		pos = -1

482	505		return pos
483	506
484	507
485		-	def expand_braces(patterns, flags, limit):
	508	+	def expand_braces(patterns: AnyStr, flags: int, limit: int) -> Iterable[AnyStr]:
486	509		"""Expand braces."""
487	510
488	511		if flags & BRACE:

502	525		yield p
503	526
504	527
505		-	def expand_tilde(pattern, is_unix, flags):
	528	+	def expand_tilde(pattern: AnyStr, is_unix: bool, flags: int) -> AnyStr:
506	529		"""Expand tilde."""
507	530
508	531		pos = tilde_pos(pattern, flags)
509	532
510	533		if pos > -1:
511	534		string_type = util.BYTES if isinstance(pattern, bytes) else util.UNICODE
512		-	tilde = TILDE_SYM[string_type]
513		-	re_tilde = RE_WIN_TILDE[string_type] if not is_unix else RE_TILDE[string_type]
	535	+	tilde = cast(AnyStr, TILDE_SYM[string_type])
	536	+	re_tilde = cast(Pattern[AnyStr], RE_WIN_TILDE[string_type] if not is_unix else RE_TILDE[string_type])
514	537		m = re_tilde.match(pattern, pos)
515	538		if m:
516	539		expanded = os.path.expanduser(m.group(0))
517	540		if not expanded.startswith(tilde) and os.path.exists(expanded):
518		-	pattern = (pattern[0] if pos else pattern[0:0]) + escape(expanded, is_unix) + pattern[m.end(0):]
	541	+	pattern = (pattern[0:1] if pos else pattern[0:0]) + escape(expanded, is_unix) + pattern[m.end(0):]
519	542		return pattern
520	543
521	544
522		-	def expand(pattern, flags, limit):
	545	+	def expand(pattern: AnyStr, flags: int, limit: int) -> Iterable[AnyStr]:
523	546		"""Expand and normalize."""
524	547
525	548		for expanded in expand_braces(pattern, flags, limit):

527	550		yield expand_tilde(splitted, is_unix_style(flags), flags)
528	551
529	552
530		-	def is_case_sensitive(flags):
	553	+	def is_case_sensitive(flags: int) -> bool:
531	554		"""Is case sensitive."""
532	555
533	556		if bool(flags & FORCEWIN):

539	562		return case_sensitive
540	563
541	564
542		-	def get_case(flags):
	565	+	def get_case(flags: int) -> bool:
543	566		"""Parse flags for case sensitivity settings."""
544	567
545	568		if not bool(flags & CASE_FLAGS):

551	574		return case_sensitive
552	575
553	576
554		-	def escape_drive(drive, case):
	577	+	def escape_drive(drive: str, case: bool) -> str:
555	578		"""Escape drive."""
556	579
557	580		return '(?i:{})'.format(re.escape(drive)) if case else re.escape(drive)
558	581
559	582
560		-	def is_unix_style(flags):
	583	+	def is_unix_style(flags: int) -> bool:
561	584		"""Check if we should use Unix style."""
562	585
563	586		return (

569	592		)
570	593
571	594
572		-	def translate(patterns, flags, limit=PATTERN_LIMIT):
	595	+	def translate(
	596	+	patterns: Sequence[AnyStr],
	597	+	flags: int,
	598	+	limit: int = PATTERN_LIMIT
	599	+	) -> Tuple[List[AnyStr], List[AnyStr]]:
573	600		"""Translate patterns."""
574	601
575		-	positive = []
576		-	negative = []
577		-	if isinstance(patterns, (str, bytes)):
578		-	patterns = [patterns]
	602	+	positive = [] # type: List[AnyStr]
	603	+	negative = [] # type: List[AnyStr]
579	604
580	605		flags = (flags \| _TRANSLATE) & FLAG_MASK
581	606		is_unix = is_unix_style(flags)

585	610		current_limit = limit
586	611		total = 0
587	612		for pattern in patterns:
588		-	pattern = util.norm_pattern(pattern, not is_unix, flags & RAWCHARS)
	613	+	pattern = util.norm_pattern(pattern, not is_unix, bool(flags & RAWCHARS))
589	614		count = 0
590	615		for count, expanded in enumerate(expand(pattern, flags, current_limit), 1):
591	616		total += 1

601	626		except bracex.ExpansionLimitException:
602	627		raise PatternLimitException("Pattern limit exceeded the limit of {:d}".format(limit))
603	628
604		-	if patterns and negative and not positive:
	629	+	if patterns is not None and negative and not positive:
605	630		if flags & NEGATEALL:
606	631		default = b'' if isinstance(patterns[0], bytes) else ''
607		-	positive.append(WcParse(default, flags \| (GLOBSTAR if flags & PATHNAME else 0)).parse())
	632	+	positive.append(
	633	+	WcParse(default, flags \| (GLOBSTAR if flags & PATHNAME else 0)).parse()
	634	+	)
608	635
609	636		if patterns and flags & NODIR:
610	637		index = util.BYTES if isinstance(patterns[0], bytes) else util.UNICODE
611		-	exclude = _NO_NIX_DIR[index] if is_unix else _NO_WIN_DIR[index]
	638	+	exclude = cast(AnyStr, _NO_NIX_DIR[index] if is_unix else _NO_WIN_DIR[index])
612	639		negative.append(exclude)
613	640
614	641		return positive, negative
615	642
616	643
617		-	def split(pattern, flags):
	644	+	def split(pattern: AnyStr, flags: int) -> Iterable[AnyStr]:
618	645		"""Split patterns."""
619	646
620	647		if flags & SPLIT: