fal 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

fal/sdk.py

@@ -26,6 +26,7 @@ UNSET = object()
 
 _DEFAULT_SERIALIZATION_METHOD = "dill"
 FAL_SERVERLESS_DEFAULT_KEEP_ALIVE = 10
+FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING = 1
 
 log = get_logger(__name__)
 
@@ -183,23 +184,9 @@ class AliasInfo:
     alias: str
     revision: str
     auth_mode: str
+    keep_alive: int
     max_concurrency: int
-
-
-@dataclass(frozen=True)
-class Cron:
-    cron_id: str
-    cron_string: str
-    next_run: datetime
-    active: bool
-
-
-@dataclass(frozen=True)
-class ScheduledRunActivation:
-    cron_id: str
-    activation_id: str
-    started_at: datetime
-    finished_at: datetime
+    max_multiplexing: int
 
 
 @dataclass
@@ -216,16 +203,6 @@ class RegisterApplicationResult:
     logs: list[Log] = field(default_factory=list)
 
 
-@dataclass(frozen=True)
-class RegisterCronResultType:
-    cron_id: str
-
-
-@dataclass(frozen=True)
-class RegisterCronResult:
-    result: RegisterCronResultType
-
-
 @dataclass
 class RegisterApplicationResultType:
     application_id: str
@@ -268,27 +245,6 @@ class KeyScope(enum.Enum):
             raise ValueError(f"Unknown KeyScope: {proto}")
 
 
-@from_grpc.register(isolate_proto.RegisterCronResult)
-def _from_grpc_register_cron_result(
-    message: isolate_proto.RegisterCronResult,
-) -> RegisterCronResult:
-    return RegisterCronResult(
-        result=RegisterCronResultType(message.result.cron_id),
-    )
-
-
-@from_grpc.register(isolate_proto.CronResultType)
-def _from_grpc_cron_result_type(
-    message: isolate_proto.CronResultType,
-) -> Cron:
-    return Cron(
-        cron_id=message.cron_id,
-        cron_string=message.cron_string,
-        next_run=message.next_run.ToDatetime(),
-        active=message.is_active,
-    )
-
-
 @from_grpc.register(isolate_proto.AliasInfo)
 def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
     if message.auth_mode is isolate_proto.ApplicationAuthMode.PUBLIC:
@@ -304,7 +260,9 @@ def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
         alias=message.alias,
         revision=message.revision,
         auth_mode=auth_mode,
+        keep_alive=message.keep_alive,
         max_concurrency=message.max_concurrency,
+        max_multiplexing=message.max_multiplexing,
     )
 
 
@@ -344,13 +302,6 @@ def _from_grpc_hosted_run_result(
     )
 
 
-def _get_cron_id(run: Cron | str) -> str:
-    if isinstance(run, Cron):
-        return run.cron_id
-    else:
-        return run
-
-
 @dataclass
 class MachineRequirements:
     machine_type: str
@@ -359,6 +310,8 @@ class MachineRequirements:
     exposed_port: int | None = None
     scheduler: str | None = None
     scheduler_options: dict[str, Any] | None = None
+    max_concurrency: int | None = None
+    max_multiplexing: int | None = None
 
 
 @dataclass
@@ -420,31 +373,17 @@ class FalServerlessConnection:
         request = isolate_proto.RevokeUserKeyRequest(key_id=key_id)
         self.stub.RevokeUserKey(request)
 
