笔记 on kutake小站

在有共同字段下的pydantic类转换不正确问题

Sat, 10 Feb 2024 16:15:40 +0800

在使用 Pydantic 进行数据验证和设置时，你可能会遇到一个问题：当多个类有共同字段时，Pydantic 可能无法正确地区分这些类。让我通过一个简单的例子来解释这个问题。

基于Route来解决playwright的静态HTML资源加载问题

Sat, 10 Feb 2024 16:14:14 +0800

前因

由于python中没有方便快捷生成美观图片的方案，所以我使用了jinja2模板生成html后交给playwright生成网页图片，这其中，图片资源可以使用base64格式解决，而字体加载就难了。

使用Github Workflows构建Tauri应用

Thu, 28 Dec 2023 21:04:15 +0800

下面这个例子是，当release分支有commit发生时，自动获取当前应用的版本信息，并使用缓存，分别构建前端和rust，并将构建好的包上传至指定tag的release上。在 platform处定义平台，这里我只选定了Win

Tauri 调用终端api

Wed, 29 Nov 2023 22:25:50 +0800

当你想从Tauri调用终端并运行类似 ls的命令的话，需要使用 @tauri-apps/api/shell的api，步骤如下

编辑 tauri.conf.json下的 tauri.allowlist.shell

{
 "tauri": {
 "allowlist": {
 "shell": {
 "all": true, // enable all shell APIs
 "execute": true, // enable process spawn APIs
 "sidecar": true, // enable spawning sidecars
 "open": true // enable opening files/URLs using the default program
 }
 }
 }
}

其他api暂时不讨论，只说 execute，假设我们需要使用git命令（案例来自官网）

编辑 scope定义好需要用到的命令，要是没有定义则无法调用

{
 "scope": [
 {
 "name": "run-git-commit",
 "cmd": "git",
 "args": ["commit", "-m", { "validator": "\\S+" }]
 }
 ]
}

开始调用该命令

import { Command } from '@tauri-apps/api/shell'
const c = new Command('run-git-commit', ['commit', '-m', 'the commit message'])
const std = await c.execute();
std.stderr
std.stdout
std.code
std.signal

你可以将 args设置为 true来使js端可以传入任意参数

Tauri 文件访问api

Wed, 29 Nov 2023 22:07:56 +0800

tauri支持从$APPCONFIG, $APPDATA, $APPLOCALDATA, $APPCACHE, $APPLOG, $AUDIO, $CACHE, $CONFIG, $DATA, $LOCALDATA, $DESKTOP, $DOCUMENT, $DOWNLOAD, $EXE, $FONT, $HOME, $PICTURE, $PUBLIC, $RUNTIME, $TEMPLATE, $VIDEO, $RESOURCE, $APP, $LOG, $TEMP 访问并读或文件夹和文件，具体措施如下

编辑 tauri.conf.json内的tauri.allowlist.fs

{
 "tauri": {
 "allowlist": {
 "fs": {
 "all": true, // enable all FS APIs
 "readFile": true,
 "writeFile": true,
 "readDir": true,
 "copyFile": true,
 "createDir": true,
 "removeDir": true,
 "removeFile": true,
 "renameFile": true,
 "exists": true
 }
 }
 }
}

可以直接 all: true 来开放所有tauri文件api，也可以单独开放某个api

编辑 scope开放具体访问权限
```
{
 "tauri": {
 "allowlist": {
 "fs": {
 "scope": ["$APPDATA/img/*"]
 }
 }
 }
}
```
注意，这里开放了 $APPDATA下的 database访问权限，这样可以阻止程序访问任何路径，除了 database

从js中访问

import { readBinaryFile, BaseDirectory } from '@tauri-apps/api/fs'; // 可以是任何api
// Read the image file in the `$APPDATA/avatar.png` path
const contents = await readBinaryFile('img/avatar.png', { dir: BaseDirectory.AppData });
// 注意！一定要加上BaseDirectory.AppData

开放了哪个目录权限，就用 dir: BaseDirectory来指定访问路径，至少用绝对路径访问的方法我还没有找到，当然，这种相对路径访问的方式更加安全

从创建项目到测试打包上传Pypi

Mon, 30 Oct 2023 20:16:30 +0800

前言

这是一次从创建项目到测试打包上传Pypi的过程，记录一下。

创建项目

这里我是用的是pdm这个包管理工具，创建项目的命令是pdm init，跟着引导一步步走，之后会生成一个pyproject.toml文件，里面有项目的一些基本信息，比如作者、版本号等。下面是一个示例：

