Allow precompiled matcher objects to be hashed and pickled

Author: facelessuser

.pyspelling.yml

@@ -1,3 +1,5 @@
+jobs: 8
+
 matrix:
 - name: mkdocs
   sources:

tests/test_fnmatch.py

@@ -5,6 +5,7 @@
 import sys
 import os
 import pytest
+import copy
 import wcmatch.fnmatch as fnmatch
 from unittest import mock
 from wcmatch import util
@@ -804,3 +805,19 @@ def test_precompiled_filter_empty(self):
 
         m = fnmatch.compile('*file')
         self.assertEqual(m.filter([]), [])
+
+    def test_hash(self):
+        """Test hashing."""
+
+        m1 = fnmatch.compile('test', flags=fnmatch.C)
+        m2 = fnmatch.compile('test', flags=fnmatch.C)
+        m3 = fnmatch.compile('test', flags=fnmatch.I)
+        m4 = fnmatch.compile(b'test', flags=fnmatch.C)
+
+        self.assertTrue(m1 == m2)
+        self.assertTrue(m1 != m3)
+        self.assertTrue(m1 != m4)
+
+        m5 = copy.copy(m1)
+        self.assertTrue(m1 == m5)
+        self.assertTrue(m5 in {m1})

tests/test_globmatch.py

@@ -2,6 +2,7 @@
 """Tests for `globmatch`."""
 import unittest
 import pytest
+import copy
 import re
 import os
 import sys
@@ -1959,3 +1960,19 @@ def test_precompiled_filter_pathlib(self):
             m.filter(paths),
             glob.globfilter(paths, pattern, flags=glob.GLOBSTAR)
         )
+
+    def test_hash(self):
+        """Test hashing."""
+
+        m1 = glob.compile('test', flags=glob.C)
+        m2 = glob.compile('test', flags=glob.C)
+        m3 = glob.compile('test', flags=glob.I)
+        m4 = glob.compile(b'test', flags=glob.C)
+
+        self.assertTrue(m1 == m2)
+        self.assertTrue(m1 != m3)
+        self.assertTrue(m1 != m4)
+
+        m5 = copy.copy(m1)
+        self.assertTrue(m1 == m5)
+        self.assertTrue(m5 in {m1})

wcmatch/_wcmatch.py

@@ -373,8 +373,47 @@ def filter(
         return matches
 
 
-def _pickle(p):  # type: ignore[no-untyped-def]
-    return WcRegexp, (p._include, p._exclude, p._real, p._path, p._follow)
+class WcMatcher(util.Immutable, Generic[AnyStr]):
+    """Pre-compiled matcher object."""
+
+    _matcher: WcRegexp[AnyStr]
+    _hash: int
+
+    __slots__ = ('_matcher', '_hash')
+
+    def __init__(self, matcher: WcRegexp[AnyStr]) -> None:
+        """Initialize."""
+
+        super().__init__(
+            _matcher=matcher,
+            _hash=hash(
+                (
+                    type(self),
+                    type(matcher), matcher,
+                )
+            )
+        )
+
+    def __hash__(self) -> int:
+        """Hash."""
+
+        return self._hash
+
+    def __eq__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            isinstance(other, WcMatcher) and
+            self._matcher == other._matcher
+        )
+
+    def __ne__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            not isinstance(other, WcMatcher) or
+            self._matcher != other._matcher
+        )
 
 
-copyreg.pickle(WcRegexp, _pickle)
+copyreg.pickle(WcRegexp, lambda p: (WcRegexp, (p._include, p._exclude, p._real, p._path, p._follow)))

wcmatch/fnmatch.py

@@ -5,9 +5,10 @@
 A custom implementation of `fnmatch`.
 """
 from __future__ import annotations
-from wcmatch._wcmatch import WcRegexp
+from . import _wcmatch
 from . import _wcparse
-from typing import AnyStr, Iterable, Sequence, Generic
+import copyreg
+from typing import AnyStr, Iterable, Sequence
 
 __all__ = (
     "CASE", "EXTMATCH", "IGNORECASE", "RAWCHARS",
@@ -47,23 +48,21 @@
 )
 
 
-class WcMatcher(Generic[AnyStr]):
+class WcMatcher(_wcmatch.WcMatcher[AnyStr]):
     """Pre-compiled matcher object."""
 
-    def __init__(self, matcher: WcRegexp[AnyStr]) -> None:
-        """Initialize."""
-
-        self.matcher = matcher  # type: WcRegexp[AnyStr]
-
     def match(self, filename: AnyStr) -> bool:
         """Match filename."""
 
-        return self.matcher.match(filename)
+        return self._matcher.match(filename)
 
     def filter(self, filenames: Iterable[AnyStr]) -> list[AnyStr]:
         """Match filename."""
 
-        return self.matcher.filter(filenames)  # type: ignore[return-value]
+        return self._matcher.filter(filenames)  # type: ignore[return-value]
+
+
+copyreg.pickle(WcMatcher, lambda p: (WcMatcher, (p._matcher,)))
 
 
 def compile(  # noqa: A001

wcmatch/glob.py

@@ -11,10 +11,10 @@
 import functools
 from collections import namedtuple
 import bracex
+import copyreg
 from . import _wcparse
 from . import _wcmatch
 from . import util
-from ._wcmatch import WcRegexp
 from typing import Iterator, Iterable, AnyStr, Generic, Pattern, Callable, Any, Sequence
 
 __all__ = (
@@ -898,14 +898,9 @@ def glob(
     return list(iglob(patterns, flags=flags, root_dir=root_dir, dir_fd=dir_fd, limit=limit, exclude=exclude))
 
 
-class WcMatcher(Generic[AnyStr]):
+class WcMatcher(_wcmatch.WcMatcher[AnyStr]):
     """Pre-compiled matcher object."""
 
-    def __init__(self, matcher: WcRegexp[AnyStr]) -> None:
-        """Initialize."""
-
-        self.matcher = matcher  # type: WcRegexp[AnyStr]
-
     def match(
         self,
         filename: AnyStr | os.PathLike[AnyStr],
@@ -915,7 +910,7 @@ def match(
     ) -> bool:
         """Match filename."""
 
-        return self.matcher.match(filename, root_dir, dir_fd)
+        return self._matcher.match(filename, root_dir, dir_fd)
 
     def filter(
         self,
@@ -926,7 +921,10 @@ def filter(
     ) -> list[AnyStr | os.PathLike[AnyStr]]:
         """Match filename."""
 
-        return self.matcher.filter(filenames, root_dir, dir_fd)
+        return self._matcher.filter(filenames, root_dir, dir_fd)
+
+
+copyreg.pickle(WcMatcher, lambda p: (WcMatcher, (p._matcher,)))
 
 
 def compile(  # noqa: A001