-    # TODO: get rid of this in favor of define_environment
-    def create_environment(
-        self,
-        kind: str,
-        configuration_options: dict[str, Any],
+    def define_environment(
+        self, kind: str, **options: Any
     ) -> isolate_proto.EnvironmentDefinition:
-        assert isinstance(
-            configuration_options, dict
-        ), "configuration_options must be a dict"
         struct = isolate_proto.Struct()
-        struct.update(configuration_options)
+        struct.update(options)
 
         return isolate_proto.EnvironmentDefinition(
             kind=kind,
             configuration=struct,
         )
 
-    def define_environment(
-        self, kind: str, **options: Any
-    ) -> isolate_proto.EnvironmentDefinition:
-        return self.create_environment(
-            kind=kind,
-            configuration_options=options,
-        )
-
     def register(
         self,
         function: Callable[..., ResultT],
@@ -452,7 +391,6 @@ class FalServerlessConnection:
         application_name: str | None = None,
         application_auth_mode: Literal["public", "private", "shared"] | None = None,
         *,
-        max_concurrency: int | None = None,
         serialization_method: str = _DEFAULT_SERIALIZATION_METHOD,
         machine_requirements: MachineRequirements | None = None,
         metadata: dict[str, Any] | None = None,
@@ -468,6 +406,8 @@ class FalServerlessConnection:
                 scheduler_options=to_struct(
                     machine_requirements.scheduler_options or {}
                 ),
+                max_concurrency=machine_requirements.max_concurrency,
+                max_multiplexing=machine_requirements.max_multiplexing,
             )
         else:
             wrapped_requirements = None
@@ -488,7 +428,6 @@ class FalServerlessConnection:
             function=wrapped_function,
             environments=environments,
             machine_requirements=wrapped_requirements,
-            max_concurrency=max_concurrency,
             application_name=application_name,
             auth_mode=auth_mode,
             metadata=struct_metadata,
@@ -497,20 +436,25 @@ class FalServerlessConnection:
             yield from_grpc(partial_result)
 
     def scale(self, application_name: str, max_concurrency: int | None = None) -> None:
-        request = isolate_proto.ScaleApplicationRequest(
-            application_name=application_name,
-            max_concurrency=max_concurrency,
-        )
-        self.stub.ScaleApplication(request)
+        raise NotImplementedError
 
     def update_application(
-        self, application_name: str, keep_alive: int | None = None
-    ) -> None:
+        self,
+        application_name: str,
+        keep_alive: int | None = None,
+        max_multiplexing: int | None = None,
+        max_concurrency: int | None = None,
+    ) -> AliasInfo:
         request = isolate_proto.UpdateApplicationRequest(
             application_name=application_name,
             keep_alive=keep_alive,
+            max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
         )
-        self.stub.UpdateApplication(request)
+        res: isolate_proto.UpdateApplicationResult = self.stub.UpdateApplication(
+            request
+        )
+        return from_grpc(res.alias_info)
 
     def run(
         self,
@@ -532,6 +476,8 @@ class FalServerlessConnection:
                 scheduler_options=to_struct(
                     machine_requirements.scheduler_options or {}
                 ),
+                max_concurrency=machine_requirements.max_concurrency,
+                max_multiplexing=machine_requirements.max_multiplexing,
             )
         else:
             wrapped_requirements = None
@@ -548,62 +494,36 @@ class FalServerlessConnection:
         for partial_result in self.stub.Run(request):
             yield from_grpc(partial_result)
 
-    def schedule_cronjob(
+    def create_alias(
         self,
-        application_id: str,
-        cron: str,
-    ) -> str:
-        request = isolate_proto.RegisterCronRequest(
-            application_id=application_id, cron=cron
+        alias: str,
+        revision: str,
+        auth_mode: Literal["public", "private", "shared"],
+    ):
+        if auth_mode == "public":
+            auth = isolate_proto.ApplicationAuthMode.PUBLIC
+        elif auth_mode == "shared":
+            auth = isolate_proto.ApplicationAuthMode.SHARED
+        else:
+            auth = isolate_proto.ApplicationAuthMode.PRIVATE
+
+        request = isolate_proto.SetAliasRequest(
+            alias=alias,
+            revision=revision,
+            auth_mode=auth,
         )
-        response: isolate_proto.RegisterCronResult = self.stub.RegisterCron(request)
-        return response.result.cron_id
+        self.stub.SetAlias(request)
+
+    def delete_alias(self, alias: str) -> str:
+        request = isolate_proto.DeleteAliasRequest(alias=alias)
+        res: isolate_proto.DeleteAliasResult = self.stub.DeleteAlias(request)
+        return res.revision
 
     def list_aliases(self) -> list[AliasInfo]:
         request = isolate_proto.ListAliasesRequest()
         response: isolate_proto.ListAliasesResult = self.stub.ListAliases(request)
         return [from_grpc(alias) for alias in response.aliases]
 
-    def list_scheduled_runs(self) -> list[Cron]:
-        request = isolate_proto.ListCronsRequest()
-        response: isolate_proto.ListCronsResult = self.stub.ListCrons(request)
-        return [from_grpc(cron) for cron in response.crons]
-
-    def list_run_activations(self, run: str | Cron) -> list[ScheduledRunActivation]:
-        request = isolate_proto.ListActivationsRequest(cron_id=_get_cron_id(run))
-        response: isolate_proto.ListActivationsResult = self.stub.ListActivations(
-            request
-        )
-        return [
-            ScheduledRunActivation(
-                cron_id=_get_cron_id(run),
-                activation_id=activation.activation_id,
-                started_at=activation.started_at.ToDatetime(),
-                finished_at=activation.finished_at.ToDatetime(),
-            )
-            for activation in response.activations
-        ]
-
-    def cancel_scheduled_run(self, cron_id: str) -> None:
-        request = isolate_proto.CancelCronRequest(cron_id=cron_id)
-        response: isolate_proto.CancelCronResult = self.stub.CancelCron(request)
-        return
-
-    def get_activation_logs(self, cron_id: str, activation_id: str) -> list[Log]:
-        request = isolate_proto.GetActivationLogsRequest(
-            cron_id=cron_id, activation_id=activation_id
-        )
-        response = self.stub.GetActivationLogs(request)
-        return [from_grpc(log) for log in response.logs]
-
-    def get_logs(
-        self, lines: int | None = None, url: str | None = None
-    ) -> Iterator[Log]:
-        filter = isolate_proto.LogsFilter(lines=lines, url=url)
-        request = isolate_proto.GetLogsRequest(filter=filter)
-        for partial_result in self.stub.GetLogs(request):
-            yield from_grpc(partial_result.log_entry)
-
     def set_secret(self, name: str, value: str) -> None:
         request = isolate_proto.SetSecretRequest(name=name, value=value)
         self.stub.SetSecret(request)

fal/sync.py

@@ -5,13 +5,14 @@ import os
 import zipfile
 from pathlib import Path
 
+from fal.rest_client import REST_CLIENT
+from pathspec import PathSpec
+
 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 fal.rest_client import REST_CLIENT
-from pathspec import PathSpec
 
 
 def _check_hash(target_path: str, hash_string: str) -> bool:

fal/toolkit/file/file.py

@@ -1,25 +1,26 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Callable, Literal
+from typing import Callable
 
 from fal.toolkit.file.providers.fal import FalFileRepository, InMemoryRepository
 from fal.toolkit.file.providers.gcp import GoogleStorageRepository
+from fal.toolkit.file.providers.r2 import R2Repository
 from fal.toolkit.file.types import FileData, FileRepository, RepositoryId
 from fal.toolkit.mainify import mainify
 from pydantic import BaseModel, Field, PrivateAttr
 
-BuiltInRepositoryId = Literal["fal", "in_memory", "gcp_storage"]
 FileRepositoryFactory = Callable[[], FileRepository]
 
-BUILT_IN_REPOSITORIES: dict[BuiltInRepositoryId, FileRepositoryFactory] = {
+BUILT_IN_REPOSITORIES: dict[RepositoryId, FileRepositoryFactory] = {
     "fal": lambda: FalFileRepository(),
     "in_memory": lambda: InMemoryRepository(),
     "gcp_storage": lambda: GoogleStorageRepository(),
+    "r2": lambda: R2Repository(),
 }
 
 
-def get_builtin_repository(id: BuiltInRepositoryId) -> FileRepository:
+def get_builtin_repository(id: RepositoryId) -> FileRepository:
     if id not in BUILT_IN_REPOSITORIES.keys():
         raise ValueError(f'"{id}" is not a valid built-in file repository')
     return BUILT_IN_REPOSITORIES[id]()
@@ -27,7 +28,7 @@ def get_builtin_repository(id: BuiltInRepositoryId) -> FileRepository:
 
 get_builtin_repository.__module__ = "__main__"
 
-DEFAULT_REPOSITORY: FileRepository | BuiltInRepositoryId = "fal"
+DEFAULT_REPOSITORY: FileRepository | RepositoryId = "fal"
 
 
 @mainify

fal/toolkit/file/providers/gcp.py

@@ -17,6 +17,7 @@ class GoogleStorageRepository(FileRepository):
     bucket_name: str = "fal_file_storage"
     url_expiration: int | None = DEFAULT_URL_TIMEOUT
     gcp_account_json: str | None = None
+    folder: str = ""
 
     _storage_client = None
     _bucket = None
@@ -50,7 +51,9 @@ class GoogleStorageRepository(FileRepository):
         return self._bucket
 
     def save(self, data: FileData) -> str:
-        gcp_blob = self.bucket.blob(data.file_name)
+        destination_path = os.path.join(self.folder, data.file_name)
+
+        gcp_blob = self.bucket.blob(destination_path)
         gcp_blob.upload_from_string(data.data, content_type=data.content_type)
 
         if self.url_expiration is None:

fal/toolkit/file/providers/r2.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from io import BytesIO
+
+from fal.toolkit.file.types import FileData, FileRepository
+from fal.toolkit.mainify import mainify
+
+DEFAULT_URL_TIMEOUT = 60 * 15  # 15 minutes
+
+
+@mainify
+@dataclass
+class R2Repository(FileRepository):
+    bucket_name: str = "fal_file_storage"
+    url_expiration: int = DEFAULT_URL_TIMEOUT
+    r2_account_json: str | None = None
+    key: str = ""
+
+    _storage_client = None
+    _bucket = None
+
+    def __post_init__(self):
+        import boto3
+        from botocore.client import Config
+
+        r2_account_json = self.r2_account_json
+        if r2_account_json is None:
+            r2_account_json = os.environ.get("R2_CREDS_JSON")
+            if r2_account_json is None:
+                raise Exception("R2_CREDS_JSON environment secret is not set")
+
+        r2_account_info = json.loads(r2_account_json)
+        account_id = r2_account_info["ACCOUNT_ID"]
+        access_key_id = r2_account_info["ACCESS_KEY_ID"]
+        secret_access_key = r2_account_info["SECRET_ACCESS_KEY"]
+
+        self._s3_client = boto3.client(
+            "s3",
+            endpoint_url=f"https://{account_id}.r2.cloudflarestorage.com",
+            aws_access_key_id=access_key_id,
+            aws_secret_access_key=secret_access_key,
+            config=Config(signature_version="s3v4"),
+        )
+        self._s3_resource = boto3.resource(
+            "s3",
+            endpoint_url=f"https://{account_id}.r2.cloudflarestorage.com",
+            aws_access_key_id=access_key_id,
+            aws_secret_access_key=secret_access_key,
+        )
+
+        self._bucket = self._s3_resource.Bucket(self.bucket_name)
+
+    @property
+    def storage_client(self):
+        if self._s3_resource is None:
+            raise Exception("S3 Resource is not initialized")
+
+        return self._s3_resource
+
+    @property
+    def bucket(self):
+        if self._bucket is None:
+            raise Exception("S3 bucket is not initialized")
+
+        return self._bucket
+
+    def save(self, data: FileData) -> str:
+        destination_path = os.path.join(self.key, data.file_name)
+
+        s3_object = self.bucket.Object(destination_path)
+        s3_object.upload_fileobj(
+            BytesIO(data.data), ExtraArgs={"ContentType": data.content_type}
+        )
+
+        public_url = self._s3_client.generate_presigned_url(
+            ClientMethod="get_object",
+            Params={"Bucket": self.bucket_name, "Key": destination_path},
+            ExpiresIn=self.url_expiration,
+        )
+        return public_url

fal/toolkit/file/types.py

@@ -31,7 +31,7 @@ class FileData:
             self.file_name = file_name
 
 
-RepositoryId = Literal["fal", "in_memory", "gcp_storage"]
+RepositoryId = Literal["fal", "in_memory", "gcp_storage", "r2"]
 
 
 @mainify

fal/toolkit/image/image.py

@@ -25,10 +25,10 @@ ImageSizePreset = Literal[
 @mainify
 class ImageSize(BaseModel):
     width: int = Field(
-        default=512, description="The width of the generated image.", gt=0, le=4096
+        default=512, description="The width of the generated image.", gt=0, le=14142
     )
     height: int = Field(
-        default=512, description="The height of the generated image.", gt=0, le=4096
+        default=512, description="The height of the generated image.", gt=0, le=14142
     )
 
 

fal/toolkit/utils/download_utils.py

@@ -148,7 +148,7 @@ def download_file(
 
     # If target_dir is not an absolute path, use "/data" as the relative directory
     if not target_dir_path.is_absolute():
-        target_dir_path = Path("/data") / target_dir_path
+        target_dir_path = FAL_PERSISTENT_DIR / target_dir_path
 
     target_path = target_dir_path.resolve() / file_name
 

{fal-0.11.1.dist-info → fal-0.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 0.11.1
+Version: 0.11.3
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels
 Author-email: hello@fal.ai
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: attrs (>=21.3.0)
 Requires-Dist: auth0-python (>=4.1.0,<5.0.0)
+Requires-Dist: boto3 (>=1.33.8,<2.0.0)
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: datadog-api-client (==2.12.0)
@@ -21,7 +22,7 @@ Requires-Dist: grpc-interceptor (>=0.15.0,<0.16.0)
 Requires-Dist: grpcio (>=1.50.0,<2.0.0)
 Requires-Dist: httpx (>=0.15.4,<0.25.0)
 Requires-Dist: importlib-metadata (>=4.4) ; python_version < "3.10"
-Requires-Dist: isolate-proto (==0.1.4)
+Requires-Dist: isolate-proto (>=0.2.1,<0.3.0)
 Requires-Dist: isolate[build] (>=0.12.3,<1.0)
 Requires-Dist: opentelemetry-api (>=1.15.0,<2.0.0)
 Requires-Dist: opentelemetry-sdk (>=1.15.0,<2.0.0)
@@ -43,5 +44,41 @@ fal is a serverless Python runtime that lets you run and scale code in the cloud
 
 With fal, you can build pipelines, serve ML models and scale them up to many users. You scale down to 0 when you don't use any resources.
 
-Check out to the [docs](https://serverless.fal.ai/docs) for more details.
+## Quickstart
+
+First, you need to install the `fal` package. You can do so using pip:
+```shell
+pip install fal
+```
+
+Then you need to authenticate:
+```shell
+fal auth login
+```
+
+You can also use fal keys that you can get from [our dashboard](https://fal.ai/dashboard/keys).
+
+Now can use the fal package in your Python scripts as follows:
+
+```py
+import fal
+
+@fal.function(
+    "virtualenv",
+    requirements=["pyjokes"],
+)
+def tell_joke() -> str:
+    import pyjokes
+
+    joke = pyjokes.get_joke()
+    return joke
+
+print("Joke from the clouds: ", tell_joke())
+```
+
+A new virtual environment will be created by fal in the cloud and the set of requirements that we passed will be installed as soon as this function is called. From that point on, our code will be executed as if it were running locally, and the joke prepared by the pyjokes library will be returned.
+
+## Next steps
+
+If you would like to find out more about the capabilities of fal, check out to the [docs](https://fal.ai/docs). You can learn more about persistent storage, function caches and deploying your functions as API endpoints.