beanhub-cli 2.0.0__tar.gz → 2.1.0b2__tar.gz

{beanhub_cli-2.0.0 → beanhub_cli-2.1.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: beanhub-cli
-Version: 2.0.0
+Version: 2.1.0b2
 Summary: Command line tools for BeanHub
 License: MIT
 Author: Fang-Pen Lin
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: connect
 Provides-Extra: login
+Requires-Dist: attrs (>=22.2.0) ; extra == "login" or extra == "connect"
 Requires-Dist: beancount-black (>=1.0.1,<2.0.0)
 Requires-Dist: beancount-parser (>=1.2.3,<1.3.0)
 Requires-Dist: beanhub-extract (>=0.1.0,<1.0.0)
@@ -21,12 +22,13 @@ Requires-Dist: beanhub-import (>=1.0.0,<2.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: cryptography (>=44.0.0,<45.0.0) ; extra == "connect"
 Requires-Dist: fastapi (>=0.98.0,<1.0.0)
+Requires-Dist: httpx (>=0.20.0,<0.29.0) ; extra == "login" or extra == "connect"
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: pydantic (>=2.4.0,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.0.3,<3.0.0)
 Requires-Dist: pynacl (>=1.5.0,<2.0.0) ; extra == "connect"
+Requires-Dist: python-dateutil (>=2.8.0,<3.0.0) ; extra == "login" or extra == "connect"
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0) ; extra == "login" or extra == "connect"
 Requires-Dist: rich (>=13.6.0,<14.0.0)
 Requires-Dist: starlette-wtf (>=0.4.3,<0.5.0)
 Requires-Dist: tomli (>=2.2.1,<3.0.0) ; extra == "login" or extra == "connect"

beanhub_cli-2.1.0b2/beanhub_cli/api_helpers.py

@@ -0,0 +1,41 @@
+import functools
+import json
+import logging
+import sys
+import typing
+
+
+def handle_api_exception(logger: logging.Logger | None = None):
+    def decorator(func: typing.Callable):
+        @functools.wraps(func)
+        def callee(*args, **kwargs):
+            from .internal_api.errors import UnexpectedStatus
+            from .internal_api.models import GenericError
+
+            try:
+                return func(*args, **kwargs)
+            except UnexpectedStatus as exp:
+                log = logger or logging.getLogger(__name__)
+                error = None
+                try:
+                    error = GenericError.from_dict(json.loads(exp.content))
+                except ValueError:
+                    pass
+                log.error(
+                    "Failed to make BeanHub API call with code %s and error: %s",
+                    exp.status_code,
+                    error.detail if error is not None else exp.content,
+                )
+                sys.exit(-1)
+
+        return callee
+
+    return decorator
+
+
+def make_auth_client(base_url: str, token: str) -> "AuthenticatedClient":
+    from .internal_api.client import AuthenticatedClient
+
+    return AuthenticatedClient(
+        base_url=base_url, prefix="", auth_header_name="access-token", token=token
+    )

{beanhub_cli-2.0.0 → beanhub_cli-2.1.0b2}/beanhub_cli/cli.py

@@ -34,3 +34,5 @@ def cli(env: Environment, log_level: str):
         handlers=[RichHandler(console=console)],
         force=True,
     )
+    httpx_logger = logging.getLogger("httpx")
+    httpx_logger.level = logging.WARNING

{beanhub_cli-2.0.0 → beanhub_cli-2.1.0b2}/beanhub_cli/config.py

@@ -45,5 +45,5 @@ def save_config(config: Config, file_path: pathlib.Path | None = None):
     # TODO: for now we save the config as plaintext. We should consider to use OS keychain service in the future
     #       for better security
     with file_path.open("wb") as fo:
-        obj = config.model_dump(mode="json")
+        obj = config.model_dump(mode="json", exclude_none=True)
         tomli_w.dump(obj, fo)

beanhub_cli-2.1.0b2/beanhub_cli/connect/config.py

