def __init__(self,
account: Account,
balance_time: Optional[datetime] = None,
denomination: Optional[Denomination] = None) -> None:
if not isinstance(account, Account):
raise TypeError('account must be of type Account')
if (balance_time is not None
and not isinstance(balance_time, datetime)):
raise TypeError(
'balance_time must be of type `datetime or None')
if (denomination is not None
and not isinstance(denomination, Denomination)):
raise TypeError('denomination must conform to `Denomination`')
if denomination is None:
denomination = account.denomination
self._account = account
self._balance_time = None
if balance_time:
self._balance_time = AmatinoTime(balance_time)
self._denomination = denomination
def decode(
cls: Type[T],
entity: Entity,
data: Any
) -> T:
if not isinstance(data, dict):
raise UnexpectedResponseType(data, dict)
try:
income = None
if data['income'] is not None:
income = TreeNode.decode_many(entity, data['income'])
expenses = None
if data['expenses'] is not None:
expenses = TreeNode.decode_many(entity, data['expenses'])
performance = cls(
entity=entity,
start_time=AmatinoTime.decode(data['start_time']),
end_time=AmatinoTime.decode(data['end_time']),
generated_time=AmatinoTime.decode(data['generated_time']),
custom_unit_id=data['custom_unit_denomination'],
global_unit_id=data['global_unit_denomination'],
income=income,
expenses=expenses,
depth=data['depth']
)
except KeyError as error:
raise MissingKey(error.args[0])
return performance
def __init__(
self,
start_time: datetime,
end_time: datetime,
denomination: Denomination,
depth: Optional[int] = None
) -> None:
if not isinstance(start_time, datetime):
raise TypeError('start_time must be of type `datetime`')
if not isinstance(end_time, datetime):
raise TypeError('end_time must be of type `datetime`')
if not isinstance(denomination, Denomination):
raise TypeError('denomination must be of type `Denomination`')
if depth is not None and not isinstance(depth, int):
raise TypeError(
'If supplied, depth must be of type `int`'
)
self._start_time = AmatinoTime(start_time)
self._end_time = AmatinoTime(end_time)
self._denomination = denomination
self._depth = depth
return
def serialise(self) -> Dict[str, Any]:
global_unit_id = None
custom_unit_id = None
if isinstance(self._denomination, GlobalUnit):
global_unit_id = self._denomination.id_
else:
assert isinstance(self._denomination, CustomUnit)
custom_unit_id = self._denomination.id_
start_time = None
if self._start_time:
start_time = AmatinoTime(self._start_time).serialise()
end_time = None
if self._end_time:
end_time = AmatinoTime(self._end_time).serialise()
data = {
'account_id': self._account.id_,
'start_time': start_time,
'end_time': end_time,
'page': self._page,
'global_unit_denomination': global_unit_id,
'custom_unit_denomination': custom_unit_id,
'order_oldest_first': self._order.value
}
return data
def decode(
cls: Type[T],
entity: Entity,
data: Any
) -> T:
if not isinstance(data, dict):
raise UnexpectedResponseType(data, dict)
try:
if data['assets'] is None:
data['assets'] = list()
if data['liabilities'] is None:
data['liabilities'] = list()
if data['equities'] is None:
data['equities'] = list()
position = cls(
entity=entity,
balance_time=AmatinoTime.decode(data['balance_time']),
generated_time=AmatinoTime.decode(data['generated_time']),
global_unit_id=data['global_unit_denomination'],
custom_unit_id=data['custom_unit_denomination'],
assets=TreeNode.decode_many(entity, data['assets']),
liabilities=TreeNode.decode_many(entity, data['liabilities']),
equities=TreeNode.decode_many(entity, data['equities']),
depth=data['depth']
)
except KeyError as error:
raise MissingKey(error.args[0])
return position
def __init__(
self,
balance_time: datetime,
denomination: Denomination
) -> None:
if not isinstance(balance_time, datetime):
raise TypeError('balance_time must be of type `datetime`')
if not isinstance(denomination, Denomination):
raise TypeError('denomination must be of type `denomination`')
self._balance_time = AmatinoTime(balance_time)
self._denomination = denomination
class RetrieveArguments(Encodable):
def __init__(
self,
start_time: datetime,
end_time: datetime,
denomination: Denomination,
depth: Optional[int] = None
) -> None:
if not isinstance(start_time, datetime):
raise TypeError('start_time must be of type `datetime`')
if not isinstance(end_time, datetime):
raise TypeError('end_time must be of type `datetime`')
if not isinstance(denomination, Denomination):
raise TypeError('denomination must be of type `Denomination`')
if depth is not None and not isinstance(depth, int):
raise TypeError(
'If supplied, depth must be of type `int`'
)
self._start_time = AmatinoTime(start_time)
self._end_time = AmatinoTime(end_time)
self._denomination = denomination
self._depth = depth
return
def serialise(self) -> Dict[str, Any]:
global_unit_id = None
custom_unit_id = None
if isinstance(self._denomination, GlobalUnit):
global_unit_id = self._denomination.id_
else:
assert isinstance(self._denomination, CustomUnit)
custom_unit_id = self._denomination.id_
data = {
'start_time': self._start_time.serialise(),
'end_time': self._end_time.serialise(),
'custom_unit_denomination': custom_unit_id,
'global_unit_denomination': global_unit_id,
'depth': self._depth
}
return data
class RetrieveArguments(Encodable):
def __init__(
self,
balance_time: datetime,
denomination: Denomination
) -> None:
if not isinstance(balance_time, datetime):
raise TypeError('balance_time must be of type `datetime`')
if not isinstance(denomination, Denomination):
raise TypeError('denomination must be of type `denomination`')
self._balance_time = AmatinoTime(balance_time)
self._denomination = denomination
def serialise(self) -> Dict[str, Any]:
global_unit_id = None
custom_unit_id = None
if isinstance(self._denomination, GlobalUnit):
global_unit_id = self._denomination.id_
else:
assert isinstance(self._denomination, CustomUnit)
custom_unit_id = self._denomination.id_
data = {
'balance_time': self._balance_time.serialise(),
'custom_unit_denomination': custom_unit_id,
'global_unit_denomination': global_unit_id
}
return data
class UpdateArguments(Encodable):
def __init__(self,
transaction: T,
time: Optional[datetime] = None,
entries: Optional[List[Entry]] = None,
denomination: Optional[Denomination] = None,
description: Optional[str] = None) -> None:
if not isinstance(transaction, Transaction):
raise TypeError('transaction must be of type `Transaction`')
self._transaction_id = transaction.id_
if time:
if not isinstance(time, datetime):
raise TypeError('time must be of type `datetime`')
self._time = AmatinoTime(time)
else:
self._time = AmatinoTime(transaction.time)
if entries:
self._entries = Transaction._Entries(entries)
else:
self._entries = Transaction._Entries(transaction.entries)
if denomination:
if not isinstance(denomination, Denomination):
raise TypeError(
'demomination must be of type `Denomination`')
self._denomination = denomination
else:
self._denomination = transaction.denomination
if description:
self._description = Transaction._Description(description)
else:
self._description = Transaction._Description(
transaction.description)
return
def serialise(self) -> Dict[str, Any]:
if isinstance(self._denomination, CustomUnit):
custom_unit_id = self._denomination.id_
global_unit_id = None
else:
custom_unit_id = None
global_unit_id = self._denomination.id_
data = {
'transaction_id': self._transaction_id,
'transaction_time': self._time.serialise(),
'custom_unit_denomination': custom_unit_id,
'global_unit_denomination': global_unit_id,
'description': self._description.serialise(),
'entries': self._entries.serialise()
}
return data
def decode(data: dict) -> T:
if not isinstance(data, dict):
raise ApiError('Unexpected non-dict data returned')
try:
transaction = cls(
entity=entity,
transaction_id=data['transaction_id'],
transaction_time=AmatinoTime.decode(
data['transaction_time']),
version_time=AmatinoTime.decode(data['version_time']),
description=data['description'],
entries=cls._decode_entries(data['entries']),
global_unit_id=data['global_unit_denomination'],
custom_unit_id=data['custom_unit_denomination'])
except KeyError as error:
raise MissingKey(error.args[0])
return transaction
def decode(cls: Type[T], entity: Entity, data: Any) -> T:
if not isinstance(data, dict):
raise UnexpectedResponseType(data, dict)
try:
tree = cls(
entity=entity,
balance_time=AmatinoTime.decode(data['balance_time']),
generated_time=AmatinoTime.decode(data['generated_time']),
global_unit_denomination=data['global_unit_denomination'],
custom_unit_denomination=data['custom_unit_denomination'],
tree=TreeNode.decode_many(entity, data['tree'])
)
except KeyError as error:
raise MissingKey(error.args[0])
return tree
def __init__(
self,
time: datetime,
entries: List[Entry],
denomination: Denomination,
description: Optional[str] = None,
) -> None:
if not isinstance(time, datetime):
raise TypeError('time must be of type `datetime.datetime`')
if not isinstance(denomination, Denomination):
raise TypeError('denomination must be of type `Denomination`')
self._time = AmatinoTime(time)
self._denomination = denomination
self._entries = Transaction._Entries(entries)
self._description = Transaction._Description(description)
return
def _decode_many(cls: Type[T], entity: Entity, data: Any) -> List[T]:
if not isinstance(data, list):
raise UnexpectedResponseType(data, list)
for balance in data:
if not isinstance(balance, dict):
raise UnexpectedResponseType(balance, dict)
balances = list()
for balance in data:
balances.append(
cls(entity, AmatinoTime.decode(balance['balance_time']),
AmatinoTime.decode(balance['generated_time']),
balance['recursive'], balance['global_unit_denomination'],
balance['custom_unit_denomination'], balance['account_id'],
Decimal(balance['balance'])))
return balances
def __init__(self,
account: Account,
order: LedgerOrder = LedgerOrder.YOUNGEST_FIRST,
page: int = 1,
start_time: Optional[datetime] = None,
end_time: Optional[datetime] = None,
denomination: Optional[Denomination] = None) -> None:
if not isinstance(account, Account):
raise TypeError('account must be of type `Account`')
if not isinstance(order, LedgerOrder):
raise TypeError('order must beof type `LedgerOrder`')
if not isinstance(page, int):
raise TypeError('page must be of type `int`')
if start_time and not isinstance(start_time, datetime):
raise TypeError(
'start_time must be of type `datetime` or None')
if end_time and not isinstance(end_time, datetime):
raise TypeError('end_time must be of type `datetime` or None')
if denomination and not isinstance(denomination, Denomination):
raise TypeError(
'denomination must be of type `Denomination` or None')
if denomination is None:
denomination = account.denomination
self._account = account
self._order = order
self._page = page
self._start_time = None
if start_time:
self._start_time = AmatinoTime(start_time)
self._end_time = None
if end_time:
self._end_time = AmatinoTime(end_time)
self._denomination = denomination
def __init__(self,
transaction: T,
time: Optional[datetime] = None,
entries: Optional[List[Entry]] = None,
denomination: Optional[Denomination] = None,
description: Optional[str] = None) -> None:
if not isinstance(transaction, Transaction):
raise TypeError('transaction must be of type `Transaction`')
self._transaction_id = transaction.id_
if time:
if not isinstance(time, datetime):
raise TypeError('time must be of type `datetime`')
self._time = AmatinoTime(time)
else:
self._time = AmatinoTime(transaction.time)
if entries:
self._entries = Transaction._Entries(entries)
else:
self._entries = Transaction._Entries(transaction.entries)
if denomination:
if not isinstance(denomination, Denomination):
raise TypeError(
'demomination must be of type `Denomination`')
self._denomination = denomination
else:
self._denomination = transaction.denomination
if description:
self._description = Transaction._Description(description)
else:
self._description = Transaction._Description(
transaction.description)
return
class RetrieveArguments(Encodable):
def __init__(self,
account: Account,
balance_time: Optional[datetime] = None,
denomination: Optional[Denomination] = None) -> None:
if not isinstance(account, Account):
raise TypeError('account must be of type Account')
if (balance_time is not None
and not isinstance(balance_time, datetime)):
raise TypeError(
'balance_time must be of type `datetime or None')
if (denomination is not None
and not isinstance(denomination, Denomination)):
raise TypeError('denomination must conform to `Denomination`')
if denomination is None:
denomination = account.denomination
self._account = account
self._balance_time = None
if balance_time:
self._balance_time = AmatinoTime(balance_time)
self._denomination = denomination
def serialise(self) -> Dict[str, Any]:
global_unit_id = None
custom_unit_id = None
if isinstance(self._denomination, GlobalUnit):
global_unit_id = self._denomination.id_
else:
assert isinstance(self._denomination, CustomUnit)
custom_unit_id = self._denomination.id_
balance_time = None
if self._balance_time:
balance_time = self._balance_time.serialise()
data = {
'account_id': self._account.id_,
'balance_time': balance_time,
'custom_unit_denomination': custom_unit_id,
'global_unit_denomination': global_unit_id
}
return data
def _decode(cls: Type[T], entity: Entity, data: Any) -> T:
if not isinstance(data, dict):
raise UnexpectedResponseType(type(data), dict)
try:
ledger = cls(entity=entity,
account_id=data['account_id'],
start_time=AmatinoTime.decode(data['start_time']),
end_time=AmatinoTime.decode(data['end_time']),
recursive=data['recursive'],
generated_time=AmatinoTime.decode(
data['generated_time']),
global_unit_id=data['global_unit_denomination'],
custom_unit_id=data['custom_unit_denomination'],
ledger_rows=Ledger._decode_rows(data['ledger_rows']),
page=data['page'],
number_of_pages=data['number_of_pages'],
order=LedgerOrder(data['ordered_oldest_first']))
except KeyError as error:
raise MissingKey(error.args[0])
return ledger
def decode(data) -> LedgerRow:
if not isinstance(data, list):
raise UnexpectedResponseType(data, list)
row = LedgerRow(transaction_id=data[0],
transaction_time=AmatinoTime.decode(data[1]),
description=data[2],
opposing_account_id=data[3],
opposing_account_name=data[4],
debit=AmatinoAmount.decode(data[5]),
credit=AmatinoAmount.decode(data[6]),
balance=AmatinoAmount.decode(data[7]))
return row
def decode(cls: Type[T], session: Session, data: Any) -> T:
if not isinstance(data, dict):
raise ApiError('Unexpected data type returned: ' + str(type(data)))
try:
user_list = cls(page=data['page'],
number_of_pages=data['number_of_pages'],
generated_time=AmatinoTime.decode(
data['generated_time']),
state=State(data['state']),
users=User.decode_many(session, data['users']),
session=session)
except KeyError as error:
raise MissingKey(error.args[0])
return user_list
class CreateArguments(Encodable):
def __init__(
self,
time: datetime,
entries: List[Entry],
denomination: Denomination,
description: Optional[str] = None,
) -> None:
if not isinstance(time, datetime):
raise TypeError('time must be of type `datetime.datetime`')
if not isinstance(denomination, Denomination):
raise TypeError('denomination must be of type `Denomination`')
self._time = AmatinoTime(time)
self._denomination = denomination
self._entries = Transaction._Entries(entries)
self._description = Transaction._Description(description)
return
def serialise(self) -> Dict[str, Any]:
if isinstance(self._denomination, CustomUnit):
custom_unit_id = self._denomination.id_
global_unit_id = None
else:
custom_unit_id = None
global_unit_id = self._denomination.id_
data = {
'transaction_time': self._time.serialise(),
'custom_unit_denomination': custom_unit_id,
'global_unit_denomination': global_unit_id,
'description': self._description.serialise(),
'entries': self._entries.serialise()
}
return data
