--------------------------------------------------------------------------------
/beanhub_cli/forms/app/templates/layout.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
27 | {% include "flash_messages.html" %}
28 | {% block content %}{% endblock %}
29 | {% include "footer.html" %}
30 |
31 |
32 |
33 |
34 |
35 | {% block js %}{% endblock %}
36 |
37 |
--------------------------------------------------------------------------------
/beanhub_cli/forms/cli.py:
--------------------------------------------------------------------------------
1 | from ..aliase import AliasedGroup
2 | from ..cli import cli as root_cli
3 |
4 |
5 | @root_cli.group(
6 | name="form",
7 | help="Validating BeanHub Forms and running a simple web app.",
8 | cls=AliasedGroup,
9 | )
10 | def cli():
11 | pass
12 |
--------------------------------------------------------------------------------
/beanhub_cli/inbox/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LaunchPlatform/beanhub-cli/f9a97e92bcbdb7e3ff7fc51bbcee9657503edf34/beanhub_cli/inbox/__init__.py
--------------------------------------------------------------------------------
/beanhub_cli/inbox/cli.py:
--------------------------------------------------------------------------------
1 | from ..aliase import AliasedGroup
2 | from ..cli import cli as root_cli
3 |
4 |
5 | @root_cli.group(
6 | name="inbox",
7 | help="BeanHub inbox features, such as dump (login required) or extract.",
8 | cls=AliasedGroup,
9 | )
10 | def cli():
11 | pass
12 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/__init__.py:
--------------------------------------------------------------------------------
1 | """A client library for accessing BeanHub Internal API"""
2 | from .client import AuthenticatedClient
3 | from .client import Client
4 |
5 | __all__ = (
6 | "AuthenticatedClient",
7 | "Client",
8 | )
9 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/api/__init__.py:
--------------------------------------------------------------------------------
1 | """Contains methods for accessing the API"""
2 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/api/auth/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LaunchPlatform/beanhub-cli/f9a97e92bcbdb7e3ff7fc51bbcee9657503edf34/beanhub_cli/internal_api/api/auth/__init__.py
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/api/connect/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LaunchPlatform/beanhub-cli/f9a97e92bcbdb7e3ff7fc51bbcee9657503edf34/beanhub_cli/internal_api/api/connect/__init__.py
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/api/inbox/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LaunchPlatform/beanhub-cli/f9a97e92bcbdb7e3ff7fc51bbcee9657503edf34/beanhub_cli/internal_api/api/inbox/__init__.py
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/api/repo/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LaunchPlatform/beanhub-cli/f9a97e92bcbdb7e3ff7fc51bbcee9657503edf34/beanhub_cli/internal_api/api/repo/__init__.py
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/errors.py:
--------------------------------------------------------------------------------
1 | """Contains shared errors types that can be raised from API functions"""
2 |
3 |
4 | class UnexpectedStatus(Exception):
5 | """Raised by api functions when the response status an undocumented status and Client.raise_on_unexpected_status is True"""
6 |
7 | def __init__(self, status_code: int, content: bytes):
8 | self.status_code = status_code
9 | self.content = content
10 |
11 | super().__init__(
12 | f"Unexpected status code: {status_code}\n\nResponse content:\n{content.decode(errors='ignore')}"
13 | )
14 |
15 |
16 | __all__ = ["UnexpectedStatus"]
17 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/__init__.py:
--------------------------------------------------------------------------------
1 | """Contains all the data models used in inputs/outputs"""
2 | from .auth_session_not_ready_response import AuthSessionNotReadyResponse
3 | from .auth_session_poll_response import AuthSessionPollResponse
4 | from .auth_session_request import AuthSessionRequest
5 | from .auth_session_response import AuthSessionResponse
6 | from .create_dump_request_request import CreateDumpRequestRequest
7 | from .create_dump_request_response import CreateDumpRequestResponse
8 | from .create_inbox_dump_request import CreateInboxDumpRequest
9 | from .create_inbox_dump_request_response import CreateInboxDumpRequestResponse
10 | from .create_sync_batch_response import CreateSyncBatchResponse
11 | from .dump_request_state import DumpRequestState
12 | from .generic_error import GenericError
13 | from .get_dump_request_response import GetDumpRequestResponse
14 | from .get_inbox_dump_request_response import GetInboxDumpRequestResponse
15 | from .get_inbox_email_response import GetInboxEmailResponse
16 | from .get_sync_batch_response import GetSyncBatchResponse
17 | from .http_validation_error import HTTPValidationError
18 | from .inbox_dump_request_state import InboxDumpRequestState
19 | from .inbox_email import InboxEmail
20 | from .inbox_email_headers import InboxEmailHeaders
21 | from .item_data import ItemData
22 | from .list_repositories_response import ListRepositoriesResponse
23 | from .plaid_item_sync_state import PlaidItemSyncState
24 | from .repository import Repository
25 | from .repository_type import RepositoryType
26 | from .sync_data import SyncData
27 | from .validation_error import ValidationError
28 |
29 | __all__ = (
30 | "AuthSessionNotReadyResponse",
31 | "AuthSessionPollResponse",
32 | "AuthSessionRequest",
33 | "AuthSessionResponse",
34 | "CreateDumpRequestRequest",
35 | "CreateDumpRequestResponse",
36 | "CreateInboxDumpRequest",
37 | "CreateInboxDumpRequestResponse",
38 | "CreateSyncBatchResponse",
39 | "DumpRequestState",
40 | "GenericError",
41 | "GetDumpRequestResponse",
42 | "GetInboxDumpRequestResponse",
43 | "GetInboxEmailResponse",
44 | "GetSyncBatchResponse",
45 | "HTTPValidationError",
46 | "InboxDumpRequestState",
47 | "InboxEmail",
48 | "InboxEmailHeaders",
49 | "ItemData",
50 | "ListRepositoriesResponse",
51 | "PlaidItemSyncState",
52 | "Repository",
53 | "RepositoryType",
54 | "SyncData",
55 | "ValidationError",
56 | )
57 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/auth_session_not_ready_response.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 |
4 | from attrs import define as _attrs_define
5 | from attrs import field as _attrs_field
6 |
7 | T = TypeVar("T", bound="AuthSessionNotReadyResponse")
8 |
9 |
10 | @_attrs_define
11 | class AuthSessionNotReadyResponse:
12 | """
13 | Attributes:
14 | code (str):
15 | message (str):
16 | """
17 |
18 | code: str
19 | message: str
20 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
21 |
22 | def to_dict(self) -> dict[str, Any]:
23 | code = self.code
24 |
25 | message = self.message
26 |
27 | field_dict: dict[str, Any] = {}
28 | field_dict.update(self.additional_properties)
29 | field_dict.update(
30 | {
31 | "code": code,
32 | "message": message,
33 | }
34 | )
35 |
36 | return field_dict
37 |
38 | @classmethod
39 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
40 | d = src_dict.copy()
41 | code = d.pop("code")
42 |
43 | message = d.pop("message")
44 |
45 | auth_session_not_ready_response = cls(
46 | code=code,
47 | message=message,
48 | )
49 |
50 | auth_session_not_ready_response.additional_properties = d
51 | return auth_session_not_ready_response
52 |
53 | @property
54 | def additional_keys(self) -> list[str]:
55 | return list(self.additional_properties.keys())
56 |
57 | def __getitem__(self, key: str) -> Any:
58 | return self.additional_properties[key]
59 |
60 | def __setitem__(self, key: str, value: Any) -> None:
61 | self.additional_properties[key] = value
62 |
63 | def __delitem__(self, key: str) -> None:
64 | del self.additional_properties[key]
65 |
66 | def __contains__(self, key: str) -> bool:
67 | return key in self.additional_properties
68 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/auth_session_request.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 |
4 | from attrs import define as _attrs_define
5 | from attrs import field as _attrs_field
6 |
7 | T = TypeVar("T", bound="AuthSessionRequest")
8 |
9 |
10 | @_attrs_define
11 | class AuthSessionRequest:
12 | """
13 | Attributes:
14 | hostname (str):
15 | """
16 |
17 | hostname: str
18 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
19 |
20 | def to_dict(self) -> dict[str, Any]:
21 | hostname = self.hostname
22 |
23 | field_dict: dict[str, Any] = {}
24 | field_dict.update(self.additional_properties)
25 | field_dict.update(
26 | {
27 | "hostname": hostname,
28 | }
29 | )
30 |
31 | return field_dict
32 |
33 | @classmethod
34 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
35 | d = src_dict.copy()
36 | hostname = d.pop("hostname")
37 |
38 | auth_session_request = cls(
39 | hostname=hostname,
40 | )
41 |
42 | auth_session_request.additional_properties = d
43 | return auth_session_request
44 |
45 | @property
46 | def additional_keys(self) -> list[str]:
47 | return list(self.additional_properties.keys())
48 |
49 | def __getitem__(self, key: str) -> Any:
50 | return self.additional_properties[key]
51 |
52 | def __setitem__(self, key: str, value: Any) -> None:
53 | self.additional_properties[key] = value
54 |
55 | def __delitem__(self, key: str) -> None:
56 | del self.additional_properties[key]
57 |
58 | def __contains__(self, key: str) -> bool:
59 | return key in self.additional_properties
60 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/create_dump_request_request.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 | from typing import Union
4 |
5 | from attrs import define as _attrs_define
6 | from attrs import field as _attrs_field
7 |
8 | from ..types import UNSET
9 | from ..types import Unset
10 |
11 | T = TypeVar("T", bound="CreateDumpRequestRequest")
12 |
13 |
14 | @_attrs_define
15 | class CreateDumpRequestRequest:
16 | """
17 | Attributes:
18 | public_key (str):
19 | output_accounts (Union[Unset, bool]): Default: False.
20 | """
21 |
22 | public_key: str
23 | output_accounts: Union[Unset, bool] = False
24 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
25 |
26 | def to_dict(self) -> dict[str, Any]:
27 | public_key = self.public_key
28 |
29 | output_accounts = self.output_accounts
30 |
31 | field_dict: dict[str, Any] = {}
32 | field_dict.update(self.additional_properties)
33 | field_dict.update(
34 | {
35 | "public_key": public_key,
36 | }
37 | )
38 | if output_accounts is not UNSET:
39 | field_dict["output_accounts"] = output_accounts
40 |
41 | return field_dict
42 |
43 | @classmethod
44 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
45 | d = src_dict.copy()
46 | public_key = d.pop("public_key")
47 |
48 | output_accounts = d.pop("output_accounts", UNSET)
49 |
50 | create_dump_request_request = cls(
51 | public_key=public_key,
52 | output_accounts=output_accounts,
53 | )
54 |
55 | create_dump_request_request.additional_properties = d
56 | return create_dump_request_request
57 |
58 | @property
59 | def additional_keys(self) -> list[str]:
60 | return list(self.additional_properties.keys())
61 |
62 | def __getitem__(self, key: str) -> Any:
63 | return self.additional_properties[key]
64 |
65 | def __setitem__(self, key: str, value: Any) -> None:
66 | self.additional_properties[key] = value
67 |
68 | def __delitem__(self, key: str) -> None:
69 | del self.additional_properties[key]
70 |
71 | def __contains__(self, key: str) -> bool:
72 | return key in self.additional_properties
73 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/create_dump_request_response.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 | from uuid import UUID
4 |
5 | from attrs import define as _attrs_define
6 | from attrs import field as _attrs_field
7 |
8 | T = TypeVar("T", bound="CreateDumpRequestResponse")
9 |
10 |
11 | @_attrs_define
12 | class CreateDumpRequestResponse:
13 | """
14 | Attributes:
15 | id (UUID):
16 | """
17 |
18 | id: UUID
19 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
20 |
21 | def to_dict(self) -> dict[str, Any]:
22 | id = str(self.id)
23 |
24 | field_dict: dict[str, Any] = {}
25 | field_dict.update(self.additional_properties)
26 | field_dict.update(
27 | {
28 | "id": id,
29 | }
30 | )
31 |
32 | return field_dict
33 |
34 | @classmethod
35 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
36 | d = src_dict.copy()
37 | id = UUID(d.pop("id"))
38 |
39 | create_dump_request_response = cls(
40 | id=id,
41 | )
42 |
43 | create_dump_request_response.additional_properties = d
44 | return create_dump_request_response
45 |
46 | @property
47 | def additional_keys(self) -> list[str]:
48 | return list(self.additional_properties.keys())
49 |
50 | def __getitem__(self, key: str) -> Any:
51 | return self.additional_properties[key]
52 |
53 | def __setitem__(self, key: str, value: Any) -> None:
54 | self.additional_properties[key] = value
55 |
56 | def __delitem__(self, key: str) -> None:
57 | del self.additional_properties[key]
58 |
59 | def __contains__(self, key: str) -> bool:
60 | return key in self.additional_properties
61 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/create_inbox_dump_request.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import cast
3 | from typing import TypeVar
4 |
5 | from attrs import define as _attrs_define
6 | from attrs import field as _attrs_field
7 |
8 | T = TypeVar("T", bound="CreateInboxDumpRequest")
9 |
10 |
11 | @_attrs_define
12 | class CreateInboxDumpRequest:
13 | """
14 | Attributes:
15 | public_key (str):
16 | email_ids (list[str]):
17 | """
18 |
19 | public_key: str
20 | email_ids: list[str]
21 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
22 |
23 | def to_dict(self) -> dict[str, Any]:
24 | public_key = self.public_key
25 |
26 | email_ids = self.email_ids
27 |
28 | field_dict: dict[str, Any] = {}
29 | field_dict.update(self.additional_properties)
30 | field_dict.update(
31 | {
32 | "public_key": public_key,
33 | "email_ids": email_ids,
34 | }
35 | )
36 |
37 | return field_dict
38 |
39 | @classmethod
40 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
41 | d = src_dict.copy()
42 | public_key = d.pop("public_key")
43 |
44 | email_ids = cast(list[str], d.pop("email_ids"))
45 |
46 | create_inbox_dump_request = cls(
47 | public_key=public_key,
48 | email_ids=email_ids,
49 | )
50 |
51 | create_inbox_dump_request.additional_properties = d
52 | return create_inbox_dump_request
53 |
54 | @property
55 | def additional_keys(self) -> list[str]:
56 | return list(self.additional_properties.keys())
57 |
58 | def __getitem__(self, key: str) -> Any:
59 | return self.additional_properties[key]
60 |
61 | def __setitem__(self, key: str, value: Any) -> None:
62 | self.additional_properties[key] = value
63 |
64 | def __delitem__(self, key: str) -> None:
65 | del self.additional_properties[key]
66 |
67 | def __contains__(self, key: str) -> bool:
68 | return key in self.additional_properties
69 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/create_inbox_dump_request_response.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 | from uuid import UUID
4 |
5 | from attrs import define as _attrs_define
6 | from attrs import field as _attrs_field
7 |
8 | T = TypeVar("T", bound="CreateInboxDumpRequestResponse")
9 |
10 |
11 | @_attrs_define
12 | class CreateInboxDumpRequestResponse:
13 | """
14 | Attributes:
15 | id (UUID):
16 | """
17 |
18 | id: UUID
19 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
20 |
21 | def to_dict(self) -> dict[str, Any]:
22 | id = str(self.id)
23 |
24 | field_dict: dict[str, Any] = {}
25 | field_dict.update(self.additional_properties)
26 | field_dict.update(
27 | {
28 | "id": id,
29 | }
30 | )
31 |
32 | return field_dict
33 |
34 | @classmethod
35 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
36 | d = src_dict.copy()
37 | id = UUID(d.pop("id"))
38 |
39 | create_inbox_dump_request_response = cls(
40 | id=id,
41 | )
42 |
43 | create_inbox_dump_request_response.additional_properties = d
44 | return create_inbox_dump_request_response
45 |
46 | @property
47 | def additional_keys(self) -> list[str]:
48 | return list(self.additional_properties.keys())
49 |
50 | def __getitem__(self, key: str) -> Any:
51 | return self.additional_properties[key]
52 |
53 | def __setitem__(self, key: str, value: Any) -> None:
54 | self.additional_properties[key] = value
55 |
56 | def __delitem__(self, key: str) -> None:
57 | del self.additional_properties[key]
58 |
59 | def __contains__(self, key: str) -> bool:
60 | return key in self.additional_properties
61 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/create_sync_batch_response.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 | from uuid import UUID
4 |
5 | from attrs import define as _attrs_define
6 | from attrs import field as _attrs_field
7 |
8 | T = TypeVar("T", bound="CreateSyncBatchResponse")
9 |
10 |
11 | @_attrs_define
12 | class CreateSyncBatchResponse:
13 | """
14 | Attributes:
15 | id (UUID):
16 | """
17 |
18 | id: UUID
19 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
20 |
21 | def to_dict(self) -> dict[str, Any]:
22 | id = str(self.id)
23 |
24 | field_dict: dict[str, Any] = {}
25 | field_dict.update(self.additional_properties)
26 | field_dict.update(
27 | {
28 | "id": id,
29 | }
30 | )
31 |
32 | return field_dict
33 |
34 | @classmethod
35 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
36 | d = src_dict.copy()
37 | id = UUID(d.pop("id"))
38 |
39 | create_sync_batch_response = cls(
40 | id=id,
41 | )
42 |
43 | create_sync_batch_response.additional_properties = d
44 | return create_sync_batch_response
45 |
46 | @property
47 | def additional_keys(self) -> list[str]:
48 | return list(self.additional_properties.keys())
49 |
50 | def __getitem__(self, key: str) -> Any:
51 | return self.additional_properties[key]
52 |
53 | def __setitem__(self, key: str, value: Any) -> None:
54 | self.additional_properties[key] = value
55 |
56 | def __delitem__(self, key: str) -> None:
57 | del self.additional_properties[key]
58 |
59 | def __contains__(self, key: str) -> bool:
60 | return key in self.additional_properties
61 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/dump_request_state.py:
--------------------------------------------------------------------------------
1 | from enum import Enum
2 |
3 |
4 | class DumpRequestState(str, Enum):
5 | COMPLETE = "COMPLETE"
6 | FAILED = "FAILED"
7 | PENDING = "PENDING"
8 | PROCESSING = "PROCESSING"
9 |
10 | def __str__(self) -> str:
11 | return str(self.value)
12 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/generic_error.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 | from typing import Union
4 |
5 | from attrs import define as _attrs_define
6 | from attrs import field as _attrs_field
7 |
8 | from ..types import UNSET
9 | from ..types import Unset
10 |
11 | T = TypeVar("T", bound="GenericError")
12 |
13 |
14 | @_attrs_define
15 | class GenericError:
16 | """
17 | Attributes:
18 | detail (Union[Unset, Any]):
19 | """
20 |
21 | detail: Union[Unset, Any] = UNSET
22 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
23 |
24 | def to_dict(self) -> dict[str, Any]:
25 | detail = self.detail
26 |
27 | field_dict: dict[str, Any] = {}
28 | field_dict.update(self.additional_properties)
29 | field_dict.update({})
30 | if detail is not UNSET:
31 | field_dict["detail"] = detail
32 |
33 | return field_dict
34 |
35 | @classmethod
36 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
37 | d = src_dict.copy()
38 | detail = d.pop("detail", UNSET)
39 |
40 | generic_error = cls(
41 | detail=detail,
42 | )
43 |
44 | generic_error.additional_properties = d
45 | return generic_error
46 |
47 | @property
48 | def additional_keys(self) -> list[str]:
49 | return list(self.additional_properties.keys())
50 |
51 | def __getitem__(self, key: str) -> Any:
52 | return self.additional_properties[key]
53 |
54 | def __setitem__(self, key: str, value: Any) -> None:
55 | self.additional_properties[key] = value
56 |
57 | def __delitem__(self, key: str) -> None:
58 | del self.additional_properties[key]
59 |
60 | def __contains__(self, key: str) -> bool:
61 | return key in self.additional_properties
62 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/get_sync_batch_response.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TYPE_CHECKING
3 | from typing import TypeVar
4 | from uuid import UUID
5 |
6 | from attrs import define as _attrs_define
7 | from attrs import field as _attrs_field
8 |
9 | if TYPE_CHECKING:
10 | from ..models.sync_data import SyncData
11 |
12 |
13 | T = TypeVar("T", bound="GetSyncBatchResponse")
14 |
15 |
16 | @_attrs_define
17 | class GetSyncBatchResponse:
18 | """
19 | Attributes:
20 | id (UUID):
21 | syncs (list['SyncData']):
22 | """
23 |
24 | id: UUID
25 | syncs: list["SyncData"]
26 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
27 |
28 | def to_dict(self) -> dict[str, Any]:
29 | id = str(self.id)
30 |
31 | syncs = []
32 | for syncs_item_data in self.syncs:
33 | syncs_item = syncs_item_data.to_dict()
34 | syncs.append(syncs_item)
35 |
36 | field_dict: dict[str, Any] = {}
37 | field_dict.update(self.additional_properties)
38 | field_dict.update(
39 | {
40 | "id": id,
41 | "syncs": syncs,
42 | }
43 | )
44 |
45 | return field_dict
46 |
47 | @classmethod
48 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
49 | from ..models.sync_data import SyncData
50 |
51 | d = src_dict.copy()
52 | id = UUID(d.pop("id"))
53 |
54 | syncs = []
55 | _syncs = d.pop("syncs")
56 | for syncs_item_data in _syncs:
57 | syncs_item = SyncData.from_dict(syncs_item_data)
58 |
59 | syncs.append(syncs_item)
60 |
61 | get_sync_batch_response = cls(
62 | id=id,
63 | syncs=syncs,
64 | )
65 |
66 | get_sync_batch_response.additional_properties = d
67 | return get_sync_batch_response
68 |
69 | @property
70 | def additional_keys(self) -> list[str]:
71 | return list(self.additional_properties.keys())
72 |
73 | def __getitem__(self, key: str) -> Any:
74 | return self.additional_properties[key]
75 |
76 | def __setitem__(self, key: str, value: Any) -> None:
77 | self.additional_properties[key] = value
78 |
79 | def __delitem__(self, key: str) -> None:
80 | del self.additional_properties[key]
81 |
82 | def __contains__(self, key: str) -> bool:
83 | return key in self.additional_properties
84 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/http_validation_error.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TYPE_CHECKING
3 | from typing import TypeVar
4 | from typing import Union
5 |
6 | from attrs import define as _attrs_define
7 | from attrs import field as _attrs_field
8 |
9 | from ..types import UNSET
10 | from ..types import Unset
11 |
12 | if TYPE_CHECKING:
13 | from ..models.validation_error import ValidationError
14 |
15 |
16 | T = TypeVar("T", bound="HTTPValidationError")
17 |
18 |
19 | @_attrs_define
20 | class HTTPValidationError:
21 | """
22 | Attributes:
23 | detail (Union[Unset, list['ValidationError']]):
24 | """
25 |
26 | detail: Union[Unset, list["ValidationError"]] = UNSET
27 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
28 |
29 | def to_dict(self) -> dict[str, Any]:
30 | detail: Union[Unset, list[dict[str, Any]]] = UNSET
31 | if not isinstance(self.detail, Unset):
32 | detail = []
33 | for detail_item_data in self.detail:
34 | detail_item = detail_item_data.to_dict()
35 | detail.append(detail_item)
36 |
37 | field_dict: dict[str, Any] = {}
38 | field_dict.update(self.additional_properties)
39 | field_dict.update({})
40 | if detail is not UNSET:
41 | field_dict["detail"] = detail
42 |
43 | return field_dict
44 |
45 | @classmethod
46 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
47 | from ..models.validation_error import ValidationError
48 |
49 | d = src_dict.copy()
50 | detail = []
51 | _detail = d.pop("detail", UNSET)
52 | for detail_item_data in _detail or []:
53 | detail_item = ValidationError.from_dict(detail_item_data)
54 |
55 | detail.append(detail_item)
56 |
57 | http_validation_error = cls(
58 | detail=detail,
59 | )
60 |
61 | http_validation_error.additional_properties = d
62 | return http_validation_error
63 |
64 | @property
65 | def additional_keys(self) -> list[str]:
66 | return list(self.additional_properties.keys())
67 |
68 | def __getitem__(self, key: str) -> Any:
69 | return self.additional_properties[key]
70 |
71 | def __setitem__(self, key: str, value: Any) -> None:
72 | self.additional_properties[key] = value
73 |
74 | def __delitem__(self, key: str) -> None:
75 | del self.additional_properties[key]
76 |
77 | def __contains__(self, key: str) -> bool:
78 | return key in self.additional_properties
79 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/inbox_dump_request_state.py:
--------------------------------------------------------------------------------
1 | from enum import Enum
2 |
3 |
4 | class InboxDumpRequestState(str, Enum):
5 | COMPLETE = "COMPLETE"
6 | FAILED = "FAILED"
7 | PENDING = "PENDING"
8 | PROCESSING = "PROCESSING"
9 |
10 | def __str__(self) -> str:
11 | return str(self.value)
12 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/inbox_email_headers.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 |
4 | from attrs import define as _attrs_define
5 | from attrs import field as _attrs_field
6 |
7 | T = TypeVar("T", bound="InboxEmailHeaders")
8 |
9 |
10 | @_attrs_define
11 | class InboxEmailHeaders:
12 | """ """
13 |
14 | additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
15 |
16 | def to_dict(self) -> dict[str, Any]:
17 | field_dict: dict[str, Any] = {}
18 | field_dict.update(self.additional_properties)
19 |
20 | return field_dict
21 |
22 | @classmethod
23 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
24 | d = src_dict.copy()
25 | inbox_email_headers = cls()
26 |
27 | inbox_email_headers.additional_properties = d
28 | return inbox_email_headers
29 |
30 | @property
31 | def additional_keys(self) -> list[str]:
32 | return list(self.additional_properties.keys())
33 |
34 | def __getitem__(self, key: str) -> str:
35 | return self.additional_properties[key]
36 |
37 | def __setitem__(self, key: str, value: str) -> None:
38 | self.additional_properties[key] = value
39 |
40 | def __delitem__(self, key: str) -> None:
41 | del self.additional_properties[key]
42 |
43 | def __contains__(self, key: str) -> bool:
44 | return key in self.additional_properties
45 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/item_data.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import cast
3 | from typing import TypeVar
4 | from typing import Union
5 |
6 | from attrs import define as _attrs_define
7 | from attrs import field as _attrs_field
8 |
9 | T = TypeVar("T", bound="ItemData")
10 |
11 |
12 | @_attrs_define
13 | class ItemData:
14 | """
15 | Attributes:
16 | id (str):
17 | institution_name (Union[None, str]):
18 | """
19 |
20 | id: str
21 | institution_name: Union[None, str]
22 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
23 |
24 | def to_dict(self) -> dict[str, Any]:
25 | id = self.id
26 |
27 | institution_name: Union[None, str]
28 | institution_name = self.institution_name
29 |
30 | field_dict: dict[str, Any] = {}
31 | field_dict.update(self.additional_properties)
32 | field_dict.update(
33 | {
34 | "id": id,
35 | "institution_name": institution_name,
36 | }
37 | )
38 |
39 | return field_dict
40 |
41 | @classmethod
42 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
43 | d = src_dict.copy()
44 | id = d.pop("id")
45 |
46 | def _parse_institution_name(data: object) -> Union[None, str]:
47 | if data is None:
48 | return data
49 | return cast(Union[None, str], data)
50 |
51 | institution_name = _parse_institution_name(d.pop("institution_name"))
52 |
53 | item_data = cls(
54 | id=id,
55 | institution_name=institution_name,
56 | )
57 |
58 | item_data.additional_properties = d
59 | return item_data
60 |
61 | @property
62 | def additional_keys(self) -> list[str]:
63 | return list(self.additional_properties.keys())
64 |
65 | def __getitem__(self, key: str) -> Any:
66 | return self.additional_properties[key]
67 |
68 | def __setitem__(self, key: str, value: Any) -> None:
69 | self.additional_properties[key] = value
70 |
71 | def __delitem__(self, key: str) -> None:
72 | del self.additional_properties[key]
73 |
74 | def __contains__(self, key: str) -> bool:
75 | return key in self.additional_properties
76 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/list_repositories_response.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TYPE_CHECKING
3 | from typing import TypeVar
4 |
5 | from attrs import define as _attrs_define
6 | from attrs import field as _attrs_field
7 |
8 | if TYPE_CHECKING:
9 | from ..models.repository import Repository
10 |
11 |
12 | T = TypeVar("T", bound="ListRepositoriesResponse")
13 |
14 |
15 | @_attrs_define
16 | class ListRepositoriesResponse:
17 | """
18 | Attributes:
19 | repositories (list['Repository']):
20 | """
21 |
22 | repositories: list["Repository"]
23 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
24 |
25 | def to_dict(self) -> dict[str, Any]:
26 | repositories = []
27 | for repositories_item_data in self.repositories:
28 | repositories_item = repositories_item_data.to_dict()
29 | repositories.append(repositories_item)
30 |
31 | field_dict: dict[str, Any] = {}
32 | field_dict.update(self.additional_properties)
33 | field_dict.update(
34 | {
35 | "repositories": repositories,
36 | }
37 | )
38 |
39 | return field_dict
40 |
41 | @classmethod
42 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
43 | from ..models.repository import Repository
44 |
45 | d = src_dict.copy()
46 | repositories = []
47 | _repositories = d.pop("repositories")
48 | for repositories_item_data in _repositories:
49 | repositories_item = Repository.from_dict(repositories_item_data)
50 |
51 | repositories.append(repositories_item)
52 |
53 | list_repositories_response = cls(
54 | repositories=repositories,
55 | )
56 |
57 | list_repositories_response.additional_properties = d
58 | return list_repositories_response
59 |
60 | @property
61 | def additional_keys(self) -> list[str]:
62 | return list(self.additional_properties.keys())
63 |
64 | def __getitem__(self, key: str) -> Any:
65 | return self.additional_properties[key]
66 |
67 | def __setitem__(self, key: str, value: Any) -> None:
68 | self.additional_properties[key] = value
69 |
70 | def __delitem__(self, key: str) -> None:
71 | del self.additional_properties[key]
72 |
73 | def __contains__(self, key: str) -> bool:
74 | return key in self.additional_properties
75 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/plaid_item_sync_state.py:
--------------------------------------------------------------------------------
1 | from enum import Enum
2 |
3 |
4 | class PlaidItemSyncState(str, Enum):
5 | IMPORT_COMPLETE = "IMPORT_COMPLETE"
6 | IMPORT_COMPLETE_NO_CHANGES = "IMPORT_COMPLETE_NO_CHANGES"
7 | IMPORT_FAILED = "IMPORT_FAILED"
8 | PENDING = "PENDING"
9 | PROCESSING = "PROCESSING"
10 | SYNC_COMPLETE = "SYNC_COMPLETE"
11 | SYNC_FAILED = "SYNC_FAILED"
12 |
13 | def __str__(self) -> str:
14 | return str(self.value)
15 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/repository.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import TypeVar
3 |
4 | from attrs import define as _attrs_define
5 | from attrs import field as _attrs_field
6 |
7 | from ..models.repository_type import RepositoryType
8 |
9 | T = TypeVar("T", bound="Repository")
10 |
11 |
12 | @_attrs_define
13 | class Repository:
14 | """
15 | Attributes:
16 | username (str):
17 | name (str):
18 | type_ (RepositoryType):
19 | public (bool):
20 | active (bool):
21 | """
22 |
23 | username: str
24 | name: str
25 | type_: RepositoryType
26 | public: bool
27 | active: bool
28 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
29 |
30 | def to_dict(self) -> dict[str, Any]:
31 | username = self.username
32 |
33 | name = self.name
34 |
35 | type_ = self.type_.value
36 |
37 | public = self.public
38 |
39 | active = self.active
40 |
41 | field_dict: dict[str, Any] = {}
42 | field_dict.update(self.additional_properties)
43 | field_dict.update(
44 | {
45 | "username": username,
46 | "name": name,
47 | "type": type_,
48 | "public": public,
49 | "active": active,
50 | }
51 | )
52 |
53 | return field_dict
54 |
55 | @classmethod
56 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
57 | d = src_dict.copy()
58 | username = d.pop("username")
59 |
60 | name = d.pop("name")
61 |
62 | type_ = RepositoryType(d.pop("type"))
63 |
64 | public = d.pop("public")
65 |
66 | active = d.pop("active")
67 |
68 | repository = cls(
69 | username=username,
70 | name=name,
71 | type_=type_,
72 | public=public,
73 | active=active,
74 | )
75 |
76 | repository.additional_properties = d
77 | return repository
78 |
79 | @property
80 | def additional_keys(self) -> list[str]:
81 | return list(self.additional_properties.keys())
82 |
83 | def __getitem__(self, key: str) -> Any:
84 | return self.additional_properties[key]
85 |
86 | def __setitem__(self, key: str, value: Any) -> None:
87 | self.additional_properties[key] = value
88 |
89 | def __delitem__(self, key: str) -> None:
90 | del self.additional_properties[key]
91 |
92 | def __contains__(self, key: str) -> bool:
93 | return key in self.additional_properties
94 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/repository_type.py:
--------------------------------------------------------------------------------
1 | from enum import Enum
2 |
3 |
4 | class RepositoryType(str, Enum):
5 | CONNECT = "CONNECT"
6 | GIT = "GIT"
7 |
8 | def __str__(self) -> str:
9 | return str(self.value)
10 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/models/validation_error.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import cast
3 | from typing import TypeVar
4 | from typing import Union
5 |
6 | from attrs import define as _attrs_define
7 | from attrs import field as _attrs_field
8 |
9 | T = TypeVar("T", bound="ValidationError")
10 |
11 |
12 | @_attrs_define
13 | class ValidationError:
14 | """
15 | Attributes:
16 | loc (list[Union[int, str]]):
17 | msg (str):
18 | type_ (str):
19 | """
20 |
21 | loc: list[Union[int, str]]
22 | msg: str
23 | type_: str
24 | additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
25 |
26 | def to_dict(self) -> dict[str, Any]:
27 | loc = []
28 | for loc_item_data in self.loc:
29 | loc_item: Union[int, str]
30 | loc_item = loc_item_data
31 | loc.append(loc_item)
32 |
33 | msg = self.msg
34 |
35 | type_ = self.type_
36 |
37 | field_dict: dict[str, Any] = {}
38 | field_dict.update(self.additional_properties)
39 | field_dict.update(
40 | {
41 | "loc": loc,
42 | "msg": msg,
43 | "type": type_,
44 | }
45 | )
46 |
47 | return field_dict
48 |
49 | @classmethod
50 | def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
51 | d = src_dict.copy()
52 | loc = []
53 | _loc = d.pop("loc")
54 | for loc_item_data in _loc:
55 |
56 | def _parse_loc_item(data: object) -> Union[int, str]:
57 | return cast(Union[int, str], data)
58 |
59 | loc_item = _parse_loc_item(loc_item_data)
60 |
61 | loc.append(loc_item)
62 |
63 | msg = d.pop("msg")
64 |
65 | type_ = d.pop("type")
66 |
67 | validation_error = cls(
68 | loc=loc,
69 | msg=msg,
70 | type_=type_,
71 | )
72 |
73 | validation_error.additional_properties = d
74 | return validation_error
75 |
76 | @property
77 | def additional_keys(self) -> list[str]:
78 | return list(self.additional_properties.keys())
79 |
80 | def __getitem__(self, key: str) -> Any:
81 | return self.additional_properties[key]
82 |
83 | def __setitem__(self, key: str, value: Any) -> None:
84 | self.additional_properties[key] = value
85 |
86 | def __delitem__(self, key: str) -> None:
87 | del self.additional_properties[key]
88 |
89 | def __contains__(self, key: str) -> bool:
90 | return key in self.additional_properties
91 |
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/py.typed:
--------------------------------------------------------------------------------
1 | # Marker file for PEP 561
--------------------------------------------------------------------------------
/beanhub_cli/internal_api/types.py:
--------------------------------------------------------------------------------
1 | """Contains some shared types for properties"""
2 | from collections.abc import MutableMapping
3 | from http import HTTPStatus
4 | from typing import BinaryIO
5 | from typing import Generic
6 | from typing import Literal
7 | from typing import Optional
8 | from typing import TypeVar
9 |
10 | from attrs import define
11 |
12 |
13 | class Unset:
14 | def __bool__(self) -> Literal[False]:
15 | return False
16 |
17 |
18 | UNSET: Unset = Unset()
19 |
20 | FileJsonType = tuple[Optional[str], BinaryIO, Optional[str]]
21 |
22 |
23 | @define
24 | class File:
25 | """Contains information for file uploads"""
26 |
27 | payload: BinaryIO
28 | file_name: Optional[str] = None
29 | mime_type: Optional[str] = None
30 |
31 | def to_tuple(self) -> FileJsonType:
32 | """Return a tuple representation that httpx will accept for multipart/form-data"""
33 | return self.file_name, self.payload, self.mime_type
34 |
35 |
36 | T = TypeVar("T")
37 |
38 |
39 | @define
40 | class Response(Generic[T]):
41 | """A response from an endpoint"""
42 |
43 | status_code: HTTPStatus
44 | content: bytes
45 | headers: MutableMapping[str, str]
46 | parsed: Optional[T]
47 |
48 |
49 | __all__ = ["UNSET", "File", "FileJsonType", "Response", "Unset"]
50 |
--------------------------------------------------------------------------------
/beanhub_cli/main.py:
--------------------------------------------------------------------------------
1 | from . import format # noqa
2 | from .cli import cli
3 | from .connect import main as connect # noqa
4 | from .forms import main as forms # noqa
5 | from .import_cli import main as import_cli # noqa
6 | from .inbox import main as inbox # noqa
7 | from .login import main as login # noqa
8 |
9 | __ALL__ = [cli]
10 |
11 | if __name__ == "__main__":
12 | cli()
13 |
--------------------------------------------------------------------------------
/data/internal-api-config.yaml:
--------------------------------------------------------------------------------
1 | package_name_override: "internal_api"
2 |
--------------------------------------------------------------------------------
/docs/docs/assets/favicon.svg:
--------------------------------------------------------------------------------
1 | 
21 |