fix: handle FileLock timeout explicitly, rename misleading var, align lint ignores

- Catch filelock.Timeout separately from generic errors so operators see
  an actionable message when a pod is stuck holding the download lock
- Rename each_history → redirect_resp (response.history entries are
  redirect responses, not "histories")
- Add E402 and UP to tests_unit/ ruff ignores to match tests/ config
- Add test for FileLockTimeout → ModelFetchError propagation

Author: bigcat88

nc_py_api/ex_app/integration_fastapi.py

@@ -21,6 +21,7 @@
 )
 from fastapi.responses import JSONResponse, PlainTextResponse
 from filelock import FileLock
+from filelock import Timeout as FileLockTimeout
 from starlette.requests import HTTPConnection, Request
 from starlette.types import ASGIApp, Receive, Scope, Send
 
@@ -207,48 +208,55 @@ def __fetch_model_as_file(
 ) -> str:
     result_path = download_options.pop("save_path", urlparse(model_path).path.split("/")[-1])
     tmp_path = result_path + ".tmp"
-    with FileLock(result_path + ".lock", timeout=7200), niquests.get(model_path, stream=True) as response:
-        if not response.ok:
-            raise ModelFetchError(
-                f"Downloading of '{model_path}' failed, returned ({response.status_code}) {response.text}"
-            )
-        downloaded_size = 0
-        linked_etag = ""
-        for each_history in response.history:
-            linked_etag = each_history.headers.get("X-Linked-ETag", "")
-            if linked_etag:
-                break
-        if not linked_etag:
-            linked_etag = response.headers.get("X-Linked-ETag", response.headers.get("ETag", ""))
-        total_size = int(response.headers.get("Content-Length"))
-        try:
-            existing_size = os.path.getsize(result_path)
-        except OSError:
-            existing_size = 0
-        if linked_etag and total_size == existing_size:
-            with builtins.open(result_path, "rb") as file:
-                sha256_hash = hashlib.sha256()
-                for byte_block in iter(lambda: file.read(4096), b""):
-                    sha256_hash.update(byte_block)
-                if f'"{sha256_hash.hexdigest()}"' == linked_etag:
-                    nc.set_init_status(min(current_progress + progress_for_task, 99))
-                    return result_path
-
-        try:
-            with builtins.open(tmp_path, "wb") as file:
-                last_progress = current_progress
-                for chunk in response.iter_raw(-1):
-                    downloaded_size += file.write(chunk)
-                    if total_size:
-                        new_progress = min(current_progress + int(progress_for_task * downloaded_size / total_size), 99)
-                        if new_progress != last_progress:
-                            nc.set_init_status(new_progress)
-                            last_progress = new_progress
-            os.replace(tmp_path, result_path)
-        except BaseException:
-            if os.path.exists(tmp_path):
-                os.remove(tmp_path)
-            raise
+    try:
+        with FileLock(result_path + ".lock", timeout=7200), niquests.get(model_path, stream=True) as response:
+            if not response.ok:
+                raise ModelFetchError(
+                    f"Downloading of '{model_path}' failed, returned ({response.status_code}) {response.text}"
+                )
+            downloaded_size = 0
+            linked_etag = ""
+            for redirect_resp in response.history:
+                linked_etag = redirect_resp.headers.get("X-Linked-ETag", "")
+                if linked_etag:
+                    break
+            if not linked_etag:
+                linked_etag = response.headers.get("X-Linked-ETag", response.headers.get("ETag", ""))
+            total_size = int(response.headers.get("Content-Length"))
+            try:
+                existing_size = os.path.getsize(result_path)
+            except OSError:
+                existing_size = 0
+            if linked_etag and total_size == existing_size:
+                with builtins.open(result_path, "rb") as file:
+                    sha256_hash = hashlib.sha256()
+                    for byte_block in iter(lambda: file.read(4096), b""):
+                        sha256_hash.update(byte_block)
+                    if f'"{sha256_hash.hexdigest()}"' == linked_etag:
+                        nc.set_init_status(min(current_progress + progress_for_task, 99))
+                        return result_path
+
+            try:
+                with builtins.open(tmp_path, "wb") as file:
+                    last_progress = current_progress
+                    for chunk in response.iter_raw(-1):
+                        downloaded_size += file.write(chunk)
+                        if total_size:
+                            new_progress = min(
+                                current_progress + int(progress_for_task * downloaded_size / total_size), 99
+                            )
+                            if new_progress != last_progress:
+                                nc.set_init_status(new_progress)
+                                last_progress = new_progress
+                os.replace(tmp_path, result_path)
+            except BaseException:
+                if os.path.exists(tmp_path):
+                    os.remove(tmp_path)
+                raise
+    except FileLockTimeout as exc:
+        raise ModelFetchError(
+            f"Timed out waiting for lock on '{result_path}' after 7200s — another process may be stuck downloading"
+        ) from exc
 
     return result_path
 

pyproject.toml

@@ -151,7 +151,9 @@ lint.extend-per-file-ignores."tests/**/*.py" = [
 ]
 lint.extend-per-file-ignores."tests_unit/**/*.py" = [
   "D",
+  "E402",
   "S",
+  "UP",
 ]
 lint.mccabe.max-complexity = 16
 

tests_unit/test_fetch_model_file.py

@@ -7,6 +7,7 @@
 
 import pytest
 from filelock import FileLock
+from filelock import Timeout as FileLockTimeout
 
 from nc_py_api._exceptions import ModelFetchError
 from nc_py_api.ex_app.integration_fastapi import fetch_models_task
@@ -186,6 +187,20 @@ def mock_get(_url, **_kwargs):
         # File must be entirely one content or the other — never mixed
         assert data in (b"A" * 10000, b"B" * 10000)
 
+    def test_filelock_timeout_raises_model_fetch_error(self, tmp_path):
+        save_path = str(tmp_path / "model.bin")
+        lock = FileLock(save_path + ".lock")
+        nc = _mock_nc()
+
+        with (
+            mock.patch("nc_py_api.ex_app.integration_fastapi.FileLock", side_effect=FileLockTimeout(lock)),
+            pytest.raises(ModelFetchError),
+        ):
+            fetch_models_task(nc, {"https://example.com/m.bin": {"save_path": save_path}}, 0)
+
+        status_msg = nc.set_init_status.call_args_list[-1][0][1]
+        assert "Timed out waiting for lock" in status_msg
+
     def test_progress_updates_sent(self, tmp_path):
         save_path = str(tmp_path / "model.bin")
         nc = _mock_nc()