[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

nc_py_api/ex_app/integration_fastapi.py

@@ -244,7 +244,9 @@ def __fetch_model_as_file(
                     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)
+                            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

tests/actual_tests/integration_fastapi_test.py

@@ -187,15 +187,18 @@ def release(self, *args, **kwargs):
 
                 # Track actual HTTP downloads
                 import niquests
+
                 original_get = niquests.get
 
                 def tracked_get(url, *args, **kwargs):
                     with lock_events_lock:
                         download_attempts.append((threading.current_thread().name, url, time.time()))
                     return original_get(url, *args, **kwargs)
 
-                with patch("nc_py_api.ex_app.integration_fastapi.SoftFileLock", TrackedSoftFileLock), \
-                     patch("nc_py_api.ex_app.integration_fastapi.niquests.get", side_effect=tracked_get):
+                with (
+                    patch("nc_py_api.ex_app.integration_fastapi.SoftFileLock", TrackedSoftFileLock),
+                    patch("nc_py_api.ex_app.integration_fastapi.niquests.get", side_effect=tracked_get),
+                ):
                     # Simulate two pods trying to download simultaneously
                     results = []
                     errors = []
@@ -251,12 +254,14 @@ def download_in_thread(thread_name):
                     t2_end = thread_sections[threads[1]]["release"]
 
                     # Verify no overlap: either t1 ends before/at t2 start, or t2 ends before/at t1 start
-                    assert (t1_end <= t2_start) or (t2_end <= t1_start), \
-                        f"Critical sections overlap - locks not serialized: {lock_events}"
+                    assert (t1_end <= t2_start) or (
+                        t2_end <= t1_start
+                    ), f"Critical sections overlap - locks not serialized: {lock_events}"
 
                     # Verify file was downloaded only once (second thread should skip due to ETag match)
-                    assert len(download_attempts) == 1, \
-                        f"Expected exactly 1 download, but got {len(download_attempts)}: {download_attempts}"
+                    assert (
+                        len(download_attempts) == 1
+                    ), f"Expected exactly 1 download, but got {len(download_attempts)}: {download_attempts}"
 
                     # Verify file was downloaded successfully
                     assert Path("concurrent_test.txt").exists()
@@ -412,15 +417,23 @@ def release(self, *args, **kwargs):
                         return super().release(*args, **kwargs)
 
                 # Track actual snapshot_download calls
-                from huggingface_hub import snapshot_download as original_snapshot_download
+                from huggingface_hub import (
+                    snapshot_download as original_snapshot_download,
+                )
 
                 def tracked_snapshot_download(*args, **kwargs):
                     with lock_events_lock:
-                        download_attempts.append((threading.current_thread().name, args[0] if args else "unknown", time.time()))
+                        download_attempts.append(
+                            (threading.current_thread().name, args[0] if args else "unknown", time.time())
+                        )
                     return original_snapshot_download(*args, **kwargs)
 
-                with patch("nc_py_api.ex_app.integration_fastapi.SoftFileLock", TrackedSoftFileLock), \
-                     patch("nc_py_api.ex_app.integration_fastapi.snapshot_download", side_effect=tracked_snapshot_download):
+                with (
+                    patch("nc_py_api.ex_app.integration_fastapi.SoftFileLock", TrackedSoftFileLock),
+                    patch(
+                        "nc_py_api.ex_app.integration_fastapi.snapshot_download", side_effect=tracked_snapshot_download
+                    ),
+                ):
                     # Simulate two pods trying to download simultaneously
                     results = []
                     errors = []
@@ -476,14 +489,16 @@ def download_in_thread(thread_name):
                     t2_end = thread_sections[threads[1]]["release"]
 
                     # Verify no overlap: either t1 ends before/at t2 start, or t2 ends before/at t1 start
-                    assert (t1_end <= t2_start) or (t2_end <= t1_start), \
-                        f"Critical sections overlap - locks not serialized: {lock_events}"
+                    assert (t1_end <= t2_start) or (
+                        t2_end <= t1_start
+                    ), f"Critical sections overlap - locks not serialized: {lock_events}"
 
                     # Verify snapshot was downloaded only once (second thread should reuse cached download)
                     # HuggingFace's snapshot_download has its own caching, so both threads may call it,
                     # but the lock ensures they don't download concurrently
-                    assert len(download_attempts) <= 2, \
-                        f"Expected at most 2 snapshot_download calls, but got {len(download_attempts)}: {download_attempts}"
+                    assert (
+                        len(download_attempts) <= 2
+                    ), f"Expected at most 2 snapshot_download calls, but got {len(download_attempts)}: {download_attempts}"
 
                     # Verify model was downloaded successfully
                     assert cache_dir.exists()