fal 1.45.2__py3-none-any.whl → 1.46.0__py3-none-any.whl

fal/cli/deploy.py

@@ -1,195 +1,43 @@
 import argparse
 import json
-from collections import namedtuple
-from pathlib import Path
-from typing import Optional, Tuple, Union, cast
 
-from fal.sdk import AuthModeLiteral, DeploymentStrategyLiteral
+from fal.api.client import SyncServerlessClient
 
-from ._utils import get_app_data_from_toml, is_app_name
 from .parser import FalClientParser, RefAction, get_output_parser
 
-User = namedtuple("User", ["user_id", "username"])
-
-
-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() -> User:
-    import json
-    from http import HTTPStatus
-
-    import openapi_fal_rest.api.users.get_current_user as get_current_user
-
-    from fal.api import FalServerlessError
-    from fal.rest_client import REST_CLIENT
-
-    try:
-        user_details_response = get_current_user.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(user_id=user_id, username=user_details_response.parsed.nickname)
-    except Exception as e:
-        raise FalServerlessError(f"Could not parse the user data: {e}")
-
-
-def _deploy_from_reference(
-    app_ref: Tuple[Optional[Union[Path, str]], ...],
-    app_name: str,
-    args,
-    auth: Optional[AuthModeLiteral],
-    deployment_strategy: Optional[DeploymentStrategyLiteral],
-    scale: bool,
-):
-    from fal.api import FalServerlessError, FalServerlessHost
-    from fal.utils import load_function_from
-
-    file_path, func_name = 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)  # type: ignore
-
-    user = _get_user()
-    host = FalServerlessHost(args.host, local_file_path=str(file_path))
-    loaded = load_function_from(
-        host,
-        file_path,  # type: ignore
-        func_name,  # type: ignore
-    )
-    isolated_function = loaded.function
-    app_name = app_name or loaded.app_name  # type: ignore
-    app_auth = auth or loaded.app_auth
-    deployment_strategy = deployment_strategy or "rolling"
-
-    app_id = host.register(
-        func=isolated_function.func,
-        options=isolated_function.options,
-        application_name=app_name,
-        application_auth_mode=app_auth,  # type: ignore
-        metadata=isolated_function.options.host.get("metadata", {}),
-        deployment_strategy=deployment_strategy,
-        scale=scale,
-    )
-
-    if app_id:
-        env_host = _remove_http_and_port_from_url(host.url)
-        env_host = env_host.replace("api.", "").replace("alpha.", "")
-
-        env_host_parts = env_host.split(".")
-
-        # keep the last 3 parts
-        playground_host = ".".join(env_host_parts[-3:])
-
-        # just replace .ai for .run
-        endpoint_host = env_host.replace(".ai", ".run")
-
-        if args.output == "json":
-            args.console.print(
-                json.dumps(
-                    {
-                        "revision": app_id,
-                        "app_name": app_name,
-                    }
-                )
-            )
-        elif args.output == "pretty":
-            args.console.print(
-                "Registered a new revision for function "
-                f"'{app_name}' (revision='{app_id}')."
-            )
-            args.console.print("Playground:")
-            for endpoint in loaded.endpoints:
-                args.console.print(
-                    f"\thttps://{playground_host}/models/{user.username}/{app_name}{endpoint}"
-                )
-            args.console.print("Synchronous Endpoints:")
-            for endpoint in loaded.endpoints:
-                args.console.print(
-                    f"\thttps://{endpoint_host}/{user.username}/{app_name}{endpoint}"
-                )
-            args.console.print("Asynchronous Endpoints (Recommended):")
-            for endpoint in loaded.endpoints:
-                args.console.print(
-                    f"\thttps://queue.{endpoint_host}/{user.username}/{app_name}{endpoint}"
-                )
-        else:
-            raise AssertionError(f"Invalid output format: {args.output}")
-
 
 def _deploy(args):
-    # my-app
-    if is_app_name(args.app_ref):
-        # we do not allow --app-name and --auth to be used with app name
-        if args.app_name or args.auth:
-            raise ValueError("Cannot use --app-name or --auth with app name reference.")
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    res = client.deploy(
+        args.app_ref,
+        app_name=args.app_name,
+        auth=args.auth,
+        strategy=args.strategy,
+        reset_scale=args.app_scale_settings,
+    )
+    app_id = res.revision
+    resolved_app_name = res.app_name
 
