aoiro 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

aoiro/__init__.py

@@ -1 +1,52 @@
-__version__ = "0.0.3"
+__version__ = "0.1.1"
+from ._ledger import (
+    GeneralLedgerLine,
+    GeneralLedgerLineImpl,
+    LedgerElement,
+    LedgerElementImpl,
+    LedgerLine,
+    LedgerLineImpl,
+    MultiLedgerLine,
+    MultiLedgerLineImpl,
+    generalledger_line_to_multiledger_line,
+    generalledger_to_multiledger,
+    multiledger_line_to_generalledger_line,
+    multiledger_line_to_ledger_line,
+    multiledger_to_generalledger,
+    multiledger_to_ledger,
+)
+from ._multidimensional import multidimensional_ledger_to_ledger
+from ._sheets import get_sheets
+from .reader import (
+    ledger_from_expenses,
+    ledger_from_sales,
+    read_all_csvs,
+    read_general_ledger,
+    read_simple_csvs,
+    withholding_tax,
+)
+
+__all__ = [
+    "GeneralLedgerLine",
+    "GeneralLedgerLineImpl",
+    "LedgerElement",
+    "LedgerElementImpl",
+    "LedgerLine",
+    "LedgerLineImpl",
+    "MultiLedgerLine",
+    "MultiLedgerLineImpl",
+    "generalledger_line_to_multiledger_line",
+    "generalledger_to_multiledger",
+    "get_sheets",
+    "ledger_from_expenses",
+    "ledger_from_sales",
+    "multidimensional_ledger_to_ledger",
+    "multiledger_line_to_generalledger_line",
+    "multiledger_line_to_ledger_line",
+    "multiledger_to_generalledger",
+    "multiledger_to_ledger",
+    "read_all_csvs",
+    "read_general_ledger",
+    "read_simple_csvs",
+    "withholding_tax",
+]

aoiro/__main__.py

@@ -2,4 +2,4 @@
 
 from .cli import app
 
-app(prog_name="aoiro")
+app()

aoiro/_ledger.py

