Fixed tox

Author: atollk

fs/_ftp_parse.py

@@ -78,7 +78,7 @@ def parse(lines):
 
 def parse_line(line):
     for line_re, decode_callable in get_decoders():
-        match = line_re._match(line)
+        match = line_re.match(line)
         if match is not None:
             return decode_callable(line, match)
     return None

fs/base.py

@@ -539,22 +539,22 @@ def filterdir(
         def match_dir(patterns, info):
             # type: (Optional[Iterable[Text]], Info) -> bool
             """Pattern match info.name."""
-            return info.is_file or self._match(patterns, info.name)
+            return info.is_file or self.match(patterns, info.name)
 
         def match_file(patterns, info):
             # type: (Optional[Iterable[Text]], Info) -> bool
             """Pattern match info.name."""
-            return info.is_dir or self._match(patterns, info.name)
+            return info.is_dir or self.match(patterns, info.name)
 
         def exclude_dir(patterns, info):
             # type: (Optional[Iterable[Text]], Info) -> bool
             """Pattern match info.name."""
-            return info.is_file or not self._match(patterns, info.name)
+            return info.is_file or not self.match(patterns, info.name)
 
         def exclude_file(patterns, info):
             # type: (Optional[Iterable[Text]], Info) -> bool
             """Pattern match info.name."""
-            return info.is_dir or not self._match(patterns, info.name)
+            return info.is_dir or not self.match(patterns, info.name)
 
         if files:
             filters.append(partial(match_file, files))
@@ -1581,7 +1581,9 @@ def match(self, patterns, name, accept_prefix=False):
         case_sensitive = not typing.cast(
             bool, self.getmeta().get("case_insensitive", False)
         )
-        matcher = wildcard.get_matcher(patterns, case_sensitive, accept_prefix=accept_prefix)
+        matcher = wildcard.get_matcher(
+            patterns, case_sensitive, accept_prefix=accept_prefix
+        )
         return matcher(name)
 
     def tree(self, **kwargs):

fs/glob.py

@@ -27,6 +27,50 @@
 )  # type: LRUCache[Tuple[Text, bool], Tuple[int, bool, Pattern]]
 
 
+def _translate(pattern, case_sensitive=True):
+    # type: (Text, bool) -> Text
+    """Translate a wildcard pattern to a regular expression.
+    There is no way to quote meta-characters.
+    Arguments:
+        pattern (str): A wildcard pattern.
+        case_sensitive (bool): Set to `False` to use a case
+            insensitive regex (default `True`).
+    Returns:
+        str: A regex equivalent to the given pattern.
+    """
+    if not case_sensitive:
+        pattern = pattern.lower()
+    i, n = 0, len(pattern)
+    res = ""
+    while i < n:
+        c = pattern[i]
+        i = i + 1
+        if c == "*":
+            res = res + "[^/]*"
+        elif c == "?":
+            res = res + "."
+        elif c == "[":
+            j = i
+            if j < n and pattern[j] == "!":
+                j = j + 1
+            if j < n and pattern[j] == "]":
+                j = j + 1
+            while j < n and pattern[j] != "]":
+                j = j + 1
+            if j >= n:
+                res = res + "\\["
+            else:
+                stuff = pattern[i:j].replace("\\", "\\\\")
+                i = j + 1
+                if stuff[0] == "!":
+                    stuff = "^" + stuff[1:]
+                elif stuff[0] == "^":
+                    stuff = "\\" + stuff
+                res = "%s[%s]" % (res, stuff)
+        else:
+            res = res + re.escape(c)
+    return res
+
 def _translate_glob(pattern, case_sensitive=True):
     levels = 0
     recursive = False
@@ -37,7 +81,7 @@ def _translate_glob(pattern, case_sensitive=True):
             recursive = True
         else:
             re_patterns.append(
-                "/" + wildcard._translate(component, case_sensitive=case_sensitive)
+                "/" + _translate(component, case_sensitive=case_sensitive)
             )
         levels += 1
     re_glob = "(?ms)^" + "".join(re_patterns) + ("/$" if pattern.endswith("/") else "$")

fs/test.py

@@ -1783,9 +1783,9 @@ def test_movedir(self):
             self.fs.movedir("foo2/foofoo.txt", "foo2/baz/egg")
 
     def test_match(self):
-        self.assertTrue(self.fs._match(["*.py"], "foo.py"))
+        self.assertTrue(self.fs.match(["*.py"], "foo.py"))
         self.assertEqual(
-            self.fs._match(["*.py"], "FOO.PY"),
+            self.fs.match(["*.py"], "FOO.PY"),
             self.fs.getmeta().get("case_insensitive", False),
         )
 

