fast-dev-cli 0.14.1__tar.gz → 0.15.0__tar.gz

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/PKG-INFO

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

fast_dev_cli-0.15.0/fast_dev_cli/__init__.py

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

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/fast_dev_cli/cli.py

@@ -8,7 +8,14 @@ import subprocess  # nosec:B404
 import sys
 from functools import cached_property
 from pathlib import Path
-from typing import Literal, Optional, get_args  # Optional is required by typers
+from typing import (
+    Any,
+    Literal,
+    # Optional is required by typers
+    Optional,
+    cast,
+    get_args,
+)
 
 import emoji
 import typer
@@ -38,8 +45,12 @@ else:  # pragma: no cover
 
 
 cli = typer.Typer()
+DryOption = Option(False, "--dry", help="Only print, not really run shell command")
 TOML_FILE = "pyproject.toml"
 ToolName = Literal["poetry", "pdm", "uv"]
+ToolOption = Option(
+    "auto", "--tool", help="Explicit declare manage tool (default to auto detect)"
+)
 
 
 class ShellCommandError(Exception): ...
@@ -52,7 +63,7 @@ def poetry_module_name(name: str) -> str:
     return canonicalize_name(name).replace("-", "_").replace(" ", "_")
 
 
-def load_bool(name: str, default=False) -> bool:
+def load_bool(name: str, default: bool = False) -> bool:
     if not (v := os.getenv(name)):
         return default
     if (lower := v.lower()) in ("0", "false", "f", "off", "no", "n"):
@@ -70,13 +81,15 @@ def is_venv() -> bool:
     )
 
 
-def _run_shell(cmd: list[str] | str, **kw) -> subprocess.CompletedProcess:
+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
 
 
-def run_and_echo(cmd: str, *, dry=False, verbose=True, **kw) -> int:
+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}")
@@ -90,7 +103,9 @@ def check_call(cmd: str) -> bool:
     return r.returncode == 0
 
 
-def capture_cmd_output(command: list[str] | str, *, raises=False, **kw) -> str:
+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)
@@ -99,12 +114,12 @@ def capture_cmd_output(command: list[str] | str, *, raises=False, **kw) -> str:
     return r.stdout.strip() or r.stderr
 
 
-def _parse_version(line: str, pattern: re.Pattern) -> str:
+def _parse_version(line: str, pattern: re.Pattern[str]) -> str:
     return pattern.sub("", line).split("#")[0].strip(" '\"")
 
 
 def read_version_from_file(
-    package_name: str, work_dir=None, toml_text: str | None = None
+    package_name: str, work_dir: Path | None = None, toml_text: str | None = None
 ) -> str:
     if toml_text is None:
         toml_text = Project.load_toml_text()
