fal 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

fal/_fal_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.2.1'
-__version_tuple__ = version_tuple = (1, 2, 1)
+__version__ = version = '1.2.3'
+__version_tuple__ = version_tuple = (1, 2, 3)

fal/api.py

@@ -1048,7 +1048,9 @@ class BaseServable:
         from uvicorn import Config
 
         app = self._build_app()
-        server = Server(config=Config(app, host="0.0.0.0", port=8080))
+        server = Server(
+            config=Config(app, host="0.0.0.0", port=8080, timeout_keep_alive=300)
+        )
         metrics_app = FastAPI()
         metrics_app.add_route("/metrics", handle_metrics)
         metrics_server = Server(config=Config(metrics_app, host="0.0.0.0", port=9090))

fal/app.py

@@ -7,7 +7,7 @@ import re
 import time
 import typing
 from contextlib import asynccontextmanager, contextmanager
-from typing import Any, Callable, ClassVar, TypeVar
+from typing import Any, Callable, ClassVar, Literal, TypeVar
 
 import httpx
 from fastapi import FastAPI
@@ -152,12 +152,13 @@ class App(fal.api.BaseServable):
         "keep_alive": 60,
     }
     app_name: ClassVar[str]
+    app_auth: ClassVar[Literal["private", "public", "shared"]] = "private"
 
     def __init_subclass__(cls, **kwargs):
         app_name = kwargs.pop("name", None) or _to_fal_app_name(cls.__name__)
         parent_settings = getattr(cls, "host_kwargs", {})
         cls.host_kwargs = {**parent_settings, **kwargs}
