Merge pull request #8662 from vladmandic/api-handler

from threading import Lock

from io import BytesIO

from gradio.processing_utils import decode_base64_to_file

from fastapi import APIRouter, Depends, FastAPI, HTTPException, Request, Response

from fastapi import APIRouter, Depends, FastAPI, Request, Response

from fastapi.security import HTTPBasic, HTTPBasicCredentials

from fastapi.exceptions import HTTPException

from fastapi.responses import JSONResponse

from fastapi.encoders import jsonable_encoder

from secrets import compare_digest

import modules.shared as shared

    return base64.b64encode(bytes_data)

def api_middleware(app: FastAPI):

    rich_available = True

    try:

        import anyio # importing just so it can be placed on silent list

        import starlette # importing just so it can be placed on silent list

        from rich.console import Console

        console = Console()

    except:

        import traceback

        rich_available = False

    @app.middleware("http")

    async def log_and_time(req: Request, call_next):

        ts = time.time()

            ))

        return res

    def handle_exception(request: Request, e: Exception):

        err = {

            "error": type(e).__name__,

            "detail": vars(e).get('detail', ''),

            "body": vars(e).get('body', ''),

            "errors": str(e),

        }

        print(f"API error: {request.method}: {request.url} {err}")

        if not isinstance(e, HTTPException): # do not print backtrace on known httpexceptions

            if rich_available:

                console.print_exception(show_locals=True, max_frames=2, extra_lines=1, suppress=[anyio, starlette], word_wrap=False, width=min([console.width, 200]))

            else:

                traceback.print_exc()

        return JSONResponse(status_code=vars(e).get('status_code', 500), content=jsonable_encoder(err))

    @app.middleware("http")

    async def exception_handling(request: Request, call_next):

        try:

            return await call_next(request)

        except Exception as e:

            return handle_exception(request, e)

    @app.exception_handler(Exception)

    async def fastapi_exception_handler(request: Request, e: Exception):

        return handle_exception(request, e)

    @app.exception_handler(HTTPException)

    async def http_exception_handler(request: Request, e: HTTPException):

        return handle_exception(request, e)

class Api:

    def __init__(self, app: FastAPI, queue_lock: Lock):

torchsde

safetensors

psutil

rich