@@ -0,0 +1,70 @@
+import dataclasses
+import logging
+import sys
+import typing
+
+from ..api_helpers import make_auth_client
+from ..config import load_config
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class ConnectConfig:
+    token: str
+    username: str
+    repo: str
+
+
+def parse_repo(repo: str | None) -> typing.Tuple[str | None, str | None]:
+    if repo is None:
+        return None, None
+    return tuple(repo.split("/", 1))
+
+
+# TODO: maybe extract this part to a shared env for connect command?
+def ensure_config(api_base_url: str, repo: str | None) -> ConnectConfig:
+    config = load_config()
+    if config is None or config.access_token is None:
+        logger.error(
+            'You need to login into your BeanHub account with "bh login" command first'
+        )
+        sys.exit(-1)
+    if repo is None and (config.repo is None or config.repo.default is None):
+        logger.info(
+            "No repo provided, try to determine which repo to use automatically ..."
+        )
+
+        from ..internal_api.api.repo import list_repo
+
+        with make_auth_client(
+            base_url=api_base_url, token=config.access_token.token
+        ) as client:
+            client.raise_on_unexpected_status = True
+            resp = list_repo.sync(client=client)
+            active_repos = list(filter(lambda repo: repo.active, resp.repositories))
+            if len(active_repos) == 1:
+                active_repo = active_repos[0]
+                username = active_repo.username
+                repo_name = active_repo.name
+            else:
+                if len(active_repos) > 1:
+                    logger.error(
+                        "Cannot determine repo automatically because there are multiple active repos: %s",
+                        ", ".join(
+                            [f"{repo.username}/{repo.name}" for repo in active_repos]
+                        ),
+                    )
+                logger.error(
+                    'You need to provide a repo by -r argument, such as "myuser/myrepo" or define a default repo in your config file'
+                )
+                sys.exit(-1)
+    else:
+        username, repo_name = parse_repo(
+            repo if repo is not None else config.repo.default
+        )
+    return ConnectConfig(
+        token=config.access_token.token,
+        username=username,
+        repo=repo_name,
+    )

beanhub_cli-2.1.0b2/beanhub_cli/connect/file_io.py

@@ -0,0 +1,12 @@
+import io
+import logging
+import tarfile
+
+
+def extract_tar(input_file: io.BytesIO, logger: logging.Logger):
+    with tarfile.open(fileobj=input_file, mode="r:gz") as tar_file:
+        if hasattr(tarfile, "data_filter"):
+            tar_file.extractall(filter="data")
+        else:
+            logger.warning("Performing unsafe tar file extracting")
+            tar_file.extractall()

beanhub_cli-2.1.0b2/beanhub_cli/connect/main.py

