Fix: 使用更好的管理器检测策略 (#41)

- 更新项目到 Python 3.10+
- 升级 ruff 版本到 0.15.0+
- 使用 NB-CLI 1.7.0 的管理器检测策略
- Dockerfile 模板中使用 uv 代替 pipx

Author: NCBM

nb_cli_plugin_docker/cli.py

@@ -1,6 +1,6 @@
 from typing import cast
-from pathlib import Path
 
+import anyio
 import click
 from nb_cli import _
 from nb_cli.config import ConfigManager
@@ -69,6 +69,7 @@ async def generate(ctx: click.Context, force: bool):
     """Generate Dockerfile and docker-compose.yml."""
     python_path = await get_default_python()
     cwd = get_project_root()
+    async_cwd = anyio.Path(cwd)
 
     python_version = await get_python_version(python_path=python_path)
     python_version = f"{python_version['major']}.{python_version['minor']}"
@@ -84,18 +85,22 @@ async def generate(ctx: click.Context, force: bool):
             is_asgi=is_asgi,
             build_backend=build_backend,
         )
-        await safe_write_file(cwd / "Dockerfile", dockerfile, force=force)
+        await safe_write_file(async_cwd / "Dockerfile", dockerfile, force=force)
 
         compose_file = await generate_compose_file(is_asgi=is_asgi)
-        await safe_write_file(cwd / "docker-compose.yml", compose_file, force=force)
+        await safe_write_file(
+            async_cwd / "docker-compose.yml", compose_file, force=force
+        )
 
         await safe_copy_dir(
-            Path(__file__).parent / "static" / "common", cwd, force=force
+            anyio.Path(__file__).parent / "static" / "common", async_cwd, force=force
         )
 
         if is_asgi:
             await safe_copy_dir(
-                Path(__file__).parent / "static" / "reverse", cwd, force=force
+                anyio.Path(__file__).parent / "static" / "reverse",
+                async_cwd,
+                force=force,
             )
     except CancelledError:
         ctx.exit()
@@ -118,8 +123,8 @@ async def up(ctx: click.Context, force: bool, compose_args: list[str]):
 
     if (
         force
-        or not Path(cwd, "Dockerfile").exists()
-        or not Path(cwd, "docker-compose.yml").exists()
+        or not await anyio.Path(cwd, "Dockerfile").exists()
+        or not await anyio.Path(cwd, "docker-compose.yml").exists()
     ):
         await run_sync(ctx.invoke)(generate)
 

nb_cli_plugin_docker/handler.py

@@ -2,7 +2,7 @@
 import asyncio
 from pathlib import Path
 from dataclasses import dataclass
-from typing import IO, TYPE_CHECKING, Any, Union, Literal, Optional, cast
+from typing import IO, TYPE_CHECKING, Any, Literal, cast
 
 from nb_cli import cache
 from jinja2 import Environment, FileSystemLoader
@@ -14,6 +14,7 @@
     get_default_python,
     get_nonebot_config,
     ensure_process_terminated,
+    probe_environment_manager,
 )
 
 from .exception import GetDriverTypeError, ComposeNotAvailable
@@ -67,11 +68,11 @@ async def get_compose_command() -> Compose:
 
 @ensure_process_terminated
 async def call_compose(
-    compose_args: Optional[list[str]] = None,
-    cwd: Optional[Path] = None,
-    stdin: Optional[Union[IO[Any], int]] = None,
-    stdout: Optional[Union[IO[Any], int]] = None,
-    stderr: Optional[Union[IO[Any], int]] = None,
+    compose_args: list[str] | None = None,
+    cwd: Path | None = None,
+    stdin: IO[Any] | int | None = None,
+    stdout: IO[Any] | int | None = None,
+    stderr: IO[Any] | int | None = None,
 ) -> asyncio.subprocess.Process:
     if cwd is None:
         cwd = get_project_root()
