def test_get_last_price_entries(self, entries, _, __):
"""
2013-01-01 price USD 1.01 CAD
2013-02-01 price USD 1.02 CAD
2013-03-01 price USD 1.03 CAD
2013-04-01 price USD 1.04 CAD
2013-05-01 price USD 1.05 CAD
2013-06-01 price USD 1.06 CAD
2013-07-01 price USD 1.07 CAD
"""
self.assertEqualEntries(
"""
2013-04-01 price USD 1.04 CAD
""", prices.get_last_price_entries(entries, datetime.date(2013, 5, 1)))
self.assertEqualEntries(
"""
2013-05-01 price USD 1.05 CAD
""", prices.get_last_price_entries(entries, datetime.date(2013, 5, 2)))
self.assertEqualEntries(
"""
2013-07-01 price USD 1.07 CAD
""", prices.get_last_price_entries(entries, datetime.date(2014, 1, 1)))
self.assertEqualEntries(
"""
""", prices.get_last_price_entries(entries, datetime.date(2012, 1, 1)))
def get_holdings_entries(entries, options_map):
"""Summarizes the entries to list of entries representing the final holdings..
This list includes the latest prices entries as well. This can be used to
load a full snapshot of holdings without including the entire history. This
is a way of summarizing a balance sheet in a way that filters away history.
Args:
entries: A list of directives.
options_map: A dict of parsed options.
Returns:
A string, the entries to print out.
"""
# The entries will be created at the latest date, against an equity account.
latest_date = entries[-1].date
_, equity_account, _ = options.get_previous_accounts(options_map)
# Get all the assets.
holdings_list, _ = holdings.get_assets_holdings(entries, options_map)
# Create synthetic entries for them.
holdings_entries = []
for index, holding in enumerate(holdings_list):
meta = data.new_metadata('report_holdings_print', index)
entry = data.Transaction(meta, latest_date, flags.FLAG_SUMMARIZE, None,
"", None, None, [])
# Convert the holding to a position.
pos = holdings.holding_to_position(holding)
entry.postings.append(
data.Posting(holding.account, pos.units, pos.cost, None, None,
None))
cost = -convert.get_cost(pos)
entry.postings.append(
data.Posting(equity_account, cost, None, None, None, None))
holdings_entries.append(entry)
# Get opening directives for all the accounts.
used_accounts = {holding.account for holding in holdings_list}
open_entries = summarize.get_open_entries(entries, latest_date)
used_open_entries = [
open_entry for open_entry in open_entries
if open_entry.account in used_accounts
]
# Add an entry for the equity account we're using.
meta = data.new_metadata('report_holdings_print', -1)
used_open_entries.insert(
0, data.Open(meta, latest_date, equity_account, None, None))
# Get the latest price entries.
price_entries = prices.get_last_price_entries(entries, None)
return used_open_entries + holdings_entries + price_entries
def reload(self):
if self.transaction is not None:
self.log.warn("Discard transactions due to reload")
self.log.warn(format_entry(self.transaction))
entries, errors, options_map = loader.load_file(self.filename)
assert(len(errors) == 0)
self.entries = entries
self.options_map = options_map
self.transaction = None
# Commonly used transformations of the entries
self.price_entries = prices.get_last_price_entries(entries, datetime.date.today())
self.accounts = realization.realize(self.entries)
def summarize(entries, date, account_opening):
"""Summarize all entries before a date by replacing then with summarization entries.
This function replaces the transactions up to (and not including) the given
date with a opening balance transactions, one for each account. It returns
new entries, all of the transactions before the given date having been
replaced by a few summarization entries, one for each account.
Notes:
- Open entries are preserved for active accounts.
- The last relevant price entry for each (base, quote) pair is preserved.
- All other entries before the cutoff date are culled.
Args:
entries: A list of directives.
date: A datetime.date instance, the cutoff date before which to summararize.
account_opening: A string, the name of the source account to book summarization
entries against.
Returns:
The function returns a list of new entries and the integer index at which
the entries on or after the cutoff date begin.
"""
# Compute balances at date.
balances, index = balance_by_account(entries, date)
# We need to insert the entries with a date previous to subsequent checks,
# to maintain ensure the open directives show up before any transaction.
summarize_date = date - datetime.timedelta(days=1)
# Create summarization / opening balance entries.
summarizing_entries = create_entries_from_balances(
balances, summarize_date, account_opening, True,
data.new_metadata('<summarize>', 0), flags.FLAG_SUMMARIZE,
"Opening balance for '{account}' (Summarization)")
# Insert the last price entry for each commodity from before the date.
price_entries = prices.get_last_price_entries(entries, date)
# Gather the list of active open entries at date.
open_entries = get_open_entries(entries, date)
# Compute entries before the date and preserve the entries after the date.
before_entries = sorted(open_entries + price_entries + summarizing_entries,
key=data.entry_sortkey)
after_entries = entries[index:]
# Return a new list of entries and the index that points after the entries
# were inserted.
return (before_entries + after_entries), len(before_entries)