@@ -0,0 +1,267 @@
+import json
+import logging
+import sys
+import tarfile
+import tempfile
+import time
+
+import click
+import rich
+from rich import box
+from rich.markup import escape
+from rich.padding import Padding
+from rich.table import Table
+
+from ..api_helpers import handle_api_exception
+from ..api_helpers import make_auth_client
+from ..environment import Environment
+from ..environment import pass_env
+from ..utils import check_imports
+from ..utils import ExtraDepsSet
+from .cli import cli
+from .config import ConnectConfig
+from .config import ensure_config
+
+logger = logging.getLogger(__name__)
+
+TABLE_HEADER_STYLE = "yellow"
+TABLE_COLUMN_STYLE = "cyan"
+SPOOLED_FILE_MAX_SIZE = 1024 * 1024 * 5
+
+
+def run_sync(env: Environment, config: ConnectConfig):
+    from ..internal_api.api.connect import create_sync_batch
+    from ..internal_api.api.connect import get_sync_batch
+    from ..internal_api.models import CreateSyncBatchResponse
+    from ..internal_api.models import GetSyncBatchResponse
+    from ..internal_api.models import HTTPValidationError
+    from ..internal_api.models import PlaidItemSyncState
+
+    GOOD_TERMINAL_SYNC_STATES = frozenset(
+        [
+            PlaidItemSyncState.IMPORT_COMPLETE,
+            PlaidItemSyncState.IMPORT_COMPLETE_NO_CHANGES,
+        ]
+    )
+    BAD_TERMINAL_SYNC_STATES = frozenset(
+        [
+            PlaidItemSyncState.IMPORT_FAILED,
+            PlaidItemSyncState.SYNC_FAILED,
+        ]
+    )
+
+    logger.info(
+        "Running sync batch for repo [green]%s[/]",
+        config.repo,
+        extra={"markup": True, "highlighter": None},
+    )
+
+    with make_auth_client(base_url=env.api_base_url, token=config.token) as client:
+        client.raise_on_unexpected_status = True
+        resp: CreateSyncBatchResponse = create_sync_batch.sync(
+            username=config.username, repo_name=config.repo, client=client
+        )
+        if isinstance(resp, HTTPValidationError):
+            logger.error(
+                "Failed to create sync batch with error: %s",
+                resp.additional_properties.get("error", resp.detail),
+            )
+            sys.exit(-1)
+        batch_id = resp.id
+        logger.info(
+            "Created sync batch [green]%s[/], waiting for updates ...",
+            batch_id,
+            extra={"markup": True, "highlighter": None},
+        )
+
+        while True:
+            time.sleep(5)
+            resp: GetSyncBatchResponse = get_sync_batch.sync(
+                username=config.username,
+                repo_name=config.repo,
+                sync_batch_id=batch_id,
+                client=client,
+            )
+            total = len(resp.syncs)
+            good_terms = list(
+                sync
+                for sync in resp.syncs
+                if PlaidItemSyncState[sync.state.value] in GOOD_TERMINAL_SYNC_STATES
+            )
+            bad_terms = list(
+                sync for sync in resp.syncs if sync.state in BAD_TERMINAL_SYNC_STATES
+            )
+            progress = len(good_terms) + len(bad_terms)
+            if progress >= total:
+                break
+            else:
+                logger.info(
+                    "Still processing, [green]%s[/] out of [green]%s[/]",
+                    progress,
+                    total,
+                    extra={"markup": True, "highlighter": None},
+                )
+        table = Table(
+            title="Sync finished successfully",
+            box=box.SIMPLE,
+            header_style=TABLE_HEADER_STYLE,
+            expand=True,
+        )
+        table.add_column("Id", style=TABLE_COLUMN_STYLE)
+        table.add_column("Institution", style=TABLE_COLUMN_STYLE)
+        table.add_column("State", style=TABLE_COLUMN_STYLE)
+        for sync in good_terms:
+            table.add_row(
+                escape(sync.id),
+                escape(sync.item.institution_name),
+                escape(sync.state),
+            )
+        rich.print(Padding(table, (1, 0, 0, 4)))
+
+        table = Table(
+            title="Sync finished with error",
+            box=box.SIMPLE,
+            header_style=TABLE_HEADER_STYLE,
+            expand=True,
+        )
+        table.add_column("Id", style=TABLE_COLUMN_STYLE)
+        table.add_column("Institution", style=TABLE_COLUMN_STYLE)
+        table.add_column("State", style=TABLE_COLUMN_STYLE)
+        table.add_column("Error", style=TABLE_COLUMN_STYLE)
+        for sync in bad_terms:
+            table.add_row(
+                escape(sync.id),
+                escape(sync.item.institution_name),
+                escape(sync.state),
+                escape(sync.error_message),
+            )
+        rich.print(Padding(table, (1, 0, 0, 4)))
+
+
+@cli.command(help="Sync transactions for all BeanHub Connect banks")
+@click.option(
+    "-r",
+    "--repo",
+    type=str,
+    help='Which repository to run sync on, in "<username>/<repo_name>" format',
+)
+@pass_env
+@handle_api_exception(logger)
+@check_imports(ExtraDepsSet.LOGIN, logger)
+def sync(env: Environment, repo: str | None):
+    config = ensure_config(api_base_url=env.api_base_url, repo=repo)
+    run_sync(env, config)
+    env.logger.info("done")
+
+
+@cli.command(
+    help="Dump transaction CSV files from BeanHub Connect to your local environment"
+)
+@click.option(
+    "-r",
+    "--repo",
+    type=str,
+    help='Which repository to run sync on, in "<username>/<repo_name>" format',
+)
+@click.option(
+    "-s",
+    "--sync",
+    type=bool,
+    is_flag=True,
+    help="Run sync first before running dump",
+)
+@click.option(
+    "--unsafe-tar-extract",
+    type=bool,
+    is_flag=True,
+    help="Allow unsafe tar extraction, mostly for Python < 3.11",
+)
+@pass_env
+@handle_api_exception(logger)
+@check_imports(ExtraDepsSet.CONNECT, logger)
+def dump(env: Environment, repo: str | None, sync: bool, unsafe_tar_extract: bool):
+    import httpx
+    from ..internal_api.api.connect import create_dump_request
+    from ..internal_api.api.connect import get_dump_request
+    from ..internal_api.models import CreateDumpRequestRequest
+    from ..internal_api.models import CreateDumpRequestResponse
+    from ..internal_api.models import DumpRequestState
+    from ..internal_api.models import GetDumpRequestResponse
+    from nacl.encoding import URLSafeBase64Encoder
+    from nacl.public import PrivateKey
+    from nacl.public import SealedBox
+
+    if not hasattr(tarfile, "data_filter") and not unsafe_tar_extract:
+        logger.error(
+            "You need to use Python >= 3.11 in order to safely unpack the downloaded tar file, or you need to pass "
+            "in --unsafe-tar-extract argument to allow unsafe tar file extracting"
+        )
+        sys.exit(-1)
+    config = ensure_config(api_base_url=env.api_base_url, repo=repo)
+    if sync:
+        run_sync(env, config)
+
+    private_key = PrivateKey.generate()
+    public_key = private_key.public_key.encode(URLSafeBase64Encoder).decode("ascii")
+
+    with make_auth_client(base_url=env.api_base_url, token=config.token) as client:
+        client.raise_on_unexpected_status = True
+        resp: CreateDumpRequestResponse = create_dump_request.sync(
+            body=CreateDumpRequestRequest(public_key=public_key),
+            username=config.username,
+            repo_name=config.repo,
+            client=client,
+        )
+        dump_id = resp.id
+        logger.info(
+            "Created dump [green]%s[/] with public_key [green]%s[/], waiting for updates ...",
+            dump_id,
+            public_key,
+            extra={"markup": True, "highlighter": None},
+        )
+
+        while True:
+            time.sleep(5)
+            resp: GetDumpRequestResponse = get_dump_request.sync(
+                dump_request_id=dump_id,
+                username=config.username,
+                repo_name=config.repo,
+                client=client,
+            )
+            if resp.state == DumpRequestState.FAILED:
+                logger.error("Failed to dump with error: %s", resp.error_message)
+                sys.exit(-1)
+            elif resp.state == DumpRequestState.COMPLETE:
+                break
+            else:
+                logger.debug("State is %s, keep polling...", resp.state)
+
+    download_url = resp.download_url
+    sealed_box = SealedBox(private_key)
+    encryption_key = json.loads(
+        sealed_box.decrypt(URLSafeBase64Encoder.decode(resp.encryption_key))
+    )
+    key = URLSafeBase64Encoder.decode(encryption_key["key"])
+    iv = URLSafeBase64Encoder.decode(encryption_key["iv"])
+
+    with (
+        tempfile.SpooledTemporaryFile(SPOOLED_FILE_MAX_SIZE) as encrypted_file,
+        tempfile.SpooledTemporaryFile(SPOOLED_FILE_MAX_SIZE) as decrypted_file,
+    ):
+        with httpx.stream("GET", download_url) as req:
+            for chunk in req.iter_bytes():
+                encrypted_file.write(chunk)
+        encrypted_file.flush()
+        encrypted_file.seek(0)
+        logger.info("Decrypting downloaded file ...")
+
+        # delay import for testing purpose
+        from .encryption import decrypt_file
+        from .file_io import extract_tar
+
+        decrypt_file(
+            input_file=encrypted_file, output_file=decrypted_file, key=key, iv=iv
+        )
+        extract_tar(input_file=decrypted_file, logger=env.logger)
+
+    logger.info("done")

beanhub_cli-2.1.0b2/beanhub_cli/internal_api/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing BeanHub Internal API"""
+from .client import AuthenticatedClient
+from .client import Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

beanhub_cli-2.1.0b2/beanhub_cli/internal_api/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

beanhub_cli-2.1.0b2/beanhub_cli/internal_api/api/auth/create_auth_session.py

@@ -0,0 +1,168 @@
+from http import HTTPStatus
+from typing import Any
+from typing import Optional
+from typing import Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient
+from ...client import Client
+from ...models.auth_session_request import AuthSessionRequest
+from ...models.auth_session_response import AuthSessionResponse
+from ...models.http_validation_error import HTTPValidationError
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: AuthSessionRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v1/auth/sessions",
+    }
+
+    _body = body.to_dict()
+
+    _kwargs["json"] = _body
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[AuthSessionResponse, HTTPValidationError]]:
+    if response.status_code == 201:
+        response_201 = AuthSessionResponse.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 422:
+        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: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[AuthSessionResponse, 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(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: AuthSessionRequest,
+) -> Response[Union[AuthSessionResponse, HTTPValidationError]]:
+    """Create auth session
+
+    Args:
+        body (AuthSessionRequest):
+
+    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[AuthSessionResponse, HTTPValidationError]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: AuthSessionRequest,
+) -> Optional[Union[AuthSessionResponse, HTTPValidationError]]:
+    """Create auth session
+
+    Args:
+        body (AuthSessionRequest):
+
+    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[AuthSessionResponse, HTTPValidationError]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: AuthSessionRequest,
+) -> Response[Union[AuthSessionResponse, HTTPValidationError]]:
+    """Create auth session
+
+    Args:
+        body (AuthSessionRequest):
+
+    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[AuthSessionResponse, HTTPValidationError]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: AuthSessionRequest,
+) -> Optional[Union[AuthSessionResponse, HTTPValidationError]]:
+    """Create auth session
+
+    Args:
+        body (AuthSessionRequest):
+
+    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[AuthSessionResponse, HTTPValidationError]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed