소스 정보
- 저장소
- microwind/ai-skills
- 최근 소스 활동
- 2026년 3월 26일 14:58
- 감지된 SKILL.md 언어
- 중국어
- 스타
- 68
- 포크
- 17
설치 방법
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
소스 파일 검토
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
메뉴
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
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=)