def main(): config = Configuration() config.host = host config.username = fds_username config.password = fds_api_key config.discard_unknown_keys = True # add proxy and/or disable ssl verification according to your development environment # config.proxy = "<proxyUrl>" config.verify_ssl = False # Setting configuration to retry api calls on http status codes of 429 and 503. config.retries = Retry(total=3, status=3, status_forcelist=frozenset([429, 503]), backoff_factor=2, raise_on_status=False) api_client = ApiClient(config) components_api = ComponentsApi(api_client) try: spar_document_name = "pmw_root:/spar_documents/Factset Default Document" spar_component_name = "Returns Table" spar_component_category = "Raw Data / Returns" spar_benchmark_1 = "R.1000" spar_benchmark_2 = "RUSSELL_P:R.2000" spar_benchmark_prefix = "RUSSELL" spar_benchmark_return_type = "GTR" startdate = "20180101" enddate = "20181231" frequency = "Monthly" currency = "USD" # uncomment the below code line to setup cache control; max-stale=0 will be a fresh adhoc run and the max-stale value is in seconds. # Results are by default cached for 12 hours; Setting max-stale=300 will fetch a cached result which is 5 minutes older. # cache_control = "max-stale=0" get_components_response = components_api.get_spar_components( spar_document_name) component_id = [ id for id in list(get_components_response[0].data.keys()) if get_components_response[0].data[id].name == spar_component_name and get_components_response[0].data[id].category == spar_component_category ][0] print("SPAR Component Id: " + component_id) spar_account_identifier = SPARIdentifier( id=spar_benchmark_1, returntype=spar_benchmark_return_type, prefix=spar_benchmark_prefix) spar_accounts = [spar_account_identifier] spar_benchmark_identifier = SPARIdentifier( id=spar_benchmark_2, returntype=spar_benchmark_return_type, prefix=spar_benchmark_prefix) spar_dates = SPARDateParameters(startdate, enddate, frequency) spar_calculation_parameters = { "1": SPARCalculationParameters(componentid=component_id, accounts=spar_accounts, benchmark=spar_benchmark_identifier, dates=spar_dates, currencyisocode=currency) } spar_calculation_parameter_root = SPARCalculationParametersRoot( data=spar_calculation_parameters) spar_calculations_api = SPARCalculationsApi(api_client) post_and_calculate_response = spar_calculations_api.post_and_calculate( spar_calculation_parameters_root=spar_calculation_parameter_root) # comment the above line and uncomment the below line to run the request with the cache_control header defined earlier # post_and_calculate_response = spar_calculations_api.post_and_calculate(spar_calculation_parameters_root=spar_calculation_parameter_root, cache_control=cache_control) if post_and_calculate_response[1] == 201: output_calculation_result(post_and_calculate_response[0]['data']) elif post_and_calculate_response[1] == 200: for (calculation_unit_id, calculation_unit ) in post_and_calculate_response[0].data.units.items(): print("Calculation Unit Id:" + calculation_unit_id + " Failed!!!") print("Error message : " + str(calculation_unit.errors)) else: calculation_id = post_and_calculate_response[0].data.calculationid print("Calculation Id: " + calculation_id) status_response = spar_calculations_api.get_calculation_status_by_id( id=calculation_id) while status_response[1] == 202 and (status_response[0].data.status in ("Queued", "Executing")): max_age = '5' age_value = status_response[2].get("cache-control") if age_value is not None: max_age = age_value.replace("max-age=", "") print('Sleeping: ' + max_age) time.sleep(int(max_age)) status_response = spar_calculations_api.get_calculation_status_by_id( calculation_id) for (calculation_unit_id, calculation_unit) in status_response[0].data.units.items(): if calculation_unit.status == "Success": print("Calculation Unit Id: " + calculation_unit_id + " Succeeded!!!") result_response = spar_calculations_api.get_calculation_unit_result_by_id( id=calculation_id, unit_id=calculation_unit_id) output_calculation_result(result_response[0]['data']) else: print("Calculation Unit Id:" + calculation_unit_id + " Failed!!!") print("Error message : " + str(calculation_unit.errors)) except ApiException as e: print("Api exception Encountered") print(e) exit()
def run_calculation(self): components_api = ComponentsApi(self.api_client) components = components_api.get_pa_components( common_parameters.pa_deafult_document) component_id = list(components.keys())[0] pa_account_identifier = PAIdentifier( common_parameters.pa_benchmark_sp500) pa_accounts = [pa_account_identifier] pa_benchmark_identifier = PAIdentifier( common_parameters.pa_benchmark_r1000) pa_benchmarks = [pa_benchmark_identifier] pa_dates = PADateParameters(common_parameters.deafult_start_date, common_parameters.deafult_end_date, common_parameters.deafult_dates_frequency) pa_calculation_parameters = { "1": PACalculationParameters(component_id, pa_accounts, pa_benchmarks, pa_dates) } components = components_api.get_spar_components( common_parameters.spar_deafult_document) component_id = list(components.keys())[0] spar_account_identifier = SPARIdentifier( common_parameters.spar_benchmark_r1000, common_parameters.spar_benchmark_russell_return_type, common_parameters.spar_benchmark_russell_prefix) spar_accounts = [spar_account_identifier] spar_benchmark_identifier = SPARIdentifier( common_parameters.spar_benchmark_r2000, common_parameters.spar_benchmark_russell_return_type, common_parameters.spar_benchmark_russell_prefix) spar_dates = SPARDateParameters( common_parameters.deafult_start_date, common_parameters.deafult_end_date, common_parameters.deafult_dates_frequency) spar_calculation_parameters = { "2": SPARCalculationParameters(component_id, spar_accounts, spar_benchmark_identifier, spar_dates) } components = components_api.get_vault_components( common_parameters.vault_deafult_document) component_id = list(components.keys())[0] vault_account_identifier = VaultIdentifier( common_parameters.vault_deafult_account) vault_dates = VaultDateParameters( common_parameters.vault_start_date, common_parameters.vault_end_date, common_parameters.deafult_dates_frequency) configurations_api = ConfigurationsApi(self.api_client) configurations = configurations_api.get_vault_configurations( common_parameters.vault_deafult_account) configuration_id = list(configurations.keys())[0] vault_calculation_parameters = { "3": VaultCalculationParameters(component_id, vault_account_identifier, vault_dates, configuration_id) } calculation = Calculation(pa_calculation_parameters, spar_calculation_parameters, vault_calculation_parameters) return self.calculations_api.run_calculation_with_http_info( calculation=calculation)
class TestComponentsApi(unittest.TestCase): def setUp(self): self.components_api = ComponentsApi(CommonFunctions.build_api_client()) ###################################################################################### # PA Components Test Cases ###################################################################################### def test_get_all_pa_components(self): response = self.components_api.get_pa_components( document=common_parameters.pa_default_document, _return_http_data_only=False) component_id = list(response[0]['data'].keys())[0] self.assertEqual(response[1], 200, "Response should be 200 - Success") self.assertEqual(type(response[0]), ComponentSummaryRoot, "Response should be of dictionary type") self.assertEqual(type(response[0]['data'][component_id]), ComponentSummary, "Response should be of ComponentSummary type") # This test encounters ApiTypeException due to response having fields set to null instead of being hidden @unittest.skip( "Skip until fix API behavior where null property is returned instead of hidden" ) def test_get_pa_component_by_id(self): components = self.components_api.get_pa_components( document=common_parameters.pa_default_document) component_id = list(components['data'].keys())[0] response = self.components_api.get_pa_component_by_id( id=component_id, _return_http_data_only=False) self.assertEqual(response[1], 200, "Response should be 200 - Success") self.assertEqual(type(response[0]), PAComponentRoot, "Response should be of PAComponentRoot type.") self.assertEqual(type(response[0]['data'][component_id]), ComponentSummary, "Response should be of ComponentSummary type") ###################################################################################### # Vault Components Test Cases ###################################################################################### def test_get_all_vault_components(self): response = self.components_api.get_vault_components( document=common_parameters.vault_default_document, _return_http_data_only=False) component_id = list(response[0]['data'].keys())[0] self.assertEqual(response[1], 200, "Response should be 200 - Success") self.assertEqual(type(response[0]), ComponentSummaryRoot, "Response should be of dictionary type") self.assertEqual(type(response[0]['data'][component_id]), ComponentSummary, "Response should be of ComponentSummary type") # This test encounters ApiTypeException due to response having fields set to null instead of being hidden @unittest.skip( "Skip until fix API behavior where null property is returned instead of hidden" ) def test_get_vault_component_by_id(self): components = self.components_api.get_vault_components( document=common_parameters.vault_default_document) component_id = list(components['data'].keys())[0] response = self.components_api.get_vault_component_by_id( component_id, _return_http_data_only=False) component_id = list(response[0]['data'].keys())[0] self.assertEqual(response[1], 200, "Response should be 200 - Success") self.assertEqual(type(response[0]['data']), VaultComponent, "Response should be of VaultComponent type.") ###################################################################################### # Spar Components Test Cases ###################################################################################### def test_get_all_spar_components(self): response = self.components_api.get_spar_components( document=common_parameters.spar_default_document, _return_http_data_only=False) component_id = list(response[0]['data'].keys())[0] self.assertEqual(response[1], 200, "Response should be 200 - Success") self.assertEqual(type(response[0]), ComponentSummaryRoot, "Response should be of dictionary type") self.assertEqual(type(response[0]['data'][component_id]), ComponentSummary, "Response should be of ComponentSummary type")
enddate = "20181231" frequency = "Monthly" config = Configuration() config.host = host config.username = username config.password = password # add proxy and/or disable ssl verification according to your development environment # config.proxy = "<proxyUrl>" config.verify_ssl = False api_client = ApiClient(config) components_api = ComponentsApi(api_client) components = components_api.get_spar_components(spar_document_name) component_id = list((dict(filter(lambda component: (component[1].name == spar_component_name and component[1].category == spar_component_category), components.items()))).keys())[0] spar_account_identifier = SPARIdentifier(spar_benchmark_r_1000, spar_benchmark_russell_return_type, spar_benchmark_russell_prefix) spar_accounts = [spar_account_identifier] spar_benchmark_identifier = SPARIdentifier(spar_benchmark_russell_pr_2000, spar_benchmark_russell_return_type, spar_benchmark_russell_prefix) spar_dates = SPARDateParameters(startdate, enddate, frequency) spar_calculation_parameters = {"2": SPARCalculationParameters(component_id, spar_accounts, spar_benchmark_identifier, spar_dates)} calculation = Calculation(spar=spar_calculation_parameters) print(calculation) calculations_api = CalculationsApi(api_client) run_calculation_response = calculations_api.run_calculation_with_http_info(calculation=calculation)
class TestSparCalculationsApi(unittest.TestCase): def setUp(self): api_client = CommonFunctions.build_api_client() self.spar_calculations_api = SPARCalculationsApi(api_client) self.components_api = ComponentsApi(api_client) def test_single_unit_scenario(self): create_step_name = "create_calculation" read_status_step_name = "read_status" read_result_step_name = "read_result" def create_calculation(test_context): print("Creating single unit calculation") components = self.components_api.get_spar_components( document="SPAR_DOCUMENTS:/Factset Default Document", _return_http_data_only=True) component_summary = ComponentSummary(name="Returns Table", category="Raw Data / Returns") component_id = [ id for id in list(components.data.keys()) if components.data[id] == component_summary ][0] spar_accounts = [SPARIdentifier(id="R.1000")] spar_benchmarks = SPARIdentifier(id="RUSSELL_P:R.2000") spar_dates = SPARDateParameters(startdate="20180101", enddate="20181231", frequency="Monthly") spar_calculation_parameters = { "1": SPARCalculationParameters(componentid=component_id, accounts=spar_accounts, benchmark=spar_benchmarks, dates=spar_dates) } spar_calculation_parameter_root = SPARCalculationParametersRoot( data=spar_calculation_parameters) post_and_calculate_response = self.spar_calculations_api.post_and_calculate( spar_calculation_parameters_root= spar_calculation_parameter_root, cache_control='max-stale=0') self.assertTrue( post_and_calculate_response[1] == 201 or post_and_calculate_response[1] == 202, "Response for create_calculation should have been 201 or 202") if post_and_calculate_response[1] == 201: return { "continue_workflow": False, "next_request": None, "test_context": None } elif post_and_calculate_response[1] == 202: test_context["calculation_id"] = post_and_calculate_response[ 2]["X-Factset-Api-Calculation-Id"] return { "continue_workflow": True, "next_request": read_status_step_name, "test_context": test_context } def read_calculation_status(test_context): print("Reading single unit calculation status") calculation_id = test_context["calculation_id"] print("Calculation Id: " + calculation_id) status_response = self.spar_calculations_api.get_calculation_status_by_id( id=calculation_id) self.assertTrue( status_response[1] == 202 and (status_response[0].data.status in ("Queued", "Executing"))) while status_response[1] == 202 and (status_response[0].data.status in ("Queued", "Executing")): max_age = '5' age_value = status_response[2].get("cache-control") if age_value is not None: max_age = age_value.replace("max-age=", "") print('Sleeping: ' + max_age) time.sleep(int(max_age)) status_response = self.spar_calculations_api.get_calculation_status_by_id( id=calculation_id) test_context["calculation_units"] = status_response[ 0].data.units.items() return { "continue_workflow": True, "next_request": read_result_step_name, "test_context": test_context } def read_calculation_unit_result(test_context): calculation_id = test_context["calculation_id"] for (calculation_unit_id, calculation_unit) in test_context["calculation_units"]: result_response = self.spar_calculations_api.get_calculation_unit_result_by_id( id=calculation_id, unit_id=calculation_unit_id) self.assertEqual( result_response[1], 200, "Get calculation result should have succeeded") workflow_specification = { create_step_name: create_calculation, read_status_step_name: read_calculation_status, read_result_step_name: read_calculation_unit_result } starting_request = workflow_specification['create_calculation'] test_context = {} run_api_workflow_with_assertions(workflow_specification, starting_request, test_context)