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

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)

fal/cli/main.py

@@ -0,0 +1,82 @@
+import argparse
+
+import rich
+
+from fal import __version__
+from fal.console import console
+from fal.console.icons import CROSS_ICON
+
+from . import apps, auth, deploy, keys, run, secrets
+from .debug import debugtools, get_debug_parser
+from .parser import FalParser, FalParserExit
+
+
+def _get_main_parser() -> argparse.ArgumentParser:
+    parents = [get_debug_parser()]
+    parser = FalParser(
+        prog="fal",
+        parents=parents,
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Show fal version.",
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        required=True,
+    )
+
+    for cmd in [auth, apps, deploy, run, keys, secrets]:
+        cmd.add_parser(subparsers, parents)
+
+    return parser
+
+
+def parse_args(argv=None):
+    parser = _get_main_parser()
+    args = parser.parse_args(argv)
+    args.console = console
+    args.parser = parser
+    return args
+
+
+def main(argv=None) -> int:
+    import grpc
+
+    from fal.api import UserFunctionException
+
+    ret = 1
+    try:
+        args = parse_args(argv)
+
+        with debugtools(args):
+            ret = args.func(args)
+    except UserFunctionException as _exc:
+        cause = _exc.__cause__
+        exc: BaseException = cause or _exc
+        tb = rich.traceback.Traceback.from_exception(
+            type(exc),
+            exc,
+            exc.__traceback__,
+        )
+        console.print(tb)
+        console.print("Unhandled user exception")
+    except KeyboardInterrupt:
+        console.print("Aborted.")
+    except grpc.RpcError as exc:
+        console.print(exc.details())
+    except FalParserExit as exc:
+        ret = exc.status
+    except Exception as exc:
+        msg = f"{CROSS_ICON} {str(exc)}"
+        cause = exc.__cause__
+        if cause is not None:
+            msg += f": {str(cause)}"
+        console.print(msg)
+
+    return ret

fal/cli/parser.py

@@ -0,0 +1,74 @@
+import argparse
+import sys
+
+import rich_argparse
+
+
+class FalParserExit(Exception):
+    def __init__(self, status=0):
+        self.status = status
+
+
+class RefAction(argparse.Action):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("default", (None, None))
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, parser, args, values, option_string=None):  # noqa: ARG002
+        if isinstance(values, tuple):
+            file_path, obj_path = values
+        elif values.find("::") > 1:
+            file_path, obj_path = values.split("::", 1)
+        else:
+            file_path, obj_path = values, None
+
+        setattr(args, self.dest, (file_path, obj_path))
+
+
+class DictAction(argparse.Action):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("metavar", "<name>=<value>")
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, parser, args, values, option_string=None):  # noqa: ARG002
+        d = getattr(args, self.dest) or {}
+
+        if isinstance(values, list):
+            kvs = values
+        else:
+            kvs = [values]
+
+        for kv in kvs:
+            parts = kv.split("=", 1)
+            if len(parts) != 2:
+                raise argparse.ArgumentError(
+                    self,
+                    f'Could not parse argument "{values}" as k1=v1 k2=v2 ... format',
+                )
+            key, value = parts
+            d[key] = value
+
+        setattr(args, self.dest, d)
+
+
+class FalParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("formatter_class", rich_argparse.RawTextRichHelpFormatter)
+        super().__init__(*args, **kwargs)
+
+    def exit(self, status=0, message=None):
+        if message:
+            self._print_message(message, sys.stderr)
+        raise FalParserExit(status)
+
+
+class FalClientParser(FalParser):
+    def __init__(self, *args, **kwargs):
+        from fal.flags import GRPC_HOST
+
+        super().__init__(*args, **kwargs)
+        self.add_argument(
+            "--host",
+            default=GRPC_HOST,
+            help=argparse.SUPPRESS,
+        )

fal/cli/run.py

@@ -0,0 +1,33 @@
+from .parser import FalClientParser, RefAction
+
+
+def _run(args):
+    from fal.api import FalServerlessHost
+    from fal.utils import load_function_from
+
+    host = FalServerlessHost(args.host)
+    isolated_function, _ = load_function_from(host, *args.func_ref)
+    # let our exc handlers handle UserFunctionException
+    isolated_function.reraise = False
+    isolated_function()
+
+
+def add_parser(main_subparsers, parents):
+    run_help = "Run fal function."
+    epilog = (
+        "Examples:\n"
+        "  fal run path/to/myfile.py::myfunc"
+    )
+    parser = main_subparsers.add_parser(
+        "run",
+        description=run_help,
+        parents=[*parents, FalClientParser(add_help=False)],
+        help=run_help,
+        epilog=epilog,
+    )
+    parser.add_argument(
+        "func_ref",
+        action=RefAction,
+        help="Function reference.",
+    )
+    parser.set_defaults(func=_run)

fal/cli/secrets.py

@@ -0,0 +1,107 @@
+
+from .parser import DictAction, FalClientParser
+
+
+def _set(args):
+    from fal.sdk import FalServerlessClient
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        for name, value in args.secrets.items():
+            connection.set_secret(name, value)
+
+
+def _add_set_parser(subparsers, parents):
+    set_help = "Set a secret."
+    epilog = (
+        "Examples:\n"
+        "  fal secrets set HF_TOKEN=hf_***"
+    )
+
+    parser = subparsers.add_parser(
+        "set",
+        description=set_help,
+        help=set_help,
+        parents=parents,
+        epilog=epilog,
+    )
+    parser.add_argument(
+        "secrets",
+        metavar="NAME=VALUE",
+        nargs="+",
+        action=DictAction,
+        help="Secret NAME=VALUE pairs.",
+    )
+    parser.set_defaults(func=_set)
+
+
+def _list(args):
+    from rich.table import Table
+
+    from fal.sdk import FalServerlessClient
+
+    table = Table()
+    table.add_column("Secret Name")
+    table.add_column("Created At")
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        for secret in connection.list_secrets():
+            table.add_row(secret.name, str(secret.created_at))
+
+    args.console.print(table)
+
+
+def _add_list_parser(subparsers, parents):
+    list_help = "List secrets."
+    parser = subparsers.add_parser(
+        "list",
+        description=list_help,
+        help=list_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_list)
+
+
+def _unset(args):
+    from fal.sdk import FalServerlessClient
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.delete_secret(args.secret)
+
+
+def _add_unset_parser(subparsers, parents):
+    unset_help = "Unset a secret."
+    parser = subparsers.add_parser(
+        "unset",
+        description=unset_help,
+        help=unset_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "secret",
+        metavar="NAME",
+        help="Secret's name.",
+    )
+    parser.set_defaults(func=_unset)
+
+
+def add_parser(main_subparsers, parents):
+    secrets_help = "Manage fal secrets."
+    parser = main_subparsers.add_parser(
+        "secrets",
+        aliases=["secret"],
+        parents=parents,
+        description=secrets_help,
+        help=secrets_help,
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        required=True,
+        parser_class=FalClientParser,
+    )
+
+    _add_set_parser(subparsers, parents)
+    _add_list_parser(subparsers, parents)
+    _add_unset_parser(subparsers, parents)

fal/exceptions/__init__.py

@@ -1,32 +1,3 @@
 from __future__ import annotations
 
 from ._base import FalServerlessException  # noqa: F401
-from .handlers import (
-    BaseExceptionHandler,
-    GrpcExceptionHandler,
-    UserFunctionExceptionHandler,
-)
-
-
-class ApplicationExceptionHandler:
-    """Handle exceptions top-level exceptions.
-
-    This exception handler is capable of handling, i.e. customize the output
-    and add behavior, of any type of exception. Click handles all `ClickException`
-    types by default, but prints the stack for other exception not wrapped in
-    ClickException.
-
-    The handler also allows for central metrics and logging collection.
-    """
-
-    _handlers: list[BaseExceptionHandler] = [
-        GrpcExceptionHandler(),
-        UserFunctionExceptionHandler(),
-    ]
-
-    def handle(self, exception):
-        match_handler: BaseExceptionHandler = next(
-            (h for h in self._handlers if h.should_handle(exception)),
-            BaseExceptionHandler(),
-        )
-        match_handler.handle(exception)

fal/flags.py

@@ -27,5 +27,4 @@ FAL_RUN_HOST = (
     GRPC_HOST.replace("api.", "", 1).replace("alpha.", "", 1).replace(".ai", ".run", 1)
 )
 
-FORCE_SETUP = bool_envvar("FAL_FORCE_SETUP")
 DONT_OPEN_LINKS = bool_envvar("FAL_DONT_OPEN_LINKS")

fal/sdk.py

@@ -28,6 +28,7 @@ _DEFAULT_SERIALIZATION_METHOD = "cloudpickle"
 FAL_SERVERLESS_DEFAULT_KEEP_ALIVE = 10
 FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING = 1
 FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY = 0
+ALIAS_AUTH_MODES = ["public", "private", "shared"]
 
 logger = get_logger(__name__)
 

fal/utils.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import fal._serialization
+from fal import App, wrap_app
+
+from .api import FalServerlessError, FalServerlessHost, IsolatedFunction
+
+
+def load_function_from(
+    host: FalServerlessHost,
+    file_path: str,
+    function_name: str | None = None,
+) -> tuple[IsolatedFunction, str | None]:
+    import runpy
+
+    module = runpy.run_path(file_path)
+    if function_name is None:
+        fal_objects = {
+            obj.app_name: obj_name
+            for obj_name, obj in module.items()
+            if isinstance(obj, type)
+            and issubclass(obj, fal.App)
+            and hasattr(obj, "app_name")
+        }
+        if len(fal_objects) == 0:
+            raise FalServerlessError("No fal.App found in the module.")
+        elif len(fal_objects) > 1:
+            raise FalServerlessError(
+                "Multiple fal.Apps found in the module. "
+                "Please specify the name of the app."
+            )
+
+        [(app_name, function_name)] = fal_objects.items()
+    else:
+        app_name = None
+
+    module = runpy.run_path(file_path)
+    if function_name not in module:
+        raise FalServerlessError(f"Function '{function_name}' not found in module")
+
+    # The module for the function is set to <run_path> when runpy is used, in which
+    # case we want to manually include the package it is defined in.
+    fal._serialization.include_package_from_path(file_path)
+
+    target = module[function_name]
+    if isinstance(target, type) and issubclass(target, App):
+        app_name = target.app_name
+        target = wrap_app(target, host=host)
+
+    if not isinstance(target, IsolatedFunction):
+        raise FalServerlessError(
+            f"Function '{function_name}' is not a fal.function or a fal.App"
+        )
+    return target, app_name
+

{fal-0.15.2.dist-info → fal-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 0.15.2
+Version: 1.0.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <hello@fal.ai>
 Requires-Python: >=3.8
@@ -19,7 +19,7 @@ Requires-Dist: grpc-interceptor <1,>=0.15.0
 Requires-Dist: colorama <1,>=0.4.6
 Requires-Dist: portalocker <3,>=2.7.0
 Requires-Dist: rich <14,>=13.3.2
-Requires-Dist: rich-click
+Requires-Dist: rich-argparse
 Requires-Dist: packaging <22,>=21.3
 Requires-Dist: pathspec <1,>=0.11.1
 Requires-Dist: pydantic !=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,<3