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]))
