Apply style fixes

Author: github-actions[bot]

examples/server-async/Pipelines.py

@@ -1,13 +1,17 @@
-from diffusers.pipelines.stable_diffusion_3.pipeline_stable_diffusion_3 import StableDiffusion3Pipeline
-import torch
-import os
 import logging
-from pydantic import BaseModel
-from dataclasses import dataclass,  field
+import os
+from dataclasses import dataclass, field
 from typing import List
 
+import torch
+from pydantic import BaseModel
+
+from diffusers.pipelines.stable_diffusion_3.pipeline_stable_diffusion_3 import StableDiffusion3Pipeline
+
+
 logger = logging.getLogger(__name__)
 
+
 class TextToImageInput(BaseModel):
     model: str
     prompt: str
@@ -17,8 +21,15 @@ class TextToImageInput(BaseModel):
 
 @dataclass
 class PresetModels:
-    SD3: List[str] = field(default_factory=lambda: ['stabilityai/stable-diffusion-3-medium'])
-    SD3_5: List[str] = field(default_factory=lambda: ['stabilityai/stable-diffusion-3.5-large', 'stabilityai/stable-diffusion-3.5-large-turbo', 'stabilityai/stable-diffusion-3.5-medium'])
+    SD3: List[str] = field(default_factory=lambda: ["stabilityai/stable-diffusion-3-medium"])
+    SD3_5: List[str] = field(
+        default_factory=lambda: [
+            "stabilityai/stable-diffusion-3.5-large",
+            "stabilityai/stable-diffusion-3.5-large-turbo",
+            "stabilityai/stable-diffusion-3.5-medium",
+        ]
+    )
+
 
 class TextToImagePipelineSD3:
     def __init__(self, model_path: str | None = None):
@@ -46,8 +57,9 @@ def start(self):
         else:
             raise Exception("No CUDA or MPS device available")
 
+
 class ModelPipelineInitializer:
-    def __init__(self, model: str = '', type_models: str = 't2im'):
+    def __init__(self, model: str = "", type_models: str = "t2im"):
         self.model = model
         self.type_models = type_models
         self.pipeline = None
@@ -68,12 +80,12 @@ def initialize_pipeline(self):
             self.model_type = "SD3_5"
 
         # Create appropriate pipeline based on model type and type_models
-        if self.type_models == 't2im':
+        if self.type_models == "t2im":
             if self.model_type in ["SD3", "SD3_5"]:
                 self.pipeline = TextToImagePipelineSD3(self.model)
             else:
                 raise ValueError(f"Model type {self.model_type} not supported for text-to-image")
-        elif self.type_models == 't2v':
+        elif self.type_models == "t2v":
             raise ValueError(f"Unsupported type_models: {self.type_models}")
 
-        return self.pipeline
+        return self.pipeline

examples/server-async/serverasync.py

@@ -1,41 +1,45 @@
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.responses import FileResponse  
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.concurrency import run_in_threadpool
-from pydantic import BaseModel
-from Pipelines import ModelPipelineInitializer
-from utils import Utils, RequestScopedPipeline
+import asyncio
+import gc
 import logging
-import random
-from dataclasses import dataclass
 import os
-import torch
+import random
 import threading
-import gc
-from typing import Optional, Dict, Any, Type
 from contextlib import asynccontextmanager
-import asyncio
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Type
+
+import torch
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.concurrency import run_in_threadpool
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from Pipelines import ModelPipelineInitializer
+from pydantic import BaseModel
+
+from utils import RequestScopedPipeline, Utils
 
 
 @dataclass
 class ServerConfigModels:
-    model: str = 'stabilityai/stable-diffusion-3.5-medium'  
-    type_models: str = 't2im'  
+    model: str = "stabilityai/stable-diffusion-3.5-medium"
+    type_models: str = "t2im"
     constructor_pipeline: Optional[Type] = None
-    custom_pipeline: Optional[Type] = None  
+    custom_pipeline: Optional[Type] = None
     components: Optional[Dict[str, Any]] = None
     torch_dtype: Optional[torch.dtype] = None
-    host: str = '0.0.0.0' 
+    host: str = "0.0.0.0"
     port: int = 8500
 
+
 server_config = ServerConfigModels()
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     logging.basicConfig(level=logging.INFO)
     app.state.logger = logging.getLogger("diffusers-server")
-    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128,expandable_segments:True'
-    os.environ['CUDA_LAUNCH_BLOCKING'] = '0'
+    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128,expandable_segments:True"
+    os.environ["CUDA_LAUNCH_BLOCKING"] = "0"
 
     app.state.total_requests = 0
     app.state.active_inferences = 0
@@ -81,12 +85,12 @@ async def metrics_loop():
 
         app.state.logger.info("Lifespan shutdown complete")
 
+
 app = FastAPI(lifespan=lifespan)
 
 logger = logging.getLogger("DiffusersServer.Pipelines")
 
 
