fal 0.12.3__tar.gz → 0.12.5__tar.gz

{fal-0.12.3 → fal-0.12.5}/PKG-INFO

@@ -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 → fal-0.12.5}/openapi-fal-rest/openapi_fal_rest/__init__.py

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

fal-0.12.5/openapi-fal-rest/openapi_fal_rest/api/workflows/create_or_update_workflow_workflows_post.py

@@ -0,0 +1,172 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.http_validation_error import HTTPValidationError
+from ...models.typed_workflow import TypedWorkflow
+from ...models.workflow_detail import WorkflowDetail
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: TypedWorkflow,
+) -> Dict[str, Any]:
+    url = "{}/workflows/".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "follow_redirects": client.follow_redirects,
+        "json": json_json_body,
+    }
+
+
+def _parse_response(
+    *, client: Client, response: httpx.Response
+) -> Optional[Union[HTTPValidationError, WorkflowDetail]]:
+    if response.status_code == HTTPStatus.CREATED:
+        response_201 = WorkflowDetail.from_dict(response.json())
+
+        return response_201
+    if response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY:
+        response_422 = HTTPValidationError.from_dict(response.json())
+
+        return response_422
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Client, response: httpx.Response
+) -> Response[Union[HTTPValidationError, WorkflowDetail]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: TypedWorkflow,
+) -> Response[Union[HTTPValidationError, WorkflowDetail]]:
+    """Create Or Update Workflow
+
+    Args:
+        json_body (TypedWorkflow):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, WorkflowDetail]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    json_body: TypedWorkflow,
+) -> Optional[Union[HTTPValidationError, WorkflowDetail]]:
+    """Create Or Update Workflow
+
+    Args:
+        json_body (TypedWorkflow):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, WorkflowDetail]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: TypedWorkflow,
+) -> Response[Union[HTTPValidationError, WorkflowDetail]]:
+    """Create Or Update Workflow
+
+    Args:
+        json_body (TypedWorkflow):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, WorkflowDetail]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    json_body: TypedWorkflow,
+) -> Optional[Union[HTTPValidationError, WorkflowDetail]]:
+    """Create Or Update Workflow
+
+    Args:
+        json_body (TypedWorkflow):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, WorkflowDetail]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

fal-0.12.5/openapi-fal-rest/openapi_fal_rest/api/workflows/delete_workflow_workflows_user_id_workflow_name_delete.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.http_validation_error import HTTPValidationError
+from ...types import Response
+
+
+def _get_kwargs(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/workflows/{user_id}/{workflow_name}".format(client.base_url, user_id=user_id, workflow_name=workflow_name)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "delete",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "follow_redirects": client.follow_redirects,
+    }
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[Union[Any, HTTPValidationError]]:
+    if response.status_code == HTTPStatus.NO_CONTENT:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY:
+        response_422 = HTTPValidationError.from_dict(response.json())
+
+        return response_422
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[Union[Any, HTTPValidationError]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+) -> Response[Union[Any, HTTPValidationError]]:
+    """Delete Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, HTTPValidationError]]
+    """
+
+    kwargs = _get_kwargs(
+        user_id=user_id,
+        workflow_name=workflow_name,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+) -> Optional[Union[Any, HTTPValidationError]]:
+    """Delete Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, HTTPValidationError]
+    """
+
+    return sync_detailed(
+        user_id=user_id,
+        workflow_name=workflow_name,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+) -> Response[Union[Any, HTTPValidationError]]:
+    """Delete Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, HTTPValidationError]]
+    """
+
+    kwargs = _get_kwargs(
+        user_id=user_id,
+        workflow_name=workflow_name,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+) -> Optional[Union[Any, HTTPValidationError]]:
+    """Delete Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, HTTPValidationError]
+    """
+
+    return (
+        await asyncio_detailed(
+            user_id=user_id,
+            workflow_name=workflow_name,
+            client=client,
+        )
+    ).parsed

fal-0.12.5/openapi-fal-rest/openapi_fal_rest/api/workflows/execute_workflow_workflows_user_id_workflow_name_post.py

@@ -0,0 +1,268 @@
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.execute_workflow_workflows_user_id_workflow_name_post_json_body_type_0 import (
+    ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0,
+)
+from ...models.execute_workflow_workflows_user_id_workflow_name_post_response_200_type_0 import (
+    ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0,
+)
+from ...models.http_validation_error import HTTPValidationError
+from ...types import Response
+
+
+def _get_kwargs(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+    json_body: Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0", List[Any], bool, float, int, str],
+) -> Dict[str, Any]:
+    url = "{}/workflows/{user_id}/{workflow_name}".format(client.base_url, user_id=user_id, workflow_name=workflow_name)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body: Union[Dict[str, Any], List[Any], bool, float, int, str]
+
+    if isinstance(json_body, ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0):
+        json_json_body = json_body.to_dict()
+
+    elif isinstance(json_body, list):
+        json_json_body = json_body
+
+    else:
+        json_json_body = json_body
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "follow_redirects": client.follow_redirects,
+        "json": json_json_body,
+    }
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[
+    Union[
+        HTTPValidationError,
+        Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str],
+    ]
+]:
+    if response.status_code == HTTPStatus.OK:
+
+        def _parse_response_200(
+            data: object,
+        ) -> Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str]:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                response_200_type_0 = ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0.from_dict(data)
+
+                return response_200_type_0
+            except:  # noqa: E722
+                pass
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                response_200_type_1 = cast(List[Any], data)
+
+                return response_200_type_1
+            except:  # noqa: E722
+                pass
+            return cast(
+                Union[
+                    "ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str
+                ],
+                data,
+            )
+
+        response_200 = _parse_response_200(response.json())
+
+        return response_200
+    if response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY:
+        response_422 = HTTPValidationError.from_dict(response.json())
+
+        return response_422
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[
+    Union[
+        HTTPValidationError,
+        Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str],
+    ]
+]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+    json_body: Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0", List[Any], bool, float, int, str],
+) -> Response[
+    Union[
+        HTTPValidationError,
+        Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str],
+    ]
+]:
+    """Execute Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+        json_body (Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0', List[Any],
+            bool, float, int, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0', List[Any], bool, float, int, str]]]
+    """
+
+    kwargs = _get_kwargs(
+        user_id=user_id,
+        workflow_name=workflow_name,
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+    json_body: Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0", List[Any], bool, float, int, str],
+) -> Optional[
+    Union[
+        HTTPValidationError,
+        Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str],
+    ]
+]:
+    """Execute Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+        json_body (Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0', List[Any],
+            bool, float, int, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0', List[Any], bool, float, int, str]]
+    """
+
+    return sync_detailed(
+        user_id=user_id,
+        workflow_name=workflow_name,
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+    json_body: Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0", List[Any], bool, float, int, str],
+) -> Response[
+    Union[
+        HTTPValidationError,
+        Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str],
+    ]
+]:
+    """Execute Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+        json_body (Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0', List[Any],
+            bool, float, int, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0', List[Any], bool, float, int, str]]]
+    """
+
+    kwargs = _get_kwargs(
+        user_id=user_id,
+        workflow_name=workflow_name,
+        client=client,
+        json_body=json_body,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+    json_body: Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0", List[Any], bool, float, int, str],
+) -> Optional[
+    Union[
+        HTTPValidationError,
+        Union["ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0", List[Any], bool, float, int, str],
+    ]
+]:
+    """Execute Workflow
+
+    Args:
+        user_id (str):
+        workflow_name (str):
+        json_body (Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0', List[Any],
+            bool, float, int, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, Union['ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0', List[Any], bool, float, int, str]]
+    """
+
+    return (
+        await asyncio_detailed(
+            user_id=user_id,
+            workflow_name=workflow_name,
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed