用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/microwind/ai-skills --skill flask命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| name | Flask轻量级应用 |
| description | 当开发Flask应用时，分析路由设计，优化中间件配置，解决性能问题。验证API架构，设计RESTful服务，和最佳实践。 |
| license | MIT |
Flask是Python最流行的轻量级Web框架。不当的Flask应用设计会导致性能问题、安全漏洞和维护困难。在开发Flask应用前需要仔细分析架构需求。
核心原则: 好的Flask应用应该简洁高效、安全可靠、易于扩展。坏的Flask应用会导致代码混乱、性能瓶颈和安全风险。
始终:
触发短语:
问题:
路由结构混乱，缺乏一致性
错误示例:
- 路由命名不规范
- 缺乏RESTful设计
- 参数验证缺失
- 错误处理不统一
解决方案:
1. 遵循RESTful设计原则
2. 统一路由命名规范
3. 实施参数验证装饰器
4. 建立统一错误处理机制
问题:
中间件配置过多或顺序不当
错误示例:
- 不必要的中间件加载
- 中间件执行顺序错误
- 同步中间件阻塞
- 中间件依赖混乱
解决方案:
1. 只加载必要的中间件
2. 正确配置中间件顺序
3. 使用异步中间件
4. 清理中间件依赖关系
问题:
应用响应慢，并发能力差
错误示例:
- 同步阻塞操作
- 内存泄漏
- 数据库连接未复用
- 缺乏缓存机制
解决方案:
1. 使用异步操作避免阻塞
2. 实施内存监控和清理
3. 配置数据库连接池
4. 添加适当的缓存策略
import os
import ast
import json
from typing import List, Dict, Any, Optional
from dataclasses import dataclass
from collections import defaultdict
@dataclass
class FlaskRoute:
"""Flask路由信息"""
method: str
path: str
function_name: str
file: str
line: int
issues: List[str]
@dataclass
class FlaskMiddleware:
"""Flask中间件信息"""
name: str
type: str
file: str
line: int
issues: List[str]
@dataclass
class FlaskIssue:
"""Flask问题"""
severity: str # critical, high, medium, low
type: str
file: str
message: str
suggestion: str
line: Optional[int] = None
class FlaskAppAnalyzer:
def ():
.app_path = app_path
.routes: [FlaskRoute] = []
.middlewares: [FlaskMiddleware] = []
.issues: [FlaskIssue] = []
() -> [, ]:
:
python_files = .find_python_files()
file_path python_files:
.analyze_python_file(file_path)
.analyze_requirements()
.analyze_config_files()
.generate_report()
Exception e:
{: }
() -> []:
python_files = []
root, dirs, files os.walk(.app_path):
dirs[:] = [d d dirs d.startswith() d [, , , ]]
file files:
file.endswith():
python_files.append(os.path.join(root, file))
python_files
() -> :
:
(file_path, , encoding=) f:
content = f.read()
tree = ast.parse(content)
flask_apps = .find_flask_apps(tree, file_path)
.analyze_routes(tree, file_path, flask_apps)
.analyze_middlewares(tree, file_path, flask_apps)
.analyze_code_quality(tree, file_path)
Exception e:
.issues.append(FlaskIssue(
severity=,
=,
file=file_path,
message=,
suggestion=
))
() -> []:
flask_apps = []
node ast.walk(tree):
(node, ast.Assign):
target node.targets:
(target, ast.Name):
((node.value, ast.Call)
(node.value.func, ast.Name)
node.value.func. == ):
flask_apps.append(target.)
((node.value, ast.Call)
(node.value.func, ast.Attribute)
node.value.func.attr == ):
flask_apps.append(target.)
flask_apps
() -> :
node ast.walk(tree):
(node, ast.Call):
((node.func, ast.Attribute)
node.func.attr [, , , , , ]):
route_info = .extract_route_info(node, file_path, flask_apps)
route_info:
.routes.append(route_info)
.validate_route(route_info)
() -> [FlaskRoute]:
:
method =
node.func.attr [, , , , ]:
method = node.func.attr.upper()
path =
node.args (node.args[], ast.Str):
path = node.args[].s
node.args (node.args[], ast.Constant):
path = node.args[].value
function_name =
line = node.lineno
parent = .find_parent_function(node)
parent (parent, ast.FunctionDef):
function_name = parent.name
function_name:
FlaskRoute(
method=method,
path=path,
function_name=function_name,
file=file_path,
line=line,
issues=[]
)
Exception:
() -> [ast.AST]:
() -> :
.is_restful_path(route.path):
route.issues.append()
.issues.append(FlaskIssue(
severity=,
=,
file=route.file,
message=,
suggestion=,
line=route.line
))
.has_parameters(route.path) .has_validation(route.function_name):
route.issues.append()
.issues.append(FlaskIssue(
severity=,
=,
file=route.file,
message=,
suggestion=,
line=route.line
))
() -> :
verbs = [, , , , , , , ]
path_parts = path.strip().split()
part path_parts:
part.lower() verbs:
() -> :
path path
() -> :
() -> :
node ast.walk(tree):
(node, ast.Call):
((node.func, ast.Attribute)
node.func.attr == ):
middleware_info = FlaskMiddleware(
name=,
=,
file=file_path,
line=node.lineno,
issues=[]
)
.middlewares.append(middleware_info)
((node.func, ast.Attribute)
node.func.attr == ):
middleware_info = FlaskMiddleware(
name=,
=,
file=file_path,
line=node.lineno,
issues=[]
)
.middlewares.append(middleware_info)
((node.func, ast.Attribute)
node.func.attr == ):
middleware_info = FlaskMiddleware(
name=,
=,
file=file_path,
line=node.lineno,
issues=[]
)
.middlewares.append(middleware_info)
() -> :
node ast.walk(tree):
(node, ast.FunctionDef):
complexity = .calculate_complexity(node)
complexity > :
.issues.append(FlaskIssue(
severity=,
=,
file=file_path,
message=,
suggestion=,
line=node.lineno
))
.check_exception_handling(tree, file_path)
() -> :
complexity =
child ast.walk(node):
(child, (ast.If, ast.For, ast.While, ast.Try)):
complexity +=
(child, ast.BoolOp):
complexity += (child.values) -
complexity
() -> :
has_try_except =
node ast.walk(tree):
(node, ast.Try):
has_try_except =
has_try_except:
.issues.append(FlaskIssue(
severity=,
=,
file=file_path,
message=,
suggestion=
))
() -> :
requirements_path = os.path.join(.app_path, )
os.path.exists(requirements_path):
.issues.append(FlaskIssue(
severity=,
=,
file=,
message=,
suggestion=
))
:
(requirements_path, , encoding=) f:
requirements = f.read().strip().split()
required_deps = [, ]
security_deps = [, ]
performance_deps = [, ]
dep required_deps:
(dep.lower() req.lower() req requirements):
.issues.append(FlaskIssue(
severity=,
=,
file=,
message=,
suggestion=
))
dep security_deps:
(dep.lower() req.lower() req requirements):
.issues.append(FlaskIssue(
severity=,
=,
file=,
message=,
suggestion=
))
dep performance_deps:
(dep.lower() req.lower() req requirements):
.issues.append(FlaskIssue(
severity=,
=,
file=,
message=,
suggestion=
))
Exception e:
.issues.append(FlaskIssue(
severity=,
=,
file=,
message=,
suggestion=
))
() -> :
config_files = [, , ]
config_file config_files:
config_path = os.path.join(.app_path, config_file)
os.path.exists(config_path):
.analyze_config_file(config_path)
(os.path.exists(os.path.join(.app_path, f)) f config_files):
.issues.append(FlaskIssue(
severity=,
=,
file=,
message=,
suggestion=
))
() -> :
:
(config_path, , encoding=) f:
content = f.read()
sensitive_keys = [, , , , ]
key sensitive_keys:
key content.lower():
.issues.append(FlaskIssue(
severity=,
=,
file=config_path,
message=,
suggestion=
))
Exception e:
.issues.append(FlaskIssue(
severity=,
=,
file=config_path,
message=,
suggestion=
))
() -> [, ]:
summary = {
: (.issues),
: ([i i .issues i.severity == ]),
: ([i i .issues i.severity == ]),
: ([i i .issues i.severity == ]),
: ([i i .issues i.severity == ]),
: (.routes),
: (.middlewares)
}
recommendations = .generate_recommendations()
{
: summary,
: [.route_to_dict(r) r .routes],
: [.middleware_to_dict(m) m .middlewares],
: [.issue_to_dict(i) i .issues],
: recommendations,
: .calculate_health_score(summary)
}
() -> [, ]:
{
: route.method,
: route.path,
: route.function_name,
: route.file,
: route.line,
: route.issues
}
() -> [, ]:
{
: middleware.name,
: middleware.,
: middleware.file,
: middleware.line,
: middleware.issues
}
() -> [, ]:
{
: issue.severity,
: issue.,
: issue.file,
: issue.message,
: issue.suggestion,
: issue.line
}
() -> [[, ]]:
recommendations = []
issue_types = defaultdict()
issue .issues:
issue_types[issue.] +=
issue_types[] > :
recommendations.append({
: ,
: ,
: ,
suggestion:
})
issue_types[] > :
recommendations.append({
: ,
: ,
: ,
suggestion:
})
issue_types[] > :
recommendations.append({
: ,
: ,
: ,
suggestion:
})
recommendations
() -> :
score =
score -= summary[] *
score -= summary[] *
score -= summary[] *
score -= summary[] *
(, score)
:
():
.app_path = app_path
() -> [, ]:
optimizations = []
dependency_optimization = .optimize_dependencies()
dependency_optimization:
optimizations.append(dependency_optimization)
config_optimization = .optimize_configuration()
config_optimization:
optimizations.append(config_optimization)
structure_optimization = .optimize_structure()
structure_optimization:
optimizations.append(structure_optimization)
{
: optimizations,
: {
: (optimizations),
: .estimate_improvements(optimizations)
}
}
() -> [[, ]]:
requirements_path = os.path.join(.app_path, )
os.path.exists(requirements_path):
{
: ,
: ,
:
}
:
(requirements_path, , encoding=) f:
requirements = f.read().strip().split()
performance_deps = [, , ]
missing_deps = []
dep performance_deps:
(dep.lower() req.lower() req requirements):
missing_deps.append(dep)
missing_deps:
{
: ,
: ,
:
}
Exception:
() -> [[, ]]:
config_files = [, , ]
(os.path.exists(os.path.join(.app_path, f)) f config_files):
{
: ,
: ,
:
}
() -> [[, ]]:
required_dirs = [, ]
missing_dirs = []
dir_name required_dirs:
os.path.exists(os.path.join(.app_path, dir_name)):
missing_dirs.append(dir_name)
missing_dirs:
{
: ,
: ,
:
}
() -> [, ]:
improvements = {
: ,
: ,
:
}
opt optimizations:
opt[] == :
improvements[] +=
opt[] == :
improvements[] +=
opt[] == :
improvements[] +=
improvements
():
analyzer = FlaskAppAnalyzer()
report = analyzer.analyze_application()
()
()
()
()
()
rec report[]:
()
optimizer = FlaskAppOptimizer()
optimization = optimizer.optimize_application()
()
opt optimization[]:
()
__name__ == :
main()
import time
import psutil
from functools import wraps
from typing import Dict, Any, List
from flask import Flask, request, g
from dataclasses import dataclass
@dataclass
class RequestMetrics:
"""请求指标"""
method: str
path: str
status_code: int
duration: float
timestamp: float
user_agent: str
ip: str
@dataclass
class PerformanceMetrics:
"""性能指标"""
cpu_percent: float
memory_percent: float
memory_mb: float
active_connections: int
requests_per_second: float
class FlaskPerformanceMonitor:
def __init__(self, app: Flask = None):
self.app = app
self.requests: List[RequestMetrics] = []
self.start_time = time.time()
if app:
self.init_app(app)
def init_app(self, app: Flask) -> :
.app = app
app.before_request(._before_request)
app.after_request(._after_request)
app.teardown_appcontext(._teardown_request)
() -> :
g.start_time = time.time()
() -> :
(g, ):
duration = time.time() - g.start_time
metrics = RequestMetrics(
method=request.method,
path=request.path,
status_code=response.status_code,
duration=duration,
timestamp=time.time(),
user_agent=request.headers.get(, ),
ip=request.remote_addr
)
.requests.append(metrics)
(.requests) > :
.requests.pop()
response
() -> :
() -> [, ]:
request_stats = ._calculate_request_stats()
system_stats = ._get_system_stats()
route_stats = ._calculate_route_stats()
{
: time.time(),
: time.time() - .start_time,
: request_stats,
: system_stats,
: route_stats
}
() -> [, ]:
.requests:
{
: ,
: ,
: ,
:
}
total_requests = (.requests)
uptime = time.time() - .start_time
requests_per_second = total_requests / uptime uptime >
response_times = [req.duration req .requests]
average_response_time = (response_times) / (response_times)
error_requests = [req req .requests req.status_code >= ]
error_rate = (error_requests) / total_requests * total_requests >
{
: total_requests,
: requests_per_second,
: average_response_time,
: error_rate,
: ._calculate_percentile(response_times, ),
: ._calculate_percentile(response_times, )
}
() -> [, ]:
{
: psutil.cpu_percent(),
: psutil.virtual_memory().percent,
: psutil.virtual_memory().used / / ,
: (psutil.net_connections()),
: (psutil.pids())
}
() -> [[, ]]:
route_stats = {}
req .requests:
route_key =
route_key route_stats:
route_stats[route_key] = {
: ,
: ,
: ,
:
}
stats = route_stats[route_key]
stats[] +=
stats[] += req.duration
stats[] = stats[] / stats[]
req.status_code >= :
stats[] +=
(
[
{
: route,
**stats
}
route, stats route_stats.items()
],
key= x: x[],
reverse=
)[:]
() -> :
values:
sorted_values = (values)
index = ((sorted_values) * percentile / )
sorted_values[(index, (sorted_values) - )]
():
():
():
start_time = time.time()
:
result = func(*args, **kwargs)
result
:
duration = time.time() - start_time
wrapper
decorator
():
app = Flask(__name__)
monitor = FlaskPerformanceMonitor(app)
():
monitor.get_metrics()
():
():
time.sleep()
{: []}
app
__name__ == :
app = create_app()
app.run(debug=)