GH-73435: Implement recursive wildcards in pathlib.PurePath.match()

Doc/library/pathlib.rst

@@ -568,13 +568,24 @@ Pure paths provide the following methods and properties:
  >>> PurePath('a/b.py').match('/*.py')
  False
 
+ The *pattern* may be another path object; this speeds up matching the same
+ pattern against multiple files::
+
+ >>> pattern = PurePath('*.py')
+ >>> PurePath('a/b.py').match(pattern)
+ True
+
  As with other methods, case-sensitivity follows platform defaults::
 
  >>> PurePosixPath('b.py').match('*.PY')
  False
  >>> PureWindowsPath('b.py').match('*.PY')
  True
 
+ .. versionchanged:: 3.12
+ Support for the recursive wildcard "``**``" was added. In previous
+ versions, it acted like the non-recursive wildcard "``*``".
+
 
 .. method:: PurePath.relative_to(other, walk_up=False)
 

Doc/whatsnew/3.12.rst

@@ -365,6 +365,9 @@ pathlib
 * Add :meth:`pathlib.Path.is_junction` as a proxy to :func:`os.path.isjunction`.
  (Contributed by Charles Machalow in :gh:`99547`.)
 
+* Add support for recursive wildcards in :meth:`pathlib.PurePath.match`.
+ (Contributed by Barney Gale in :gh:`101398`.)
+
 
 dis
 ---

Lib/pathlib.py

@@ -61,6 +61,15 @@ def _is_case_sensitive(flavour):
 # Globbing helpers
 #
 
+
+_FNMATCH_PREFIX, _FNMATCH_SUFFIX = fnmatch.translate('_').split('_')
+_FNMATCH_SLICE = slice(len(_FNMATCH_PREFIX), -len(_FNMATCH_SUFFIX))
+_SWAP_SEP_AND_NEWLINE = {
+ '/': str.maketrans({'/': '\n', '\n': '/'}),
+ '\\': str.maketrans({'\\': '\n', '\n': '\\'}),
+}
+
+
 @functools.lru_cache()
 def _make_selector(pattern_parts, flavour, case_sensitive):
  pat = pattern_parts[0]
@@ -271,6 +280,13 @@ class PurePath(object):
  # to implement comparison methods like `__lt__()`.
  '_parts_normcase_cached',
 
+ # The `_lines_cached` and `_matcher_cached` slots store the
+ # string path with path separators and newlines swapped, and an
+ # `re.Pattern` object derived thereof. These are used to implement
+ # `match()`.
+ '_lines_cached',
+ '_matcher_cached',
+
  # The `_hash` slot stores the hash of the case-normalized string
  # path. It's set when `__hash__()` is called for the first time.
  '_hash',
@@ -430,6 +446,41 @@ def _parts_normcase(self):
  self._parts_normcase_cached = self._str_normcase.split(self._flavour.sep)
  return self._parts_normcase_cached
 
+ @property
+ def _lines(self):
+ # Path with separators and newlines swapped, for pattern matching.
+ try:
+ return self._lines_cached
+ except AttributeError:
+ trans = _SWAP_SEP_AND_NEWLINE[self._flavour.sep]
+ self._lines_cached = str(self).translate(trans)
+ return self._lines_cached
+
+ @property
+ def _matcher(self):
+ try:
+ return self._matcher_cached
+ except AttributeError:
+ if not self.parts:
+ raise ValueError("empty pattern")
+ parts = [r'\A' if self.drive or self.root else '^']
+ for part in self._lines.splitlines(keepends=True):
+ if part == '**\n':
+ part = r'[\s\S]*^'
+ elif part == '**':
+ part = r'[\s\S]*'
+ elif '**' in part:
+ raise ValueError("Invalid pattern: '**' can only be an entire path component")
+ else:
+ part = fnmatch.translate(part)[_FNMATCH_SLICE]
+ parts.append(part)
+ parts.append(r'\Z')
+ flags = re.MULTILINE
+ if not _is_case_sensitive(self._flavour):
+ flags |= re.IGNORECASE
+ self._matcher_cached = re.compile(''.join(parts), flags=flags)
+ return self._matcher_cached
+
  def __eq__(self, other):
  if not isinstance(other, PurePath):
  return NotImplemented
@@ -686,20 +737,11 @@ def match(self, path_pattern):
  """
  Return True if this path matches the given pattern.
  """
- pat = self.with_segments(path_pattern)
- if not pat.parts:
- raise ValueError("empty pattern")
- pat_parts = pat._parts_normcase
- parts = self._parts_normcase
- if pat.drive or pat.root:
- if len(pat_parts) != len(parts):
- return False
- elif len(pat_parts) > len(parts):
- return False
- for part, pat in zip(reversed(parts), reversed(pat_parts)):
- if not fnmatch.fnmatchcase(part, pat):
- return False
- return True
+ if not isinstance(path_pattern, PurePath) or self._flavour is not path_pattern._flavour:
+ path_pattern = self.with_segments(path_pattern)
+ match = path_pattern._matcher.search(self._lines)
+ return match is not None
+
 
 # Can't subclass os.PathLike from PurePath and keep the constructor
 # optimizations in PurePath.__slots__.

Lib/test/test_pathlib.py

@@ -310,8 +310,30 @@ def test_match_common(self):
  self.assertFalse(P('/ab.py').match('/a/*.py'))
  self.assertFalse(P('/a/b/c.py').match('/a/*.py'))
  # Multi-part glob-style pattern.
- self.assertFalse(P('/a/b/c.py').match('/**/*.py'))
+ self.assertTrue(P('a').match('**'))
+ self.assertTrue(P('c.py').match('**'))
+ self.assertTrue(P('a/b/c.py').match('**'))
+ self.assertTrue(P('/a/b/c.py').match('**'))
+ self.assertTrue(P('/a/b/c.py').match('/**'))
+ self.assertTrue(P('/a/b/c.py').match('**/'))
+ self.assertTrue(P('/a/b/c.py').match('/a/**'))
+ self.assertTrue(P('/a/b/c.py').match('**/*.py'))
+ self.assertTrue(P('/a/b/c.py').match('/**/*.py'))
  self.assertTrue(P('/a/b/c.py').match('/a/**/*.py'))
+ self.assertTrue(P('/a/b/c.py').match('/a/b/**/*.py'))
+ self.assertTrue(P('/a/b/c.py').match('/**/**/**/**/*.py'))
+ self.assertFalse(P('c.py').match('**/a.py'))
+ self.assertFalse(P('c.py').match('c/**'))
+ self.assertFalse(P('a/b/c.py').match('**/a'))
+ self.assertFalse(P('a/b/c.py').match('**/a/b'))
+ self.assertFalse(P('a/b/c.py').match('**/a/b/c'))
+ self.assertFalse(P('a/b/c.py').match('**/a/b/c.'))
+ self.assertFalse(P('a/b/c.py').match('**/a/b/c./**'))
+ self.assertFalse(P('a/b/c.py').match('**/a/b/c./**'))
+ self.assertFalse(P('a/b/c.py').match('/a/b/c.py/**'))
+ self.assertFalse(P('a/b/c.py').match('/**/a/b/c.py'))
+ self.assertRaises(ValueError, P('a').match, '**a/b/c')
+ self.assertRaises(ValueError, P('a').match, 'a/b/c**')
 
  def test_ordering_common(self):
  # Ordering is tuple-alike.

Misc/NEWS.d/next/Library/2023-02-17-18-56-46.gh-issue-73435.7sTJHk.rst

@@ -0,0 +1 @@
+Add support for recursive wildcards in :meth:`pathlib.PurePath.match`.