@@ -135,7 +150,9 @@ def read_version_from_file(
 
 
 def get_current_version(
-    verbose=False, is_poetry: bool | None = None, package_name: str | None = None
+    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()
@@ -163,9 +180,19 @@ def _ensure_bool(value: bool | OptionInfo) -> bool:
     return value
 
 
+def _ensure_str(value: str | OptionInfo) -> str:
+    if not isinstance(value, str):
+        value = getattr(value, "default", "")
+    return value
+
+
 def exit_if_run_failed(
-    cmd: str, env=None, _exit=False, dry=False, **kw
-) -> subprocess.CompletedProcess:
+    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)
@@ -180,7 +207,7 @@ def exit_if_run_failed(
 
 
 class DryRun:
-    def __init__(self: Self, _exit=False, dry=False) -> None:
+    def __init__(self: Self, _exit: bool = False, dry: bool = False) -> None:
         self.dry = dry
         self._exit = _exit
 
@@ -198,7 +225,11 @@ class BumpUp(DryRun):
         major = "major"
 
     def __init__(
-        self: Self, commit: bool, part: str, filename: str | None = None, dry=False
+        self: Self,
+        commit: bool,
+        part: str,
+        filename: str | None = None,
+        dry: bool = False,
     ) -> None:
         self.commit = commit
         self.part = part
@@ -208,9 +239,9 @@ class BumpUp(DryRun):
         super().__init__(dry=dry)
 
     @staticmethod
-    def get_last_commit_message() -> str:
+    def get_last_commit_message(raises: bool = False) -> str:
         cmd = 'git show --pretty=format:"%s" -s HEAD'
-        return capture_cmd_output(cmd)
+        return capture_cmd_output(cmd, raises=raises)
 
     @classmethod
     def should_add_emoji(cls) -> bool:
@@ -218,9 +249,12 @@ class BumpUp(DryRun):
         If last commit message is startswith emoji,
         add a ⬆️ flag at the prefix of bump up commit message.
         """
-        if out := cls.get_last_commit_message():
-            return emoji.is_emoji(out[0])
-        return False
+        try:
+            first_char = cls.get_last_commit_message(raises=True)[0]
+        except (IndexError, ShellCommandError):
+            return False
+        else:
+            return emoji.is_emoji(first_char)
 
     @staticmethod
     def parse_filename() -> str:
@@ -348,7 +382,7 @@ def bump_version(
     commit: bool = Option(
         False, "--commit", "-c", help="Whether run `git commit` after version changed"
     ),
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    dry: bool = DryOption,
 ) -> None:
     """Bump up version string in pyproject.toml"""
     return BumpUp(_ensure_bool(commit), getattr(part, "value", part), dry=dry).run()
@@ -378,7 +412,9 @@ class Project:
         return 'build-backend = "poetry' in text
 
     @staticmethod
-    def work_dir(name: str, parent: Path, depth: int, be_file=False) -> Path | None:
+    def work_dir(
+        name: str, parent: Path, depth: int, be_file: bool = False
+    ) -> Path | None:
         for _ in range(depth):
             if (f := parent.joinpath(name)).exists():
                 if be_file:
@@ -390,10 +426,10 @@ class Project:
     @classmethod
     def get_work_dir(
         cls: type[Self],
-        name=TOML_FILE,
+        name: str = TOML_FILE,
         cwd: Path | None = None,
-        allow_cwd=False,
-        be_file=False,
+        allow_cwd: bool = False,
+        be_file: bool = False,
     ) -> Path:
         cwd = cwd or Path.cwd()
         if d := cls.work_dir(name, cwd, cls.path_depth, be_file):
@@ -403,7 +439,7 @@ class Project:
         raise EnvError(f"{name} not found! Make sure this is a poetry project.")
 
     @classmethod
-    def load_toml_text(cls: type[Self], name=TOML_FILE) -> str:
+    def load_toml_text(cls: type[Self], name: str = TOML_FILE) -> str:
         toml_file = cls.get_work_dir(name, be_file=True)
         return toml_file.read_text("utf8")
 
@@ -420,7 +456,7 @@ class Project:
         else:
             for name in get_args(ToolName):
                 if f"[tool.{name}]" in text:
-                    return name
+                    return cast(ToolName, name)
             # Poetry 2.0 default to not include the '[tool.poetry]' section
             if cls.is_poetry_v2(text):
                 return "poetry"
@@ -446,6 +482,12 @@ class ParseError(Exception):
 
 
 class UpgradeDependencies(Project, DryRun):
+    def __init__(
+        self: Self, _exit: bool = False, dry: bool = False, tool: ToolName = "poetry"
+    ) -> None:
+        super().__init__(_exit, dry)
+        self._tool = tool
+
     class DevFlag(StrEnum):
         new = "[tool.poetry.group.dev.dependencies]"
         old = "[tool.poetry.dev-dependencies]"
@@ -537,7 +579,7 @@ class UpgradeDependencies(Project, DryRun):
         return cls.DevFlag.new in text or cls.DevFlag.old in text
 
     @staticmethod
-    def parse_item(toml_str) -> list[str]:
+    def parse_item(toml_str: str) -> list[str]:
         lines: list[str] = []
         for line in toml_str.splitlines():
             if (line := line.strip()).startswith("["):
@@ -607,20 +649,26 @@ class UpgradeDependencies(Project, DryRun):
         return _upgrade
 
     def gen(self: Self) -> str:
+        if self._tool == "uv":
+            return "uv lock --upgrade --verbose && uv sync --frozen"
+        elif self._tool == "pdm":
+            return "pdm update --verbose && pdm install"
         return self.gen_cmd() + " && poetry lock && poetry update"
 
 
 @cli.command()
 def upgrade(
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    tool: str = ToolOption,
+    dry: bool = DryOption,
 ) -> None:
     """Upgrade dependencies in pyproject.toml to latest versions"""
-    if (tool := Project.get_manage_tool()) == "uv":
-        exit_if_run_failed("uv lock --upgrade && uv sync", dry=dry)
-    elif tool == "pdm":
-        exit_if_run_failed("pdm update && pdm install", dry=dry)
+    if not (tool := _ensure_str(tool)) or tool == ToolOption.default:
+        tool = Project.get_manage_tool() or "uv"
+    if tool in get_args(ToolName):
+        UpgradeDependencies(dry=dry, tool=cast(ToolName, tool)).run()
     else:
-        UpgradeDependencies(dry=dry).run()
+        secho(f"Unknown tool {tool!r}", fg=typer.colors.YELLOW)
+        raise typer.Exit(1)
 
 
 class GitTag(DryRun):
@@ -666,7 +714,7 @@ class GitTag(DryRun):
 @cli.command()
 def tag(
     message: str = Option("", "-m", "--message"),
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    dry: bool = DryOption,
 ) -> None:
     """Run shell command: git tag -a <current-version-in-pyproject.toml> -m {message}"""
     GitTag(message, dry=dry).run()
@@ -675,19 +723,21 @@ def tag(
 class LintCode(DryRun):
     def __init__(
         self: Self,
-        args,
-        check_only=False,
-        _exit=False,
-        dry=False,
-        bandit=False,
-        skip_mypy=False,
-        dmypy=False,
+        args: list[str] | str | None,
+        check_only: bool = False,
+        _exit: bool = False,
+        dry: bool = False,
+        bandit: bool = False,
+        skip_mypy: bool = False,
+        dmypy: bool = False,
+        tool: str = ToolOption.default,
     ) -> None:
         self.args = args
         self.check_only = check_only
         self._bandit = bandit
         self._skip_mypy = skip_mypy
         self._use_dmypy = dmypy
+        self._tool = tool
         super().__init__(_exit, dry)
 
     @staticmethod
@@ -695,7 +745,7 @@ class LintCode(DryRun):
         return check_call("ruff --version")
 
     @staticmethod
-    def prefer_dmypy(paths: str, tools: list[str], use_dmypy=False) -> bool:
+    def prefer_dmypy(paths: str, tools: list[str], use_dmypy: bool = False) -> bool:
         return (
             paths == "."
             and any(t.startswith("mypy") for t in tools)
@@ -705,7 +755,8 @@ class LintCode(DryRun):
     @staticmethod
     def get_package_name() -> str:
         root = Project.get_work_dir(allow_cwd=True)
-        package_maybe = (root.name.replace("-", "_"), "src")
+        module_name = root.name.replace("-", "_").replace(" ", "_")
+        package_maybe = (module_name, "src")
         for name in package_maybe:
             if root.joinpath(name).is_dir():
                 return name
@@ -719,7 +770,10 @@ class LintCode(DryRun):
         bandit: bool = False,
         skip_mypy: bool = False,
         use_dmypy: bool = False,
+        tool: str = ToolOption.default,
     ) -> str:
+        if paths != "." and all(i.endswith(".html") for i in paths.split()):
+            return f"prettier -w {paths}"
         cmd = ""
         tools = ["ruff format", "ruff check --extend-select=I,B,SIM --fix", "mypy"]
         if check_only:
@@ -745,8 +799,11 @@ class LintCode(DryRun):
                     secho(f"{tip}\n\n  {command}\n", fg="yellow")
         else:
             should_run_by_tool = True
-        if should_run_by_tool and (manage_tool := Project.get_manage_tool()):
-            prefix = manage_tool + " run "
+        if should_run_by_tool and tool:
+            if tool == ToolOption.default:
+                tool = Project.get_manage_tool() or ""
+            if tool:
+                prefix = tool + " run "
         if cls.prefer_dmypy(paths, tools, use_dmypy=use_dmypy):
             tools[-1] = "dmypy run"
         cmd += lint_them.format(prefix, paths, *tools)
@@ -763,7 +820,9 @@ class LintCode(DryRun):
         return cmd
 
     def gen(self: Self) -> str:
-        paths = " ".join(map(str, self.args)) if self.args else "."
+        if isinstance(args := self.args, str):
+            args = args.split()
+        paths = " ".join(map(str, args)) if args else "."
         return self.to_cmd(
             paths, self.check_only, self._bandit, self._skip_mypy, self._use_dmypy
         )
@@ -773,15 +832,31 @@ def parse_files(args: list[str] | tuple[str, ...]) -> list[str]:
     return [i for i in args if not i.startswith("-")]
 
 
-def lint(files=None, dry=False, bandit=False, skip_mypy=False, dmypy=False) -> None:
+def lint(
+    files: list[str] | str | None = None,
+    dry: bool = False,
+    bandit: bool = False,
+    skip_mypy: bool = False,
+    dmypy: bool = False,
+    tool: str = ToolOption.default,
+) -> None:
     if files is None:
         files = parse_files(sys.argv[1:])
     if files and files[0] == "lint":
         files = files[1:]
-    LintCode(files, dry=dry, skip_mypy=skip_mypy, bandit=bandit, dmypy=dmypy).run()
+    LintCode(
+        files, dry=dry, skip_mypy=skip_mypy, bandit=bandit, dmypy=dmypy, tool=tool
+    ).run()
 
 
-def check(files=None, dry=False, bandit=False, skip_mypy=False, dmypy=False) -> None:
+def check(
+    files: list[str] | str | None = None,
+    dry: bool = False,
+    bandit: bool = False,
+    skip_mypy: bool = False,
+    dmypy: bool = False,
+    tool: str = ToolOption.default,
+) -> None:
     LintCode(
         files,
         check_only=True,
@@ -790,46 +865,51 @@ def check(files=None, dry=False, bandit=False, skip_mypy=False, dmypy=False) ->
         bandit=bandit,
         skip_mypy=skip_mypy,
         dmypy=dmypy,
+        tool=tool,
     ).run()
 
 
 @cli.command(name="lint")
 def make_style(
-    files: Optional[list[Path]] = typer.Argument(default=None),  # noqa:B008
+    files: Optional[list[str]] = typer.Argument(default=None),  # noqa:B008
     check_only: bool = Option(False, "--check-only", "-c"),
     bandit: bool = Option(False, "--bandit", help="Run `bandit -r <package_dir>`"),
     skip_mypy: bool = Option(False, "--skip-mypy"),
     use_dmypy: bool = Option(
         False, "--dmypy", help="Use `dmypy run` instead of `mypy`"
     ),
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    tool: str = ToolOption,
+    dry: bool = DryOption,
 ) -> None:
     """Run: ruff check/format to reformat code and then mypy to check"""
     if getattr(files, "default", files) is None:
-        files = [Path(".")]
+        files = ["."]
     elif isinstance(files, str):
         files = [files]
     skip = _ensure_bool(skip_mypy)
     dmypy = _ensure_bool(use_dmypy)
     bandit = _ensure_bool(bandit)
+    tool = _ensure_str(tool)
     if _ensure_bool(check_only):
-        check(files, dry=dry, skip_mypy=skip, dmypy=dmypy, bandit=bandit)
+        check(files, dry=dry, skip_mypy=skip, dmypy=dmypy, bandit=bandit, tool=tool)
     else:
-        lint(files, dry=dry, skip_mypy=skip, dmypy=dmypy, bandit=bandit)
+        lint(files, dry=dry, skip_mypy=skip, dmypy=dmypy, bandit=bandit, tool=tool)
 
 
 @cli.command(name="check")
 def only_check(
     bandit: bool = Option(False, "--bandit", help="Run `bandit -r <package_dir>`"),
     skip_mypy: bool = Option(False, "--skip-mypy"),
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    dry: bool = DryOption,
 ) -> None:
     """Check code style without reformat"""
     check(dry=dry, bandit=bandit, skip_mypy=_ensure_bool(skip_mypy))
 
 
 class Sync(DryRun):
-    def __init__(self: Self, filename: str, extras: str, save: bool, dry=False) -> None:
+    def __init__(
+        self: Self, filename: str, extras: str, save: bool, dry: bool = False
+    ) -> None:
         self.filename = filename
         self.extras = extras
         self._save = save
@@ -868,12 +948,12 @@ class Sync(DryRun):
 
 @cli.command()
 def sync(
-    filename="dev_requirements.txt",
+    filename: str = "dev_requirements.txt",
     extras: str = Option("", "--extras", "-E"),
     save: bool = Option(
         False, "--save", "-s", help="Whether save the requirement file"
     ),
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    dry: bool = DryOption,
 ) -> None:
     """Export dependencies by poetry to a txt file then install by pip."""
     Sync(filename, extras, save, dry=dry).run()
@@ -886,7 +966,7 @@ def _should_run_test_script(path: Path = Path("scripts")) -> Path | None:
     return None
 
 
-def test(dry: bool, ignore_script=False) -> None:
+def test(dry: bool, ignore_script: bool = False) -> None:
     cwd = Path.cwd()
     root = Project.get_work_dir(cwd=cwd, allow_cwd=True)
     script_dir = root / "scripts"
@@ -907,7 +987,7 @@ def test(dry: bool, ignore_script=False) -> None:
 
 @cli.command(name="test")
 def coverage_test(
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    dry: bool = DryOption,
     ignore_script: bool = Option(False, "--ignore-script", "-i"),
 ) -> None:
     """Run unittest by pytest and report coverage"""
@@ -930,7 +1010,7 @@ class Publish:
 
 @cli.command()
 def upload(
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    dry: bool = DryOption,
 ) -> None:
     """Shortcut for package publish"""
     cmd = Publish.gen()
@@ -941,13 +1021,13 @@ def dev(
     port: int | None | OptionInfo,
     host: str | None | OptionInfo,
     file: str | None | ArgumentInfo = None,
-    dry=False,
+    dry: bool = False,
 ) -> None:
     cmd = "fastapi dev"
     no_port_yet = True
     if file is not None:
         try:
-            port = int(str(file))  # type:ignore[arg-type]
+            port = int(str(file))
         except ValueError:
             cmd += f" {file}"
         else:
@@ -969,7 +1049,7 @@ def runserver(
     file_or_port: Optional[str] = typer.Argument(default=None),
     port: Optional[int] = Option(None, "-p", "--port"),
     host: Optional[str] = Option(None, "-h", "--host"),
-    dry: bool = Option(False, "--dry", help="Only print, not really run shell command"),
+    dry: bool = DryOption,
 ) -> None:
     """Start a fastapi server(only for fastapi>=0.111.0)"""
     if getattr(file_or_port, "default", file_or_port):

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/pyproject.toml

@@ -41,7 +41,7 @@ dependencies = [
     "pytest >=8.2.0,<9",
     "packaging>=20.5",
 ]
-version = "0.14.1"
+version = "0.15.0"
 
 [project.urls]
 Homepage = "https://github.com/waketzheng/fast-dev-cli"
@@ -124,6 +124,7 @@ pretty = true
 python_version = "3.9"
 ignore_missing_imports = true
 check_untyped_defs = true
+warn_unused_ignores = true
 exclude = [
     "^fabfile\\.py$",
     "two\\.pyi$",

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/tests/test_bump.py

@@ -1,4 +1,5 @@
 import os
+import shutil
 import subprocess
 from contextlib import redirect_stdout
 from io import StringIO
@@ -17,10 +18,11 @@ from fast_dev_cli.cli import (
     StrEnum,
     bump,
     bump_version,
+    capture_cmd_output,
     get_current_version,
 )
 
-from .utils import chdir, mock_sys_argv
+from .utils import chdir, mock_sys_argv, prepare_poetry_project
 
 
 def test_enum():
@@ -53,12 +55,14 @@ def test_bump_dry(mocker):
     mocker.patch("fast_dev_cli.cli.Project.manage_by_poetry", return_value=True)
     with pytest.raises(ShellCommandError):
         get_current_version()
-    # TODO:
-    # version = get_current_version()
-    # patch_without_commit, patch_with_commit, minor_with_commit = _bump_commands(version)
-    # assert BumpUp(part="patch", commit=False, dry=True).gen() == patch_without_commit
-    # assert BumpUp(part="patch", commit=True, dry=True).gen() == patch_with_commit
-    # assert BumpUp(part="minor", commit=True, dry=True).gen() == minor_with_commit
+    mocker.patch("fast_dev_cli.cli.Project.manage_by_poetry", return_value=False)
+    version = get_current_version()
+    patch_without_commit, patch_with_commit, minor_with_commit = _bump_commands(
+        version, filename="fast_dev_cli/__init__.py"
+    )
+    assert BumpUp(part="patch", commit=False, dry=True).gen() == patch_without_commit
+    assert BumpUp(part="patch", commit=True, dry=True).gen() == patch_with_commit
+    assert BumpUp(part="minor", commit=True, dry=True).gen() == minor_with_commit
 
 
 def test_bump(
@@ -145,36 +149,46 @@ def test_bump_with_emoji(mocker, tmp_path, monkeypatch):
     mocker.patch("fast_dev_cli.cli.Project.manage_by_poetry", return_value=True)
     with pytest.raises(ShellCommandError):
         get_current_version()
-    # TODO:
-    # version = get_current_version()
-    # patch_without_commit, patch_with_commit, minor_with_commit = _bump_commands(
-    #     version, emoji=True
-    # )
-    # last_commit = "📝 Update release notes"
-    # mocker.patch(
-    #     "fast_dev_cli.cli.BumpUp.get_last_commit_message",
-    #     return_value=last_commit,
-    # )
-    # assert BumpUp(part="patch", commit=False, dry=True).gen() == patch_without_commit
-    # assert BumpUp(part="patch", commit=True, dry=True).gen() == patch_with_commit
-    # assert BumpUp(part="minor", commit=True, dry=True).gen() == minor_with_commit
+    mocker.patch("fast_dev_cli.cli.Project.manage_by_poetry", return_value=False)
+    version = get_current_version()
+    patch_without_commit, patch_with_commit, minor_with_commit = _bump_commands(
+        version, filename="fast_dev_cli/__init__.py", emoji=True
+    )
+    last_commit = "📝 Update release notes"
+    mocker.patch(
+        "fast_dev_cli.cli.BumpUp.get_last_commit_message",
+        return_value=last_commit,
+    )
+    assert BumpUp(part="patch", commit=False, dry=True).gen() == patch_without_commit
+    assert BumpUp(part="patch", commit=True, dry=True).gen() == patch_with_commit
+    assert BumpUp(part="minor", commit=True, dry=True).gen() == minor_with_commit
+
+
+def test_bump_with_emoji_in_poetry_project(mocker, tmp_path, monkeypatch):
     # real bump
-    # with chdir(tmp_path):
-    #     project = "foo"
-    #     subprocess.run(["poetry", "new", project])
-    #     with chdir(tmp_path / project):
-    #         subprocess.run(["git", "init"])
-    #         subprocess.run(["git", "add", "."])
-    #         subprocess.run(["git", "commit", "-m", last_commit])
-    #         monkeypatch.setenv("DONT_GIT_PUSH", "1")
-    #         command = BumpUp(part="patch", commit=True).gen()
-    #         expected = patch_with_commit.split("&&")[0].strip().replace('""', '"0.1.0"')
-    #         assert expected == command
-    #         subprocess.run(["poetry", "run", "pip", "install", "bumpversion2"])
-    #         subprocess.run(["fast", "bump", "patch", "--commit"])
-    #         out = capture_cmd_output(["git", "log"])
-    # new_commit = "⬆️  Bump version: 0.1.0 → 0.1.1"
-    # assert new_commit in out
+    last_commit = "📝 Update release notes"
+    _, patch_with_commit, __ = _bump_commands("0.1.0", emoji=True)
+    with prepare_poetry_project(tmp_path):
+        subprocess.run(["git", "init"])
+        subprocess.run(["git", "add", "."])
+        subprocess.run(["git", "config", "user.name", "sb"])
+        subprocess.run(["git", "config", "user.email", "sb@foo.com"])
+        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()
+        expected = patch_with_commit.split("&&")[0].strip().replace('""', '"0.1.0"')
+        assert expected == command
+        subprocess.run(["poetry", "run", "pip", "install", "bumpversion2"])
+        subprocess.run(["fast", "bump", "patch", "--commit"])
+        out = capture_cmd_output(["git", "log"])
+        assert BumpUp.should_add_emoji()
+        Path("a.txt").touch()
+        subprocess.run(["git", "add", "."])
+        subprocess.run(["git", "commit", "-m", "no emoji"])
+        assert BumpUp.should_add_emoji() is False
+    new_commit = "⬆️  Bump version: 0.1.0 → 0.1.1"
+    assert new_commit in out
 
 
 def test_bump_with_uv(tmp_path):
@@ -187,3 +201,32 @@ def test_bump_with_uv(tmp_path):
         Path(TOML_FILE).write_text("[project]" + os.linesep + 'version = "0.1.0"')
         command = BumpUp(part="patch", commit=True).gen()
         assert TOML_FILE in command
+
+
+def test_parse_filename(tmp_path):
+    pyproject = """
+[tool.poetry]
+version = "0"
+    """
+    project_dir = tmp_path / "helloworld"
+    project_dir.mkdir()
+    with chdir(project_dir):
+        toml_file = project_dir.joinpath(TOML_FILE)
+        toml_file.write_text(pyproject)
+        src_dir = project_dir / project_dir.name
+        src_dir.mkdir()
+        init_file = src_dir / "__init__.py"
+        init_file.write_text('__version__ = "0.1.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"
+        toml_file.write_text(pyproject.strip() + '\npackages=[{include="hello"}]')
+        assert BumpUp.parse_filename() == "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"

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/tests/test_functions.py

@@ -1,6 +1,7 @@
 import os
 from contextlib import redirect_stdout
 from io import StringIO
+from pathlib import Path
 
 import pytest
 import typer
@@ -16,6 +17,8 @@ from fast_dev_cli.cli import (
     run_and_echo,
 )
 
+from .utils import prepare_poetry_project
+
 
 def test_utils(capsys):
     # parse files
@@ -64,19 +67,15 @@ def test_run_shell():
     # current version
     with pytest.raises(ShellCommandError):
         get_current_version(True, is_poetry=True)
-    # TODO: add [tool.poetry] to pyproject.toml
-    # stream = StringIO()
-    # write_to_stream = redirect_stdout(stream)
-    # with write_to_stream:
-    #     get_current_version(True, is_poetry=True)
-    # assert "poetry version -s" in stream.getvalue()
 
     name = "TEST_EXIT_IF_RUN_FAILED"
     value = "foo"
     cmd = 'python -c "import os;print(list(os.environ))"'
     with redirect_stdout(StringIO()):
-        r = exit_if_run_failed(cmd, env={name: value}, capture_output=True)
-    assert name in r.stdout.decode()
+        r = exit_if_run_failed(
+            cmd, env={name: value}, capture_output=True, encoding="utf-8"
+        )
+    assert name in r.stdout
 
     assert run_and_echo("echo foo", capture_output=True) == 0
 
@@ -92,6 +91,15 @@ def test_run_shell():
         A().run()
 
 
+def test_get_version_in_poetry_project(tmp_path: Path):
+    with prepare_poetry_project(tmp_path):
+        stream = StringIO()
+        write_to_stream = redirect_stdout(stream)
+        with write_to_stream:
+            get_current_version(True, is_poetry=True)
+    assert "poetry version -s" in stream.getvalue()
+
+
 def test_ensure_bool():
     assert _ensure_bool(True) is True
     assert _ensure_bool(False) is False

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/tests/test_lint.py

@@ -65,7 +65,7 @@ def test_check(mock_no_dmypy, monkeypatch, mocker):
     for cmd in CHECK_CMD.split(SEP):
         assert cmd in command
     command2 = capture_cmd_output("fast check --bandit --dry")
-    assert command2 == command + " && bandit -r fast_dev_cli"
+    assert command2 == command + " && bandit -c pyproject.toml -r ."
     monkeypatch.setenv("FASTDEVCLI_BANDIT", "1")
     command3 = capture_cmd_output("fast check --dry")
     assert command3 == command2
@@ -82,10 +82,21 @@ def test_check_bandit(tmp_path):
     src_dir = package_path / "src"
     if not src_dir.exists():  # For poetry<2.1
         src_dir = src_dir.parent / package_path.name
+    with chdir(package_path):
+        package_name = src_dir.name
+        assert f"bandit -r {package_name}" in LintCode.to_cmd(bandit=True)
+        toml_file = Path(TOML_FILE)
+        content = toml_file.read_text()
+        toml_file.write_text(content + '\n[tool.bandit]\nexclude_dirs = ["tests"]')
+        assert f"bandit -c {TOML_FILE} -r ." in LintCode.to_cmd(bandit=True)
     shutil.rmtree(src_dir)
     with chdir(package_path):
+        assert LintCode.get_package_name() == "."
         command = capture_cmd_output("fast check --bandit --dry")
-    assert "bandit -r ." in command
+        assert f"bandit -c {TOML_FILE} -r ." in command
+        toml_file.write_text(content)
+        command = capture_cmd_output("fast check --bandit --dry")
+        assert "bandit -r ." in command
 
 
 def test_check_skip_mypy(mock_skip_mypy_0, mocker, capsys):
@@ -132,6 +143,23 @@ def test_lint_cmd(mock_no_dmypy):
     )
 
 
+def test_lint_html():
+    run = "pdm run "
+    lint_cmd = f"{run}python fast_dev_cli/cli.py lint"
+    command = capture_cmd_output(f"{lint_cmd} index.html --dry")
+    assert "prettier -w index.html" in command
+    command = capture_cmd_output(f"{lint_cmd} index.html flv.html --dry")
+    assert "prettier -w index.html flv.html" in command
+    cmd = "fast lint index.html --dry"
+    assert "prettier -w index.html" in capture_cmd_output(cmd)
+    assert "prettier -w index.html" in capture_cmd_output("pdm run " + cmd)
+    cmd = "fast lint index.html flv.html --dry"
+    assert "prettier -w index.html flv.html" in capture_cmd_output(cmd)
+    assert "prettier -w index.html flv.html" in capture_cmd_output("pdm run " + cmd)
+    assert LintCode.to_cmd("index.html") == "prettier -w index.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"
@@ -141,20 +169,29 @@ def test_lint_by_global_fast():
 
 
 def test_with_dmypy():
-    command = capture_cmd_output("fast lint --dmypy --dry .")
+    cmd = "fast lint --dmypy --dry ."
+    assert "dmypy run ." in capture_cmd_output(cmd)
+    assert "dmypy run ." in capture_cmd_output("pdm run " + cmd)
+    command = LintCode.to_cmd(use_dmypy=True, tool="pdm")
     assert "dmypy run ." in command
+    command = LintCode.to_cmd(use_dmypy=False, tool="pdm")
+    assert "dmypy run ." not in command
 
 
 def test_dmypy_run(monkeypatch):
+    command = capture_cmd_output("python -m fast_dev_cli lint --dry .")
+    assert "dmypy run ." not in command
     monkeypatch.setenv("FASTDEVCLI_DMYPY", "1")
     command = capture_cmd_output("python -m fast_dev_cli lint --dry .")
     assert "dmypy run ." in command
+    command = capture_cmd_output("python -m fast_dev_cli lint --skip-mypy --dry .")
+    assert "dmypy run ." not in command
 
 
 def test_lint_with_prefix(mocker):
     mocker.patch("fast_dev_cli.cli.is_venv", return_value=False)
     with capture_stdout() as stream:
-        make_style([Path(".")], check_only=False, dry=True)
+        make_style(["."], check_only=False, dry=True)
     assert "pdm run" in stream.getvalue()
 
 
@@ -164,13 +201,13 @@ def test_make_style(mock_skip_mypy_0, mocker, mock_no_dmypy):
         make_style(check_only=False, dry=True)
     assert LINT_CMD in stream.getvalue()
     with capture_stdout() as stream:
-        make_style([Path(".")], check_only=False, dry=True)
+        make_style(["."], check_only=False, dry=True)
     assert LINT_CMD in stream.getvalue()
     with capture_stdout() as stream:
         make_style(".", check_only=False, dry=True)  # type:ignore[arg-type]
     assert LINT_CMD in stream.getvalue()
     with capture_stdout() as stream:
-        make_style([Path(".")], check_only=True, dry=True)
+        make_style(["."], check_only=True, dry=True)
     assert CHECK_CMD in stream.getvalue()
     with capture_stdout() as stream:
         only_check(dry=True)
@@ -287,3 +324,24 @@ def test_get_manage_tool(tmp_path):
         assert Project.get_manage_tool() == "pdm"
         Path(TOML_FILE).write_text("[tool.uv]")
         assert Project.get_manage_tool() == "uv"
+
+
+class TestGetPackageName:
+    project = "hello-world"
+
+    def test_get_package_name(self, tmp_path):
+        project_dir = tmp_path / self.project
+        project_dir.mkdir()
+        module_name = project_dir.name.replace("-", "_").replace(" ", "_")
+        with chdir(project_dir):
+            Path(TOML_FILE).touch()
+            Path(module_name).mkdir()
+            assert LintCode.get_package_name() == module_name
+            Path("src").mkdir()
+            assert LintCode.get_package_name() == module_name
+            shutil.rmtree(module_name)
+            assert LintCode.get_package_name() == "src"
+
+
+class TestGetPackageNameWithSpace(TestGetPackageName):
+    project = "hello world"

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/tests/test_upgrade.py

@@ -6,9 +6,14 @@ from contextlib import redirect_stdout
 from io import StringIO
 from pathlib import Path
 
+import pytest
+import typer
+
+import fast_dev_cli
 from fast_dev_cli.cli import (
     TOML_FILE,
     UpgradeDependencies,
+    capture_cmd_output,
     run_and_echo,
     upgrade,
 )
@@ -283,3 +288,34 @@ fastapi = "^0.112.2"
         [],
         "--dev",
     )
+
+
+def test_upgrade_uv_project():
+    cmd = "fast upgrade --tool=uv --dry"
+    expected = "uv lock --upgrade --verbose && uv sync --frozen"
+    assert expected in capture_cmd_output(cmd)
+    assert expected in capture_cmd_output("pdm run " + cmd)
+    assert UpgradeDependencies(tool="uv").gen() == expected
+
+
+def test_upgrade_pdm_project():
+    cmd = "fast upgrade --tool=pdm --dry"
+    expected = "pdm update --verbose && pdm install"
+    assert expected in capture_cmd_output(cmd)
+    assert expected in capture_cmd_output("pdm run " + cmd)
+    assert UpgradeDependencies(tool="pdm").gen() == expected
+
+
+def test_upgrade_unknown_tool(mocker):
+    cmd = "fast upgrade --tool=hatch --dry"
+    expected = "Unknown tool 'hatch'"
+    assert expected in capture_cmd_output(cmd)
+    assert expected in capture_cmd_output("pdm run " + cmd)
+    assert run_and_echo(cmd, verbose=False) == 1
+    assert run_and_echo("pdm run " + cmd, verbose=False) == 1
+    mocker.patch("fast_dev_cli.cli.secho")
+    with pytest.raises(typer.Exit):
+        upgrade(tool="pipenv")
+    fast_dev_cli.cli.secho.assert_called_once_with(  # type:ignore
+        "Unknown tool 'pipenv'", fg=typer.colors.YELLOW
+    )

{fast_dev_cli-0.14.1 → fast_dev_cli-0.15.0}/tests/utils.py

@@ -1,27 +1,25 @@
 import os
+import subprocess
 import sys
-from contextlib import contextmanager, redirect_stdout
+from contextlib import AbstractContextManager, contextmanager, redirect_stdout
 from io import StringIO
 from pathlib import Path
 
-if sys.version_info >= (3, 11):
-    from contextlib import chdir  # type:ignore[attr-defined]
-else:
-    from contextlib import AbstractContextManager
 
-    class chdir(AbstractContextManager):  # type:ignore[no-redef]
-        """Non thread-safe context manager to change the current working directory."""
+# 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 __init__(self, path):
+        self.path = path
+        self._old_cwd = []
 
-        def __enter__(self):
-            self._old_cwd.append(os.getcwd())
-            os.chdir(self.path)
+    def __enter__(self):
+        self._old_cwd.append(os.getcwd())
+        os.chdir(self.path)
 
-        def __exit__(self, *excinfo):
-            os.chdir(self._old_cwd.pop())
+    def __exit__(self, *excinfo):
+        os.chdir(self._old_cwd.pop())
 
 
 __all__ = (
@@ -66,3 +64,12 @@ def temp_file(name: str, text=""):
     yield
     if path.exists():
         path.unlink()
+
+
+@contextmanager
+def prepare_poetry_project(tmp_path: Path):
+    with chdir(tmp_path):
+        project = "foo"
+        subprocess.run(["poetry", "new", project])
+        with chdir(tmp_path / project):
+            yield

fast_dev_cli-0.14.1/fast_dev_cli/__init__.py

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