fast-dev-cli 0.25.0__tar.gz → 0.25.2__tar.gz

{fast_dev_cli-0.25.0 → fast_dev_cli-0.25.2}/PKG-INFO

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

fast_dev_cli-0.25.2/fast_dev_cli/__init__.py

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

{fast_dev_cli-0.25.0 → fast_dev_cli-0.25.2}/fast_dev_cli/cli.py

@@ -114,13 +114,19 @@ def yellow_warn(msg: str) -> None:
 def load_bool(name: str, default: bool = False, *, verbose: bool = True) -> bool:
     if not (v := os.getenv(name)):
         return default
+    if (b := _convert_bool(v)) is not None:
+        return b
+    if verbose:
+        secho(f"WARNING: can not convert value({v!r}) of {name} to bool!")
+    return default
+
+
+def _convert_bool(v: str) -> bool | None:
     if (lower := v.lower()) in ("0", "false", "f", "off", "no", "n"):
         return False
     elif lower in ("1", "true", "t", "on", "yes", "y"):
         return True
-    if verbose:
-        secho(f"WARNING: can not convert value({v!r}) of {name} to bool!")
-    return default
+    return None
 
 
 def is_venv() -> bool:
@@ -141,7 +147,8 @@ class Shell:
     ) -> subprocess.CompletedProcess[str]:
         if isinstance(cmd, str):
             kw.setdefault("shell", True)
-        return subprocess.run(cmd, **kw)  # nosec:B603
+        check = kw.pop("check", False)
+        return subprocess.run(cmd, check=check, **kw)  # nosec:B603
 
     @property
     def command(self) -> list[str] | str:
@@ -260,13 +267,12 @@ def read_version_from_file(
     for line in all_lines:
         if pattern.match(line):
             return _parse_version(line, pattern)
-    else:
-        pattern = re.compile(r"VERSION\s*=")
-        for line in all_lines:
-            if pattern.match(line):
-                return _parse_version(line, pattern)
-        secho(f"WARNING: can not find version pattern in {version_file}!")
-        return "0.0.0"
+    pattern = re.compile(r"VERSION\s*=")
+    for line in all_lines:
+        if pattern.match(line):
+            return _parse_version(line, pattern)
+    secho(f"WARNING: can not find version pattern in {version_file}!")
+    return "0.0.0"
 
 
 def _get_frontend_version() -> tuple[Path, str] | None:
@@ -325,9 +331,9 @@ def get_current_version(
     if package_name is None:
         try:
             work_dir = Project.get_work_dir()
-        except EnvError as e:
+        except EnvError:
             if (res := _get_frontend_version()) is None:
-                raise e
+                raise
             current_version = res[1]
             if check_version:
                 return False, current_version
@@ -372,6 +378,36 @@ def _ensure_str(value: str | OptionInfo | None) -> str | None:
     return getattr(value, "default", "")
 
 
+def _quote_shell_arg(value: str | Path) -> str:
+    text = str(value)
+    if not is_windows():
+        return shlex.quote(text)
+    if text and not re.search(r'[\s"&|<>^()%!]', text):
+        return text
+
+    # Quote for the Windows C runtime while keeping cmd.exe metacharacters inert.
+    result = ['"']
+    backslashes = 0
+    for char in text:
+        if char == "\\":
+            backslashes += 1
+        elif char == '"':
+            result.append("\\" * (backslashes * 2 + 1))
+            result.append(char)
+            backslashes = 0
+        else:
+            result.append("\\" * backslashes)
+            result.append(char)
+            backslashes = 0
+    result.append("\\" * (backslashes * 2))
+    result.append('"')
+    return "".join(result)
+
+
+def _join_shell_args(args: list[str]) -> str:
+    return " ".join(_quote_shell_arg(arg) for arg in args)
+
+
 class DryRun:
     def __init__(self, _exit: bool = False, dry: bool = False) -> None:
         self.dry = _ensure_bool(dry)
@@ -468,7 +504,7 @@ class BumpUp(DryRun):
         toml_text: str | None = None,
         work_dir: Path | None = None,
         package_name: str | None = None,
-        context: dict | None = None,
+        context: dict[str, Any] | None = None,
     ) -> str:
         if context is None:
             if toml_text is None:
@@ -528,11 +564,11 @@ class BumpUp(DryRun):
         ds: list[Path] = []
         if package_name is not None:
             packages.insert(0, (package_name, ""))
-        for package_name, source_dir in packages:
-            ds.append(cwd / package_name)
-            ds.append(cwd / "src" / package_name)
+        for pack_name, source_dir in packages:
+            ds.append(cwd / pack_name)
+            ds.append(cwd / "src" / pack_name)
             if source_dir and source_dir != "src":
-                ds.append(cwd / source_dir / package_name)
+                ds.append(cwd / source_dir / pack_name)
         module_name = poetry_module_name(cwd.name)
         ds.extend([cwd / module_name, cwd / "src" / module_name, cwd])
         for d in ds:
@@ -569,7 +605,10 @@ class BumpUp(DryRun):
                 part = self.get_part(a)
         self.part = part
         parse = r'--parse "(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)"'
-        cmd = f'bumpversion {parse} --current-version="{_version}" {part} {filename}'
+        filename_arg = _quote_shell_arg(filename)
+        cmd = (
+            f'bumpversion {parse} --current-version="{_version}" {part} {filename_arg}'
+        )
         if self.commit:
             if part != "patch":
                 cmd += " --tag"
@@ -756,7 +795,7 @@ class Project:
         if skip_uv:
             for name in ("pdm", "poetry"):
                 if f"[tool.{name}]" in text:
-                    cls._tool = cast(ToolName, name)
+                    cls._tool = name
                     return cls._tool
             work_dir = cls.get_work_dir(allow_cwd=True)
             for name in ("pdm", "poetry"):
@@ -791,11 +830,11 @@ class Project:
                 if backend:
                     for t in ("pdm", "poetry"):
                         if t in backend:
-                            cls._tool = cast(ToolName, t)
+                            cls._tool = t
                             return cls._tool
                 for name in ("pdm", "poetry"):
                     if f"[tool.{name}]" in text:
-                        cls._tool = cast(ToolName, name)
+                        cls._tool = name
                         return cls._tool
                 if x == 2:
                     cls._tool = (
@@ -919,7 +958,7 @@ class UpgradeDependencies(Project, DryRun):
         elif v == "[":
             echo(f"Skip complex dependence: {line}")
             return True
-        elif v.startswith(">") or v.startswith("<") or v[0].isdigit():
+        elif v.startswith((">", "<")) or v[0].isdigit():
             echo(f"Ignore bigger/smaller/equal: {line}")
             return True
         return False
@@ -1082,7 +1121,10 @@ class GitTag(DryRun):
         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"
+        cmd = (
+            f"git tag -a {_quote_shell_arg(_version)} "
+            f"-m {_quote_shell_arg(self.message)} && git push --tags"
+        )
         if self.should_push():
             cmd += " && git push"
         if should_sync and not self._no_sync and (sync := Project.get_sync_command()):
@@ -1184,7 +1226,7 @@ class LintCode(DryRun):
     @classmethod
     def to_cmd(
         cls: type[Self],
-        paths: str = ".",
+        paths: str | list[str] = ".",
         check_only: bool = False,
         bandit: bool = False,
         skip_mypy: bool = False,
@@ -1197,8 +1239,12 @@ class LintCode(DryRun):
         prefer_ty: bool = False,
         ruff_check_fix: bool = True,
     ) -> str:
-        if paths != "." and all(i.endswith(".html") for i in paths.split()):
-            return f"prettier -w {paths}"
+        path_args = shlex.split(paths) if isinstance(paths, str) else paths
+        if not path_args:
+            path_args = ["."]
+        quoted_paths = _join_shell_args(path_args)
+        if path_args != ["."] and all(i.endswith(".html") for i in path_args):
+            return f"prettier -w {quoted_paths}"
         ruff_rules = ["I", "B"]
         if ruff_check_sim and not load_bool("FASTDEVCLI_NO_SIM"):
             ruff_rules.append("SIM")
@@ -1288,7 +1334,7 @@ class LintCode(DryRun):
                         prefix += "--no-sync "
                     elif Path(bin_dir := ".venv/bin/").exists():
                         prefix = bin_dir
-        if cls.prefer_dmypy(paths, tools, use_dmypy=use_dmypy):
+        if cls.prefer_dmypy(quoted_paths, tools, use_dmypy=use_dmypy):
             tools[-1] = "dmypy run"
         cmd = " && ".join(
             (
@@ -1302,7 +1348,7 @@ class LintCode(DryRun):
                 )
                 else prefix + tool
             )
-            + f" {paths}"
+            + f" {quoted_paths}"
             for tool in tools
         )
         if bandit or load_bool("FASTDEVCLI_BANDIT"):
@@ -1311,36 +1357,35 @@ class LintCode(DryRun):
                 toml_text = Project.load_toml_text()
                 if "[tool.bandit" in toml_text:
                     command += " -c pyproject.toml"
-            if paths == "." and " -c " not in command:
-                paths = cls.get_package_name()
-            command += f" -r {paths}"
+            if quoted_paths == "." and " -c " not in command:
+                quoted_paths = _quote_shell_arg(cls.get_package_name())
+            command += f" -r {quoted_paths}"
             cmd += " && " + command
         return cmd
 
     def gen(self) -> str:
-        paths = "."
+        paths = ["."]
         if args := self.args:
-            ps = args.split() if isinstance(args, str) else [str(i) for i in args]
+            ps = shlex.split(args) if isinstance(args, str) else [str(i) for i in args]
             if len(ps) == 1:
-                paths = ps[0]
+                path = ps[0]
                 if (
-                    paths != "."
+                    path != "."
                     # `Path("a.").suffix` got "." in py3.14 and got "" with py<3.14
-                    and (p := Path(paths)).suffix in ("", ".")
+                    and (p := Path(path)).suffix in ("", ".")
                     and not p.exists()
                 ):
                     # e.g.:
                     # stem -> stem.py
                     # me. -> me.py
-                    if paths.endswith("."):
-                        p = p.with_name(paths[:-1])
+                    if path.endswith("."):
+                        p = p.with_name(path[:-1])
                     for suffix in (".py", ".html"):
                         p = p.with_suffix(suffix)
                         if p.exists():
-                            paths = p.name
+                            ps[0] = p.name
                             break
-            else:
-                paths = " ".join(ps)
+            paths = ps
         return self.to_cmd(
             paths,
             self.check_only,
@@ -1423,6 +1468,14 @@ def check(
     ).run()
 
 
+def _should_bandit() -> bool:
+    if v := os.getenv("FASTDEVCLI_BANDIT"):
+        return _convert_bool(v) or True
+    toml_text = Project.load_toml_text()
+    lines = toml_text.splitlines()
+    return any(i.startswith("[tool.bandit") for i in lines)
+
+
 @cli.command(name="lint")
 def make_style(
     files: list[str] | None = typer.Argument(default=None),  # noqa:B008
@@ -1444,6 +1497,9 @@ def make_style(
     strict: bool = Option(False, help="Whether run mypy with --strict"),
     ty: bool = Option(False, help="Whether use ty instead of mypy"),
     fix: bool | None = Option(None, help="Whether ruff check with --fix"),
+    auto_bandit: bool | None = Option(
+        None, help="Whether to run bandit if `[tool.bandit]` in pyproject.toml"
+    ),
 ) -> None:
     """Run: ruff check/format to reformat code and then mypy to check"""
     if getattr(files, "default", files) is None:
@@ -1452,7 +1508,9 @@ def make_style(
         files = [files]
     skip = _ensure_bool(skip_mypy)
     dmypy = _ensure_bool(use_dmypy)
-    bandit = _ensure_bool(bandit)
+    bandit = _ensure_bool(bandit) or (
+        auto_bandit is not None and _ensure_bool(auto_bandit) and _should_bandit()
+    )
     tool = _ensure_str(tool) or ""
     up = _ensure_bool(up)
     sim = _ensure_bool(sim)
@@ -1498,10 +1556,11 @@ class Sync(DryRun):
     def gen(self) -> str:
         extras, save = self.extras, self._save
         should_remove = not Path.cwd().joinpath(self.filename).exists()
+        filename = _quote_shell_arg(self.filename)
         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}"
+            return f"python -m pip install -r {filename}"
         prefix = ""
         if not is_venv():
             prefix = f"{tool} run " + "--no-sync " * (tool == "uv")
@@ -1514,7 +1573,7 @@ class Sync(DryRun):
                 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("'", '"')
+                    export_cmd += f" --extras={_quote_shell_arg(str(extras))}"
             elif check_call(prefix + "python -m pip --version"):
                 ensure_pip = ""
         elif check_call(prefix + "python -m pip --version"):
@@ -1524,7 +1583,7 @@ class Sync(DryRun):
         )
         if should_remove and not save:
             install_cmd += " && rm -f {0}"
-        return install_cmd.format(self.filename, prefix, export_cmd)
+        return install_cmd.format(filename, prefix, export_cmd)
 
 
 @cli.command()
@@ -1554,11 +1613,11 @@ def test(dry: bool, ignore_script: bool = False) -> None:
     if not _ensure_bool(ignore_script) and (
         test_script := _should_run_test_script(script_dir)
     ):
-        cmd = test_script.relative_to(root).as_posix()
+        cmd = _quote_shell_arg(test_script.relative_to(root).as_posix())
         if test_script.suffix == ".py":
             cmd = "python " + cmd
         if cwd != root:
-            cmd = f"cd {root} && " + cmd
+            cmd = f"cd {_quote_shell_arg(root)} && " + cmd
     else:
         cmd = 'coverage run -m pytest -s && coverage report --omit="tests/*" -m'
         if not is_venv() or not check_call("coverage --version"):
@@ -1585,7 +1644,7 @@ class Publish:
         twine = "python -m build && twine upload"
 
     @classmethod
-    def gen(cls, tool: str, verbose: bool) -> str:
+    def gen(cls, tool: str | None, verbose: bool) -> str:
         if tool == "auto":
             tool = Project.get_manage_tool() or ""
         if tool:
@@ -1612,7 +1671,7 @@ def upload(
     dry: bool = DryOption,
 ) -> None:
     """Shortcut for package publish"""
-    cmd = Publish.gen(tool, verbose)
+    cmd = Publish.gen(_ensure_str(tool), verbose)
     exit_if_run_failed(cmd, dry=dry)
 
 
@@ -1626,6 +1685,7 @@ def should_use_just() -> bool:
             return _prefer_just_dev(f)
         if d.joinpath("pyproject.toml").exists():
             break
+        d = d.parent
     return False
 
 
@@ -1635,10 +1695,22 @@ def _prefer_just_dev(f: Path) -> bool:
     dev_recipe = "dev *args:"
     re_import = re.compile(r"import[?]? ")
     has_import = False
+    total = len(lines)
     for i, line in enumerate(lines):
         if line.startswith(dev_recipe):
             # Avoid cycle callback
-            return "fast dev" not in lines[i + 1]
+            command_lines = []
+            for j in range(i + 1, total):
+                try:
+                    s = lines[j]
+                except IndexError:
+                    break
+                if not s.startswith(" "):
+                    break
+                command_lines.append(s)
+            if not command_lines:  # Invalid justfile
+                return False
+            return all("fast dev" not in i for i in command_lines)
         elif not has_import and re_import.match(line):
             has_import = True
     if has_import:
@@ -1650,7 +1722,20 @@ def _prefer_just_dev(f: Path) -> bool:
     return False
 
 
-def _parse_serve_file(uvicorn, filename: str, cmd: str, args: list) -> str:
+def _load_fastapi_entrypoint() -> str:
+    with contextlib.suppress(FileNotFoundError, KeyError):
+        try:
+            toml_text = Project.load_toml_text()
+        except EnvError:
+            return ""
+        doc = tomllib.loads(toml_text)
+        return doc["tool"]["fastapi"]["entrypoint"]
+    return ""
+
+
+def _parse_serve_file(
+    uvicorn: bool | None, filename: str, cmd: str, args: list[str]
+) -> str:
     if m := re.search(r"(.*):(\d+)$", filename):
         h, p = m.group(1), m.group(2)
         if h and "--host" not in str(args):
@@ -1660,24 +1745,32 @@ def _parse_serve_file(uvicorn, filename: str, cmd: str, args: list) -> str:
                 args.append(f"--host={h}")
         args.append(f"--port={p}")
         if uvicorn:
-            p = Path("main.py")
-            if p.exists():
-                cmd += " main:app"
-            elif Path("app", p.name).exists():
-                cmd += " app.main:app"
-            elif Path("app.py").exists():
-                cmd += " app:app"
+            if entrypoint := _load_fastapi_entrypoint():
+                cmd += " " + entrypoint
+            else:
+                p = Path("main.py")
+                if p.exists():
+                    cmd += " main:app"
+                elif Path("app", p.name).exists():
+                    cmd += " app.main:app"
+                elif Path("app.py").exists():
+                    cmd += " app:app"
         return cmd
     if uvicorn and ((filepath := Path(filename)).is_file() or filepath.suffix == ".py"):
         filename = filepath.stem + ":app"
         parent_names = [j for i in filepath.parents if (j := i.name)]
         if parent_names:
             filename = ".".join([*parent_names[::-1], filename])
-    cmd += " " + filename
+    cmd += " " + _quote_shell_arg(filename)
     return cmd
 
 
-def _runserver(uvicorn, host, port, file) -> tuple[str, list[str]]:
+def _runserver(
+    uvicorn: bool | None,
+    host: OptionInfo | str | None,
+    port: OptionInfo | int | None,
+    file: ArgumentInfo | str | None,
+) -> tuple[str, list[str]]:
     cmd = "uvicorn" if uvicorn else "fastapi dev"
     args = []
     if (host := getattr(host, "default", host)) and host not in (
@@ -1696,6 +1789,8 @@ def _runserver(uvicorn, host, port, file) -> tuple[str, list[str]]:
             if port != 8000:
                 args.append(f"--port={port}")
                 no_port_yet = False
+    elif uvicorn and (entrypoint := _load_fastapi_entrypoint()):
+        cmd += " " + entrypoint
     if no_port_yet and (port := getattr(port, "default", port)) and str(port) != "8000":
         args.append(f"--port={port}")
     if shutil.which("pdm") is not None:
@@ -1710,16 +1805,17 @@ def dev(
     uvicorn: bool | None = None,
     prod: bool | None = None,
     reload: bool | None = None,
+    just: bool | None = None,
     file: str | None | ArgumentInfo = None,
     dry: bool = False,
 ) -> None:
-    if should_use_just():
+    if just is not False and should_use_just():
         args = [i for i in sys.argv[2:] if i != "--dry"]
         cmd = "just dev"
     else:
         cmd, args = _runserver(uvicorn, host, port, file)
     if args:
-        cmd += " " + " ".join(args)
+        cmd += " " + _join_shell_args(args)
     exit_if_run_failed(cmd, dry=dry)
 
 
@@ -1732,10 +1828,13 @@ def runserver(
     uvicorn: bool | None = None,
     prod: bool | None = None,
     reload: bool | None = None,
+    just: bool | None = None,
     dry: bool = DryOption,
 ) -> None:
     """Start a fastapi server(only for fastapi>=0.111.0)"""
-    f = functools.partial(dev, port, host, fastapi, uvicorn, prod, reload, dry=dry)
+    f = functools.partial(
+        dev, port, host, fastapi, uvicorn, prod, reload, just, dry=dry
+    )
     if getattr(file_or_port, "default", file_or_port):
         f(file=file_or_port)
     else:
@@ -1754,7 +1853,7 @@ def run_by_subprocess(cmd: str, dry: bool = DryOption) -> None:
         ):
             echo(f"Command not found: {command}")
             raise Exit(1) from None
-        raise e
+        raise
     else:
         if rc:
             raise Exit(rc)
@@ -1805,9 +1904,13 @@ class MakeDeps(DryRun):
             if opt not in cmd:
                 cmd += opt
         if self._no_extra:
-            cmd += " " + " ".join(f"--no-extra {i}" for i in self._no_extra)
+            cmd += " " + " ".join(
+                f"--no-extra {_quote_shell_arg(i)}" for i in self._no_extra
+            )
         if self._no_group:
-            cmd += " " + " ".join(f"--no-group {i}" for i in self._no_group)
+            cmd += " " + " ".join(
+                f"--no-group {_quote_shell_arg(i)}" for i in self._no_group
+            )
         if self._frozen:
             cmd += " --frozen"
         if opts := os.getenv("FASTDEVCLI_DEPS_OPTS"):
@@ -1824,15 +1927,17 @@ class MakeDeps(DryRun):
             tool_section = doc["tool"]
             uv_package = tool_section.get("uv", {}).get("package")
             if uv_package is not None:
-                return doc["project"]["name"] if uv_package else ""
-            match doc["build-system"]["build-backend"]:
-                case "pdm.backend":
-                    if not tool_section.get("pdm", {}).get("distribution", True):
-                        return ""
-                case x if x.startswith("poetry"):
-                    if not tool_section.get("poetry", {}).get("package-mode", True):
-                        return ""
-            return doc["project"]["name"]
+                if not uv_package:
+                    return ""
+            else:
+                match doc["build-system"]["build-backend"]:
+                    case "pdm.backend":
+                        if not tool_section.get("pdm", {}).get("distribution", True):
+                            return ""
+                    case x if x.startswith("poetry"):
+                        if not tool_section.get("poetry", {}).get("package-mode", True):
+                            return ""
+            return cast(str, doc["project"]["name"])
         return ""
 
     def _gen(self) -> str:
@@ -1841,7 +1946,7 @@ class MakeDeps(DryRun):
         elif self._tool == "uv":
             uv_sync = "uv sync"
             if project := self.get_package_name():
-                uv_sync += f" --reinstall-package={project}"
+                uv_sync += " " + _quote_shell_arg(f"--reinstall-package={project}")
             uv_sync += " --inexact" * self._inexact + " --active" * self._active
             return uv_sync + (
                 " --no-dev" if self._prod else " --all-extras --all-groups"
@@ -1948,7 +2053,7 @@ class UvPypi(DryRun):
 
     @staticmethod
     def get_target_content(
-        text: str, verbose: bool, target_registry, target_host: str
+        text: str, verbose: bool, target_registry: str, target_host: str
     ) -> str | None:
         registry_pattern = r'(registry = ")(.*?)"'
         registry_urls = {i[1] for i in re.findall(registry_pattern, text)}

{fast_dev_cli-0.25.0 → fast_dev_cli-0.25.2}/pyproject.toml

@@ -29,7 +29,7 @@ dependencies = [
     "typer>=0.24.0,<1",
     "tomli >=2.0.1,<3; python_version < '3.11'",
 ]
-version = "0.25.0"
+version = "0.25.2"
 
 [project.urls]
 Homepage = "https://github.com/waketzheng/fast-dev-cli"
@@ -184,10 +184,13 @@ extend-select = [
 [tool.ruff.lint.per-file-ignores]
 "test_*.py" = [
     "E501",
+    "BLE001",
+    "PLW1510",
 ]
 "scripts/*.py" = [
     "UP009",
     "UP032",
+    "PLW1510",
 ]
 "fast_dev_cli/cli.py" = [
     "UP007",

fast_dev_cli-0.25.0/fast_dev_cli/__init__.py

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