backend/services/profiles.py (2)

120-121: Consider moving asyncio import to module level.

While local imports can reduce startup overhead, asyncio is a standard library module with negligible import cost. Moving it to the top of the file with other imports would follow the conventional Python import style.

✨ Optional: Move asyncio to top-level imports

 from typing import List, Optional
 from datetime import datetime
+import asyncio
 import uuid
 import shutil

Then remove the local import:

-    import asyncio
-
     profile = db.query(DBVoiceProfile).filter_by(id=profile_id).first()

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@backend/services/profiles.py` around lines 120 - 121, Move the local "import
asyncio" out of the function and add a top-level "import asyncio" with the other
module imports; then delete the local "import asyncio" statement (the one shown
in the diff) so all uses in this module rely on the single module-level asyncio
import.

---

25-25: Remove unused load_audio import from line 25.

The load_audio function is no longer called in this file after the refactor to use validate_and_load_reference_audio. Remove it from the import statement.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@backend/services/profiles.py` at line 25, The import statement currently
brings in load_audio which is unused after switching to
validate_and_load_reference_audio; update the import on the line that references
validate_reference_audio, validate_and_load_reference_audio, load_audio,
save_audio by removing load_audio so only the used symbols
(validate_reference_audio, validate_and_load_reference_audio, save_audio) are
imported.

backend/utils/audio.py (1)

226-256: Good refactor for single-pass validation and loading.

This eliminates redundant audio decoding by combining validation and loading into one function. The 4-tuple return type is consistently applied across all code paths.

One minor suggestion from static analysis: prefer f-string conversion flag over explicit str() call.

✨ Optional: Use explicit conversion flag

     except Exception as e:
-        return False, f"Error validating audio: {str(e)}", None, None
+        return False, f"Error validating audio: {e!s}", None, None

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@backend/utils/audio.py` around lines 226 - 256, In
validate_and_load_reference_audio, update the exception formatting to use the
f-string conversion flag instead of calling str() directly; replace the current
return in the except block that builds the error message using str(e) with an
f-string that uses the conversion flag (e.g., {e!s}) so the message becomes
f"Error validating audio: {e!s}" while leaving the rest of the return tuple
unchanged.

backend/routes/profiles.py (1)

123-131: Consider offloading blocking file writes to a thread pool.

The PR objective mentions moving audio processing to a thread pool to avoid blocking the async event loop. While file.read() is async, tmp.write(chunk) is a synchronous blocking call. For a 50 MB upload with 1 MB chunks, this results in 50 blocking write operations on the event loop.

♻️ Proposed fix using run_in_executor

+import asyncio
+from functools import partial
+
 # In the upload handler:
-            tmp.write(chunk)
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, tmp.write, chunk)

Alternatively, consider using aiofiles for fully async file I/O if it's already a project dependency.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@backend/routes/profiles.py` around lines 123 - 131, The sync tmp.write(chunk)
inside the upload loop blocks the async event loop; change it to run the write
in the threadpool (use loop.run_in_executor or
asyncio.get_running_loop().run_in_executor) so writes are executed off the event
loop while keeping the async file.read(...) loop and the total_size checks
intact (refer to SAMPLE_UPLOAD_CHUNK_SIZE, SAMPLE_MAX_FILE_SIZE, file.read,
tmp.write and Path(tmp.name).unlink). Alternatively, replace the temp file usage
with aiofiles to perform async writes if the project already depends on
aiofiles; ensure the error/cleanup path (unlink on oversized) still runs
correctly.

backend/routes/transcription.py (1)

48-49: Consider exposing a public method for cache checking.

Line 49 accesses the private method _is_model_cached. While this works, accessing private methods directly couples this route to implementation details of the whisper model class. Consider adding a public is_model_cached(model_size) method to the whisper model interface.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@backend/routes/transcription.py` around lines 48 - 49, The route currently
inspects a private member by calling whisper_model._is_model_cached(model_size);
instead add and use a public method like
whisper_model.is_model_cached(model_size) on the whisper model class and update
the route to call that instead of the private method, keeping the existing logic
that checks whisper_model.is_loaded() and whisper_model.model_size; implement
the new public is_model_cached(model_size) method to wrap the existing private
check so callers no longer rely on _is_model_cached.