def interval_balances(self, interval, account_name, accumulate=False):
"""Balances by interval.
Arguments:
interval: An interval.
account_name: An account name.
accumulate: A boolean, ``True`` if the balances for an interval
should include all entries up to the end of the interval.
Returns:
A list of RealAccount instances for all the intervals.
"""
min_accounts = [
account for account in self.accounts.keys()
if account.startswith(account_name)
]
interval_tuples = list(
reversed(list(pairwise(self.interval_ends(interval)))))
interval_balances = [
realization.realize(
list(
iter_entry_dates(
self.entries,
datetime.date.min if accumulate else begin_date,
end_date,
)),
min_accounts,
) for begin_date, end_date in interval_tuples
]
return interval_balances, interval_tuples
def interval_totals(
self,
interval: Interval,
accounts: Union[str, Tuple[str]],
conversion: str,
):
"""Renders totals for account (or accounts) in the intervals.
Args:
interval: An interval.
accounts: A single account (str) or a tuple of accounts.
conversion: The conversion to use.
"""
price_map = self.ledger.price_map
for begin, end in pairwise(self.ledger.interval_ends(interval)):
inventory = Inventory()
entries = iter_entry_dates(self.ledger.entries, begin, end)
for entry in (e for e in entries if isinstance(e, Transaction)):
for posting in entry.postings:
if posting.account.startswith(accounts):
inventory.add_position(posting)
yield {
"date":
begin,
"balance":
cost_or_value(inventory, conversion, price_map, end - ONE_DAY),
"budgets":
self.ledger.budgets.calculate_children(accounts, begin, end),
}
def interval_balances(self, interval, account_name, accumulate=False):
"""Balances by interval.
Arguments:
interval: An interval.
account_name: An account name.
accumulate: A boolean, ``True`` if the balances for an interval
should include all entries up to the end of the interval.
Returns:
A list of RealAccount instances for all the intervals.
"""
min_accounts = [
account for account in
self.accounts.keys()
if account.startswith(account_name)]
interval_tuples = list(
reversed(list(pairwise(self.interval_ends(interval))))
)
interval_balances = [
realization.realize(list(iter_entry_dates(
self.entries,
datetime.date.min if accumulate else begin_date,
end_date)), min_accounts)
for begin_date, end_date in interval_tuples]
return interval_balances, interval_tuples
def interval_totals(
self,
filtered: FilteredLedger,
interval: Interval,
accounts: str | tuple[str],
conversion: str,
invert: bool = False,
) -> Generator[DateAndBalanceWithBudget, None, None]:
"""Renders totals for account (or accounts) in the intervals.
Args:
interval: An interval.
accounts: A single account (str) or a tuple of accounts.
conversion: The conversion to use.
invert: invert all numbers.
"""
# pylint: disable=too-many-locals
price_map = self.ledger.price_map
for begin, end in pairwise(filtered.interval_ends(interval)):
inventory = Inventory()
entries = iter_entry_dates(filtered.entries, begin, end)
account_inventories = {}
for entry in (e for e in entries if isinstance(e, Transaction)):
for posting in entry.postings:
if posting.account.startswith(accounts):
if posting.account not in account_inventories:
account_inventories[posting.account] = Inventory()
account_inventories[posting.account].add_position(
posting)
inventory.add_position(posting)
balance = cost_or_value(inventory, conversion, price_map,
end - ONE_DAY)
account_balances = {}
for account, acct_value in account_inventories.items():
account_balances[account] = cost_or_value(
acct_value,
conversion,
price_map,
end - ONE_DAY,
)
budgets = {}
if isinstance(accounts, str):
budgets = self.ledger.budgets.calculate_children(
accounts, begin, end)
if invert:
# pylint: disable=invalid-unary-operand-type
balance = -balance
budgets = {k: -v for k, v in budgets.items()}
account_balances = {k: -v for k, v in account_balances.items()}
yield DateAndBalanceWithBudget(
begin,
balance,
account_balances,
budgets,
)
def interval_totals(
self,
interval: Interval,
accounts: Union[str, Tuple[str]],
conversion: str,
invert: bool = False,
) -> Generator[DateAndBalanceWithBudget, None, None]:
"""Renders totals for account (or accounts) in the intervals.
Args:
interval: An interval.
accounts: A single account (str) or a tuple of accounts.
conversion: The conversion to use.
"""
price_map = self.ledger.price_map
for begin, end in pairwise(self.ledger.interval_ends(interval)):
inventory = Inventory()
entries = iter_entry_dates(self.ledger.entries, begin, end)
for entry in (e for e in entries if isinstance(e, Transaction)):
for posting in entry.postings:
if posting.account.startswith(accounts):
inventory.add_position(posting)
balance = cost_or_value(
inventory, conversion, price_map, end - ONE_DAY
)
budgets = {}
if isinstance(accounts, str):
budgets = self.ledger.budgets.calculate_children(
accounts, begin, end
)
if invert:
# pylint: disable=invalid-unary-operand-type
balance = -balance
budgets = {k: -v for k, v in budgets.items()}
yield {
"date": begin,
"balance": balance,
"budgets": budgets,
}
def interval_balances(
self,
filtered: FilteredLedger,
interval: date.Interval,
account_name: str,
accumulate: bool = False,
) -> tuple[list[realization.RealAccount], list[tuple[datetime.date,
datetime.date]], ]:
"""Balances by interval.
Arguments:
filtered: The currently filtered ledger.
interval: An interval.
account_name: An account name.
accumulate: A boolean, ``True`` if the balances for an interval
should include all entries up to the end of the interval.
Returns:
A list of RealAccount instances for all the intervals.
"""
min_accounts = [
account for account in self.accounts.keys()
if account.startswith(account_name)
]
interval_tuples = list(
reversed(list(pairwise(filtered.interval_ends(interval)))))
interval_balances = [
realization.realize(
list(
iter_entry_dates(
filtered.entries,
datetime.date.min if accumulate else begin_date,
end_date,
)),
min_accounts,
) for begin_date, end_date in interval_tuples
]
return interval_balances, interval_tuples
def interval_totals(self, interval, accounts):
"""Renders totals for account (or accounts) in the intervals.
Args:
interval: An interval.
accounts: A single account (str) or a tuple of accounts.
"""
for begin, end in pairwise(self.ledger.interval_ends(interval)):
inventory = CounterInventory()
entries = iter_entry_dates(self.ledger.entries, begin, end)
for entry in filter_type(entries, Transaction):
for posting in entry.postings:
if posting.account.startswith(accounts):
inventory.add_position(posting)
yield {
'date': begin,
'balance': cost_or_value(inventory, end),
'budgets':
self.ledger.budgets.calculate_children(accounts, begin, end),
}
def interval_totals(self, interval, accounts):
"""Renders totals for account (or accounts) in the intervals.
Args:
interval: A string for the interval.
accounts: A single account (str) or a tuple of accounts.
"""
for begin, end in pairwise(self.ledger.interval_ends(interval)):
inventory = Inventory()
entries = iter_entry_dates(self.ledger.entries, begin, end)
for entry in filter_type(entries, Transaction):
for posting in entry.postings:
if posting.account.startswith(accounts):
inventory.add_position(posting)
yield {
'begin_date': begin,
'totals': _inventory_cost_or_value(inventory, end),
'budgets':
self.ledger.budgets.calculate(accounts[0], begin, end),
}
def interval_totals(self, interval, accounts):
"""Renders totals for account (or accounts) in the intervals.
Args:
interval: An interval.
accounts: A single account (str) or a tuple of accounts.
"""
for begin, end in pairwise(self.ledger.interval_ends(interval)):
inventory = CounterInventory()
entries = iter_entry_dates(self.ledger.entries, begin, end)
for entry in filter_type(entries, Transaction):
for posting in entry.postings:
if posting.account.startswith(accounts):
inventory.add_position(posting)
yield {
"date": begin,
"balance": cost_or_value(inventory, end),
"budgets": self.ledger.budgets.calculate_children(
accounts, begin, end
),
}
def test_pairwise():
assert list(pairwise([1, 2, 3])) == [(1, 2), (2, 3)]
assert list(pairwise([])) == []
def test_pairwise() -> None:
assert list(pairwise([1, 2, 3])) == [(1, 2), (2, 3)]
assert not list(pairwise([]))
def test_pairwise():
assert list(pairwise([1, 2, 3])) == [(1, 2), (2, 3)]
assert list(pairwise([])) == []
