YONGFEIUALL

Python给Jenkins Job批量修改权限

2022-02-21T01:16:09.000Z

开发老是不自觉的更新UAT的Job，对测试造成一定的影响。查看了一下，Jenkins上的用户是通过第三方系统引入的，没有更合理的分组，用Role Based Strategy不能够实现对特定Job的权限控制。

采用项目矩阵授权策略来实现：目前的权限不受影响，只有UAT View下的Job只有测试能访问执行。

全局配置，设置Admin和Authenticated User权限
项目设置，选择不继承权限策略，并对特定用户加进来设置相应权限

这种方式，View下有很多个Job，每来一个人都要一个一个加，可以利用代码方式批量的来添加用户权限：

s = jenkins.Jenkins(url=URL, username=USERNAME, password=PASSWORD)

jobs = s.get_jobs(view_name=VIEW_NAME)

for job in jobs:
    name = job['name']
    config = s.get_job_config(name)

    content = f'''</permission>
    <permission>hudson.model.Item.Build:{USER}</permission>
    <permission>hudson.model.Item.Cancel:{USER}</permission>
    <permission>hudson.model.Item.Configure:{USER}</permission>
    <permission>hudson.model.Item.Delete:{USER}</permission>
    <permission>hudson.model.Item.Move:{USER}</permission>
    <permission>hudson.model.Item.Read:{USER}</permission>
    <permission>hudson.model.Item.Workspace:{USER}</permission>
    '''

    new = config.replace('</permission>', content, 1)

    s.reconfig_job(name, new)

Python给Gogs项目批量打Tag

2021-10-21T03:03:54.000Z

Gogs的Rest API不能用，就用下面的方式来实现：

通过csv文件配置要打Tag的项目

1	Project Name,Release,Tag Name,Tag Branch,Title,Content t1,Y,v1.1.0,master,,test1 t2,Y,v1.1.0,master,v1.1.0,test2 t3,Y,v1.1.0,master,v1.1.0,test3

实现

session = HTMLSession()

# Get crsf token
r = session.get(url=f'{URL}/user/login')
csrf = r.html.xpath('//input[@name="_csrf"]/@value', first=True)

# Login
data = {
    '_csrf': csrf,
    'user_name': USERNAME,
    'password': PASSWORD,
    'login_source': 2
}
session.post(url=f'{URL}/user/login', data=data)

# Get login crsf token
r = session.get(url=f'{URL}')
login_csrf = r.html.xpath('//meta[@name="_csrf"]/@content', first=True)

# Set tag for project from csv file
projects = get_test_csv_data('build.csv')
for project in projects:
    if project[1] == 'Y':

        build_data = {
            'tag_name': project[2],
            'tag_target': project[3],
            'title': project[4],
            'content': project[5],
            '_csrf': login_csrf
        }

        print(f'===== set tag {project[2]} for {project[0]} =====')
        print(build_data)
        r = session.post(url=f'{URL}/{OWNER}/{project[0]}/releases/new', data=build_data)

        # Verify set correctly
        try:
            res = session.get(f'{URL}/{OWNER}/{project[0]}/releases')
            version = res.html.xpath('//ul[@id="release-list"]//a', first=True).text
            if version == project[2]:
                print(f'===== set tag {project[2]} for {project[0]} successfully =====')
        except:
            print(f'===== set tag {project[2]} for {project[0]} failed =====')
        print()

结果

===== set tag v1.1.0 for t1 =====
{'tag_name': 'v1.1.0', 'tag_target': 'master', 'title': '', 'content': 'test1', '_csrf': 'iE2XUTv0z4jDvjr6HuPYTiFvOrc6MTYzNTUwMDA3OTgyNjgxNTU5Mw=='}
===== set tag v1.1.0 for t1 failed =====

===== set tag v1.1.0 for t2 =====
{'tag_name': 'v1.1.0', 'tag_target': 'master', 'title': 'v1.1.0', 'content': 'test2', '_csrf': 'iE2XUTv0z4jDvjr6HuPYTiFvOrc6MTYzNTUwMDA3OTgyNjgxNTU5Mw=='}
===== set tag v1.1.0 for t2 successfully =====

