fal 0.12.3__py3-none-any.whl → 0.12.5__py3-none-any.whl

fal/auth/__init__.py

@@ -85,10 +85,12 @@ def _fetch_access_token() -> str:
 class UserAccess:
     _access_token: str | None = field(repr=False, default=None)
     _user_info: dict | None = field(repr=False, default=None)
+    _exc: Exception | None = field(repr=False, default=None)
 
     def invalidate(self) -> None:
         self._access_token = None
         self._user_info = None
+        self._exc = None
 
     @property
     def info(self) -> dict:
@@ -99,8 +101,18 @@ class UserAccess:
 
     @property
     def access_token(self) -> str:
+        if self._exc is not None:
+            # We access this several times, so we want to raise the
+            # original exception instead of the newer exceptions we
+            # would get from the effects of the original exception.
+            raise self._exc
+
         if self._access_token is None:
-            self._access_token = _fetch_access_token()
+            try:
+                self._access_token = _fetch_access_token()
+            except Exception as e:
+                self._exc = e
+                raise
 
         return self._access_token
 

fal/auth/auth0.py

@@ -169,6 +169,7 @@ def validate_id_token(token: str):
         algorithms=AUTH0_ALGORITHMS,
         issuer=AUTH0_ISSUER,
         audience=AUTH0_CLIENT_ID,
+        leeway=60,  # 1 minute, to account for clock skew
         options={
             "verify_signature": True,
             "verify_exp": True,
@@ -180,12 +181,11 @@ def validate_id_token(token: str):
 
 
 def verify_access_token_expiration(token: str):
-    from datetime import timedelta
-
     from jwt import decode
 
+    leeway = 60 * 30 * 60  # 30 minutes
     decode(
         token,
-        leeway=timedelta(minutes=-30),  # Mark as expired some time before it expires
+        leeway=-leeway,  # negative to consider expired before actual expiration
         options={"verify_exp": True, "verify_signature": False},
     )

fal/cli.py

@@ -54,6 +54,8 @@ class MainGroup(click.Group):
     _tracer = get_tracer(__name__)
 
     def invoke(self, ctx):
+        from click.exceptions import Abort, ClickException, Exit
+
         execution_info = ExecutionInfo(debug=ctx.params["debug"])
         qualified_name = " ".join([ctx.info_name] + argv[1:])
         invocation_id = execution_info.invocation_id
@@ -68,6 +70,9 @@ class MainGroup(click.Group):
                     command=qualified_name,
                 )
                 return super().invoke(ctx)
+            except (EOFError, KeyboardInterrupt, ClickException, Exit, Abort):
+                # let click's main handle these
+                raise
             except Exception as exception:
                 logger.error(exception)
                 if execution_info.debug:
@@ -571,7 +576,10 @@ def _get_user_id() -> str:
             raise api.FalServerlessError(content["detail"])
     try:
         full_user_id = user_details_response.parsed.user_id
-        user_id = full_user_id.split("|")[1]
+        _provider, _, user_id = full_user_id.partition("|")
+        if not user_id:
+            user_id = full_user_id
+
         return user_id
     except Exception as e:
         raise api.FalServerlessError(f"Could not parse the user data: {e}")

fal/flags.py

@@ -30,3 +30,4 @@ FAL_RUN_HOST = (
 )
 
 FORCE_SETUP = bool_envvar("FAL_FORCE_SETUP")
+DONT_OPEN_LINKS = bool_envvar("FAL_DONT_OPEN_LINKS")

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.3.dist-info → fal-0.12.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 0.12.3
+Version: 0.12.5
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels
 Author-email: hello@fal.ai
@@ -19,7 +19,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)
 Requires-Dist: importlib-metadata (>=4.4) ; python_version < "3.10"
-Requires-Dist: isolate-proto (==0.3.3)
+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)

{fal-0.12.3.dist-info → fal-0.12.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-openapi_fal_rest/__init__.py,sha256=sqsyB55QptrijXTCVFQfIJ6uC__vXez1i5KNvYplk5w,151
+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
@@ -7,27 +7,48 @@ openapi_fal_rest/api/billing/get_user_details.py,sha256=2HQHRUQj8QwqSKgiV_USBdXC
 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=u2YVZnZwu9YqDPasBnh9GLVIkEJj4PFCThf97Pblx4o,601
-openapi_fal_rest/models/app_metadata_response_app_metadata.py,sha256=swJMfWvbjlMF8dmv-KEqcR9If0UjsRogwj9UqBBlkpc,1251
+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=XQBaO-A5DI54nCau5ZIR0jhCAmsBJKrtDgApuu6PFrU,3912
+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=4xaUIOliefW-5jz_p-JT2LO7-V0wKWaniHGtjPBQfvQ,993
+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=4W_9svpsmohRPhBi4yjx9rAPaUeBTHaJvSRpdRzXA5s,3133
-fal/auth/auth0.py,sha256=hQ3ZTqqsgpL62GsNB9KvjE8k_2hxXMIJb5TNpRmaiYs,5485
+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=nLk4LJsGvLicA_iW0T1ldYb_igMwYOdC2fQxUsdWCRQ,17236
+fal/cli.py,sha256=mvYl6-wlrofY9wFzdjAO31ut2RVvwnXf6aIqFkxNWmQ,17526
 fal/console/__init__.py,sha256=ernZ4bzvvliQh5SmrEqQ7lA5eVcbw6Ra2jalKtA7dxg,132
 fal/console/icons.py,sha256=De9MfFaSkO2Lqfne13n3PrYfTXJVIzYZVqYn5BWsdrA,108
 fal/console/ux.py,sha256=4vj1aGA3grRn-ebeMuDLR6u3YjMwUGpqtNgdTG9su5s,485
@@ -36,7 +57,7 @@ fal/exceptions/__init__.py,sha256=Q4LCSqIrJ8GFQZWH5BvWL5mDPR0HwYQuIhNvsdiOkEU,93
 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=8OaKkJg_-UvtyRbZf-rW5ZTW3B1xQpzzXnLRNFB7grA,889
+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
@@ -60,7 +81,8 @@ 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-0.12.3.dist-info/METADATA,sha256=0eR9dtKw9ZU7y2Dxjx9NtXp--hmw7XG24LuTylD5BlE,2930
-fal-0.12.3.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-fal-0.12.3.dist-info/entry_points.txt,sha256=nE9GBVV3PdBosudFwbIzZQUe_9lfPR6EH8K_FdDASnM,62
-fal-0.12.3.dist-info/RECORD,,
+fal/workflows.py,sha256=2xMC4dybiAv05eEua_YpKRAs395YR2UVKvhGS0HZdm8,14155
+fal-0.12.5.dist-info/entry_points.txt,sha256=nE9GBVV3PdBosudFwbIzZQUe_9lfPR6EH8K_FdDASnM,62
+fal-0.12.5.dist-info/METADATA,sha256=CG9k8-tOXQ9rvTFC4mLc44pj7FDNLpTpyYwEeBp5n4w,2937
+fal-0.12.5.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+fal-0.12.5.dist-info/RECORD,,

openapi_fal_rest/__init__.py

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