xinference 1.10.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

xinference/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-09-12T21:20:52+0800",
+ "date": "2025-10-19T20:53:12+0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "b018733c97029fb59e8ffe55fadc6473232fbf23",
- "version": "1.10.0"
+ "full-revisionid": "baaa40b463e4948762b078f5995d67775df53704",
+ "version": "1.11.0"
 }
 '''  # END VERSION_JSON
 

xinference/api/restful_api.py

@@ -739,6 +739,18 @@ class RESTfulAPI(CancelMixin):
                 else None
             ),
         )
+        self._router.add_api_route(
+            "/v1/images/edits",
+            self.create_image_edits,
+            methods=["POST"],
+            response_model=ImageList,
+            dependencies=(
+                [Security(self._auth_service, scopes=["models:read"])]
+                if self.is_authenticated()
+                else None
+            ),
+        )
+
         # SD WebUI API
         self._router.add_api_route(
             "/sdapi/v1/options",
@@ -2136,7 +2148,7 @@ class RESTfulAPI(CancelMixin):
     async def create_variations(
         self,
         model: str = Form(...),
-        image: UploadFile = File(media_type="application/octet-stream"),
+        image: List[UploadFile] = File(media_type="application/octet-stream"),
         prompt: Optional[Union[str, List[str]]] = Form(None),
         negative_prompt: Optional[Union[str, List[str]]] = Form(None),
         n: Optional[int] = Form(1),
@@ -2164,8 +2176,17 @@ class RESTfulAPI(CancelMixin):
                 parsed_kwargs = {}
             request_id = parsed_kwargs.get("request_id")
             self._add_running_task(request_id)
+
+            # Handle single image or multiple images
+            if len(image) == 1:
+                # Single image
+                image_data = Image.open(image[0].file)
+            else:
+                # Multiple images - convert to list of PIL Images
+                image_data = [Image.open(img.file) for img in image]
+
             image_list = await model_ref.image_to_image(
-                image=Image.open(image.file),
+                image=image_data,
                 prompt=prompt,
                 negative_prompt=negative_prompt,
                 n=n,
@@ -2290,6 +2311,453 @@ class RESTfulAPI(CancelMixin):
             self.handle_request_limit_error(e)
             raise HTTPException(status_code=500, detail=str(e))
 
+    async def create_image_edits(
+        self,
+        request: Request,
+        prompt: str = Form(...),
+        mask: Optional[UploadFile] = File(None, media_type="application/octet-stream"),
+        model: Optional[str] = Form(None),
+        n: Optional[int] = Form(1),
+        size: Optional[str] = Form("original"),
+        response_format: Optional[str] = Form("url"),
+        stream: Optional[bool] = Form(False),
+    ) -> Response:
+        """OpenAI-compatible image edit endpoint."""
+        import io
+
+        # Parse multipart form data to handle files
+        content_type = request.headers.get("content-type", "")
+
+        if "multipart/form-data" in content_type:
+            # Try manual multipart parsing for better duplicate field handling
+            try:
+                image_files, manual_mask = await self._parse_multipart_manual(request)
+                # Use manually parsed mask if available, otherwise keep the original
+                if manual_mask is not None:
+                    mask = manual_mask
+            except Exception as e:
+                logger.error(f"Manual parsing failed, falling back to FastAPI: {e}")
+                # Fallback to FastAPI form parsing
+                form = await request.form()
+                multipart_files: dict[str, list] = {}
+                for key, value in form.items():
+                    if hasattr(value, "filename") and value.filename:
+                        if key not in multipart_files:
+                            multipart_files[key] = []
+                        multipart_files[key].append(value)
+
+                image_files = multipart_files.get("image", [])
+                if not image_files:
+                    image_files = multipart_files.get("image[]", [])
+                if not image_files:
+                    image_files = multipart_files.get("images", [])
+
+        else:
+            # Fallback to FastAPI form parsing
+            form = await request.form()
+            fallback_files: dict[str, list] = {}
+            for key, value in form.items():
+                if hasattr(value, "filename") and value.filename:
+                    if key not in fallback_files:
+                        fallback_files[key] = []
+                    fallback_files[key].append(value)
+
+            image_files = fallback_files.get("image", [])
+            if not image_files:
+                image_files = fallback_files.get("image[]", [])
+            if not image_files:
+                image_files = fallback_files.get("images", [])
+
+        all_file_keys = []
+        if "multipart/form-data" in content_type:
+            all_file_keys = [f"image[] (x{len(image_files)})"] if image_files else []
+        else:
+            # Fallback to FastAPI form parsing
+            form = await request.form()
+            debug_files: dict[str, list] = {}
+            for key, value in form.items():
+                if hasattr(value, "filename") and value.filename:
+                    if key not in debug_files:
+                        debug_files[key] = []
+                    debug_files[key].append(value)
+
+            # Get image files
+            image_files = debug_files.get("image", [])
+            if not image_files:
+                image_files = debug_files.get("image[]", [])
+            if not image_files:
+                image_files = debug_files.get("images", [])
+
+        logger.info(f"Total image files found: {len(image_files)}")
+
+        if not image_files:
+            # Debug: log all received file fields
+            logger.warning(
+                f"No image files found. Available file fields: {all_file_keys}"
+            )
+            raise HTTPException(
+                status_code=400, detail="At least one image file is required"
+            )
+
+        # Validate response format
+        if response_format not in ["url", "b64_json"]:
+            raise HTTPException(
+                status_code=400, detail="response_format must be 'url' or 'b64_json'"
+            )
+
+        # Get default model if not specified
+        if not model:
+            try:
+                models = await (await self._get_supervisor_ref()).list_models()
+                image_models = [
+                    name
+                    for name, info in models.items()
+                    if info["model_type"] == "image"
+                    and info.get("model_ability", [])
+                    and (
+                        "image2image" in info["model_ability"]
+                        or "inpainting" in info["model_ability"]
+                    )
+                ]
+                if not image_models:
+                    raise HTTPException(
+                        status_code=400, detail="No available image models found"
+                    )
+                model = image_models[0]
+            except Exception as e:
+                logger.error(f"Failed to get available models: {e}", exc_info=True)
+                raise HTTPException(
+                    status_code=500, detail="Failed to get available models"
+                )
+
+        model_uid = model
+        try:
+            model_ref = await (await self._get_supervisor_ref()).get_model(model_uid)
+        except ValueError as ve:
+            logger.error(str(ve), exc_info=True)
+            await self._report_error_event(model_uid, str(ve))
+            raise HTTPException(status_code=400, detail=str(ve))
+        except Exception as e:
+            logger.error(e, exc_info=True)
+            await self._report_error_event(model_uid, str(e))
+            raise HTTPException(status_code=500, detail=str(e))
+
+        request_id = None
+        try:
+            self._add_running_task(request_id)
+
+            # Read and process all images (needed for both streaming and non-streaming)
+            images = []
+            for i, img in enumerate(image_files):
+                image_content = await img.read()
+                image_file = io.BytesIO(image_content)
+                pil_image = Image.open(image_file)
+
+                # Debug: save the received image for inspection
+                debug_filename = f"/tmp/received_image_{i}_{pil_image.mode}_{pil_image.size[0]}x{pil_image.size[1]}.png"
+                pil_image.save(debug_filename)
+                logger.info(f"Saved received image {i} to {debug_filename}")
+
+                # Convert to RGB format to avoid channel mismatch errors
+                if pil_image.mode == "RGBA":
+                    logger.info(f"Converting RGBA image {i} to RGB")
+                    # Create white background for RGBA images
+                    background = Image.new("RGB", pil_image.size, (255, 255, 255))
+                    background.paste(pil_image, mask=pil_image.split()[3])
+                    pil_image = background
+                elif pil_image.mode != "RGB":
+                    logger.info(f"Converting {pil_image.mode} image {i} to RGB")
+                    pil_image = pil_image.convert("RGB")
+
+                # Debug: save the converted image
+                converted_filename = f"/tmp/converted_image_{i}_RGB_{pil_image.size[0]}x{pil_image.size[1]}.png"
+                pil_image.save(converted_filename)
+                logger.info(f"Saved converted image {i} to {converted_filename}")
+
+                images.append(pil_image)
+
+            # Debug: log image summary
+            logger.info(f"Processing {len(images)} images:")
+            for i, img in enumerate(images):
+                logger.info(
+                    f"  Image {i}: mode={img.mode}, size={img.size}, filename={image_files[i].filename if hasattr(image_files[i], 'filename') else 'unknown'}"
+                )
+
+            # Handle streaming if requested
+            if stream:
+                return EventSourceResponse(
+                    self._stream_image_edit(
+                        model_ref,
+                        images,  # Pass processed images instead of raw files
+                        mask,
+                        prompt,
+                        (
+                            size.replace("x", "*") if size else ""
+                        ),  # Convert size format for streaming
+                        response_format,
+                        n,
+                    )
+                )
+
+            # Use the first image as primary, others as reference
+            primary_image = images[0]
+            reference_images = images[1:] if len(images) > 1 else []
+
+            # Prepare model parameters
+            # If size is "original", use empty string to let model determine original dimensions
+            if size == "original":
+                model_size = ""
+            else:
+                model_size = size.replace("x", "*") if size else ""
+
+            model_params = {
+                "prompt": prompt,
+                "n": n or 1,
+                "size": model_size,
+                "response_format": response_format,
+                "denoising_strength": 0.75,  # Default strength for image editing
+                "reference_images": reference_images,  # Pass reference images
+                "negative_prompt": " ",  # Space instead of empty string to prevent filtering
+            }
+
+            # Generate the image
+            if mask:
+                # Use inpainting for masked edits
+                mask_content = await mask.read()
+                mask_image = Image.open(io.BytesIO(mask_content))
+                result = await model_ref.inpainting(
+                    image=primary_image,
+                    mask_image=mask_image,
+                    **model_params,
+                )
+            else:
+                # Use image-to-image for general edits
+                result = await model_ref.image_to_image(
+                    image=primary_image, **model_params
+                )
+
+            # Return the result directly (should be ImageList format)
+            return Response(content=result, media_type="application/json")
+
+        except asyncio.CancelledError:
+            err_str = f"The request has been cancelled: {request_id or 'unknown'}"
+            logger.error(err_str)
+            await self._report_error_event(model_uid, err_str)
+            raise HTTPException(status_code=409, detail=err_str)
+        except Exception as e:
+            e = await self._get_model_last_error(model_ref.uid, e)
+            logger.error(e, exc_info=True)
+            await self._report_error_event(model_uid, str(e))
+            self.handle_request_limit_error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def _parse_multipart_manual(self, request: Request):
+        """Manually parse multipart form data to handle duplicate field names"""
+        import io
+
+        class FileWrapper:
+            """Wrapper for BytesIO to add filename and content_type attributes"""
+
+            def __init__(self, data, filename, content_type="application/octet-stream"):
+                self._file = io.BytesIO(data)
+                self.filename = filename
+                self.content_type = content_type
+
+            def read(self, *args, **kwargs):
+                return self._file.read(*args, **kwargs)
+
+            def seek(self, *args, **kwargs):
+                return self._file.seek(*args, **kwargs)
+
+            def tell(self, *args, **kwargs):
+                return self._file.tell(*args, **kwargs)
+
+        from multipart.multipart import parse_options_header
+
+        content_type = request.headers.get("content-type", "")
+        if not content_type:
+            return [], None
+
+        # Parse content type and boundary
+        content_type, options = parse_options_header(content_type.encode("utf-8"))
+        if content_type != b"multipart/form-data":
+            return [], None
+
+        boundary = options.get(b"boundary")
+        if not boundary:
+            return [], None
+
+        # Get the raw body
+        body = await request.body()
+
+        # Parse multipart data manually
+        image_files = []
+        mask_file = None
+        try:
+            # Import multipart parser
+            from multipart.multipart import MultipartParser
+
+            # Parse the multipart data
+            parser = MultipartParser(
+                io.BytesIO(body),
+                boundary.decode("utf-8") if isinstance(boundary, bytes) else boundary,
+            )
+
+            for part in parser:
+                # Check if this part is an image file
+                field_name = part.name
+                filename = part.filename or ""
+
+                # Look for image fields with different naming conventions
+                if field_name in ["image", "image[]", "images"] and filename:
+                    # Create a file-like object from the part data
+                    file_obj = FileWrapper(
+                        part.data,
+                        filename,
+                        part.content_type or "application/octet-stream",
+                    )
+                    image_files.append(file_obj)
+                elif field_name == "mask" and filename:
+                    # Handle mask file
+                    mask_file = FileWrapper(
+                        part.data,
+                        filename,
+                        part.content_type or "application/octet-stream",
+                    )
+                    logger.info(f"Manual multipart parsing found mask file: {filename}")
+
+            logger.info(
+                f"Manual multipart parsing found {len(image_files)} image files and mask: {mask_file is not None}"
+            )
+
+        except Exception as e:
+            logger.error(f"Manual multipart parsing failed: {e}")
+            # Return empty list to trigger fallback
+            return [], None
+
+        return image_files, mask_file
+
+    async def _stream_image_edit(
+        self, model_ref, images, mask, prompt, size, response_format, n
+    ):
+        """Stream image editing progress and results"""
+        import io
+        import json
+        from datetime import datetime
+
+        try:
+            # Send start event
+            yield {
+                "event": "start",
+                "data": json.dumps(
+                    {
+                        "type": "image_edit_started",
+                        "timestamp": datetime.now().isoformat(),
+                        "prompt": prompt,
+                        "image_count": len(images),
+                    }
+                ),
+            }
+
+            # Images are already processed in the main method, just use them directly
+            image_objects = images
+            logger.info(f"Streaming: Using {len(image_objects)} pre-processed images")
+
+            # Debug: log streaming image summary
+            logger.info(f"Streaming: Processing {len(image_objects)} images:")
+            for i, img in enumerate(image_objects):
+                logger.info(f"  Streaming Image {i}: mode={img.mode}, size={img.size}")
+
+            # Use the first image as primary, others as reference
+            primary_image = image_objects[0]
+            reference_images = image_objects[1:] if len(image_objects) > 1 else []
+
+            # Send processing event
+            yield {
+                "event": "processing",
+                "data": json.dumps(
+                    {
+                        "type": "images_loaded",
+                        "timestamp": datetime.now().isoformat(),
+                        "primary_image_size": primary_image.size,
+                        "reference_images_count": len(reference_images),
+                    }
+                ),
+            }
+
+            # Prepare model parameters
+            # If size is "original", use empty string to let model determine original dimensions
+            if size == "original":
+                model_size = ""
+            else:
+                model_size = size
+
+            model_params = {
+                "prompt": prompt,
+                "n": n or 1,
+                "size": model_size,
+                "response_format": response_format,
+                "denoising_strength": 0.75,
+                "reference_images": reference_images,
+                "negative_prompt": " ",  # Space instead of empty string to prevent filtering
+            }
+
+            # Generate the image
+            if mask:
+                mask_content = await mask.read()
+                mask_image = Image.open(io.BytesIO(mask_content))
+                yield {
+                    "event": "processing",
+                    "data": json.dumps(
+                        {
+                            "type": "mask_loaded",
+                            "timestamp": datetime.now().isoformat(),
+                            "mask_size": mask_image.size,
+                        }
+                    ),
+                }
+                result = await model_ref.inpainting(
+                    image=primary_image,
+                    mask_image=mask_image,
+                    **model_params,
+                )
+            else:
+                yield {
+                    "event": "processing",
+                    "data": json.dumps(
+                        {
+                            "type": "starting_generation",
+                            "timestamp": datetime.now().isoformat(),
+                        }
+                    ),
+                }
+                result = await model_ref.image_to_image(
+                    image=primary_image, **model_params
+                )
+
+            # Parse the result and send final event in OpenAI format
+            result_data = json.loads(result)
+
+            # Send completion event with OpenAI-compatible format
+            yield {
+                "event": "complete",
+                "data": json.dumps(
+                    result_data
+                ),  # Direct send the result in OpenAI format
+            }
+
+        except Exception as e:
+            yield {
+                "event": "error",
+                "data": json.dumps(
+                    {
+                        "type": "image_edit_error",
+                        "timestamp": datetime.now().isoformat(),
+                        "error": str(e),
+                    }
+                ),
+            }
+
     async def create_flexible_infer(self, request: Request) -> Response:
         payload = await request.json()
 
@@ -2346,7 +2814,7 @@ class RESTfulAPI(CancelMixin):
             )
             return Response(content=video_list, media_type="application/json")
         except asyncio.CancelledError:
-            err_str = f"The request has been cancelled: {request_id}"
+            err_str = f"The request has been cancelled: {request_id or 'unknown'}"
             logger.error(err_str)
             await self._report_error_event(model_uid, err_str)
             raise HTTPException(status_code=409, detail=err_str)
@@ -2395,7 +2863,7 @@ class RESTfulAPI(CancelMixin):
             )
             return Response(content=video_list, media_type="application/json")
         except asyncio.CancelledError:
-            err_str = f"The request has been cancelled: {request_id}"
+            err_str = f"The request has been cancelled: {request_id or 'unknown'}"
             logger.error(err_str)
             await self._report_error_event(model_uid, err_str)
             raise HTTPException(status_code=409, detail=err_str)
@@ -2446,7 +2914,7 @@ class RESTfulAPI(CancelMixin):
             )
             return Response(content=video_list, media_type="application/json")
         except asyncio.CancelledError:
-            err_str = f"The request has been cancelled: {request_id}"
+            err_str = f"The request has been cancelled: {request_id or 'unknown'}"
             logger.error(err_str)
             await self._report_error_event(model_uid, err_str)
             raise HTTPException(status_code=409, detail=err_str)
@@ -2858,19 +3326,6 @@ class RESTfulAPI(CancelMixin):
     def extract_guided_params(raw_body: dict) -> dict:
         kwargs = {}
         raw_extra_body: dict = raw_body.get("extra_body")  # type: ignore
-        # Convert OpenAI response_format to vLLM guided decoding
-        response_format = raw_body.get("response_format")
-        if response_format is not None:
-            if isinstance(response_format, dict):
-                format_type = response_format.get("type")
-                if format_type == "json_schema":
-                    json_schema = response_format.get("json_schema")
-                    if isinstance(json_schema, dict):
-                        schema = json_schema.get("schema")
-                        if schema is not None:
-                            kwargs["guided_json"] = schema
-                elif format_type == "json_object":
-                    kwargs["guided_json_object"] = True
         if raw_body.get("guided_json"):
             kwargs["guided_json"] = raw_body.get("guided_json")
         if raw_body.get("guided_regex") is not None:
@@ -2889,19 +3344,6 @@ class RESTfulAPI(CancelMixin):
             )
         # Parse OpenAI extra_body
         if raw_extra_body is not None:
-            # Convert OpenAI response_format to vLLM guided decoding
-            extra_response_format = raw_extra_body.get("response_format")
-            if extra_response_format is not None:
-                if isinstance(extra_response_format, dict):
-                    format_type = extra_response_format.get("type")
-                    if format_type == "json_schema":
-                        json_schema = extra_response_format.get("json_schema")
-                        if isinstance(json_schema, dict):
-                            schema = json_schema.get("schema")
-                            if schema is not None:
-                                kwargs["guided_json"] = schema
-                    elif format_type == "json_object":
-                        kwargs["guided_json_object"] = True
             if raw_extra_body.get("guided_json"):
                 kwargs["guided_json"] = raw_extra_body.get("guided_json")
             if raw_extra_body.get("guided_regex") is not None: