fal 0.15.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

fal/cli/apps.py

@@ -0,0 +1,313 @@
+from typing import TYPE_CHECKING
+
+from .parser import FalClientParser
+
+if TYPE_CHECKING:
+    from fal.sdk import AliasInfo, ApplicationInfo
+
+
+def _apps_table(apps: list["AliasInfo"]):
+    from rich.table import Table
+
+    table = Table()
+    table.add_column("Name", no_wrap=True)
+    table.add_column("Revision")
+    table.add_column("Auth")
+    table.add_column("Min Concurrency")
+    table.add_column("Max Concurrency")
+    table.add_column("Max Multiplexing")
+    table.add_column("Keep Alive")
+    table.add_column("Active Workers")
+
+    for app in apps:
+        table.add_row(
+            app.alias,
+            app.revision,
+            app.auth_mode,
+            str(app.min_concurrency),
+            str(app.max_concurrency),
+            str(app.max_multiplexing),
+            str(app.keep_alive),
+            str(app.active_runners),
+        )
+
+    return table
+
+
+def _list(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        apps = connection.list_aliases()
+        table = _apps_table(apps)
+
+    args.console.print(table)
+
+
+def _add_list_parser(subparsers, parents):
+    list_help = "List applications."
+    parser = subparsers.add_parser(
+        "list",
+        description=list_help,
+        help=list_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_list)
+
+
+def _app_rev_table(revs: list["ApplicationInfo"]):
+    from rich.table import Table
+
+    table = Table()
+    table.add_column("Revision", no_wrap=True)
+    table.add_column("Min Concurrency")
+    table.add_column("Max Concurrency")
+    table.add_column("Max Multiplexing")
+    table.add_column("Keep Alive")
+    table.add_column("Active Workers")
+
+    for rev in revs:
+        table.add_row(
+            rev.application_id,
+            str(rev.min_concurrency),
+            str(rev.max_concurrency),
+            str(rev.max_multiplexing),
+            str(rev.keep_alive),
+            str(rev.active_runners),
+        )
+
+    return table
+
+
+def _list_rev(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        revs = connection.list_applications()
+        table = _app_rev_table(revs)
+
+    args.console.print(table)
+
+
+def _add_list_rev_parser(subparsers, parents):
+    list_help = "List application revisions."
+    parser = subparsers.add_parser(
+        "list-rev",
+        description=list_help,
+        help=list_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_list_rev)
+
+
+def _scale(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        if (
+            args.keep_alive is None
+            and args.max_multiplexing is None
+            and args.max_concurrency is None
+            and args.min_concurrency is None
+        ):
+            args.console.log("No parameters for update were provided, ignoring.")
+            return
+
+        alias_info = connection.update_application(
+            application_name=args.app_alias,
+            keep_alive=args.keep_alive,
+            max_multiplexing=args.max_multiplexing,
+            max_concurrency=args.max_concurrency,
+            min_concurrency=args.min_concurrency,
+        )
+        table = _apps_table([alias_info])
+
+    args.console.print(table)
+
+
+def _add_scale_parser(subparsers, parents):
+    scale_help = "Scale application."
+    parser = subparsers.add_parser(
+        "scale",
+        description=scale_help,
+        help=scale_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "--keep-alive",
+        type=int,
+        help="Keep alive (seconds).",
+    )
+    parser.add_argument(
+        "--max-multiplexing",
+        type=int,
+        help="Maximum multiplexing",
+    )
+    parser.add_argument(
+        "--max-concurrency",
+        type=int,
+        help="Maximum concurrency.",
+    )
+    parser.add_argument(
+        "--min-concurrency",
+        type=int,
+        help="Minimum concurrency",
+    )
+    parser.set_defaults(func=_scale)
+
+
+def _set_rev(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.create_alias(args.app_name, args.app_rev, args.auth)
+
+
+def _add_set_rev_parser(subparsers, parents):
+    from fal.sdk import ALIAS_AUTH_MODES
+
+    set_help = "Set application to a particular revision."
+    parser = subparsers.add_parser(
+        "set-rev",
+        description=set_help,
+        help=set_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_name",
+        help="Application name.",
+    )
+    parser.add_argument(
+        "app_rev",
+        help="Application revision.",
+    )
+    parser.add_argument(
+        "--auth",
+        choices=ALIAS_AUTH_MODES,
+        default="private",
+        help="Application authentication mode.",
+    )
+    parser.set_defaults(func=_set_rev)
+
+
+def _runners(args):
+    from rich.table import Table
+
+    from fal.sdk import FalServerlessClient
+
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        runners = connection.list_alias_runners(alias=args.app_name)
+
+    table = Table()
+    table.add_column("Runner ID")
+    table.add_column("In Flight Requests")
+    table.add_column("Expires in")
+    table.add_column("Uptime")
+
+    for runner in runners:
+        table.add_row(
+            runner.runner_id,
+            str(runner.in_flight_requests),
+            (
+                "N/A (active)"
+                if not runner.expiration_countdown
+                else f"{runner.expiration_countdown}s"
+            ),
+            f"{runner.uptime} ({runner.uptime.total_seconds()}s)",
+        )
+
+    args.console.print(table)
+
+
+def _add_runners_parser(subparsers, parents):
+    runners_help = "List application runners."
+    parser = subparsers.add_parser(
+        "runners",
+        description=runners_help,
+        help=runners_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_name",
+        help="Application name.",
+    )
+    parser.set_defaults(func=_runners)
+
+
+def _delete(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.delete_alias(args.app_name)
+
+
+def _add_delete_parser(subparsers, parents):
+    delete_help = "Delete application."
+    parser = subparsers.add_parser(
+        "delete",
+        description=delete_help,
+        help=delete_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_name",
+        help="Application name.",
+    )
+    parser.set_defaults(func=_delete)
+
+
+def _delete_rev(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.delete_application(args.app_rev)
+
+
+def _add_delete_rev_parser(subparsers, parents):
+    delete_help = "Delete application revision."
+    parser = subparsers.add_parser(
+        "delete-rev",
+        description=delete_help,
+        help=delete_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_rev",
+        help="Application revision.",
+    )
+    parser.set_defaults(func=_delete_rev)
+
+
+def add_parser(main_subparsers, parents):
+    apps_help = "Manage fal applications."
+    parser = main_subparsers.add_parser(
+        "apps",
+        aliases=["app"],
+        description=apps_help,
+        help=apps_help,
+        parents=parents,
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        required=True,
+    )
+
+    parents = [*parents, FalClientParser(add_help=False)]
+
+    _add_list_parser(subparsers, parents)
+    _add_list_rev_parser(subparsers, parents)
+    _add_set_rev_parser(subparsers, parents)
+    _add_scale_parser(subparsers, parents)
+    _add_runners_parser(subparsers, parents)
+    _add_delete_parser(subparsers, parents)
+    _add_delete_rev_parser(subparsers, parents)

fal/cli/auth.py

@@ -0,0 +1,59 @@
+from fal.auth import USER, login, logout
+
+
+def _login(args):
+    login()
+
+
+def _logout(args):
+    logout()
+
+
+def _whoami(args):
+    user_name = USER.info["name"]
+    sub = USER.info["sub"]
+    args.console.print(f"Hello, {user_name} - '{sub}'")
+
+
+def add_parser(main_subparsers, parents):
+    auth_help = "Authenticate with fal."
+    parser = main_subparsers.add_parser(
+        "auth",
+        description=auth_help,
+        help=auth_help,
+        parents=parents,
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        dest="cmd",
+        required=True,
+    )
+
+    login_help = "Log in a user."
+    login_parser = subparsers.add_parser(
+        "login",
+        description=login_help,
+        help=login_help,
+        parents=parents,
+    )
+    login_parser.set_defaults(func=_login)
+
+    logout_help = "Log out the currently logged-in user."
+    logout_parser = subparsers.add_parser(
+        "logout",
+        description=logout_help,
+        help=logout_help,
+        parents=parents,
+    )
+    logout_parser.set_defaults(func=_logout)
+
+    whoami_help = "Show the currently authenticated user."
+    whoami_parser = subparsers.add_parser(
+        "whoami",
+        description=whoami_help,
+        help=whoami_help,
+        parents=parents,
+    )
+    whoami_parser.set_defaults(func=_whoami)

fal/cli/debug.py

@@ -0,0 +1,65 @@
+from contextlib import ExitStack, contextmanager
+
+from .parser import FalParser
+
+
+@contextmanager
+def _pdb():
+    try:
+        yield
+    except Exception:
+        try:
+            import ipdb as pdb  # noqa: T100
+        except ImportError:
+            import pdb  # noqa: T100
+        pdb.post_mortem()
+
+
+@contextmanager
+def _cprofile():
+    import cProfile
+
+    prof = cProfile.Profile()
+    prof.enable()
+
+    try:
+        yield
+    finally:
+        prof.disable()
+        prof.print_stats(sort="cumtime")
+
+
+@contextmanager
+def debugtools(args):
+    with ExitStack() as stack:
+        if args.pdb:
+            stack.enter_context(_pdb())
+        if args.cprofile:
+            stack.enter_context(_cprofile())
+        try:
+            yield
+        except Exception:
+            if args.debug:
+                args.console.print_exception()
+            raise
+
+
+def get_debug_parser():
+    parser = FalParser(add_help=False)
+    group = parser.add_argument_group(title="Debug")
+    group.add_argument(
+        "--debug",
+        action="store_true",
+        help="Show verbose errors."
+    )
+    group.add_argument(
+        "--pdb",
+        action="store_true",
+        help="Start pdb on error.",
+    )
+    group.add_argument(
+        "--cprofile",
+        action="store_true",
+        help="Show cProfile report.",
+    )
+    return parser

fal/cli/deploy.py

@@ -0,0 +1,146 @@
+from pathlib import Path
+
+from .parser import FalClientParser, RefAction
+
+
+def _remove_http_and_port_from_url(url):
+    # Remove http://
+    if "http://" in url:
+        url = url.replace("http://", "")
+
+    # Remove https://
+    if "https://" in url:
+        url = url.replace("https://", "")
+
+    # Remove port information
+    url_parts = url.split(":")
+    if len(url_parts) > 1:
+        url = url_parts[0]
+
+    return url
+
+
+def _get_user_id() -> str:
+    import json
+    from http import HTTPStatus
+
+    import openapi_fal_rest.api.billing.get_user_details as get_user_details
+
+    from fal.api import FalServerlessError
+    from fal.rest_client import REST_CLIENT
+
+    try:
+        user_details_response = get_user_details.sync_detailed(
+            client=REST_CLIENT,
+        )
+    except Exception as e:
+        raise FalServerlessError(f"Error fetching user details: {str(e)}")
+
+    if user_details_response.status_code != HTTPStatus.OK:
+        try:
+            content = json.loads(user_details_response.content.decode("utf8"))
+        except Exception:
+            raise FalServerlessError(
+                f"Error fetching user details: {user_details_response}"
+            )
+        else:
+            raise FalServerlessError(content["detail"])
+    try:
+        full_user_id = user_details_response.parsed.user_id
+        _provider, _, user_id = full_user_id.partition("|")
+        if not user_id:
+            user_id = full_user_id
+
+        return user_id
+    except Exception as e:
+        raise FalServerlessError(f"Could not parse the user data: {e}")
+
+
+def _deploy(args):
+    from fal.api import FalServerlessError, FalServerlessHost
+    from fal.utils import load_function_from
+
+    file_path, func_name = args.app_ref
+    if file_path is None:
+        # Try to find a python file in the current directory
+        options = list(Path(".").glob("*.py"))
+        if len(options) == 0:
+            raise FalServerlessError(
+                "No python files found in the current directory"
+            )
+        elif len(options) > 1:
+            raise FalServerlessError(
+                "Multiple python files found in the current directory. "
+                "Please specify the file path of the app you want to deploy."
+            )
+
+        [file_path] = options
+        file_path = str(file_path)
+
+    user_id = _get_user_id()
+    host = FalServerlessHost(args.host)
+    isolated_function, app_name = load_function_from(
+        host,
+        file_path,
+        func_name,
+    )
+    app_name = args.app_name or app_name
+    app_id = host.register(
+        func=isolated_function.func,
+        options=isolated_function.options,
+        application_name=app_name,
+        application_auth_mode=args.auth,
+        metadata=isolated_function.options.host.get("metadata", {}),
+    )
+
+    if app_id:
+        gateway_host = _remove_http_and_port_from_url(host.url)
+        gateway_host = (
+            gateway_host.replace("api.", "").replace("alpha.", "").replace("ai", "run")
+        )
+
+        args.console.print(
+            "Registered a new revision for function "
+            f"'{app_name}' (revision='{app_id}')."
+        )
+        args.console.print(f"URL: https://{gateway_host}/{user_id}/{app_name}")
+
+
+def add_parser(main_subparsers, parents):
+    from fal.sdk import ALIAS_AUTH_MODES
+
+    deploy_help = "Deploy a fal application."
+    epilog = (
+        "Examples:\n"
+        "  fal deploy\n"
+        "  fal deploy path/to/myfile.py\n"
+        "  fal deploy path/to/myfile.py::MyApp\n"
+        "  fal deploy path/to/myfile.py::MyApp --app-name myapp --auth public\n"
+    )
+    parser = main_subparsers.add_parser(
+        "deploy",
+        parents=[*parents, FalClientParser(add_help=False)],
+        description=deploy_help,
+        help=deploy_help,
+        epilog=epilog,
+    )
+    parser.add_argument(
+        "app_ref",
+        nargs="?",
+        action=RefAction,
+        help=(
+            "Application reference. "
+            "For example: `myfile.py::MyApp`, `myfile.py`."
+        ),
+    )
+    parser.add_argument(
+        "--app-name",
+        help="Application name to deploy with.",
+    )
+    parser.add_argument(
+        "--auth",
+        choices=ALIAS_AUTH_MODES,
+        default="private",
+        help="Application authentication mode.",
+    )
+    parser.set_defaults(func=_deploy)

fal/cli/keys.py

@@ -0,0 +1,118 @@
+from fal.sdk import KeyScope
+
+from .parser import FalClientParser
+
+
+def _create(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        parsed_scope = KeyScope(args.scope)
+        result = connection.create_user_key(parsed_scope, args.desc)
+        args.console.print(
+            f"Generated key id and key secret, with the scope `{args.scope}`.\n"
+            "This is the only time the secret will be visible.\n"
+            "You will need to generate a new key pair if you lose access to this "
+            "secret."
+        )
+        args.console.print(f"FAL_KEY='{result[1]}:{result[0]}'")
+
+
+def _add_create_parser(subparsers, parents):
+    create_help = "Create a key."
+    parser = subparsers.add_parser(
+        "create",
+        description=create_help,
+        help=create_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "--scope",
+        required=True,
+        choices=[KeyScope.ADMIN.value, KeyScope.API.value],
+        help="The privilage scope of the key.",
+    )
+    parser.add_argument(
+        "--desc",
+        help='Key description (e.g. "My Test Key")',
+    )
+    parser.set_defaults(func=_create)
+
+
+def _list(args):
+    from rich.table import Table
+
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    table = Table()
+    table.add_column("Key ID")
+    table.add_column("Created At")
+    table.add_column("Scope")
+    table.add_column("Description")
+
+    with client.connect() as connection:
+        keys = connection.list_user_keys()
+        for key in keys:
+            table.add_row(
+                key.key_id, str(key.created_at), str(key.scope.value), key.alias,
+            )
+
+    args.console.print(table)
+
+
+def _add_list_parser(subparsers, parents):
+    list_help = "List keys."
+    parser = subparsers.add_parser(
+        "list",
+        description=list_help,
+        help=list_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_list)
+
+
+def _revoke(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.revoke_user_key(args.key_id)
+
+
+def _add_revoke_parser(subparsers, parents):
+    revoke_help = "Revoke key."
+    parser = subparsers.add_parser(
+        "revoke",
+        description=revoke_help,
+        help=revoke_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "key_id",
+        help="Key ID.",
+    )
+    parser.set_defaults(func=_revoke)
+
+
+def add_parser(main_subparsers, parents):
+    keys_help = "Manage fal keys."
+    parser = main_subparsers.add_parser(
+        "keys",
+        aliases=["key"],
+        description=keys_help,
+        help=keys_help,
+        parents=parents,
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        required=True,
+        parser_class=FalClientParser,
+    )
+
+    _add_create_parser(subparsers, parents)
+    _add_list_parser(subparsers, parents)
+    _add_revoke_parser(subparsers, parents)