fastapi-cli 0.0.24__tar.gz → 0.0.26__tar.gz

{fastapi_cli-0.0.24 → fastapi_cli-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cli
-Version: 0.0.24
+Version: 0.0.26
 Summary: Run and manage FastAPI apps from the command line with FastAPI CLI. 🚀
 Author-Email: =?utf-8?q?Sebasti=C3=A1n_Ram=C3=ADrez?= <tiangolo@gmail.com>
 License-Expression: MIT

{fastapi_cli-0.0.24 → fastapi_cli-0.0.26}/pyproject.toml

@@ -38,7 +38,7 @@ dependencies = [
     "rich-toolkit >= 0.14.8",
     "tomli >= 2.0.0; python_version < '3.11'",
 ]
-version = "0.0.24"
+version = "0.0.26"
 
 [project.optional-dependencies]
 standard = [
@@ -63,6 +63,7 @@ Changelog = "https://github.com/fastapi/fastapi-cli/blob/main/release-notes.md"
 dev = [
     { include-group = "tests" },
     "prek>=0.2.24,<1.0.0",
+    "zizmor>=1.24.1",
 ]
 github-actions = [
     "smokeshow>=0.5.0",
@@ -70,10 +71,11 @@ github-actions = [
 tests = [
     "coverage[toml]>=6.2,<8.0",
     "fastapi>=0.128.0",
-    "mypy==1.19.1",
+    "mypy==2.1.0",
     "pytest>=7.4.0,<10.0.0",
-    "ruff==0.15.2",
+    "ruff>=0.15.15",
     "uvicorn>=0.39.0",
+    "ty>=0.0.25",
 ]
 
 [build-system]
@@ -161,3 +163,18 @@ known-third-party = [
 
 [tool.ruff.lint.pyupgrade]
 keep-runtime-typing = true
+
+[tool.ty.terminal]
+error-on-warning = true
+
+[tool.typos.files]
+extend-exclude = [
+    "coverage/",
+    "dist/",
+    "release-notes.md",
+    "htmlcov/",
+    "uv.lock",
+]
+
+[tool.typos.default.extend-identifiers]
+alls = "alls"

fastapi_cli-0.0.26/scripts/add_latest_release_date.py

@@ -0,0 +1,40 @@
+"""Check release-notes.md and add today's date to the latest release header if missing."""
+
+import re
+import sys
+from datetime import date
+
+RELEASE_NOTES_FILE = "release-notes.md"
+RELEASE_HEADER_PATTERN = re.compile(r"^## (\d+\.\d+\.\d+)\s*(\(.*\))?\s*$")
+
+
+def main() -> None:
+    with open(RELEASE_NOTES_FILE) as f:
+        lines = f.readlines()
+
+    for i, line in enumerate(lines):
+        match = RELEASE_HEADER_PATTERN.match(line)
+        if not match:
+            continue
+
+        version = match.group(1)
+        date_part = match.group(2)
+
+        if date_part:
+            print(f"Latest release {version} already has a date: {date_part}")
+            sys.exit(0)
+
+        today = date.today().isoformat()
+        lines[i] = f"## {version} ({today})\n"
+        print(f"Added date: {version} ({today})")
+
+        with open(RELEASE_NOTES_FILE, "w") as f:
+            f.writelines(lines)
+        sys.exit(0)
+
+    print("No release header found")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

{fastapi_cli-0.0.24 → fastapi_cli-0.0.26}/scripts/lint.sh

@@ -4,5 +4,6 @@ set -e
 set -x
 
 mypy src tests
+ty check src tests
 ruff check src tests scripts
 ruff format src tests --check

fastapi_cli-0.0.26/scripts/prepare_release.py

@@ -0,0 +1,216 @@
+"""Prepare a release by updating the package version and release notes."""
+
+import re
+from datetime import date
+from enum import Enum
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+VERSION_PATTERN = re.compile(r'(?m)^__version__ = "(\d+\.\d+\.\d+)"$')
+VERSION_HEADING_PATTERN = re.compile(r"(?m)^## (\d+\.\d+\.\d+)(?: \([^)]+\))?$")
+RELEASE_NOTES_HEADER = "# Release Notes\n\n"
+LATEST_CHANGES_HEADER = "## Latest Changes"
+
+
+class BumpType(str, Enum):
+    major = "major"
+    minor = "minor"
+    patch = "patch"
+
+
+app = typer.Typer()
+
+
+def parse_version(version: str) -> tuple[int, int, int]:
+    match = re.fullmatch(r"\d+\.\d+\.\d+", version)
+    if not match:
+        raise ValueError(f"Invalid version: {version!r}. Expected format: X.Y.Z")
+    major, minor, patch = version.split(".")
+    return int(major), int(minor), int(patch)
+
+
+def get_current_version(content: str, version_file: Path) -> str:
+    matches = list(VERSION_PATTERN.finditer(content))
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"Expected exactly one __version__ assignment in {version_file}, "
+            f"found {len(matches)}"
+        )
+    return matches[0].group(1)
+
+
+def bump_version(version: str, bump: BumpType) -> str:
+    major, minor, patch = parse_version(version)
+    if bump is BumpType.major:
+        return f"{major + 1}.0.0"
+    if bump is BumpType.minor:
+        return f"{major}.{minor + 1}.0"
+    return f"{major}.{minor}.{patch + 1}"
+
+
+def update_version_file(content: str, version: str, version_file: Path) -> str:
+    current_version = get_current_version(content, version_file)
+    if parse_version(version) <= parse_version(current_version):
+        raise RuntimeError(
+            f"New version {version} must be greater than current version {current_version}"
+        )
+    return VERSION_PATTERN.sub(f'__version__ = "{version}"', content, count=1)
+
+
+def update_release_notes(
+    content: str, version: str, release_date: date, release_notes_file: Path
+) -> str:
+    if not content.startswith(RELEASE_NOTES_HEADER):
+        raise RuntimeError(
+            f"{release_notes_file} must start with {RELEASE_NOTES_HEADER!r}"
+        )
+    if re.search(rf"^## {re.escape(version)}(?: \([^)]+\))?$", content, re.M):
+        raise RuntimeError(f"Release notes already contain a section for {version}")
+
+    latest_header = f"{RELEASE_NOTES_HEADER}{LATEST_CHANGES_HEADER}\n"
+    if not content.startswith(latest_header):
+        raise RuntimeError(f"{release_notes_file} must start with {latest_header!r}")
+
+    release_header = f"## {version} ({release_date.isoformat()})"
+    return content.replace(
+        latest_header,
+        f"{RELEASE_NOTES_HEADER}{LATEST_CHANGES_HEADER}\n\n{release_header}\n",
+        1,
+    )
+
+
+def get_release_notes_body(content: str, version: str, release_notes_file: Path) -> str:
+    version_heading = re.compile(rf"(?m)^## {re.escape(version)}(?: \([^)]+\))?$")
+    match = version_heading.search(content)
+    if not match:
+        raise RuntimeError(
+            f"Could not find release notes section for {version} in {release_notes_file}"
+        )
+
+    next_match = VERSION_HEADING_PATTERN.search(content, match.end())
+    end = next_match.start() if next_match else len(content)
+    body = content[match.end() : end].strip()
+    if not body:
+        raise RuntimeError(
+            f"Release notes section for {version} in {release_notes_file} is empty"
+        )
+    return f"{body}\n"
+
+
+@app.command()
+def prepare(
+    bump: Annotated[
+        BumpType,
+        typer.Argument(
+            envvar="PREPARE_RELEASE_BUMP",
+            help="The release bump to make: major, minor, or patch.",
+        ),
+    ],
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            writable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+    release_notes_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_RELEASE_NOTES_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            writable=True,
+            help="Path to the release notes Markdown file.",
+        ),
+    ],
+    release_date: Annotated[
+        str,
+        typer.Option(
+            "--date",
+            envvar="PREPARE_RELEASE_DATE",
+            help="Release date in YYYY-MM-DD format. Defaults to today.",
+        ),
+    ] = date.today().isoformat(),
+) -> None:
+    parsed_release_date = date.fromisoformat(release_date or date.today().isoformat())
+
+    version_file_content = version_file.read_text()
+    release_notes_content = release_notes_file.read_text()
+    version = bump_version(
+        get_current_version(version_file_content, version_file), bump
+    )
+
+    version_file.write_text(
+        update_version_file(version_file_content, version, version_file)
+    )
+    release_notes_file.write_text(
+        update_release_notes(
+            release_notes_content, version, parsed_release_date, release_notes_file
+        )
+    )
+
+    typer.echo(f"Prepared release {version} ({parsed_release_date.isoformat()})")
+
+
+@app.command()
+def current_version(
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+) -> None:
+    typer.echo(get_current_version(version_file.read_text(), version_file))
+
+
+@app.command()
+def release_notes(
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+    release_notes_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_RELEASE_NOTES_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the release notes Markdown file.",
+        ),
+    ],
+) -> None:
+    version = get_current_version(version_file.read_text(), version_file)
+    typer.echo(
+        get_release_notes_body(
+            release_notes_file.read_text(), version, release_notes_file
+        ),
+        nl=False,
+    )
+
+
+if __name__ == "__main__":
+    app()

fastapi_cli-0.0.26/src/fastapi_cli/__init__.py

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

{fastapi_cli-0.0.24 → fastapi_cli-0.0.26}/src/fastapi_cli/cli.py

@@ -5,10 +5,16 @@ from typing import Annotated, Any
 import typer
 from pydantic import ValidationError
 from rich import print
+from rich.syntax import Syntax
 from rich.tree import Tree
 
 from fastapi_cli.config import FastAPIConfig
-from fastapi_cli.discover import get_import_data, get_import_data_from_import_string
+from fastapi_cli.discover import (
+    AppConfigSource,
+    ModuleConfigSource,
+    get_import_data,
+    get_import_data_from_import_string,
+)
 from fastapi_cli.exceptions import FastAPICLIException
 
 from . import __version__
@@ -22,10 +28,19 @@ app = typer.Typer(
 logger = logging.getLogger(__name__)
 
 
+SOURCE_DESCRIPTIONS: dict[ModuleConfigSource | AppConfigSource, str] = {
+    "entrypoint-option": "[blue]--entrypoint[/] CLI option",
+    "entrypoint-pyproject": "[blue]entrypoint[/] in [blue]pyproject.toml[/]",
+    "path-argument": "[blue]path[/] CLI argument",
+    "app-option": "[blue]--app[/] CLI option",
+    "auto-discovery": "auto-discovery",
+}
+
+
 try:
     import uvicorn
 except ImportError:  # pragma: no cover
-    uvicorn = None  # type: ignore[assignment]
+    uvicorn = None  # type: ignore[assignment]  # ty: ignore[invalid-assignment]
 
 
 try:
@@ -39,7 +54,7 @@ except ImportError:  # pragma: no cover
 
 
 try:
-    from fastapi_new.cli import (  # type: ignore[import-not-found]
+    from fastapi_new.cli import (  # type: ignore[import-not-found]  # ty: ignore[unresolved-import]
         app as fastapi_new_cli,
     )
 
@@ -51,6 +66,15 @@ except ImportError:  # pragma: no cover
 def version_callback(value: bool) -> None:
     if value:
         print(f"FastAPI CLI version: [green]{__version__}[/green]")
+        try:
+            from fastapi_cloud_cli import (
+                __version__ as cloud_cli_version,
+            )
+
+            print(f"FastAPI Cloud CLI version: [green]{cloud_cli_version}[/green]")
+        except ImportError:  # pragma: no cover
+            pass
+
         raise typer.Exit()
 
 
@@ -151,7 +175,9 @@ def _run(
             if path or app:
                 import_data = get_import_data(path=path, app_name=app)
             elif config.entrypoint:
-                import_data = get_import_data_from_import_string(config.entrypoint)
+                import_data = get_import_data_from_import_string(
+                    config.entrypoint, config.from_pyproject
+                )
             else:
                 import_data = get_import_data()
         except FastAPICLIException as e:
@@ -189,6 +215,34 @@ def _run(
             tag="app",
         )
 
+        mod_source_desc = SOURCE_DESCRIPTIONS[import_data.module_config_source]
+        app_source_desc = SOURCE_DESCRIPTIONS[import_data.app_name_config_source]
+        toolkit.print_line()
+        toolkit.print("Configuration sources:", tag="info")
+        if mod_source_desc == app_source_desc:
+            toolkit.print(f" • Import string: {mod_source_desc}")
+        else:
+            toolkit.print(f" • Module: {mod_source_desc}")
+            toolkit.print(f" • App name: {app_source_desc}")
+
+        if import_data.module_config_source == "auto-discovery":
+            toolkit.print_line()
+            toolkit.print(
+                "You can configure an entrypoint in [blue]pyproject.toml[/] for this app with:",
+                tag="tip",
+            )
+            toolkit.print_line()
+            toolkit.print(
+                Syntax(
+                    (
+                        "[tool.fastapi]\n"
+                        f'entrypoint = "{import_data.module_data.module_import_str}:{import_data.app_name}"'
+                    ),
+                    "toml",
+                    theme="ansi_light",
+                )
+            )
+
         url = f"http://{host}:{port}"
         url_docs = f"{url}/docs"
 

{fastapi_cli-0.0.24 → fastapi_cli-0.0.26}/src/fastapi_cli/config.py

@@ -9,6 +9,7 @@ logger = logging.getLogger(__name__)
 
 class FastAPIConfig(BaseModel):
     entrypoint: StrictStr | None = None
+    from_pyproject: bool = False
 
     @classmethod
     def _read_pyproject_toml(cls) -> dict[str, Any]:
@@ -19,7 +20,7 @@ class FastAPIConfig(BaseModel):
             return {}
 
         try:
-            import tomllib  # type: ignore[import-not-found, unused-ignore]
+            import tomllib  # type: ignore[import-not-found, unused-ignore]  # ty: ignore[unresolved-import]
         except ImportError:
             try:
                 import tomli as tomllib  # type: ignore[no-redef, import-not-found, unused-ignore]
@@ -30,7 +31,7 @@ class FastAPIConfig(BaseModel):
         with open(pyproject_path, "rb") as f:
             data = tomllib.load(f)
 
-            return data.get("tool", {}).get("fastapi", {})  # type: ignore
+            return data.get("tool", {}).get("fastapi", {})  # type: ignore[no-any-return]
 
     @classmethod
     def resolve(cls, entrypoint: str | None = None) -> "FastAPIConfig":
@@ -39,4 +40,6 @@ class FastAPIConfig(BaseModel):
         if entrypoint is not None:
             config["entrypoint"] = entrypoint
 
+        config["from_pyproject"] = ("entrypoint" in config) and (entrypoint is None)
+
         return cls.model_validate(config)

{fastapi_cli-0.0.24 → fastapi_cli-0.0.26}/src/fastapi_cli/discover.py

@@ -3,6 +3,7 @@ import sys
 from dataclasses import dataclass
 from logging import getLogger
 from pathlib import Path
+from typing import Literal, TypeAlias
 
 from fastapi_cli.exceptions import FastAPICLIException
 
@@ -11,7 +12,7 @@ logger = getLogger(__name__)
 try:
     from fastapi import FastAPI
 except ImportError:  # pragma: no cover
-    FastAPI = None  # type: ignore[misc, assignment]
+    FastAPI = None  # type: ignore[misc, assignment]  # ty: ignore[invalid-assignment]
 
 
 def get_default_path() -> Path:
@@ -102,18 +103,35 @@ def get_app_name(*, mod_data: ModuleData, app_name: str | None = None) -> str:
     raise FastAPICLIException("Could not find FastAPI app in module, try using --app")
 
 
+ModuleConfigSource: TypeAlias = Literal[
+    "entrypoint-option",
+    "entrypoint-pyproject",
+    "path-argument",
+    "auto-discovery",
+]
+
+AppConfigSource: TypeAlias = Literal[
+    "entrypoint-option", "entrypoint-pyproject", "app-option", "auto-discovery"
+]
+
+
 @dataclass
 class ImportData:
     app_name: str
     module_data: ModuleData
     import_string: str
 
+    module_config_source: ModuleConfigSource
+    app_name_config_source: AppConfigSource
+
 
 def get_import_data(
     *, path: Path | None = None, app_name: str | None = None
 ) -> ImportData:
+    path_config_source: ModuleConfigSource = "path-argument"
     if not path:
         path = get_default_path()
+        path_config_source = "auto-discovery"
 
     logger.debug(f"Using path [blue]{path}[/blue]")
     logger.debug(f"Resolved absolute path {path.resolve()}")
@@ -127,11 +145,17 @@ def get_import_data(
     import_string = f"{mod_data.module_import_str}:{use_app_name}"
 
     return ImportData(
-        app_name=use_app_name, module_data=mod_data, import_string=import_string
+        app_name=use_app_name,
+        module_data=mod_data,
+        import_string=import_string,
+        module_config_source=path_config_source,
+        app_name_config_source="app-option" if app_name else "auto-discovery",
     )
 
 
-def get_import_data_from_import_string(import_string: str) -> ImportData:
+def get_import_data_from_import_string(
+    import_string: str, from_pyproject: bool
+) -> ImportData:
     module_str, _, app_name = import_string.partition(":")
 
     if not module_str or not app_name:
@@ -151,4 +175,10 @@ def get_import_data_from_import_string(import_string: str) -> ImportData:
             module_paths=[],
         ),
         import_string=import_string,
+        module_config_source=(
+            "entrypoint-pyproject" if from_pyproject else "entrypoint-option"
+        ),
+        app_name_config_source=(
+            "entrypoint-pyproject" if from_pyproject else "entrypoint-option"
+        ),
     )

{fastapi_cli-0.0.24 → fastapi_cli-0.0.26}/tests/test_cli.py

@@ -35,6 +35,10 @@ def test_dev() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:app" in result.output
+        assert "Configuration sources:" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting development server 🚀" in result.output
         assert "Server started at http://127.0.0.1:8000" in result.output
         assert "Documentation at http://127.0.0.1:8000/docs" in result.output
@@ -59,6 +63,11 @@ def test_dev_no_args_auto_discovery() -> None:
             assert mock_run.call_args.kwargs["port"] == 8000
             assert mock_run.call_args.kwargs["reload"] is True
         assert "Using import string: main:app" in result.output
+        assert "Configuration sources:" in result.output
+        assert "Import string: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" in result.output
+        assert "[tool.fastapi]" in result.output
+        assert 'entrypoint = "main:app"' in result.output
 
 
 def test_dev_package() -> None:
@@ -81,6 +90,9 @@ def test_dev_package() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: nested_package.package:app" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting development server 🚀" in result.output
         assert "Server started at http://127.0.0.1:8000" in result.output
         assert "Documentation at http://127.0.0.1:8000/docs" in result.output
@@ -131,6 +143,9 @@ def test_dev_args() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:api" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: --app CLI option" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting development server 🚀" in result.output
         assert "Server started at http://192.168.0.2:8080" in result.output
         assert "Documentation at http://192.168.0.2:8080/docs" in result.output
@@ -162,6 +177,9 @@ def test_dev_env_vars() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:app" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting development server 🚀" in result.output
         assert "Server started at http://127.0.0.1:8111" in result.output
         assert "Documentation at http://127.0.0.1:8111/docs" in result.output
@@ -200,6 +218,9 @@ def test_dev_env_vars_and_args() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:app" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting development server 🚀" in result.output
         assert "Server started at http://127.0.0.1:8080" in result.output
         assert "Documentation at http://127.0.0.1:8080/docs" in result.output
@@ -246,6 +267,9 @@ def test_run() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:app" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting production server 🚀" in result.output
         assert "Server started at http://0.0.0.0:8000" in result.output
         assert "Documentation at http://0.0.0.0:8000/docs" in result.output
@@ -321,6 +345,9 @@ def test_run_args() -> None:
             }
 
         assert "Using import string: single_file_app:api" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: --app CLI option" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting production server 🚀" in result.output
         assert "Server started at http://192.168.0.2:8080" in result.output
         assert "Documentation at http://192.168.0.2:8080/docs" in result.output
@@ -352,6 +379,9 @@ def test_run_env_vars() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:app" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting production server 🚀" in result.output
         assert "Server started at http://0.0.0.0:8111" in result.output
         assert "Documentation at http://0.0.0.0:8111/docs" in result.output
@@ -386,6 +416,9 @@ def test_run_env_vars_and_args() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:app" in result.output
+        assert "Module: path CLI argument" in result.output
+        assert "App name: auto-discovery" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
         assert "Starting production server 🚀" in result.output
         assert "Server started at http://0.0.0.0:8080" in result.output
         assert "Documentation at http://0.0.0.0:8080/docs" in result.output
@@ -452,6 +485,7 @@ def test_version() -> None:
     result = runner.invoke(app, ["--version"])
     assert result.exit_code == 0, result.output
     assert "FastAPI CLI version:" in result.output
+    assert "FastAPI Cloud CLI version:" in result.output
 
 
 def test_dev_reload_dir() -> None:
@@ -498,6 +532,8 @@ def test_dev_with_import_string() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:api" in result.output
+        assert "Import string: --entrypoint CLI option" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
 
 
 def test_run_with_import_string() -> None:
@@ -520,6 +556,8 @@ def test_run_with_import_string() -> None:
                 "log_config": get_uvicorn_log_config(),
             }
         assert "Using import string: single_file_app:app" in result.output
+        assert "Import string: --entrypoint CLI option" in result.output
+        assert "You can configure an entrypoint in pyproject.toml" not in result.output
 
 
 def test_script() -> None: