fast-dev-cli 0.17.0__tar.gz → 0.17.1__tar.gz

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/PKG-INFO

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

fast_dev_cli-0.17.1/fast_dev_cli/__init__.py

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

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/fast_dev_cli/cli.py

@@ -10,6 +10,7 @@ import sys
 from functools import cached_property
 from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
     Any,
     Literal,
     # Optional is required by Option generated by typer
@@ -23,17 +24,6 @@ import typer
 from typer import Exit, Option, echo, secho
 from typer.models import ArgumentInfo, OptionInfo
 
-try:
-    from emoji import is_emoji
-except ImportError:
-
-    def is_emoji(char: str) -> bool:  # type:ignore[misc]
-        return (
-            not re.match(r"[\w\d\s]", char)
-            and not "\u4e00" <= char <= "\u9fff"  # Chinese
-        )
-
-
 try:
     from . import __version__
 except ImportError:  # pragma: no cover
@@ -43,20 +33,24 @@ except ImportError:  # pragma: no cover
 
 if sys.version_info >= (3, 11):  # pragma: no cover
     from enum import StrEnum
-    from typing import Self
 
     import tomllib
 else:  # pragma: no cover
     from enum import Enum
 
     import tomli as tomllib
-    from typing_extensions import Self
 
     class StrEnum(str, Enum):
         __str__ = str.__str__
 
 
-cli = typer.Typer()
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        from typing_extensions import Self
+
+cli = typer.Typer(no_args_is_help=True)
 DryOption = Option(False, "--dry", help="Only print, not really run shell command")
 TOML_FILE = "pyproject.toml"
 ToolName = Literal["poetry", "pdm", "uv"]
@@ -83,6 +77,18 @@ def poetry_module_name(name: str) -> str:
     return canonicalize_name(name).replace("-", "_").replace(" ", "_")
 
 
+def is_emoji(char: str) -> bool:
+    try:
+        import emoji
+    except ImportError:
+        pass
+    else:
+        return emoji.is_emoji(char)
+    if re.match(r"[\w\d\s]", char):
+        return False
+    return not "\u4e00" <= char <= "\u9fff"  # Chinese character
+
+
 def load_bool(name: str, default: bool = False) -> bool:
     if not (v := os.getenv(name)):
         return default
