fast-dev-cli 0.18.4__tar.gz → 0.18.6__tar.gz

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fast-dev-cli
-Version: 0.18.4
+Version: 0.18.6
 Summary: Python project development tool.
 Author-Email: Waket Zheng <waketzheng@gmail.com>>
 Classifier: Development Status :: 4 - Beta

fast_dev_cli-0.18.6/fast_dev_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.6"

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/fast_dev_cli/cli.py

@@ -4,6 +4,7 @@ import contextlib
 import functools
 import importlib.metadata as importlib_metadata
 import os
+import platform
 import re
 import shlex
 import shutil
@@ -102,7 +103,14 @@ def is_emoji(char: str) -> bool:
     return not "\u4e00" <= char <= "\u9fff"  # Chinese character
 
 
+@functools.cache
+def is_windows() -> bool:
+    return platform.system() == "Windows"
+
+
 def yellow_warn(msg: str) -> None:
+    if is_windows() and (encoding := sys.stdout.encoding) != "utf-8":
+        msg = msg.encode(encoding, errors="ignore").decode(encoding)
     secho(msg, fg="yellow")
 
 
@@ -124,44 +132,96 @@ def is_venv() -> bool:
     )
 
 
-def _run_shell(cmd: list[str] | str, **kw: Any) -> subprocess.CompletedProcess[str]:
-    if isinstance(cmd, str):
-        kw.setdefault("shell", True)
-    return subprocess.run(cmd, **kw)  # nosec:B603
+class Shell:
+    def __init__(self, cmd: list[str] | str, **kw: Any) -> None:
+        self._cmd = cmd
+        self._kw = kw
+
+    @staticmethod
+    def run_by_subprocess(
+        cmd: list[str] | str, **kw: Any
+    ) -> subprocess.CompletedProcess[str]:
+        if isinstance(cmd, str):
+            kw.setdefault("shell", True)
+        return subprocess.run(cmd, **kw)  # nosec:B603
+
+    @property
+    def command(self) -> list[str] | str:
+        command: list[str] | str = self._cmd
+        if (
+            isinstance(command, str)
+            and "shell" not in self._kw
+            and not (set(self._cmd) & {"|", ">", "&"})
+        ):
+            command = shlex.split(command)
+        return command
+
+    def _run(self) -> subprocess.CompletedProcess[str]:
+        return self.run_by_subprocess(self.command, **self._kw)
+
+    def run(self, verbose: bool = False, dry: bool = False) -> int:
+        if verbose:
+            echo(f"--> {self._cmd}")
+        if dry:
+            return 0
+        return self._run().returncode
+
+    def check_call(self) -> bool:
+        self._kw.update(stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return self.run() == 0
+
+    def capture_output(self, raises: bool = False) -> str:
+        self._kw.update(capture_output=True, encoding="utf-8")
+        r = self._run()
+        if raises and r.returncode != 0:
+            raise ShellCommandError(r.stderr)
+        return (r.stdout or r.stderr or "").strip()
+
+    def finish(
+        self, env: dict[str, str] | None = None, _exit: bool = False, dry=False
+    ) -> subprocess.CompletedProcess[str]:
+        self.run(verbose=True, dry=True)
+        if _ensure_bool(dry):
+            return subprocess.CompletedProcess("", 0)
+        if env is not None:
+            self._kw["env"] = {**os.environ, **env}
+        r = self._run()
+        if rc := r.returncode:
+            if _exit:
+                sys.exit(rc)
+            raise Exit(rc)
+        return r
 
 
 def run_and_echo(
     cmd: str, *, dry: bool = False, verbose: bool = True, **kw: Any
 ) -> int:
     """Run shell command with subprocess and print it"""
-    if verbose:
-        echo(f"--> {cmd}")
-    if dry:
-        return 0
-    command: list[str] | str = cmd
-    if "shell" not in kw and not (set(cmd) & {"|", ">", "&"}):
-        command = shlex.split(cmd)
-    return _run_shell(command, **kw).returncode
+    return Shell(cmd, **kw).run(verbose=verbose, dry=dry)
 
 
 def check_call(cmd: str) -> bool:
-    r = _run_shell(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    return r.returncode == 0
+    return Shell(cmd).check_call()
 
 
 def capture_cmd_output(
     command: list[str] | str, *, raises: bool = False, **kw: Any
 ) -> str:
-    if isinstance(command, str) and not kw.get("shell"):
-        command = shlex.split(command)
-    r = _run_shell(command, capture_output=True, encoding="utf-8", **kw)
-    if raises and r.returncode != 0:
-        raise ShellCommandError(r.stderr)
-    return r.stdout.strip() or r.stderr
+    return Shell(command, **kw).capture_output(raises=raises)
+
+
+def exit_if_run_failed(
+    cmd: str,
+    env: dict[str, str] | None = None,
+    _exit: bool = False,
+    dry: bool = False,
+    **kw: Any,
+) -> subprocess.CompletedProcess[str]:
+    return Shell(cmd, **kw).finish(env=env, _exit=_exit, dry=dry)
 
 
 def _parse_version(line: str, pattern: re.Pattern[str]) -> str:
-    return pattern.sub("", line).split("#")[0].strip(" '\"")
+    return pattern.sub("", line).split("#")[0].strip().strip(" '\"")
 
 
 def read_version_from_file(
@@ -276,26 +336,6 @@ def _ensure_str(value: str | OptionInfo | None) -> str:
     return value
 
 
-def exit_if_run_failed(
-    cmd: str,
-    env: dict[str, str] | None = None,
-    _exit: bool = False,
-    dry: bool = False,
-    **kw: Any,
-) -> subprocess.CompletedProcess[str]:
-    run_and_echo(cmd, dry=True)
-    if _ensure_bool(dry):
-        return subprocess.CompletedProcess("", 0)
-    if env is not None:
-        env = {**os.environ, **env}
-    r = _run_shell(cmd, env=env, **kw)
-    if rc := r.returncode:
-        if _exit:
-            sys.exit(rc)
-        raise Exit(rc)
-    return r
-
-
 class DryRun:
     def __init__(self, _exit: bool = False, dry: bool = False) -> None:
         self.dry = _ensure_bool(dry)
@@ -561,6 +601,19 @@ class Project:
     def is_poetry_v2(text: str) -> bool:
         return 'build-backend = "poetry' in text
 
+    @staticmethod
+    def get_poetry_version(command: str = "poetry") -> str:
+        pattern = r"(\d+\.\d+\.\d+)"
+        text = capture_cmd_output(f"{command} --version")
+        for expr in (
+            rf"Poetry \(version {pattern}\)",
+            rf"Poetry.*version.*{pattern}.*\)",
+            rf"{pattern}",
+        ):
+            if m := re.search(expr, text):
+                return m.group(1)
+        return ""
+
     @staticmethod
     def work_dir(
         name: str, parent: Path, depth: int, be_file: bool = False
@@ -657,7 +710,7 @@ class Project:
     @classmethod
     def get_sync_command(cls, prod: bool = True, doc: dict | None = None) -> str:
         if cls.is_pdm_project():
-            return "pdm sync" + " --prod" * prod
+            return "pdm install --frozen" + " --prod" * prod
         elif cls.manage_by_poetry(cache=True):
             cmd = "poetry install"
             if prod:
@@ -854,7 +907,7 @@ class UpgradeDependencies(Project, DryRun):
             deps = "uv sync --inexact --frozen --all-groups --all-extras"
             return f"{up} && {deps}"
         elif self._tool == "pdm":
-            return "pdm update --verbose && pdm sync -G :all --frozen"
+            return "pdm update --verbose && pdm install -G :all --frozen"
         return self.gen_cmd() + " && poetry lock && poetry update"
 
 
@@ -952,7 +1005,11 @@ class LintCode(DryRun):
 
     @staticmethod
     def check_lint_tool_installed() -> bool:
-        return check_call("ruff --version")
+        try:
+            return check_call("ruff --version")
+        except FileNotFoundError:
+            # Windows may raise FileNotFoundError when ruff not installed
+            return False
 
     @staticmethod
     def missing_mypy_exec() -> bool:
@@ -1019,7 +1076,7 @@ class LintCode(DryRun):
         if not should_run_by_tool:
             if is_venv() and Path(sys.argv[0]).parent != Path.home().joinpath(
                 ".local/bin"
-            ):
+            ):  # Virtual environment activated and fast-dev-cli is installed in it
                 if not ruff_exists:
                     should_run_by_tool = True
                     command = "pipx install ruff"
@@ -1038,17 +1095,26 @@ class LintCode(DryRun):
                             "You may need to run the following command"
                             f" to install lint tools:\n\n  {command}\n"
                         )
+            elif tool == ToolOption.default:
+                root = Project.get_work_dir(allow_cwd=True)
+                if py := shutil.which("python"):
+                    try:
+                        Path(py).relative_to(root)
+                    except ValueError:
+                        # Virtual environment not activated
+                        should_run_by_tool = True
             else:
                 should_run_by_tool = True
         if should_run_by_tool and tool:
             if tool == ToolOption.default:
                 tool = Project.get_manage_tool() or ""
             if tool:
-                prefix = (
-                    bin_dir
-                    if tool == "uv" and Path(bin_dir := ".venv/bin/").exists()
-                    else (tool + " run ")
-                )
+                prefix = tool + " run "
+                if tool == "uv":
+                    if is_windows():
+                        prefix += "--no-sync "
+                    elif Path(bin_dir := ".venv/bin/").exists():
+                        prefix = bin_dir
         if cls.prefer_dmypy(paths, tools, use_dmypy=use_dmypy):
             tools[-1] = "dmypy run"
         cmd += lint_them.format(prefix, paths, *tools)
@@ -1070,7 +1136,12 @@ class LintCode(DryRun):
             ps = args.split() if isinstance(args, str) else [str(i) for i in args]
             if len(ps) == 1:
                 paths = ps[0]
-                if paths != "." and not (p := Path(paths)).suffix and not p.exists():
+                if (
+                    paths != "."
+                    # `Path("a.").suffix` got "." in py3.14 and got "" with py<3.14
+                    and (p := Path(paths)).suffix in ("", ".")
+                    and not p.exists()
+                ):
                     # e.g.:
                     # stem -> stem.py
                     # me. -> me.py
@@ -1252,7 +1323,9 @@ def test(dry: bool, ignore_script: bool = False) -> None:
     if not _ensure_bool(ignore_script) and (
         test_script := _should_run_test_script(script_dir)
     ):
-        cmd = f"{os.path.relpath(test_script, root)}"
+        cmd = test_script.relative_to(root).as_posix()
+        if test_script.suffix == ".py":
+            cmd = "python " + cmd
         if cwd != root:
             cmd = f"cd {root} && " + cmd
     else:
@@ -1343,8 +1416,11 @@ def run_by_subprocess(cmd: str, dry: bool = DryOption) -> None:
     try:
         rc = run_and_echo(cmd, verbose=True, dry=_ensure_bool(dry))
     except FileNotFoundError as e:
-        if e.filename == cmd.split()[0]:
-            echo(f"Command not found: {e.filename}")
+        command = cmd.split()[0]
+        if e.filename == command or (
+            e.filename is None and "系统找不到指定的文件" in str(e)
+        ):
+            echo(f"Command not found: {command}")
             raise Exit(1) from None
         raise e
     else:
@@ -1380,7 +1456,7 @@ class MakeDeps(DryRun):
 
     def gen(self) -> str:
         if self._tool == "pdm":
-            return "pdm sync " + ("--prod" if self._prod else "-G :all")
+            return "pdm install --frozen " + ("--prod" if self._prod else "-G :all")
         elif self._tool == "uv":
             uv_sync = "uv sync" + " --inexact" * self._inexact
             if self._active:

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/pyproject.toml

@@ -42,7 +42,7 @@ dependencies = [
     "bumpversion2 >=1.4.3",
     "pytest >=8.2.0",
 ]
-version = "0.18.4"
+version = "0.18.6"
 
 [project.urls]
 Homepage = "https://github.com/waketzheng/fast-dev-cli"

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/test_bump.py

@@ -230,16 +230,16 @@ version = "0"
         another_dir = project_dir / "hello"
         another_dir.mkdir()
         shutil.copy(init_file, another_dir / init_file.name)
-        assert BumpUp.parse_filename() == "helloworld/__init__.py"
+        assert BumpUp.parse_filename() == os.path.join("helloworld", "__init__.py")
         toml_file.write_text(pyproject.strip() + '\npackages=[{include="hello"}]')
-        assert BumpUp.parse_filename() == "hello/__init__.py"
+        assert BumpUp.parse_filename() == os.path.join("hello", "__init__.py")
         toml_file.write_text(
             pyproject.strip() + '\npackages=[{include="hello",from="py"}]'
         )
         from_dir = project_dir / "py"
         from_dir.mkdir()
         shutil.move(another_dir, from_dir)
-        assert BumpUp.parse_filename() == "py/hello/__init__.py"
+        assert BumpUp.parse_filename() == os.path.join("py", "hello", "__init__.py")
 
 
 PDM_DYNAMIC_VERSION = """
@@ -269,7 +269,7 @@ def test_pdm_project(dynamic_pdm_project):
     init_file = dynamic_pdm_project / "__init__.py"
     init_file.write_text('__version__ = "0.2.0"')
     out = capture_cmd_output("fast bump patch")
-    assert str(init_file) in out
+    assert init_file.as_posix() in out
     assert "0.2.1" in init_file.read_text()
     run_and_echo("git init")
     shutil.copy(Path(__file__).parent.parent / ".gitignore", ".")
@@ -291,7 +291,7 @@ def test_installed_version_is_0_0_0(dynamic_pdm_project):
     capture_cmd_output("pdm install")
     version_file.write_text('__version__ = "0.3.0"')
     out = capture_cmd_output("fast bump patch")
-    assert str(version_file) in out
+    assert version_file.as_posix() in out
     assert "0.3.1" in version_file.read_text()
 
 
@@ -332,7 +332,7 @@ __description__ = "A next generation HTTP client, for Python 3."
 __version__ = "0.28.1"
         """)
         out = capture_cmd_output("fast bump patch")
-        assert str(version_file) in out
+        assert version_file.as_posix() in out
         assert "0.28.2" in version_file.read_text()
 
 
@@ -365,7 +365,7 @@ requires = ["pdm-backend"]
 build-backend = "pdm.backend"
         """)
         out = capture_cmd_output("fast bump patch")
-        assert str(version_file) in out
+        assert version_file.as_posix() in out
         assert "0.3.1" in version_file.read_text()
 
 
@@ -400,5 +400,5 @@ requires = ["pdm-backend"]
 build-backend = "pdm.backend"
         """)
         out = capture_cmd_output("fast bump patch")
