def test_create_portfolio_with_properties(self): _, scope, property_code, _ = self.id_generator.generate_scope_and_code( "property_definition", scope=TestDataUtilities.tutorials_scope, code_prefix="fund-style-", annotations=["Portfolio"]) data_type_id = models.ResourceId("system", "string") # property definition property_definition = models.CreatePropertyDefinitionRequest( domain="Portfolio", scope=TestDataUtilities.tutorials_scope, code=property_code, value_required=False, display_name="Fund Style", life_time="Perpetual", data_type_id=data_type_id) # create the property definition property_definition_result = self.property_definitions_api.create_property_definition( create_property_definition_request=property_definition) # property value property_value = "Active" portfolio_property = models.ModelProperty( key=property_definition_result.key, value=models.PropertyValue(label_value=property_value)) _, scope, portfolio_code = self.id_generator.generate_scope_and_code( "portfolio", scope=TestDataUtilities.tutorials_scope, code_prefix="portfolio-") # details of the portfolio to be created request = models.CreateTransactionPortfolioRequest( display_name=portfolio_code, code=portfolio_code, base_currency="GBP", # set the property value when creating the portfolio properties={property_definition_result.key: portfolio_property}) # create the portfolio portfolio = self.transaction_portfolios_api.create_portfolio( scope=scope, create_transaction_portfolio_request=request) portfolio_code = portfolio.id.code self.assertEqual(portfolio_code, request.code) portfolio_properties = self.portfolios_api.get_portfolio_properties( TestDataUtilities.tutorials_scope, portfolio_code) self.assertEqual(len(portfolio_properties.properties), 1) self.assertEqual( portfolio_properties.properties[ property_definition_result.key].value.label_value, property_value)
def test_create_portfolio_with_metric_property(self): uuid = self.get_guid() effective_date = datetime(year=2018, month=1, day=1, tzinfo=pytz.utc) # details of property to be created metric_property_definition = models.CreatePropertyDefinitionRequest( domain="Portfolio", scope=TestDataUtilities.tutorials_scope, code="fund-NAV-{}".format(uuid), display_name="fund NAV", life_time="Perpetual", value_required=False, data_type_id=models.resource_id.ResourceId( scope="system", code="currencyAndAmount")) # create property definitions metric_property_definition_result = self.property_definitions_api.create_property_definition( metric_property_definition) # create the property values metric_property_value_request = models.PropertyValue( metric_value=models.MetricValue(value=1100000, unit="GBP")) # metric_property_value_request = models.PropertyValue(label_value="Active") # Details of the new portfolio to be created, created here with the minimum set of mandatory fields create_portfolio_request = models.CreateTransactionPortfolioRequest( code="ud-{}".format(uuid), display_name="portfolio-{}".format(uuid), base_currency="GBP", created=effective_date, properties={ metric_property_definition_result.key: models.PerpetualProperty( key=metric_property_definition_result.key, value=metric_property_value_request) }) # Create portfolio portfolio_result = self.transaction_portfolios_api.create_portfolio( scope=TestDataUtilities.tutorials_scope, create_transaction_portfolio_request=create_portfolio_request) portfolio_properties = self.portfolios_api.get_portfolio_properties( scope=TestDataUtilities.tutorials_scope, code=portfolio_result.id.code).properties metric_property = portfolio_properties[ metric_property_definition_result.key] # Perform assertions on codes, keys, values and units self.assertEqual(portfolio_result.id.code, create_portfolio_request.code) self.assertEqual( list(portfolio_properties.keys())[0], metric_property_definition_result.key) self.assertEqual(metric_property.value.metric_value.value, metric_property_value_request.metric_value.value) self.assertEqual(metric_property.value.metric_value.unit, metric_property_value_request.metric_value.unit)
def create_portfolio_model(code): model = models.CreateTransactionPortfolioRequest( display_name=code, code=code, base_currency="GBP", description="Paper transaction portfolio", created="2020-02-25T00:00:00Z", ) return model
def test_create_portfolio_with_label_property(self): # Details of property to be created uuid = self.get_guid() effective_date = datetime(year=2018, month=1, day=1, tzinfo=pytz.utc) label_property_definition = models.CreatePropertyDefinitionRequest( domain="Portfolio", scope=TestDataUtilities.tutorials_scope, code="fund-style-{}".format(uuid), display_name="fund style", life_time="Perpetual", value_required=False, data_type_id=models.resource_id.ResourceId(scope="system", code="string")) # create property definition label_property_definition_request = self.property_definitions_api.create_property_definition( label_property_definition) # create property values property_value = models.PropertyValue(label_value="Active") # Details of new portfolio to be created create_portfolio_request = models.CreateTransactionPortfolioRequest( code="ud-{}".format(uuid), display_name="portfolio-{}".format(uuid), base_currency="GBP", created=effective_date, properties={ label_property_definition_request.key: models.PerpetualProperty( key=label_property_definition_request.key, value=property_value) }) # create portfolio portfolio_request = self.transaction_portfolios_api.create_portfolio( scope=TestDataUtilities.tutorials_scope, create_transaction_portfolio_request=create_portfolio_request) # get properties for assertions portfolio_properties = self.portfolios_api.get_portfolio_properties( scope=TestDataUtilities.tutorials_scope, code=portfolio_request.id.code).properties label_property = portfolio_properties[ label_property_definition_request.key] # Perform assertions on keys, codes and values self.assertEqual( list(portfolio_properties.keys())[0], label_property_definition_request.key) self.assertEqual(portfolio_request.id.code, create_portfolio_request.code) self.assertEqual(label_property.value.label_value, property_value.label_value)
def create_portfolios_if_not_exist(client, scope, data_frame, required_mapping, optional_mapping): """ This function creates portfolios :param LusidApi client: The LusidApi client to use :param str scope: The scope to create the portfolios in :param dict mapping: The mapping from the data_frame to LUSID :param pandas DataFrame data_frame: The DataFrame containing the portfolio details :param datetime created_date: The date from which the portfolios should be effective :param str accounting_method: The accounting method of the portfolios :return: dict[str: models.Portfolio]: A dict of the created portfolios keyed by the code """ responses = {} portfolio_codes_to_check = data_frame[required_mapping['code']].unique() # Get all the portfolios currently in the scope existing_portfolios_in_scope = client.portfolios.list_portfolios_for_scope( scope=scope) existing_portfolio_codes = [ portfolio.id.code for portfolio in existing_portfolios_in_scope.values ] # Determine which need to be created by excluding those that already exist portfolio_codes_to_create = list( set(portfolio_codes_to_check) - set(existing_portfolio_codes)) for code in portfolio_codes_to_create: portfolio = data_frame.loc[data_frame[required_mapping['code']] == code] # Build the request to create the portfolio request = models.CreateTransactionPortfolioRequest( display_name=portfolio[required_mapping['display_name']].values[0], code=make_code_lusid_friendly(code), created=portfolio[required_mapping['created']].values[0], base_currency=portfolio[ required_mapping['base_currency']].values[0]) for lusid_field, column_name in optional_mapping.items(): if column_name is not None: setattr(request, lusid_field, portfolio[column_name].values[0]) # Call LUSID to create the portfolio response = client.transaction_portfolios.create_portfolio( scope=scope, create_request=request) responses[code] = response return responses
def create_portfolios(api_factory, scopes, code, currency): """ This function creates a portfolio in multiple scopes. param (lusid.utilities.ClientApiFactory) api_factory: The LUSID api factory to use param (list[str]) scopes: The scopes to create the portfolio in param (str) code: The code for the portfolio param (str) currency: The base/reporting currency of the portfolio return (list[lusid.models.createportfolioresponse]) responses: The responses from creating the portfolio in each scope """ # The date your portfolio was first created portfolio_creation_date = datetime.now(pytz.UTC) - timedelta(days=5000) responses = [] for scope in scopes: try: api_factory.build(lusid.api.PortfoliosApi).delete_portfolio( scope=scope, code=code ) except lusid.ApiException as e: pass # Create the request to add your portfolio to LUSID transaction_portfolio_request = models.CreateTransactionPortfolioRequest( display_name="Global Fund", code=code, base_currency=currency, created=portfolio_creation_date, sub_holding_keys=None, ) # Call LUSID to create your portfolio response = api_factory.build( lusid.api.TransactionPortfoliosApi ).create_portfolio( scope=scope, create_transaction_portfolio_request=transaction_portfolio_request, ) responses.append(response) return responses
def test_create_portfolio(self): guid = str(uuid.uuid4()) # details of the new portfolio to be created, created here with the minimum set of mandatory fields request = models.CreateTransactionPortfolioRequest( # descriptive name for the portfolio display_name="portfolio-{0}".format(guid), # unique portfolio code, portfolio codes must be unique across scopes code="id-{0}".format(guid), base_currency="GBP") # create the portfolio in LUSID in the specified scope result = self.transaction_portfolios_api.create_portfolio( scope=TestDataUtilities.tutorials_scope, create_request=request) self.assertEqual(result.id.code, request.code)
def setup_portfolio(api_factory, portfolio_scope, portfolio_code, portfolio_created_date, properties: dict): # Create portfolio and assign the corp action source portfolio_request = models.CreateTransactionPortfolioRequest( display_name=portfolio_code, code=portfolio_code, base_currency="GBP", created=portfolio_created_date, properties=properties) try: api_factory.build(lusid.api.TransactionPortfoliosApi).create_portfolio( scope=portfolio_scope, create_transaction_portfolio_request=portfolio_request) except ApiException: print( f"Portfolio with code {portfolio_code} and scope {portfolio_scope} already exists" )
def create_transaction_portfolio(self, scope): guid = str(uuid.uuid4()) # Effective date of the portfolio, this is the date the portfolio was created and became live. # All dates/times must be supplied in UTC effective_date = datetime(2018, 1, 1, tzinfo=pytz.utc) # Details of the new portfolio to be created, created here with the minimum set of mandatory fields request = models.CreateTransactionPortfolioRequest(display_name="Portfolio-{}".format(guid), code="Id-{}".format(guid), base_currency="GBP", created=effective_date) # Create the portfolio in LUSID portfolio = self.transaction_portfolio_api.create_portfolio(scope, transaction_portfolio=request) assert (portfolio.id.code == request.code) return portfolio.id.code
def request_transaction_portfolio_creation(portfolio_code, portfolio_creation_date, analyst_scope_code, description, api_factory): # Create the request to add our portfolio transaction_portfolio_request = models.CreateTransactionPortfolioRequest( display_name=portfolio_code, code=portfolio_code, base_currency='GBP', description='Paper transaction portfolio', created=portfolio_creation_date) # Call LUSID to create our portfolio portfolio_response = api_factory.build( lusid.api.TransactionPortfoliosApi).create_portfolio( scope=analyst_scope_code, create_transaction_portfolio_request=transaction_portfolio_request) # Pretty print the response from LUSID prettyprint.portfolio_response(portfolio_response)
def create_portfolio(self): # Details of new portfolio to be created effective_date = datetime(2020, 12, 1, 0, 0, tzinfo=pytz.utc) create_portfolio_request = models.CreateTransactionPortfolioRequest( code=self.code, display_name=self.code, base_currency="GBP", created=effective_date, ) # create portfolio try: self.transaction_portfolios_api.create_portfolio( scope=self.scope, create_transaction_portfolio_request=create_portfolio_request, ) except lusid.ApiException as e: if json.loads(e.body)["name"] == "PortfolioWithIdAlreadyExists": self.root_logger.info( f"Portfolio {create_portfolio_request.code} already exists" )
def test_create_portfolio(self): _, scope, portfolio_code = self.id_generator.generate_scope_and_code( "portfolio", scope=TestDataUtilities.tutorials_scope, code_prefix="portfolio-") # details of the new portfolio to be created, created here with the minimum set of mandatory fields request = models.CreateTransactionPortfolioRequest( # descriptive name for the portfolio display_name=portfolio_code, # unique portfolio code, portfolio codes must be unique across scopes code=portfolio_code, base_currency="GBP") # create the portfolio in LUSID in the specified scope result = self.transaction_portfolios_api.create_portfolio( scope=scope, create_transaction_portfolio_request=request) self.assertEqual(result.id.code, request.code)
def test_12_pg_add_portfolios_different_scopes(self) -> None: """ Test description: ----------------- Here we test adding portfolios with multiple scopes. Expected outcome: ----------------- Request should be successful - returned with portfolios with multiple scopes. """ test_case_scope = create_scope_id() data_frame = self.csv_to_data_frame_with_scope( "data/port_group_tests/test_12_pg_add_portfolios_different_scopes.csv", self.portfolio_scope, ) port_scope_for_test = create_scope_id() self.api_factory.build(lusid.api.TransactionPortfoliosApi).create_portfolio( scope=port_scope_for_test, create_transaction_portfolio_request=models.CreateTransactionPortfolioRequest( display_name=data_frame["FundCode"][0], code=data_frame["FundCode"][0], base_currency="GBP", ), ) port_group_request = lusid.models.CreatePortfolioGroupRequest( code=data_frame["PortGroupCode"][0], display_name=data_frame["PortGroupCode"][0], values=[ lusid.models.ResourceId( code=data_frame["FundCode"][0], scope=port_scope_for_test ) ], ) self.api_factory.build(lusid.api.PortfolioGroupsApi).create_portfolio_group( scope=test_case_scope, create_portfolio_group_request=port_group_request, ) responses = self.cocoon_load_from_dataframe( scope=test_case_scope, data_frame=data_frame, ) self.log_error_requests_title("portfolio_groups", responses) self.assertTrue( expr=all( [ id in responses["portfolio_groups"]["success"][0].portfolios for id in [ lusid.models.ResourceId( code=data_frame["FundCode"][1], scope=data_frame["Scope"][1] ), lusid.models.ResourceId( code=data_frame["FundCode"][0], scope=port_scope_for_test ), lusid.models.ResourceId( code=data_frame["FundCode"][0], scope=data_frame["Scope"][0] ), lusid.models.ResourceId( code=data_frame["FundCode"][2], scope=data_frame["Scope"][2] ), ] ] ) )
token=lusid.utilities.RefreshingToken(config), api_secrets_filename=secrets_file_path) api_client = api_factory.api_client instruments_api = api_factory.build(lusid.api.InstrumentsApi) tx_portfolios_api = api_factory.build(lusid.api.TransactionPortfoliosApi) # Create a portfolio # You need to set the timezone or it will throw an error portfolio_creation_date = datetime.datetime(2021, 3, 20, tzinfo=pytz.utc) scope = "GettingStartedScope" guid = uuid.uuid4() portfolio_request = models.CreateTransactionPortfolioRequest( display_name=f"Portfolio-{guid}", code=f"Id-{guid}", base_currency="GBP", created=portfolio_creation_date) portfolio = tx_portfolios_api.create_portfolio( scope, create_transaction_portfolio_request=portfolio_request) portfolio_code = portfolio.id.code print("portfolio:", portfolio_code) # Add instruments # FIGIs are from https://www.openfigi.com/search#!?page=1 figis_to_create = { figi: models.InstrumentDefinition( name=name, identifiers={"Figi": models.InstrumentIdValue(value=figi)}) for figi, name in [("BBG000C6K6G9", "VODAFONE GROUP PLC"), ("BBG000C04D57",
def test_create_portfolio_with_mv_property(self): # Details of property to be created effective_date = datetime(year=2018, month=1, day=1, tzinfo=pytz.utc) scope = "MultiValueProperties" code = "MorningstarQuarterlyRating" portfolio_code = "Portfolio-MVP" multi_value_property_definition = models.CreatePropertyDefinitionRequest( domain="Portfolio", scope=scope, code=code, display_name=code, constraint_style="Collection", data_type_id=lusid.ResourceId(scope="system", code="string"), ) # create property definition try: self.property_definitions_api.create_property_definition( create_property_definition_request= multi_value_property_definition) except lusid.ApiException as e: if json.loads(e.body)["name"] == "PropertyAlreadyExists": logging.info( f"Property {multi_value_property_definition.domain}/{multi_value_property_definition.scope}/{multi_value_property_definition.display_name} already exists" ) finally: self.id_generator.add_scope_and_code( "property_definition", multi_value_property_definition.scope, multi_value_property_definition.code, ["Portfolio"]) schedule = [ '{ "2019-12-31" : "5"}', '{ "2020-03-31" : "4"}', '{ "2020-06-30" : "3"}', '{ "2020-09-30" : "3"}', ] # Details of new portfolio to be created create_portfolio_request = models.CreateTransactionPortfolioRequest( code=portfolio_code, display_name=portfolio_code, base_currency="GBP", created=effective_date, ) # create portfolio try: self.transaction_portfolios_api.create_portfolio( scope=scope, create_transaction_portfolio_request=create_portfolio_request, ) except lusid.ApiException as e: if json.loads(e.body)["name"] == "PortfolioWithIdAlreadyExists": logging.info( f"Portfolio {create_portfolio_request.code} already exists" ) finally: self.id_generator.add_scope_and_code("portfolio", scope, portfolio_code) self.portfolios_api.upsert_portfolio_properties( scope=scope, code=portfolio_code, request_body={ f"Portfolio/{scope}/{code}": models.ModelProperty( key=f"Portfolio/{scope}/{code}", value=models.PropertyValue( label_value_set=models.LabelValueSet(values=schedule)), ) }, ) # get properties for assertions portfolio_properties = self.portfolios_api.get_portfolio_properties( scope=scope, code=portfolio_code).properties label_value_set = portfolio_properties[ f"Portfolio/MultiValueProperties/{code}"].value.label_value_set.values self.assertCountEqual(label_value_set, schedule)
config = ApiConfigurationLoader.load(secrets_file_path) api_factory = lusid.utilities.ApiClientFactory( token=lusid.utilities.RefreshingToken(config), api_secrets_filename=secrets_file_path ) # Create portfolio tx_portfolios_api = api_factory.build(lusid.api.TransactionPortfoliosApi) scope = "GettingStartedScope" guid = uuid.uuid4() portfolio_request = models.CreateTransactionPortfolioRequest( display_name=f"Portfolio-{guid}", code=f"Id-{guid}", base_currency="GBP", created=datetime.datetime(2021, 3, 20, tzinfo=pytz.utc) ) portfolio = tx_portfolios_api.create_portfolio(scope, create_transaction_portfolio_request=portfolio_request) portfolio_code = portfolio.id.code print("Porfolio Code:", portfolio_code) # Upsert instruments instruments_api = api_factory.build(lusid.api.InstrumentsApi) # FIGI is from https://www.openfigi.com/id/BBG000C6K6G9 figis_to_create = { "BBG000C6K6G9": models.InstrumentDefinition(name="VODAFONE GROUP PLC", identifiers={"Figi": models.InstrumentIdValue(value="BBG000C6K6G9")} )