fs/walk.py

@@ -276,7 +276,8 @@ def check_scan_dir(self, fs, path, info):
     def _check_file(self, fs, dir_path, info):
         # type: (FS, Text, Info) -> bool
         """Check if a filename should be included."""
-        # Weird check required for backwards compatibility, when _check_file did not exist.
+        # Weird check required for backwards compatibility,
+        # when _check_file did not exist.
         if Walker._check_file == type(self)._check_file:
             if self.exclude is not None and fs.match(self.exclude, info.name):
                 return False

fs/wildcard.py

@@ -1,12 +1,12 @@
 """Match wildcard filenames.
 
-    Patterns are derived from Unix shell style:
+Patterns are derived from Unix shell style:
 
-    *       matches everything except for a path seperator
-    **      matches everything
-    ?       matches any single character
-    [seq]   matches any character in seq
-    [!seq]  matches any char not in seq
+*       matches everything except for a path seperator
+**      matches everything
+?       matches any single character
+[seq]   matches any character in seq
+[!seq]  matches any char not in seq
 """
 
 from __future__ import unicode_literals, print_function
@@ -19,7 +19,9 @@
     from typing import Callable, Iterable, Text, Tuple
 
 
-_PATTERN_CACHE = LRUCache(1000)  # type: LRUCache[Tuple[Text, bool, bool], PatternMatcher]
+_PATTERN_CACHE = LRUCache(
+    1000
+)  # type: LRUCache[Tuple[Text, bool, bool], _PatternMatcher]
 
 
 def match(pattern, name, accept_prefix=False):
@@ -38,7 +40,7 @@ def match(pattern, name, accept_prefix=False):
     try:
         pat = _PATTERN_CACHE[args]
     except KeyError:
-        pat = PatternMatcher(*args)
+        pat = _PatternMatcher(*args)
         _PATTERN_CACHE[args] = pat
     return pat(name)
 
@@ -59,7 +61,7 @@ def imatch(pattern, name, accept_prefix=False):
     try:
         pat = _PATTERN_CACHE[args]
     except KeyError:
-        pat = PatternMatcher(*args)
+        pat = _PatternMatcher(*args)
         _PATTERN_CACHE[args] = pat
     return pat(name)
 
@@ -138,7 +140,7 @@ def get_matcher(patterns, case_sensitive, accept_prefix=False):
         return lambda name: imatch_any(patterns, name, accept_prefix)
 
 
-class PatternMatcher:
+class _PatternMatcher:
     def __init__(self, pattern, case_sensitive, accept_prefixes):
         self.case_sensitive = case_sensitive
         self.accept_prefixes = accept_prefixes
@@ -151,16 +153,24 @@ def __init__(self, pattern, case_sensitive, accept_prefixes):
                 i = pattern.find("]", i) + 1
                 self.tokens.append(_PatternMatcherToken(pattern[start:i]))
             elif pattern[i] == "]":
-                raise ValueError(pattern + " is not a valid wildcard pattern. (unmatched ])")
+                raise ValueError(
+                    pattern + " is not a valid wildcard pattern. (unmatched ])"
+                )
             elif pattern[i] == "?":
                 self.tokens.append(_PatternMatcherToken("?"))
                 i += 1
             elif pattern[i] == "*":
                 asterik_len = 1
-                while (asterik_len + i) < len(pattern) and pattern[asterik_len + i] == "*":
+                while (asterik_len + i) < len(pattern) and pattern[
+                    asterik_len + i
+                ] == "*":
                     asterik_len += 1
                 if asterik_len > 2:
-                    raise ValueError(pattern + " is not a valid wildcard pattern. (sequence of three or more *)")
+                    raise ValueError(
+                        pattern
+                        + " is not a valid wildcard pattern. "
+                        + "(sequence of three or more *)"
+                    )
                 self.tokens.append(_PatternMatcherToken("*" * asterik_len))
                 i += asterik_len
             else:

tests/test_walk.py

@@ -314,6 +314,16 @@ def test_walk_files_filter(self):
 
         self.assertEqual(files, [])
 
+    def test_walk_files_filter_glob(self):
+        files = list(self.fs.walk.files(filter_glob=["/foo2/**"]))
+        self.assertEqual(
+            files,
+            [
+                "/foo2/top3.bin",
+                "/foo2/bar2/bar3/test.txt",
+            ],
+        )
+
     def test_walk_files_exclude(self):
         # Test exclude argument works
         files = list(self.fs.walk.files(exclude=["*.txt"]))