Added decorator to encapsulate the fork multiprocessing workaround.

Author: jaraco

importlib_metadata/__init__.py

@@ -787,6 +787,24 @@ def find_distributions(self, context=Context()) -> Iterable[Distribution]:
         """
 
 
+def _clear_lru_cache_after_fork(func):
+    """Wrap ``func`` with ``functools.lru_cache`` and clear it after ``fork``.
+
+    ``FastPath`` caches zip-backed ``pathlib.Path`` objects that keep a
+    reference to the parent's open ``ZipFile`` handle. Re-using a cached
+    instance in a forked child can therefore resurrect invalid file pointers
+    and trigger ``BadZipFile``/``OSError`` failures (python/importlib_metadata#520).
+    Registering ``cache_clear`` with ``os.register_at_fork`` ensures every
+    process gets a pristine cache and opens its own archive handles.
+    """
+
+    cached = functools.lru_cache()(func)
+    register = getattr(os, 'register_at_fork', None)
+    if register is not None:
+        register(after_in_child=cached.cache_clear)
+    return cached
+
+
 class FastPath:
     """
     Micro-optimized class for searching a root for children.
@@ -803,8 +821,7 @@ class FastPath:
     True
     """
 
-    # The following cache is cleared at fork, see os.register_at_fork below
-    @functools.lru_cache()  # type: ignore[misc]
+    @_clear_lru_cache_after_fork  # type: ignore[misc]
     def __new__(cls, root):
         return super().__new__(cls)
 
@@ -844,11 +861,6 @@ def mtime(self):
     def lookup(self, mtime):
         return Lookup(self)
 
-# Clear FastPath.__new__ cache when forked, avoids trying to re-useing open 
-# file pointers from zipp.Path/zipfile.Path objects in forked process
-os.register_at_fork(after_in_child=FastPath.__new__.cache_clear)
-
-
 class Lookup:
     """
     A micro-optimized class for searching a (fast) path for metadata.