gh-160900: document path-like support and test mixed filename types

Author: MonikaDvorackova

Doc/library/fnmatch.rst

@@ -46,8 +46,10 @@ module.  See module :mod:`glob` for pathname expansion (:mod:`glob` uses
 a period are not special for this module, and are matched by the ``*`` and ``?``
 patterns.
 
-Unless stated otherwise, "filename string" and "pattern string" either refer to
-:class:`str` or ``ISO-8859-1`` encoded :class:`bytes` objects. Note that the
+Unless stated otherwise, "filename string" and "pattern string" refer to
+:class:`str` or ``ISO-8859-1`` encoded :class:`bytes` objects.
+In addition to filename strings, :func:`.filter` and :func:`.filterfalse`
+accept :term:`path-like objects <path-like object>` in *names*. Note that the
 functions documented below do not allow to mix a :class:`!bytes` pattern with
 a :class:`!str` filename, and vice-versa.
 
@@ -85,29 +87,27 @@ functions: :func:`~fnmatch.fnmatch`, :func:`fnmatchcase`, :func:`.filter`,
 
 .. function:: filter(names, pat)
 
-   Construct a list from those elements of the :term:`iterable` of filenames
-   *names* that match the pattern string *pat*.
+   Construct a list from those elements of the :term:`iterable` of filename
+   strings *names* that match the pattern string *pat*.
    It is the same as ``[n for n in names if fnmatch(n, pat)]``,
    but implemented more efficiently.
 
-   The filenames may be strings or path-like objects. Each filename is
-   normalized using :func:`os.path.normcase` for matching; the original
-   objects are preserved in the returned list.
+   .. versionchanged:: next
+      Added support for path-like objects in *names*.
 
 
 .. function:: filterfalse(names, pat)
 
-   Construct a list from those elements of the :term:`iterable` of filenames
-   *names* that do not match the pattern string *pat*.
+   Construct a list from those elements of the :term:`iterable` of filename
+   strings *names* that do not match the pattern string *pat*.
    It is the same as ``[n for n in names if not fnmatch(n, pat)]``,
    but implemented more efficiently.
 
-   The filenames may be strings or path-like objects. Each filename is
-   normalized using :func:`os.path.normcase` for matching; the original
-   objects are preserved in the returned list.
-
    .. versionadded:: 3.14
 
+   .. versionchanged:: next
+      Added support for path-like objects in *names*.
+
 
 .. function:: translate(pat)
 

Lib/test/test_fnmatch.py

@@ -332,6 +332,16 @@ def test_mix_bytes_str(self):
         self.assertRaises(TypeError, filter, ['test'], b'*')
         self.assertRaises(TypeError, filter, [b'test'], '*')
 
+
+    def test_mix_bytes_str_pathlike(self):
+        path = pathlib.Path("test")
+        self.assertRaises(TypeError, filter, [path], b'*')
+        self.assertRaises(TypeError, filter, [path, b'test'], '*')
+        self.assertRaises(TypeError, filter, [b'test', path], '*')
+        self.assertRaises(TypeError, filter, [path, 'test'], b'*')
+        self.assertRaises(TypeError, filter, ['test', path], b'*')
+        self.assertEqual(filter([path, 'other'], 'te*'), [path])
+
     def test_case(self):
         self.assertEqual(filter(['Test.py', 'Test.rb', 'Test.PL'], '*.p*'),
                          ['Test.py', 'Test.PL'] if IGNORECASE else ['Test.py'])
@@ -360,6 +370,16 @@ def test_mix_bytes_str(self):
         self.assertRaises(TypeError, filterfalse, ['test'], b'*')
         self.assertRaises(TypeError, filterfalse, [b'test'], '*')
 
+
+    def test_mix_bytes_str_pathlike(self):
+        path = pathlib.Path("test")
+        self.assertRaises(TypeError, filterfalse, [path], b'*')
+        self.assertRaises(TypeError, filterfalse, [path, b'test'], '*')
+        self.assertRaises(TypeError, filterfalse, [b'test', path], '*')
+        self.assertRaises(TypeError, filterfalse, [path, 'test'], b'*')
+        self.assertRaises(TypeError, filterfalse, ['test', path], b'*')
+        self.assertEqual(filterfalse([path, 'other'], 'te*'), ['other'])
+
     def test_case(self):
         self.assertEqual(filterfalse(['Test.py', 'Test.rb', 'Test.PL'], '*.p*'),
                          ['Test.rb'] if IGNORECASE else ['Test.rb', 'Test.PL'])