@@ -0,0 +1,298 @@
+from collections.abc import Sequence
+from decimal import Decimal
+from itertools import chain
+from typing import Any, Callable, Literal, Protocol, TypeVar
+
+import attrs
+import pandas as pd
+from account_codes_jp._common import SUNDRY
+
+AccountSundry = Literal["諸口"]
+Account = TypeVar("Account", bound=str)
+Currency = TypeVar("Currency", bound=str)
+
+
+class _LedgerLineBase(Protocol):
+    date: pd.Timestamp
+    """The date when the transaction occurred."""
+
+
+class LedgerLine(_LedgerLineBase, Protocol[Account, Currency]):
+    amount: Decimal
+    """The amount. Must be non-negative."""
+    currency: Currency
+    """The currency."""
+    debit_account: Account
+    """The account written on the debit side."""
+    credit_account: Account
+    """The account written on the credit side."""
+
+
+class LedgerElement(Protocol[Account, Currency]):
+    account: Account
+    """The account."""
+    amount: Decimal
+    """The amount."""
+    currency: Currency
+    """The currency."""
+
+
+class MultiLedgerLine(_LedgerLineBase, Protocol[Account, Currency]):
+    debit: Sequence[LedgerElement[Account, Currency]]
+    """The accounts and amounts on the debit side.
+    Each amount needs to be non-negative."""
+    credit: Sequence[LedgerElement[Account, Currency]]
+    """The accounts and amounts on the credit side.
+    Each amount needs to be non-negative."""
+
+
+class GeneralLedgerLine(_LedgerLineBase, Protocol[Account, Currency]):
+    values: Sequence[LedgerElement[Account, Currency]]
+    """The accounts and amounts. Amounts does not need to be non-negative."""
+
+
+@attrs.frozen(kw_only=True)
+class LedgerLineImpl(LedgerLine[Account, Currency]):
+    date: pd.Timestamp
+    amount: Decimal = attrs.field()
+    currency: Currency
+    debit_account: Account
+    credit_account: Account
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.date} {self.amount} {self.currency} "
+            f"{self.debit_account} / {self.credit_account}"
+        )
+
+    @amount.validator
+    def _validate_amount(self, attribute: Any, value: Decimal) -> None:
+        if value < Decimal(0):
+            raise ValueError("amount must be non-negative")
+
+
+@attrs.frozen(kw_only=True)
+class LedgerElementImpl(LedgerElement[Account, Currency]):
+    account: Account
+    amount: Decimal
+    currency: Currency
+
+    def __repr__(self) -> str:
+        return f"{self.account} {self.amount} {self.currency}"
+
+
+@attrs.frozen(kw_only=True, auto_detect=True)
+class MultiLedgerLineImpl(MultiLedgerLine[Account, Currency]):
+    date: pd.Timestamp
+    debit: Sequence[LedgerElement[Account, Currency]] = attrs.field()
+    credit: Sequence[LedgerElement[Account, Currency]] = attrs.field()
+
+    def __repr__(self) -> str:
+        date = pd.Series([self.date], name="date")
+        debit = pd.DataFrame(
+            self.debit, columns=["debit_account", "amount", "currency"]
+        )
+        credit = pd.DataFrame(
+            self.credit, columns=["credit_account", "amount", "currency"]
+        )
+        return (
+            pd.concat([date, debit, credit], axis=1)
+            .replace({pd.NaT: ""})
+            .fillna("")
+            .to_string(index=False, header=False)
+        )
+
+    @debit.validator
+    def _validate_debit(
+        self, attribute: Any, value: Sequence[LedgerElement[Account, Currency]]
+    ) -> None:
+        if any(el.amount < Decimal(0) for el in value):
+            raise ValueError("amount must be non-negative")
+
+    @credit.validator
+    def _validate_credit(
+        self, attribute: Any, value: Sequence[LedgerElement[Account, Currency]]
+    ) -> None:
+        if any(el.amount < Decimal(0) for el in value):
+            raise ValueError("amount must be non-negative")
+
+
+@attrs.frozen(kw_only=True, auto_detect=True)
+class GeneralLedgerLineImpl(GeneralLedgerLine[Account, Currency]):
+    date: pd.Timestamp
+    values: Sequence[LedgerElement[Account, Currency]]
+
+
+def generalledger_line_to_multiledger_line(
+    line: GeneralLedgerLine[Account, Currency], is_debit: Callable[[Account], bool], /
+) -> MultiLedgerLine[Account, Currency]:
+    """
+    Convert a GeneralLedgerLine to a MultiLedgerLine.
+
+    Parameters
+    ----------
+    line : GeneralLedgerLine[Account, Currency]
+        The GeneralLedgerLine to convert.
+    is_debit : Callable[[Account], bool]
+        Whether the account is a debit account.
+
+    Returns
+    -------
+    MultiLedgerLine[Account, Currency]
+        The converted MultiLedgerLine.
+
+    """
+    debit = []
+    credit = []
+    for el in line.values:
+        if is_debit(el.account) == (el.amount > 0):
+            debit.append(
+                LedgerElementImpl(
+                    account=el.account, amount=abs(el.amount), currency=el.currency
+                )
+            )
+        else:
+            credit.append(
+                LedgerElementImpl(
+                    account=el.account, amount=abs(el.amount), currency=el.currency
+                )
+            )
+    return MultiLedgerLineImpl(date=line.date, debit=debit, credit=credit)
+
+
+def multiledger_line_to_generalledger_line(
+    line: MultiLedgerLine[Account, Currency], /
+) -> GeneralLedgerLine[Account, Currency]:
+    """
+    Convert a MultiLedgerLine to a GeneralLedgerLine.
+
+    Parameters
+    ----------
+    line : MultiLedgerLine[Account, Currency]
+        The MultiLedgerLine to convert.
+
+    Returns
+    -------
+    GeneralLedgerLine[Account, Currency]
+        The converted GeneralLedgerLine.
+
+    """
+    return GeneralLedgerLineImpl(
+        date=line.date,
+        values=[*line.debit, *line.credit],
+    )
+
+
+def multiledger_line_to_ledger_line(
+    line: MultiLedgerLine[Account, Currency], /
+) -> Sequence[LedgerLine[Account | AccountSundry, Currency]]:
+    """
+    Convert a MultiLedgerLine to a list of LedgerLine.
+
+    Parameters
+    ----------
+    line : MultiLedgerLine[Account, Currency]
+        The MultiLedgerLine to convert.
+
+    Returns
+    -------
+    Sequence[LedgerLine[Account | AccountSundry, Currency]]
+        The converted LedgerLines.
+
+    """
+    if (
+        len(line.debit) == len(line.credit) == 1
+        and line.debit[0].amount == line.credit[0].amount
+        and line.debit[0].currency == line.credit[0].currency
+    ):
+        return [
+            LedgerLineImpl(
+                date=line.date,
+                amount=line.debit[0].amount,
+                currency=line.debit[0].currency,
+                debit_account=line.debit[0].account,
+                credit_account=line.credit[0].account,
+            )
+        ]
+    return [
+        LedgerLineImpl(
+            date=line.date,
+            amount=el.amount,
+            currency=el.currency,
+            debit_account=el.account,
+            credit_account=SUNDRY,
+        )
+        for el in line.debit
+    ] + [
+        LedgerLineImpl(
+            date=line.date,
+            amount=el.amount,
+            currency=el.currency,
+            debit_account=SUNDRY,
+            credit_account=el.account,
+        )
+        for el in line.credit
+    ]
+
+
+def generalledger_to_multiledger(
+    lines: Sequence[GeneralLedgerLine[Account, Currency]],
+    is_debit: Callable[[Account], bool],
+) -> Sequence[MultiLedgerLine[Account, Currency]]:
+    """
+    Convert a GeneralLedger to a MultiLedger.
+
+    Parameters
+    ----------
+    lines : Sequence[GeneralLedgerLine[Account, Currency]]
+        The GeneralLedger to convert.
+    is_debit : Callable[[Account], bool]
+        Whether the account is a debit account.
+
+    Returns
+    -------
+    Sequence[MultiLedgerLine[Account, Currency]]
+        The converted MultiLedger.
+
+    """
+    return [generalledger_line_to_multiledger_line(line, is_debit) for line in lines]
+
+
+def multiledger_to_generalledger(
+    lines: Sequence[MultiLedgerLine[Account, Currency]],
+) -> Sequence[GeneralLedgerLine[Account, Currency]]:
+    """
+    Convert a MultiLedger to a GeneralLedger.
+
+    Parameters
+    ----------
+    lines : Sequence[MultiLedgerLine[Account, Currency]]
+        The MultiLedger to convert.
+
+    Returns
+    -------
+    Sequence[GeneralLedgerLine[Account, Currency]]
+        The converted GeneralLedger.
+
+    """
+    return [multiledger_line_to_generalledger_line(line) for line in lines]
+
+
+def multiledger_to_ledger(
+    lines: Sequence[MultiLedgerLine[Account, Currency]],
+) -> Sequence[LedgerLine[Account | AccountSundry, Currency]]:
+    """
+    Convert a MultiLedger to a Ledger.
+
+    Parameters
+    ----------
+    lines : Sequence[MultiLedgerLine[Account, Currency]]
+        The MultiLedger to convert.
+
+    Returns
+    -------
+    Sequence[LedgerLine[Account | AccountSundry, Currency]]
+        The converted Ledger.
+
+    """
+    return list(chain(*[multiledger_line_to_ledger_line(line) for line in lines]))