-        assert str(version_file) in out
+        assert version_file.as_posix() in out
         assert "0.3.1" in version_file.read_text()

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/test_deps.py

@@ -12,8 +12,8 @@ def test_make_deps_class():
     )
     assert MakeDeps("uv", prod=True).gen() == "uv sync --inexact --active"
     assert MakeDeps("uv", prod=True, active=False).gen() == "uv sync --inexact"
-    assert MakeDeps("pdm", prod=False).gen() == "pdm sync -G :all"
-    assert MakeDeps("pdm", prod=True).gen() == "pdm sync --prod"
+    assert MakeDeps("pdm", prod=False).gen() == "pdm install --frozen -G :all"
+    assert MakeDeps("pdm", prod=True).gen() == "pdm install --frozen --prod"
     assert (
         MakeDeps("poetry", prod=False).gen()
         == "poetry install --all-extras --all-groups"
@@ -31,7 +31,7 @@ def test_make_deps_class():
 
 def test_fast_deps():
     out = capture_cmd_output("fast deps --dry")
-    assert out == "--> pdm sync -G :all"
+    assert out == "--> pdm install --frozen -G :all"
     out = capture_cmd_output("fast deps --uv --prod --dry")
     assert out == "--> uv sync --inexact --active"
     out = capture_cmd_output("fast deps --uv --prod --dry --no-active")

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/test_fast_test.py

@@ -95,7 +95,7 @@ def test_run_script_in_sub_directory(mocker: MockerFixture, capsys, script_path)
     mocker.patch("pathlib.Path.cwd", return_value=script_path.parent)
     unitcase(dry=True)
     out = capsys.readouterr().out
-    assert f"cd {script_path.parent.parent} && {TEST_SCRIPT}" in out
+    assert f"cd {script_path.parent.parent} && python {TEST_SCRIPT}" in out
 
 
 def test_fast_test(mocker, capsys):

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/test_functions.py

@@ -80,8 +80,16 @@ def test_run_shell():
     assert run_and_echo("echo foo", capture_output=True) == 0
 
     with pytest.raises(SystemExit):
+        exit_if_run_failed(
+            "in_valid_command", _exit=True, capture_output=True, shell=True
+        )
+    with pytest.raises(FileNotFoundError):
         exit_if_run_failed("in_valid_command", _exit=True, capture_output=True)
     with pytest.raises(typer.Exit):
+        exit_if_run_failed(
+            "in_valid_command", _exit=False, capture_output=True, shell=True
+        )
+    with pytest.raises(FileNotFoundError):
         exit_if_run_failed("in_valid_command", _exit=False, capture_output=True)
     with pytest.raises(NotImplementedError):
 

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/test_lint.py

@@ -183,7 +183,7 @@ def test_dmypy_run(monkeypatch):
 def test_lint_with_prefix(mocker):
     mocker.patch("fast_dev_cli.cli.is_venv", return_value=False)
     with capture_stdout() as stream:
-        make_style(["."], check_only=False, dry=True)
+        make_style(["."], check_only=False, dry=True, prefix=True)
     assert "pdm run" in stream.getvalue()
 
 

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/test_poetry_version_plugin.py

@@ -10,6 +10,7 @@ from fast_dev_cli.cli import (
     TOML_FILE,
     BumpUp,
     ParseError,
+    Project,
     poetry_module_name,
     run_and_echo,
 )
@@ -93,3 +94,9 @@ def test_version_plugin_include_defined(mark, tmp_path: Path) -> None:
         assert BumpUp(part="patch", commit=False, dry=True).gen() == command
         run_and_echo("poetry run fast bump patch")
         assert init_file.read_text() == '__version__ = "0.0.2"\n'
+
+
+@pytest.mark.parametrize("command", ["poetry", "uvx poetry"])
+def test_poetry_version(command) -> None:
+    v = Project.get_poetry_version(command)
+    assert v >= "2.2.0"

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/test_upgrade.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import re
-import sys
 from contextlib import redirect_stdout
 from io import StringIO
 from pathlib import Path
@@ -12,13 +10,14 @@ import typer
 import fast_dev_cli
 from fast_dev_cli.cli import (
     TOML_FILE,
+    Project,
     UpgradeDependencies,
     capture_cmd_output,
     run_and_echo,
     upgrade,
 )
 
-from .utils import chdir
+from .utils import chdir, prepare_poetry_project
 
 
 def test_parse_value():
@@ -85,28 +84,24 @@ uvicorn = {version = "^0.23.2", platform = "linux", optional = true}
 
 def test_dev_flag(tmp_path: Path):
     assert UpgradeDependencies.should_with_dev() is False
-    with chdir(tmp_path):
-        project = tmp_path / "project"
-        run_and_echo(f"poetry new {project.name}")
-        with chdir(project):
-            if sys.version_info < (3, 13):
-                p = Path("pyproject.toml")
-                content = p.read_text()
-                pattern = r'(python = "\^3)\.\d+"'
-                new_content = re.sub(pattern, r'\1.9"', content)
-                p.write_text(new_content)
-            assert not UpgradeDependencies.should_with_dev()
-            run_and_echo("poetry add pytest")
+    with prepare_poetry_project(tmp_path) as poetry:
+        is_newer_poetry = Project.get_poetry_version(poetry) >= "2.2.0"
+        assert not UpgradeDependencies.should_with_dev()
+        run_and_echo(f"{poetry} add pytest")
+        assert not UpgradeDependencies.should_with_dev()
+        run_and_echo(f"{poetry} add --group=dev typer")
+        if is_newer_poetry:
             assert not UpgradeDependencies.should_with_dev()
-            run_and_echo("poetry add --group=dev typer")
+        else:
+            toml_file = Path(TOML_FILE)
             assert UpgradeDependencies.should_with_dev()
-            text = project.joinpath(TOML_FILE).read_text()
+            text = toml_file.read_text()
             DevFlag = UpgradeDependencies.DevFlag
             if DevFlag.new in text:
                 new_text = text.replace(DevFlag.new, DevFlag.old)
             else:
                 new_text = text.replace(DevFlag.old, DevFlag.new)
-            project.joinpath(TOML_FILE).write_text(new_text)
+            toml_file.write_text(new_text)
             assert UpgradeDependencies.should_with_dev()
 
 
@@ -300,7 +295,7 @@ def test_upgrade_uv_project():
 
 def test_upgrade_pdm_project():
     cmd = "fast upgrade --tool=pdm --dry"
-    expected = "pdm update --verbose && pdm sync -G :all --frozen"
+    expected = "pdm update --verbose && pdm install -G :all --frozen"
     assert expected in capture_cmd_output(cmd)
     assert expected in capture_cmd_output("pdm run " + cmd)
     assert UpgradeDependencies(tool="pdm").gen() == expected

{fast_dev_cli-0.18.4 → fast_dev_cli-0.18.6}/tests/utils.py

@@ -1,5 +1,6 @@
 import shutil
 import sys
+from collections.abc import Generator
 from contextlib import contextmanager, redirect_stdout
 from io import StringIO
 from pathlib import Path
@@ -8,8 +9,9 @@ from asynctor import Shell
 from asynctor.compat import chdir
 
 __all__ = (
-    "mock_sys_argv",
     "capture_stdout",
+    "mock_sys_argv",
+    "prepare_poetry_project",
     "temp_file",
 )
 
@@ -51,7 +53,7 @@ def temp_file(name: str, text=""):
 
 
 @contextmanager
-def prepare_poetry_project(tmp_path: Path):
+def prepare_poetry_project(tmp_path: Path) -> Generator[str]:
     py = "{}.{}".format(*sys.version_info)
     poetry = "poetry"
     if shutil.which(poetry) is None:
@@ -64,4 +66,4 @@ def prepare_poetry_project(tmp_path: Path):
                 f"{poetry} config --local virtualenvs.in-project true"
             )
             Shell.run_by_subprocess(f"{poetry} env use {py}")
-            yield
+            yield poetry

fast_dev_cli-0.18.4/fast_dev_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.18.4"