更优雅的包可用性检测

Sun, 06 Aug 2023 03:32:54 +0800

一般

try:
 import numpy
except ImportError:
 print("numpy is not installed")

更推荐

from importlib.util import find_spec

if find_spec("numpy") is not None:
 print("numpy is installed")
else:
 print("numpy is not installed")

Rich 使用PY在终端上展示富文本界面

Fri, 28 Jul 2023 02:15:54 +0800

安装

pip install rich

# PDM
pdm add rich

文档 & 源码

基础

from rich import print

print("Hello World")

Rich功能非常丰富，从日志处理到富文本显示甚至动态的终端界面。

要使用Rich用做界面的话，一般是这样的：

from rich.console import Console
from rich.layout import Layout
from rich.panel import

console = Console()
panel = Panel(name="panel_name")
layout = Layout(panel,name="layout_name")

界面Layout和面板Panel是经常要用到的东西，Layout作为界面布局，Panel内展示元素并风格化，比如经常使用的表格Table；要实现动态变化而不是print需要用到Live。

一个PY多数据源的统一入口思路

Fri, 21 Apr 2023 22:41:27 +0800

需求

以我的bot来说：

Bot:
├─config
├─core
├─modules
│ ├─required
│ │ ├─BotManager
│ │ ├─BotStatus
│ │ ├─ExceptionCatch
│ │ ├─...
│ └─self
│ ├─Modules1
│ ├─Modules2
│ ├─...
├─resources
├─service
└─utils

模块统一放在modules下，required是bot运行必须的模块，self是可卸载安装的模块。

sqlalchemy异步与同步方式获取自增id

Thu, 05 Jan 2023 00:19:10 +0800

同步

# sync_session
# example(id, name)
e = example(name="name1")
db.add(e)
db.flush()
print(e.id) # id = 1

异步

# async_session
# example(id, name)
e = example(name="name1")
db.add(e)
await db.flush()
await db.commit()
await db.refresh(e)
print(e.id) # id = 1

[myabtis-plus]XML中返回的id顺序问题

Thu, 22 Dec 2022 02:25:25 +0800

问题

<insert id="insertListIfNotExists" useGeneratedKeys="true" keyProperty="id">
 INSERT IGNORE INTO
 `tag` (name, create_time)
 VALUES
 <foreach collection="list" item="item" separator=",">
 (#{item.name}, #{item.createTime})
 </foreach>
 </insert>

useGeneratedKeys与INSERT IGNORE配合后，若插入顺序是

id:1 name: name1
id: null name: name2
id: null name: name3

返回的id会变成

[myabtis-plus]xml中的字段注入不生效

Thu, 22 Dec 2022 02:23:17 +0800

未声明则不插入

create_time是自动注入字段

xml是最终执行的sql命令，未声明加入则不会插入

<insert id="insertListIfNotExists" useGeneratedKeys="true" keyProperty="id">
 INSERT IGNORE INTO
 `tag` (name)
 VALUES
 <foreach collection="list" item="item" separator=",">
 (#{item.name})
 </foreach>
 </insert>

修改：

<insert id="insertListIfNotExists" useGeneratedKeys="true" keyProperty="id">
 INSERT IGNORE INTO
 `tag` (name, create_time)
 VALUES
 <foreach collection="list" item="item" separator=",">
 (#{item.name}, #{item.createTime})
 </foreach>
 </insert>

bot的一些反思

Sun, 25 Sep 2022 15:50:04 +0800

模块化

我现在是这样的

Bot:
└─config
└─db
└─modules
└─utils

config内包含所有模块用到的配置项
db内是实体类和业务语句的集合
utils内是一些公共工具

现在问题是，config与db非常难维护，一打开就是几百行语句，找起来都麻烦，数据库和配置项有一点不对整个bot就无法启动

PDM-更现代的python包管理器

Tue, 31 May 2022 15:57:23 +0800

PDM介绍

一个现代的 Python 包管理器，支持 PEP 582

跟pipenv与poetry有着相同功能
抛弃传统包管理器所需的虚拟环境 - PEP 582
比poetry更快的依赖解析
类似pnpm的中心化安装缓存
插件系统
PEP 621 元数据格式
兼容 PEP 517 的构建后端，用于构建发布包(源码格式与 wheel 格式)

Python中便捷的上下文管理器contextmanager

Sat, 14 May 2022 20:36:57 +0800

基本的上下文管理器

需要定义：

class ContextM:
 def __enter__():
 dosomethings()

 def __exit__():
 dosometings()

class AsyncContextM:
 async def __aenter__():
 await dosometings()

 async def __aexit__():
 await dosometings()

调用时使用with ContextM()或async with AsyncContextM

ContextManager

Python内置的一个很方便的生成上下文管理器的装饰器

在fastapi中使用loguru记录日志

Sat, 12 Mar 2022 17:54:22 +0800

日志重写

import logging
import os
import sys
from pprint import pformat
from loguru import logger
from config import settings


class InterceptHandler(logging.Handler):
 def emit(self, record):
 # Get corresponding Loguru level if it exists
 try:
 level = logger.level(record.levelname).name
 except ValueError:
 level = record.levelno

 # Find caller from where originated the logged message
 frame, depth = logging.currentframe(), 2
 while frame.f_code.co_filename == logging.__file__:
 frame = frame.f_back
 depth += 1

 logger.opt(depth=depth, exception=record.exc_info).log(
 level, record.getMessage()
 )


def format_record(record: dict) -> str:
 format_string = settings.config.LOG_FORMAT

 if record["extra"].get("payload") is not None:
 record["extra"]["payload"] = pformat(
 record["extra"]["payload"], indent=4, compact=True, width=88
 )
 format_string += "\n<level>{extra[payload]}</level>"

 format_string += "{exception}\n"
 return format_string


# it requires app init or won't be work
def logger_init():
 log_path_all = os.path.join(settings.config.log_path, settings.config.LOG_FILE)
 log_path_error = os.path.join(settings.config.log_error_path, settings.config.LOG_FILE)
 logging.getLogger().handlers = [InterceptHandler()]
 logger.configure(
 handlers=[{"sink": sys.stdout, "level": logging.DEBUG, "format": format_record}])
 # logger.add(config.LOG_DIR, encoding='utf-8', rotation="9:46")
 logger.add(log_path_all,
 rotation="00:00",
 retention="2 week",
 enqueue=True,
 diagnose=True,
 level="DEBUG",
 format=format_record
 )
 logger.add(log_path_error,
 rotation="00:00",
 retention="3 week",
 enqueue=True,
 backtrace=True,
 diagnose=True,
 level="ERROR",
 format=format_record
 )
 logger.debug('日志系统已加载\n\n\n')
 logging.getLogger("uvicorn.access").handlers = [InterceptHandler()]

在app中调用

app = FastAPI(
 title=config.settings.title,
 debug=config.settings.config.DEBUG
)
# app create frist, then init logger
logger_init()


origins = [
 "http://127.0.0.1",
 f"http://127.0.0.1:{config.settings.config.port}",
 "http://localhost",
 f"http://localhost:{config.settings.config.port}",
 # "*"
]

app.include_router(scraper.router)
app.include_router(works.router)
app.include_router(users.router)
app.add_middleware(
 CORSMiddleware,
 allow_origins=origins,
 allow_credentials=True,
 allow_methods=["*"],
 allow_headers=["*"],
)

if __name__ == '__main__':

 uvicorn.run(
 app='main:app',
 host='0.0.0.0',
 port=config.settings.config.port,
 reload=True, # should be False at production
 access_log=True,
 ws_ping_interval=300,
 ws_ping_timeout=300
 )

FastApi使用jwt-token进行验证

Sat, 12 Mar 2022 17:48:58 +0800

以Depends的方式定义jwt

from jose import JWTError, jwt
from passlib.context import CryptContext
from fastapi.security import OAuth2PasswordBearer
from fastapi import Depends, HTTPException, status
from db import Curd
from typing import Optional
from datetime import datetime
from config import settings
from utils import logger
from .db import get_db
from datetime import timedelta


pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_schema = OAuth2PasswordBearer(tokenUrl="/users/login")


def hash_password(plain_password: str) -> str:
 return pwd_context.hash(plain_password)


def verity_password(plain_password: str, hashed_password: str) -> bool:
 return pwd_context.verify(plain_password, hashed_password)


async def jwt_authenticate_user(username: str, password: str):
 db = get_db()
 user = await Curd.get_user_by_name(await db.__anext__(), username)
 if not user:
 return False
 if not verity_password(password, user.password):
 return False
 return user


def created_access_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=settings.config.ACCESS_TOKEN_EXPIRE_MINUTES)
 to_encode.update({"exp": expire})
 encoded_jwt = jwt.encode(claims=to_encode, key=settings.default.SECRET_KEY, algorithm="HS256")
 return encoded_jwt


async def jwt_verity(token: str = Depends(oauth2_schema)):
 credentials_exception = HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Could not validate credentials",
 headers={"WWW-Authenticate": "Bearer"},
 )
 try:
 playload = jwt.decode(token=token, key=settings.default.SECRET_KEY, algorithms=["HS256"])
 except JWTError as e:
 logger.error("验证出现错误:\n", e)
 raise credentials_exception
 else:
 return playload


async def jwt_get_current_user(playload: dict = Depends(jwt_verity)):
 db = get_db()
 user_id = int(playload.get("sub"))
 user = await Curd.get_user_by_id(await db.__anext__(), user_id=user_id)
 return user


async def jwt_verity_admin(playload: dict = Depends(jwt_verity)):
 db = get_db()
 user_id = int(playload.get("sub"))
 is_admin = playload.get("is_admin")
 if is_admin:
 user = await Curd.get_user_by_id(await db.__anext__(), user_id=user_id)
 if user.is_admin:
 return
 raise HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Could not validate credentials",
 headers={"WWW-Authenticate": "Bearer"},
 )

需要分发token的url

router = APIRouter(
 prefix="/users",
 tags=["user"],
)

# it defind at dependencies.jwt
# oauth2_schema = OAuth2PasswordBearer(tokenUrl="/users/token")


@router.post("/register", response_model=UserToken)
async def user_register(user: OAuth2PasswordRequestForm = Depends(), db: AsyncSession = Depends(get_db)):
 if await Curd.is_user_name_exists(db, user.username):
 raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
 detail="username already exists")
 hashed_password = hash_password(user.password)
 new_user = UserCreate(id=worker.get_id(), name=user.username, password=hashed_password)
 await Curd.register_user(db, new_user)


@router.post("/login", response_model=UserToken)
async def user_login(user: OAuth2PasswordRequestForm = Depends()):
 user = await jwt_authenticate_user(username=user.username, password=user.password)
 if not user:
 raise HTTPException(
 status.HTTP_401_UNAUTHORIZED,
 detail="Incorrect username or password",
 headers={"WWW-Authenticate": "Bearer"},
 )
 access_token = created_access_token(data={"sub": str(user.id)})
 user_token = UserToken(username=user.name,
 access_token=access_token,
 token_type="bearer")
 return user_token

需要token进行访问限制的url

router = APIRouter(
 prefix="/works",
 tags=["works"],
)


@router.get("/get", response_model=Works)
async def test(
 order: int,
 nsfw: bool,
 page: int,
 sort: int,
 user: User = Depends(jwt_get_current_user),
 db: AsyncSession = Depends(get_db),
 ):
 works = await Curd.get_works(db, user.id, order, nsfw, page, sort)
 return works

Sqlalchemy-关于PyhtonORM的各种事

Sat, 12 Mar 2022 17:27:57 +0800

ORM

ORM：对象关系映射（Object Relational Mapping，简称ORM，或O/RM，或O/R mapping)，用于实现面向对象编程语言里不同类型系统的数据之间的转换

数据结构复习

Mon, 27 Dec 2021 00:41:50 +0800

1.什么是算法？

算法是计算机科学中的基本概念，是对特定问题的求解步骤

2.什么是算法的复杂度？

分为时间复杂度和空间复杂度，前者一般是指程序运行从开始到结束所需的时间，后者一般是指对应的程序从运行开始到结束所需的储存空间

考试相关

Fri, 17 Dec 2021 23:24:56 +0800

Linux

基本的排错

检查端口是否打开
检查服务/容器是否启动
检查防火墙是否关闭
ftp中检查配置文件中的 ip 是否替换为了自己的ip
docker中注意容器的命名冲突

Centos的Apache部署web

Fri, 17 Dec 2021 22:28:33 +0800

前言

Apache程序是目前拥有很高市场占有率的Web服务程序之一，这里演示如何安装，并访问一个简单的index.html

开整

首先安装apache的软件包：

FTP的配置与遇到的问题

Wed, 15 Dec 2021 22:59:06 +0800

安装

# 安装
yum install vsftpd -y
yum install ftp -y
# 启用
systemctl restart vsftpd
systemctl enable vsftpd
# 处理配置文件
mv /etc/vsftpd/vsftpd.conf /etc/vsftpd/vsftpd.conf.bak
grep -v "#" /etc/vsftpd/vsftpd.conf.bak > /etc/vsftpd/vsftpd.conf
# 关闭SELinux
setenforce 0

修改配置文件：

vim /etc/vsftpd/vsftpd.conf

将以下内容复制进去（注意！将18行 pasv_address 等号后面的ip改为你自己云服务器的ip地址！！）

Docker-2021/12/10

Mon, 13 Dec 2021 20:02:55 +0800

Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。

菜鸟教程--docker的优点

Note: 数据库原理与应用P113 sql表创建

Mon, 06 Dec 2021 11:28:11 +0800

CREATE TABLE Student(
Sno Char(3) NOT NULL PRIMARY KEY,
Sname CHAR(3) NOT NULL,
Ssex CHAR(2) NOT NULL,
Sbirthday datetime,
Class CHAR(5)
)
CREATE TABLE Teacher(
Tno CHAR(3) PRIMARY KEY,
Tname CHAR(4) NOT NULL,
Tsex CHAR(2) NOT NULL,
Tbirthday datetime,
Prof CHAR(6),
Depart VARCHAR(10) NOT NULL
)
CREATE TABLE Course(
Cno CHAR(5) NOT NULL PRIMARY KEY,
Cname VARCHAR(10) NOT NULL,
Tno CHAR(3) NOT NULL,
FOREIGN KEY (Tno) REFERENCES Teacher(Tno)
)
CREATE TABLE Score(
Sno CHAR(3) NOT NULL,
Cno CHAR(5) NOT NULL,
Degree Decimal(4,1)
FOREIGN KEY (Sno) REFERENCES Student(Sno),
FOREIGN KEY (Cno) REFERENCES Course(Cno)
)

哈夫曼编码的实现(python)

Sun, 21 Nov 2021 21:31:23 +0800

思路

~~C++实在是弄不懂~~

代码

from typing import List, Optional
class Node:
"""
结点
"""
def __init__(self):
self.name: Optional[str] = None
self.weight: Optional[int] = None
self.left_child: Optional[Node] = None
self.right_child: Optional[Node] = None
self.parent: Optional[Node] = None
class NodeCode:
"""
结点的编码
"""
def __init__(self, name: str, code: str):
self.name = name
self.code = code
def __str__(self):
return f"{self.name}:{self.code}"
class HaffumanTreeCode:
"""
哈夫曼树的编码
"""
def __init__(self):
self.code_list: List[NodeCode] = []
def append(self, code: NodeCode):
self.code_list.append(code)
def code(self, massage: str):
"""
针对编码表编码
:param massage: 需要编码的信息
:return:
"""
code = ""
for i in massage:
for n in self.code_list:
if n.name == i:
code += n.code
break
# raise ValueError(f"'{i}'不存在")
return code
def decode(self, code: str):
"""
针对编码表解码
:param code:需要解码的哈夫曼码
:return:
"""
out = ""
i = 0
while code:
code_need_match = code[0:i+1]
for n in self.code_list:
if n.code == code_need_match:
out += n.name
code = code[i+1:]
i = 0
break
i += 1
return out
def __str__(self):
"""
打印
:return:
"""
out = ""
for i in self.code_list:
out += i.__str__() + "\n"
return out.strip()
class HaffumanTree:
"""
哈夫曼树
"""
def __init__(self):
self.root = Node()
self.nodes: List[Node] = []
self.nodes_raw: List[Node] = []
self.codes: HaffumanTreeCode = HaffumanTreeCode()
def inser(self, newnode: Node):
for i in range(len(self.nodes)):
if self.nodes[i].weight < newnode.weight:
self.nodes.insert(i, newnode)
return
self.nodes.append(newnode)
def build_tree(self, name_list: List[str], weight_list: List[int]):
"""
创建哈夫曼树
:param name_list: 字符列表
:param weight_list: 权重列表
:return:
"""
# 队每个字符生成结点
while len(name_list) > 0:
max_weight = max(weight_list)
max_index = weight_list.index(max_weight)
max_name = name_list[max_index]
newnode = Node()
newnode.name = max_name
newnode.weight = max_weight
self.nodes.append(newnode)
name_list.remove(max_name)
weight_list.remove(max_weight)
# 保存源结点
self.nodes_raw = self.nodes[:]
# 创建新结点并生成树
while len(self.nodes) > 2:
left = self.nodes.pop()
right = self.nodes.pop()
newnode = Node()
newnode.weight = left.weight + right.weight
newnode.left_child = left
newnode.right_child = right
left.parent = newnode
right.parent = newnode
# 根据权重插入
self.inser(newnode)
left = self.nodes.pop()
right = self.nodes.pop()
self.root.weight = left.weight + right.weight
self.root.left_child = left
self.root.right_child = right
left.parent = self.root
right.parent = self.root
def make_code(self):
"""
生成编码表
:return:
"""
while len(self.nodes_raw):
node = self.nodes_raw.pop()
name = node.name
code = ""
while node.parent != self.root:
parent = node.parent
if parent.left_child == node:
code = "0" + code
elif parent.right_child == node:
code = "1" + code
node = parent
if self.root.left_child == node:
code = "0" + code
elif self.root.right_child == node:
code = "1" + code
self.codes.append(NodeCode(name, code))
def decode(self, code: str):
return self.codes.decode(code)
def code(self, massage: str):
return self.codes.code(massage)
if __name__ == '__main__':
h = HaffumanTree()
name_list = ["a", "b", "c", "d", "e"]
wight_list = [5, 11, 6, 21, 19]
h.build_tree(name_list, wight_list)
h.make_code()
print(f"编码表：\n{h.codes}")
print(f'bcacce编码为：{h.code("bcacce")}')
print(f'01001000001001解码为： {h.decode("0100100000100110")}')