@@ -88,11 +89,11 @@ async def call_compose(
 
 
 async def compose_up(
-    compose_args: Optional[list[str]] = None,
-    cwd: Optional[Path] = None,
-    stdin: Optional[Union[IO[Any], int]] = None,
-    stdout: Optional[Union[IO[Any], int]] = None,
-    stderr: Optional[Union[IO[Any], int]] = None,
+    compose_args: list[str] | None = None,
+    cwd: Path | None = None,
+    stdin: IO[Any] | int | None = None,
+    stdout: IO[Any] | int | None = None,
+    stderr: IO[Any] | int | None = None,
 ) -> asyncio.subprocess.Process:
     return await call_compose(
         ["up", "-d", "--build", *(compose_args or [])],
@@ -104,11 +105,11 @@ async def compose_up(
 
 
 async def compose_down(
-    compose_args: Optional[list[str]] = None,
-    cwd: Optional[Path] = None,
-    stdin: Optional[Union[IO[Any], int]] = None,
-    stdout: Optional[Union[IO[Any], int]] = None,
-    stderr: Optional[Union[IO[Any], int]] = None,
+    compose_args: list[str] | None = None,
+    cwd: Path | None = None,
+    stdin: IO[Any] | int | None = None,
+    stdout: IO[Any] | int | None = None,
+    stderr: IO[Any] | int | None = None,
 ) -> asyncio.subprocess.Process:
     return await call_compose(
         ["down", *(compose_args or [])],
@@ -120,11 +121,11 @@ async def compose_down(
 
 
 async def compose_build(
-    compose_args: Optional[list[str]] = None,
-    cwd: Optional[Path] = None,
-    stdin: Optional[Union[IO[Any], int]] = None,
-    stdout: Optional[Union[IO[Any], int]] = None,
-    stderr: Optional[Union[IO[Any], int]] = None,
+    compose_args: list[str] | None = None,
+    cwd: Path | None = None,
+    stdin: IO[Any] | int | None = None,
+    stdout: IO[Any] | int | None = None,
+    stderr: IO[Any] | int | None = None,
 ) -> asyncio.subprocess.Process:
     return await call_compose(
         ["build", *(compose_args or [])],
@@ -136,11 +137,11 @@ async def compose_build(
 
 
 async def compose_logs(
-    compose_args: Optional[list[str]] = None,
-    cwd: Optional[Path] = None,
-    stdin: Optional[Union[IO[Any], int]] = None,
-    stdout: Optional[Union[IO[Any], int]] = None,
-    stderr: Optional[Union[IO[Any], int]] = None,
+    compose_args: list[str] | None = None,
+    cwd: Path | None = None,
+    stdin: IO[Any] | int | None = None,
+    stdout: IO[Any] | int | None = None,
+    stderr: IO[Any] | int | None = None,
 ) -> asyncio.subprocess.Process:
     return await call_compose(
         ["logs", *(compose_args or [])],
@@ -152,11 +153,11 @@ async def compose_logs(
 
 
 async def compose_ps(
-    compose_args: Optional[list[str]] = None,
-    cwd: Optional[Path] = None,
-    stdin: Optional[Union[IO[Any], int]] = None,
-    stdout: Optional[Union[IO[Any], int]] = None,
-    stderr: Optional[Union[IO[Any], int]] = None,
+    compose_args: list[str] | None = None,
+    cwd: Path | None = None,
+    stdin: IO[Any] | int | None = None,
+    stdout: IO[Any] | int | None = None,
+    stderr: IO[Any] | int | None = None,
 ) -> asyncio.subprocess.Process:
     return await call_compose(
         ["ps", *(compose_args or [])],
@@ -169,10 +170,10 @@ async def compose_ps(
 
 @requires_nonebot
 async def get_driver_type(
-    adapters: Optional[list[SimpleInfo]] = None,
-    builtin_plugins: Optional[list[str]] = None,
-    python_path: Optional[str] = None,
-    cwd: Optional[Path] = None,
+    adapters: list[SimpleInfo] | None = None,
+    builtin_plugins: list[str] | None = None,
+    python_path: str | None = None,
+    cwd: Path | None = None,
 ) -> bool:
     bot_config = get_nonebot_config()
     if adapters is None:
@@ -206,23 +207,21 @@ async def get_driver_type(
 
 
 async def get_build_backend(
-    config_manager: Optional[ConfigManager] = None,
-) -> Optional[Literal["poetry", "pdm", "pip"]]:
+    config_manager: ConfigManager | None = None,
+) -> Literal["poetry", "pdm", "uv", "pip"] | None:
     if config_manager is None:
         config_manager = GLOBAL_CONFIG
 
-    if data := config_manager._get_data():
-        backend = data.get("build-system", {}).get("build-backend", "")
-        if "poetry" in backend:
-            return "poetry"
-        elif "pdm" in backend:
-            return "pdm"
+    inferred, _ = await probe_environment_manager(cwd=config_manager.working_dir)
+
+    if inferred != "pip":
+        return cast(Literal["uv", "pdm", "poetry"], inferred)
     if (config_manager.project_root / "requirements.txt").exists():
         return "pip"
 
 
 async def generate_dockerfile(
-    python_version: str, is_asgi: bool, build_backend: Optional[str]
+    python_version: str, is_asgi: bool, build_backend: str | None
 ):
     t = templates.get_template(
         "docker/reverse.Dockerfile.jinja"

nb_cli_plugin_docker/template/docker/_helpers.Dockerfile.jinja

@@ -3,23 +3,26 @@ FROM python:{{ python_version }} as requirements_stage
 
 WORKDIR /wheel
 
-RUN python -m pip install --user pipx
+RUN python -m pip install --user uv
 
-COPY ./pyproject.toml{% if build_backend == "poetry" %} \
-  ./poetry.lock{% elif build_backend == "pdm" %} \
-  ./pdm.lock{% elif build_backend == "pip" %} \
+COPY ./pyproject.toml{% if build_backend == "uv" %} \
+  ./uv.lock{% elif build_backend == "pdm" %} \
+  ./pdm.lock{% elif build_backend == "poetry" %}\
+  ./poetry.lock{% elif build_backend == "pip" %} \
   ./requirements.txt{% endif %} \
   /wheel/
 
 {% if build_backend == "poetry" %}
-RUN python -m pipx run --no-cache poetry export -f requirements.txt --output requirements.txt --without-hashes
+RUN python -m uv tool run --no-cache poetry export -f requirements.txt --output requirements.txt --without-hashes
 {% elif build_backend == "pdm" %}
-RUN python -m pipx run --no-cache pdm export -f requirements --output requirements.txt --without-hashes
+RUN python -m uv tool run --no-cache pdm export -f requirements --output requirements.txt --without-hashes
+{% elif build_backend == "uv" %}
+RUN python -m uv export -f requirements --output requirements.txt --without-hashes
 {% endif %}
 
 {% if build_backend %}
 RUN python -m pip wheel --wheel-dir=/wheel --no-cache-dir --requirement ./requirements.txt
 {% endif %}
 
-RUN python -m pipx run --no-cache nb-cli generate -f /tmp/bot.py
+RUN python -m uv tool run --no-cache --from nb-cli nb generate -f /tmp/bot.py
 {% endmacro %}

nb_cli_plugin_docker/utils.py

@@ -1,20 +1,18 @@
-from pathlib import Path
-from typing import Union, Optional
-
+from anyio import Path
 from noneprompt import ConfirmPrompt
 
 
 async def safe_write_file(
-    file_path: Path, content: Union[str, bytes], force: bool = False
-) -> Optional[int]:
+    file_path: Path, content: str | bytes, force: bool = False
+) -> int | None:
     directory = file_path.parent
-    if not directory.exists():
-        directory.mkdir(exist_ok=True, parents=True)
-    elif not directory.is_dir():
+    if not await directory.exists():
+        await directory.mkdir(exist_ok=True, parents=True)
+    elif not await directory.is_dir():
         raise RuntimeError(f"File {directory} already exists and is not a directory")
 
     if (
-        file_path.exists()
+        await file_path.exists()
         and not force
         and not await ConfirmPrompt(
             f"File {file_path} already exists, overwrite?",
@@ -24,27 +22,27 @@ async def safe_write_file(
         return
 
     return (
-        file_path.write_text(content, encoding="utf-8")
+        await file_path.write_text(content, encoding="utf-8")
         if isinstance(content, str)
-        else file_path.write_bytes(content)
+        else await file_path.write_bytes(content)
     )
 
 
 async def safe_copy_dir(source: Path, destination: Path, force: bool = False):
-    if not source.exists():
+    if not await source.exists():
         raise RuntimeError(f"Directory {source} does not exist")
-    if not source.is_dir():
+    if not await source.is_dir():
         raise RuntimeError(f"Path {source} is not a directory")
 
-    if not destination.exists():
-        destination.mkdir(exist_ok=True, parents=True)
-    elif not destination.is_dir():
+    if not await destination.exists():
+        await destination.mkdir(exist_ok=True, parents=True)
+    elif not await destination.is_dir():
         raise RuntimeError(f"File {destination} already exists and is not a directory")
 
-    for file in source.iterdir():
-        if file.is_dir():
+    async for file in source.iterdir():
+        if await file.is_dir():
             await safe_copy_dir(file, destination / file.name, force=force)
         else:
             await safe_write_file(
-                destination / file.name, file.read_bytes(), force=force
+                destination / file.name, await file.read_bytes(), force=force
             )