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

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

Author: pre-commit-ci[bot]

studio/backend/mcp_server.py

@@ -62,15 +62,15 @@ async def _send_unauthorized(send: Any, scope_type: str) -> None:
 def _dump(value: Any) -> Any:
     """Convert Pydantic responses to plain JSON values for MCP clients."""
     if hasattr(value, "model_dump"):
-        return value.model_dump(mode="json")
+        return value.model_dump(mode = "json")
     return value
 
 
 def create_studio_mcp() -> FastMCP:
     """Create the Studio MCP server and register the high-value tools."""
     mcp = FastMCP(
         "Unsloth Studio",
-        instructions=(
+        instructions = (
             "Use read tools to inspect the local Studio state before starting GPU work. "
             "Training and export tools can consume substantial VRAM and write files. "
             "Never expose tokens or local paths from tool results unless the user asks."
@@ -87,9 +87,9 @@ async def studio_status() -> dict[str, Any]:
         from utils.hardware import get_gpu_utilization
 
         training, export, inference = await _gather_status(
-            get_training_status(current_subject="mcp"),
-            get_export_status(current_subject="mcp"),
-            get_inference_status(current_subject="mcp"),
+            get_training_status(current_subject = "mcp"),
+            get_export_status(current_subject = "mcp"),
+            get_inference_status(current_subject = "mcp"),
         )
         return {
             "training": _dump(training),
@@ -102,15 +102,13 @@ async def studio_status() -> dict[str, Any]:
     async def list_local_models(models_dir: str = "./models") -> dict[str, Any]:
         """List local and cached models available to Studio."""
         from routes.models import list_local_models as list_models
-
-        return _dump(await list_models(models_dir=models_dir, current_subject="mcp"))
+        return _dump(await list_models(models_dir = models_dir, current_subject = "mcp"))
 
     @mcp.tool
     async def get_training_status() -> dict[str, Any]:
         """Read the active training job, phase, progress, and recent metrics."""
         from routes.training import get_training_status as get_status
-
-        return _dump(await get_status(current_subject="mcp"))
+        return _dump(await get_status(current_subject = "mcp"))
 
     @mcp.tool
     async def start_training(config: dict[str, Any]) -> dict[str, Any]:
@@ -123,43 +121,43 @@ async def start_training(config: dict[str, Any]) -> dict[str, Any]:
         from routes.training import start_training as start
 
         request = TrainingStartRequest.model_validate(config)
-        return _dump(await start(request, current_subject="mcp"))
+        return _dump(await start(request, current_subject = "mcp"))
 
     @mcp.tool
     async def stop_training(save: bool = True) -> dict[str, Any]:
         """Ask the active training process to stop at its next safe checkpoint."""
         from routes.training import TrainingStopRequest, stop_training as stop
-
-        return _dump(await stop(TrainingStopRequest(save=save), current_subject="mcp"))
+        return _dump(await stop(TrainingStopRequest(save = save), current_subject = "mcp"))
 
     @mcp.tool
     async def list_training_runs(limit: int = 50, offset: int = 0) -> dict[str, Any]:
         """List completed and stopped training runs, newest first."""
         from routes.training_history import list_training_runs as list_runs
-
-        return _dump(await list_runs(limit=limit, offset=offset, current_subject="mcp"))
+        return _dump(await list_runs(limit = limit, offset = offset, current_subject = "mcp"))
 
     @mcp.tool
     def validate_recipe(recipe: dict[str, Any]) -> dict[str, Any]:
         """Validate a Data Recipe with the same validator used by Studio."""
         from models.data_recipe import RecipePayload
         from routes.data_recipe.validate import validate
 
-        return _dump(validate(RecipePayload(recipe=recipe)))
+        return _dump(validate(RecipePayload(recipe = recipe)))
 
     @mcp.tool
     def get_recipe_job_status(job_id: str) -> dict[str, Any]:
         """Read the status of a Data Recipe job."""
         from routes.data_recipe.jobs import job_status
-
         return _dump(job_status(job_id))
 
     @mcp.tool
-    def get_recipe_job_dataset(job_id: str, limit: int = 20, offset: int = 0) -> dict[str, Any]:
+    def get_recipe_job_dataset(
+        job_id: str,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
         """Read a bounded page of generated Data Recipe rows."""
         from routes.data_recipe.jobs import job_dataset
-
-        return _dump(job_dataset(job_id, limit=limit, offset=offset))
+        return _dump(job_dataset(job_id, limit = limit, offset = offset))
 
     @mcp.tool
     async def load_checkpoint(
@@ -173,12 +171,12 @@ async def load_checkpoint(
         from routes.export import load_checkpoint as load
 
         request = LoadCheckpointRequest(
-            checkpoint_path=checkpoint_path,
-            max_seq_length=max_seq_length,
-            load_in_4bit=load_in_4bit,
-            trust_remote_code=trust_remote_code,
+            checkpoint_path = checkpoint_path,
+            max_seq_length = max_seq_length,
+            load_in_4bit = load_in_4bit,
+            trust_remote_code = trust_remote_code,
         )
-        return _dump(await load(request, current_subject="mcp"))
+        return _dump(await load(request, current_subject = "mcp"))
 
     @mcp.tool
     async def export_gguf(
@@ -192,12 +190,12 @@ async def export_gguf(
         from routes.export import export_gguf as export
 
         request = ExportGGUFRequest(
-            save_directory=save_directory,
-            quantization_method=quantization_method,
-            push_to_hub=push_to_hub,
-            repo_id=repo_id,
+            save_directory = save_directory,
+            quantization_method = quantization_method,
+            push_to_hub = push_to_hub,
+            repo_id = repo_id,
         )
-        return _dump(await export(request, current_subject="mcp"))
+        return _dump(await export(request, current_subject = "mcp"))
 
     return mcp
 
@@ -206,7 +204,7 @@ async def _gather_status(*coroutines: Any) -> tuple[Any, ...]:
     """Gather independent status calls without letting one optional backend fail all state."""
     import asyncio
 
-    results = await asyncio.gather(*coroutines, return_exceptions=True)
+    results = await asyncio.gather(*coroutines, return_exceptions = True)
     return tuple(
         {"error": str(result)} if isinstance(result, Exception) else result for result in results
-    )
+    )

studio/backend/tests/test_mcp_server.py

@@ -74,4 +74,4 @@ async def send(message):
         )
     )
 
-    assert events == [{"type": "websocket.close", "code": 4401}]
+    assert events == [{"type": "websocket.close", "code": 4401}]