fal 1.49.1__py3-none-any.whl → 1.57.2__py3-none-any.whl

fal/sdk.py

@@ -246,6 +246,7 @@ class ApplicationInfo:
     min_concurrency: int
     concurrency_buffer: int
     concurrency_buffer_perc: int
+    scaling_delay: int
     machine_types: list[str]
     request_timeout: int
     startup_timeout: int
@@ -265,6 +266,7 @@ class AliasInfo:
     min_concurrency: int
     concurrency_buffer: int
     concurrency_buffer_perc: int
+    scaling_delay: int
     machine_types: list[str]
     request_timeout: int
     startup_timeout: int
@@ -272,27 +274,14 @@ class AliasInfo:
 
 
 class RunnerState(Enum):
-    RUNNING = "running"
-    PENDING = "pending"
-    SETUP = "setup"
-    DOCKER_PULL = "docker_pull"
-    DEAD = "dead"
-    UNKNOWN = "unknown"
-
-    @staticmethod
-    def from_proto(proto: isolate_proto.RunnerInfo.State) -> RunnerState:
-        if proto is isolate_proto.RunnerInfo.State.RUNNING:
-            return RunnerState.RUNNING
-        elif proto is isolate_proto.RunnerInfo.State.PENDING:
-            return RunnerState.PENDING
-        elif proto is isolate_proto.RunnerInfo.State.SETUP:
-            return RunnerState.SETUP
-        elif proto is isolate_proto.RunnerInfo.State.DEAD:
-            return RunnerState.DEAD
-        elif proto is isolate_proto.RunnerInfo.State.DOCKER_PULL:
-            return RunnerState.DOCKER_PULL
-        else:
-            return RunnerState.UNKNOWN
+    RUNNING = "RUNNING"
+    PENDING = "PENDING"
+    SETUP = "SETUP"
+    DOCKER_PULL = "DOCKER_PULL"
+    DEAD = "DEAD"
+    DRAINING = "DRAINING"
+    TERMINATING = "TERMINATING"
+    TERMINATED = "TERMINATED"
 
 
 @dataclass
@@ -414,6 +403,7 @@ def _from_grpc_application_info(
         min_concurrency=message.min_concurrency,
         concurrency_buffer=message.concurrency_buffer,
         concurrency_buffer_perc=message.concurrency_buffer_perc,
+        scaling_delay=message.scaling_delay_seconds,
         machine_types=list(message.machine_types),
         request_timeout=message.request_timeout,
         startup_timeout=message.startup_timeout,
@@ -444,6 +434,7 @@ def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
         min_concurrency=message.min_concurrency,
         concurrency_buffer=message.concurrency_buffer,
         concurrency_buffer_perc=message.concurrency_buffer_perc,
+        scaling_delay=message.scaling_delay_seconds,
         machine_types=list(message.machine_types),
         request_timeout=message.request_timeout,
         startup_timeout=message.startup_timeout,
@@ -468,7 +459,7 @@ def _from_grpc_runner_info(message: isolate_proto.RunnerInfo) -> RunnerInfo:
         external_metadata=external_metadata,
         revision=message.revision,
         alias=message.alias,
-        state=RunnerState.from_proto(message.state),
+        state=RunnerState(isolate_proto.RunnerInfo.State.Name(message.state)),
     )
 
 
@@ -537,8 +528,10 @@ class MachineRequirements:
     min_concurrency: int | None = None
     concurrency_buffer: int | None = None
     concurrency_buffer_perc: int | None = None
+    scaling_delay: int | None = None
     request_timeout: int | None = None
     startup_timeout: int | None = None
+    valid_regions: list[str] | None = None
 
     def __post_init__(self):
         if isinstance(self.machine_types, str):
@@ -633,6 +626,7 @@ class FalServerlessConnection:
         auth_mode: Optional[AuthModeLiteral] = None,
         *,
         source_code: str | None = None,
+        health_check_path: str | None = None,
         serialization_method: str = _DEFAULT_SERIALIZATION_METHOD,
         machine_requirements: MachineRequirements | None = None,
         metadata: dict[str, Any] | None = None,
@@ -640,7 +634,7 @@ class FalServerlessConnection:
         scale: bool = True,
         private_logs: bool = False,
         files: list[File] | None = None,
-    ) -> Iterator[isolate_proto.RegisterApplicationResult]:
+    ) -> Iterator[RegisterApplicationResult]:
         wrapped_function = to_serialized_object(function, serialization_method)
         if machine_requirements:
             wrapped_requirements = isolate_proto.MachineRequirements(
@@ -659,9 +653,11 @@ class FalServerlessConnection:
                 min_concurrency=machine_requirements.min_concurrency,
                 concurrency_buffer=machine_requirements.concurrency_buffer,
                 concurrency_buffer_perc=machine_requirements.concurrency_buffer_perc,
+                scaling_delay_seconds=machine_requirements.scaling_delay,
                 max_multiplexing=machine_requirements.max_multiplexing,
                 request_timeout=machine_requirements.request_timeout,
                 startup_timeout=machine_requirements.startup_timeout,
+                valid_regions=machine_requirements.valid_regions,
             )
         else:
             wrapped_requirements = None
@@ -702,6 +698,7 @@ class FalServerlessConnection:
             private_logs=private_logs,
             files=files,
             source_code=source_code,
+            health_check_path=health_check_path,
         )
         for partial_result in self.stub.RegisterApplication(request):
             yield from_grpc(partial_result)
@@ -718,6 +715,7 @@ class FalServerlessConnection:
         min_concurrency: int | None = None,
         concurrency_buffer: int | None = None,
         concurrency_buffer_perc: int | None = None,
+        scaling_delay: int | None = None,
         request_timeout: int | None = None,
         startup_timeout: int | None = None,
         valid_regions: list[str] | None = None,
@@ -731,6 +729,7 @@ class FalServerlessConnection:
             min_concurrency=min_concurrency,
             concurrency_buffer=concurrency_buffer,
             concurrency_buffer_perc=concurrency_buffer_perc,
+            scaling_delay_seconds=scaling_delay,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
             valid_regions=valid_regions,
@@ -757,6 +756,17 @@ class FalServerlessConnection:
         request = isolate_proto.DeleteApplicationRequest(application_id=application_id)
         self.stub.DeleteApplication(request)
 
+    def rollout_application(
+        self,
+        application_name: str,
+        force: bool = False,
+    ) -> None:
+        request = isolate_proto.RolloutApplicationRequest(
+            application_name=application_name,
+            force=force,
+        )
+        self.stub.RolloutApplication(request)
+
     def run(
         self,
         function: Callable[..., ResultT],
@@ -786,8 +796,10 @@ class FalServerlessConnection:
                 min_concurrency=machine_requirements.min_concurrency,
                 concurrency_buffer=machine_requirements.concurrency_buffer,
                 concurrency_buffer_perc=machine_requirements.concurrency_buffer_perc,
+                scaling_delay_seconds=machine_requirements.scaling_delay,
                 request_timeout=machine_requirements.request_timeout,
                 startup_timeout=machine_requirements.startup_timeout,
+                valid_regions=machine_requirements.valid_regions,
             )
         else:
             wrapped_requirements = None
@@ -884,6 +896,10 @@ class FalServerlessConnection:
             for secret in response.secrets
         ]
 
+    def stop_runner(self, runner_id: str) -> None:
+        request = isolate_proto.StopRunnerRequest(runner_id=runner_id)
+        self.stub.StopRunner(request)
+
     def kill_runner(self, runner_id: str) -> None:
         request = isolate_proto.KillRunnerRequest(runner_id=runner_id)
         self.stub.KillRunner(request)

fal/sync.py

@@ -4,21 +4,21 @@ import hashlib
 import os
 import zipfile
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from openapi_fal_rest.client import Client
 
-import openapi_fal_rest.api.files.check_dir_hash as check_dir_hash_api
-import openapi_fal_rest.api.files.upload_local_file as upload_local_file_api
-import openapi_fal_rest.models.body_upload_local_file as upload_file_model
-import openapi_fal_rest.models.hash_check as hash_check_model
-import openapi_fal_rest.types as rest_types
 from pathspec import PathSpec
 
-from fal.rest_client import REST_CLIENT
 
+def _check_hash(client: Client, target_path: str, hash_string: str) -> bool:
+    import openapi_fal_rest.api.files.check_dir_hash as check_dir_hash_api
+    import openapi_fal_rest.models.hash_check as hash_check_model
 
-def _check_hash(target_path: str, hash_string: str) -> bool:
     response = check_dir_hash_api.sync_detailed(
         target_path,
-        client=REST_CLIENT,
+        client=client,
         json_body=hash_check_model.HashCheck(hash_string),
     )
 
@@ -26,7 +26,13 @@ def _check_hash(target_path: str, hash_string: str) -> bool:
     return response.status_code == 200 and res
 
 
-def _upload_file(source_path: str, target_path: str, unzip: bool = False):
+def _upload_file(
+    client: Client, source_path: str, target_path: str, unzip: bool = False
+):
+    import openapi_fal_rest.api.files.upload_local_file as upload_local_file_api
+    import openapi_fal_rest.models.body_upload_local_file as upload_file_model
+    import openapi_fal_rest.types as rest_types
+
     with open(source_path, "rb") as file_to_upload:
         body = upload_file_model.BodyUploadLocalFile(
             rest_types.File(
@@ -39,7 +45,7 @@ def _upload_file(source_path: str, target_path: str, unzip: bool = False):
 
         response = upload_local_file_api.sync_detailed(
             target_path,
-            client=REST_CLIENT,
+            client=client,
             unzip=unzip,
             multipart_data=body,
         )
@@ -94,6 +100,8 @@ def _zip_directory(dir_path: str, zip_path: str) -> None:
 
 
 def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
+    from fal.api.client import SyncServerlessClient
+
     local_dir_abs = os.path.expanduser(local_dir)
     if not os.path.isabs(remote_dir) or not remote_dir.startswith("/data"):
         raise ValueError(
@@ -106,9 +114,11 @@ def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
     # Compute the local directory hash
     local_hash = _compute_directory_hash(local_dir_abs)
 
+    client = SyncServerlessClient()._create_rest_client()
+
     print(f"Syncing {local_dir} with {remote_dir}...")
 
-    if _check_hash(remote_dir, local_hash) and not force_upload:
+    if _check_hash(client, remote_dir, local_hash) and not force_upload:
         print(f"{remote_dir} already uploaded and matches {local_dir}")
         return remote_dir
 
@@ -121,7 +131,7 @@ def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
     _zip_directory(local_dir_abs, zip_path)
 
     # Upload the zipped directory to the serverless environment
-    _upload_file(zip_path, remote_dir, unzip=True)
+    _upload_file(client, zip_path, remote_dir, unzip=True)
 
     os.remove(zip_path)
 

fal/toolkit/__init__.py

@@ -1,6 +1,12 @@
 from __future__ import annotations
 
 from fal.toolkit.audio.audio import Audio, AudioField
+from fal.toolkit.compilation import (
+    get_gpu_type,
+    load_inductor_cache,
+    sync_inductor_cache,
+    synchronized_inductor_cache,
+)
 from fal.toolkit.file import CompressedFile, File, FileField
 from fal.toolkit.image.image import Image, ImageField, ImageSizeInput, get_image_size
 from fal.toolkit.optimize import optimize
@@ -33,4 +39,8 @@ __all__ = [
     "clone_repository",
     "download_file",
     "download_model_weights",
+    "get_gpu_type",
+    "load_inductor_cache",
+    "sync_inductor_cache",
+    "synchronized_inductor_cache",
 ]

fal/toolkit/compilation.py

@@ -0,0 +1,220 @@
+"""PyTorch compilation cache management utilities.
+
+This module provides utilities for managing PyTorch Inductor compilation caches
+across workers. When using torch.compile(), PyTorch generates optimized CUDA kernels
+on first run, which can take 20-30 seconds. By sharing these compiled kernels across
+workers, subsequent workers can load pre-compiled kernels in ~2 seconds instead of
+recompiling.
+
+Typical usage in a model setup:
+
+    Manual cache management:
+        dir_hash = load_inductor_cache("mymodel/v1")
+        self.model = torch.compile(self.model)
+        self.warmup()  # Triggers compilation
+        sync_inductor_cache("mymodel/v1", dir_hash)
+
+    Context manager (automatic):
+        with synchronized_inductor_cache("mymodel/v1"):
+            self.model = torch.compile(self.model)
+            self.warmup()  # Compilation is automatically synced after
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+
+LOCAL_INDUCTOR_CACHE_DIR = Path("/tmp/inductor-cache/")
+GLOBAL_INDUCTOR_CACHES_DIR = Path("/data/inductor-caches/")
+PERSISTENT_TMP_DIR = Path("/data/tmp/")
+
+
+def get_gpu_type() -> str:
+    """Detect the GPU type using nvidia-smi.
+
+    Returns:
+        The GPU model name (e.g., "H100", "A100", "H200") or "UNKNOWN"
+        if detection fails.
+
+    Example:
+        >>> gpu_type = get_gpu_type()
+        >>> print(f"Running on: {gpu_type}")
+        Running on: H100
+    """
+    try:
+        gpu_type_string = subprocess.run(
+            ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+            capture_output=True,
+            text=True,
+            check=False,
+        ).stdout
+        matches = re.search(r"NVIDIA [a-zA-Z0-9]*", gpu_type_string)
+        # check for matches - if there are none, return "UNKNOWN"
+        if matches:
+            gpu_type = matches.group(0)
+            return gpu_type[7:]  # remove `NVIDIA `
+        else:
+            return "UNKNOWN"
+    except Exception:
+        return "UNKNOWN"
+
+
+def _dir_hash(path: Path) -> str:
+    """Compute a hash of all filenames in a directory (recursively).
+
+    Args:
+        path: Directory to hash.
+
+    Returns:
+        SHA256 hex digest of sorted filenames.
+    """
+    # Hash of all the filenames in the directory, recursively, sorted
+    filenames = {str(file) for file in path.rglob("*") if file.is_file()}
+    return hashlib.sha256("".join(sorted(filenames)).encode()).hexdigest()
+
+
+def load_inductor_cache(cache_key: str) -> str:
+    """Load PyTorch Inductor compilation cache from global storage.
+
+    This function:
+    1. Sets TORCHINDUCTOR_CACHE_DIR environment variable
+    2. Looks for cached compiled kernels in GPU-specific global storage
+    3. Unpacks the cache to local temporary directory
+    4. Returns a hash of the unpacked directory for change detection
+
+    Args:
+        cache_key: Unique identifier for this cache (e.g., "flux/2", "mymodel/v1")
+
+    Returns:
+        Hash of the unpacked cache directory, or empty string if cache not found.
+
+    Example:
+        >>> dir_hash = load_inductor_cache("flux/2")
+        Found compilation cache at /data/inductor-caches/H100/flux/2.zip, unpacking...
+        Cache unpacked successfully.
+    """
+    gpu_type = get_gpu_type()
+
+    os.environ["TORCHINDUCTOR_CACHE_DIR"] = str(LOCAL_INDUCTOR_CACHE_DIR)
+
+    cache_source_path = GLOBAL_INDUCTOR_CACHES_DIR / gpu_type / f"{cache_key}.zip"
+
+    try:
+        next(cache_source_path.parent.iterdir(), None)
+    except Exception as e:
+        # Check for cache without gpu_type in the path
+        try:
+            old_source_path = GLOBAL_INDUCTOR_CACHES_DIR / f"{cache_key}.zip"
+            # Since old source exists, copy it over to global caches
+            os.makedirs(cache_source_path.parent, exist_ok=True)
+            shutil.copy(old_source_path, cache_source_path)
+        except Exception:
+            print(f"Failed to list: {e}")
+
+    if not cache_source_path.exists():
+        print(f"Couldn't find compilation cache at {cache_source_path}")
+        return ""
+
+    print(f"Found compilation cache at {cache_source_path}, unpacking...")
+    try:
+        shutil.unpack_archive(cache_source_path, LOCAL_INDUCTOR_CACHE_DIR)
+    except Exception as e:
+        print(f"Failed to unpack cache: {e}")
+        return ""
+
+    print("Cache unpacked successfully.")
+    return _dir_hash(LOCAL_INDUCTOR_CACHE_DIR)
+
+
+def sync_inductor_cache(cache_key: str, unpacked_dir_hash: str) -> None:
+    """Sync updated PyTorch Inductor cache back to global storage.
+
+    This function:
+    1. Checks if the local cache has changed (by comparing hashes)
+    2. If changed, creates a zip archive of the new cache
+    3. Saves it to GPU-specific global storage
+
+    Args:
+        cache_key: Unique identifier for this cache (same as used in
+            load_inductor_cache)
+        unpacked_dir_hash: Hash returned from load_inductor_cache
+            (for change detection)
+
+    Example:
+        >>> sync_inductor_cache("flux/2", dir_hash)
+        No changes in the cache dir, skipping sync.
+        # or
+        Changes detected in the cache dir, syncing...
+    """
+    gpu_type = get_gpu_type()
+    if not LOCAL_INDUCTOR_CACHE_DIR.exists():
+        print(f"No cache to sync, {LOCAL_INDUCTOR_CACHE_DIR} doesn't exist.")
+        return
+
+    if not GLOBAL_INDUCTOR_CACHES_DIR.exists():
+        GLOBAL_INDUCTOR_CACHES_DIR.mkdir(parents=True)
+
+    # If we updated the cache (the hashes of LOCAL_INDUCTOR_CACHE_DIR and
+    # unpacked_dir_hash differ), we pack the cache and move it to the
+    # global cache directory.
+    new_dir_hash = _dir_hash(LOCAL_INDUCTOR_CACHE_DIR)
+    if new_dir_hash == unpacked_dir_hash:
+        print("No changes in the cache dir, skipping sync.")
+        return
+
+    print("Changes detected in the cache dir, syncing...")
+    os.makedirs(
+        PERSISTENT_TMP_DIR, exist_ok=True
+    )  # Non fal-ai users do not have this directory
+    with tempfile.TemporaryDirectory(dir=PERSISTENT_TMP_DIR) as temp_dir:
+        temp_dir_path = Path(temp_dir)
+        cache_path = GLOBAL_INDUCTOR_CACHES_DIR / gpu_type / f"{cache_key}.zip"
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            zip_name = shutil.make_archive(
+                str(temp_dir_path / "inductor_cache"),
+                "zip",
+                LOCAL_INDUCTOR_CACHE_DIR,
+            )
+            os.rename(
+                zip_name,
+                cache_path,
+            )
+        except Exception as e:
+            print(f"Failed to sync cache: {e}")
+            return
+
+
+@contextmanager
+def synchronized_inductor_cache(cache_key: str) -> Iterator[None]:
+    """Context manager to automatically load and sync PyTorch Inductor cache.
+
+    This wraps load_inductor_cache and sync_inductor_cache for convenience.
+    The cache is loaded on entry and synced on exit (even if an exception occurs).
+
+    Args:
+        cache_key: Unique identifier for this cache (e.g., "flux/2", "mymodel/v1")
+
+    Yields:
+        None
+
+    Example:
+        >>> with synchronized_inductor_cache("mymodel/v1"):
+        ...     self.model = torch.compile(self.model)
+        ...     self.warmup()  # Compilation happens here
+        # Cache is automatically synced after the with block
+    """
+    unpacked_dir_hash = load_inductor_cache(cache_key)
+    try:
+        yield
+    finally:
+        sync_inductor_cache(cache_key, unpacked_dir_hash)

fal/toolkit/file/file.py

@@ -16,8 +16,7 @@ from fastapi import Request
 if not hasattr(pydantic, "__version__") or pydantic.__version__.startswith("1."):
     IS_PYDANTIC_V2 = False
 else:
-    from pydantic import GetCoreSchemaHandler
-    from pydantic_core import CoreSchema, core_schema
+    from pydantic import model_validator
 
     IS_PYDANTIC_V2 = True
 
@@ -137,14 +136,16 @@ class File(BaseModel):
     # Pydantic custom validator for input type conversion
     if IS_PYDANTIC_V2:
 
+        @model_validator(mode="before")
         @classmethod
-        def __get_pydantic_core_schema__(
-            cls, source_type: Any, handler: GetCoreSchemaHandler
-        ) -> CoreSchema:
-            return core_schema.no_info_before_validator_function(
-                cls.__convert_from_str,
-                handler(source_type),
-            )
+        def __convert_from_str_v2(cls, value: Any):
+            if isinstance(value, str):
+                parsed_url = urlparse(value)
+                if parsed_url.scheme not in ["http", "https", "data"]:
+                    raise ValueError("value must be a valid URL")
+                # Return a mapping so the model can be constructed normally
+                return {"url": parsed_url.geturl()}
+            return value
 
     else:
 

fal/utils.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-import fal._serialization
-from fal import App, wrap_app
-
-from .api import FalServerlessError, FalServerlessHost, IsolatedFunction
+if TYPE_CHECKING:
+    from .api import FalServerlessHost, IsolatedFunction
 
 
 @dataclass
@@ -17,6 +16,62 @@ class LoadedFunction:
     source_code: str | None
 
 
+def _find_target(
+    module: dict[str, object], function_name: str | None = None
+) -> tuple[object, str | None, str | None]:
+    import fal
+    from fal.api import FalServerlessError, IsolatedFunction
+
+    if function_name is not None:
+        if function_name not in module:
+            raise FalServerlessError(f"Function '{function_name}' not found in module")
+
+        target = module[function_name]
+
+        if isinstance(target, type) and issubclass(target, fal.App):
+            return target, target.app_name, target.app_auth
+
+        if isinstance(target, IsolatedFunction):
+            return target, function_name, None
+
+        raise FalServerlessError(
+            f"Function '{function_name}' is not a fal.App or a fal.function"
+        )
+
+    fal_apps = {
+        obj_name: obj
+        for obj_name, obj in module.items()
+        if isinstance(obj, type) and issubclass(obj, fal.App) and obj is not fal.App
+    }
+
+    if len(fal_apps) == 1:
+        [(function_name, target)] = fal_apps.items()
+        return target, target.app_name, target.app_auth
+    elif len(fal_apps) > 1:
+        raise FalServerlessError(
+            f"Multiple fal.Apps found in the module: {list(fal_apps.keys())}. "
+            "Please specify the name of the app."
+        )
+
+    fal_functions = {
+        obj_name: obj
+        for obj_name, obj in module.items()
+        if isinstance(obj, IsolatedFunction)
+    }
+
+    if len(fal_functions) == 0:
+        raise FalServerlessError("No fal.App or fal.function found in the module.")
+    elif len(fal_functions) > 1:
+        raise FalServerlessError(
+            "Multiple fal.functions found in the module: "
+            f"{list(fal_functions.keys())}. "
+            "Please specify the name of the function."
+        )
+
+    [(function_name, target)] = fal_functions.items()
+    return target, function_name, None
+
+
 def load_function_from(
     host: FalServerlessHost,
     file_path: str,
@@ -26,45 +81,24 @@ def load_function_from(
     import runpy
     import sys
 
+    import fal._serialization
+    from fal import App, wrap_app
+
+    from .api import FalServerlessError, IsolatedFunction
+
     sys.path.append(os.getcwd())
     module = runpy.run_path(file_path)
-    if function_name is None:
-        fal_objects = {
-            obj_name: obj
-            for obj_name, obj in module.items()
-            if isinstance(obj, type) and issubclass(obj, fal.App) and obj is not fal.App
-        }
-        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."
-            )
-
-        [(function_name, obj)] = fal_objects.items()
-        app_name = obj.app_name
-        app_auth = obj.app_auth
-    else:
-        app_name = None
-        app_auth = None
-
-    if function_name not in module:
-        raise FalServerlessError(f"Function '{function_name}' not found in module")
+    target, app_name, app_auth = _find_target(module, function_name)
 
     # 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]
-
     with open(file_path) as f:
         source_code = f.read()
 
     endpoints = ["/"]
     if isinstance(target, type) and issubclass(target, App):
-        app_name = target.app_name
-        app_auth = target.app_auth
         endpoints = target.get_endpoints() or ["/"]
         target = wrap_app(target, host=host)
 

fal/workflows.py

@@ -19,7 +19,6 @@ from rich.syntax import Syntax
 import fal
 from fal import flags
 from fal.exceptions import FalServerlessException
-from fal.rest_client import REST_CLIENT
 
 JSONType = Union[Dict[str, Any], List[Any], str, int, float, bool, None, "Leaf"]
 SchemaType = Dict[str, Any]
@@ -372,6 +371,11 @@ class Workflow:
     to_dict = to_json
 
     def publish(self, title: str, *, is_public: bool = True):
+        from fal.api.client import SyncServerlessClient
+
+        client = SyncServerlessClient()
+        rest_client = client._create_rest_client()
+
         workflow_contents = publish_workflow.TypedWorkflow(
             name=self.name,
             title=title,
@@ -379,7 +383,7 @@ class Workflow:
             is_public=is_public,
         )
         published_workflow = publish_workflow.sync(
-            client=REST_CLIENT,
+            client=rest_client,
             json_body=workflow_contents,
         )
         if isinstance(published_workflow, Exception):