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

openapi_fal_rest/api/workflows/get_workflow_workflows_user_id_workflow_name_get.py

@@ -0,0 +1,181 @@
+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.workflow_detail import WorkflowDetail
+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": "get",
+        "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[HTTPValidationError, WorkflowDetail]]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = WorkflowDetail.from_dict(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, 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(
+    user_id: str,
+    workflow_name: str,
+    *,
+    client: Client,
+) -> Response[Union[HTTPValidationError, WorkflowDetail]]:
+    """Get 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[HTTPValidationError, WorkflowDetail]]
+    """
+
+    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[HTTPValidationError, WorkflowDetail]]:
+    """Get 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[HTTPValidationError, WorkflowDetail]
+    """
+
+    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[HTTPValidationError, WorkflowDetail]]:
+    """Get 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[HTTPValidationError, WorkflowDetail]]
+    """
+
+    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[HTTPValidationError, WorkflowDetail]]:
+    """Get 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[HTTPValidationError, WorkflowDetail]
+    """
+
+    return (
+        await asyncio_detailed(
+            user_id=user_id,
+            workflow_name=workflow_name,
+            client=client,
+        )
+    ).parsed

openapi_fal_rest/api/workflows/get_workflows_workflows_get.py

@@ -0,0 +1,189 @@
+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.page_workflow_item import PageWorkflowItem
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = 1,
+    size: Union[Unset, None, int] = 50,
+) -> Dict[str, Any]:
+    url = "{}/workflows/".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    params["page"] = page
+
+    params["size"] = size
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    return {
+        "method": "get",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "follow_redirects": client.follow_redirects,
+        "params": params,
+    }
+
+
+def _parse_response(
+    *, client: Client, response: httpx.Response
+) -> Optional[Union[HTTPValidationError, PageWorkflowItem]]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = PageWorkflowItem.from_dict(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, PageWorkflowItem]]:
+    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,
+    page: Union[Unset, None, int] = 1,
+    size: Union[Unset, None, int] = 50,
+) -> Response[Union[HTTPValidationError, PageWorkflowItem]]:
+    """Get Workflows
+
+    Args:
+        page (Union[Unset, None, int]):  Default: 1.
+        size (Union[Unset, None, int]):  Default: 50.
+
+    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, PageWorkflowItem]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        page=page,
+        size=size,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = 1,
+    size: Union[Unset, None, int] = 50,
+) -> Optional[Union[HTTPValidationError, PageWorkflowItem]]:
+    """Get Workflows
+
+    Args:
+        page (Union[Unset, None, int]):  Default: 1.
+        size (Union[Unset, None, int]):  Default: 50.
+
+    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, PageWorkflowItem]
+    """
+
+    return sync_detailed(
+        client=client,
+        page=page,
+        size=size,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = 1,
+    size: Union[Unset, None, int] = 50,
+) -> Response[Union[HTTPValidationError, PageWorkflowItem]]:
+    """Get Workflows
+
+    Args:
+        page (Union[Unset, None, int]):  Default: 1.
+        size (Union[Unset, None, int]):  Default: 50.
+
+    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, PageWorkflowItem]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        page=page,
+        size=size,
+    )
+
+    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,
+    page: Union[Unset, None, int] = 1,
+    size: Union[Unset, None, int] = 50,
+) -> Optional[Union[HTTPValidationError, PageWorkflowItem]]:
+    """Get Workflows
+
+    Args:
+        page (Union[Unset, None, int]):  Default: 1.
+        size (Union[Unset, None, int]):  Default: 50.
+
+    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, PageWorkflowItem]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            page=page,
+            size=size,
+        )
+    ).parsed

openapi_fal_rest/models/__init__.py

@@ -3,17 +3,51 @@
 from .app_metadata_response_app_metadata import AppMetadataResponseAppMetadata
 from .body_upload_local_file import BodyUploadLocalFile
 from .customer_details import CustomerDetails
+from .execute_workflow_workflows_user_id_workflow_name_post_json_body_type_0 import (
+    ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0,
+)
+from .execute_workflow_workflows_user_id_workflow_name_post_response_200_type_0 import (
+    ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0,
+)
 from .hash_check import HashCheck
 from .http_validation_error import HTTPValidationError
 from .lock_reason import LockReason
+from .page_workflow_item import PageWorkflowItem
+from .typed_workflow import TypedWorkflow
 from .validation_error import ValidationError
+from .workflow_contents import WorkflowContents
+from .workflow_contents_nodes import WorkflowContentsNodes
+from .workflow_contents_output import WorkflowContentsOutput
+from .workflow_detail import WorkflowDetail
+from .workflow_detail_contents_type_0 import WorkflowDetailContentsType0
+from .workflow_item import WorkflowItem
+from .workflow_node import WorkflowNode
+from .workflow_node_type import WorkflowNodeType
+from .workflow_schema import WorkflowSchema
+from .workflow_schema_input import WorkflowSchemaInput
+from .workflow_schema_output import WorkflowSchemaOutput
 
 __all__ = (
     "AppMetadataResponseAppMetadata",
     "BodyUploadLocalFile",
     "CustomerDetails",
+    "ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0",
+    "ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0",
     "HashCheck",
     "HTTPValidationError",
     "LockReason",
+    "PageWorkflowItem",
+    "TypedWorkflow",
     "ValidationError",
+    "WorkflowContents",
+    "WorkflowContentsNodes",
+    "WorkflowContentsOutput",
+    "WorkflowDetail",
+    "WorkflowDetailContentsType0",
+    "WorkflowItem",
+    "WorkflowNode",
+    "WorkflowNodeType",
+    "WorkflowSchema",
+    "WorkflowSchemaInput",
+    "WorkflowSchemaOutput",
 )

openapi_fal_rest/models/app_metadata_response_app_metadata.py

@@ -12,6 +12,7 @@ class AppMetadataResponseAppMetadata:
     additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
+
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})

openapi_fal_rest/models/customer_details.py

@@ -15,32 +15,33 @@ class CustomerDetails:
         user_id (str):
         soft_monthly_budget (Union[Unset, int]):
         hard_monthly_budget (Union[Unset, int]):
+        lock_reason (Union[Unset, None, LockReason]): An enumeration.
         current_balance (Union[Unset, int]):
         is_paying (Union[Unset, bool]):
         is_locked (Union[Unset, bool]):
-        lock_reason (Union[Unset, None, LockReason]): An enumeration.
     """
 
     user_id: str
     soft_monthly_budget: Union[Unset, int] = UNSET
     hard_monthly_budget: Union[Unset, int] = UNSET
