|
from logging import getLogger |
|
from pathlib import Path |
|
from typing import Any, Union |
|
|
|
import typer |
|
from rich import print |
|
from rich.padding import Padding |
|
from rich.panel import Panel |
|
from typing_extensions import Annotated |
|
|
|
from fastapi_cli.discover import get_import_string |
|
from fastapi_cli.exceptions import FastAPICLIException |
|
|
|
from . import __version__ |
|
from .logging import setup_logging |
|
|
|
app = typer.Typer(rich_markup_mode="rich") |
|
|
|
setup_logging() |
|
logger = getLogger(__name__) |
|
|
|
try: |
|
import uvicorn |
|
except ImportError: |
|
uvicorn = None |
|
|
|
|
|
def version_callback(value: bool) -> None: |
|
if value: |
|
print(f"FastAPI CLI version: [green]{__version__}[/green]") |
|
raise typer.Exit() |
|
|
|
|
|
@app.callback() |
|
def callback( |
|
version: Annotated[ |
|
Union[bool, None], |
|
typer.Option( |
|
"--version", help="Show the version and exit.", callback=version_callback |
|
), |
|
] = None, |
|
) -> None: |
|
""" |
|
FastAPI CLI - The [bold]fastapi[/bold] command line app. 😎 |
|
|
|
Manage your [bold]FastAPI[/bold] projects, run your FastAPI apps, and more. |
|
|
|
Read more in the docs: [link]https://fastapi.tiangolo.com/fastapi-cli/[/link]. |
|
""" |
|
|
|
|
|
def _run( |
|
path: Union[Path, None] = None, |
|
*, |
|
host: str = "127.0.0.1", |
|
port: int = 8000, |
|
reload: bool = True, |
|
workers: Union[int, None] = None, |
|
root_path: str = "", |
|
command: str, |
|
app: Union[str, None] = None, |
|
proxy_headers: bool = False, |
|
) -> None: |
|
try: |
|
use_uvicorn_app = get_import_string(path=path, app_name=app) |
|
except FastAPICLIException as e: |
|
logger.error(str(e)) |
|
raise typer.Exit(code=1) from None |
|
serving_str = f"[dim]Serving at:[/dim] [link]http://{host}:{port}[/link]\n\n[dim]API docs:[/dim] [link]http://{host}:{port}/docs[/link]" |
|
|
|
if command == "dev": |
|
panel = Panel( |
|
f"{serving_str}\n\n[dim]Running in development mode, for production use:[/dim] \n\n[b]fastapi run[/b]", |
|
title="FastAPI CLI - Development mode", |
|
expand=False, |
|
padding=(1, 2), |
|
style="black on yellow", |
|
) |
|
else: |
|
panel = Panel( |
|
f"{serving_str}\n\n[dim]Running in production mode, for development use:[/dim] \n\n[b]fastapi dev[/b]", |
|
title="FastAPI CLI - Production mode", |
|
expand=False, |
|
padding=(1, 2), |
|
style="green", |
|
) |
|
print(Padding(panel, 1)) |
|
if not uvicorn: |
|
raise FastAPICLIException( |
|
"Could not import Uvicorn, try running 'pip install uvicorn'" |
|
) from None |
|
uvicorn.run( |
|
app=use_uvicorn_app, |
|
host=host, |
|
port=port, |
|
reload=reload, |
|
workers=workers, |
|
root_path=root_path, |
|
proxy_headers=proxy_headers, |
|
) |
|
|
|
|
|
@app.command() |
|
def dev( |
|
path: Annotated[ |
|
Union[Path, None], |
|
typer.Argument( |
|
help="A path to a Python file or package directory (with [blue]__init__.py[/blue] files) containing a [bold]FastAPI[/bold] app. If not provided, a default set of paths will be tried." |
|
), |
|
] = None, |
|
*, |
|
host: Annotated[ |
|
str, |
|
typer.Option( |
|
help="The host to serve on. For local development in localhost use [blue]127.0.0.1[/blue]. To enable public access, e.g. in a container, use all the IP addresses available with [blue]0.0.0.0[/blue]." |
|
), |
|
] = "127.0.0.1", |
|
port: Annotated[ |
|
int, |
|
typer.Option( |
|
help="The port to serve on. You would normally have a termination proxy on top (another program) handling HTTPS on port [blue]443[/blue] and HTTP on port [blue]80[/blue], transferring the communication to your app." |
|
), |
|
] = 8000, |
|
reload: Annotated[ |
|
bool, |
|
typer.Option( |
|
help="Enable auto-reload of the server when (code) files change. This is [bold]resource intensive[/bold], use it only during development." |
|
), |
|
] = True, |
|
root_path: Annotated[ |
|
str, |
|
typer.Option( |
|
help="The root path is used to tell your app that it is being served to the outside world with some [bold]path prefix[/bold] set up in some termination proxy or similar." |
|
), |
|
] = "", |
|
app: Annotated[ |
|
Union[str, None], |
|
typer.Option( |
|
help="The name of the variable that contains the [bold]FastAPI[/bold] app in the imported module or package. If not provided, it is detected automatically." |
|
), |
|
] = None, |
|
proxy_headers: Annotated[ |
|
bool, |
|
typer.Option( |
|
help="Enable/Disable X-Forwarded-Proto, X-Forwarded-For, X-Forwarded-Port to populate remote address info." |
|
), |
|
] = True, |
|
) -> Any: |
|
""" |
|
Run a [bold]FastAPI[/bold] app in [yellow]development[/yellow] mode. 🧪 |
|
|
|
This is equivalent to [bold]fastapi run[/bold] but with [bold]reload[/bold] enabled and listening on the [blue]127.0.0.1[/blue] address. |
|
|
|
It automatically detects the Python module or package that needs to be imported based on the file or directory path passed. |
|
|
|
If no path is passed, it tries with: |
|
|
|
- [blue]main.py[/blue] |
|
- [blue]app.py[/blue] |
|
- [blue]api.py[/blue] |
|
- [blue]app/main.py[/blue] |
|
- [blue]app/app.py[/blue] |
|
- [blue]app/api.py[/blue] |
|
|
|
It also detects the directory that needs to be added to the [bold]PYTHONPATH[/bold] to make the app importable and adds it. |
|
|
|
It detects the [bold]FastAPI[/bold] app object to use. By default it looks in the module or package for an object named: |
|
|
|
- [blue]app[/blue] |
|
- [blue]api[/blue] |
|
|
|
Otherwise, it uses the first [bold]FastAPI[/bold] app found in the imported module or package. |
|
""" |
|
_run( |
|
path=path, |
|
host=host, |
|
port=port, |
|
reload=reload, |
|
root_path=root_path, |
|
app=app, |
|
command="dev", |
|
proxy_headers=proxy_headers, |
|
) |
|
|
|
|
|
@app.command() |
|
def run( |
|
path: Annotated[ |
|
Union[Path, None], |
|
typer.Argument( |
|
help="A path to a Python file or package directory (with [blue]__init__.py[/blue] files) containing a [bold]FastAPI[/bold] app. If not provided, a default set of paths will be tried." |
|
), |
|
] = None, |
|
*, |
|
host: Annotated[ |
|
str, |
|
typer.Option( |
|
help="The host to serve on. For local development in localhost use [blue]127.0.0.1[/blue]. To enable public access, e.g. in a container, use all the IP addresses available with [blue]0.0.0.0[/blue]." |
|
), |
|
] = "0.0.0.0", |
|
port: Annotated[ |
|
int, |
|
typer.Option( |
|
help="The port to serve on. You would normally have a termination proxy on top (another program) handling HTTPS on port [blue]443[/blue] and HTTP on port [blue]80[/blue], transferring the communication to your app." |
|
), |
|
] = 8000, |
|
reload: Annotated[ |
|
bool, |
|
typer.Option( |
|
help="Enable auto-reload of the server when (code) files change. This is [bold]resource intensive[/bold], use it only during development." |
|
), |
|
] = False, |
|
workers: Annotated[ |
|
Union[int, None], |
|
typer.Option( |
|
help="Use multiple worker processes. Mutually exclusive with the --reload flag." |
|
), |
|
] = None, |
|
root_path: Annotated[ |
|
str, |
|
typer.Option( |
|
help="The root path is used to tell your app that it is being served to the outside world with some [bold]path prefix[/bold] set up in some termination proxy or similar." |
|
), |
|
] = "", |
|
app: Annotated[ |
|
Union[str, None], |
|
typer.Option( |
|
help="The name of the variable that contains the [bold]FastAPI[/bold] app in the imported module or package. If not provided, it is detected automatically." |
|
), |
|
] = None, |
|
proxy_headers: Annotated[ |
|
bool, |
|
typer.Option( |
|
help="Enable/Disable X-Forwarded-Proto, X-Forwarded-For, X-Forwarded-Port to populate remote address info." |
|
), |
|
] = True, |
|
) -> Any: |
|
""" |
|
Run a [bold]FastAPI[/bold] app in [green]production[/green] mode. 🚀 |
|
|
|
This is equivalent to [bold]fastapi dev[/bold] but with [bold]reload[/bold] disabled and listening on the [blue]0.0.0.0[/blue] address. |
|
|
|
It automatically detects the Python module or package that needs to be imported based on the file or directory path passed. |
|
|
|
If no path is passed, it tries with: |
|
|
|
- [blue]main.py[/blue] |
|
- [blue]app.py[/blue] |
|
- [blue]api.py[/blue] |
|
- [blue]app/main.py[/blue] |
|
- [blue]app/app.py[/blue] |
|
- [blue]app/api.py[/blue] |
|
|
|
It also detects the directory that needs to be added to the [bold]PYTHONPATH[/bold] to make the app importable and adds it. |
|
|
|
It detects the [bold]FastAPI[/bold] app object to use. By default it looks in the module or package for an object named: |
|
|
|
- [blue]app[/blue] |
|
- [blue]api[/blue] |
|
|
|
Otherwise, it uses the first [bold]FastAPI[/bold] app found in the imported module or package. |
|
""" |
|
_run( |
|
path=path, |
|
host=host, |
|
port=port, |
|
reload=reload, |
|
workers=workers, |
|
root_path=root_path, |
|
app=app, |
|
command="run", |
|
proxy_headers=proxy_headers, |
|
) |
|
|
|
|
|
def main() -> None: |
|
app() |
|
|