fast-dev-cli 0.10.0__tar.gz → 0.11.0__tar.gz

{fast_dev_cli-0.10.0 → fast_dev_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fast-dev-cli
-Version: 0.10.0
+Version: 0.11.0
 Summary: Python project development tool.
 Author-Email: Waket Zheng <waketzheng@gmail.com>>
 Classifier: Development Status :: 4 - Beta
@@ -78,9 +78,9 @@ Python 3.10+
 <div class="termy">
 
 ```bash
-pip install "fast-dev-cli"
+pip install fast-dev-cli
 ```
-*Will install: fast-dev-cli typer ruff mypy bumpversion pytest coverage*
+*Will install: fast-dev-cli emoji typer ruff mypy bumpversion2 pytest coverage*
 
 </div>
 

{fast_dev_cli-0.10.0 → fast_dev_cli-0.11.0}/README.md

@@ -43,9 +43,9 @@ Python 3.10+
 <div class="termy">
 
 ```bash
-pip install "fast-dev-cli"
+pip install fast-dev-cli
 ```
-*Will install: fast-dev-cli typer ruff mypy bumpversion pytest coverage*
+*Will install: fast-dev-cli emoji typer ruff mypy bumpversion2 pytest coverage*
 
 </div>
 

fast_dev_cli-0.11.0/fast_dev_cli/__init__.py

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

fast_dev_cli-0.11.0/fast_dev_cli/__main__.py

@@ -0,0 +1,3 @@
+from fast_dev_cli.cli import main
+
+main()

{fast_dev_cli-0.10.0 → fast_dev_cli-0.11.0}/fast_dev_cli/cli.py

@@ -8,7 +8,7 @@ import subprocess  # nosec:B404
 import sys
 from functools import cached_property
 from pathlib import Path
-from typing import Literal, Optional, Type
+from typing import Literal, Optional, Type, TypeAlias
 
 import emoji
 import typer
@@ -37,8 +37,9 @@ else:  # pragma: no cover
         __str__ = str.__str__
 
 
-TOML_FILE = "pyproject.toml"
 cli = typer.Typer()
+TOML_FILE = "pyproject.toml"
+ToolName: TypeAlias = Literal["poetry", "pdm", "uv", ""]
 
 
 def load_bool(name: str, default=False) -> bool:
@@ -86,15 +87,55 @@ def capture_cmd_output(command: list[str] | str, **kw) -> str:
     return r.stdout.strip().decode()
 
 
+def _parse_version(line: str, pattern: re.Pattern) -> str:
+    return pattern.sub("", line).split("#")[0].strip(" '\"")
+
+
+def read_version_from_file(
+    package_name: str, work_dir=None, toml_text: str | None = None
+) -> str:
+    if toml_text is None:
+        toml_text = Project.load_toml_text()
+    pattern = re.compile(r"version\s*=")
+    invalid = ("0", "0.0.0")
+    for line in toml_text.splitlines():
+        if pattern.match(line):
+            version = _parse_version(line, pattern)
+            if version.startswith("{") or version in invalid:
+                break
+            return version
+    if work_dir is None:
+        work_dir = Project.get_work_dir()
+    package_dir = work_dir / package_name
+    init_file = package_dir / "__init__.py"
+    if not init_file.exists():
+        init_file = work_dir / "app" / init_file.name
+        if not init_file.exists():
+            secho("WARNING: __init__.py file does not exist!")
+            return "0.0.0"
+    pattern = re.compile(r"__version__\s*=")
+    for line in init_file.read_text().splitlines():
+        if pattern.match(line):
+            return _parse_version(line, pattern)
+    secho(f"WARNING: can not find '__version__' var in {init_file}!")
+    return "0.0.0"
+
+
 def get_current_version(
-    verbose=False,
-    is_poetry: bool | None = None,
-    package_name=Path(__file__).parent.name,
+    verbose=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:
-        return importlib_metadata.version(package_name)
+        work_dir = None
+        if package_name is None:
+            work_dir = Project.get_work_dir()
+            package_name = re.sub(r"[- ]", "_", work_dir.name)
+        try:
+            return importlib_metadata.version(package_name)
+        except importlib_metadata.PackageNotFoundError:
+            return read_version_from_file(package_name, work_dir)
+
     cmd = ["poetry", "version", "-s"]
     if verbose:
         echo(f"--> {' '.join(cmd)}")
@@ -182,7 +223,7 @@ class BumpUp(DryRun):
             version_value = context["tool"]["poetry"]["version"]
         except KeyError:
             return TOML_FILE
-        if version_value == "0":
+        if version_value in ("0", "0.0.0"):
             try:
                 package_item = context["tool"]["poetry"]["packages"]
             except KeyError:
@@ -321,16 +362,16 @@ class Project:
         return "[tool.poetry]" in cls.load_toml_text()
 
     @classmethod
-    def get_manage_tool(cls: Type[Self]) -> Literal["poetry", "pdm", ""]:
+    def get_manage_tool(cls: Type[Self]) -> ToolName:
         try:
             text = cls.load_toml_text()
         except EnvError:
             pass
         else:
-            if "[tool.poetry]" in text:
-                return "poetry"
-            elif "[tool.pdm]" in text:
-                return "pdm"
+            name: ToolName
+            for name in ("poetry", "pdm", "uv"):
+                if f"[tool.{name}]" in text:
+                    return name
         return ""
 
     @staticmethod
@@ -592,6 +633,15 @@ class LintCode(DryRun):
             and not load_bool("NO_DMYPY")
         )
 
+    @staticmethod
+    def get_package_name() -> str:
+        root = Project.get_work_dir(allow_cwd=True)
+        package_maybe = (root.name.replace("-", "_"), "src")
+        for name in package_maybe:
+            if root.joinpath(name).is_dir():
+                return name
+        return "."
+
     @classmethod
     def to_cmd(cls: Type[Self], paths=".", check_only=False, bandit=False) -> str:
         cmd = ""
@@ -611,7 +661,7 @@ class LintCode(DryRun):
         if is_venv():
             if not cls.check_lint_tool_installed():
                 should_run_by_tool = True
-                if check_call("python -c 'import fast_dev_cli'"):
+                if check_call('python -c "import fast_dev_cli"'):
                     command = 'python -m pip install -U "fast_dev_cli"'
                     tip = "You may need to run following command to install lint tools:"
                     secho(f"{tip}\n\n  {command}\n", fg="yellow")
@@ -625,15 +675,7 @@ class LintCode(DryRun):
         if bandit or load_bool("FASTDEVCLI_BANDIT"):
             command = prefix + "bandit"
             if paths == ".":  # fast check --bandit
-                command += " -r"
-                root = Project.get_work_dir(allow_cwd=True)
-                package_maybe = (root.name.replace("-", "_"), "src")
-                for name in package_maybe:
-                    if root.joinpath(name).is_dir():
-                        command += " " + name
-                        break
-                else:
-                    command += " ."
+                command += " -r " + cls.get_package_name()
                 cmd += " && " + command
         return cmd
 
@@ -694,18 +736,31 @@ class Sync(DryRun):
     def gen(self) -> str:
         extras, save = self.extras, self._save
         should_remove = not Path.cwd().joinpath(self.filename).exists()
-        prefix = "" if is_venv() else "poetry run "
-        install_cmd = (
-            "poetry export --with=dev --without-hashes -o {0}"
-            " && {1}pip install -r {0}"
-        )
-        if not UpgradeDependencies.should_with_dev():
-            install_cmd = install_cmd.replace(" --with=dev", "")
-        if extras and isinstance(extras, str | list):
-            install_cmd = install_cmd.replace("export", f"export --{extras=}")
+        if not (tool := Project.get_manage_tool()):
+            if should_remove or not is_venv():
+                raise EnvError("There project is not managed by uv/pdm/poetry!")
+            return f"python -m pip install -r {self.filename}"
+        prefix = "" if is_venv() else f"{tool} run "
+        ensurepip = " {1}python -m ensurepip && {1}python -m pip install -U pip &&"
+        match tool:
+            case "uv":
+                export_cmd = "uv export --no-hashes --all-extras --frozen"
+                if check_call(prefix + "python -m pip --version"):
+                    ensurepip = ""
+            case "poetry" | "pdm":
+                export_cmd = f"{tool} export --without-hashes --with=dev"
+                if tool == "poetry":
+                    ensurepip = ""
+                    if not UpgradeDependencies.should_with_dev():
+                        export_cmd = export_cmd.replace(" --with=dev", "")
+                    if extras and isinstance(extras, str | list):
+                        export_cmd += f" --{extras=}".replace("'", '"')
+                elif check_call(prefix + "python -m pip --version"):
+                    ensurepip = ""
+        install_cmd = "{2} -o {0} &&%s {1}python -m pip install -r {0}" % ensurepip
         if should_remove and not save:
             install_cmd += " && rm -f {0}"
-        return install_cmd.format(self.filename, prefix)
+        return install_cmd.format(self.filename, prefix, export_cmd)
 
 
 @cli.command()
@@ -721,16 +776,21 @@ def sync(
     Sync(filename, extras, save, dry=dry).run()
 
 
-def _should_run_test_script(path: Path = Path("scripts/test.sh")) -> bool:
-    return path.exists()
+def _should_run_test_script(path: Path = Path("scripts")) -> Path | None:
+    for name in ("test.sh", "test.py"):
+        if (file := path / name).exists():
+            return file
+    return None
 
 
 def test(dry: bool, ignore_script=False) -> None:
     cwd = Path.cwd()
     root = Project.get_work_dir(cwd=cwd, allow_cwd=True)
-    test_script = root / "scripts" / "test.sh"
-    if not _ensure_bool(ignore_script) and _should_run_test_script(test_script):
-        cmd = f"sh {os.path.relpath(test_script, root)}"
+    script_dir = root / "scripts"
+    if not _ensure_bool(ignore_script) and (
+        test_script := _should_run_test_script(script_dir)
+    ):
+        cmd = f"{os.path.relpath(test_script, root)}"
         if cwd != root:
             cmd = f"cd {root} && " + cmd
     else:

{fast_dev_cli-0.10.0 → fast_dev_cli-0.11.0}/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "bumpversion2 >=1.4.2,<2",
     "pytest >=8.2.0,<9",
 ]
-version = "0.10.0"
+version = "0.11.0"
 
 [project.urls]
 Homepage = "https://github.com/waketzheng/fast-dev-cli"

fast_dev_cli-0.11.0/scripts/check.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+import os
+import sys
+
+parent = os.path.abspath(os.path.dirname(__file__))
+work_dir = os.path.dirname(parent)
+if os.getcwd() != work_dir:
+    os.chdir(work_dir)
+
+if os.system("pdm run fast check") != 0:
+    print("\033[1m Please run './scripts/format.py' to auto-fix style issues \033[0m")
+    sys.exit(1)
+
+package_name = os.path.basename(work_dir).replace("-", "_")
+cmd = "pdm run bandit -r {}".format(package_name)
+print("-->", cmd)
+if os.system(cmd) != 0:
+    sys.exit(1)
+print("Done. ✨ 🍰 ✨")

fast_dev_cli-0.11.0/scripts/format.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+import os
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+
+work_dir = Path(__file__).parent.resolve().parent
+if Path.cwd() != work_dir:
+    os.chdir(str(work_dir))
+
+cmd = "pdm run fast lint"
+r = subprocess.run(shlex.split(cmd), env=dict(os.environ, SKIP_MYPY="1"))
+sys.exit(None if r.returncode == 0 else 1)

fast_dev_cli-0.11.0/scripts/test.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+import os
+import shlex
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+work_dir = Path(__file__).parent.resolve().parent
+if Path.cwd() != work_dir:
+    os.chdir(str(work_dir))
+
+CMD = "pdm run coverage run -m pytest"
+COMBINE = "pdm run coverage combine .coverage*"
+REPORT = "pdm run coverage report -m"
+
+
+def remove_outdate_files(start_time: float) -> None:
+    for file in work_dir.glob(".coverage*"):
+        if file.stat().st_mtime < start_time:
+            file.unlink()
+            print(f"Removed outdate file: {file}")
+
+
+def run_command(cmd: str, shell=False) -> None:
+    print("-->", cmd, flush=True)
+    r = subprocess.run(cmd if shell else shlex.split(cmd), shell=shell)
+    r.returncode and sys.exit(1)
+
+
+def combine_result_files(shell=COMBINE) -> None:
+    to_be_combine = [i.name for i in work_dir.glob(".coverage.*")]
+    if to_be_combine:
+        if sys.platform == "win32":
+            if work_dir.joinpath(".coverage").exists():
+                shell = shell.replace("*", " ")
+            else:
+                shell = shell.replace(".coverage*", "")
+            shell += " ".join(to_be_combine)
+        run_command(shell, True)
+
+
+started_at = time.time()
+run_command(CMD)
+remove_outdate_files(started_at)
+combine_result_files()
+run_command(REPORT)

{fast_dev_cli-0.10.0 → fast_dev_cli-0.11.0}/tests/test_fast_test.py

@@ -1,5 +1,8 @@
+import os
 import pathlib
+from typing import Generator
 
+import pytest
 from pytest_mock import MockerFixture
 
 from fast_dev_cli.cli import (
@@ -10,6 +13,15 @@ from fast_dev_cli.cli import (
 )
 from fast_dev_cli.cli import test as unitcase
 
+TEST_SCRIPT = os.path.join("scripts", "test.py")
+
+
+@pytest.fixture
+def script_path() -> Generator[pathlib.Path, None, None]:
+    parent = pathlib.Path(__file__).parent
+    test_script = parent.resolve().parent / "scripts" / "test.py"
+    yield test_script
+
 
 def test_cli_test(mocker, capsys):
     output = capture_cmd_output("python fast_dev_cli/cli.py test --dry --ignore-script")
@@ -19,7 +31,7 @@ def test_cli_test(mocker, capsys):
     )
 
     mocker.patch("fast_dev_cli.cli.is_venv", return_value=True)
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=False)
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=None)
     unitcase(dry=True)
     assert (
         'coverage run -m pytest -s && coverage report --omit="tests/*" -m'
@@ -29,7 +41,7 @@ def test_cli_test(mocker, capsys):
 
 def test_test_with_pdm_run(mocker: MockerFixture, capsys):
     mocker.patch("fast_dev_cli.cli.check_call", return_value=False)
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=False)
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=None)
     unitcase(dry=True)
     assert (
         '--> pdm run coverage run -m pytest -s && pdm run coverage report --omit="tests/*" -m'
@@ -39,7 +51,7 @@ def test_test_with_pdm_run(mocker: MockerFixture, capsys):
 
 def test_test_with_poetry_or_pdm_run(mocker: MockerFixture, capsys):
     mocker.patch("fast_dev_cli.cli.check_call", return_value=False)
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=False)
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=None)
     mocker.patch("fast_dev_cli.cli.Project.manage_by_poetry", return_value=True)
     unitcase(dry=True)
     command = "coverage"
@@ -52,7 +64,7 @@ def test_test_with_poetry_or_pdm_run(mocker: MockerFixture, capsys):
 
 
 def test_test_not_in_venv(mocker: MockerFixture, capsys):
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=False)
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=None)
     mocker.patch("fast_dev_cli.cli.is_venv", return_value=False)
     unitcase(dry=True)
     command = "coverage"
@@ -64,26 +76,26 @@ def test_test_not_in_venv(mocker: MockerFixture, capsys):
     )
 
 
-def test_run_script(mocker: MockerFixture, capsys):
+def test_run_script(mocker: MockerFixture, capsys, script_path):
     assert _should_run_test_script()
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=True)
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=script_path)
     unitcase(dry=True)
-    assert "sh scripts/test.sh" in capsys.readouterr().out
+    assert TEST_SCRIPT in capsys.readouterr().out
+    assert _should_run_test_script(pathlib.Path("not-exist")) is None
 
 
-def test_ignore_script(mocker: MockerFixture, capsys):
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=True)
+def test_ignore_script(mocker: MockerFixture, capsys, script_path):
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=script_path)
     unitcase(dry=True, ignore_script=True)
-    assert "sh scripts/test.sh" not in capsys.readouterr().out
+    assert TEST_SCRIPT not in capsys.readouterr().out
 
 
-def test_run_script_in_sub_directory(mocker: MockerFixture, capsys):
-    parent = pathlib.Path(__file__).parent
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=True)
-    mocker.patch("pathlib.Path.cwd", return_value=parent)
+def test_run_script_in_sub_directory(mocker: MockerFixture, capsys, script_path):
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=script_path)
+    mocker.patch("pathlib.Path.cwd", return_value=script_path.parent)
     unitcase(dry=True)
     out = capsys.readouterr().out