-        app_name = args.app_ref[0]
-        app_ref, app_auth, app_deployment_strategy, app_scale_settings = (
-            get_app_data_from_toml(app_name)
+    if args.output == "json":
+        args.console.print(
+            json.dumps({"revision": app_id, "app_name": resolved_app_name})
         )
-        file_path, func_name = RefAction.split_ref(app_ref)
-
-    # path/to/myfile.py::MyApp
+    elif args.output == "pretty":
+        args.console.print(
+            "Registered a new revision for function "
+            f"'{resolved_app_name}' (revision='{app_id}')."
+        )
+        args.console.print("Playground:")
+        for url in res.urls.get("playground", {}).values():
+            args.console.print(f"\t{url}")
+        args.console.print("Synchronous Endpoints:")
+        for url in res.urls.get("sync", {}).values():
+            args.console.print(f"\t{url}")
+        args.console.print("Asynchronous Endpoints (Recommended):")
+        for url in res.urls.get("async", {}).values():
+            args.console.print(f"\t{url}")
     else:
-        file_path, func_name = args.app_ref
-        app_name = cast(str, args.app_name)
-        # default to be set in the backend
-        app_auth = cast(Optional[AuthModeLiteral], args.auth)
-        # default comes from the CLI
-        app_deployment_strategy = cast(DeploymentStrategyLiteral, args.strategy)
-        app_scale_settings = cast(bool, args.app_scale_settings)
-        file_path = str(Path(file_path).absolute())
-
-    _deploy_from_reference(
-        (file_path, func_name),
-        app_name,
-        args,
-        app_auth,
-        app_deployment_strategy,
-        scale=app_scale_settings,
-    )
+        raise AssertionError(f"Invalid output format: {args.output}")
 
 
 def add_parser(main_subparsers, parents):

fal/cli/queue.py

@@ -11,7 +11,7 @@ from .parser import FalClientParser, get_output_parser
 
 
 def _queue_size(args):
-    from .deploy import _get_user
+    from fal.api.deploy import _get_user
 
     user = _get_user()
 
@@ -38,7 +38,7 @@ def _queue_size(args):
 
 
 def _queue_flush(args):
-    from .deploy import _get_user
+    from fal.api.deploy import _get_user
 
     user = _get_user()
 

fal/cli/runners.py

@@ -12,10 +12,10 @@ from httpx_sse import connect_sse
 from rich.console import Console
 from structlog.typing import EventDict
 
+from fal.api.client import SyncServerlessClient
 from fal.rest_client import REST_CLIENT
-from fal.sdk import RunnerInfo, RunnerState
+from fal.sdk import FalServerlessClient, RunnerInfo, RunnerState
 
-from ._utils import get_client
 from .parser import FalClientParser, SinceAction, get_output_parser
 
 
@@ -96,8 +96,10 @@ def runners_requests_table(runners: list[RunnerInfo]):
 
 
 def _kill(args):
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    with FalServerlessClient(
+        client._grpc_host, client._credentials
+    ).connect() as connection:
         connection.kill_runner(args.id)
 
 
@@ -122,45 +124,41 @@ def _list_json(args, runners: list[RunnerInfo]):
 
 
 def _list(args):
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
-        start_time = getattr(args, "since", None)
-        runners = connection.list_runners(start_time=start_time)
-
-        if getattr(args, "state", None):
-            states = set(args.state)
-            if "all" not in states:
-                runners = [r for r in runners if r.state.value in states]
-        pending_runners = [
-            runner for runner in runners if runner.state == RunnerState.PENDING
-        ]
-        setup_runners = [
-            runner for runner in runners if runner.state == RunnerState.SETUP
-        ]
-        dead_runners = [
-            runner for runner in runners if runner.state == RunnerState.DEAD
-        ]
-        if args.output == "pretty":
-            args.console.print(
-                "Runners: "
-                + str(
-                    len(runners)
-                    - len(pending_runners)
-                    - len(setup_runners)
-                    - len(dead_runners)
-                )
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    start_time = args.since
+    runners = client.runners.list(since=start_time)
+
+    if args.state:
+        states = set(args.state)
+        if "all" not in states:
+            runners = [r for r in runners if r.state.value in states]
+
+    pending_runners = [
+        runner for runner in runners if runner.state == RunnerState.PENDING
+    ]
+    setup_runners = [runner for runner in runners if runner.state == RunnerState.SETUP]
+    dead_runners = [runner for runner in runners if runner.state == RunnerState.DEAD]
+    if args.output == "pretty":
+        args.console.print(
+            "Runners: "
+            + str(
+                len(runners)
+                - len(pending_runners)
+                - len(setup_runners)
+                - len(dead_runners)
             )
-            args.console.print(f"Runners Pending: {len(pending_runners)}")
-            args.console.print(f"Runners Setting Up: {len(setup_runners)}")
-            args.console.print(runners_table(runners))
-
-            requests_table = runners_requests_table(runners)
-            args.console.print(f"Requests: {len(requests_table.rows)}")
-            args.console.print(requests_table)
-        elif args.output == "json":
-            _list_json(args, runners)
-        else:
-            raise AssertionError(f"Invalid output format: {args.output}")
+        )
+        args.console.print(f"Runners Pending: {len(pending_runners)}")
+        args.console.print(f"Runners Setting Up: {len(setup_runners)}")
+        args.console.print(runners_table(runners))
+
+        requests_table = runners_requests_table(runners)
+        args.console.print(f"Requests: {len(requests_table.rows)}")
+        args.console.print(requests_table)
+    elif args.output == "json":
+        _list_json(args, runners)
+    else:
+        raise AssertionError(f"Invalid output format: {args.output}")
 
 
 def _add_kill_parser(subparsers, parents):
@@ -420,17 +418,17 @@ DEFAULT_STREAM_SINCE = timedelta(minutes=1)
 
 def _logs(args):
     params: dict[str, str] = {"job_id": args.id}
-    if getattr(args, "search", None) is not None:
+    if args.search is not None:
         params["search"] = args.search
 
     runner_info = _get_runner_info(args.id)
-    follow: bool = getattr(args, "follow", False)
-    since = getattr(args, "since", None)
+    follow: bool = args.follow
+    since = args.since
     if follow:
         since = since or (datetime.now(timezone.utc) - DEFAULT_STREAM_SINCE)
     else:
         since = since or runner_info.started_at
-    until = getattr(args, "until", None) or runner_info.ended_at
+    until = args.until or runner_info.ended_at
 
     # Normalize to aware UTC for comparisons
     if since is not None:
@@ -454,7 +452,7 @@ def _logs(args):
     if since is not None and until is not None and until < since:
         since, until = until, since
 
-    lines_arg = getattr(args, "lines", None)
+    lines_arg = args.lines
     lines_count: int | None = None
     lines_oldest = False
     if lines_arg is not None:

fal/distributed/__init__.py

@@ -0,0 +1,3 @@
+from fal.distributed.worker import DistributedRunner, DistributedWorker  # noqa
+
+__all__ = ["DistributedRunner", "DistributedWorker"]