fastapi-cli 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

fastapi_cli/__init__.py

@@ -1,3 +1 @@
-from importlib_metadata import version
-
-__version__ = version(__package__)
+__version__ = "0.0.2"

fastapi_cli/__main__.py

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

fastapi_cli/cli.py

@@ -0,0 +1,260 @@
+from logging import getLogger
+from pathlib import Path
+from typing import Any, Union
+
+import typer
+import uvicorn
+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__)
+
+
+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,
+    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))
+    uvicorn.run(
+        app=use_uvicorn_app,
+        host=host,
+        port=port,
+        reload=reload,
+        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,
+    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,
+        root_path=root_path,
+        app=app,
+        command="run",
+        proxy_headers=proxy_headers,
+    )
+
+
+def main() -> None:
+    app()

fastapi_cli/discover.py

@@ -0,0 +1,163 @@
+import importlib
+import sys
+from dataclasses import dataclass
+from logging import getLogger
+from pathlib import Path
+from typing import Union
+
+from fastapi import FastAPI
+from rich import print
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.tree import Tree
+
+from fastapi_cli.exceptions import FastAPICLIException
+
+logger = getLogger(__name__)
+
+
+def get_default_path() -> Path:
+    path = Path("main.py")
+    if path.is_file():
+        return path
+    path = Path("app.py")
+    if path.is_file():
+        return path
+    path = Path("api.py")
+    if path.is_file():
+        return path
+    path = Path("app/main.py")
+    if path.is_file():
+        return path
+    path = Path("app/app.py")
+    if path.is_file():
+        return path
+    path = Path("app/api.py")
+    if path.is_file():
+        return path
+    raise FastAPICLIException(
+        "Could not find a default file to run, please provide an explicit path"
+    )
+
+
+@dataclass
+class ModuleData:
+    module_import_str: str
+    extra_sys_path: Path
+
+
+def get_module_data_from_path(path: Path) -> ModuleData:
+    logger.info(
+        "Searching for package file structure from directories with [blue]__init__.py[/blue] files"
+    )
+    use_path = path.resolve()
+    module_path = use_path
+    if use_path.is_file() and use_path.stem == "__init__":
+        module_path = use_path.parent
+    module_paths = [module_path]
+    extra_sys_path = module_path.parent
+    for parent in module_path.parents:
+        init_path = parent / "__init__.py"
+        if init_path.is_file():
+            module_paths.insert(0, parent)
+            extra_sys_path = parent.parent
+        else:
+            break
+    logger.info(f"Importing from {extra_sys_path.resolve()}")
+    root = module_paths[0]
+    name = f"🐍 {root.name}" if root.is_file() else f"📁 {root.name}"
+    root_tree = Tree(name)
+    if root.is_dir():
+        root_tree.add("[dim]🐍 __init__.py[/dim]")
+    tree = root_tree
+    for sub_path in module_paths[1:]:
+        sub_name = (
+            f"🐍 {sub_path.name}" if sub_path.is_file() else f"📁 {sub_path.name}"
+        )
+        tree = tree.add(sub_name)
+        if sub_path.is_dir():
+            tree.add("[dim]🐍 __init__.py[/dim]")
+    title = "[b green]Python module file[/b green]"
+    if len(module_paths) > 1 or module_path.is_dir():
+        title = "[b green]Python package file structure[/b green]"
+    panel = Padding(
+        Panel(
+            root_tree,
+            title=title,
+            expand=False,
+            padding=(1, 2),
+        ),
+        1,
+    )
+    print(panel)
+    module_str = ".".join(p.stem for p in module_paths)
+    logger.info(f"Importing module [green]{module_str}[/green]")
+    return ModuleData(
+        module_import_str=module_str, extra_sys_path=extra_sys_path.resolve()
+    )
+
+
+def get_app_name(*, mod_data: ModuleData, app_name: Union[str, None] = None) -> str:
+    try:
+        mod = importlib.import_module(mod_data.module_import_str)
+    except (ImportError, ValueError) as e:
+        logger.error(f"Import error: {e}")
+        logger.warning(
+            "Ensure all the package directories have an [blue]__init__.py[/blue] file"
+        )
+        raise
+    object_names = dir(mod)
+    object_names_set = set(object_names)
+    if app_name:
+        if app_name not in object_names_set:
+            raise FastAPICLIException(
+                f"Could not find app name {app_name} in {mod_data.module_import_str}"
+            )
+        app = getattr(mod, app_name)
+        if not isinstance(app, FastAPI):
+            raise FastAPICLIException(
+                f"The app name {app_name} in {mod_data.module_import_str} doesn't seem to be a FastAPI app"
+            )
+        return app_name
+    for preferred_name in ["app", "api"]:
+        if preferred_name in object_names_set:
+            obj = getattr(mod, preferred_name)
+            if isinstance(obj, FastAPI):
+                return preferred_name
+    for name in object_names:
+        obj = getattr(mod, name)
+        if isinstance(obj, FastAPI):
+            return name
+    raise FastAPICLIException("Could not find FastAPI app in module, try using --app")
+
+
+def get_import_string(
+    *, path: Union[Path, None] = None, app_name: Union[str, None] = None
+) -> str:
+    if not path:
+        path = get_default_path()
+    logger.info(f"Using path [blue]{path}[/blue]")
+    logger.info(f"Resolved absolute path {path.resolve()}")
+    if not path.exists():
+        raise FastAPICLIException(f"Path does not exist {path}")
+    mod_data = get_module_data_from_path(path)
+    sys.path.insert(0, str(mod_data.extra_sys_path))
+    use_app_name = get_app_name(mod_data=mod_data, app_name=app_name)
+    import_example = Syntax(
+        f"from {mod_data.module_import_str} import {use_app_name}", "python"
+    )
+    import_panel = Padding(
+        Panel(
+            import_example,
+            title="[b green]Importable FastAPI app[/b green]",
+            expand=False,
+            padding=(1, 2),
+        ),
+        1,
+    )
+    logger.info("Found importable FastAPI app")
+    print(import_panel)
+    import_string = f"{mod_data.module_import_str}:{use_app_name}"
+    logger.info(f"Using import string [b green]{import_string}[/b green]")
+    return import_string

fastapi_cli/exceptions.py

@@ -0,0 +1,2 @@
+class FastAPICLIException(Exception):
+    pass

fastapi_cli/logging.py

@@ -0,0 +1,23 @@
+import logging
+from typing import Union
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+def setup_logging(terminal_width: Union[int, None] = None) -> None:
+    logger = logging.getLogger("fastapi_cli")
+    console = Console(width=terminal_width) if terminal_width else None
+    rich_handler = RichHandler(
+        show_time=False,
+        rich_tracebacks=True,
+        tracebacks_show_locals=True,
+        markup=True,
+        show_path=False,
+        console=console,
+    )
+    rich_handler.setFormatter(logging.Formatter("%(message)s"))
+    logger.addHandler(rich_handler)
+
+    logger.setLevel(logging.INFO)
+    logger.propagate = False

fastapi_cli-0.0.2.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.1
+Name: fastapi-cli
+Version: 0.0.2
+Summary: Run and manage FastAPI apps from the command line with FastAPI CLI. 🚀
+Home-page: https://github.com/tiangolo/fastapi-cli
+Author-Email: =?utf-8?q?Sebasti=C3=A1n_Ram=C3=ADrez?= <tiangolo@gmail.com>
+License: MIT
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Project-URL: Documentation, https://fastapi.tiangolo.com
+Project-URL: Homepage, https://github.com/tiangolo/fastapi-cli
+Project-URL: Repository, https://github.com/tiangolo/fastapi-cli
+Requires-Python: >=3.8
+Requires-Dist: typer>=0.12.3
+Requires-Dist: fastapi
+Requires-Dist: uvicorn[standard]>=0.29.0
+Description-Content-Type: text/markdown
+
+# FastAPI CLI
+
+<a href="https://github.com/tiangolo/fastapi-cli/actions/workflows/test.yml" target="_blank">
+    <img src="https://github.com/tiangolo/fastapi-cli/actions/workflows/test.yml/badge.svg" alt="Test">
+</a>
+<a href="https://github.com/tiangolo/fastapi-cli/actions/workflows/publish.yml" target="_blank">
+    <img src="https://github.com/tiangolo/fastapi-cli/actions/workflows/publish.yml/badge.svg" alt="Publish">
+</a>
+<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/tiangolo/fastapi-cli" target="_blank">
+    <img src="https://coverage-badge.samuelcolvin.workers.dev/tiangolo/fastapi-cli.svg" alt="Coverage">
+<a href="https://pypi.org/project/fastapi-cli" target="_blank">
+    <img src="https://img.shields.io/pypi/v/fastapi-cli?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+
+---
+
+**Source Code**: <a href="https://github.com/tiangolo/fastapi-cli" target="_blank">https://github.com/tiangolo/fastapi-cli</a>
+
+---
+
+Run and manage FastAPI apps from the command line with FastAPI CLI. 🚀
+
+## Description
+
+**FastAPI CLI** is a command line program `fastapi` that you can use to serve your FastAPI app, manage your FastAPI project, and more.
+
+When you install FastAPI (e.g. with `pip install fastapi`), it includes a package called `fastapi-cli`, this package provides the `fastapi` command in the terminal.
+
+To run your FastAPI app for development, you can use the `fastapi dev` command:
+
+<div class="termy">
+
+```console
+$ fastapi dev main.py
+INFO     Using path main.py
+INFO     Resolved absolute path /home/user/code/awesomeapp/main.py
+INFO     Searching for package file structure from directories with __init__.py files
+INFO     Importing from /home/user/code/awesomeapp
+
+ ╭─ Python module file ─╮
+ │                      │
+ │  🐍 main.py          │
+ │                      │
+ ╰──────────────────────╯
+
+INFO     Importing module main
+INFO     Found importable FastAPI app
+
+ ╭─ Importable FastAPI app ─╮
+ │                          │
+ │  from main import app    │
+ │                          │
+ ╰──────────────────────────╯
+
+INFO     Using import string main:app
+
+ ╭────────── FastAPI CLI - Development mode ───────────╮
+ │                                                     │
+ │  Serving at: http://127.0.0.1:8000                  │
+ │                                                     │
+ │  API docs: http://127.0.0.1:8000/docs               │
+ │                                                     │
+ │  Running in development mode, for production use:   │
+ │                                                     │
+ │  fastapi run                                        │
+ │                                                     │
+ ╰─────────────────────────────────────────────────────╯
+
+INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
+INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+INFO:     Started reloader process [56345] using WatchFiles
+INFO:     Started server process [56352]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+```
+
+</div>
+
+That command line program called `fastapi` is **FastAPI CLI**.
+
+FastAPI CLI takes the path to your Python program and automatically detects the variable with the FastAPI (commonly named `app`) and how to import it, and then serves it.
+
+For production you would use `fastapi run` instead. 🚀
+
+## `fastapi dev`
+
+When you run `fastapi dev`, it will run on development mode.
+
+By default, it will have **auto-reload** enabled, so it will automatically reload the server when you make changes to your code. This is resource intensive and could be less stable than without it, you should only use it for development.
+
+By default it will listen on the IP address `127.0.0.1`, which is the IP for your machine to communicate with itself alone (`localhost`).
+
+## `fastapi run`
+
+When you run `fastapi run`, it will run on production mode by default.
+
+It will have **auto-reload disabled** by default.
+
+It will listen on the IP address `0.0.0.0`, which means all the available IP addresses, this way it will be publicly accessible to anyone that can communicate with the machine. This is how you would normally run it in production, for example, in a container.
+
+In most cases you would (and should) have a "termination proxy" handling HTTPS for you on top, this will depend on how you deploy your application, your provider might do this for you, or you might need to set it up yourself. You can learn more about it in the <a href="https://fastapi.tiangolo.com/deployment/" class="external-link" target="_blank">FastAPI Deployment documentation</a>.
+
+## License
+
+This project is licensed under the terms of the MIT license.

fastapi_cli-0.0.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+fastapi_cli-0.0.2.dist-info/METADATA,sha256=DADt2yADHsKGZzCrzC4bcnF7ZKyHZnmaGPXSjmEzRVc,6780
+fastapi_cli-0.0.2.dist-info/WHEEL,sha256=vnE8JVcI2Wz7GRKorsPArnBdnW2SWKWGow5gu5tHlRU,90
+fastapi_cli-0.0.2.dist-info/entry_points.txt,sha256=RLUGtkrAf9gNKxCS3EeJNYN8AF1Er364vjW7bnEcCA8,50
+fastapi_cli-0.0.2.dist-info/licenses/LICENSE,sha256=FqD5B4VbXJnefprQseE0U8llL6FxojC-i8muZy7YmSU,1086
+fastapi_cli/__init__.py,sha256=QvlVh4JTl3JL7jQAja76yKtT-IvF4631ASjWY1wS6AQ,22
+fastapi_cli/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+fastapi_cli/cli.py,sha256=OkiQenSf9HgBN7FxTTAoLfzqySsX1Z6FGxlRU7ILcGM,8754
+fastapi_cli/discover.py,sha256=5QbjDHEbfNUQoYG7ZXRfYWvSJkj74ojkFtzUftPb2VE,5285
+fastapi_cli/exceptions.py,sha256=AHRSqd43fbqN5IpX-Fq389k9MoEK_q28wVFL7oqPNcc,47
+fastapi_cli/logging.py,sha256=lI7rIsioTJQsxDuWpG5YR_brWpIAUY4vDnhYm5p91ws,664
+fastapi_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_cli-0.0.2.dist-info/RECORD,,

{fastapi_cli-0.0.1.dist-info → fastapi_cli-0.0.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry 0.12.17
+Generator: pdm-backend (2.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any

fastapi_cli-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+fastapi = fastapi_cli.cli:main
+

fastapi_cli-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Sebastián Ramírez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

fastapi_cli-0.0.1.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.1
-Name: fastapi-cli
-Version: 0.0.1
-Summary: 
-Author: Sebastián Ramírez
-Author-email: tiangolo@gmail.com
-Requires-Python: >=3.6,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Requires-Dist: importlib_metadata (>=1.5,<2.0)

fastapi_cli-0.0.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-fastapi_cli/__init__.py,sha256=5RpLGahop916SeM-IBybvWyDoKIuatfa3Aw-NIlBIgA,75
-fastapi_cli-0.0.1.dist-info/WHEEL,sha256=f_L0I4hqSDuunYLcjib7afhVEQa4uCwremk0_wPx54s,85
-fastapi_cli-0.0.1.dist-info/METADATA,sha256=w7fBwjwDWvtDXARBL_HqBIUjTa0r76nhlyhsXm2UEgw,349
-fastapi_cli-0.0.1.dist-info/RECORD,,