===== set tag v1.1.0 for t3 =====
{'tag_name': 'v1.1.0', 'tag_target': 'master', 'title': 'v1.1.0', 'content': 'test3', '_csrf': 'iE2XUTv0z4jDvjr6HuPYTiFvOrc6MTYzNTUwMDA3OTgyNjgxNTU5Mw=='}
===== set tag v1.1.0 for t3 successfully =====

Python获得Gogs里项目最新发布版本Version

2021-10-10T05:59:01.000Z

现在每个大版本号对应的各个项目的小版本号是不一致的，要快速的获得每次发布所对应的版本号。写个脚本来实现。

session = HTMLSession()

# Get crsf token
r = session.get(url=URL)
csrf = r.html.xpath('//input[@name="_csrf"]', first=True)

# Login
data = {
    '_csrf': csrf.attrs.get('value'),
    'user_name': USERNAME,
    'password': PASSWORD,
    'login_source': 2
}
session.post(url=URL, data=data)

# Get project latest release version
release_version = {}
for p in PROJECT_LIST:
    res = session.get(f'https://{URL}/{p}/releases')

    version = res.html.xpath('//ul[@id="release-list"]//a', first=True).text

    release_version[p] = version

print(json.dumps(release_version, indent=4))

并通过API的方式，直接把相关信息填写到Confluence上。

con = Confluence(url=URL, username=USERNAME, password=PASSWORD)

body = '<div class="table-wrap"><table class="relative-table wrapped confluenceTable">版本信息</table></div>'
con.create_page(space='BDP', title='testtesttest', parent_id=85295571,
                body=body)

最后，把脚本集成到Jenkins上，每次只要运行一下Job就可以快速完整版本号的整理工作。

FastAPI: JWT登录认证（20）

2021-10-06T13:30:11.000Z

至此，FastAPI的基本使用和整个流程都过完了。接下来看一下登录认证，是一个系统里最基本的功能，有些页面只能登录之后才能够访问。

有Session和Token两种方式实现，目前最流行的下面token方式：

用户登录后，返回一个token给前端，后台不存储该token
前端再带着这个token去访问需要登录的页面
后端根据token去判断用户，确定当前登录用户

Bearer的简单OAuth2，前面已聊过FastAPI: Security（14），当时还没有生成token，OAuth2不能生成token，我们一般用JWT来实现

JWT

JWT全称是Json Web Token，JWT认证目前是前后端分离中非常流行的一种认证方式，生成的token分为三个部分: HEADER.PAYLOAD.SIGNATURE, 这三个部分都是可逆算法base64加密后的字符串, 最后用.拼接

HEADER

通常是加密算法
PAYLOAD

存储的自定义信息和token的过期时间
SIGNATURE

这个签证信息由三部分组成：
- header (base64后的)
- payload (base64后的)
- secret （盐值(salt): 指的是加密时加入的自定义的字符串, 最好是随机或者杂乱的字符串, 这样更能够确定加密后字符串的唯一性, 可以使用settings中的SECRET_KEY）
这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。

python中有好几多库可以实现JWT认证，这里也用官网使用的python-jose，Python-jose需要一个额外的加密后端。这里我们使用的是推荐的后端:pyca/cryptography

1	pip install python-jose[cryptography]

生成token

from jose import jwt
from datetime import datetime, timedelta

# 加密密钥
SECRET_KEY = "testjwt"

# 设置过期时间 示例5分钟
expire = datetime.utcnow() + timedelta(minutes=5)

# exp 是固定写法必须得传  username和uid是自己存的值
to_encode = {"exp": expire, "username": "admin", "uid": "12345"}

# 生成token
token = jwt.encode(to_encode, SECRET_KEY, algorithm="HS256")

解密token

from jose.exceptions import ExpiredSignatureError, JWTError
try:
    payload = jwt.decode(token, SECRET_KEY, algorithms="HS256" )
    print(payload)
except ExpiredSignatureError as e:
    print("token过期")
except JWTError as e:
    print("token验证失败")

FastAPI实现JWT认证

加密解密的公共方法

def create_jwt_token(data: dict, expires_delta: Optional[timedelta] = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=config.ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    token = jwt.encode(claims=to_encode, key=config.SECRET_KEY, algorithm=config.ALGORITHM)
    return token


def decode_jwt_token(token: str):
    try:
        payload = jwt.decode(token=token, key=config.SECRET_KEY, algorithms=config.ALGORITHM)
        return payload
    except (jwt.JWTError, jwt.ExpiredSignatureError, AttributeError) as e:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
                            detail=f'access token failed: {e}',
                            # 根据OAuth2规范, 认证失败需要在响应头中添加如下键值对
                            headers={'WWW-Authenticate': "Bearer"}
                            )

