Merge branch 'main' into gh-73435-pathlib-match-recursive

python · barneygale · May 30, 2023 · Jan 28, 2023 · Jan 29, 2023 · Feb 15, 2023
commit 559787dac96ad5b1695aa44f05783e3ad2f95db9
@@ -583,6 +583,11 @@ Pure paths provide the following methods and properties:
       >>> PureWindowsPath('b.py').match('*.PY')
       True
 
+   Set *case_sensitive* to ``True`` or ``False`` to override this behaviour.
+
+   .. versionadded:: 3.12
+      The *case_sensitive* argument.
+
    .. versionchanged:: 3.12
       Support for the recursive wildcard "``**``" was added. In previous
       versions, it acted like the non-recursive wildcard "``*``".

diff --git a/Doc/whatsnew/3.12.rst b/Doc/whatsnew/3.12.rst
@@ -395,6 +395,10 @@ pathlib
 * Add :meth:`pathlib.Path.is_junction` as a proxy to :func:`os.path.isjunction`.
   (Contributed by Charles Machalow in :gh:`99547`.)
 
+* Add *case_sensitive* optional parameter to :meth:`pathlib.Path.glob`,
+  :meth:`pathlib.Path.rglob` and :meth:`pathlib.PurePath.match` for matching
+  the path's case sensitivity, allowing for more precise control over the matching process.
+
 * Add support for recursive wildcards in :meth:`pathlib.PurePath.match`.
   (Contributed by Barney Gale in :gh:`73435`.)
 

@@ -77,26 +77,6 @@ def _is_case_sensitive(flavour):
 }
 
 
-@functools.lru_cache()
-def _compile_pattern(pattern_lines, case_sensitive):
-    parts = ['^']
-    for part in pattern_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 case_sensitive:
-        flags |= re.IGNORECASE
-    return re.compile(''.join(parts), flags=flags)
-
-
 @functools.lru_cache()
 def _make_selector(pattern_parts, flavour, case_sensitive):
     pat = pattern_parts[0]
@@ -128,6 +108,26 @@ def _compile_pattern(pat, case_sensitive):
     return re.compile(fnmatch.translate(pat), flags).match
 
 
+@functools.lru_cache()
+def _compile_pattern_lines(pattern_lines, case_sensitive):
+    parts = ['^']
+    for part in pattern_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 case_sensitive:
+        flags |= re.IGNORECASE
+    return re.compile(''.join(parts), flags=flags)
+
+
 class _Selector:
     """A selector matches a specific glob pattern part against the children
     of a given path."""
@@ -741,8 +741,9 @@ def match(self, path_pattern, *, case_sensitive=None):
         """
         if not isinstance(path_pattern, PurePath):
             path_pattern = self.with_segments(path_pattern)
-        case_sensitive = _is_case_sensitive(self._flavour)
-        pattern = _compile_pattern(path_pattern._lines, case_sensitive)
+        if case_sensitive is None:
+            case_sensitive = _is_case_sensitive(self._flavour)
+        pattern = _compile_pattern_lines(path_pattern._lines, case_sensitive)
         if path_pattern.drive or path_pattern.root:
             return pattern.match(self._lines) is not None
         elif path_pattern._tail:

@@ -334,6 +334,11 @@ def test_match_common(self):
         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**')
+        # Case-sensitive flag
+        self.assertFalse(P('A.py').match('a.PY', case_sensitive=True))
+        self.assertTrue(P('A.py').match('a.PY', case_sensitive=False))
+        self.assertFalse(P('c:/a/B.Py').match('C:/A/*.pY', case_sensitive=True))
+        self.assertTrue(P('/a/b/c.py').match('/A/*/*.Py', case_sensitive=False))
 
     def test_ordering_common(self):
         # Ordering is tuple-alike.