24024
af7c11d7f9
- 新增图像生成接口，支持试用、积分和自定义API Key模式 - 实现生成图片结果异步上传至MinIO存储，带重试机制 - 优化积分预扣除和异常退还逻辑，保障用户积分准确 - 添加获取生成历史记录接口，支持时间范围和分页 - 提供本地字典配置接口，支持模型、比例、提示模板和尺寸 - 实现图片批量上传接口，支持S3兼容对象存储 feat(admin): 增加管理员角色管理与权限分配接口 - 实现角色列表查询、角色创建、更新及删除功能 - 增加权限列表查询接口 - 实现用户角色分配接口，便于统一管理用户权限 - 增加系统字典增删查改接口，支持分类过滤和排序 - 权限控制全面覆盖管理接口，保证安全访问 feat(auth): 完善用户登录注册及权限相关接口与页面 - 实现手机号验证码发送及校验功能，保障注册安全 - 支持手机号注册、登录及退出接口，集成日志记录 - 增加修改密码功能，验证原密码后更新 - 提供动态导航菜单接口，基于权限展示不同菜单 - 实现管理界面路由及日志、角色、字典管理页面访问权限控制 - 添加系统日志查询接口，支持关键词和等级筛选 feat(app): 初始化Flask应用并配置蓝图与数据库 - 创建应用程序工厂，加载配置，初始化数据库和Redis客户端 - 注册认证、API及管理员蓝图，整合路由 - 根路由渲染主页模板 - 应用上下文中自动创建数据库表，保证运行环境准备完毕 feat(database): 提供数据库创建与迁移支持脚本 - 新增数据库创建脚本，支持自动检测是否已存在 - 添加数据库表初始化脚本，支持创建和删除所有表 - 实现RBAC权限初始化，包含基础权限和角色创建 - 新增字段手动修复脚本，添加用户API Key和积分字段 - 强制迁移脚本支持清理连接和修复表结构，初始化默认数据及角色分配 feat(config): 新增系统配置参数 - 配置数据库、Redis、Session和MinIO相关参数 - 添加AI接口地址及试用Key配置 - 集成阿里云短信服务配置及开发模式相关参数 feat(extensions): 初始化数据库、Redis和MinIO客户端 - 创建全局SQLAlchemy数据库实例和Redis客户端 - 配置基于boto3的MinIO兼容S3客户端 chore(logs): 添加示例系统日志文件 - 记录用户请求、验证码发送成功与失败的日志信息
355 lines
12 KiB
Python
355 lines
12 KiB
Python
"""Orchestrator for building wheels from InstallRequirements.
|
|
"""
|
|
|
|
import logging
|
|
import os.path
|
|
import re
|
|
import shutil
|
|
from typing import Iterable, List, Optional, Tuple
|
|
|
|
from pip._vendor.packaging.utils import canonicalize_name, canonicalize_version
|
|
from pip._vendor.packaging.version import InvalidVersion, Version
|
|
|
|
from pip._internal.cache import WheelCache
|
|
from pip._internal.exceptions import InvalidWheelFilename, UnsupportedWheel
|
|
from pip._internal.metadata import FilesystemWheel, get_wheel_distribution
|
|
from pip._internal.models.link import Link
|
|
from pip._internal.models.wheel import Wheel
|
|
from pip._internal.operations.build.wheel import build_wheel_pep517
|
|
from pip._internal.operations.build.wheel_editable import build_wheel_editable
|
|
from pip._internal.operations.build.wheel_legacy import build_wheel_legacy
|
|
from pip._internal.req.req_install import InstallRequirement
|
|
from pip._internal.utils.logging import indent_log
|
|
from pip._internal.utils.misc import ensure_dir, hash_file
|
|
from pip._internal.utils.setuptools_build import make_setuptools_clean_args
|
|
from pip._internal.utils.subprocess import call_subprocess
|
|
from pip._internal.utils.temp_dir import TempDirectory
|
|
from pip._internal.utils.urls import path_to_url
|
|
from pip._internal.vcs import vcs
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_egg_info_re = re.compile(r"([a-z0-9_.]+)-([a-z0-9_.!+-]+)", re.IGNORECASE)
|
|
|
|
BuildResult = Tuple[List[InstallRequirement], List[InstallRequirement]]
|
|
|
|
|
|
def _contains_egg_info(s: str) -> bool:
|
|
"""Determine whether the string looks like an egg_info.
|
|
|
|
:param s: The string to parse. E.g. foo-2.1
|
|
"""
|
|
return bool(_egg_info_re.search(s))
|
|
|
|
|
|
def _should_build(
|
|
req: InstallRequirement,
|
|
need_wheel: bool,
|
|
) -> bool:
|
|
"""Return whether an InstallRequirement should be built into a wheel."""
|
|
if req.constraint:
|
|
# never build requirements that are merely constraints
|
|
return False
|
|
if req.is_wheel:
|
|
if need_wheel:
|
|
logger.info(
|
|
"Skipping %s, due to already being wheel.",
|
|
req.name,
|
|
)
|
|
return False
|
|
|
|
if need_wheel:
|
|
# i.e. pip wheel, not pip install
|
|
return True
|
|
|
|
# From this point, this concerns the pip install command only
|
|
# (need_wheel=False).
|
|
|
|
if not req.source_dir:
|
|
return False
|
|
|
|
if req.editable:
|
|
# we only build PEP 660 editable requirements
|
|
return req.supports_pyproject_editable()
|
|
|
|
return True
|
|
|
|
|
|
def should_build_for_wheel_command(
|
|
req: InstallRequirement,
|
|
) -> bool:
|
|
return _should_build(req, need_wheel=True)
|
|
|
|
|
|
def should_build_for_install_command(
|
|
req: InstallRequirement,
|
|
) -> bool:
|
|
return _should_build(req, need_wheel=False)
|
|
|
|
|
|
def _should_cache(
|
|
req: InstallRequirement,
|
|
) -> Optional[bool]:
|
|
"""
|
|
Return whether a built InstallRequirement can be stored in the persistent
|
|
wheel cache, assuming the wheel cache is available, and _should_build()
|
|
has determined a wheel needs to be built.
|
|
"""
|
|
if req.editable or not req.source_dir:
|
|
# never cache editable requirements
|
|
return False
|
|
|
|
if req.link and req.link.is_vcs:
|
|
# VCS checkout. Do not cache
|
|
# unless it points to an immutable commit hash.
|
|
assert not req.editable
|
|
assert req.source_dir
|
|
vcs_backend = vcs.get_backend_for_scheme(req.link.scheme)
|
|
assert vcs_backend
|
|
if vcs_backend.is_immutable_rev_checkout(req.link.url, req.source_dir):
|
|
return True
|
|
return False
|
|
|
|
assert req.link
|
|
base, ext = req.link.splitext()
|
|
if _contains_egg_info(base):
|
|
return True
|
|
|
|
# Otherwise, do not cache.
|
|
return False
|
|
|
|
|
|
def _get_cache_dir(
|
|
req: InstallRequirement,
|
|
wheel_cache: WheelCache,
|
|
) -> str:
|
|
"""Return the persistent or temporary cache directory where the built
|
|
wheel need to be stored.
|
|
"""
|
|
cache_available = bool(wheel_cache.cache_dir)
|
|
assert req.link
|
|
if cache_available and _should_cache(req):
|
|
cache_dir = wheel_cache.get_path_for_link(req.link)
|
|
else:
|
|
cache_dir = wheel_cache.get_ephem_path_for_link(req.link)
|
|
return cache_dir
|
|
|
|
|
|
def _verify_one(req: InstallRequirement, wheel_path: str) -> None:
|
|
canonical_name = canonicalize_name(req.name or "")
|
|
w = Wheel(os.path.basename(wheel_path))
|
|
if canonicalize_name(w.name) != canonical_name:
|
|
raise InvalidWheelFilename(
|
|
f"Wheel has unexpected file name: expected {canonical_name!r}, "
|
|
f"got {w.name!r}",
|
|
)
|
|
dist = get_wheel_distribution(FilesystemWheel(wheel_path), canonical_name)
|
|
dist_verstr = str(dist.version)
|
|
if canonicalize_version(dist_verstr) != canonicalize_version(w.version):
|
|
raise InvalidWheelFilename(
|
|
f"Wheel has unexpected file name: expected {dist_verstr!r}, "
|
|
f"got {w.version!r}",
|
|
)
|
|
metadata_version_value = dist.metadata_version
|
|
if metadata_version_value is None:
|
|
raise UnsupportedWheel("Missing Metadata-Version")
|
|
try:
|
|
metadata_version = Version(metadata_version_value)
|
|
except InvalidVersion:
|
|
msg = f"Invalid Metadata-Version: {metadata_version_value}"
|
|
raise UnsupportedWheel(msg)
|
|
if metadata_version >= Version("1.2") and not isinstance(dist.version, Version):
|
|
raise UnsupportedWheel(
|
|
f"Metadata 1.2 mandates PEP 440 version, but {dist_verstr!r} is not"
|
|
)
|
|
|
|
|
|
def _build_one(
|
|
req: InstallRequirement,
|
|
output_dir: str,
|
|
verify: bool,
|
|
build_options: List[str],
|
|
global_options: List[str],
|
|
editable: bool,
|
|
) -> Optional[str]:
|
|
"""Build one wheel.
|
|
|
|
:return: The filename of the built wheel, or None if the build failed.
|
|
"""
|
|
artifact = "editable" if editable else "wheel"
|
|
try:
|
|
ensure_dir(output_dir)
|
|
except OSError as e:
|
|
logger.warning(
|
|
"Building %s for %s failed: %s",
|
|
artifact,
|
|
req.name,
|
|
e,
|
|
)
|
|
return None
|
|
|
|
# Install build deps into temporary directory (PEP 518)
|
|
with req.build_env:
|
|
wheel_path = _build_one_inside_env(
|
|
req, output_dir, build_options, global_options, editable
|
|
)
|
|
if wheel_path and verify:
|
|
try:
|
|
_verify_one(req, wheel_path)
|
|
except (InvalidWheelFilename, UnsupportedWheel) as e:
|
|
logger.warning("Built %s for %s is invalid: %s", artifact, req.name, e)
|
|
return None
|
|
return wheel_path
|
|
|
|
|
|
def _build_one_inside_env(
|
|
req: InstallRequirement,
|
|
output_dir: str,
|
|
build_options: List[str],
|
|
global_options: List[str],
|
|
editable: bool,
|
|
) -> Optional[str]:
|
|
with TempDirectory(kind="wheel") as temp_dir:
|
|
assert req.name
|
|
if req.use_pep517:
|
|
assert req.metadata_directory
|
|
assert req.pep517_backend
|
|
if global_options:
|
|
logger.warning(
|
|
"Ignoring --global-option when building %s using PEP 517", req.name
|
|
)
|
|
if build_options:
|
|
logger.warning(
|
|
"Ignoring --build-option when building %s using PEP 517", req.name
|
|
)
|
|
if editable:
|
|
wheel_path = build_wheel_editable(
|
|
name=req.name,
|
|
backend=req.pep517_backend,
|
|
metadata_directory=req.metadata_directory,
|
|
tempd=temp_dir.path,
|
|
)
|
|
else:
|
|
wheel_path = build_wheel_pep517(
|
|
name=req.name,
|
|
backend=req.pep517_backend,
|
|
metadata_directory=req.metadata_directory,
|
|
tempd=temp_dir.path,
|
|
)
|
|
else:
|
|
wheel_path = build_wheel_legacy(
|
|
name=req.name,
|
|
setup_py_path=req.setup_py_path,
|
|
source_dir=req.unpacked_source_directory,
|
|
global_options=global_options,
|
|
build_options=build_options,
|
|
tempd=temp_dir.path,
|
|
)
|
|
|
|
if wheel_path is not None:
|
|
wheel_name = os.path.basename(wheel_path)
|
|
dest_path = os.path.join(output_dir, wheel_name)
|
|
try:
|
|
wheel_hash, length = hash_file(wheel_path)
|
|
shutil.move(wheel_path, dest_path)
|
|
logger.info(
|
|
"Created wheel for %s: filename=%s size=%d sha256=%s",
|
|
req.name,
|
|
wheel_name,
|
|
length,
|
|
wheel_hash.hexdigest(),
|
|
)
|
|
logger.info("Stored in directory: %s", output_dir)
|
|
return dest_path
|
|
except Exception as e:
|
|
logger.warning(
|
|
"Building wheel for %s failed: %s",
|
|
req.name,
|
|
e,
|
|
)
|
|
# Ignore return, we can't do anything else useful.
|
|
if not req.use_pep517:
|
|
_clean_one_legacy(req, global_options)
|
|
return None
|
|
|
|
|
|
def _clean_one_legacy(req: InstallRequirement, global_options: List[str]) -> bool:
|
|
clean_args = make_setuptools_clean_args(
|
|
req.setup_py_path,
|
|
global_options=global_options,
|
|
)
|
|
|
|
logger.info("Running setup.py clean for %s", req.name)
|
|
try:
|
|
call_subprocess(
|
|
clean_args, command_desc="python setup.py clean", cwd=req.source_dir
|
|
)
|
|
return True
|
|
except Exception:
|
|
logger.error("Failed cleaning build dir for %s", req.name)
|
|
return False
|
|
|
|
|
|
def build(
|
|
requirements: Iterable[InstallRequirement],
|
|
wheel_cache: WheelCache,
|
|
verify: bool,
|
|
build_options: List[str],
|
|
global_options: List[str],
|
|
) -> BuildResult:
|
|
"""Build wheels.
|
|
|
|
:return: The list of InstallRequirement that succeeded to build and
|
|
the list of InstallRequirement that failed to build.
|
|
"""
|
|
if not requirements:
|
|
return [], []
|
|
|
|
# Build the wheels.
|
|
logger.info(
|
|
"Building wheels for collected packages: %s",
|
|
", ".join(req.name for req in requirements), # type: ignore
|
|
)
|
|
|
|
with indent_log():
|
|
build_successes, build_failures = [], []
|
|
for req in requirements:
|
|
assert req.name
|
|
cache_dir = _get_cache_dir(req, wheel_cache)
|
|
wheel_file = _build_one(
|
|
req,
|
|
cache_dir,
|
|
verify,
|
|
build_options,
|
|
global_options,
|
|
req.editable and req.permit_editable_wheels,
|
|
)
|
|
if wheel_file:
|
|
# Record the download origin in the cache
|
|
if req.download_info is not None:
|
|
# download_info is guaranteed to be set because when we build an
|
|
# InstallRequirement it has been through the preparer before, but
|
|
# let's be cautious.
|
|
wheel_cache.record_download_origin(cache_dir, req.download_info)
|
|
# Update the link for this.
|
|
req.link = Link(path_to_url(wheel_file))
|
|
req.local_file_path = req.link.file_path
|
|
assert req.link.is_wheel
|
|
build_successes.append(req)
|
|
else:
|
|
build_failures.append(req)
|
|
|
|
# notify success/failure
|
|
if build_successes:
|
|
logger.info(
|
|
"Successfully built %s",
|
|
" ".join([req.name for req in build_successes]), # type: ignore
|
|
)
|
|
if build_failures:
|
|
logger.info(
|
|
"Failed to build %s",
|
|
" ".join([req.name for req in build_failures]), # type: ignore
|
|
)
|
|
# Return a list of requirements that failed to build
|
|
return build_successes, build_failures
|