登录生成Token

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/login")

@router.post('/api/login', tags=['users'])
def user_login(username: str = Form(...), password: str = Form(...), db: Session = Depends(get_db)):
    db_user = crud.get_user_by_mail(db, username)
    if not db_user:
        raise HTTPException(status_code=404, detail="User not found")
    if password != db_user.hash_password:
        raise HTTPException(status_code=400, detail='passwod incorrect')

    data = {'email': db_user.email, 'user_id': db_user.id}
    token = jwttoken.create_jwt_token(data)

    return {"token": token, "token_type": "bearer"}

@router.get('/current/user', tags=['users'])
def get_current_user(token: Optional[str] = Header(...), db: Session = Depends(get_db)):
    payload = jwttoken.decode_jwt_token(token)
    email: str = payload.get("email")

    if email is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
                            detail=f'access token failed',
                            # 根据OAuth2规范, 认证失败需要在响应头中添加如下键值对
                            headers={'WWW-Authenticate': "Bearer"}
                            )

    user = crud.get_user_by_mail(db, email=email)
    if user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return user

验证Token

FastAPI: Docker部署（19）

2021-10-06T09:10:27.000Z

用Docker去部署应用已是目前最流行和通用的方式。现在把之前的项目部署到Docker上去。

准备Dockerfile

项目根目录下创建Dockerfile

FROM python:3.7

WORKDIR /fastapi

COPY ./requirements.txt /fastapi/requirements.txt

RUN pip install --no-cache-dir --upgrade -r /fastapi/requirements.txt

COPY . /fastapi/

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

Build Docker Image

去到项目根目录下，执行下面命令

docker build -t myfastapi:user .

验证

1	PS E:\fastapi> docker image ls REPOSITORY TAG IMAGE ID CREATED SIZE myfastapi user 0790ae3493a3 14 seconds ago 972MB

Start Docker Container

执行下面命令，部署应用到Container

docker run -d --name fastapiservice -p 80:80 myfastapi:user

验证

1
2
3

PS E:\fastapi> docker container ls
CONTAINER ID   IMAGE            COMMAND                  CREATED              STATUS              PORTS                NAMES
7b550b5a7ebb   myfastapi:user   "uvicorn main:app --…"   About a minute ago   Up About a minute   0.0.0.0:80->80/tcp   fastapiservice

验证部署成功

FastAPI: 项目结构（18）

2021-10-05T07:16:39.000Z

如前言所述，开发一个项目，不可能所所有的文件都放到一个文件里，是需要有结构化的目录。

简单结构如下：

E:.
│  config.py
│  dependencies.py
│  main.py
│  requirements.txt
│
├─models
│  │  crud.py
│  │  database.py
│  │  models.py
│  │  schemas.py
│  │  __init__.py
│
├─routers
│  │  users.py
│  │  __init__.py
│
├─static
│      fastapi.jpg
│
├─templates
│  │  index.html
│
├─utils
│  │  __init__.py

models

对数据库和数据的定义操作
routers

路由控制，更好的按模块化划分系统功能实现
static

引用的静态资源文件，js,css
templates

前面页面的模板文件
dependencies

系统所需的依赖项
main

系统启动入口
config

配置参数，连接数据等
utils

公共的方法，E.g., JWT token的处理
requirements

系统所依赖的外部库

项目请参见：github-fastapi

FastAPI: APIRouter（17）

2021-10-05T06:59:41.000Z

从前面的例子看，所有的Views操作都放在一个文件里，代码不易维护。为了更好的管理路径和代码，可以通过APIRouter来为该模块创建路径操作，给我们提供了在多个文件中注册路由的功能。

使用Router

在项目下创建routers -> users.py

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import List
from models import crud,schemas
from dependencies import get_db

router = APIRouter()


# 新建用户
@router.post("/users/", response_model=schemas.User, tags=['users'])
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    return crud.create_user(db, user=user)


# 通过id查询用户
@router.get("/user/{user_id}", response_model=schemas.User, tags=['users'])
def read_user(user_id: int, db: Session = Depends(get_db)):
    db_user = crud.get_user(db, user_id=user_id)
    if not db_user:
        raise HTTPException(status_code=404, detail="User not found")
    return db_user


# 所有用户
@router.get('/users/', response_model=List[schemas.User], tags=['users'])
def read_users(start: int=0, limit: int=10, db: Session = Depends(get_db)):
    return crud.get_users(db, start, limit)

# Delete user
@router.delete('/user/{user_id}', response_model=schemas.User, tags=['users'])
def delete_user(user_id: int, db: Session = Depends(get_db)):
    db_user = crud.delete_user(db, user_id=user_id)
    if not db_user:
        raise HTTPException(status_code=400, detail='User not found')
    return db_user

# Update User
@router.put('/user/{user_id}', response_model=schemas.User, tags=['users'])
def update_user(user_id: int, update_user: schemas.UserUpdate, db: Session = Depends(get_db)):
    db_user = crud.update_user(db, user_id=user_id, update_user=update_user)
    if not db_user:
        raise HTTPException(status_code=400, detail='User not found')
    return db_user

注册Router

将我们的 APIRouter 注册到核心对象上去。main.py

# 导入 FastAPI
from fastapi import FastAPI
from routers import users
import uvicorn
import config

# 实例化 FastAPI
app = FastAPI()

app.include_router(users.router)

FastAPI: static file & template（16）

2021-10-04T12:32:18.000Z

合理的使用静态资源和页面模板，更好的来实现网站前后端分离。

静态资源通过aiofiles来实现。

简单理解，模板就是 web 后端向前端发送的 html 模型，还是jinia2来实现。

安装

1
2
3

pip install aiofiles

pip install jinja2

验证

在项目根目录下，创建static和templates文件夹。
在static下添加一个图片fastapi.jpg。

在templates下添加一个页面模板。

<!DOCTYPE html>
<html>
<head>
    <title>Welcome</title>
    <link href="{{ url_for('static', path='/fastapi.jpg') }}" rel="stylesheet">
</head>
<body>
    <h1>Welcome: {{ username }}</h1>
</body>
</html>

接口返回html页面。

from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates

app.mount("/static", StaticFiles(directory="static"), name="static")

templates = Jinja2Templates(directory="templates")

# Return html page
@app.get("/user/{user_id}", response_class=HTMLResponse)
def read_user(request: Request, user_id: int, db: Session = Depends(get_db)):
    db_user = crud.get_user(db, user_id=user_id)
    if not db_user:
        raise HTTPException(status_code=404, detail="User not found")
    return templates.TemplateResponse('index.html', {'request': request, 'username': db_user.email})

结果

FastAPI: Mysql数据库操作（15）

2021-10-04T09:24:50.000Z

FastAPI可以通过SQLAlchemy将其轻松的适应于任何的数据库。SQLAlchemy是一个ORM（object-relational mapping）的框架。在ORM中，你创建一个类就会通过SQLAlchemy将其自动转成一张表，在类中的每一个属性就会将其转成表中的字段。

需要安装

1	pip install sqlalchemy pip install pymysql

统一来管理数据库相关：

├─db
│      crud.py
│      database.py
│      models.py
│      schemas.py
│      __init__.py

database.py 数据库配置相关

在数据库相关的配置文件中，首先创建一个SQLAlchemy的”engine”，然后创建SessionLocal实例进行会话，最后创建模型类的基类。

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "mysql+pymysql://root:123456@127.0.0.1:3306/test"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL, encoding='utf8', echo=True
)

# SQLAlchemy中，CRUD是通过会话进行管理的，所以需要先创建会话，
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 创建基本映射类
Base = declarative_base()

models.py 数据库模型表

通过数据库配置文件中的基类来创建模型类。

from sqlalchemy import Boolean, Column, Integer, String
from database import Base


class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    email = Column(String(32), unique=True, index=True)
    hash_password = Column(String(32))
    is_active = Column(Boolean, default=True)

schemas.py 模型验证

定义请求参数模型验证与响应模型验证的Pydantic模型，其中响应模型中设置orm_mode=True参数，表示与ORM模型兼容，因为后续中返回的数据库查询是orm模型，通过设置这个参数可以将orm模型通过pydantic模型进行验证。

from pydantic import BaseModel


class UserBase(BaseModel):
    email: str


class UserCreate(UserBase):
    """
    请求模型验证：
    email:
    password:
    """
    password: str

class UserUpdate(UserBase):
    is_active: bool

class User(UserBase):
    """
    响应模型：
    id:
    email:
    is_active
    并且设置orm_mode与之兼容
    """
    id: int
    is_active: bool

    class Config:
        orm_mode = True

crud.py 数据库操作相关

通过传入数据库连接以及参数等进行数据库操作，包括创建用户、查询用户等，返回的是orm模型对象。

from sqlalchemy.orm import Session
import models, schemas


# Get user by id
def get_user(db: Session, user_id: int):
    return db.query(models.User).filter(models.User.id == user_id).first()

# Get all users
def get_users(db: Session, start: int=0, limit: int=10):
    return db.query(models.User).offset(start).limit(limit).all()

# creae user
def create_user(db: Session, user: schemas.UserCreate):
    fake_hashed_password = user.password + "notreallyhashed"
    user = models.User(email=user.email, hash_password=fake_hashed_password)
    db.add(user)
    db.commit()  # 提交保存到数据库中
    db.refresh(user)  # 刷新
    return user

# Delete user
def delete_user(db: Session, user_id: int):
    user = db.query(models.User).filter(models.User.id == user_id).first()
    if user:
        db.delete(user)
        db.commit()
        db.flush()
        return user


# Update user
def update_user(db: Session, user_id: int, update_user: schemas.UserUpdate):
    user = db.query(models.User).filter(models.User.id == user_id).first()
    if user:
        update_user = update_user.dict(exclude_unset=True)
        for k, v in update_user.items():
            setattr(user, k, v)
        db.commit()
        db.flush()
        db.refresh(user)
        return user

调用验证

Base.metadata.create_all(bind=engine) #数据库初始化，如果没有库或者表，会自动创建

# 实例化 FastAPI
app = FastAPI()

# Dependency
def get_db():
    """
    每一个请求处理完毕后会关闭当前连接，不同的请求使用不同的连接
    :return:
    """
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


# 新建用户
@app.post("/users/", response_model=schemas.User)
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    return crud.db_create_user(db=db, user=user)


# 通过id查询用户
@app.get("/user/{user_id}", response_model=schemas.User)
def read_user(user_id: int, db: Session = Depends(get_db)):
    db_user = crud.get_user(db, user_id=user_id)
    if not db_user:
        raise HTTPException(status_code=404, detail="User not found")
    return db_user

# 所有用户
@app.get('/users/', response_model=List[schemas.User])
def read_users(start: int=0, limit: int=10, db: Session = Depends(get_db)):
    return crud.get_users(db, start, limit)

# Delete user
@app.delete('/user/{user_id}', response_model=schemas.User)
def delete_user(user_id: int, db: Session = Depends(get_db)):
    db_user = crud.delete_user(db, user_id=user_id)
    if not db_user:
        raise HTTPException(status_code=400, detail='User not found')
    return db_user

# Update User
@app.put('/user/{user_id}', response_model=schemas.User)
def update_user(user_id: int, update_user: schemas.UserUpdate, db: Session = Depends(get_db)):
    db_user = crud.update_user(db, user_id=user_id, update_user=update_user)
    if not db_user:
        raise HTTPException(status_code=400, detail='User not found')
    return db_user

DB:

mysql> desc users;
+---------------+-------------+------+-----+---------+----------------+
| Field         | Type        | Null | Key | Default | Extra          |
+---------------+-------------+------+-----+---------+----------------+
| id            | int(11)     | NO   | PRI | NULL    | auto_increment |
| email         | varchar(32) | YES  | UNI | NULL    |                |
| hash_password | varchar(32) | YES  |     | NULL    |                |
| is_active     | tinyint(1)  | YES  |     | NULL    |                |
+---------------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

FastAPI: Security（14）

2021-10-03T01:58:29.000Z

安全，权限对于任何一个系统是不可避免的。

FastAPI提供了多种工具，可帮助你以标准的方式轻松、快速地处理安全性，而无需研究和学习所有的安全规范。

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.get('/users/')
def users(token: str = Depends(oauth2_scheme)):
    return {'token': token}

简单 Bear OAuth2实现完整流程

在FastAPI中, 提供了多种认证解决方案工具, 其中也包括了OAuth2, 可以使用OAuth2PasswordBearer类来实现OAuth2的功能, 使用的是OAuth2中的一种认证方案, 通过bearer token来携带token, 具体做法就是:

在请求头中添加参数Authorization, 其值为Bearer和token中间使用空格连接形成的字符串, 如Bearer your_token_string, 注意, Authorization和Bearer都是规范中固定的写法, 不可修改

fake_user = {
    'admin':{
        'username': 'admin',
        'hash_password': 'fakehashadmin',
        'enabled': True
    }
}

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")# 这个参数的作用是当输入完用户密码后, 点击Authorize按钮后, 会请求127.0.0.1:8000/token这个网址, 把用户密码通过Form表单的形式传递给这个请求, 即这个/token就是我们网站的后台登录接口.


def fake_hash_password(password: str):
    return "fakehash" + password

class User(BaseModel):
    username: str
    enbaled: Optional[bool] = None

class UserPwd(User):
    hash_password: str


@app.post('/login')
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = fake_user.get(form.username)
    if not user:
        raise HTTPException(status_code=400, detail='user incorrect')
    u = UserPwd(**user)
    hashpwd = fake_hash_password(form.password)
    if hashpwd != u.hash_password:
        raise HTTPException(status_code=400, detail='passwod incorrect')

    return {"access_token": u.username, "token_type": "bearer"}

FastAPI: Dependencies（13）

2021-10-03T00:35:43.000Z

FastAPI 提供了简单易用，但功能强大的依赖注入系统，可以让开发人员轻松地把组件集成至 FastAPI。

编程中的「依赖注入」是声明代码（本文中为路径操作函数 ）运行所需的，或要使用的「依赖」的一种方式。

基本示例

def result(start: int = 0, limit: int = 10):
    return {'start': start, 'limit': limit}

@app.get('/users/')
def users(res: dict = Depends(result)):
    return res

@app.get('/books/')
def books(res: dict = Depends(result)):
    return res

这里只能传给 Depends 一个参数。

接收到新的请求时，FastAPI 执行如下操作：

用正确的参数调用依赖项函数（「可依赖项」）
获取函数返回的结果
把函数返回的结果赋值给路径操作函数的参数

Class 依赖注入

也可以用Python Class来实现依赖注入。

class Result():
    def __init__(self, start: int = 0, limit: int = 10):
        self.start = start
        self.limit = limit

@app.get('/users/')
def users(res: Result = Depends(Result)):
    return res

引用时，也可以用下边方式：

res: Result = Depends()

子依赖注入

FastAPI 支持创建含任意深度的子依赖项。类似于函数调用：fun1 -> fun2 -> fun3

def result1(start: int = 0):
    return start

def result2(start: int = Depends(result1), limit: int = 0):
    if limit:
        return limit
    return start

@app.get('/users/')
def users(res: dict = Depends(result2)):
    return res

结果

1	http://127.0.0.1:8000/users/?start=2 2 http://127.0.0.1:8000/users/?limit=5 5

多次使用同一个依赖项

如果在同一个路径操作 多次声明了同一个依赖项，例如，多个依赖项共用一个子依赖项，FastAPI 在处理同一请求时，只调用一次该子依赖项。

FastAPI 不会为同一个请求多次调用同一个依赖项，而是把依赖项的返回值进行「缓存」，并把它传递给同一请求中所有需要使用该返回值的「依赖项」。

在高级使用场景中，如果不想使用「缓存」值，而是为需要在同一请求的每一步操作（多次）中都实际调用依赖项，可以把 Depends 的参数 use_cache 的值设置为 False

路径依赖

以在路径操作装饰器中添加一个由 dependencies 组成的 list来注入多个引用。

def result1(start: int):
    if start != 2:
        raise HTTPException(status_code=400, detail='start not == 2')

def result2(limit: int):
    if limit != 5:
        raise HTTPException(status_code=400, detail='limit not == 5')

@app.get('/users/', dependencies=[Depends(result1), Depends(result2)])
def users():
    return {'status': 'ok'}

全局依赖

有时，我们要为整个应用添加依赖项。

可以把依赖项添加至整个 FastAPI 应用。后续就可以为所有路径操作应用该依赖项。

def result1(start: int):
    if start != 2:
        raise HTTPException(status_code=400, detail='start not == 2')

def result2(limit: int):
    if limit != 5:
        raise HTTPException(status_code=400, detail='limit not == 5')

app = FastAPI(dependencies=[Depends(result1), Depends(result2)])

