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

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

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

fast_dev_cli-0.17.0/fast_dev_cli/__init__.py

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

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

@@ -16,6 +16,7 @@ from typing import (
     Optional,
     cast,
     get_args,
+    overload,
 )
 
 import typer
@@ -64,7 +65,10 @@ ToolOption = Option(
 )
 
 
-class ShellCommandError(Exception): ...
+class FastDevCliError(Exception): ...
+
+
+class ShellCommandError(FastDevCliError): ...
 
 
 def poetry_module_name(name: str) -> str:
@@ -111,7 +115,10 @@ def run_and_echo(
         echo(f"--> {cmd}")
     if dry:
         return 0
-    return _run_shell(cmd, **kw).returncode
+    command: list[str] | str = cmd
+    if "shell" not in kw and not (set(cmd) & {"|", ">"}):
+        command = shlex.split(cmd)
+    return _run_shell(command, **kw).returncode
 
 
 def check_call(cmd: str) -> bool:
@@ -177,33 +184,61 @@ def read_version_from_file(
     return "0.0.0"
 
 
+@overload
 def get_current_version(
     verbose: bool = False,
     is_poetry: bool | None = None,
     package_name: str | None = None,
-) -> str:
-    if is_poetry is None:
-        is_poetry = Project.manage_by_poetry()
-    if not is_poetry:
-        work_dir = None
-        if package_name is None:
-            work_dir = Project.get_work_dir()
-            package_name = re.sub(r"[- ]", "_", work_dir.name)
-        try:
-            installed_version = importlib_metadata.version(package_name)
-        except importlib_metadata.PackageNotFoundError:
-            ...
-        else:
-            if installed_version != "0.0.0":
-                return installed_version
-        return read_version_from_file(package_name, work_dir)
+    *,
+    check_version: Literal[False] = False,
+) -> str: ...
 
-    cmd = ["poetry", "version", "-s"]
-    if verbose:
-        echo(f"--> {' '.join(cmd)}")
-    if out := capture_cmd_output(cmd, raises=True):
-        out = out.splitlines()[-1].strip().split()[-1]
-    return out
+
+@overload
+def get_current_version(
+    verbose: bool = False,
+    is_poetry: bool | None = None,
+    package_name: str | None = None,
+    *,
+    check_version: Literal[True] = True,
+) -> tuple[bool, str]: ...
+
+
+def get_current_version(
+    verbose: bool = False,
+    is_poetry: bool | None = None,
+    package_name: str | None = None,
+    *,
+    check_version: bool = False,
+) -> str | tuple[bool, str]:
+    if is_poetry is True or Project.manage_by_poetry():
+        cmd = ["poetry", "version", "-s"]
+        if verbose:
+            echo(f"--> {' '.join(cmd)}")
+        if out := capture_cmd_output(cmd, raises=True):
+            out = out.splitlines()[-1].strip().split()[-1]
+        if check_version:
+            return True, out
+        return out
+    toml_text = work_dir = None
+    if package_name is None:
+        work_dir = Project.get_work_dir()
+        toml_text = Project.load_toml_text()
+        doc = tomllib.loads(toml_text)
+        project_name = doc.get("project", {}).get("name", work_dir.name)
+        package_name = re.sub(r"[- ]", "_", project_name)
+    local_version = read_version_from_file(package_name, work_dir, toml_text)
+    try:
+        installed_version = importlib_metadata.version(package_name)
+    except importlib_metadata.PackageNotFoundError:
+        installed_version = ""
+    current_version = local_version or installed_version
+    if not current_version:
+        raise FastDevCliError(f"Failed to get current version of {package_name!r}")
+    if check_version:
+        is_conflict = bool(local_version) and local_version != installed_version
+        return is_conflict, current_version
+    return current_version
 
 
 def _ensure_bool(value: bool | OptionInfo) -> bool:
@@ -391,7 +426,9 @@ class BumpUp(DryRun):
             raise Exit(1) from e
 
     def gen(self: Self) -> str:
-        _version = get_current_version()
+        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:
@@ -460,6 +497,7 @@ class EnvError(Exception):
 
 class Project:
     path_depth = 5
+    _tool: ToolName | None = None
 
     @staticmethod
     def is_poetry_v2(text: str) -> bool:
@@ -490,7 +528,7 @@ class Project:
             return d
         if allow_cwd:
             return cls.get_root_dir(cwd)
-        raise EnvError(f"{name} not found! Make sure this is a poetry project.")
+        raise EnvError(f"{name} not found! Make sure this is a python project.")
 
     @classmethod
     def load_toml_text(cls: type[Self], name: str = TOML_FILE) -> str:
@@ -498,22 +536,40 @@ class Project:
         return toml_file.read_text("utf8")
 
     @classmethod
-    def manage_by_poetry(cls: type[Self]) -> bool:
-        return cls.get_manage_tool() == "poetry"
+    def manage_by_poetry(cls: type[Self], cache: bool = False) -> bool:
+        return cls.get_manage_tool(cache=cache) == "poetry"
 
     @classmethod
-    def get_manage_tool(cls: type[Self]) -> ToolName | None:
+    def get_manage_tool(cls: type[Self], cache: bool = False) -> ToolName | None:
+        if cache and cls._tool:
+            return cls._tool
         try:
             text = cls.load_toml_text()
         except EnvError:
             pass
         else:
+            with contextlib.suppress(KeyError, tomllib.TOMLDecodeError):
+                doc = tomllib.loads(text)
+                backend = doc["build-system"]["build-backend"]
+                if "poetry" in backend:
+                    cls._tool = "poetry"
+                    return cls._tool
+                elif "pdm" in backend:
+                    cls._tool = "pdm"
+                    work_dir = cls.get_work_dir(allow_cwd=True)
+                    if not Path(work_dir, "pdm.lock").exists() and (
+                        "[tool.uv]" in text or Path(work_dir, "uv.lock").exists()
+                    ):
+                        cls._tool = "uv"
+                    return cls._tool
             for name in get_args(ToolName):
                 if f"[tool.{name}]" in text:
-                    return cast(ToolName, name)
+                    cls._tool = cast(ToolName, name)
+                    return cls._tool
             # Poetry 2.0 default to not include the '[tool.poetry]' section
             if cls.is_poetry_v2(text):
-                return "poetry"
+                cls._tool = "poetry"
+                return cls._tool
         return None
 
     @staticmethod
@@ -528,6 +584,25 @@ class Project:
             root = venv_parent
         return root
 
+    @classmethod
+    def is_pdm_project(cls, strict: bool = True, cache: bool = False) -> bool:
+        if cls.get_manage_tool(cache=cache) != "pdm":
+            return False
+        if strict:
+            lock_file = cls.get_work_dir() / "pdm.lock"
+            return lock_file.exists()
+        return True
+
+    @classmethod
+    def sync_dependencies(cls) -> None:
+        if cls.is_pdm_project():
+            cmd = "pdm sync --prod"
+            run_and_echo(cmd)
+        elif cls.manage_by_poetry(cache=True):
+            run_and_echo("poetry install --only=main")
+        elif cls.get_manage_tool(cache=True) == "uv":
+            run_and_echo("uv sync")
+
 
 class ParseError(Exception):
     """Raise this if parse dependence line error"""
@@ -704,9 +779,9 @@ class UpgradeDependencies(Project, DryRun):
 
     def gen(self: Self) -> str:
         if self._tool == "uv":
-            return "uv lock --upgrade --verbose && uv sync --frozen"
+            return "uv lock --upgrade --verbose && uv sync --frozen --all-groups"
         elif self._tool == "pdm":
-            return "pdm update --verbose && pdm install"
+            return "pdm update --verbose && pdm sync -G :all"
         return self.gen_cmd() + " && poetry lock && poetry update"
 
 
@@ -738,13 +813,17 @@ class GitTag(DryRun):
         return "git push" in self.git_status
 
     def gen(self: Self) -> str:
-        _version = get_current_version(verbose=False)
+        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
         return cmd
 
     @cached_property
@@ -1111,6 +1190,21 @@ def runserver(
         dev(port, host, dry=dry)
 
 
+@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 '|'"""
+    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}")
+            raise Exit(1) from None
+        raise e
+    else:
+        if rc:
+            raise Exit(rc)
+
+
 def main() -> None:
     cli()
 

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

@@ -42,7 +42,7 @@ dependencies = [
     "bumpversion2 >=1.4.3,<2",
     "pytest >=8.2.0,<9",
 ]
-version = "0.16.1"
+version = "0.17.0"
 
 [project.urls]
 Homepage = "https://github.com/waketzheng/fast-dev-cli"
@@ -55,6 +55,11 @@ include-optional-dependencies = [
 [project.scripts]
 fast = "fast_dev_cli:cli.main"
 
+[dependency-groups]
+dev = [
+    "twine>=6.1.0",
+]
+
 [tool.pdm]
 distribution = true
 
@@ -72,6 +77,42 @@ dev = [
     "-e file:///${PROJECT_ROOT}/#egg=fast-dev-cli[all]",
 ]
 
+[tool.pdm.scripts]
+up = "pdm update -G :all"
+tree = "pdm list --tree {args}"
+deps = "pdm run python scripts/deps.py {args}"
+prod = "pdm install --prod --frozen {args}"
+test = "pdm run fast test {args}"
+lint = "pdm run fast lint {args}"
+check = "pdm run fast check {args}"
+tag = "pdm run fast tag {args}"
+bump = "pdm run fast bump patch --commit {args}"
+
+[tool.pdm.scripts.fresh]
+composite = [
+    "up",
+    "deps",
+]
+
+[tool.pdm.scripts.ci]
+composite = [
+    "deps",
+    "check",
+    "test",
+]
+
+[tool.pdm.scripts.start]
+composite = [
+    "pre-commit install",
+    "deps",
+]
+
+[tool.pdm.scripts.style]
+composite = [
+    "ruff format",
+    "ruff check --fix --unsafe-fixes {args}",
+]
+
 [tool.waketzheng._internal-slim-build.packages.fastdevcli-slim.project]
 name = "fastdevcli-slim"
 
@@ -155,6 +196,7 @@ extend-select = [
 ]
 "fast_dev_cli/cli.py" = [
     "UP007",
+    "UP045",
 ]
 
 [tool.bandit]
@@ -164,11 +206,3 @@ exclude_dirs = [
     "examples",
     ".venv",
 ]
-
-[dependency-groups]
-ci = [
-    "coveralls @ git+https://github.com/waketzheng/coveralls-python@4.1.1",
-]
-dev = [
-    "twine>=6.1.0",
-]

fast_dev_cli-0.17.0/scripts/deps.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+"""
+Install deps by `pdm install -G :all --frozen`
+if value of `pdm config use_uv` is True,
+otherwise by the following shells:
+
+    pdm run python -m ensurepip
+    pdm run python -m pip install --upgrade pip
+    pdm run python -m pip install --group dev -e .
+
+Usage::
+    pdm run python scripts/deps.py
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+
+__version__ = "0.1.3"
+__updated_at__ = "2025.07.21"
+SHELL = """
+pdm run python -m ensurepip
+pdm run python -m pip install --upgrade pip
+pdm run python -m pip install --group dev -e .
+"""
+
+
+def run_and_echo(
+    cmd: str,
+    env: dict[str, str] | None = None,
+    dry: bool = False,
+    verbose: bool = True,
+    **kw,
+) -> int:
+    if verbose:
+        print("-->", cmd)
+    if dry:
+        return 0
+    if env is not None:
+        env = dict(os.environ, **env)
+    return subprocess.run(shlex.split(cmd), env=env, **kw).returncode
+
+
+def capture_output(cmd: str) -> str:
+    r = subprocess.run(
+        shlex.split(cmd), capture_output=True, text=True, encoding="utf-8"
+    )
+    return r.stdout.strip()
+
+
+def is_using_uv() -> bool:
+    return capture_output("pdm config use_uv").lower() == "true"
+
+
+def pop_if_contains(args: list[str], flag: str) -> bool:
+    try:
+        index = args.index(flag)
+    except ValueError:
+        return False
+    else:
+        args.pop(index)
+        return True
+
+
+def prefer_pdm(args: list[str]) -> bool:
+    if pop_if_contains(args, "--pip"):
+        return False
+    return platform.system() != "Windows" or is_using_uv()
+
+
+def not_distribution() -> bool:
+    toml = Path(__file__).parent / "pyproject.toml"
+    if not toml.exists():
+        toml = toml.parent.parent / toml.name
+        if not toml.exists():
+            return False
+    if sys.version_info >= (3, 11):
+        import tomllib
+    else:
+        try:
+            import tomli as tomllib
+        except ImportError:
+            return False
+    doc = tomllib.loads(toml.read_text("utf8"))
+    try:
+        return not doc["tool"]["pdm"]["distribution"]
+    except KeyError:
+        ...
+    return False
+
+
+def run_shell(command: str, args: list[str], dry: bool) -> int | None:
+    if args:
+        command += " " + " ".join(i if i.startswith("-") else repr(i) for i in args)
+    if run_and_echo(command, dry=dry) == 0:
+        return None
+    return 1
+
+
+def pip_available() -> bool:
+    rc = run_and_echo(
+        "pdm run python -m pip --version", capture_output=True, verbose=False
+    )
+    return rc == 0
+
+
+def main() -> int | None:
+    args = sys.argv[1:]
+    if len(args) == 1:
+        a1 = args[0]
+        if a1 == "-h" or "--help" in args:
+            print(__doc__)
+            return None
+        elif a1 in ("-v", "--version"):
+            print(__version__)
+            return None
+    dry = pop_if_contains(args, "--dry") or pop_if_contains(args, "--dry-run")
+    if pop_if_contains(args, "--uv"):
+        if os.path.exists("uv.lock"):
+            return run_shell("uv sync --all-extras --all-groups", args, dry)
+        command = (
+            "uv install --all-extras -r pyproject.toml --group dev --no-verify-hashes"
+        )
+        return run_shell(command, args, dry)
+    if prefer_pdm(args):
+        command = "pdm install --frozen -G :all"
+        return run_shell(command, args, dry)
+    shell = SHELL.strip()
+    if pop_if_contains(args, "--no-dev"):
+        shell = shell.replace(" --group dev", "")
+    if args:
+        extras = " ".join(i if i.startswith("-") else repr(i) for i in args)
+        if extras.startswith("-"):
+            shell += " " + extras
+        else:
+            shell += extras  # e.g.: '[xls,fastapi]'
+    elif not_distribution():
+        shell = shell.replace(" -e .", "")
+    cmds = shell.splitlines()
+    if pip_available():  # If pip exists, skip installing it by ensurepip
+        cmds = cmds[1:]
+    for cmd in cmds:
+        if run_and_echo(cmd, dry=dry) != 0:
+            return 1
+    if not dry:
+        print("Done.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -1,6 +1,8 @@
 import os
+import re
 import shutil
 import subprocess
+import sys
 from contextlib import redirect_stdout
 from io import StringIO
 from pathlib import Path
@@ -39,12 +41,14 @@ def test_enum():
 
 
 def _bump_commands(
-    version: str, filename=TOML_FILE, emoji=False
+    version: str, filename=TOML_FILE, emoji=False, add_sync=False
 ) -> tuple[str, str, str]:
     cmd = rf'bumpversion --parse "(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)" --current-version="{version}"'
     suffix = " --commit && git push && git push --tags && git log -1"
     if emoji:
         suffix = suffix.replace("--commit", "--commit --message-emoji=1")
+    if add_sync:
+        cmd = "pdm sync --prod && " + cmd
     patch_without_commit = cmd + f" patch {filename} --allow-dirty"
     patch_with_commit = cmd + f" patch {filename}" + suffix
     minor_with_commit = cmd + f" minor {filename} --tag" + suffix
@@ -99,7 +103,9 @@ def test_bump(
 def test_bump_with_poetry(mocker, tmp_poetry_project, tmp_path):
     mocker.patch("builtins.input", return_value=" ")
     version = get_current_version()
-    patch_without_commit, patch_with_commit, minor_with_commit = _bump_commands(version)
+    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()
@@ -167,7 +173,7 @@ def test_bump_with_emoji(mocker, tmp_path, monkeypatch):
 def test_bump_with_emoji_in_poetry_project(mocker, tmp_path, monkeypatch):
     # real bump
     last_commit = "📝 Update release notes"
-    _, patch_with_commit, __ = _bump_commands("0.1.0", emoji=True)
+    _, patch_with_commit, __ = _bump_commands("0.1.0", emoji=True, add_sync=False)
     with prepare_poetry_project(tmp_path):
         subprocess.run(["git", "init"])
         subprocess.run(["git", "add", "."])
@@ -239,23 +245,41 @@ path = "app/__init__.py"
 """
 
 
-def test_pdm_project(tmp_work_dir):
-    capture_cmd_output("pdm new my-project --non-interactive")
-    with chdir("my-project"):
+@pytest.fixture
+def dynamic_pdm_project(tmp_work_dir):
+    py = "{}.{}".format(*sys.version_info)
+    project = "my-project"
+    capture_cmd_output(f"pdm new {project} --non-interactive --python={py} --no-git")
+    with chdir(project):
         toml_file = Path("pyproject.toml")
         content = toml_file.read_text().replace(
             'version = "0.1.0"', 'dynamic = ["version"]'
         )
-        toml_file.write_text(content)
-        with toml_file.open("a+") as f:
-            f.write(PDM_DYNAMIC_VERSION)
+        toml_file.write_text(content + PDM_DYNAMIC_VERSION)
         app = Path("app")
         app.mkdir()
-        init_file = app.joinpath("__init__.py")
-        init_file.write_text('__version__ = "0.2.0"')
-        out = capture_cmd_output("fast bump patch")
-        assert str(init_file) in out
-        assert "0.2.1" in init_file.read_text()
+        yield app
+
+
+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 "0.2.1" in init_file.read_text()
+
+
+def test_installed_version_is_0_0_0(dynamic_pdm_project):
+    version_file = dynamic_pdm_project / "__init__.py"
+    version_file.write_text('__version__ = "0.0.0"')
+    toml_file = Path("pyproject.toml")
+    text = toml_file.read_text()
+    toml_file.write_text(re.sub(r"(distribution = )false", r"\1true", text))
+    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 "0.3.1" in version_file.read_text()
 
 
 def test_hatch_project(tmp_work_dir):
@@ -365,39 +389,3 @@ build-backend = "pdm.backend"
         out = capture_cmd_output("fast bump patch")
         assert str(version_file) in out
         assert "0.3.1" in version_file.read_text()
-
-
-def test_installed_version_is_0_0_0(tmp_work_dir):
-    project_name = "my-project"
-    package_name = "app"
-    Path(project_name).mkdir()
-    with chdir(project_name):
-        Path(package_name).mkdir()
-        version_file = Path(package_name, "__init__.py")
-        version_file.write_text('__version__ = "0.3.0"')
-        toml_file = Path("pyproject.toml")
-        toml_file.write_text("""
-[project]
-name = "my-project"
-description = ""
-authors = [{name="Waket Zheng", email="waketzheng@gmail.com"}]
-readme = "README.md"
-dynamic = ["version"]
-keywords = []
-requires-python = ">=3.9"
-dependencies = []
-
-[tool.pdm]
-distribution = false
-
-[tool.pdm.version]
-source = "file"
-path = "app/__init__.py"
-
-[build-system]
-requires = ["pdm-backend"]
-build-backend = "pdm.backend"
-        """)
-        out = capture_cmd_output("fast bump patch")
-        assert str(version_file) in out
-        assert "0.3.1" in version_file.read_text()

fast_dev_cli-0.17.0/tests/test_exec.py

@@ -0,0 +1,41 @@
+import pytest
+
+from fast_dev_cli.cli import Exit, capture_cmd_output, run_by_subprocess
+
+
+def test_exec_dry():
+    out = capture_cmd_output('fast exec "echo hello" --dry')
+    assert "--> echo hello" in out
+    assert out.count("hello") == 1
+    out = capture_cmd_output('fast exec "echo hello|grep h" --dry')
+    assert "--> echo hello|grep h" in out
+    assert out.count("hello") == 1
+    out = capture_cmd_output(
+        'fast exec "invalid command" --dry && echo success || echo failed', shell=True
+    )
+    assert "success" in out
+    assert "failed" not in out
+
+
+def test_exec():
+    out = capture_cmd_output('fast exec "echo hello"')
+    assert "--> echo hello" in out
+    assert out.count("hello") == 2
+    out = capture_cmd_output('fast exec "echo hello|grep h"')
+    assert "--> echo hello|grep h" in out
+    assert out.count("hello") == 2
+    out = capture_cmd_output(
+        'fast exec "invalid command" && echo success || echo failed', shell=True
+    )
+    assert "failed" in out
+    assert "success" not in out
+
+
+def test_run_by_subprocess(capsys):
+    with pytest.raises(Exit):
+        run_by_subprocess("python -c 'import sys;sys.exit(1)'")
+    with pytest.raises(Exit, match="1"):
+        run_by_subprocess("not-exit-command")
+    out = capsys.readouterr().out
+    assert "Command not found: not-exit-command" in out
+    assert not run_by_subprocess(f"cat {__file__}|grep xxx")

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

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

{fast_dev_cli-0.16.1 → fast_dev_cli-0.17.0}/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"
+    expected = "uv lock --upgrade --verbose && uv sync --frozen --all-groups"
     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 install"
+    expected = "pdm update --verbose && pdm sync -G :all"
     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.16.1/fast_dev_cli/__init__.py

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