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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fast-dev-cli
-Version: 0.16.2
+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.16.2 → fast_dev_cli-0.17.1}/fast_dev_cli/cli.py

@@ -10,29 +10,20 @@ 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
     Optional,
     cast,
     get_args,
+    overload,
 )
 
 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
@@ -42,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"]
@@ -64,7 +59,10 @@ ToolOption = Option(
 )
 
 
-class ShellCommandError(Exception): ...
+class FastDevCliError(Exception): ...
+
+
+class ShellCommandError(FastDevCliError): ...
 
 
 def poetry_module_name(name: str) -> str:
@@ -79,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
@@ -111,7 +121,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:
@@ -148,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*=")
@@ -177,33 +190,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:
@@ -239,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)
 
 
@@ -257,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
@@ -317,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()
@@ -390,8 +437,8 @@ class BumpUp(DryRun):
             echo(f"Invalid part: {s!r}")
             raise Exit(1) from e
 
-    def gen(self: Self) -> str:
-        _version = get_current_version()
+    def gen(self) -> str:
+        should_sync, _version = get_current_version(check_version=True)
         filename = self.filename
         echo(f"Current version(@{filename}): {_version}")
         if self.part:
@@ -407,17 +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 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
 
-    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)
@@ -429,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")
@@ -438,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:
@@ -453,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):
@@ -462,6 +535,7 @@ class EnvError(Exception):
 
 class Project:
     path_depth = 5
+    _tool: ToolName | None = None
 
     @staticmethod
     def is_poetry_v2(text: str) -> bool:
@@ -492,7 +566,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:
@@ -500,22 +574,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
@@ -531,14 +623,40 @@ class Project:
         return root
 
     @classmethod
-    def is_pdm_project(cls, strict: bool = True) -> bool:
-        if cls.get_manage_tool() != "pdm":
+    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 get_sync_command(cls, prod: bool = True, doc: dict | None = None) -> str:
+        if cls.is_pdm_project():
+            return "pdm sync" + " --prod" * prod
+        elif cls.manage_by_poetry(cache=True):
+            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":
+            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):
     """Raise this if parse dependence line error"""
@@ -548,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
@@ -713,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"
 
 
@@ -737,34 +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:
-        _version = get_current_version(verbose=False)
+    def gen(self) -> str:
+        should_sync, _version = get_current_version(verbose=False, check_version=True)
         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
         ):
@@ -773,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")
 
@@ -781,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,
@@ -855,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"'
@@ -870,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)
@@ -886,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 "."
@@ -975,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
@@ -1124,6 +1263,41 @@ 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 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()