PyMySQL基础使用

Fri, 13 Aug 2021 13:56:12 +0800

安装

pip install PyMySQL

连接

db = pymysql.connect(host="192.168.1.1", port=3306, user="root", password="password", database="database_name")
cursor = db.cursor()

查/增

sql_insert = """
INSERT INTO 表名(id, name, path)
VALUES (%s, %s, %s)
"""
# 无论数据库数据类型为int或date，全部使用py的字符串形式插入，所以使用%s
cursor.execute(sql_insert, (user_id, name, path)) # 这种可以有效避免因敏感字符而导致出现语法错误
db.commit() # 进行提交，否则无效
# 当数据源为http相关时，注意转义
import html
from pymysql.converters import escape_string
safe_data = escape_string(html.unescape(unsafe_data)) # unescape转义html字符，escape转义为可直接插入数据库的安全字符串
# 多数据一次插入
cursor.executemany(sql, info) # info可为list，循环按顺序进行插入
db.commit()

以及

因为图库已经快20g了，为了管理方便，顺便就上了mysql做数据管理，但有个问题，pymysql非异步，可能会造成bot的io堵塞，现在的数据量查询速度还算快，但要是时间久了就不一定；

FastApi应用-bot中挂载web服务

Tue, 15 Jun 2021 19:34:04 +0800

轻量web服务

介绍

FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用 Python 3.6+ 并基于标准的 Python 类型提示。

FastAPI 框架，高性能，易于学习，高效编码，生产可用

Mediawiki - 更专业的wiki网站程序

Tue, 01 Jun 2021 20:35:25 +0800

介绍

Mediawiki是非常著名的开源wiki程序，比起之前的Dokuwiki功能要更完善，也更专业，使用PHP+SQL开发，适合用于构建百科、知识库、在线文档、个人笔记之类的应用。它的优点如下

美观的界面和可视化编辑器
拥有丰富的官方插件支持
官方文档非常完善，对中文支持也很友好

部署

我依旧是使用docker部署的，手动部署环境本次不介绍~~（不会）~~

Nginx反向代理和SSL部署

Sun, 30 May 2021 18:32:53 +0800

需求

我有几个小网站需要穿透出去，为了方便使用和安全，选择了直接使用Nginx实现反向代理和ssl的部署，另外还有一些简单的Nginx防护

反代实现
加密访问（仅本人访问）
SSL部署
Nginx防护恶意请求

反代实现

server
{
listen 80;
server_name www.your_url.com;
location / {
proxy_pass http://local456:port/;
}
}

这样就在80端口实现了对server_name 的反代操作，server_name填写外部请求的url，proxy_pass填写内部你需要反代出去的url

all() 一个便利的多条件判断方法

Tue, 04 May 2021 13:43:48 +0800

一般的多条件判断

if 判断1 and 判断2 and 判断3:
run()

当语句非常长的时候，就显得难懂且不美观

all()方法多条件判断

if all([条件1, 条件2, 条件3]):
run()

all()传入一个可迭代对象，当所有条件为True时，返回True

pip 换源与临时换源

Fri, 19 Mar 2021 18:52:42 +0800

永久换源

pip config set global.index-url https://

临时换源

pip install --index-url https:// module
pip install module -i https://

常用源

清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/
阿里云 http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
豆瓣(douban) http://pypi.douban.com/simple/
中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/

其中中国科技大学还挺好