fal 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

fal/workflows.py

@@ -0,0 +1,481 @@
+from __future__ import annotations
+
+import graphlib
+import json
+import webbrowser
+from argparse import ArgumentParser
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any, Iterator, Union, cast
+
+import rich
+from openapi_fal_rest.api.workflows import (
+    create_or_update_workflow_workflows_post as publish_workflow,
+)
+from pydantic import BaseModel
+from rich.syntax import Syntax
+
+import fal
+from fal import flags
+from fal.rest_client import REST_CLIENT
+
+JSONType = Union[dict[str, Any], list[Any], str, int, float, bool, None, "Leaf"]
+SchemaType = dict[str, Any]
+
+VARIABLE_PREFIX = "$"
+INPUT_VARIABLE_NAME = "input"
+
+# Will be 1.0 once the server is finalized and anything <1.0
+# is going to be rejected.
+WORKFLOW_EXPORT_VERSION = "0.1"
+
+
+class WorkflowSyntaxError(Exception):
+    pass
+
+
+class MisconfiguredGraphError(WorkflowSyntaxError):
+    pass
+
+
+def parse_leaf(raw_leaf: str) -> Leaf:
+    """Parses a leaf (which is in the form of $variable.field.field_2[index] etc.)
+    into a tree of Leaf objects."""
+    raw_parts = raw_leaf.split(".")
+    reference, *raw_parts = raw_parts
+    if not reference.startswith(VARIABLE_PREFIX):
+        raise WorkflowSyntaxError(
+            f"Invalid leaf: {raw_leaf} (must start with a reference)"
+        )
+
+    leaf: Leaf = ReferenceLeaf(reference.removeprefix(VARIABLE_PREFIX))
+    for raw_part in raw_parts:
+        if raw_part.isdigit():
+            leaf = IndexLeaf(leaf, int(raw_part))
+        elif raw_part.isidentifier():
+            leaf = AttributeLeaf(leaf, raw_part)
+        else:
+            raise WorkflowSyntaxError(
+                f"Invalid leaf: {raw_leaf} (unexpected {raw_part})"
+            )
+
+    return leaf
+
+
+def export_workflow_json(data: JSONType) -> JSONType:
+    if isinstance(data, dict):
+        return {k: export_workflow_json(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [export_workflow_json(v) for v in data]
+    elif isinstance(data, Leaf):
+        return repr(data)
+    else:
+        return data
+
+
+def import_workflow_json(data: JSONType) -> JSONType:
+    if isinstance(data, dict):
+        return {k: import_workflow_json(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [import_workflow_json(v) for v in data]
+    elif isinstance(data, str) and data.startswith(VARIABLE_PREFIX):
+        return parse_leaf(data)
+    else:
+        return data
+
+
+def iter_leaves(data: JSONType) -> Iterator[JSONType]:
+    if isinstance(data, dict):
+        for value in data.values():
+            yield from iter_leaves(value)
+    elif isinstance(data, list):
+        for item in data:
+            yield from iter_leaves(item)
+    else:
+        yield data
+
+
+def depends(data: JSONType) -> set[str]:
+    return {
+        leaf.referee.id  # type: ignore
+        for leaf in iter_leaves(data)
+        if isinstance(leaf, Leaf)
+    }
+
+
+@dataclass
+class Context:
+    vars: dict[str, JSONType]
+
+    def hydrate(self, input: JSONType) -> JSONType:
+        if isinstance(input, dict):
+            return {k: self.hydrate(v) for k, v in input.items()}
+        elif isinstance(input, list):
+            return [self.hydrate(v) for v in input]
+        elif isinstance(input, Leaf):
+            return input.execute(self)
+        else:
+            return input
+
+
+@dataclass
+class Leaf:
+    def execute(self, context: Context) -> JSONType:
+        raise NotImplementedError
+
+    def __getattr__(self, name: str) -> AttributeLeaf:
+        return AttributeLeaf(self, name)
+
+    def __getitem__(self, index: int) -> IndexLeaf:
+        return IndexLeaf(self, index)
+
+    @property
+    def referee(self) -> ReferenceLeaf:
+        raise NotImplementedError
+
+
+@dataclass
+class AttributeLeaf(Leaf):
+    leaf: Leaf
+    attribute: str
+
+    def execute(self, context: Context) -> JSONType:
+        output = self.leaf.execute(context)
+        assert isinstance(output, dict), f"{self.leaf!r} is not a dict"
+        return output[self.attribute]
+
+    def __repr__(self) -> str:
+        return f"{self.leaf!r}.{self.attribute}"
+
+    @property
+    def referee(self) -> ReferenceLeaf:
+        return self.leaf.referee
+
+
+@dataclass
+class IndexLeaf(Leaf):
+    leaf: Leaf
+    index: int
+
+    def execute(self, context: Context) -> JSONType:
+        output = self.leaf.execute(context)
+        assert isinstance(output, list), f"{self.leaf!r} is not an array"
+        return output[self.index]
+
+    def __repr__(self) -> str:
+        return f"{self.leaf!r}.{self.index}"
+
+    @property
+    def referee(self) -> ReferenceLeaf:
+        return self.leaf.referee
+
+
+@dataclass
+class ReferenceLeaf(Leaf):
+    id: str
+
+    def execute(self, context: Context) -> JSONType:
+        try:
+            return context.vars[self.id]
+        except KeyError:
+            raise MisconfiguredGraphError(f"Variable {self.id!r} is not defined")
+
+    def __repr__(self) -> str:
+        return VARIABLE_PREFIX + self.id
+
+    @property
+    def referee(self) -> ReferenceLeaf:
+        return self
+
+
+@dataclass
+class Node:
+    id: str
+    depends: set[str]
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> Node:
+        type = data.pop("type")
+        if type == "display":
+            return Display.from_json(data)
+        elif type == "run":
+            return Run.from_json(data)
+        else:
+            raise WorkflowSyntaxError(f"Invalid node type: {type}")
+
+    def to_json(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def execute(self, context: Context) -> JSONType:
+        raise NotImplementedError
+
+
+@dataclass
+class Display(Node):
+    fields: list[Leaf]
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> Display:
+        return cls(
+            id=data["id"],
+            depends=set(data["depends"]),
+            fields=import_workflow_json(data["fields"]),  # type: ignore
+        )
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "type": "display",
+            "id": self.id,
+            "depends": list(self.depends),
+            "fields": export_workflow_json(self.fields),
+        }
+
+    def execute(self, context: Context) -> JSONType:
+        for url in context.hydrate(self.fields):  # type: ignore
+            if flags.DONT_OPEN_LINKS:
+                print("Link:", url)
+            else:
+                webbrowser.open(url)
+
+
+@dataclass
+class Run(Node):
+    app: str
+    input: JSONType
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> Run:
+        return cls(
+            id=data["id"],
+            depends=set(data["depends"]),
+            app=data["app"],
+            input=import_workflow_json(data["input"]),
+        )
+
+    def execute(self, context: Context) -> JSONType:
+        input = context.hydrate(self.input)
+        assert isinstance(input, dict)
+        return cast(JSONType, fal.apps.run(self.app, input))
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "type": "run",
+            "id": self.id,
+            "app": self.app,
+            "depends": list(self.depends),
+            "input": export_workflow_json(self.input),  # type: ignore
+        }
+
+
+@dataclass
+class Workflow:
+    name: str
+    input_schema: SchemaType
+    output_schema: SchemaType
+    nodes: dict[str, Node] = field(default_factory=dict)
+    output: dict[str, Any] | None = None
+    _app_counter: Counter = field(default_factory=Counter)
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> Workflow:
+        data = import_workflow_json(data)  # type: ignore
+        return cls(
+            name=data["name"],
+            input_schema=data["schema"]["input"],
+            output_schema=data["schema"]["output"],
+            nodes={
+                node_id: Node.from_json(node_data)
+                for node_id, node_data in data["nodes"].items()
+            },
+            output=data["output"],
+        )
+
+    def __post_init__(self) -> None:
+        for node in self.nodes.values():
+            if isinstance(node, Run):
+                self._app_counter[node.app] += 1
+
+    def _generate_node_id(self, app: str) -> str:
+        self._app_counter[app] += 1
+        return f"{app.replace('/', '_').replace('-', '_')}_{self._app_counter[app]}"
+
+    def run(self, app: str, input: JSONType) -> ReferenceLeaf:
+        node_id = self._generate_node_id(app)
+        node = self.nodes[node_id] = Run(
+            id=node_id,
+            depends=depends(input),
+            app=app,
+            input=input,
+        )
+        return ReferenceLeaf(node.id)
+
+    def display(self, *fields: Leaf) -> None:
+        node_id = self._generate_node_id("display")
+        self.nodes[node_id] = Display(
+            node_id,
+            depends=depends(list(fields)),
+            fields=list(fields),
+        )
+
+    def set_output(self, output: JSONType) -> None:
+        self.output = output  # type: ignore
+
+    def execute(self, input: JSONType) -> JSONType:
+        if not self.output:
+            raise WorkflowSyntaxError(
+                "Can't execute the workflow before the output is set."
+            )
+
+        context = Context({INPUT_VARIABLE_NAME: input})
+
+        sorter = graphlib.TopologicalSorter(
+            graph={
+                node.id: node.depends - {INPUT_VARIABLE_NAME}
+                for node in self.nodes.values()
+            }
+        )
+        for node_id in sorter.static_order():
+            node = self.nodes[node_id]
+            context.vars[node_id] = node.execute(context)
+
+        return context.hydrate(self.output)
+
+    @property
+    def input(self) -> ReferenceLeaf:
+        return ReferenceLeaf(INPUT_VARIABLE_NAME)
+
+    def to_json(self) -> dict[str, JSONType]:
+        if not self.output:
+            raise WorkflowSyntaxError(
+                "Can't serialize the workflow before the output is set."
+            )
+
+        return {
+            "name": self.name,
+            "schema": {
+                "input": self.input_schema,
+                "output": self.output_schema,
+            },
+            "nodes": {node.id: node.to_json() for node in self.nodes.values()},
+            "output": export_workflow_json(self.output),
+            "version": WORKFLOW_EXPORT_VERSION,
+        }
+
+    to_dict = to_json
+
+    def publish(self, title: str, *, is_public: bool = True) -> None:
+        workflow_contents = publish_workflow.TypedWorkflow(
+            name=self.name,
+            title=title,
+            contents=self,  # type: ignore
+            is_public=is_public,
+        )
+        published_workflow = publish_workflow.sync(
+            client=REST_CLIENT,
+            json_body=workflow_contents,
+        )
+        if isinstance(published_workflow, Exception):
+            raise published_workflow
+
+        return (
+            REST_CLIENT.base_url
+            + "/workflows/"
+            + published_workflow.user_id
+            + "/"
+            + published_workflow.name
+        )
+
+
+def create_workflow(
+    name: str,
+    input: type[BaseModel],
+    output: type[BaseModel],
+) -> Workflow:
+    return Workflow(
+        name=name,
+        input_schema=input.schema(),
+        output_schema=output.schema(),
+    )
+
+
+def main() -> None:
+    import cli_nested_json
+
+    parser = ArgumentParser()
+    parser.add_argument("workflow_file", type=str)
+    args, input_params = parser.parse_known_args()
+
+    with open(args.workflow_file) as stream:
+        workflow = Workflow.from_json(json.load(stream))
+
+    payload = cli_nested_json.interpret_nested_json(
+        [part.split("=") for part in input_params]
+    )
+    console = rich.get_console()
+    console.print(
+        f"🤧 Loaded {workflow.name!r} with {len(workflow.nodes)} nodes!",
+        style="bold magenta",
+    )
+
+    context = Context({INPUT_VARIABLE_NAME: payload})
+
+    sorter = graphlib.TopologicalSorter(
+        graph={
+            node.id: node.depends - {INPUT_VARIABLE_NAME}
+            for node in workflow.nodes.values()
+        }
+    )
+    with console.status("Starting the execution", spinner="bouncingBall") as status:
+        for n, node_id in enumerate(sorter.static_order()):
+            node = workflow.nodes[node_id]
+            status.update(
+                status=f"Executing {node_id!r} ({n}/{len(workflow.nodes)})",
+                spinner="runner",
+            )
+            if isinstance(node, Run):
+                input = context.hydrate(node.input)
+                assert isinstance(input, dict)
+
+                owner, _, app = node.app.partition("/")
+                app, sep, path = app.partition("/")
+
+                handle = fal.apps.submit(
+                    f"{owner}/{app}",
+                    path=f"{sep}{path}",
+                    arguments=input,
+                )
+                log_count = 0
+                for event in handle.iter_events(logs=True):
+                    if isinstance(event, fal.apps.Queued):
+                        status.update(
+                            status=f"Queued for {node_id!r} (position={event.position}) ({n}/{len(workflow.nodes)})",
+                            spinner="dots",
+                        )
+                    elif isinstance(event, fal.apps.InProgress):
+                        status.update(
+                            status=f"Executing {node_id!r} ({n}/{len(workflow.nodes)})",
+                            spinner="runner",
+                        )
+                        for log in event.logs[log_count:]:  # type: ignore
+                            console.log(log["message"], style="dim")
+                            log_count += 1
+
+                handle_status = handle.status(logs=True)
+                assert isinstance(handle_status, fal.apps.Completed)
+                for log in handle_status.logs[log_count:]:  # type: ignore
+                    console.log(log["message"], style="dim")
+
+                context.vars[node_id] = handle.get()
+            else:
+                context.vars[node_id] = node.execute(context)
+
+        console.print(
+            f"🎉 Execution complete!",
+            style="bold green",
+        )
+        output = context.hydrate(workflow.output)
+        console.print(Syntax(json.dumps(output, indent=2), "json"))
+
+
+if __name__ == "__main__":
+    main()

{fal-0.12.2.dist-info → fal-0.12.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 0.12.2
+Version: 0.12.4
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels
 Author-email: hello@fal.ai
@@ -11,18 +11,15 @@ Classifier: Programming Language :: Python :: 3.9
 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)
 Requires-Dist: dill (==0.3.7)
 Requires-Dist: fastapi (==0.99.1)
 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: httpx (>=0.15.4)
 Requires-Dist: importlib-metadata (>=4.4) ; python_version < "3.10"
-Requires-Dist: isolate-proto (>=0.3.1,<0.4.0)
+Requires-Dist: isolate-proto (>=0.3.4,<0.4.0)
 Requires-Dist: isolate[build] (>=0.12.3,<1.0)
 Requires-Dist: msgpack (>=1.0.7,<2.0.0)
 Requires-Dist: opentelemetry-api (>=1.15.0,<2.0.0)
@@ -32,8 +29,8 @@ Requires-Dist: pathspec (>=0.11.1,<0.12.0)
 Requires-Dist: pillow (>=10.2.0,<11.0.0)
 Requires-Dist: portalocker (>=2.7.0,<3.0.0)
 Requires-Dist: pydantic (<2.0)
+Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
 Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
-Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: rich (>=13.3.2,<14.0.0)
 Requires-Dist: structlog (>=22.3.0,<23.0.0)
 Requires-Dist: types-python-dateutil (>=2.8.0,<3.0.0)

fal-0.12.4.dist-info/RECORD

@@ -0,0 +1,88 @@
+openapi_fal_rest/__init__.py,sha256=ziculmF_i6trw63LzZGFX-6W3Lwq9mCR8_UpkpvpaHI,152
+openapi_fal_rest/api/__init__.py,sha256=87ApBzKyGb5zsgTMOkQXDqsLZCmaSFoJMwbGzCDQZMw,47
+openapi_fal_rest/api/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openapi_fal_rest/api/applications/app_metadata.py,sha256=GqG6Q7jt8Jcyhb3ms_6i0M1B3cy205y3_A8W-AGEapY,5120
+openapi_fal_rest/api/billing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openapi_fal_rest/api/billing/get_user_details.py,sha256=2HQHRUQj8QwqSKgiV_USBdXCxGlfaVTBbLiPaDsMBUM,4013
+openapi_fal_rest/api/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openapi_fal_rest/api/files/check_dir_hash.py,sha256=zPNlOwG4YVvnhgfrleQtYLhI1lG0t8YQ1CU3TyvXvfk,4747
+openapi_fal_rest/api/files/upload_local_file.py,sha256=p2lM7hswGbs8KNLg1Pp6vwV7x-1PKtWX-aYmaHUHSDU,5649
+openapi_fal_rest/api/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openapi_fal_rest/api/workflows/create_or_update_workflow_workflows_post.py,sha256=bS-CUo3CMsBxkXBEVOoa_GqL-EDgVMW9FHUMyYBneug,4611
+openapi_fal_rest/api/workflows/delete_workflow_workflows_user_id_workflow_name_delete.py,sha256=svJcV5q2e8caxuLJKIld3M7-raQFqSIxPNq58e3AgaA,4590
+openapi_fal_rest/api/workflows/execute_workflow_workflows_user_id_workflow_name_post.py,sha256=kofDDU3TEVQ8Fmua_K2-lk5xh16g6_FNFHQ0KzoFMcM,8743
+openapi_fal_rest/api/workflows/get_workflow_workflows_user_id_workflow_name_get.py,sha256=-E-TELi9Q_-yqobdHAcTHVm-8HithJRUGk7wc1mLA18,4763
+openapi_fal_rest/api/workflows/get_workflows_workflows_get.py,sha256=iJF3lNYp22p8-JbbBMDoHO9iXQB8779lSnH2fNimYP4,5242
+openapi_fal_rest/client.py,sha256=G6BpJg9j7-JsrAUGddYwkzeWRYickBjPdcVgXoPzxuE,2817
+openapi_fal_rest/errors.py,sha256=8mXSxdfSGzxT82srdhYbR0fHfgenxJXaUtMkaGgb6iU,470
+openapi_fal_rest/models/__init__.py,sha256=pGB91qXG3VDxob4DPAh3OMa2fyJFYBxc-jQ-9A4y3Gs,2037
+openapi_fal_rest/models/app_metadata_response_app_metadata.py,sha256=1vx_5cp8V0jyE8iBRIe8TfngaeXMojfEpMCpT6i3qvs,1252
+openapi_fal_rest/models/body_upload_local_file.py,sha256=rOTEbYBXfwZk8TsywZWSPPQQEfJgvsLIufT6A40RJZs,1980
+openapi_fal_rest/models/customer_details.py,sha256=_zvJ_Y2uLowpXqhUnkcpoZpyIB0s8kc5pWSdlBA2_7o,3913
+openapi_fal_rest/models/execute_workflow_workflows_user_id_workflow_name_post_json_body_type_0.py,sha256=84MkDJeOgxwPozZZuP8Fb2dqlF57fmXuRGlrvMKxUew,1418
+openapi_fal_rest/models/execute_workflow_workflows_user_id_workflow_name_post_response_200_type_0.py,sha256=SAGhH0grz3tYISHqsTr-MeiKWqTQsi8gFwSK2ksBoqY,1433
+openapi_fal_rest/models/hash_check.py,sha256=T9R7n4EdadCxbFUZvresZZFPYwDfyJMZVNxY6wIJEE8,1352
+openapi_fal_rest/models/http_validation_error.py,sha256=2nhqlv8RX2qp6VR7hb8-SKtzJWXSZ0J95ThW9J4agJo,2131
+openapi_fal_rest/models/lock_reason.py,sha256=3b_foCV6bZKvsbyic3hM1_qzvJk_9ZD_5mS1GzSawdw,703
+openapi_fal_rest/models/page_workflow_item.py,sha256=5DCUMQ2b8LAH8So6nQJW8mhlxZbedM4ixAJqbf-KZNE,2812
+openapi_fal_rest/models/typed_workflow.py,sha256=haE4Sa16s4iea_VNYtVR7cP3A8Z2ja2KNywYJhc6GmQ,2119
+openapi_fal_rest/models/validation_error.py,sha256=I6tB-HbEOmE0ua27erDX5PX5YUynENv_dgPN3SrwTrQ,2091
+openapi_fal_rest/models/workflow_contents.py,sha256=TIockMwkpjeUjbWtZmtzcC327akwD4XgnTskgdsHQFQ,2703
+openapi_fal_rest/models/workflow_contents_nodes.py,sha256=mMeQO_DlQZQPSwyGKTNC9eBovFVCVQNFbrB60k7tTtU,1695
+openapi_fal_rest/models/workflow_contents_output.py,sha256=2m4ITxXcQxTt8iiY5bos0QQW_uMYOGAR1xAcm1rzrcI,1206
+openapi_fal_rest/models/workflow_detail.py,sha256=lxlPkiOgc9_Dz6c0v3mDJNFXa4CWDkMWw9on-9McojE,4597
+openapi_fal_rest/models/workflow_detail_contents_type_0.py,sha256=DUQg0mDQKczL5g76rJMYvFK_RFcQaQPC1BoTr43eheA,1237
+openapi_fal_rest/models/workflow_item.py,sha256=M_8ojGsBpnKUe3l9yDnciPPgEjmfq1v-Bn9kVHPxT-0,1988
+openapi_fal_rest/models/workflow_node.py,sha256=DZ3i-auxvm2cWFTBE52YSoLOEIVFvLPW9MyzyR91e78,1797
+openapi_fal_rest/models/workflow_node_type.py,sha256=-FzyeY2bxcNmizKbJI8joG7byRiPyAthdBLlioLH8Zw,161
+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
+openapi_fal_rest/py.typed,sha256=8ZJUsxZiuOy1oJeVhsTWQhTG_6pTVHVXk5hJL79ebTk,25
+openapi_fal_rest/types.py,sha256=GLwJwOotUOdfqryo_r0naw55-dh6Ilm4IvxePekSACk,994
+fal/__init__.py,sha256=6SvCuotCb0tuqSWDZSFDjtySktJ5m1QpVIlefumJpvM,1199
+fal/_serialization.py,sha256=l_dZuSX5BT7SogXw1CalYLfT2H3zy3tfq4y6jHuxZqQ,4201
+fal/api.py,sha256=Qack_oYNkvF4qown3P_oKvyvRfTJkhOG7PL1xpa8FUQ,32872
+fal/app.py,sha256=KAIgvBBpvzp6oY8BpH5hFOLDUpG4bjtwlV5jPGj2IE0,12487
+fal/apps.py,sha256=T387WJDtKpKEytu27b2AVqqo0uijKrRT9ymk6FcRiEw,6705
+fal/auth/__init__.py,sha256=ZnR1fxonzDk0UhS3-i33Kq2xOrN-leYXvJ-Ddnj94xc,3594
+fal/auth/auth0.py,sha256=Lb63u99fjZVIpbkAicVL1B5V6iPb2mE04bwHmorXbu4,5542
+fal/auth/local.py,sha256=lZqp4j32l2xFpY8zYvLoIHHyJrNAJDcm5MxgsLpY_pw,1786
+fal/cli.py,sha256=-3P9O3QORA0NolZR9juR8fv59JdJo37_puwUcinzDlY,17299
+fal/console/__init__.py,sha256=ernZ4bzvvliQh5SmrEqQ7lA5eVcbw6Ra2jalKtA7dxg,132
+fal/console/icons.py,sha256=De9MfFaSkO2Lqfne13n3PrYfTXJVIzYZVqYn5BWsdrA,108
+fal/console/ux.py,sha256=4vj1aGA3grRn-ebeMuDLR6u3YjMwUGpqtNgdTG9su5s,485
+fal/env.py,sha256=-fA8x62BbOX3MOuO0maupa-_QJ9PNwr8ogfeG11QUyQ,53
+fal/exceptions/__init__.py,sha256=Q4LCSqIrJ8GFQZWH5BvWL5mDPR0HwYQuIhNvsdiOkEU,938
+fal/exceptions/_base.py,sha256=LeQmx-soL_-s1742WKN18VwTVjUuYP0L0BdQHPJBpM4,460
+fal/exceptions/auth.py,sha256=01Ro7SyGJpwchubdHe14Cl6-Al1jUj16Sy4BvakNWf4,384
+fal/exceptions/handlers.py,sha256=b21a8S13euECArjpgm2N69HsShqLYVqAboIeMoWlWA4,1414
+fal/flags.py,sha256=AATQO65M4C87dGp0j7o6cSQWcr62xE-8DnJYsUjFFbw,942
+fal/logging/__init__.py,sha256=snqprf7-sKw6oAATS_Yxklf-a3XhLg0vIHICPwLp6TM,1583
+fal/logging/isolate.py,sha256=yDW_P4aR-t53IRmvD2Iprufv1Wn-xQXoBbMB2Ufr59s,2122
+fal/logging/style.py,sha256=ckIgHzvF4DShM5kQh8F133X53z_vF46snuDHVmo_h9g,386
+fal/logging/trace.py,sha256=OhzB6d4rQZimBc18WFLqH_9BGfqFFumKKTAGSsmWRMg,1904
+fal/logging/user.py,sha256=A8vbZX9z13TPZEDzvlbvCDDdD0EL1KrCP3qHdrT58-A,632
+fal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fal/rest_client.py,sha256=kGBGmuyHfX1lR910EoKCYPjsyU8MdXawT_cW2q8Sajc,568
+fal/sdk.py,sha256=Z3MQsD8MMQZq_GEC2VjaYChdNafFJtsgdk77-VK6N44,18782
+fal/sync.py,sha256=Ljet584PVFz4r888-0bwV1Kio-tTneF_85TnHvBPvJw,4277
+fal/toolkit/__init__.py,sha256=JDNBT_duflp93geeAzw2kFmGzG5odWnPJEXFLXE2nF4,713
+fal/toolkit/exceptions.py,sha256=--WKKYxUop6WFy_vqAPXK6uH8C-JR98gnNXwhHNCb7E,258
+fal/toolkit/file/__init__.py,sha256=YpUU6YziZV1AMuq12L0EDWToS0sgpHSGWsARbiOEHWk,56
+fal/toolkit/file/file.py,sha256=ku4agJiGXU2gdfZmFrU5mDlVsag834zoeskbo-6ErEU,5926
+fal/toolkit/file/providers/fal.py,sha256=hO59loXzGP4Vg-Q1FFR56nWbbI6BccJRnFsEI6z6EQE,3404
+fal/toolkit/file/providers/gcp.py,sha256=Bq5SJSghXF8YfFnbZ83_mPdrWs2dFhi8ytODp92USgk,1962
+fal/toolkit/file/providers/r2.py,sha256=xJtZfX3cfzJgLXS3F8mHArbrHi0_QBpIMy5M4-tS8H8,2586
+fal/toolkit/file/types.py,sha256=MTIj6Y_ioL4CiMZXMiqx74vlmUifc3SNvcrWAXQfULE,1109
+fal/toolkit/image/__init__.py,sha256=liEq0CqkRqUQ1udnnyGVFBwCXUhR2f6o5ffbtbAlP8o,57
+fal/toolkit/image/image.py,sha256=bF1PzO4cJoFGJFpQYeG0sNaGuw3cC1zmobmbZrxbPFY,4339
+fal/toolkit/mainify.py,sha256=E7gE45nZQZoaJdSlIq0mqajcH-IjcuPBWFmKm5hvhAU,406
+fal/toolkit/optimize.py,sha256=OIhX0T-efRMgUJDpvL0bujdun5SovZgTdKxNOv01b_Y,1394
+fal/toolkit/utils/__init__.py,sha256=b3zVpm50Upx1saXU7RiV9r9in6-Chs4OU9KRjBv7MYI,83
+fal/toolkit/utils/download_utils.py,sha256=bigcLJjLK1OBAGxpYisJ0-5vcQCh0HAPuCykPrcCNd0,15596
+fal/workflows.py,sha256=2xMC4dybiAv05eEua_YpKRAs395YR2UVKvhGS0HZdm8,14155
+fal-0.12.4.dist-info/entry_points.txt,sha256=nE9GBVV3PdBosudFwbIzZQUe_9lfPR6EH8K_FdDASnM,62
+fal-0.12.4.dist-info/METADATA,sha256=lcJ7E_Q3-0l1rtEIb-5tc2MLY4rpzIVSE7UXFh1D780,2937
+fal-0.12.4.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+fal-0.12.4.dist-info/RECORD,,

openapi_fal_rest/__init__.py

@@ -1,4 +1,5 @@
 """ A client library for accessing FastAPI """
+
 from .client import AuthenticatedClient, Client
 
 __all__ = (