Menü
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/microwind/ai-skills --skill flaskDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
Basierend auf der SOC-Berufsklassifikation
SKILL.md wird angezeigt
| 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=)