Replace *seps* with *sep*

barneygale · Nov 13, 2023 · Jun 18, 2023 · Jul 13, 2023 · Jul 13, 2023 · Jul 13, 2023
commit 5b620fb51eb5382d2ee6afbc1b5ec27883eb66fb
diff --git a/Doc/library/fnmatch.rst b/Doc/library/fnmatch.rst
@@ -82,7 +82,7 @@ cache the compiled regex patterns in the following functions: :func:`fnmatch`,
    ``[n for n in names if fnmatch(n, pattern)]``, but implemented more efficiently.
 
 
-.. function:: translate(pattern, seps=None)
+.. function:: translate(pattern, sep=None)
 
    Return the shell-style *pattern* converted to a regular expression for
    using with :func:`re.match`.
@@ -98,9 +98,8 @@ cache the compiled regex patterns in the following functions: :func:`fnmatch`,
       >>> reobj.match('foobar.txt')
       <re.Match object; span=(0, 10), match='foobar.txt'>
 
-   A sequence of path separator characters may be supplied to the *seps*
-   argument. If given, the separators are used to split the pattern into
-   segments, where:
+   A path separator character may be supplied to the *sep* argument. If given,
+   the separator is sed to split the pattern into segments, where:
 
    - A ``*`` pattern segment matches precisely one path segment.
    - A ``**`` pattern segment matches any number of path segments.
@@ -109,11 +108,11 @@ cache the compiled regex patterns in the following functions: :func:`fnmatch`,
    - ``*`` and ``?`` wildcards in other positions don't match path separators.
 
    These rules approximate shell recursive globbing. The :mod:`pathlib` module
-   calls this function and supplies *seps* to implement
+   calls this function and supplies *sep* to implement
    :meth:`~pathlib.PurePath.match` and :meth:`~pathlib.Path.glob`.
 
    .. versionchanged:: 3.13
-      The *seps* parameter was added.
+      The *sep* parameter was added.
 
 
 .. seealso::

diff --git a/Lib/fnmatch.py b/Lib/fnmatch.py
@@ -71,24 +71,23 @@ def fnmatchcase(name, pat):
     return match(name) is not None
 
 
-def translate(pat, seps=None):
+def translate(pat, sep=None):
     """Translate a shell PATTERN to a regular expression.
 
-    A sequence of path separator characters may be supplied to the *seps*
-    argument. If given, '*' and '?' wildcards will not match separators.
-    '*' wildcards in standalone pattern segments match precisely one path
-    segment; '**' wildcards in standalone segments match any number of path
-    segments.
+    A path separator character may be supplied to the *sep* argument. If
+    given, '*' and '?' wildcards will not match separators; '*' wildcards in
+    standalone pattern segments match precisely one path segment; and  '**'
+    wildcards in standalone segments match any number of path segments.
 
     There is no way to quote meta-characters.
     """
 
     STAR = object()
-    if seps:
-        SEPS = re.escape(''.join(seps))
-        DOT = f'[^{SEPS}]'
+    if sep:
+        SEP = re.escape(sep)
+        DOT = f'[^{SEP}]'
     else:
-        SEPS = None
+        SEP = None
         DOT = '.'
     res = []
     add = res.append
@@ -101,9 +100,9 @@ def translate(pat, seps=None):
             h = i-1
             while i < n and pat[i] == '*':
                 i = i+1
-            if seps:
+            if sep:
                 star_count = i-h
-                is_segment = (h == 0 or pat[h-1] in seps) and (i == n or pat[i] in seps)
+                is_segment = (h == 0 or pat[h-1] == sep) and (i == n or pat[i] == sep)
                 if star_count == 1:
                     if is_segment:
                         add(f'{DOT}+')
@@ -113,7 +112,7 @@ def translate(pat, seps=None):
                     if i == n:
                         add('.*')
                     else:
-                        add(f'(.*[{SEPS}])?')
+                        add(f'(.*{SEP})?')
                         i = i+1
                 else:
                     raise ValueError("Invalid pattern: '**' can only be an entire path component")

diff --git a/Lib/test/test_fnmatch.py b/Lib/test/test_fnmatch.py
@@ -250,16 +250,16 @@ def test_translate(self):
         self.assertTrue(re.match(fatre, 'cbabcaxc'))
         self.assertFalse(re.match(fatre, 'dabccbad'))
 
-    def test_translate_seps(self):
-        self.assertEqual(translate('*', seps='/'), r'(?s:[^/]+)\Z')
-        self.assertEqual(translate('?', seps='/'), r'(?s:[^/])\Z')
-        self.assertEqual(translate('a?b*', seps='/'), r'(?s:a[^/]b[^/]*)\Z')
-        self.assertEqual(translate('/**/*/*.*/**', seps='/'),
-                         r'(?s:/(.*[/])?[^/]+/[^/]*\.[^/]*/.*)\Z')
-        self.assertEqual(translate('foo/bar\\baz', seps=('/', '\\')),
-                         r'(?s:foo/bar\\baz)\Z')
-        self.assertRaises(ValueError, translate, 'a**', seps='/')
-        self.assertRaises(ValueError, translate, '**b', seps='/')
+    def test_translate_sep(self):
+        self.assertEqual(translate('*', sep='/'), r'(?s:[^/]+)\Z')
+        self.assertEqual(translate('?', sep='/'), r'(?s:[^/])\Z')
+        self.assertEqual(translate('a?b*', sep='/'), r'(?s:a[^/]b[^/]*)\Z')
+        self.assertEqual(translate('/**/*/*.*/**', sep='/'),
+                         r'(?s:/(.*/)?[^/]+/[^/]*\.[^/]*/.*)\Z')
+        self.assertEqual(translate(r'\**\*\*.*\**', sep='\\'),
+                         r'(?s:\\(.*\\)?[^\\]+\\[^\\]*\.[^\\]*\\.*)\Z')
+        self.assertRaises(ValueError, translate, 'a**', sep='/')
+        self.assertRaises(ValueError, translate, '**b', sep='/')
 
 
 class FilterTestCase(unittest.TestCase):

diff --git a/Misc/NEWS.d/next/Library/2023-07-13-00-24-52.gh-issue-72904.Yn5-j0.rst b/Misc/NEWS.d/next/Library/2023-07-13-00-24-52.gh-issue-72904.Yn5-j0.rst
@@ -1,3 +1,4 @@
-Add optional *seps* argument to :func:`fnmatch.translate`. If a sequence of
-path separators is given, the resulting pattern matches paths similarly to
-:func:`glob.glob`.
+Add optional *sep* argument to :func:`fnmatch.translate`. If a path separator
+character is given, the resulting pattern matches paths like
+:meth:`pathlib.PurePath.match` and :meth:`pathlib.Path.glob`. For example, the
+``*`` wildcard will not match path separators.