-        
 initializer = ModelPipelineInitializer(
     model=server_config.model,
     type_models=server_config.type_models,
@@ -104,12 +108,14 @@ async def metrics_loop():
 app.state.REQUEST_PIPE = request_pipe
 app.state.PIPELINE_LOCK = pipeline_lock
 
+
 class JSONBodyQueryAPI(BaseModel):
-    model : str | None = None
-    prompt : str
-    negative_prompt : str | None = None
-    num_inference_steps : int = 28
-    num_images_per_prompt : int = 1
+    model: str | None = None
+    prompt: str
+    negative_prompt: str | None = None
+    num_inference_steps: int = 28
+    num_images_per_prompt: int = 1
+
 
 @app.middleware("http")
 async def count_requests_middleware(request: Request, call_next):
@@ -123,25 +129,24 @@ async def count_requests_middleware(request: Request, call_next):
 async def root():
     return {"message": "Welcome to the Diffusers Server"}
 
+
 @app.post("/api/diffusers/inference")
 async def api(json: JSONBodyQueryAPI):
-    prompt                = json.prompt
-    negative_prompt       = json.negative_prompt or ""
-    num_steps             = json.num_inference_steps
+    prompt = json.prompt
+    negative_prompt = json.negative_prompt or ""
+    num_steps = json.num_inference_steps
     num_images_per_prompt = json.num_images_per_prompt
 
-    wrapper     = app.state.MODEL_PIPELINE   
+    wrapper = app.state.MODEL_PIPELINE
     initializer = app.state.MODEL_INITIALIZER
 
     utils_app = app.state.utils_app
 
-
     if not wrapper or not wrapper.pipeline:
         raise HTTPException(500, "Model not initialized correctly")
     if not prompt.strip():
         raise HTTPException(400, "No prompt provided")
 
-
     def make_generator():
         g = torch.Generator(device=initializer.device)
         return g.manual_seed(random.randint(0, 10_000_000))
@@ -168,7 +173,7 @@ def infer():
 
         async with app.state.metrics_lock:
             app.state.active_inferences = max(0, app.state.active_inferences - 1)
-                
+
         urls = [utils_app.save_image(img) for img in output.images]
         return {"response": urls}
 
@@ -195,27 +200,25 @@ async def serve_image(filename: str):
         raise HTTPException(status_code=404, detail="Image not found")
     return FileResponse(file_path, media_type="image/png")
 
+
 @app.get("/api/status")
 async def get_status():
     memory_info = {}
     if torch.cuda.is_available():
         memory_allocated = torch.cuda.memory_allocated() / 1024**3  # GB
-        memory_reserved = torch.cuda.memory_reserved() / 1024**3    # GB
+        memory_reserved = torch.cuda.memory_reserved() / 1024**3  # GB
         memory_info = {
             "memory_allocated_gb": round(memory_allocated, 2),
             "memory_reserved_gb": round(memory_reserved, 2),
-            "device": torch.cuda.get_device_name(0)
+            "device": torch.cuda.get_device_name(0),
         }
 
-    return {
-        "current_model" : server_config.model,
-        "type_models" : server_config.type_models,
-        "memory" : memory_info}
-        
+    return {"current_model": server_config.model, "type_models": server_config.type_models, "memory": memory_info}
+
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], 
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -224,4 +227,4 @@ async def get_status():
 if __name__ == "__main__":
     import uvicorn
 
-    uvicorn.run(app, host=server_config.host, port=server_config.port)
+    uvicorn.run(app, host=server_config.host, port=server_config.port)

examples/server-async/test.py

@@ -1,15 +1,18 @@
 import os
 import time
 import urllib.parse
+
 import requests
 
+
 SERVER_URL = "http://localhost:8500/api/diffusers/inference"
 BASE_URL = "http://localhost:8500"
 DOWNLOAD_FOLDER = "generated_images"
 WAIT_BEFORE_DOWNLOAD = 2  # seconds
 
 os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
 
+
 def save_from_url(url: str) -> str:
     """Download the given URL (relative or absolute) and save it locally."""
     if url.startswith("/"):
@@ -24,11 +27,12 @@ def save_from_url(url: str) -> str:
         f.write(resp.content)
     return path
 
+
 def main():
     payload = {
         "prompt": "The T-800 Terminator Robot Returning From The Future, Anime Style",
         "num_inference_steps": 30,
-        "num_images_per_prompt": 1
+        "num_images_per_prompt": 1,
     }
 
     print("Sending request...")
@@ -56,5 +60,6 @@ def main():
         except Exception as e:
             print(f"Error downloading {u}: {e}")
 
+
 if __name__ == "__main__":
     main()

examples/server-async/utils/__init__.py

@@ -1,2 +1,2 @@
 from .requestscopedpipeline import RequestScopedPipeline
-from .utils import Utils
+from .utils import Utils