@app.get('/users/')
def users():
    return {'status': 'ok'}

@app.get('/books/')
def users():
    return {'status': 'ok'}

FastAPI: 响应模型（12）

2021-10-02T01:27:24.000Z

在前面的操作中也看到，请求响应返回的就是请求体的内容，比如，要是登记注册就是返回用户名和密码，这种行为是不行的。

可以使用 response_model 参数来声明用于响应的模型。

将输出数据转换为其声明的类型。
校验数据。
会将输出数据限制在该模型定义内。
在 OpenAPI 的路径操作中为响应添加一个 JSON Schema。
并在自动生成文档系统中使用。

class User(BaseModel):
    username: str
    password: str
    email: EmailStr
    adress: Optional[str] = 'beijing'

class UserRes(BaseModel):
    username: str
    email: EmailStr
    address: Optional[str] = 'beijing'

@app.post('/user/register/', response_model=UserRes)
def register(user: User):
    return user

上面的例子中，可以看到响应里会自动的返回请求体里默认的字段。如果请求体中不传，就不要返回带默认值的字段，可以用response_model_exclude_unset来实现

class User(BaseModel):
    username: str
    password: str
    email: EmailStr
    adress: Optional[str] = 'beijing'

class UserRes(BaseModel):
    username: str
    email: EmailStr
    address: Optional[str] = 'beijing'

@app.post('/user/register/', response_model=UserRes, response_model_exclude_unset=True)
def register(user: User):
    return user

FastAPI: 响应状态码（11）

2021-10-02T01:27:09.000Z

可以使用 status_code 参数来声明用于响应的 HTTP 状态码。

1
2
3

@app.post('/uploads/', status_code=201)
def root(files: List[UploadFile] = File(...)):
    return {'filename': [file.filename for file in files]}

默认返回的状态码是200，修改后返回201。

HTTP的状态码很多，也不容易记住所有状态码的意思，FastAPI提供了更方便的方式。

FastAPI: 请求Form&File（10）

2021-10-02T00:29:35.000Z

Form表单和File Upload是避免不了的操作。

要使用表单，需预先安装 python-multipart

1	pip install python-multipart

Form

1
2
3

@app.post('/login/')
def root(username : str = Form(...), password: str = Form(...)):
    return {'username': username, 'password': password}

File

文件上传也是以Form形式发送。

1
2
3

@app.post('/upload/')
def root(file: UploadFile = File(...)):
    return {'filename': file.filename}

也支持多个文件上传

1
2
3

@app.post('/uploads/')
def root(files: List[UploadFile] = File(...)):
    return {'filename': [file.filename for file in files]}

FastAPI: 请求Header&Cookie（9）

2021-10-01T23:26:40.000Z

请求自定义Header。

1
2
3

@app.get('/users/')
def root(user_agent: Optional[str] = Header(None)):
    return {'User-Agent': user_agent}

@app.get('/users/')
def root(user_agent: Optional[str] = Header(None),
         sid: Optional[str] = Cookie(None)):
    return {'User-Agent': user_agent}, {'sid': sid}

FastAPI: 请求体嵌套模型（8）

2021-10-01T06:53:17.000Z

可以将一个模型属性定义为有多子元素的类型。List来实现

class Book(BaseModel):
    name: str = Field(..., min_length=2, max_length=10)
    price: float
    description: Optional[str] = None
    tag: List[str] = None

app = FastAPI()

@app.post('/books/')
def root(book: Book = Body(..., embed=True),
         query: Optional[str] = None):
    return book, query

还可以在模型里嵌套模型，可以做到任意深度嵌套，来实现更复杂的结构。

class Author(BaseModel):
    name: str
    address: Optional[str] = None


class Book(BaseModel):
    name: str
    price: float
    description: Optional[str] = None
    author: Author

app = FastAPI()

@app.post('/authors/{id}')
def root(*,
         id: int = Path(..., gt=12),
         book: Book):
    return id, book

FastAPI: 请求体Query-Path-Body-Field（7）

2021-10-01T03:22:52.000Z

多参数混用Path和Query