-        cls.app_name = app_name
+        cls.app_name = getattr(cls, "app_name", app_name)
 
         if cls.__init__ is not App.__init__:
             raise ValueError(

fal/cli/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from .parser import FalClientParser
@@ -6,7 +8,7 @@ if TYPE_CHECKING:
     from fal.sdk import AliasInfo, ApplicationInfo
 
 
-def _apps_table(apps: list["AliasInfo"]):
+def _apps_table(apps: list[AliasInfo]):
     from rich.table import Table
 
     table = Table()
@@ -56,7 +58,7 @@ def _add_list_parser(subparsers, parents):
     parser.set_defaults(func=_list)
 
 
-def _app_rev_table(revs: list["ApplicationInfo"]):
+def _app_rev_table(revs: list[ApplicationInfo]):
     from rich.table import Table
 
     table = Table()

fal/cli/create.py

@@ -0,0 +1,26 @@
+PROJECT_TYPES = ["app"]
+
+
+def _create_project(project_type: str):
+    from cookiecutter.main import cookiecutter
+
+    cookiecutter("https://github.com/fal-ai/cookiecutter-fal.git")
+
+
+def add_parser(main_subparsers, parents):
+    apps_help = "Create fal applications."
+    parser = main_subparsers.add_parser(
+        "create",
+        description=apps_help,
+        help=apps_help,
+        parents=parents,
+    )
+
+    parser.add_argument(
+        metavar="project_type",
+        choices=PROJECT_TYPES,
+        help="Type of project to create.",
+        dest="project_type",
+    )
+
+    parser.set_defaults(func=_create_project)

fal/cli/deploy.py

@@ -81,17 +81,18 @@ def _deploy(args):
 
     user = _get_user()
     host = FalServerlessHost(args.host)
-    isolated_function, app_name = load_function_from(
+    isolated_function, app_name, app_auth = load_function_from(
         host,
         file_path,
         func_name,
     )
     app_name = args.app_name or app_name
+    app_auth = args.auth or app_auth or "private"
     app_id = host.register(
         func=isolated_function.func,
         options=isolated_function.options,
         application_name=app_name,
-        application_auth_mode=args.auth,
+        application_auth_mode=app_auth,
         metadata=isolated_function.options.host.get("metadata", {}),
     )
 
@@ -151,7 +152,6 @@ def add_parser(main_subparsers, parents):
     parser.add_argument(
         "--auth",
         type=valid_auth_option,
-        default="private",
         help="Application authentication mode (private, public).",
     )
     parser.set_defaults(func=_deploy)

fal/cli/main.py

@@ -6,7 +6,7 @@ from fal import __version__
 from fal.console import console
 from fal.console.icons import CROSS_ICON
 
-from . import apps, auth, deploy, doctor, keys, run, secrets
+from . import apps, auth, create, deploy, doctor, keys, run, secrets
 from .debug import debugtools, get_debug_parser
 from .parser import FalParser, FalParserExit
 
@@ -31,7 +31,7 @@ def _get_main_parser() -> argparse.ArgumentParser:
         required=True,
     )
 
-    for cmd in [auth, apps, deploy, run, keys, secrets, doctor]:
+    for cmd in [auth, apps, deploy, run, keys, secrets, doctor, create]:
         cmd.add_parser(subparsers, parents)
 
     return parser

fal/cli/run.py

@@ -6,7 +6,7 @@ def _run(args):
     from fal.utils import load_function_from
 
     host = FalServerlessHost(args.host)
-    isolated_function, _ = load_function_from(host, *args.func_ref)
+    isolated_function, _, _ = load_function_from(host, *args.func_ref)
     # let our exc handlers handle UserFunctionException
     isolated_function.reraise = False
     isolated_function()

fal/toolkit/image/__init__.py

@@ -1,3 +1,74 @@
 from __future__ import annotations
 
+from functools import lru_cache
+from typing import TYPE_CHECKING
+from urllib.request import Request, urlopen
+
 from .image import *  # noqa: F403
+
+if TYPE_CHECKING:
+    from PIL.Image import Image as PILImage
+
+
+def filter_by(
+    has_nsfw_concepts: list[bool],
+    images: list[PILImage],
+) -> list[PILImage]:
+    from PIL import Image as PILImage
+
+    return [
+        (
+            PILImage.new("RGB", (image.width, image.height), (0, 0, 0))
+            if has_nsfw
+            else image
+        )
+        for image, has_nsfw in zip(images, has_nsfw_concepts)
+    ]
+
+
+def preprocess_image(image_pil, convert_to_rgb=True, fix_orientation=True):
+    from PIL import ImageOps, ImageSequence
+
+    # For MPO (multi picture object) format images, we only need the first image
+    images = []
+    for image in ImageSequence.Iterator(image_pil):
+        img = image
+
+        if convert_to_rgb:
+            img = img.convert("RGB")
+
+        if fix_orientation:
+            img = ImageOps.exif_transpose(img)
+
+        images.append(img)
+
+        break
+
+    return images[0]
+
+
+@lru_cache(maxsize=64)
+def read_image_from_url(
+    url: str, convert_to_rgb: bool = True, fix_orientation: bool = True
+):
+    from fastapi import HTTPException
+    from PIL import Image
+
+    TEMP_HEADERS = {
+        "User-Agent": (
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) "
+            "Gecko/20100101 Firefox/21.0"
+        ),
+    }
+
+    try:
+        request = Request(url, headers=TEMP_HEADERS)
+        response = urlopen(request)
+        image_pil = Image.open(response)
+    except Exception:
+        import traceback
+
+        traceback.print_exc()
+        raise HTTPException(422, f"Could not load image from url: {url}")
+
+    return preprocess_image(image_pil, convert_to_rgb, fix_orientation)

fal/toolkit/image/nsfw_filter/__init__.py

@@ -0,0 +1,11 @@
+from .inference import (
+    NSFWImageDetectionInput,
+    NSFWImageDetectionOutput,
+    run_nsfw_estimation,
+)
+
+__all__ = [
+    "NSFWImageDetectionInput",
+    "NSFWImageDetectionOutput",
+    "run_nsfw_estimation",
+]

fal/toolkit/image/nsfw_filter/env.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+CURR_DIR = Path(__file__).resolve().parent
+
+
+def get_requirements():
+    with open(CURR_DIR / "requirements.txt") as fp:
+        requirements = fp.read().split()
+    return requirements

fal/toolkit/image/nsfw_filter/inference.py

