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