class Book(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

class Author(BaseModel):
    name: str
    address: Optional[str] = None

app = FastAPI()

@app.post('/authors/{id}')
def root(*,
         id: int = Path(..., gt=12),
         author: Author,
         book: Book,
         query: Optional[str] = Query(None)):
    return id, author, book, query

Body实现请求体中单一值

在设定好的模型之外，想在发送请求时另外加一个字段进去，如果单独定义就会把它当成一个查询参数，可以利用Body来实现。

class Book(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

class Author(BaseModel):
    name: str
    address: Optional[str] = None

app = FastAPI()

@app.post('/authors/{id}')
def root(*,
         id: int = Path(..., gt=12),
         author: Author,
         book: Book,
         publisher: str = Body(...),
         query: Optional[str] = Query(None)):
    return id, author, book, publisher, query

嵌入请求体参数

如果想把请求体外边再加一个字段来标识，也可以通过Body来实现

class Book(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

app = FastAPI()

@app.post('/books/')
def root(book: Book = Body(..., embed=True),
         query: Optional[str] = None):
    return book, query

Field校验模型里字段

class Book(BaseModel):
    name: str = Field(..., min_length=2, max_length=10)
    price: float
    description: Optional[str] = None

app = FastAPI()

@app.post('/books/')
def root(book: Book = Body(..., embed=True),
         query: Optional[str] = None):
    return book, query

FastAPI: 请求体基础（6）

2021-10-01T03:22:10.000Z

这个不多说，就是客户端发送给 API 的数据。通过Pydantic来声明请求体。

class Book(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

app = FastAPI()

@app.post('/books/')
def root(book: Book):
    return book

FastAPI: 请求路径参数的校验（5）

2021-09-29T01:48:23.000Z

可以通过 Path 对路径参数做校验。

books = [{'name': 'python'}, {'name': 'fastapi'}, {'name': 'java'}, ]

@app.get('/users/{id}')
def root(id: int = Path(..., gt=12),
         start: int = 0,
         limit: Optional[int] = None):
    if limit:
        return {id: books[start : limit]}
    return {id: books[start: ]}

gt：大于（greater than）
ge：大于等于（greater than or equal）
lt：小于（less than）
le：小于等于（less than or equal）

1
2
3

http://127.0.0.1:8000/users/11

{"detail":[{"loc":["path","id"],"msg":"ensure this value is greater than 12","type":"value_error.number.not_gt","ctx":{"limit_value":12}}]}

参数排序

有默认值参数和必填参数值都存在时，有默认值参数必须放到必填参数后边。

传递 * 作为函数的第一个参数。

@app.get('/users/{id}')
def root(*, id: int = Path(..., gt=12),
         start: int = 0,
         limit: Optional[int] = None):
    if limit:
        return {id: books[start : limit]}
    return {id: books[start: ]}

Python 不会对该 * 做任何事情，它将之后的所有参数都作为关键字参数来调用。

FastAPI: 请求查询参数的校验（4）

2021-09-28T01:48:10.000Z

可以通过Query来实现对字符串查询参数的校验。

常规校验

books = [{'name': 'python'}, {'name': 'fastapi'}, {'name': 'java'}]

@app.get('/books/')
def root(book: str = Query('Java Script', min_length=2)):

    if book:
        books.append({'name': book})
    return books

参数的默认值是Java Script，最小长度是2。

http://127.0.0.1:8000/books/
[{"name":"python"},{"name":"fastapi"},{"name":"java"},{"name":"Java Script"}]

http://127.0.0.1:8000/books/?book=c
{"detail":[{"loc":["query","book"],"msg":"ensure this value has at least 2 characters","type":"value_error.any_str.min_length","ctx":{"limit_value":2}}]}

甚至可以直接用正则表达式来做检验，一般应该也用不到。

@app.get('/books/')
def root(book: Optional[str] = Query('Java Script', min_length=2, regex='^J')):

    if book:
        books.append({'name': book})
    return books

必填参数

可以将 ... 用作第一个参数值，在声明必填参数。

@app.get('/books/')
def root(book: str = Query(..., min_length=2, regex='^J')):

    if book:
        books.append({'name': book})
    return books

参数列表多个值

查询参数可以声明时接受多个值

books = ['python', 'fastapi']

@app.get('/books/')
def root(book: Optional[list] = Query(None)):

    if book:
        books.extend(book)
    return books

结果

http://127.0.0.1:8000/books/
["python","fastapi"]

http://127.0.0.1:8000/books/?book=java&book=c
["python","fastapi","java","c"]

还有下面的校验，用到再说

alia
title
description
deprecated