Voice et bot modif

venv/lib/python3.12/site-packages/filelock/_unix.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import os
 import sys
+import warnings
 from contextlib import suppress
-from errno import ENOSYS
+from errno import EAGAIN, ENOSYS, EWOULDBLOCK
 from pathlib import Path
 from typing import cast
 
@@ -34,37 +35,79 @@ else:  # pragma: win32 no cover
         has_fcntl = True
 
     class UnixFileLock(BaseFileLock):
-        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+        """
+        Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.
 
-        def _acquire(self) -> None:
+        Lock file cleanup: Unix and macOS delete the lock file reliably after release, even in
+        multi-threaded scenarios. Unlike Windows, Unix allows unlinking files that other processes
+        have open.
+        """
+
+        def _acquire(self) -> None:  # noqa: C901, PLR0912
             ensure_directory_exists(self.lock_file)
             open_flags = os.O_RDWR | os.O_TRUNC
             o_nofollow = getattr(os, "O_NOFOLLOW", None)
             if o_nofollow is not None:
                 open_flags |= o_nofollow
-            if not Path(self.lock_file).exists():
-                open_flags |= os.O_CREAT
-            fd = os.open(self.lock_file, open_flags, self._context.mode)
-            with suppress(PermissionError):  # This locked is not owned by this UID
-                os.fchmod(fd, self._context.mode)
+            open_flags |= os.O_CREAT
+            open_mode = self._open_mode()
+            try:
+                fd = os.open(self.lock_file, open_flags, open_mode)
+            except FileNotFoundError:
+                # On FUSE/NFS, os.open(O_CREAT) is not atomic: LOOKUP + CREATE can be split, allowing a concurrent
+                # unlink() to delete the file between them. For valid paths, treat ENOENT as transient contention.
+                # For invalid paths (e.g., empty string), re-raise to avoid infinite retry loops.
+                if self.lock_file and Path(self.lock_file).parent.exists():
+                    return
+                raise
+            except PermissionError:
+                # Sticky-bit dirs (e.g. /tmp): O_CREAT fails if the file is owned by another user (#317).
+                # Fall back to opening the existing file without O_CREAT.
+                if not Path(self.lock_file).exists():
+                    raise
+                try:
+                    fd = os.open(self.lock_file, open_flags & ~os.O_CREAT, open_mode)
+                except FileNotFoundError:
+                    return
+            if self.has_explicit_mode:
+                with suppress(PermissionError):
+                    os.fchmod(fd, self._context.mode)
             try:
                 fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
             except OSError as exception:
                 os.close(fd)
-                if exception.errno == ENOSYS:  # NotImplemented error
-                    msg = "FileSystem does not appear to support flock; use SoftFileLock instead"
-                    raise NotImplementedError(msg) from exception
+                if exception.errno == ENOSYS:
+                    with suppress(OSError):
+                        Path(self.lock_file).unlink()
+                    self._fallback_to_soft_lock()
+                    self._acquire()
+                    return
+                if exception.errno not in {EAGAIN, EWOULDBLOCK}:
+                    raise
             else:
-                self._context.lock_file_fd = fd
+                # The file may have been unlinked by a concurrent _release() between our open() and flock().
+                # A lock on an unlinked inode is useless — discard and let the retry loop start fresh.
+                if os.fstat(fd).st_nlink == 0:
+                    os.close(fd)
+                else:
+                    self._context.lock_file_fd = fd
+
+        def _fallback_to_soft_lock(self) -> None:
+            from ._soft import SoftFileLock  # noqa: PLC0415
+
+            warnings.warn("flock not supported on this filesystem, falling back to SoftFileLock", stacklevel=2)
+            from .asyncio import AsyncSoftFileLock, BaseAsyncFileLock  # noqa: PLC0415
+
+            self.__class__ = AsyncSoftFileLock if isinstance(self, BaseAsyncFileLock) else SoftFileLock
 
         def _release(self) -> None:
-            # Do not remove the lockfile:
-            #   https://github.com/tox-dev/py-filelock/issues/31
-            #   https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
             fd = cast("int", self._context.lock_file_fd)
             self._context.lock_file_fd = None
+            with suppress(OSError):
+                Path(self.lock_file).unlink()
             fcntl.flock(fd, fcntl.LOCK_UN)
-            os.close(fd)
+            with suppress(OSError):  # close can raise EIO on FUSE/Docker bind-mount filesystems after unlink
+                os.close(fd)
 
 
 __all__ = [