aoiro/_multidimensional.py

@@ -0,0 +1,186 @@
+from collections import defaultdict
+from collections.abc import Iterable, Mapping, Sequence
+from decimal import ROUND_DOWN, Decimal, localcontext
+from pathlib import Path
+from sys import platform
+from typing import Callable, Literal
+
+import numpy as np
+import pandas as pd
+import requests
+
+from ._ledger import (
+    Account,
+    Currency,
+    GeneralLedgerLine,
+    GeneralLedgerLineImpl,
+    LedgerElement,
+    LedgerElementImpl,
+)
+
+
+def _get_currency(
+    lines: Sequence[GeneralLedgerLine[Account, Currency]],
+) -> Sequence[Currency]:
+    return np.unique([x.currency for line in lines for x in line.values])
+
+
+def get_prices(
+    currency: Iterable[Currency],
+) -> Mapping[Currency, "pd.Series[Decimal]"]:
+    """
+    Get prices of the currency indexed by date (not datetime).
+
+    Interpolates missing dates by forward fill.
+
+    Parameters
+    ----------
+    currency : Iterable[Currency]
+        The currency to get prices.
+
+    Returns
+    -------
+    Mapping[Currency, pd.Series[Decimal]]
+        The prices, indexed by date.
+
+    """
+    URL = "https://www.mizuhobank.co.jp/market/quote.csv"
+    path_dir = Path("~/.cache/aoiro").expanduser()
+    path_dir.mkdir(exist_ok=True, parents=True)
+    path = path_dir / "quote.csv"
+    if not path.exists():
+        with path.open("w", encoding="utf-8") as f:
+            r = requests.get(URL, timeout=5)
+            r.encoding = "Shift_JIS"
+            f.write(r.text)
+    df = pd.read_csv(
+        path,
+        index_col=0,
+        skiprows=3 if platform == "win32" else 2,
+        na_values=["*****"],
+        parse_dates=True,
+    )
+    # fill missing dates
+    df = df.reindex(pd.date_range(df.index[0], df.index[-1]), method="ffill")
+    return df
+
+
+def multidimensional_ledger_to_ledger(
+    lines: Sequence[GeneralLedgerLine[Account, Currency]],
+    is_debit: Callable[[Account], bool],
+    prices: Mapping[Currency, "pd.Series[Decimal]"] = {},
+) -> Sequence[
+    GeneralLedgerLineImpl[Account | Literal["為替差益", "為替差損"], Literal[""]]
+]:
+    """
+    Convert multidimensional ledger to ledger.
+
+    The multidimensional ledger's any account must have
+    positive amount.
+    At the BOY, the previous B/S sheet
+    must be added as a general ledger line, for example,
+
+    >>> lines.append(
+    >>>    GeneralLedgerLineImpl(
+    >>>        date=datetime(2024, 1, 1),
+    >>>        values=[
+    >>>            ("売掛金", 1000, ""),
+    >>>            ("元入金", 1000, "")
+    >>>         ]
+    >>>     )
+    >>> )
+
+    Returns
+    -------
+    GeneralLedgerLineImpl[Account | Literal["為替差益", "為替差損"], Literal[""]]
+        The ledger lines.
+
+    """
+    # get prices, use prices_
+    lines = sorted(lines, key=lambda x: x.date)
+    prices_ = dict(prices)
+    del prices
+    prices_.update(get_prices(set(_get_currency(lines)) - set(prices_.keys())))
+
+    # balance of (account, currency) represented by tuple (price, amount)
+    balance: dict[Account, dict[Currency, list[tuple[Decimal, Decimal]]]] = defaultdict(
+        lambda: defaultdict(list)
+    )
+
+    # the new lines
+    lines_new = []
+    for line in lines:
+        # profit of the old line
+        profit = Decimal(0)
+
+        # the values of the new line
+        values: list[
+            LedgerElement[Account | Literal["為替差益", "為替差損"], Literal[""]]
+        ] = []
+
+        # iterate over the values of the old line
+        for el in line.values:
+            amount_left = el.amount
+            # skip if the currency is empty (default, exchange rate = 1)
+            if el.currency == "":
+                values.append(el)  # type: ignore
+                continue
+
+            # meaning of "quote": https://docs.ccxt.com/#/?id=market-structure
+            price_current = Decimal(str(prices_[el.currency][line.date]))
+            amount_in_quote = Decimal(0)
+            if amount_left < 0:
+                while amount_left < 0:
+                    # the maximum amount to subtract from the first element
+                    # of the balance[account][currency]
+                    amount_substract = max(
+                        -amount_left, balance[el.account][el.currency][0][1]
+                    )
+                    amount_in_quote -= (
+                        amount_substract * balance[el.account][el.currency][0][0]
+                    )
+                    amount_left += amount_substract
+
+                    # subtract the amount from the balance
+                    balance[el.account][el.currency][0] = (
+                        balance[el.account][el.currency][0][0],
+                        balance[el.account][el.currency][0][1] - amount_substract,
+                    )
+                    # remove if the amount is zero
+                    if balance[el.account][el.currency][0][1] == 0:
+                        balance[el.account][el.currency].pop(0)
+            else:
+                balance[el.account][el.currency].append((price_current, amount_left))
+                amount_in_quote = amount_left * price_current
+
+            # round the amount_in_quote
+            with localcontext() as ctx:
+                ctx.rounding = ROUND_DOWN
+                amount_in_quote = round(amount_in_quote, 0)
+
+            # append to the values of the new line
+            values.append(
+                LedgerElementImpl(
+                    account=el.account, amount=amount_in_quote, currency=""
+                )
+            )
+
+            # add to the profit
+            if is_debit(el.account) is True:
+                profit += amount_in_quote
+            else:
+                profit -= amount_in_quote
+
+        # append only if profit is not zero
+        if profit != 0:
+            values.append(
+                LedgerElementImpl(
+                    account="為替差益" if profit > 0 else "為替差損",
+                    amount=abs(profit),
+                    currency="",
+                )
+            )
+
+        # append the new line
+        lines_new.append(GeneralLedgerLineImpl(date=line.date, values=values))
+    return lines_new

aoiro/_sheets.py

@@ -0,0 +1,123 @@
+from collections.abc import Sequence
+from itertools import groupby
+from typing import Any
+
+import networkx as nx
+
+from ._ledger import Account, Currency, GeneralLedgerLine
+
+
+def get_sheets(
+    lines: Sequence[GeneralLedgerLine[Account, Currency]],
+    G: nx.DiGraph,
+    *,
+    drop: bool = True,
+) -> nx.DiGraph:
+    """
+    Get the blue return accounts as a graph.
+
+    Returns
+    -------
+    nx.DiGraph
+        Tree representation of the blue return account list.
+        Has the following attributes:
+
+        sum: dict[Currency, Decimal]
+            The sum of the children for each currency,
+            with alternating signs for each AccountType.
+
+        sum_natural: dict[Currency, Decimal]
+            The sum of the children for each currency.
+            For accounts with AccountType well-defined, the sum is not
+            altered.
+            For accounts with AccountType None, the value is the same as sum.
+
+    """
+    G = G.copy()
+    values = [value for line in lines for value in line.values]
+    grouped = {
+        k: list(v)
+        for k, v in groupby(
+            sorted(values, key=lambda x: (x.account, x.currency)),
+            key=lambda x: (x.account, x.currency),
+        )
+    }
+    grouped_nested = {
+        k: dict(v) for k, v in groupby(grouped.items(), key=lambda x: x[0][0])
+    }
+
+    # Check that all accounts are in G
+    all_accounts = set(grouped_nested.keys())
+    all_accounts_G = {d["label"] for n, d in G.nodes(data=True) if not d["abstract"]}
+    if all_accounts - all_accounts_G:
+        raise ValueError(f"{all_accounts - all_accounts_G} not in G")
+
+    # non-abstract accounts
+    met_accounts: set[Any] = set()
+    for n in reversed(list(nx.topological_sort(G))):
+        d = G.nodes[n]
+        successors = list(G.successors(n))
+        add_current = (not d["abstract"]) and d["label"] in (
+            all_accounts - met_accounts
+        )
+        if successors or add_current:
+            G.nodes[n]["sum"] = _dict_sum(
+                [G.nodes[child]["sum"] for child in successors]
+                + (
+                    [
+                        {
+                            currency: sum(el.amount for el in values)
+                            * (1 if d["account_type"].debit else -1)
+                            for (_, currency), values in grouped_nested[
+                                d["label"]
+                            ].items()
+                        }
+                    ]
+                    if add_current
+                    else []
+                )
+            )
+            if add_current:
+                met_accounts.add(d["label"])
+        else:
+            if drop:
+                G.remove_node(n)
+            else:
+                G.nodes[n]["sum"] = {}
+
+    # natural sum
+    for n, d in G.nodes(data=True):
+        account_type = d["account_type"]
+        if account_type is not None:
+            G.nodes[n]["sum_natural"] = {
+                k: v * (1 if account_type.debit else -1) for k, v in d["sum"].items()
+            }
+        else:
+            G.nodes[n]["sum_natural"] = d["sum"]
+    return G
+
+
+def _dict_sum(
+    ds: Sequence[dict[Any, Any]],
+    /,
+) -> dict[Any, Any]:
+    """
+    Sum dictionaries.
+
+    Return a dictionary which,
+    for any key in any of the dictionaries,
+    contains the sum of the values of that key in all dictionaries
+    where the key is present.
+
+    Parameters
+    ----------
+    ds : Sequence[dict[Any, Any]]
+        The dictionaries to sum.
+
+    Returns
+    -------
+    dict[Any, Any]
+        The sum of the dictionaries.
+
+    """
+    return {k: sum([d.get(k, 0) for d in ds]) for k in set().union(*ds)}