@@ -0,0 +1,77 @@
+from pydantic import BaseModel, Field
+
+import fal
+from fal.toolkit.image import read_image_from_url
+
+from .env import get_requirements
+from .model import get_model
+
+
+class NSFWImageDetectionInput(BaseModel):
+    image_url: str = Field(
+        description="Input image url.",
+        examples=[
+            "https://storage.googleapis.com/falserverless/model_tests/remove_background/elephant.jpg",
+        ],
+    )
+
+
+class NSFWImageDetectionOutput(BaseModel):
+    nsfw_probability: float = Field(
+        description="The probability of the image being NSFW.",
+    )
+
+
+def check_nsfw_content(pil_image: object):
+    import torch
+
+    model, processor = get_model()
+
+    with torch.no_grad():
+        inputs = processor(images=pil_image, return_tensors="pt")
+        outputs = model(**inputs)
+        logits = outputs.logits.squeeze()  # Remove batch dimension to simplify indexing
+
+    # Apply softmax to convert logits to probabilities
+    probabilities = torch.softmax(logits, dim=0)
+
+    nsfw_class_index = model.config.label2id.get(
+        "nsfw", None
+    )  # Replace "NSFW" with the exact class name if different
+
+    # Validate that NSFW class index is found
+    if nsfw_class_index is not None:
+        nsfw_probability = probabilities[int(nsfw_class_index)].item()
+        return nsfw_probability
+    else:
+        raise ValueError("NSFW class not found in model output.")
+
+
+def run_nsfw_estimation(
+    input: NSFWImageDetectionInput,
+) -> NSFWImageDetectionOutput:
+    img = read_image_from_url(input.image_url)
+    nsfw_probability = check_nsfw_content(img)
+
+    return NSFWImageDetectionOutput(nsfw_probability=nsfw_probability)
+
+
+@fal.function(
+    requirements=get_requirements(),
+    machine_type="GPU-A6000",
+    serve=True,
+)
+def run_nsfw_estimation_on_fal(
+    input: NSFWImageDetectionInput,
+) -> NSFWImageDetectionOutput:
+    return run_nsfw_estimation(input)
+
+
+if __name__ == "__main__":
+    local = run_nsfw_estimation_on_fal.on(serve=False)
+    result = local(
+        NSFWImageDetectionInput(
+            image_url="https://storage.googleapis.com/falserverless/model_tests/remove_background/elephant.jpg",
+        )
+    )
+    print(result)

fal/toolkit/image/nsfw_filter/model.py

@@ -0,0 +1,18 @@
+import fal
+
+
+@fal.cached
+def get_model():
+    import os
+
+    from transformers import AutoModelForImageClassification, ViTImageProcessor
+
+    os.environ["TRANSFORMERS_CACHE"] = "/data/models"
+    os.environ["HF_HOME"] = "/data/models"
+
+    model = AutoModelForImageClassification.from_pretrained(
+        "Falconsai/nsfw_image_detection"
+    )
+    processor = ViTImageProcessor.from_pretrained("Falconsai/nsfw_image_detection")
+
+    return model, processor

fal/toolkit/image/nsfw_filter/requirements.txt

@@ -0,0 +1,4 @@
+accelerate
+Pillow
+torch
+transformers

fal/toolkit/image/safety_checker.py

@@ -0,0 +1,107 @@
+from typing import Any
+
+import fal
+
+from . import filter_by
+from .nsfw_filter.model import get_model
+
+
+@fal.cached
+def load_safety_checker():
+    import torch
+    from diffusers.pipelines.stable_diffusion.safety_checker import (
+        StableDiffusionSafetyChecker,
+    )
+    from transformers import AutoFeatureExtractor
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        "CompVis/stable-diffusion-safety-checker",
+        torch_dtype="float16",
+    )
+    safety_checker = StableDiffusionSafetyChecker.from_pretrained(
+        "CompVis/stable-diffusion-safety-checker",
+        torch_dtype=torch.float16,
+    ).to("cuda")
+
+    return feature_extractor, safety_checker
+
+
+def run_safety_checker(
+    pil_images: list[object],
+) -> list[bool]:
+    import numpy as np
+    import torch
+
+    feature_extractor, safety_checker = load_safety_checker()
+
+    safety_checker_input = feature_extractor(pil_images, return_tensors="pt").to("cuda")
+
+    np_image = [np.array(val) for val in pil_images]
+
+    _, has_nsfw_concept = safety_checker(
+        images=np_image,
+        clip_input=safety_checker_input.pixel_values.to(torch.float16),
+    )
+
+    return has_nsfw_concept
+
+
+def run_safety_checker_v2(pil_images: list, nsfw_threshold: float = 0.5) -> list[bool]:
+    import torch
+
+    model, processor = get_model()
+
+    has_nsfw_concept = []
+
+    with torch.no_grad():
+        for pil_image in pil_images:
+            inputs = processor(
+                images=pil_image.convert("RGB"),
+                return_tensors="pt",
+            )
+            outputs = model(**inputs)
+            logits = (
+                outputs.logits.squeeze()
+            )  # Remove batch dimension to simplify indexing
+
+            # Apply softmax to convert logits to probabilities
+            probabilities = torch.softmax(logits, dim=0)
+
+            nsfw_class_index = model.config.label2id.get(
+                "nsfw", None
+            )  # Replace "NSFW" with the exact class name if different
+
+            # Validate that NSFW class index is found
+            if nsfw_class_index is not None:
+                nsfw_probability = probabilities[int(nsfw_class_index)].item()
+                print("NSFW probability:", nsfw_probability)
+                has_nsfw_concept.append(nsfw_probability > nsfw_threshold)
+            else:
+                raise ValueError("NSFW class not found in model output.")
+
+    return has_nsfw_concept
+
+
+def postprocess_images(
+    pil_images: list[object],
+    enable_safety_checker: bool = True,
+    safety_checker_version: int = 2,
+) -> dict[str, Any]:
+    outputs: dict[str, list[Any]] = {
+        "images": pil_images,
+    }
+
+    if enable_safety_checker:
+        safety_checker_fn = (
+            run_safety_checker_v2 if safety_checker_version == 2 else run_safety_checker
+        )
+        outputs["has_nsfw_concepts"] = safety_checker_fn(pil_images)  # type: ignore
+    else:
+        outputs["has_nsfw_concepts"] = [False] * len(pil_images)
+
+    outputs["images"] = filter_by(
+        outputs["has_nsfw_concepts"],
+        outputs["images"],
+    )
+
+    return outputs

