def __init__(self, componentid=None, accounts=None, benchmarks=None, dates=None, groups=None, currencyisocode=None, columns=None, local_vars_configuration=None): # noqa: E501
"""PACalculationParameters - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._componentid = None
self._accounts = None
self._benchmarks = None
self._dates = None
self._groups = None
self._currencyisocode = None
self._columns = None
self.discriminator = None
self.componentid = componentid
if accounts is not None:
self.accounts = accounts
if benchmarks is not None:
self.benchmarks = benchmarks
if dates is not None:
self.dates = dates
if groups is not None:
self.groups = groups
if currencyisocode is not None:
self.currencyisocode = currencyisocode
if columns is not None:
self.columns = columns
def __init__(self, benchmark_code=None, benchmark_name=None, max_end_date=None, min_start_date=None, locking_date=None, name=None, local_vars_configuration=None): # noqa: E501
"""ConfigurationAccount - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._benchmark_code = None
self._benchmark_name = None
self._max_end_date = None
self._min_start_date = None
self._locking_date = None
self._name = None
self.discriminator = None
if benchmark_code is not None:
self.benchmark_code = benchmark_code
if benchmark_name is not None:
self.benchmark_name = benchmark_name
if max_end_date is not None:
self.max_end_date = max_end_date
if min_start_date is not None:
self.min_start_date = min_start_date
if locking_date is not None:
self.locking_date = locking_date
if name is not None:
self.name = name
def __init__(self,
defaultstatisticsids=None,
name=None,
directory=None,
category=None,
local_vars_configuration=None): # noqa: E501
"""Column - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._defaultstatisticsids = None
self._name = None
self._directory = None
self._category = None
self.discriminator = None
if defaultstatisticsids is not None:
self.defaultstatisticsids = defaultstatisticsids
if name is not None:
self.name = name
if directory is not None:
self.directory = directory
if category is not None:
self.category = category
def __init__(self, id=None, local_vars_configuration=None): # noqa: E501
"""VaultIdentifier - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._id = None
self.discriminator = None
self.id = id
def __init__(self, id=None, local_vars_configuration=None): # noqa: E501
"""PACalculationGroup - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._id = None
self.discriminator = None
if id is not None:
self.id = id
def __init__(self, name=None, local_vars_configuration=None): # noqa: E501
"""Currency - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._name = None
self.discriminator = None
if name is not None:
self.name = name
def __init__(self, startdate=None, enddate=None, frequency=None, local_vars_configuration=None): # noqa: E501
"""PADateParameters - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._startdate = None
self._enddate = None
self._frequency = None
self.discriminator = None
if startdate is not None:
self.startdate = startdate
self.enddate = enddate
self.frequency = frequency
def __init__(self,
id=None,
holdingsmode=None,
local_vars_configuration=None): # noqa: E501
"""PAIdentifier - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._id = None
self._holdingsmode = None
self.discriminator = None
self.id = id
if holdingsmode is not None:
self.holdingsmode = holdingsmode
def build_api_client():
if (common_parameters.user_name and common_parameters.password):
config = Configuration()
config.host = common_parameters.base_url
config.username = common_parameters.user_name
config.password = common_parameters.password
config.discard_unknown_keys = True
config.verify_ssl = False
return ApiClient(config)
raise ValueError(
"Please set ANALYTICS_API_QAR_USERNAME_SERIAL and ANALYTICS_API_QAR_PASSWORD environment variables."
)
def __init__(self, id=None, returntype=None, prefix=None, local_vars_configuration=None): # noqa: E501
"""SPARIdentifier - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._id = None
self._returntype = None
self._prefix = None
self.discriminator = None
self.id = id
if returntype is not None:
self.returntype = returntype
if prefix is not None:
self.prefix = prefix
def __init__(self,
name=None,
category=None,
local_vars_configuration=None): # noqa: E501
"""ComponentSummary - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._name = None
self._category = None
self.discriminator = None
if name is not None:
self.name = name
if category is not None:
self.category = category
def __init__(self,
name=None,
accounts=None,
local_vars_configuration=None): # noqa: E501
"""VaultConfiguration - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._name = None
self._accounts = None
self.discriminator = None
if name is not None:
self.name = name
if accounts is not None:
self.accounts = accounts
def __init__(self,
documents=None,
directories=None,
local_vars_configuration=None): # noqa: E501
"""DocumentDirectories - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._documents = None
self._directories = None
self.discriminator = None
if documents is not None:
self.documents = documents
if directories is not None:
self.directories = directories
def __init__(self, id=None, name=None, holdingsmode=None, local_vars_configuration=None): # noqa: E501
"""ComponentAccount - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._id = None
self._name = None
self._holdingsmode = None
self.discriminator = None
if id is not None:
self.id = id
if name is not None:
self.name = name
if holdingsmode is not None:
self.holdingsmode = holdingsmode
def __init__(self,
configuration=None,
header_name=None,
header_value=None,
cookie=None,
pool_threads=1):
if configuration is None:
configuration = Configuration.get_default_copy()
self.configuration = configuration
self.pool_threads = pool_threads
self.rest_client = rest.RESTClientObject(configuration)
self.default_headers = {}
if header_name is not None:
self.default_headers[header_name] = header_value
self.cookie = cookie
# Set default User-Agent.
self.user_agent = 'engines-api/5.3.0/python'
def __init__(self, status=None, points=None, error=None, result=None, local_vars_configuration=None): # noqa: E501
"""CalculationUnitStatus - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._status = None
self._points = None
self._error = None
self._result = None
self.discriminator = None
if status is not None:
self.status = status
if points is not None:
self.points = points
if error is not None:
self.error = error
if result is not None:
self.result = result
def __init__(self,
id=None,
account=None,
benchmark=None,
currencyisocode=None,
dates=None,
snapshot=None,
name=None,
category=None,
local_vars_configuration=None): # noqa: E501
"""VaultComponent - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._id = None
self._account = None
self._benchmark = None
self._currencyisocode = None
self._dates = None
self._snapshot = None
self._name = None
self._category = None
self.discriminator = None
if id is not None:
self.id = id
if account is not None:
self.account = account
if benchmark is not None:
self.benchmark = benchmark
if currencyisocode is not None:
self.currencyisocode = currencyisocode
if dates is not None:
self.dates = dates
if snapshot is not None:
self.snapshot = snapshot
if name is not None:
self.name = name
if category is not None:
self.category = category
def __init__(self,
pa=None,
spar=None,
vault=None,
local_vars_configuration=None): # noqa: E501
"""Calculation - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._pa = None
self._spar = None
self._vault = None
self.discriminator = None
if pa is not None:
self.pa = pa
if spar is not None:
self.spar = spar
if vault is not None:
self.vault = vault
def __init__(self,
componentid=None,
account=None,
dates=None,
configid=None,
local_vars_configuration=None): # noqa: E501
"""VaultCalculationParameters - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._componentid = None
self._account = None
self._dates = None
self._configid = None
self.discriminator = None
self.componentid = componentid
self.account = account
if dates is not None:
self.dates = dates
self.configid = configid
def __init__(self,
componentid=None,
accounts=None,
benchmark=None,
dates=None,
local_vars_configuration=None): # noqa: E501
"""SPARCalculationParameters - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._componentid = None
self._accounts = None
self._benchmark = None
self._dates = None
self.discriminator = None
self.componentid = componentid
if accounts is not None:
self.accounts = accounts
if benchmark is not None:
self.benchmark = benchmark
if dates is not None:
self.dates = dates
def main():
config = Configuration()
config.host = host
config.username = fds_username
config.password = fds_api_key
# 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)
try:
screeningExpressionUniverse = QuantScreeningExpressionUniverse(
source="ScreeningExpressionUniverse",
universe_expr=
"(TICKER=\"IBM\" OR TICKER=\"MS\" OR TICKER=\"GE\")=1",
universe_type="Equity",
security_expr="TICKER")
fdsDate = QuantFdsDate(source="FdsDate",
start_date="20050701",
end_date="20051001",
frequency="M",
calendar="FIVEDAY")
fqlExpression = QuantFqlExpression(source="FqlExpression",
expr="P_PRICE(#DATE,#DATE,#FREQ)",
name="Price")
fqlExpression1 = QuantFqlExpression(source="FqlExpression",
expr="FF_EPS(,#DATE,#DATE,#FREQ)",
name="Eps")
fqlExpression2 = QuantFqlExpression(source="FqlExpression",
expr="FG_GICS_SECTOR",
name="Sector")
quant_calculation_parameters = {
"1":
QuantCalculationParameters(
universe=screeningExpressionUniverse,
dates=fdsDate,
formulas=[fqlExpression, fqlExpression1, fqlExpression2])
}
# 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"
quant_calculations_meta = QuantCalculationMeta(format='Feather')
quant_calculation_parameter_root = QuantCalculationParametersRoot(
data=quant_calculation_parameters, meta=quant_calculations_meta)
quant_calculations_api = QuantCalculationsApi(api_client)
post_and_calculate_response = quant_calculations_api.post_and_calculate(
quant_calculation_parameters_root=quant_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 = quant_calculations_api.post_and_calculate(
# quant_calculation_parameters_root=quant_calculation_parameter_root, cache_control=cache_control)
if post_and_calculate_response[1] == 201:
output_calculation_result('data', post_and_calculate_response[0])
else:
calculation_id = post_and_calculate_response[0].data.calculationid
print("Calculation Id: " + calculation_id)
status_response = quant_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 = quant_calculations_api.get_calculation_status_by_id(
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 = quant_calculations_api.get_calculation_unit_result_by_id(
id=calculation_id, unit_id=calculation_unit_id)
print("Calculation Data")
output_calculation_result('data',
result_response[0].read())
result_response = quant_calculations_api.get_calculation_unit_info_by_id(
id=calculation_id, unit_id=calculation_unit_id)
print("Calculation Info")
output_calculation_result('info',
result_response[0].read())
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 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:
vault_document_name = "Client:/aapi/VAULT_QA_PI_DEFAULT_LOCKED"
vault_component_total_returns = "Total Returns"
vault_component_performance = "Performance Over Time"
vault_component_category = "Performance / Performance Relative Dates"
vault_default_account = "CLIENT:/BISAM/REPOSITORY/QA/SMALL_PORT.ACCT"
vault_startdate = "20180101"
vault_enddate = "20180329"
frequency = "Monthly"
# 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_vault_components(
vault_document_name)
component_total_returns_id = [
id for id in list(get_components_response[0].data.keys())
if get_components_response[0].data[id].name ==
vault_component_total_returns and get_components_response[0].
data[id].category == vault_component_category
][0]
print("Vault Total Returns Component Id: " +
component_total_returns_id)
component_performance_id = [
id for id in list(get_components_response[0].data.keys())
if get_components_response[0].data[id].name ==
vault_component_performance and get_components_response[0].
data[id].category == vault_component_category
][0]
print("Vault Performance Over Time Component Id: " +
component_performance_id)
vault_account_identifier = VaultIdentifier(vault_default_account)
vault_dates = VaultDateParameters(startdate=vault_startdate,
enddate=vault_enddate,
frequency=frequency)
configurations_api = ConfigurationsApi(api_client)
get_vault_configurations_response = configurations_api.get_vault_configurations(
vault_default_account)
configuration_id = list(
get_vault_configurations_response[0].data.keys())[0]
vault_calculation_parameters = {
"total_returns":
VaultCalculationParameters(componentid=component_total_returns_id,
account=vault_account_identifier,
dates=vault_dates,
configid=configuration_id),
"performance_over_time":
VaultCalculationParameters(componentid=component_performance_id,
account=vault_account_identifier,
dates=vault_dates,
configid=configuration_id)
}
vault_calculation_parameters_root = VaultCalculationParametersRoot(
data=vault_calculation_parameters)
vault_calculations_api = VaultCalculationsApi(api_client)
post_and_calculate_response = vault_calculations_api.post_and_calculate(
vault_calculation_parameters_root=vault_calculation_parameters_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 = vault_calculations_api.post_and_calculate(vault_calculation_parameters_root=vault_calculation_parameters_root, cache_control=cache_control)
if post_and_calculate_response[
1] == 202 or post_and_calculate_response[1] == 200:
calculation_id = post_and_calculate_response[0].data.calculationid
print("Calculation Id: " + calculation_id)
status_response = vault_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 = vault_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 = vault_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))
else:
print("Calculation creation failed")
print("Error status : " + str(post_and_calculate_response[1]))
print("Error message : " + str(post_and_calculate_response[0]))
except ApiException as e:
print("Api exception Encountered")
print(e)
exit()
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)
calculations = [
"Security Type", "Security Name", "Run Status",
"Elapse Time (seconds)", "Calc From Method", "Option Pricing Model",
"Yield Curve Date", "Settlement Date", "Discount Curve", "Price",
"Yield to No Call", "OAS", "Effective Duration", "Effective Convexity",
"CF Coupon"
]
security1 = FISecurity(calc_from_method="Price",
calc_from_value=100.285,
face=10000.0,
symbol="912828ZG8",
settlement="20201202",
discount_curve="UST")
security2 = FISecurity(calc_from_method="Price",
calc_from_value=101.138,
face=200000.0,
symbol="US037833AR12",
settlement="20201203",
discount_curve="UST")
# 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"
securities = [security1, security2]
jobSettings = FIJobSettings(as_of_date="20201201",
partial_duration_months=[1, 3, 6])
fi_calculation_parameters = FICalculationParameters(
securities, calculations, jobSettings)
fi_calculation_parameters_root = FICalculationParametersRoot(
data=fi_calculation_parameters)
fi_calculations_api = FICalculationsApi(api_client)
run_calculation_response = fi_calculations_api.post_and_calculate(
fi_calculation_parameters_root=fi_calculation_parameters_root)
# comment the above line and uncomment the below line to run the request with the cache_control header defined earlier
# run_calculation_response = fi_calculations_api.post_and_calculate(
# fi_calculation_parameters_root=fi_calculation_parameters_root, cache_control=cache_control)
if run_calculation_response[1] != 202 and run_calculation_response[
1] != 201:
print_error(run_calculation_response)
sys.exit()
if run_calculation_response[1] == 201:
output_calculation_result(run_calculation_response[0].data)
sys.exit()
calculation_id = run_calculation_response[2][
"X-Factset-Api-Calculation-Id"]
print("Calculation Id: " + calculation_id)
status_response = fi_calculations_api.get_calculation_status_by_id(
id=calculation_id)
while status_response[1] == 202:
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 = fi_calculations_api.get_calculation_status_by_id(
id=calculation_id)
if status_response[1] != 201:
print_error(status_response)
sys.exit()
output_calculation_result(status_response[0].data)
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)
try:
pub_document_name = "Super_client:/publisher/Equity Snapshot.PUB_BRIDGE_PDF"
pub_account_id = "BENCH:SP50"
startdate = "-1M"
enddate = "0M"
# 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"
pub_account_identifier = PubIdentifier(pub_account_id)
pub_dates = PubDateParameters(enddate, startdate=startdate)
pub_calculation_parameters = {
"1": PubCalculationParameters(pub_document_name, pub_account_identifier, pub_dates)
}
pub_calculation_parameters_root = PubCalculationParametersRoot(
data=pub_calculation_parameters)
pub_calculations_api = PubCalculationsApi(api_client)
post_and_calculate_response = pub_calculations_api.post_and_calculate(
pub_calculation_parameters_root=pub_calculation_parameters_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 = pub_calculations_api.post_and_calculate(pub_calculation_parameters_root=pub_calculation_parameters_root, cache_control=cache_control)
if post_and_calculate_response[1] == 201:
output_calculation_result(
"single_unit", (post_and_calculate_response[0].read()))
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 = pub_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 = pub_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 = pub_calculations_api.get_calculation_unit_result_by_id(id=calculation_id,
unit_id=calculation_unit_id)
output_calculation_result(
"single_unit", (result_response[0].read()))
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 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 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:
pa_document_name = "PA_DOCUMENTS:DEFAULT"
pa_component_name = "Weights"
pa_component_category = "Weights / Exposures"
portfolio = "BENCH:SP50"
benchmark = "BENCH:R.1000"
startdate = "20180101"
enddate = "20181231"
frequency = "Monthly"
# 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_pa_components(
document=pa_document_name)
component_id = [
id for id in list(get_components_response[0].data.keys())
if get_components_response[0].data[id].name == pa_component_name
and get_components_response[0].data[id].category ==
pa_component_category
][0]
print("PA Component Id: " + component_id)
pa_accounts = [PAIdentifier(id=portfolio)]
pa_benchmarks = [PAIdentifier(id=benchmark)]
pa_dates = PADateParameters(startdate=startdate,
enddate=enddate,
frequency=frequency)
pa_calculation_parameters = {
"1":
PACalculationParameters(componentid=component_id,
accounts=pa_accounts,
benchmarks=pa_benchmarks,
dates=pa_dates),
"2":
PACalculationParameters(componentid=component_id,
accounts=pa_accounts,
benchmarks=pa_benchmarks,
dates=pa_dates)
}
pa_calculation_parameter_root = PACalculationParametersRoot(
data=pa_calculation_parameters)
pa_calculations_api = PACalculationsApi(api_client)
post_and_calculate_response = pa_calculations_api.post_and_calculate(
pa_calculation_parameters_root=pa_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 = pa_calculations_api.post_and_calculate(pa_calculation_parameters_root=pa_calculation_parameter_root, cache_control=cache_control)
if post_and_calculate_response[
1] == 202 or post_and_calculate_response[1] == 200:
calculation_id = post_and_calculate_response[0].data.calculationid
print("Calculation Id: " + calculation_id)
status_response = pa_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 = pa_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 = pa_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))
else:
print("Calculation creation failed")
print("Error status : " + str(post_and_calculate_response[1]))
print("Error message : " + str(post_and_calculate_response[0]))
except ApiException as e:
print("Api exception Encountered")
print(e)
exit()
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)
try:
screeningExpressionUniverse = QuantScreeningExpressionUniverse(
universe_expr="ISON_DOW", universe_type="Equity", security_expr="TICKER")
fdsDate = QuantFdsDate(
start_date="0", end_date="-5D", frequency="D", calendar="FIVEDAY")
screeningExpression = [QuantScreeningExpression(
expr="P_PRICE", name="Price (SCR)")]
fqlExpression = [QuantFqlExpression(
expr="P_PRICE", name="Price (SCR)")]
quant_calculation_parameters = {"1": QuantCalculationParameters(screening_expression_universe=screeningExpressionUniverse,
fds_date=fdsDate, screening_expression=screeningExpression, fql_expression=fqlExpression)}
quant_calculation_parameter_root = QuantCalculationParametersRoot(
data=quant_calculation_parameters)
# 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"
quant_calculations_api = QuantCalculationsApi(api_client)
post_and_calculate_response = quant_calculations_api.post_and_calculate(
quant_calculation_parameters_root=quant_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 = quant_calculations_api.post_and_calculate(
# quant_calculation_parameters_root=quant_calculation_parameter_root, cache_control=cache_control)
if post_and_calculate_response[1] == 201:
output_calculation_result(post_and_calculate_response[0].read())
else:
calculation_id = post_and_calculate_response[0].data.calculationid
print("Calculation Id: " + calculation_id)
status_response = quant_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 = quant_calculations_api.get_calculation_status_by_id(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 = quant_calculations_api.get_calculation_unit_result_by_id(id=calculation_id,
unit_id=calculation_unit_id)
print("Calculation Data")
output_calculation_result(json.loads(result_response[0].read())['data'])
result_response = quant_calculations_api.get_calculation_unit_info_by_id(id=calculation_id,
unit_id=calculation_unit_id)
print("Calculation Info")
output_calculation_result(json.loads(result_response[0].read())['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 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)
try:
# {
# "strategy": {
# "id": "Client:/analytics_api/dbui_simple_strategy"
# },
# "account": {
# "id": "CLIENT:/FPO/1K_MAC_AMZN_AAPL.ACCT",
# "padocument": {
# "id": "CLIENT:/FPO/FPO_MASTER"
# }
# },
# "optimization": {
# "riskmodeldate": "0M",
# "backtestdate": "0M"
# },
# "outputtypes": {
# "trades": {
# "identifiertype": "Asset",
# "includecash": false
# }
# }
# }
# 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"
fpo_optimizer_strategy = FPOOptimizerStrategy(
id="Client:/analytics_api/dbui_simple_strategy")
fpo_pa_doc = PaDoc("CLIENT:/FPO/FPO_MASTER")
fpo_optimizer_account = FPOAccount(
fpo_pa_doc, id="CLIENT:/FPO/1K_MAC_AMZN_AAPL.ACCT")
fpo_optimizer_optimization = Optimization(
risk_model_date="0M",
backtest_date="0M",
)
fpo_optimizer_trades_list = OptimizerTradesList(
identifier_type="Asset", include_cash=False)
fpo_optimizer_output_types = OptimizerOutputTypes(
trades=fpo_optimizer_trades_list)
fpo_optimizer_parameters = FPOOptimizationParameters(
fpo_optimizer_strategy,
fpo_optimizer_output_types,
account=fpo_optimizer_account,
optimization=fpo_optimizer_optimization
)
fpo_optimization_parameters_root = FPOOptimizationParametersRoot(
data=fpo_optimizer_parameters)
fpo_optimizations_api = FPOOptimizerApi(api_client)
post_and_optimize_response = fpo_optimizations_api.post_and_optimize(
fpo_optimization_parameters_root=fpo_optimization_parameters_root
)
# comment the above line and uncomment the below line to run the request with the cache_control header defined earlier
# post_and_optimize_response = fpo_optimizations_api.post_and_optimize(
# fpo_optimization_parameters_root=fpo_optimization_parameters_root, cache_control=cache_control
# )
if post_and_optimize_response[1] == 201:
output_optimization_result(post_and_optimize_response[0]['data'])
else:
optimization_id = post_and_optimize_response[2]["X-Factset-Api-Calculation-Id"]
print("Calculation Id: " + optimization_id)
status_response = fpo_optimizations_api.get_optimization_status_by_id(id=optimization_id)
while status_response[1] == 202:
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 = fpo_optimizations_api.get_optimization_status_by_id(optimization_id)
if status_response[1] == 201:
print("Optimization Id: " + optimization_id + " Succeeded!!!")
result_response = fpo_optimizations_api.get_optimization_result(id=optimization_id)
output_optimization_result(result_response[0]['data'])
else:
print("Optimization Id:" + optimization_id + " Failed!!!")
print("Error message : " + status_response[0].errors)
except ApiException as e:
print("Api exception Encountered")
print(e)
exit()
host = "https://api.factset.com" username = "******" password = "******" spar_document_name = "pmw_root:/spar_documents/Factset Default Document" spar_component_name = "Returns Data" spar_component_category = "Raw Data / Returns" spar_benchmark_r_1000 = "R.1000" spar_benchmark_russell_pr_2000 = "RUSSELL_P:R.2000" spar_benchmark_russell_prefix = "RUSSELL" spar_benchmark_russell_return_type = "GTR" startdate = "20180101" 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)