-    assert f"cd {parent.parent} && sh scripts/test.sh" in out
+    assert f"cd {script_path.parent.parent} && {TEST_SCRIPT}" in out
 
 
 def test_fast_test(mocker, capsys):
@@ -94,7 +106,7 @@ def test_fast_test(mocker, capsys):
     )
 
     mocker.patch("fast_dev_cli.cli.is_venv", return_value=True)
-    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=False)
+    mocker.patch("fast_dev_cli.cli._should_run_test_script", return_value=None)
     coverage_test(dry=True)
     assert (
         'coverage run -m pytest -s && coverage report --omit="tests/*" -m'

{fast_dev_cli-0.10.0 → fast_dev_cli-0.11.0}/tests/test_lint.py

@@ -1,3 +1,4 @@
+import shutil
 from pathlib import Path
 
 import pytest
@@ -10,6 +11,7 @@ from fast_dev_cli.cli import (
     lint,
     make_style,
     only_check,
+    run_and_echo,
 )
 
 from .utils import capture_stdout, chdir, mock_sys_argv
@@ -56,7 +58,7 @@ LINT_CMD = _CMD.format("", " --fix")
 CHECK_CMD = _CMD.format(" --check", "")
 
 
-def test_check(mock_no_dmypy, monkeypatch):
+def test_check(mock_no_dmypy, monkeypatch, mocker):
     command = capture_cmd_output("fast check --dry")
     for cmd in CHECK_CMD.split(SEP):
         assert cmd in command
@@ -70,6 +72,16 @@ def test_check(mock_no_dmypy, monkeypatch):
     assert command4 == command
 
 
+def test_check_bandit(tmp_path):
+    package_path = tmp_path / "foo"
+    with chdir(tmp_path):
+        run_and_echo(f"poetry new {package_path.name}")
+    shutil.rmtree(package_path / package_path.name)
+    with chdir(package_path):
+        command = capture_cmd_output("fast check --bandit --dry")
+    assert "bandit -r ." in command
+
+
 def test_fast_check():
     _fast_check()
 
@@ -155,7 +167,7 @@ def test_lint_func(mocker, mock_no_dmypy):
     with capture_stdout() as stream:
         lint(["lint"], dry=True)
     assert LINT_CMD in stream.getvalue()
-    assert LINT_CMD in capture_cmd_output("python -m fast_dev_cli lint --dry")
+    assert LINT_CMD in capture_cmd_output("pdm run python -m fast_dev_cli lint --dry")
 
 
 def test_lint_without_ruff_installed(mocker, mock_no_dmypy):
@@ -226,3 +238,5 @@ def test_get_manage_tool(tmp_path):
         assert Project.get_manage_tool() == "poetry"
         Path(TOML_FILE).write_text("[tool.pdm]")
         assert Project.get_manage_tool() == "pdm"
+        Path(TOML_FILE).write_text("[tool.uv]")
+        assert Project.get_manage_tool() == "uv"

fast_dev_cli-0.11.0/tests/test_poetry_version_plugin.py

@@ -0,0 +1,94 @@
+import os
+import shutil
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Generator
+
+import pytest
+
+from fast_dev_cli.cli import (
+    TOML_FILE,
+    BumpUp,
+    ParseError,
+    run_and_echo,
+)
+
+from .utils import chdir
+
+CONF = """
+
+[tool.poetry-version-plugin]
+source = "init"
+"""
+CONF_2 = """
+
+[tool.poetry-dynamic-versioning]
+enable = true
+"""
+
+
+@contextmanager
+def _prepare_package(
+    package_path: Path, define_include=False, mark="0"
+) -> Generator[Path, None, None]:
+    toml_file = package_path / TOML_FILE
+    package_name = package_path.name.replace(" ", "_")
+    init_file = package_path / package_name / "__init__.py"
+    a, b = 'version = "0.1.0"', f'version = "{mark}"'
+    if define_include:
+        b += '\npackages = [{include = "%s"}]' % package_name
+    with chdir(package_path.parent):
+        run_and_echo(f'poetry new "{package_path.name}"')
+    toml_file.unlink()
+    py_version = "{0}.{1}".format(*sys.version_info)
+    with chdir(package_path):
+        run_and_echo(f'poetry init --python="^{py_version}" --no-interaction')
+        text = toml_file.read_text().replace(a, b)
+        toml_file.write_text(text + CONF)
+        shutil.move(package_path.name, package_name)
+        init_file.write_text('__version__ = "0.0.1"\n')
+        yield init_file
+
+
+def _build_bump_cmd(init_file: Path) -> str:
+    relative_path = os.path.join(init_file.parent.name, init_file.name)
+    return rf'bumpversion --parse "(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)" --current-version="0.0.1" patch {relative_path} --allow-dirty'
+
+
+def test_version_plugin(tmp_path: Path) -> None:
+    with _prepare_package(tmp_path / "helloworld") as init_file:
+        command = _build_bump_cmd(init_file)
+        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_2(tmp_path: Path) -> None:
+    with _prepare_package(tmp_path / "helloworld", mark="0.0.0") as init_file:
+        command = _build_bump_cmd(init_file)
+        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:
+    with _prepare_package(tmp_path / "hello world", True) as init_file:
+        command = _build_bump_cmd(init_file)
+        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:
+    with _prepare_package(tmp_path / "hello world", True, mark="0.0.0") as init_file:
+        command = _build_bump_cmd(init_file)
+        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.11.0/tests/test_sync.py

@@ -0,0 +1,214 @@
+from pathlib import Path
+
+import pytest
+
+from fast_dev_cli.cli import TOML_FILE, EnvError, Sync, run_and_echo, sync
+
+from .utils import chdir, temp_file
+
+TOML_TEXT = """
+[tool.poetry]
+name = "foo"
+version = "0.1.0"
+description = ""
+authors = []
+readme = ""
+
+[tool.poetry.dependencies]
+python = "^3.11"
+click = ">=7.1.1"
+anyio = {version = "^4.0", optional = true}
+
+[tool.poetry.extras]
+all = ["anyio"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+"""
+
+
+def test_sync_not_in_venv(mocker, capsys):
+    mocker.patch("fast_dev_cli.cli.is_venv", return_value=False)
+    test_dir = Path(__file__).parent
+    with temp_file(TOML_FILE, TOML_TEXT), chdir(test_dir):
+        cmd = Sync("req.txt", "all", save=False, dry=True).gen()
+    assert (
+        cmd
+        == 'poetry export --without-hashes --extras="all" -o req.txt && poetry run python -m pip install -r req.txt && rm -f req.txt'
+    )
+    sync(extras="all", save=False, dry=True)
+    assert "pip install -r" in capsys.readouterr().out
+    mocker.patch(
+        "fast_dev_cli.cli.UpgradeDependencies.should_with_dev", return_value=True
+    )
+    assert (
+        Sync("req.txt", "", True, dry=True).gen()
+        == "pdm export --without-hashes --with=dev -o req.txt && pdm run python -m pip install -r req.txt"
+    )
+
+
+def test_sync(mocker):
+    mocker.patch("fast_dev_cli.cli.is_venv", return_value=True)
+    test_dir = Path(__file__).parent
+    with temp_file(TOML_FILE, TOML_TEXT), chdir(test_dir):
+        cmd = Sync("req.txt", "all", save=False, dry=True).gen()
+    assert (
+        cmd
+        == 'poetry export --without-hashes --extras="all" -o req.txt && python -m pip install -r req.txt && rm -f req.txt'
+    )
+    mocker.patch(
+        "fast_dev_cli.cli.UpgradeDependencies.should_with_dev", return_value=True
+    )
+    assert (
+        Sync("req.txt", "", True, dry=True).gen()
+        == "pdm export --without-hashes --with=dev -o req.txt && python -m pip install -r req.txt"
+    )
+
+
+UV_TOML_EXAMPLE = """
+[project]
+name = "examples"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "asynctor>=0.6.6",
+]
+
+[tool.uv]
+index-url = "https://mirrors.cloud.tencent.com/pypi/simple/"
+"""
+UV_LOCK_EXAMPLE = """
+version = 1
+requires-python = ">=3.10"
+
+[[package]]
+name = "anyio"
+version = "4.6.2.post1"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+dependencies = [
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "idna" },
+    { name = "sniffio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/9f/09/45b9b7a6d4e45c6bcb5bf61d19e3ab87df68e0601fa8c5293de3542546cc/anyio-4.6.2.post1.tar.gz", hash = "sha256:4c8bc31ccdb51c7f7bd251f51c609e038d63e34219b44aa86e47576389880b4c" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/e4/f5/f2b75d2fc6f1a260f340f0e7c6a060f4dd2961cc16884ed851b0d18da06a/anyio-4.6.2.post1-py3-none-any.whl", hash = "sha256:6d170c36fba3bdd840c73d3868c1e777e33676a69c3a72cf0a0d5d6d8009b61d" },
+]
+
+[[package]]
+name = "async-timeout"
+version = "4.0.3"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/87/d6/21b30a550dafea84b1b8eee21b5e23fa16d010ae006011221f33dcd8d7f8/async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/a7/fa/e01228c2938de91d47b307831c62ab9e4001e747789d0b05baf779a6488c/async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028" },
+]
+
+[[package]]
+name = "asynctor"
+version = "0.6.6"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+dependencies = [
+    { name = "anyio" },
+    { name = "redis" },
+]
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/38/d0/452d78491eda3b70bd7b8d401093e5e77999f0232a836b4465e0395223c5/asynctor-0.6.6.tar.gz", hash = "sha256:594c60a38483e399d5a6be513256657989fa2bbf069572074c6b529fa72219ef" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/77/01/31143ebf73a22b5e11a1c6dd3f3af53f1d045d9ab0f13a0159b32df71440/asynctor-0.6.6-py3-none-any.whl", hash = "sha256:54785f1cfd32bd9f9bcffe9445ffd02421aab9c3501c134dbd955901606cf1b4" },
+]
+
+[[package]]
+name = "examples"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "asynctor" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "asynctor", specifier = ">=0.6.6" }]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.2"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b" },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3" },
+]
+
+[[package]]
+name = "redis"
+version = "5.1.1"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+dependencies = [
+    { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
+]
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/e0/58/dcf97c3c09d429c3bb830d6075322256da3dba42df25359bd1c82b442d20/redis-5.1.1.tar.gz", hash = "sha256:f6c997521fedbae53387307c5d0bf784d9acc28d9f1d058abeac566ec4dbed72" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/15/f1/feeeaaaac0f589bcbc12c02da357cf635ee383c9128b77230a1e99118885/redis-5.1.1-py3-none-any.whl", hash = "sha256:f8ea06b7482a668c6475ae202ed8d9bcaa409f6e87fb77ed1043d912afd62e24" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://mirrors.cloud.tencent.com/pypi/simple/" }
+sdist = { url = "https://mirrors.cloud.tencent.com/pypi/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8" }
+wheels = [
+    { url = "https://mirrors.cloud.tencent.com/pypi/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d" },
+]
+"""
+
+
+def test_sync_uv(mocker, tmp_path):
+    mocker.patch("fast_dev_cli.cli.is_venv", return_value=False)
+    with chdir(tmp_path):
+        toml = tmp_path / TOML_FILE
+        toml.write_text(UV_TOML_EXAMPLE)
+        toml.with_name("uv.lock").write_text(UV_LOCK_EXAMPLE)
+        assert (
+            Sync("req.txt", "", True, dry=True).gen()
+            == "uv export --no-hashes --all-extras --frozen -o req.txt && uv run python -m ensurepip && uv run python -m pip install -U pip && uv run python -m pip install -r req.txt"
+        )
+        run_and_echo("uv run python -m ensurepip")
+        assert (
+            Sync("req.txt", "", True, dry=True).gen()
+            == "uv export --no-hashes --all-extras --frozen -o req.txt && uv run python -m pip install -r req.txt"
+        )
+
+
+def test_sync_no_tool(mocker, tmp_path):
+    mocker.patch("fast_dev_cli.cli.is_venv", return_value=False)
+    with chdir(tmp_path):
+        with pytest.raises(EnvError):
+            Sync("req.txt", "", True, dry=True).gen()
+        Path("req.txt").write_text("six")
+        with pytest.raises(EnvError):
+            Sync("req.txt", "", True, dry=True).gen()
+        mocker.patch("fast_dev_cli.cli.is_venv", return_value=True)
+        assert (
+            Sync("req.txt", "", True, dry=True).gen()
+            == "python -m pip install -r req.txt"
+        )

{fast_dev_cli-0.10.0 → fast_dev_cli-0.11.0}/tests/test_tag.py

@@ -1,3 +1,4 @@
+import sys
 from contextlib import contextmanager
 
 from fast_dev_cli.cli import (
@@ -36,7 +37,12 @@ def test_echo_when_not_dry(mocker, capsys):
 
 @contextmanager
 def _clear_tags():
-    run_and_echo("git tag | xargs git tag -d")
+    if sys.platform == "win32":
+        for t in capture_cmd_output("git tag").splitlines():
+            if "v" in (tag := t.strip()):
+                run_and_echo(f"git tag -d {tag}")
+    else:
+        run_and_echo("git tag | xargs git tag -d")
     yield
     run_and_echo("git pull --tags")
 

fast_dev_cli-0.11.0/tests/test_version.py

@@ -0,0 +1,56 @@
+import re
+from pathlib import Path
+
+from fast_dev_cli import __version__
+from fast_dev_cli.cli import (
+    TOML_FILE,
+    _parse_version,
+    get_current_version,
+    read_version_from_file,
+    version,
+)
+
+from .utils import chdir
+
+
+def test_version(capsys):
+    version()
+    assert get_current_version(is_poetry=False) in capsys.readouterr().out
+    assert get_current_version(is_poetry=False) == __version__
+    assert get_current_version(is_poetry=True) == ""
+    assert get_current_version() == __version__
+
+
+def test_read_version(tmp_path: Path, capsys):
+    assert read_version_from_file("fast_dev_cli") == __version__
+    toml_text = 'version = "0.1.0"'
+    assert read_version_from_file("", toml_text=toml_text) == "0.1.0"
+    with chdir(tmp_path):
+        tmp_path.joinpath(TOML_FILE).write_text("")
+        assert read_version_from_file("") == "0.0.0"
+        assert "WARNING" in capsys.readouterr().out
+        init_file = tmp_path / "app" / "__init__.py"
+        init_file.parent.mkdir()
+        init_file.write_text("")
+        assert read_version_from_file("") == "0.0.0"
+        assert "WARNING" in capsys.readouterr().out
+        assert get_current_version() == "0.0.0"
+
+
+def test_parse_version():
+    pattern = re.compile(r"version\s*=")
+    line = 'version="0.0.1" # adsfasf version="0.0.2"'
+    assert _parse_version(line, pattern) == "0.0.1"
+    line = 'version = "0.0.1" # adsfasf version="0.0.2"'
+    assert _parse_version(line, pattern) == "0.0.1"
+    line = "version = '0.0.1' # adsfasf version=\"0.0.2\""
+    assert _parse_version(line, pattern) == "0.0.1"
+    line = "version='0.0.1' # adsfasf version=\"0.0.2\""
+    assert _parse_version(line, pattern) == "0.0.1"
+    line = 'version="0.0.1"'
+    assert _parse_version(line, pattern) == "0.0.1"
+    pattern = re.compile(r"__version__\s*=")
+    line = '__version__ = "0.0.1"'
+    assert _parse_version(line, pattern) == "0.0.1"
+    line = '__version__ = "0.0.1"  # 0.0.2'
+    assert _parse_version(line, pattern) == "0.0.1"

fast_dev_cli-0.10.0/fast_dev_cli/__init__.py

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

fast_dev_cli-0.10.0/fast_dev_cli/__main__.py

@@ -1,3 +0,0 @@
-from .cli import main
-
-main()

fast_dev_cli-0.10.0/scripts/check.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -x
-
-[ -f pyproject.toml ] || ([ -f ../pyproject.toml ] && cd ..)
-
-pdm run fast check || \
-  echo -e "\033[1m Please run './scripts/format.sh' to auto-fix style issues \033[0m"
-
-pdm run bandit -r fast_dev_cli/

fast_dev_cli-0.10.0/scripts/format.sh

@@ -1,6 +0,0 @@
-#!/bin/sh -e
-set -x
-
-[ -f pyproject.toml ] || ([ -f ../pyproject.toml ] && cd ..)
-
-SKIP_MYPY=1 pdm run fast lint

fast_dev_cli-0.10.0/scripts/test.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-pdm run coverage run -m pytest
-pdm run coverage combine .coverage*
-pdm run coverage report -m

fast_dev_cli-0.10.0/tests/test_poetry_version_plugin.py

@@ -1,62 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from fast_dev_cli.cli import (
-    TOML_FILE,
-    BumpUp,
-    ParseError,
-    run_and_echo,
-)
-
-from .utils import chdir
-
-CONF = """
-
-[tool.poetry-version-plugin]
-source = "init"
-"""
-
-
-def test_version_plugin(tmp_path: Path) -> None:
-    package_path = tmp_path / "helloworld"
-    toml_file = package_path / TOML_FILE
-    init_file = package_path / package_path.name / "__init__.py"
-    a, b = 'version = "0.1.0"', 'version = "0"'
-    with chdir(tmp_path):
-        run_and_echo(f"poetry new {package_path.name}")
-    with chdir(package_path):
-        text = toml_file.read_text().replace(a, b)
-        toml_file.write_text(text + CONF)
-        init_file.write_text('__version__ = "0.0.1"\n')
-        assert (
-            BumpUp(part="patch", commit=False, dry=True).gen()
-            == 'bumpversion --parse "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)" --current-version="0.0.1" patch helloworld/__init__.py --allow-dirty'
-        )
-        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:
-    package_path = tmp_path / "hello world"
-    toml_file = package_path / TOML_FILE
-    package_name = package_path.name.replace(" ", "_")
-    init_file = package_path / package_name / "__init__.py"
-    a, b = 'version = "0.1.0"', 'version = "0"'
-    b += '\npackages = [{include = "%s"}]' % package_name
-    with chdir(tmp_path):
-        run_and_echo(f"poetry new '{package_path.name}'")
-    with chdir(package_path):
-        text = toml_file.read_text().replace(a, b)
-        toml_file.write_text(text + CONF)
-        run_and_echo(f"mv '{package_path.name}' {package_name}")
-        init_file.write_text('__version__ = "0.0.1"\n')
-        assert (
-            BumpUp(part="patch", commit=False, dry=True).gen()
-            == f'bumpversion --parse "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)" --current-version="0.0.1" patch {package_name}/__init__.py --allow-dirty'
-        )
-        run_and_echo("poetry run fast bump patch")
-        assert init_file.read_text() == '__version__ = "0.0.2"\n'

fast_dev_cli-0.10.0/tests/test_sync.py

@@ -1,64 +0,0 @@
-from pathlib import Path
-
-from fast_dev_cli.cli import TOML_FILE, Sync, sync
-
-from .utils import chdir, temp_file
-
-TOML_TEXT = """
-[tool.poetry]
-name = "foo"
-version = "0.1.0"
-description = ""
-authors = []
-readme = ""
-
-[tool.poetry.dependencies]
-python = "^3.11"
-click = ">=7.1.1"
-anyio = {version = "^4.0", optional = true}
-
-[tool.poetry.extras]
-all = ["anyio"]
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-"""
-
-
-def test_sync_not_in_venv(mocker, capsys):
-    mocker.patch("fast_dev_cli.cli.is_venv", return_value=False)
-    test_dir = Path(__file__).parent
-    with temp_file(TOML_FILE, TOML_TEXT), chdir(test_dir):
-        cmd = Sync("req.txt", "all", save=False, dry=True).gen()
-    assert (
-        cmd
-        == "poetry export --extras='all' --without-hashes -o req.txt && poetry run pip install -r req.txt && rm -f req.txt"
-    )
-    sync(extras="all", save=False, dry=True)
-    assert "pip install -r" in capsys.readouterr().out
-    mocker.patch(
-        "fast_dev_cli.cli.UpgradeDependencies.should_with_dev", return_value=True
-    )
-    assert (
-        Sync("req.txt", "", True, dry=True).gen()
-        == "poetry export --with=dev --without-hashes -o req.txt && poetry run pip install -r req.txt"
-    )
-
-
-def test_sync(mocker):
-    mocker.patch("fast_dev_cli.cli.is_venv", return_value=True)
-    test_dir = Path(__file__).parent
-    with temp_file(TOML_FILE, TOML_TEXT), chdir(test_dir):
-        cmd = Sync("req.txt", "all", save=False, dry=True).gen()
-    assert (
-        cmd
-        == "poetry export --extras='all' --without-hashes -o req.txt && pip install -r req.txt && rm -f req.txt"
-    )
-    mocker.patch(
-        "fast_dev_cli.cli.UpgradeDependencies.should_with_dev", return_value=True
-    )
-    assert (
-        Sync("req.txt", "", True, dry=True).gen()
-        == "poetry export --with=dev --without-hashes -o req.txt && pip install -r req.txt"
-    )

fast_dev_cli-0.10.0/tests/test_version.py

@@ -1,10 +0,0 @@
-from fast_dev_cli import __version__
-from fast_dev_cli.cli import get_current_version, version
-
-
-def test_version(capsys):
-    version()
-    assert get_current_version(is_poetry=False) in capsys.readouterr().out
-    assert get_current_version(is_poetry=False) == __version__
-    assert get_current_version(is_poetry=True) == ""
-    assert get_current_version() == __version__