fal/utils.py

@@ -10,13 +10,13 @@ def load_function_from(
     host: FalServerlessHost,
     file_path: str,
     function_name: str | None = None,
-) -> tuple[IsolatedFunction, str | None]:
+) -> tuple[IsolatedFunction, str | None, str | None]:
     import runpy
 
     module = runpy.run_path(file_path)
     if function_name is None:
         fal_objects = {
-            obj.app_name: obj_name
+            obj_name: obj
             for obj_name, obj in module.items()
             if isinstance(obj, type)
             and issubclass(obj, fal.App)
@@ -30,9 +30,12 @@ def load_function_from(
                 "Please specify the name of the app."
             )
 
-        [(app_name, function_name)] = fal_objects.items()
+        [(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")
@@ -44,10 +47,11 @@ def load_function_from(
     target = module[function_name]
     if isinstance(target, type) and issubclass(target, App):
         app_name = target.app_name
+        app_auth = target.app_auth
         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
+    return target, app_name, app_auth

{fal-1.2.1.dist-info → fal-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 1.2.1
+Version: 1.2.3
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
@@ -34,6 +34,7 @@ Requires-Dist: websockets <13,>=12.0
 Requires-Dist: pillow <11,>=10.2.0
 Requires-Dist: pyjwt[crypto] <3,>=2.8.0
 Requires-Dist: uvicorn <1,>=0.29.0
+Requires-Dist: cookiecutter
 Requires-Dist: importlib-metadata >=4.4 ; python_version < "3.10"
 Provides-Extra: dev
 Requires-Dist: fal[test] ; extra == 'dev'

{fal-1.2.1.dist-info → fal-1.2.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
 fal/__init__.py,sha256=wXs1G0gSc7ZK60-bHe-B2m0l_sA6TrFk4BxY0tMoLe8,784
 fal/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
-fal/_fal_version.py,sha256=2U0Gn26fYI3Vgj5hgkLM8I3wI6YEVdffJGllaVW-sSc,411
+fal/_fal_version.py,sha256=VUBVzEBuW57s195P22MF-rLGH7GWx3G_z5nV-l_8MBE,411
 fal/_serialization.py,sha256=rD2YiSa8iuzCaZohZwN_MPEB-PpSKbWRDeaIDpTEjyY,7653
 fal/_version.py,sha256=EBGqrknaf1WygENX-H4fBefLvHryvJBBGtVJetaB0NY,266
-fal/api.py,sha256=x60GlBWynDd1yhHsVWeqf07WVTzgbwNC6cqCjhlTiFQ,40556
-fal/app.py,sha256=duOf_YKE8o30hmhNtF9zvkT8wlKYXW7hdQLJtPrXHik,15793
+fal/api.py,sha256=LAPl5Hf6ZWzEjv4lFUtsisWgrnXH_qNUHdJrEHT_A5Y,40602
+fal/app.py,sha256=9HJGu_64ArtW8W91BC0U4Etr2gA31LXaHgR6HzoOops,15903
 fal/apps.py,sha256=FrKmaAUo8U9vE_fcva0GQvk4sCrzaTEr62lGtu3Ld5M,6825
 fal/container.py,sha256=V7riyyq8AZGwEX9QaqRQDZyDN_bUKeRKV1OOZArXjL0,622
 fal/flags.py,sha256=oWN_eidSUOcE9wdPK_77si3A1fpgOC0UEERPsvNLIMc,842
@@ -12,21 +12,22 @@ fal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fal/rest_client.py,sha256=kGBGmuyHfX1lR910EoKCYPjsyU8MdXawT_cW2q8Sajc,568
 fal/sdk.py,sha256=wA58DYnSK1vdsBi8Or9Z8kvMMEyBNfeZYk_xulSfTWE,20078
 fal/sync.py,sha256=ZuIJA2-hTPNANG9B_NNJZUsO68EIdTH0dc9MzeVE2VU,4340
-fal/utils.py,sha256=pstF7-13xjB1gKOtzz4tIXc8b8nMSDd9HO79WCiVrt4,1753
+fal/utils.py,sha256=4-V6iGSRd3kG_-UP6OdZp_-EhAkl3zectFlFKkCsS0Q,1884
 fal/workflows.py,sha256=jx3tGy2R7cN6lLvOzT6lhhlcjmiq64iZls2smVrmQj0,14657
 fal/auth/__init__.py,sha256=r8iA2-5ih7-Fik3gEC4HEWNFbGoxpYnXpZu1icPIoS0,3561
 fal/auth/auth0.py,sha256=rSG1mgH-QGyKfzd7XyAaj1AYsWt-ho8Y_LZ-FUVWzh4,5421
 fal/auth/local.py,sha256=sndkM6vKpeVny6NHTacVlTbiIFqaksOmw0Viqs_RN1U,1790
 fal/cli/__init__.py,sha256=padK4o0BFqq61kxAA1qQ0jYr2SuhA2mf90B3AaRkmJA,37
-fal/cli/apps.py,sha256=GlQSEE68HYfnhK90WIiOx611tcVkkbc9bu_10FMaFLY,8143
+fal/cli/apps.py,sha256=-DDp-Gvxz5kHho5YjAhbri8vOny_9cftAI_wP2KR5nU,8175
 fal/cli/auth.py,sha256=--MhfHGwxmtHbRkGioyn1prKn_U-pBzbz0G_QeZou-U,1352
+fal/cli/create.py,sha256=a8WDq-nJLFTeoIXqpb5cr7GR7YR9ZZrQCawNm34KXXE,627
 fal/cli/debug.py,sha256=u_urnyFzSlNnrq93zz_GXE9FX4VyVxDoamJJyrZpFI0,1312
-fal/cli/deploy.py,sha256=jA-C4Pvzie70MVDnaFKc6ByfBrNFeaMROAKX98RD8tQ,4785
+fal/cli/deploy.py,sha256=1e4OERVGtfwgM0VEFjlCLpNyuOl1BiLI-dx8u-71PVs,4817
 fal/cli/doctor.py,sha256=U4ne9LX5gQwNblsYQ27XdO8AYDgbYjTO39EtxhwexRM,983
 fal/cli/keys.py,sha256=trDpA3LJu9S27qE_K8Hr6fKLK4vwVzbxUHq8TFrV4pw,3157
-fal/cli/main.py,sha256=MxETDhqIT37quMbmofSMxBcAFOhnEHjpQ_pYEtOhApM,1993
+fal/cli/main.py,sha256=_Wh_DQc02qwh-ZN7v41lZm0lDR1WseViXVOcqUlyWLg,2009
 fal/cli/parser.py,sha256=r1hd5e8Jq6yzDZw8-S0On1EjJbjRtHMuVuHC6MlvUj4,2835
-fal/cli/run.py,sha256=enhnpqo07PzGK2uh8M522zenNWxrBFOqb3oMZ8XiWdg,870
+fal/cli/run.py,sha256=8wHNDruIr8i21JwbfFzS389C-y0jktM5zN5iDnJHsvA,873
 fal/cli/secrets.py,sha256=740msFm7d41HruudlcfqUXlFl53N-WmChsQP9B9M9Po,2572
 fal/console/__init__.py,sha256=ernZ4bzvvliQh5SmrEqQ7lA5eVcbw6Ra2jalKtA7dxg,132
 fal/console/icons.py,sha256=De9MfFaSkO2Lqfne13n3PrYfTXJVIzYZVqYn5BWsdrA,108
@@ -48,8 +49,14 @@ fal/toolkit/file/types.py,sha256=bJCeV5NPcpJYJoglailiRgFsuNAfcextYA8Et5-XUag,106
 fal/toolkit/file/providers/fal.py,sha256=65-BkK9jhGBwYI_OjhHJsL2DthyKxBBRrqXPI_ZN4-k,4115
 fal/toolkit/file/providers/gcp.py,sha256=pUVH2qNcnO_VrDQQU8MmfYOQZMGaKQIqE4yGnYdQhAc,2003
 fal/toolkit/file/providers/r2.py,sha256=WxmOHF5WxHt6tKMcFjWj7ZWO8a1EXysO9lfYv_tB3MI,2627
-fal/toolkit/image/__init__.py,sha256=qNLyXsBWysionUjbeWbohLqWlw3G_UpzunamkZd_JLQ,71
+fal/toolkit/image/__init__.py,sha256=aLcU8HzD7HyOxx-C-Bbx9kYCMHdBhy9tR98FSVJ6gSA,1830
 fal/toolkit/image/image.py,sha256=UDIHgkxae8LzmCvWBM9GayMnK8c0JMMfsrVlLnW5rto,4234
+fal/toolkit/image/safety_checker.py,sha256=S7ow-HuoVxC6ixHWWcBrAUm2dIlgq3sTAIull6xIbAg,3105
+fal/toolkit/image/nsfw_filter/__init__.py,sha256=0d9D51EhcnJg8cZLYJjgvQJDZT74CfQu6mpvinRYRpA,216
+fal/toolkit/image/nsfw_filter/env.py,sha256=iAP2Q3vzIl--DD8nr8o3o0goAwhExN2v0feYE0nIQjs,212
+fal/toolkit/image/nsfw_filter/inference.py,sha256=BhIPF_zxRLetThQYxDDF0sdx9VRwvu74M5ye6Povi40,2167
+fal/toolkit/image/nsfw_filter/model.py,sha256=63mu8D15z_IosoRUagRLGHy6VbLqFmrG-yZqnu2vVm4,457
+fal/toolkit/image/nsfw_filter/requirements.txt,sha256=3Pmrd0Ny6QAeBqUNHCgffRyfaCARAPJcfSCX5cRYpbM,37
 fal/toolkit/utils/__init__.py,sha256=CrmM9DyCz5-SmcTzRSm5RaLgxy3kf0ZsSEN9uhnX2Xo,97
 fal/toolkit/utils/download_utils.py,sha256=9WMpn0mFIhkFelQpPj5KG-pC7RMyyOzGHbNRDSyz07o,17664
 openapi_fal_rest/__init__.py,sha256=ziculmF_i6trw63LzZGFX-6W3Lwq9mCR8_UpkpvpaHI,152
@@ -115,8 +122,8 @@ openapi_fal_rest/models/workflow_node_type.py,sha256=-FzyeY2bxcNmizKbJI8joG7byRi
 openapi_fal_rest/models/workflow_schema.py,sha256=4K5gsv9u9pxx2ItkffoyHeNjBBYf6ur5bN4m_zePZNY,2019
 openapi_fal_rest/models/workflow_schema_input.py,sha256=2OkOXWHTNsCXHWS6EGDFzcJKkW5FIap-2gfO233EvZQ,1191
 openapi_fal_rest/models/workflow_schema_output.py,sha256=EblwSPAGfWfYVWw_WSSaBzQVju296is9o28rMBAd0mc,1196
-fal-1.2.1.dist-info/METADATA,sha256=1ViXkmFXOXQqD52q0HPxP-BuzHL5RzQ6x6MC__GOXn4,3777
-fal-1.2.1.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-fal-1.2.1.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
-fal-1.2.1.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
-fal-1.2.1.dist-info/RECORD,,
+fal-1.2.3.dist-info/METADATA,sha256=tUsGGaLLvqfYpEePodE0fuc5nm_XSoYE7AWTrci2nEY,3805
+fal-1.2.3.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+fal-1.2.3.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
+fal-1.2.3.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
+fal-1.2.3.dist-info/RECORD,,

{fal-1.2.1.dist-info → fal-1.2.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any