@@ -116,7 +122,7 @@ def run_and_echo(
     if dry:
         return 0
     command: list[str] | str = cmd
-    if "shell" not in kw and not (set(cmd) & {"|", ">"}):
+    if "shell" not in kw and not (set(cmd) & {"|", ">", "&"}):
         command = shlex.split(cmd)
     return _run_shell(command, **kw).returncode
 
@@ -155,9 +161,9 @@ def read_version_from_file(
             toml_text = Project.load_toml_text()
         context = tomllib.loads(toml_text)
         with contextlib.suppress(KeyError):
-            return context["project"]["version"]
+            return cast(str, context["project"]["version"])
         with contextlib.suppress(KeyError):  # Poetry V1
-            return context["tool"]["poetry"]["version"]
+            return cast(str, context["tool"]["poetry"]["version"])
         secho(f"WARNING: can not find 'version' item in {version_file}!")
         return "0.0.0"
     pattern = re.compile(r"__version__\s*=")
@@ -274,14 +280,14 @@ def exit_if_run_failed(
 
 
 class DryRun:
-    def __init__(self: Self, _exit: bool = False, dry: bool = False) -> None:
+    def __init__(self, _exit: bool = False, dry: bool = False) -> None:
         self.dry = dry
         self._exit = _exit
 
-    def gen(self: Self) -> str:
+    def gen(self) -> str:
         raise NotImplementedError
 
-    def run(self: Self) -> None:
+    def run(self) -> None:
         exit_if_run_failed(self.gen(), _exit=self._exit, dry=self.dry)
 
 
@@ -292,17 +298,21 @@ class BumpUp(DryRun):
         major = "major"
 
     def __init__(
-        self: Self,
+        self,
         commit: bool,
         part: str,
         filename: str | None = None,
         dry: bool = False,
+        no_sync: bool = False,
+        emoji: bool | None = None,
     ) -> None:
         self.commit = commit
         self.part = part
         if filename is None:
             filename = self.parse_filename()
         self.filename = filename
+        self._no_sync = no_sync
+        self._emoji = emoji
         super().__init__(dry=dry)
 
     @staticmethod
@@ -352,7 +362,9 @@ class BumpUp(DryRun):
                         work_dir = Project.get_work_dir()
                     for tool in ("pdm", "hatch"):
                         with contextlib.suppress(KeyError):
-                            version_path = context["tool"][tool]["version"]["path"]
+                            version_path = cast(
+                                str, context["tool"][tool]["version"]["path"]
+                            )
                             if (
                                 Path(version_path).exists()
                                 or work_dir.joinpath(version_path).exists()
@@ -425,10 +437,8 @@ class BumpUp(DryRun):
             echo(f"Invalid part: {s!r}")
             raise Exit(1) from e
 
-    def gen(self: Self) -> str:
+    def gen(self) -> str:
         should_sync, _version = get_current_version(check_version=True)
-        if should_sync:
-            Project.sync_dependencies()
         filename = self.filename
         echo(f"Current version(@{filename}): {_version}")
         if self.part:
@@ -444,15 +454,17 @@ class BumpUp(DryRun):
             if part != "patch":
                 cmd += " --tag"
             cmd += " --commit"
-            if self.should_add_emoji():
+            if self._emoji or (self._emoji is None and self.should_add_emoji()):
                 cmd += " --message-emoji=1"
             if not load_bool("DONT_GIT_PUSH"):
                 cmd += " && git push && git push --tags && git log -1"
         else:
             cmd += " --allow-dirty"
+        if should_sync and not self._no_sync and (sync := Project.get_sync_command()):
+            cmd = f"{sync} && " + cmd
         return cmd
 
-    def run(self: Self) -> None:
+    def run(self) -> None:
         super().run()
         if not self.commit and not self.dry:
             new_version = get_current_version(True)
@@ -464,7 +476,19 @@ class BumpUp(DryRun):
 @cli.command()
 def version() -> None:
     """Show the version of this tool"""
-    echo(f"Fast Dev Cli version: {__version__}")
+    echo("Fast Dev Cli Version: " + typer.style(__version__, fg=typer.colors.BLUE))
+    with contextlib.suppress(FileNotFoundError, KeyError):
+        toml_text = Project.load_toml_text()
+        doc = tomllib.loads(toml_text)
+        version_file = doc["tool"]["pdm"]["version"]["path"]
+        text = Project.get_work_dir().joinpath(version_file).read_text()
+        varname = "__version__"
+        for line in text.splitlines():
+            if line.strip().startswith(varname):
+                value = line.split("=", 1)[-1].strip().strip('"').strip("'")
+                styled = typer.style(value, bold=True)
+                echo(f"Version value in {version_file}: " + styled)
+                break
 
 
 @cli.command(name="bump")
@@ -473,10 +497,24 @@ def bump_version(
     commit: bool = Option(
         False, "--commit", "-c", help="Whether run `git commit` after version changed"
     ),
+    emoji: Optional[bool] = Option(
+        None, "--emoji", help="Whether add emoji prefix to commit message"
+    ),
+    no_sync: bool = Option(
+        False, "--no-sync", help="Do not run sync command to update version"
+    ),
     dry: bool = DryOption,
 ) -> None:
     """Bump up version string in pyproject.toml"""
-    return BumpUp(_ensure_bool(commit), getattr(part, "value", part), dry=dry).run()
+    if emoji is not None:
+        emoji = _ensure_bool(emoji)
+    return BumpUp(
+        _ensure_bool(commit),
+        getattr(part, "value", part),
+        no_sync=_ensure_bool(no_sync),
+        emoji=emoji,
+        dry=dry,
+    ).run()
 
 
 def bump() -> None:
@@ -488,7 +526,7 @@ def bump() -> None:
             if not a.startswith("-"):
                 part = a
                 break
-    return BumpUp(commit, part, dry="--dry" in args).run()
+    return BumpUp(commit, part, no_sync="--no-sync" in args, dry="--dry" in args).run()
 
 
 class EnvError(Exception):
@@ -594,14 +632,30 @@ class Project:
         return True
 
     @classmethod
-    def sync_dependencies(cls) -> None:
+    def get_sync_command(cls, prod: bool = True, doc: dict | None = None) -> str:
         if cls.is_pdm_project():
-            cmd = "pdm sync --prod"
-            run_and_echo(cmd)
+            return "pdm sync" + " --prod" * prod
         elif cls.manage_by_poetry(cache=True):
-            run_and_echo("poetry install --only=main")
+            cmd = "poetry install"
+            if prod:
+                if doc is None:
+                    doc = tomllib.loads(cls.load_toml_text())
+                if doc.get("project", {}).get("dependencies") or any(
+                    i != "python"
+                    for i in doc.get("tool", {})
+                    .get("poetry", {})
+                    .get("dependencies", [])
+                ):
+                    cmd += " --only=main"
+            return cmd
         elif cls.get_manage_tool(cache=True) == "uv":
-            run_and_echo("uv sync")
+            return "uv sync --inexact" + " --no-dev" * prod
+        return ""
+
+    @classmethod
+    def sync_dependencies(cls, prod: bool = True) -> None:
+        if cmd := cls.get_sync_command():
+            run_and_echo(cmd)
 
 
 class ParseError(Exception):
@@ -612,7 +666,7 @@ class ParseError(Exception):
 
 class UpgradeDependencies(Project, DryRun):
     def __init__(
-        self: Self, _exit: bool = False, dry: bool = False, tool: ToolName = "poetry"
+        self, _exit: bool = False, dry: bool = False, tool: ToolName = "poetry"
     ) -> None:
         super().__init__(_exit, dry)
         self._tool = tool
@@ -777,11 +831,13 @@ class UpgradeDependencies(Project, DryRun):
             _upgrade += f" && poetry add {' '.join(single)}"
         return _upgrade
 
-    def gen(self: Self) -> str:
+    def gen(self) -> str:
         if self._tool == "uv":
-            return "uv lock --upgrade --verbose && uv sync --frozen --all-groups"
+            up = "uv lock --upgrade --verbose"
+            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"
+            return "pdm update --verbose && pdm sync -G :all --frozen"
         return self.gen_cmd() + " && poetry lock && poetry update"
 
 
@@ -801,36 +857,35 @@ def upgrade(
 
 
 class GitTag(DryRun):
-    def __init__(self: Self, message: str, dry: bool) -> None:
+    def __init__(self, message: str, dry: bool, no_sync: bool = False) -> None:
         self.message = message
+        self._no_sync = no_sync
         super().__init__(dry=dry)
 
     @staticmethod
     def has_v_prefix() -> bool:
         return "v" in capture_cmd_output("git tag")
 
-    def should_push(self: Self) -> bool:
+    def should_push(self) -> bool:
         return "git push" in self.git_status
 
-    def gen(self: Self) -> str:
+    def gen(self) -> str:
         should_sync, _version = get_current_version(verbose=False, check_version=True)
-        if should_sync:
-            Project.sync_dependencies()
         if self.has_v_prefix():
             # Add `v` at prefix to compare with bumpversion tool
             _version = "v" + _version
         cmd = f"git tag -a {_version} -m {self.message!r} && git push --tags"
         if self.should_push():
             cmd += " && git push"
-        if Project.is_pdm_project():
-            cmd = "pdm sync --prod && " + cmd
+        if should_sync and not self._no_sync and (sync := Project.get_sync_command()):
+            cmd = f"{sync} && " + cmd
         return cmd
 
     @cached_property
-    def git_status(self: Self) -> str:
+    def git_status(self) -> str:
         return capture_cmd_output("git status")
 
-    def mark_tag(self: Self) -> bool:
+    def mark_tag(self) -> bool:
         if not re.search(r"working (tree|directory) clean", self.git_status) and (
             "无文件要提交，干净的工作区" not in self.git_status
         ):
@@ -839,7 +894,7 @@ class GitTag(DryRun):
             return False
         return bool(super().run())
 
-    def run(self: Self) -> None:
+    def run(self) -> None:
         if self.mark_tag() and not self.dry:
             echo("You may want to publish package:\n poetry publish --build")
 
@@ -847,15 +902,18 @@ class GitTag(DryRun):
 @cli.command()
 def tag(
     message: str = Option("", "-m", "--message"),
+    no_sync: bool = Option(
+        False, "--no-sync", help="Do not run sync command to update version"
+    ),
     dry: bool = DryOption,
 ) -> None:
     """Run shell command: git tag -a <current-version-in-pyproject.toml> -m {message}"""
-    GitTag(message, dry=dry).run()
+    GitTag(message, dry=dry, no_sync=_ensure_bool(no_sync)).run()
 
 
 class LintCode(DryRun):
     def __init__(
-        self: Self,
+        self,
         args: list[str] | str | None,
         check_only: bool = False,
         _exit: bool = False,
@@ -921,10 +979,21 @@ class LintCode(DryRun):
         lint_them = " && ".join(
             "{0}{" + str(i) + "} {1}" for i in range(2, len(tools) + 2)
         )
+        if ruff_exists := cls.check_lint_tool_installed():
+            # `ruff <command>` get the same result with `pdm run ruff <command>`
+            # While `mypy .`(installed global and env not activated),
+            #   does not the same as `pdm run mypy .`
+            lint_them = " && ".join(
+                ("" if tool.startswith("ruff") else "{0}")
+                + (
+                    "{%d} {1}" % i  # noqa: UP031
+                )
+                for i, tool in enumerate(tools, 2)
+            )
         prefix = ""
         should_run_by_tool = False
         if is_venv() and Path(sys.argv[0]).parent != Path.home().joinpath(".local/bin"):
-            if not cls.check_lint_tool_installed():
+            if not ruff_exists:
                 should_run_by_tool = True
                 if check_call('python -c "import fast_dev_cli"'):
                     command = 'python -m pip install -U "fast-dev-cli"'
@@ -936,7 +1005,11 @@ class LintCode(DryRun):
             if tool == ToolOption.default:
                 tool = Project.get_manage_tool() or ""
             if tool:
-                prefix = tool + " run "
+                prefix = (
+                    str(bin_dir)
+                    if tool == "uv" and (bin_dir := Path(".venv/bin/")).exists()
+                    else (tool + " run ")
+                )
         if cls.prefer_dmypy(paths, tools, use_dmypy=use_dmypy):
             tools[-1] = "dmypy run"
         cmd += lint_them.format(prefix, paths, *tools)
@@ -952,7 +1025,7 @@ class LintCode(DryRun):
             cmd += " && " + command
         return cmd
 
-    def gen(self: Self) -> str:
+    def gen(self) -> str:
         if isinstance(args := self.args, str):
             args = args.split()
         paths = " ".join(map(str, args)) if args else "."
@@ -1041,7 +1114,7 @@ def only_check(
 
 class Sync(DryRun):
     def __init__(
-        self: Self, filename: str, extras: str, save: bool, dry: bool = False
+        self, filename: str, extras: str, save: bool, dry: bool = False
     ) -> None:
         self.filename = filename
         self.extras = extras
@@ -1192,7 +1265,7 @@ def runserver(
 
 @cli.command(name="exec")
 def run_by_subprocess(cmd: str, dry: bool = DryOption) -> None:
-    """Run cmd by subprocess, auto set shell=True when cmd contains '|'"""
+    """Run cmd by subprocess, auto set shell=True when cmd contains '|>'"""
     try:
         rc = run_and_echo(cmd, verbose=True, dry=_ensure_bool(dry))
     except FileNotFoundError as e:
@@ -1205,6 +1278,26 @@ def run_by_subprocess(cmd: str, dry: bool = DryOption) -> None:
             raise Exit(rc)
 
 
+def version_callback(value: bool) -> None:
+    if value:
+        echo("Fast Dev Cli Version: " + typer.style(__version__, bold=True))
+        raise Exit()
+
+
+@cli.callback()
+def common(
+    version: bool = Option(
+        None,
+        "--version",
+        "-V",
+        callback=version_callback,
+        is_eager=True,
+        help="Show the version of this tool",
+    ),
+) -> None:
+    pass
+
+
 def main() -> None:
     cli()
 

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/pyproject.toml

@@ -42,7 +42,7 @@ dependencies = [
     "bumpversion2 >=1.4.3,<2",
     "pytest >=8.2.0,<9",
 ]
-version = "0.17.0"
+version = "0.17.1"
 
 [project.urls]
 Homepage = "https://github.com/waketzheng/fast-dev-cli"
@@ -59,6 +59,9 @@ fast = "fast_dev_cli:cli.main"
 dev = [
     "twine>=6.1.0",
 ]
+test = [
+    "asynctor>=0.8.6",
+]
 
 [tool.pdm]
 distribution = true
@@ -150,7 +153,7 @@ omit = [
 context = "${CONTEXT}"
 
 [tool.coverage.report]
-exclude_lines = [
+exclude_also = [
     "pragma: no cover",
     "@overload",
     "if __name__ == \"__main__\":",

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/tests/conftest.py

@@ -1,10 +1,10 @@
+import sys
 from pathlib import Path
 
 import pytest
+from asynctor.compat import chdir
 
-from fast_dev_cli.cli import TOML_FILE
-
-from .utils import chdir
+from fast_dev_cli.cli import TOML_FILE, run_and_echo
 
 # toml file content before migrate to pdm
 TOML_CONTENT = """
@@ -59,4 +59,6 @@ def tmp_work_dir(tmp_path):
 @pytest.fixture
 def tmp_poetry_project(tmp_work_dir: Path):
     Path(TOML_FILE).write_text(TOML_CONTENT)
+    if sys.version_info >= (3, 10):
+        run_and_echo("poetry config --local virtualenvs.in-project true")
     yield tmp_work_dir

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/tests/test_bump.py

@@ -22,6 +22,7 @@ from fast_dev_cli.cli import (
     bump_version,
     capture_cmd_output,
     get_current_version,
+    run_and_echo,
 )
 
 from .utils import chdir, mock_sys_argv, prepare_poetry_project
@@ -102,35 +103,38 @@ def test_bump(
 
 def test_bump_with_poetry(mocker, tmp_poetry_project, tmp_path):
     mocker.patch("builtins.input", return_value=" ")
-    version = get_current_version()
+    version = get_current_version(check_version=False)
     patch_without_commit, patch_with_commit, minor_with_commit = _bump_commands(
         version, add_sync=False
     )
     stream = StringIO()
     with redirect_stdout(stream):
-        BumpUp(part="patch", commit=False).run()
+        BumpUp(part="patch", commit=False, no_sync=True).run()
     assert f"Current version(@{TOML_FILE}):" in stream.getvalue()
     stream = StringIO()
     with redirect_stdout(stream):
-        BumpUp(part="minor", commit=False).run()
+        BumpUp(part="minor", commit=False, no_sync=True).run()
     assert "You may want to pin tag by `fast tag`" in stream.getvalue()
     stream = StringIO()
     new_version = get_current_version()
     with redirect_stdout(stream):
-        bump_version(BumpUp.PartChoices.patch, commit=False, dry=True)
+        bump_version(BumpUp.PartChoices.patch, commit=False, dry=True, no_sync=True)
     assert patch_without_commit.replace(version, new_version) in stream.getvalue()
     stream = StringIO()
-    with redirect_stdout(stream), mock_sys_argv(["patch", "--dry"]):
+    with redirect_stdout(stream), mock_sys_argv(["patch", "--dry", "--no-sync"]):
         bump()
     assert patch_without_commit.replace(version, new_version) in stream.getvalue()
     stream = StringIO()
-    with redirect_stdout(stream), mock_sys_argv(["patch", "--commit", "--dry"]):
+    with (
+        redirect_stdout(stream),
+        mock_sys_argv(["patch", "--commit", "--dry", "--no-sync"]),
+    ):
         bump()
     assert patch_with_commit.replace(version, new_version) in stream.getvalue()
     stream = StringIO()
     with (
         redirect_stdout(stream),
-        mock_sys_argv(["-c", "minor", "--commit", "--dry"]),
+        mock_sys_argv(["-c", "minor", "--commit", "--dry", "--no-sync"]),
     ):
         bump()
     assert minor_with_commit.replace(version, new_version) in stream.getvalue()
@@ -182,7 +186,7 @@ def test_bump_with_emoji_in_poetry_project(mocker, tmp_path, monkeypatch):
         assert BumpUp.should_add_emoji() is False
         subprocess.run(["git", "commit", "-m", last_commit])
         monkeypatch.setenv("DONT_GIT_PUSH", "1")
-        command = BumpUp(part="patch", commit=True).gen()
+        command = BumpUp(part="patch", commit=True, no_sync=True).gen()
         expected = patch_with_commit.split("&&")[0].strip().replace('""', '"0.1.0"')
         assert expected == command
         subprocess.run(["poetry", "run", "pip", "install", "bumpversion2"])
@@ -267,6 +271,15 @@ def test_pdm_project(dynamic_pdm_project):
     out = capture_cmd_output("fast bump patch")
     assert str(init_file) in out
     assert "0.2.1" in init_file.read_text()
+    run_and_echo("git init")
+    shutil.copy(Path(__file__).parent.parent / ".gitignore", ".")
+    run_and_echo("git add .")
+    run_and_echo("git config user.name xxx")
+    run_and_echo("git config user.email xxx@a.com")
+    run_and_echo('git commit -m "xxx"')
+    out = capture_cmd_output("fast bump patch --emoji --commit")
+    assert "--message-emoji=1" in out
+    assert "⬆️  Bump version: 0.2.1 → 0.2.2" in capture_cmd_output("git log")
 
 
 def test_installed_version_is_0_0_0(dynamic_pdm_project):

fast_dev_cli-0.17.1/tests/test_help.py

@@ -0,0 +1,7 @@
+from asynctor import Shell
+
+
+def test_help():
+    out = Shell("fast").capture_output()
+    out_help = Shell("fast --help").capture_output()
+    assert out == out_help

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/tests/test_lint.py

@@ -160,14 +160,6 @@ def test_lint_html():
     assert LintCode.to_cmd("index.html flv.html") == "prettier -w index.html flv.html"
 
 
-def test_lint_by_global_fast():
-    run = "pdm run "
-    fast = Path.home() / ".local" / "bin" / "fast"
-    command = capture_cmd_output(f"{fast} lint --dry")
-    for cmd in command.split(SEP):
-        assert run in cmd
-
-
 def test_with_dmypy():
     cmd = "fast lint --dmypy --dry ."
     assert "dmypy run ." in capture_cmd_output(cmd)

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/tests/test_poetry_version_plugin.py

@@ -38,21 +38,20 @@ def _prepare_package(
     a, b = 'version = "0.1.0"', f'version = "{mark}"'
     if define_include:
         b += f'\npackages = [{{include = "{package_name}"}}]'
+    py_version = "{}.{}".format(*sys.version_info)
     with chdir(package_path.parent):
-        run_and_echo(f'poetry new "{package_path.name}"')
+        run_and_echo(
+            f'poetry new --python="^{py_version}" --no-interaction "{package_path.name}"'
+        )
     src_dir = package_path / "src"
     if is_src_layout := src_dir.exists():
         # poetry v2 default to use src/<package_name> layout
         init_file = src_dir / package_name / init_file.name
-    toml_file.unlink()
-    py_version = "{}.{}".format(*sys.version_info)
     with chdir(package_path):
-        run_and_echo(f'poetry init --python="^{py_version}" --no-interaction')
+        run_and_echo("poetry config --local virtualenvs.in-project true")
         text = toml_file.read_text().replace(a, b)
         if " " in package_path.name:
-            text = text.replace(
-                f'name = "{package_path.name}"', f'name = "{package_name}"'
-            )
+            text = text.replace(f'"{package_path.name}"', f'"{package_name}"')
         toml_file.write_text(text + CONF)
         if package_path.name != package_name:
             if is_src_layout:
@@ -63,15 +62,21 @@ def _prepare_package(
         yield init_file
 
 
-def _build_bump_cmd(init_file: Path, project_path: Path) -> str:
+def _build_bump_cmd(
+    init_file: Path, project_path: Path, should_sync: bool = False
+) -> str:
     relative_path = init_file.relative_to(project_path).as_posix()
-    return rf'bumpversion --parse "(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)" --current-version="0.0.1" patch {relative_path} --allow-dirty'
+    cmd = rf'bumpversion --parse "(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)" --current-version="0.0.1" patch {relative_path} --allow-dirty'
+    if should_sync:
+        cmd = "poetry install && " + cmd
+    return cmd
 
 
-def test_version_plugin(tmp_path: Path) -> None:
+@pytest.mark.parametrize("mark", ["0", "0.0.0"])
+def test_version_plugin(mark, tmp_path: Path) -> None:
     project_path = tmp_path / "helloworld"
-    with _prepare_package(project_path) as init_file:
-        command = _build_bump_cmd(init_file, project_path)
+    with _prepare_package(project_path, mark=mark) as init_file:
+        command = _build_bump_cmd(init_file, project_path, should_sync=True)
         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'
@@ -80,31 +85,11 @@ def test_version_plugin(tmp_path: Path) -> None:
             BumpUp(part="patch", commit=False, dry=True).gen()
 
 
-def test_version_plugin_2(tmp_path: Path) -> None:
-    project_path = tmp_path / "helloworld"
-    with _prepare_package(project_path, mark="0.0.0") as init_file:
-        command = _build_bump_cmd(init_file, project_path)
-        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'
-        init_file.unlink()
-        with pytest.raises(ParseError, match=r"Version file not found!.*"):
-            BumpUp(part="patch", commit=False, dry=True).gen()
-
-
-def test_version_plugin_include_defined(tmp_path: Path) -> None:
-    project_path = tmp_path / "hello world"
-    with _prepare_package(project_path, True) as init_file:
-        command = _build_bump_cmd(init_file, project_path)
-        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'
-
-
-def test_version_plugin_include_defined_2(tmp_path: Path) -> None:
+@pytest.mark.parametrize("mark", ["0", "0.0.0"])
+def test_version_plugin_include_defined(mark, tmp_path: Path) -> None:
     project_path = tmp_path / "hello world"
-    with _prepare_package(project_path, True, mark="0.0.0") as init_file:
-        command = _build_bump_cmd(init_file, project_path)
+    with _prepare_package(project_path, True, mark=mark) as init_file:
+        command = _build_bump_cmd(init_file, project_path, should_sync=True)
         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'

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/tests/test_tag.py

@@ -50,16 +50,24 @@ def _clear_tags():
 def test_with_push(mocker):
     git_tag = GitTag("", dry=True)
     mocker.patch.object(git_tag, "git_status", return_value="git push")
-    version = get_current_version()
+    should_sync, version = get_current_version(check_version=True)
     prefix = "v" if "v" in capture_cmd_output(["git", "tag"]) else ""
     sync = "pdm sync --prod"
     push = "git push --tags"
-    assert git_tag.gen() == f"{sync} && git tag -a {prefix}{version} -m '' && {push}"
+    expected = f"git tag -a {prefix}{version} -m '' && {push}"
+    if should_sync:
+        expected = f"{sync} && " + expected
+    assert git_tag.gen() == expected
     with _clear_tags():
         git_tag_cmd = git_tag.gen()
-    assert git_tag_cmd == f"{sync} && git tag -a {version} -m '' && {push}"
+    expected = f"git tag -a {version} -m '' && {push}"
+    if should_sync:
+        expected = f"{sync} && " + expected
+    assert git_tag_cmd == expected
     mocker.patch.object(git_tag, "has_v_prefix", return_value=True)
-    tag_cmd = f"{sync} && git tag -a v{version} -m '' && {push}"
-    assert git_tag.gen() == tag_cmd
+    expected = f"git tag -a v{version} -m '' && {push}"
+    if should_sync:
+        expected = f"{sync} && " + expected
+    assert git_tag.gen() == expected
     mocker.patch.object(git_tag, "should_push", return_value=True)
-    assert git_tag.gen() == tag_cmd + " && git push"
+    assert git_tag.gen() == expected + " && git push"

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/tests/test_upgrade.py

@@ -292,7 +292,7 @@ fastapi = "^0.112.2"
 
 def test_upgrade_uv_project():
     cmd = "fast upgrade --tool=uv --dry"
-    expected = "uv lock --upgrade --verbose && uv sync --frozen --all-groups"
+    expected = "uv lock --upgrade --verbose && uv sync --inexact --frozen --all-groups --all-extras"
     assert expected in capture_cmd_output(cmd)
     assert expected in capture_cmd_output("pdm run " + cmd)
     assert UpgradeDependencies(tool="uv").gen() == expected
@@ -300,7 +300,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"
+    expected = "pdm update --verbose && pdm sync -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.17.0 → fast_dev_cli-0.17.1}/tests/test_version.py

@@ -2,19 +2,21 @@ import re
 from pathlib import Path
 
 import pytest
+from asynctor import Shell
+from asynctor.compat import chdir
 
 from fast_dev_cli import __version__
 from fast_dev_cli.cli import (
     TOML_FILE,
+    Exit,
     ShellCommandError,
     _parse_version,
     get_current_version,
     read_version_from_file,
     version,
+    version_callback,
 )
 
-from .utils import chdir
-
 
 def test_version(capsys):
     version()
@@ -58,3 +60,19 @@ def test_parse_version():
     assert _parse_version(line, pattern) == "0.0.1"
     line = '__version__ = "0.0.1"  # 0.0.2'
     assert _parse_version(line, pattern) == "0.0.1"
+
+
+def test_display_self_version(capsys):
+    with pytest.raises(Exit):
+        version_callback(True)
+    assert __version__ in capsys.readouterr().out
+    out = Shell("fast --version").capture_output().strip()
+    assert out == "Fast Dev Cli Version: 0.17.0"
+    out_v = Shell("fast -V").capture_output().strip()
+    assert out_v == out
+
+
+def test_fast_version(capsys):
+    out = Shell("fast version").capture_output().strip()
+    assert "Fast Dev Cli Version: 0.17.0" in out
+    assert "fast_dev_cli/__init__.py: 0.17.0" in out

{fast_dev_cli-0.17.0 → fast_dev_cli-0.17.1}/tests/utils.py

@@ -1,29 +1,13 @@
-import os
-import subprocess
+import shutil
 import sys
-from contextlib import AbstractContextManager, contextmanager, redirect_stdout
+from contextlib import contextmanager, redirect_stdout
 from io import StringIO
 from pathlib import Path
 
-
-# TODO: use `from contextlib import chdir` instead when drop support for Python3.10
-class chdir(AbstractContextManager):  # Copied from source code of Python3.13
-    """Non thread-safe context manager to change the current working directory."""
-
-    def __init__(self, path):
-        self.path = path
-        self._old_cwd = []
-
-    def __enter__(self):
-        self._old_cwd.append(os.getcwd())
-        os.chdir(self.path)
-
-    def __exit__(self, *excinfo):
-        os.chdir(self._old_cwd.pop())
-
+from asynctor import Shell
+from asynctor.compat import chdir
 
 __all__ = (
-    "chdir",
     "mock_sys_argv",
     "capture_stdout",
     "temp_file",
@@ -68,8 +52,16 @@ def temp_file(name: str, text=""):
 
 @contextmanager
 def prepare_poetry_project(tmp_path: Path):
+    py = "{}.{}".format(*sys.version_info)
+    poetry = "poetry"
+    if shutil.which(poetry) is None:
+        poetry = "uvx " + poetry
     with chdir(tmp_path):
         project = "foo"
-        subprocess.run(["poetry", "new", project])
+        Shell.run_by_subprocess(f"{poetry} new {project} --python=^{py}")
         with chdir(tmp_path / project):
+            Shell.run_by_subprocess(
+                f"{poetry} config --local virtualenvs.in-project true"
+            )
+            Shell.run_by_subprocess(f"{poetry} env use {py}")
             yield

fast_dev_cli-0.17.0/fast_dev_cli/__init__.py

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