使用fastapi的时候，swagger-ui.css 、swagger-ui-bundle.js、redoc.standalone.js 有时候无法加载（国内环境原因或者是局域网屏蔽），此时就需要自己用魔法下载好对应文件，然后替换到fastapi里面去。





fastapi里面依靠这2个函数实现docs和redoc：

```bash
from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
```

fastapi里面官网给的解决办法：

[https://github.com/tiangolo/fastapi/blob/ac93277d3b506f4076aee1af6ae5a86406f545c6/docs_src/custom_docs_ui/tutorial001.py#L4](https://github.com/tiangolo/fastapi/blob/ac93277d3b506f4076aee1af6ae5a86406f545c6/docs_src/custom_docs_ui/tutorial001.py#L4)

实践起来就是，首先下载好这些文件：

![在这里插入图片描述](/static/img/images/03782.png)

其次复现出/docs路由和/redoc路由：

```python
import os
import uvicorn
from fastapi import FastAPI
from starlette.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
app = FastAPI(
    title='outpainting_captioning_upscaler',
    description='outpainting images, captioning images,upscaler images',
    version='1.0.0',
    docs_url=None,
    redoc_url=None,  # 设置 ReDoc 文档的路径
)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
app.mount("/static", StaticFiles(directory="static"), name="static")
@app.get("/docs", include_in_schema=False)
async def custom_swagger_ui_html():
    return get_swagger_ui_html(
        openapi_url="/openapi.json",
        title="xx",
        # oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url,
        swagger_js_url='/static/swagger/swagger-ui-bundle.js',
        swagger_css_url='/static/swagger/swagger-ui.css',
        swagger_favicon_url='/static/swagger/img.png',
    )
@app.get("/redoc", include_in_schema=False)
async def redoc_html():
    return get_redoc_html(
        openapi_url=app.openapi_url,
        title=app.title + " - ReDoc",
        redoc_js_url="/static/swagger/redoc.standalone.js",
    )
# 写个测试接口
@app.get('/xx')
async def test():
    return {'message': 'test success'}
if __name__ == '__main__':
    uvicorn.run(f'{os.path.basename(__file__).split(".")[0]}:app',
                host='0.0.0.0',
                port=7777,
                reload=False,
                workers=1)
```

其中文件也可以去这里下载：

```bash
下载:https://wwsm.lanzouy.com/i682Q1frjnmd 密码:9zw2
```



成功：

![在这里插入图片描述](/static/img/images/03783.png)

【Python】Fastapi swagger-ui.css 、swagger-ui-bundle.js 无法加载，docs无法加载，redocs无法使用

Python





```python
import copy
import logging
import sys
class ColoredFormatter(logging.Formatter):
    COLORS = {
        "DEBUG": "\033[0;36m",  # CYAN
        "INFO": "\033[0;32m",  # GREEN
        "WARNING": "\033[0;33m",  # YELLOW
        "ERROR": "\033[0;31m",  # RED
        "CRITICAL": "\033[0;37;41m",  # WHITE ON RED
        "RESET": "\033[0m",  # RESET COLOR
    }
    def format(self, record):
        colored_record = copy.copy(record)
        levelname = colored_record.levelname
        seq = self.COLORS.get(levelname, self.COLORS["RESET"])
        colored_record.levelname = f"{seq}{levelname}{self.COLORS['RESET']}"
        return super().format(colored_record)
# Create a new logger
logger = logging.getLogger("user_server")
logger.propagate = False
# Add handler if we don't have one.
if not logger.handlers:
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(
        ColoredFormatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    )
    logger.addHandler(handler)
# Configure logger
loglevel = getattr(logging, "INFO", "info")
logger.setLevel(loglevel)
logger.info("sdfasdasdas")
logger.warning("sdfasdasdas")
logger.error("sdfasdasdas")
```


![在这里插入图片描述](/static/img/images/03790.png)

【python】【logging】python如何使用logging模块，一个完美的logging模块

pip install pillow





示例代码：
```python
from PIL import Image, ImageSequence
# 图片文件名列表
image_files = ['car.png', 'detected_map.png', 'base64_image_out.png']
# 打开图片
images = [Image.open(filename) for filename in image_files]
# 设置输出 GIF 文件名
output_gif = 'output.gif'
# 将图片保存为 GIF
images[0].save(
    output_gif,
    save_all=True,
    append_images=images[1:],
    duration=2000,  # 设置每张图片的显示时间（毫秒）
    loop=0,  # 设置循环次数，0 表示不循环
)
print(f'GIF 文件已创建: {output_gif}')
```

将某个路径的所有图片按名称排序后，转为gif文件：

```clike
import os
from PIL import Image, ImageSequence
# 目标路径
target_path = './images'
# 获取目录下所有文件
all_files = os.listdir(target_path)
# 筛选出图片文件
image_files = [os.path.join(target_path, filename) for filename in all_files if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif'))]
# 按照文件名排序
sorted_image_files = sorted(image_files)
# 打开图片并调整为相同的模式
images = [Image.open(filename).convert('RGBA') for filename in sorted_image_files]
# 设置输出 GIF 文件名
output_gif = 'output.gif'
# 将图片保存为 GIF
images[0].save(
    output_gif,
    save_all=True,
    append_images=images[1:],
    duration=2000,  # 设置每张图片的显示时间（毫秒）
    loop=0,  # 设置循环次数，0 表示不循环
)
print(f'GIF 文件已创建: {output_gif}')
```

![在这里插入图片描述](/static/img/images/03791.gif)

【python】Python生成GIF动图，多张图片转动态图，pillow

原则：





1. 输入输出都基于BaseModel

2. 依靠JSONResponse制定返回错误的json信息

3. 依靠装饰器中@app.post制定responses字典从而让docs文档更丰富


```python
import uvicorn
from pydantic import BaseModel, Field
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from transformers import BlipProcessor, BlipForConditionalGeneration
from fastapi.responses import JSONResponse
from PIL import Image
import io
import base64
class UpscalerRequest(BaseModel):
    base64_image: str = Field(
        ...,
        title="Base64 Encoded Image",
        description="The base64-encoded image that you want to upscale."
    )
    outscale: float = Field(
        ...,
        ge=1.0,  # 大于等于1.0
        le=5.0,  # 小于等于5.0
        title="Upscale Factor",
        description="The scaling factor for image upscaling. Should be between 1.0 and 5.0."
    )
class UpscalerResponse(BaseModel):
    base64_image_out: str = Field(
        ...,
        title="Base64 Encoded Upscaled Image",
        description="The base64-encoded image after upscaling."
    )
class CustomErrorResponse:
    def __init__(self, description: str, error_code: int, detail: str):
        self.description = description
        self.error_code = error_code
        self.detail = detail
    def to_response_dict(self):
        return {
            "description": self.description,
            "content": {
                "application/json": {
                    "example": {"error_code": self.error_code, "detail": self.detail}
                }
            },
        }
    def __call__(self, extra_detail=None):
        if extra_detail is not None:
            self.detail = f"detail:{self.detail}, extra_detail:{extra_detail}"
        return JSONResponse(content={"error_code": self.error_code, "detail": self.detail}, status_code=self.error_code)
image_upscaler_CustomErrorResponse = CustomErrorResponse("超分执行错误", 501, "upscale error")
@app.post("/image_upscaler", response_model=UpscalerResponse, summary="Image Upscaler",
          responses={image_upscaler_CustomErrorResponse.error_code: image_upscaler_CustomErrorResponse.to_response_dict()})
def image_upscaler(request: UpscalerRequest):
    """
    Image Upscaler.
    Parameters:
    - `base64_image`: The base64-encoded image.
    - `outscale`: The scaling factor for image upscaling (between 1.0 and 5.0).
    Returns:
    - `output`: The base64-encoded upscaled image.
    Example:
    ```python

import requests

import base64

from PIL import Image

from io import BytesIO

# 1. 读取图像文件并转换为base64字符串

image_path = "car.png"

with open(image_path, "rb") as image_file:

    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

# 2. 构造请求数据

outpainting_request = {

    "base64_image": base64_image,

    "outscale": 3,

}

# 3. 发送HTTP POST请求

api_url = "http://home.elvisiky.com:7862/image_upscaler"

response = requests.post(api_url, json=outpainting_request)

# 4. 处理响应

if response.status_code == 200:

    result_data = response.json()

    # 5. 保存base64编码的图像为文件

    detected_map_base64 = result_data["base64_image_out"]

    detected_map_image = Image.open(BytesIO(base64.b64decode(detected_map_base64)))

    detected_map_image.save("base64_image_out.png")

    print("图像保存成功！")

else:

    print(f"API调用失败，HTTP状态码：{response.status_code}")

    print(response.json())

    ```
    """
    try:
        base64_image = request.base64_image
        logging.info(f"image_upscaler, image length {len(base64_image)}")
        img = decode_image_from_base64(base64_image)
        img_cv2 = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
        output = enhance_image(img_cv2, outscale=request.outscale)
        if output is None:
            return image_upscaler_CustomErrorResponse()
        else:
            output_base64 = base64.b64encode(cv2.imencode('.png', output)[1]).decode('utf-8')
            return {"base64_image_out": output_base64}
    except Exception as e:
        return image_upscaler_CustomErrorResponse(str(e))
if __name__ == '__main__':
    uvicorn.run(f'{os.path.basename(__file__).split(".")[0]}:app',
                host='0.0.0.0',
                port=7862,
                reload=False,
                workers=1)
```

![在这里插入图片描述](/static/img/images/03792.png)

【python FastAPI】fastapi中如何限制输入参数，如何让docs更好看，如何自定义错误码json返回

![在这里插入图片描述](/static/img/images/03819.png)






```python
import tkinter as tk
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from pylab import mpl
mpl.rcParams['font.sans-serif'] = ['FangSong']  # 指定默认字体
mpl.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
# 函数用于执行最小二乘法线性拟合
def linear_regression():
    x_values = [float(x) for x in x_entry.get().split()]
    y_values = [float(y) for y in y_entry.get().split()]
    A = np.vstack([x_values, np.ones(len(x_values))]).T
    m, c = np.linalg.lstsq(A, y_values, rcond=None)[0]
    # 清空画布
    ax[0].clear()
    ax[1].clear()
    # 绘制数据点
    ax[0].scatter(x_values, y_values, label='数据点')
    # 绘制最小二乘法拟合线
    ax[0].plot(x_values, m * np.array(x_values) + c, 'r', label='自己计算的')
    ax[0].set_title(f'自己计算的: Y = {m:.5f} * X + {c:.5f}')
    # 从斜率和截距输入框获取备选直线的参数
    lines_m = [float(m) for m in m_entry.get().split()]
    lines_c = [float(c) for c in c_entry.get().split()]
    # 绘制备选直线
    for i in range(len(lines_m)):
        ax[0].plot(x_values, lines_m[i] * np.array(x_values) + lines_c[i], label=f'直线 {i + 1}')
    # 计算备选直线中最好的拟合直线，得到是哪一条直线最好
    best_line_index = np.argmin([np.sum(np.square(y_values - (m * np.array(x_values) + c))) for m, c in
                                 zip(lines_m, lines_c)])
    ax[0].set_xlabel('X')
    ax[0].set_ylabel('Y')
    ax[0].legend()
    # 在ax[1]绘制最好的直线
    ax[1].scatter(x_values, y_values, label='数据点')
    ax[1].plot(x_values, lines_m[best_line_index] * np.array(x_values) + lines_c[best_line_index], 'r',
               label=f'直线 {best_line_index + 1}')
    ax[1].set_title(
        f'最佳备选线: Y = {lines_m[best_line_index]} * X + {lines_c[best_line_index]},Index: {best_line_index + 1}')
    ax[1].set_xlabel('X')
    ax[1].set_ylabel('Y')
    ax[1].legend()
    canvas.draw()
# 创建Tkinter窗口
root = tk.Tk()
root.title('最小二乘法线性拟合')
frame = tk.Frame(root)
frame.pack(padx=10, pady=10)
# 创建输入框和标签
x_label = tk.Label(frame, text='输入x值（用空格分隔）:')
x_label.pack()
x_entry = tk.Entry(frame)
x_entry.insert(0, '2 4 6 8 10')  # 设置默认值
x_entry.pack()
y_label = tk.Label(frame, text='输入y值（用空格分隔）:')
y_label.pack()
y_entry = tk.Entry(frame)
y_entry.insert(0, '10.046 20.090 30.155 40.125 50.074')  # 设置默认值
y_entry.pack()
m_label = tk.Label(frame, text='输入备选直线的斜率（用空格分隔）:')
m_label.pack()
m_entry = tk.Entry(frame)
m_entry.insert(0, '5.0 5.01 4.97 4.95 5.08')  # 设置默认值
m_entry.pack()
c_label = tk.Label(frame, text='输入备选直线的截距（用空格分隔）:')
c_label.pack()
c_entry = tk.Entry(frame)
c_entry.insert(0, '0.08 0.07 0.12 0.15 0.06')  # 设置默认值
c_entry.pack()
# 创建确认按钮
calculate_button = tk.Button(frame, text='确认', command=linear_regression)
calculate_button.pack()
# 创建大画布
fig, ax = plt.subplots(1, 2, figsize=(10, 5))
canvas = FigureCanvasTkAgg(fig, master=frame)
canvas.get_tk_widget().pack()
canvas.draw()
# 运行Tkinter主循环
root.mainloop()
```

最小二乘法，可视化UI界面

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。