+    lock_reason: Union[Unset, None, LockReason] = UNSET
     current_balance: Union[Unset, int] = 0
     is_paying: Union[Unset, bool] = False
     is_locked: Union[Unset, bool] = False
-    lock_reason: Union[Unset, None, LockReason] = UNSET
     additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
         user_id = self.user_id
         soft_monthly_budget = self.soft_monthly_budget
         hard_monthly_budget = self.hard_monthly_budget
-        current_balance = self.current_balance
-        is_paying = self.is_paying
-        is_locked = self.is_locked
         lock_reason: Union[Unset, None, str] = UNSET
         if not isinstance(self.lock_reason, Unset):
             lock_reason = self.lock_reason.value if self.lock_reason else None
 
+        current_balance = self.current_balance
+        is_paying = self.is_paying
+        is_locked = self.is_locked
+
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -52,14 +53,14 @@ class CustomerDetails:
             field_dict["soft_monthly_budget"] = soft_monthly_budget
         if hard_monthly_budget is not UNSET:
             field_dict["hard_monthly_budget"] = hard_monthly_budget
+        if lock_reason is not UNSET:
+            field_dict["lock_reason"] = lock_reason
         if current_balance is not UNSET:
             field_dict["current_balance"] = current_balance
         if is_paying is not UNSET:
             field_dict["is_paying"] = is_paying
         if is_locked is not UNSET:
             field_dict["is_locked"] = is_locked
-        if lock_reason is not UNSET:
-            field_dict["lock_reason"] = lock_reason
 
         return field_dict
 
@@ -72,12 +73,6 @@ class CustomerDetails:
 
         hard_monthly_budget = d.pop("hard_monthly_budget", UNSET)
 
-        current_balance = d.pop("current_balance", UNSET)
-
-        is_paying = d.pop("is_paying", UNSET)
-
-        is_locked = d.pop("is_locked", UNSET)
-
         _lock_reason = d.pop("lock_reason", UNSET)
         lock_reason: Union[Unset, None, LockReason]
         if _lock_reason is None:
@@ -87,14 +82,20 @@ class CustomerDetails:
         else:
             lock_reason = LockReason(_lock_reason)
 
+        current_balance = d.pop("current_balance", UNSET)
+
+        is_paying = d.pop("is_paying", UNSET)
+
+        is_locked = d.pop("is_locked", UNSET)
+
         customer_details = cls(
             user_id=user_id,
             soft_monthly_budget=soft_monthly_budget,
             hard_monthly_budget=hard_monthly_budget,
+            lock_reason=lock_reason,
             current_balance=current_balance,
             is_paying=is_paying,
             is_locked=is_locked,
-            lock_reason=lock_reason,
         )
 
         customer_details.additional_properties = d

openapi_fal_rest/models/execute_workflow_workflows_user_id_workflow_name_post_json_body_type_0.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0")
+
+
+@attr.s(auto_attribs=True)
+class ExecuteWorkflowWorkflowsUserIdWorkflowNamePostJsonBodyType0:
+    """ """
+
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        execute_workflow_workflows_user_id_workflow_name_post_json_body_type_0 = cls()
+
+        execute_workflow_workflows_user_id_workflow_name_post_json_body_type_0.additional_properties = d
+        return execute_workflow_workflows_user_id_workflow_name_post_json_body_type_0
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

openapi_fal_rest/models/execute_workflow_workflows_user_id_workflow_name_post_response_200_type_0.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0")
+
+
+@attr.s(auto_attribs=True)
+class ExecuteWorkflowWorkflowsUserIdWorkflowNamePostResponse200Type0:
+    """ """
+
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        execute_workflow_workflows_user_id_workflow_name_post_response_200_type_0 = cls()
+
+        execute_workflow_workflows_user_id_workflow_name_post_response_200_type_0.additional_properties = d
+        return execute_workflow_workflows_user_id_workflow_name_post_response_200_type_0
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties