seqtree 1.3.1__tar.gz → 1.3.2__tar.gz

{seqtree-1.3.1 → seqtree-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: seqtree
-Version: 1.3.1
+Version: 1.3.2
 Summary: Fast fuzzy search over biological sequences (C++ core, Python bindings)
 Keywords: sequence-search,fuzzy-matching,CDR3,immunology,bioinformatics,trie
 Author-Email: ISALGO laboratory <mikhail.shugay@gmail.com>

{seqtree-1.3.1 → seqtree-1.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "seqtree"
-version = "1.3.1"
+version = "1.3.2"
 description = "Fast fuzzy search over biological sequences (C++ core, Python bindings)"
 readme = "README.md"
 requires-python = ">=3.10"

{seqtree-1.3.1 → seqtree-1.3.2}/python/seqtree/control.py

@@ -122,24 +122,53 @@ def _prune_superseded(cache_dir, name, size, keep):
                 pass
 
 
-def _build_lock(cache):
-    """An inter-process lock around build-and-save, if ``filelock`` happens to be installed.
-
-    This is an *optimisation*, not the fix. ``Index.save`` writes to a temporary and renames it
-    into place, so a reader can never observe a half-written index whether or not this lock is
-    taken. What the lock buys is work: without it, a cold-cache fan-out of N workers has every
-    worker build the same 250k-clonotype index (seconds of CPU, 45 MB written) and N-1 of those
-    are thrown away. With it, one builds and the rest wait and load.
-
-    seqtree has no runtime dependencies, so ``filelock`` is used only if something else already
-    put it there -- ``huggingface_hub`` pulls it in, and that is installed whenever a control is
-    downloaded rather than read from the bundled asset.
+@contextlib.contextmanager
+def _build_lock(cache, timeout=600):
+    """Serialize cold builds without optional dependencies; process death releases the lock.
+
+    Keep the guard file: deleting it could let waiters lock different inodes.
     """
-    try:
-        from filelock import FileLock
-    except ImportError:
-        return contextlib.nullcontext()
-    return FileLock(cache + ".lock", timeout=600)
+    import errno
+    import time
+
+    with open(cache + ".lock", "a+b") as handle:
+        if os.name == "nt":
+            import msvcrt
+            if handle.seek(0, 2) == 0:
+                handle.write(b"\0")
+                handle.flush()
+
+            def acquire():
+                handle.seek(0)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+
+            def release():
+                handle.seek(0)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+        else:
+            import fcntl
+
+            def acquire():
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+            def release():
+                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+        deadline = time.monotonic() + timeout
+        while True:
+            try:
+                acquire()
+                break
+            except OSError as exc:
+                if exc.errno not in (errno.EACCES, errno.EAGAIN, errno.EDEADLK):
+                    raise
+                if time.monotonic() >= deadline:
+                    raise TimeoutError(f"Another control build owns {cache}.lock after {timeout:g}s") from exc
+                time.sleep(0.05)
+        try:
+            yield
+        finally:
+            release()
 
 
 def _load_cached(cache):