def test_ImmutableDicts(self): attr = self.transaction.to_dict() attr.pop('parties') # Remove parties so that the default constructor is used transaction = Transaction(**attr) transaction.parties.update({'TEST': Party(party_id=random_string(8))}) self.assertEqual(len(transaction.parties), 1) transaction2 = Transaction(**attr) self.assertEqual(len(transaction2.parties), 0)
def json_to_transaction(json_transaction): # Iterate through the Transaction children, converting the various JSON attributes into the relevant class type for (collection_name, clazz) in Transaction.children().items(): children = json_transaction.pop(collection_name, {}) collection = {} for (child_type, child_json) in children.items(): # Handle the case where there are multiple children for a given type - e.g. links if isinstance(child_json, list): child = set() for child_json_in_list in child_json: child.add(clazz(**child_json_in_list)) else: child = clazz(**child_json) collection[child_type] = child json_transaction[collection_name] = collection transaction_type = json_transaction.get('transaction_type') clazz = CashTransaction if transaction_type in CASH_TRANSACTION_TYPES else Transaction args = inspect.getargspec(clazz.__init__) # Some fields are always added in, even though they're not explicitly part of the constructor clazz_args = args.args + clazz.amaas_model_attributes() # is not None is important so it includes zeros and False constructor_dict = { arg: json_transaction.get(arg) for arg in clazz_args if json_transaction.get(arg) is not None and arg != 'self' } transaction = clazz(**constructor_dict) return transaction
def create_transaction(asset_manager_id, transaction_id, asset_book_id, cpty_book_id, asset_id, transaction_date, settlement_date): quantity = Decimal(random.randint(1, 1000)) price = Decimal(random.random()).quantize(Decimal('0.01')) transaction = Transaction(asset_manager_id=asset_manager_id, transaction_id=transaction_id, transaction_action=random.choice(['Buy', 'Sell']), asset_book_id=asset_book_id, counterparty_book_id=cpty_book_id, asset_id=asset_id, transaction_currency=random.choice(currencies), transaction_date=transaction_date, settlement_date=settlement_date, quantity=quantity, price=price) transaction_interface.new(transaction)
def book_transaction(asset_manager_id, asset_book_id, counterparty_book_id, asset, transaction_date, settlement_date, quantity): price = Decimal('3.92') # Price of Singtel today :-) transaction = Transaction(asset_manager_id=asset_manager_id, transaction_action='Buy', asset_book_id=asset_book_id, counterparty_book_id=counterparty_book_id, asset_id=asset.asset_id, transaction_currency=asset.currency, transaction_date=transaction_date, settlement_date=settlement_date, quantity=quantity, price=price) transaction = transaction_interface.new(transaction) return transaction.transaction_id
def main(): logging.info("--- SETTING UP IDENTIFIERS ---") asset_manager_id = random.randint(1, 2**31 - 1) asset_manager_party_id = 'AMID' + str(asset_manager_id) book_one_id = 'BOOK1' book_two_id = 'BOOK2' wash_book_id = 'WASH' broker_id = broker_book_id = 'BROKER' currency = 'JPY' # Create the books logging.info("--- SETTING UP BOOKS ---") book_one, book_two, wash_book, broker_book = create_books( asset_manager_id=asset_manager_id, asset_manager_party_id=asset_manager_party_id, book_one_id=book_one_id, book_two_id=book_two_id, wash_book_id=wash_book_id, broker_id=broker_id, broker_book_id=broker_book_id) # Create parties - obviously this normally would be a one-time setup thing logging.info("--- SETTING UP PARTIES ---") asset_manager = Company(asset_manager_id=asset_manager_id, party_id=asset_manager_party_id, base_currency=currency) parties_interface.new(asset_manager) broker = Broker(asset_manager_id=asset_manager_id, party_id=broker_id, base_currency=currency) parties_interface.new(broker) # Create assets - things like a JGB would be centrally setup with AMID 0 logging.info("--- SETTING UP ASSETS ---") jgb = create_jgb(asset_manager_id=asset_manager_id) # TEMP TEMP TEMP TEMP TEMP TEMP TEMP TEMP transaction_asset_fields = [ 'asset_manager_id', 'asset_id', 'asset_status', 'asset_class', 'asset_type', 'fungible' ] jgb_json = jgb.to_json() transaction_jgb_json = { attr: jgb_json.get(attr) for attr in transaction_asset_fields } transaction_interface.upsert_transaction_asset( transaction_asset_json=transaction_jgb_json) transaction_book_fields = [ 'asset_manager_id', 'book_id', 'party_id', 'book_status', 'description' ] for book in [book_one, book_two, wash_book, broker_book]: book_json = book.to_json() transaction_book_json = { attr: book_json.get(attr) for attr in transaction_book_fields } transaction_interface.upsert_transaction_book( transaction_book_json=transaction_book_json) # ENDTEMP ENDTEMP ENDTEMP ENDTEMP ENDTEMP ENDTEMP # Trading Activity logging.info("--- BOOKING TRADES ---") logging.info("** BUY JGB **") transaction = Transaction(asset_manager_id=asset_manager_id, transaction_action='Buy', asset_book_id=book_one_id, counterparty_book_id=broker_book_id, asset_id=jgb.asset_id, transaction_currency=jgb.currency, transaction_date=date.today(), settlement_date=date.today() + relativedelta(days=2), quantity=1e06, price=Decimal('100.487')) transaction_interface.new(transaction) logging.info("--- POSITIONS AFTER FIRST TRADE ---") positions = transaction_interface.positions_by_asset_manager( asset_manager_id=asset_manager_id) for position in positions: logging.info(' | '.join( [position.book_id, str(position.quantity), position.asset_id])) logging.info("--- DO A BOOK TRANSFER ---") transaction_interface.book_transfer(asset_manager_id=asset_manager_id, source_book_id=book_one_id, target_book_id=book_two_id, wash_book_id=wash_book_id, asset_id=jgb.asset_id, quantity=500000, price=Decimal('100.45'), currency='JPY') logging.info("--- POSITIONS AFTER BOOK TRANSFER ---") positions = transaction_interface.positions_by_asset_manager( asset_manager_id=asset_manager_id) for position in positions: logging.info(' | '.join( [position.book_id, str(position.quantity), position.asset_id]))
def generate_transaction(asset_manager_id=None, asset_book_id=None, counterparty_book_id=None, asset_id=None, quantity=None, transaction_date=None, transaction_id=None, price=None, transaction_action=None, transaction_type=None, settlement_date=None, transaction_status=None, transaction_currency=None, settlement_currency=None, net_affecting_charges=None, charge_currency=None): # Explicitly handle price is None (in case price is 0) price = Decimal(random.uniform(1.0, 1000.0)).quantize( Decimal('0.01')) if price is None else price transaction_currency = transaction_currency or random.choice( ['SGD', 'USD']) settlement_currency = settlement_currency or transaction_currency or random.choice( ['SGD', 'USD']) common = generate_common(asset_manager_id=asset_manager_id, asset_book_id=asset_book_id, counterparty_book_id=counterparty_book_id, asset_id=asset_id, quantity=quantity, transaction_date=transaction_date, transaction_id=transaction_id, transaction_action=transaction_action, transaction_status=transaction_status, transaction_type=transaction_type, settlement_date=settlement_date) transaction = Transaction(price=price, transaction_currency=transaction_currency, settlement_currency=settlement_currency, **common) charges = { charge_type: Charge(charge_value=Decimal(random.uniform(1.0, 100.0)).quantize( Decimal('0.01')), currency=charge_currency or random.choice(['USD', 'SGD']), net_affecting=net_affecting_charges or random.choice([True, False])) for charge_type in CHARGE_TYPES } links = { 'Single': Link(linked_transaction_id=random_string(8)), 'Multiple': {Link(linked_transaction_id=random_string(8)) for x in range(3)} } codes = { code_type: Code(code_value=random_string(8)) for code_type in CODE_TYPES } comments = { comment_type: Comment(comment_value=random_string(8)) for comment_type in COMMENT_TYPES } parties = { party_type: Party(party_id=random_string(8)) for party_type in PARTY_TYPES } rates = { rate_type: Rate(rate_value=Decimal(random.uniform(1.0, 100.0)).quantize( Decimal('0.01'))) for rate_type in RATE_TYPES } references = { ref_type: Reference(reference_value=random_string(10)) for ref_type in REFERENCE_TYPES } transaction.charges.update(charges) transaction.codes.update(codes) transaction.comments.update(comments) transaction.links.update(links) transaction.parties.update(parties) transaction.rates.update(rates) transaction.references.update(references) return transaction
def main(): logging.info("--- SETTING UP IDENTIFIERS ---") asset_manager_id = random.randint(1, 2**31 - 1) asset_manager_party_id = 'AMID' + str(asset_manager_id) trading_book_id = 'DEMO-BOOK' broker_id = 'BROKER' currency = 'USD' today = date.today() settlement_date = today + relativedelta(days=2) # Create the books logging.info("--- SETTING UP BOOKS ---") trading_book, broker_book = create_books( asset_manager_id=asset_manager_id, asset_manager_party_id=asset_manager_party_id, trading_book_id=trading_book_id, broker_id=broker_id) # Create parties - obviously this normally would be a one-time setup thing logging.info("--- SETTING UP PARTIES ---") asset_manager, broker = create_parties( asset_manager_id=asset_manager_id, asset_manager_party_id=asset_manager_party_id, broker_id=broker_id, base_currency=currency) # Create assets - things like HSBC would be centrally setup with AMID 0 logging.info("--- SETTING UP ASSETS ---") hsbc = create_assets(asset_manager_id=asset_manager_id) # TEMP TEMP TEMP TEMP TEMP TEMP TEMP TEMP transaction_asset_fields = [ 'asset_manager_id', 'asset_id', 'asset_status', 'asset_class', 'asset_type', 'fungible' ] hsbc_json = hsbc.to_json() transaction_hsbc_json = { attr: hsbc_json.get(attr) for attr in transaction_asset_fields } transaction_interface.upsert_transaction_asset( transaction_asset_json=transaction_hsbc_json) transaction_book_fields = [ 'asset_manager_id', 'book_id', 'party_id', 'book_status', 'description' ] trading_json = trading_book.to_json() trading_book_json = { attr: trading_json.get(attr) for attr in transaction_book_fields } transaction_interface.upsert_transaction_book( transaction_book_json=trading_book_json) broker_json = broker_book.to_json() broker_book_json = { attr: broker_json.get(attr) for attr in transaction_book_fields } transaction_interface.upsert_transaction_book( transaction_book_json=broker_book_json) # ENDTEMP ENDTEMP ENDTEMP ENDTEMP ENDTEMP ENDTEMP # Trading Activity logging.info("--- BOOKING TRADES ---") logging.info("** BUY HSBC **") transaction1 = Transaction(asset_manager_id=asset_manager_id, transaction_id='transaction1', transaction_action='Buy', asset_book_id=trading_book.book_id, counterparty_book_id=broker_book.book_id, asset_id=hsbc.asset_id, transaction_currency=hsbc.currency, transaction_date=today, settlement_date=settlement_date, quantity=Decimal('100'), price=Decimal('63')) transaction_interface.new(transaction1) logging.info("** SELL HSBC **") transaction2 = Transaction(asset_manager_id=asset_manager_id, transaction_id='transaction2', transaction_action='Sell', asset_book_id=trading_book.book_id, counterparty_book_id=broker_book.book_id, asset_id=hsbc.asset_id, transaction_currency=hsbc.currency, transaction_date=today, settlement_date=settlement_date, quantity=Decimal('50'), price=Decimal('63.5')) transaction_interface.new(transaction2) logging.info("--- SHOW TRADING POSITIONS ---") positions = transaction_interface.position_search( asset_manager_ids=[asset_manager_id], book_ids=[trading_book.book_id], accounting_types=['Transaction Date']) for position in positions: logging.info(' | '.join( [position.book_id, str(position.quantity), position.asset_id]))
def _import_transaction(asset_manager_id, rowdata): charge_columns = [ c for c in rowdata.keys() if c.startswith(CHARGES_PREFIX) ] charges = { column.replace(CHARGES_PREFIX, ''): rowdata.pop(column) for column in charge_columns if rowdata.get(column) } party_columns = [c for c in rowdata.keys() if c.startswith(PARTIES_PREFIX)] parties = { column.replace(PARTIES_PREFIX, ''): rowdata.pop(column) for column in party_columns if rowdata.get(column) } rate_columns = [c for c in rowdata.keys() if c.startswith(RATES_PREFIX)] rates = { column.replace(RATES_PREFIX, ''): rowdata.pop(column) for column in rate_columns if rowdata.get(column) } rowdata = {to_snake_case(key): value for key, value in rowdata.items()} asset_type = rowdata.pop('asset_type') if not asset_type: return asset_id = rowdata['asset_id'] settlement_date = parse(rowdata['settlement_date']) if asset_type in ['ForeignExchangeSpot', 'ForeignExchangeForward']: underlying = asset_id # this should be handled by our SDK ideally prefix, model = ('SPT', ForeignExchangeSpot) \ if asset_type == 'ForeignExchangeSpot' \ else ('FWD', ForeignExchangeForward) asset_id = f'{prefix}{asset_id}{settlement_date.strftime("%Y%m%d")}' rowdata['asset_id'] = asset_id params = { 'asset_manager_id': asset_manager_id, 'asset_id': asset_id, 'underlying': underlying, 'settlement_date': rowdata['settlement_date'], 'currency': rowdata['transaction_currency'] } if asset_type == 'ForeignExchangeForward': params['fixing_date'] = rowdata.get('fixing_date') params['forward_rate'] = rowdata['price'] asset = model(**params) asset.references['CCY Pair'] = Reference(underlying, reference_primary=True) asset_api = AssetsInterface(environment=ENVIRONMENT) existing_asset = asset_api.search(asset_manager_id=asset_manager_id, asset_ids=[asset_id]) asset = asset_api.new(asset) if not existing_asset \ else asset_api.amend(asset) transaction = Transaction(**rowdata) transaction_api = TransactionsInterface(environment=ENVIRONMENT) existing_transaction = transaction_api.search( asset_manager_id=asset_manager_id, transaction_ids=[rowdata['transaction_id']]) for party_type, party_id in parties.items(): transaction.parties[party_type] = TransactionParty(party_id) for charge_type, charge_value in charges.items(): transaction.charges[charge_type] = Charge( charge_value, rowdata['transaction_currency']) for rate_type, rate_value in rates.items(): transaction.rates[rate_type] = Rate(rate_value) if not existing_transaction: transaction_api.new(transaction) else: transaction_api.amend(transaction) return transaction
def main(): """ Main example """ logging.info("--- SETTING UP IDENTIFIERS ---") asset_manager_id = random.randint(1, 2**31-1) fund_id = 'DEMO-FUND' trader_id = 'TRADER-JOE' investor_id = 'INVESTOR1' issuance_id = 'ISSUANCE' currency = 'USD' today = date.today() tomorrow = today + relativedelta(days=1) # Create parties logging.info("--- SETTING UP PARTIES ---") create_parties(asset_manager_id=asset_manager_id, fund_id=fund_id, trader_id=trader_id, investor_id=investor_id, base_currency=currency) # Create the books logging.info("--- SETTING UP BOOKS ---") create_books(asset_manager_id=asset_manager_id, fund_id=fund_id, trader_id=trader_id, investor_id=investor_id, issuance_id=issuance_id) logging.info("--- SETTING UP FUND EQUITY ---") asset = Equity(asset_manager_id=asset_manager_id, asset_id=fund_id, asset_issuer_id=fund_id, currency=currency) assets_interface.new(asset) logging.info("--- ACQUIRE THE INITIAL FUND EQUITY TRANSACTION ---") initial_transaction = Transaction(asset_manager_id=asset_manager_id, asset_book_id=fund_id, counterparty_book_id=issuance_id, transaction_id='SHARE-CREATION', transaction_action='Acquire', asset_id=fund_id, quantity=Decimal('100'), price=Decimal('0'), transaction_date=today, settlement_date=today, transaction_currency=currency, ) transaction_interface.new(initial_transaction) logging.info("--- INVESTOR SUBSCRIBES ---") subscription = Transaction(asset_manager_id=asset_manager_id, asset_book_id=fund_id, counterparty_book_id=investor_id, transaction_id='SUBSCRIPTION-ONE', transaction_action='Subscription', asset_id=fund_id, quantity=Decimal('10'), price=Decimal('1000000'), transaction_date=today, settlement_date=tomorrow, transaction_currency=currency, ) transaction_interface.new(subscription) logging.info("--- SHOW HOLDINGS ---") positions = transaction_interface.position_search(asset_manager_ids=[asset_manager_id], asset_ids=[fund_id], accounting_types=['Transaction Date']) for position in positions: logging.info(' | '.join([position.book_id, str(position.quantity), position.asset_id]))