feat(new-sdk-version): adding version 4.0.0 sdk (#11)

Supported API versions:
* v2

Summary:
* Adding support for new features

Breaking changes:
* No changes

Functionality Additions:
* Publisher API calculation and document lookup
* New componentdetail parameter for PA and Vault calculation

Bug Fixes:
* No changes

Author: kahmed00

CHANGELOG.md

@@ -1,3 +1,23 @@
+4.0.0 (06/17/2020)
+
+Supported API versions:
+* v2
+
+Summary:
+* Adding support for new features
+
+Breaking changes:
+* No changes
+
+Functionality Additions:
+* Publisher API calculation and document lookup
+* New componentdetail parameter for PA and Vault calculation
+
+Bug Fixes:
+* No changes
+
+-----------------------
+
 3.0.0 (12/02/2019)
 
 Supported API versions:

README.md

@@ -11,8 +11,8 @@ API client library to leverage FactSet's PA Engine, SPAR Engine and Vault API in
 * Python 3.4+
 
 #### Current versions
-* API_VERSION - 2
-* PACKAGE_VERSION - 3.0.0
+* API_VERSION - v2
+* PACKAGE_VERSION - 4.0.0
 
 ## To install the API client library
 * Run the below command.

Utilities/codegen/openapi-generator-config.json

@@ -1,6 +1,6 @@
 {
   "packageName": "fds.analyticsapi.engines",
   "projectName": "fds.analyticsapi.engines",
-  "packageVersion": "3.0.0",
+  "packageVersion": "4.0.0",
   "packageUrl": "https://github.com/factset/analyticsapi-engines-python-sdk"
 }

Utilities/codegen/openapi-schema.json

@@ -22,6 +22,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="multiple_engines_example.py" />
+    <Compile Include="pub_engine_example.py" />
     <Compile Include="pa_engine_example.py">
       <SubType>Code</SubType>
     </Compile>

Utilities/examples/examples.pyproj

@@ -0,0 +1,99 @@
+import json
+import sys
+import time
+
+from fds.analyticsapi.engines.api.calculations_api import CalculationsApi
+from fds.analyticsapi.engines.api.utility_api import UtilityApi
+from fds.analyticsapi.engines.api_client import ApiClient
+from fds.analyticsapi.engines.configuration import Configuration
+from fds.analyticsapi.engines.models.calculation import Calculation
+from fds.analyticsapi.engines.models.pub_calculation_parameters import PubCalculationParameters
+from fds.analyticsapi.engines.models.pub_identifier import PubIdentifier
+from fds.analyticsapi.engines.models.pub_date_parameters import PubDateParameters
+from fds.protobuf.stach.Package_pb2 import Package
+
+from google.protobuf import json_format
+from google.protobuf.json_format import MessageToJson
+from google.protobuf.json_format import MessageToDict
+
+from urllib3 import Retry
+from pathlib import Path
+
+host = "https://api.factset.com"
+username = "<username-serial>"
+password = "<apiKey>"
+
+pub_document_name = "Super_client:/publisher/Equity Snapshot.PUB_BRIDGE_PDF"
+pub_account_name = "BENCH:SP50"
+startdate = "-1M"
+enddate = "0M"
+
+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
+
+# 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)
+
+pub_account_identifier = PubIdentifier(pub_account_name);
+pub_dates = PubDateParameters(startdate, enddate);
+
+pub_calculation_parameters = {"1": PubCalculationParameters(pub_document_name, pub_account_identifier, pub_dates)}
+
+calculation = Calculation(pub=pub_calculation_parameters)
+print(calculation)
+
+calculations_api = CalculationsApi(api_client)
+run_calculation_response = calculations_api.run_calculation_with_http_info(calculation=calculation)
+
+if run_calculation_response[1] != 202:
+    print("Calculation Failed!!!")
+    print("Status Code: " + run_calculation_response[1])
+    print("Request Key: " + run_calculation_response[2].get("x-datadirect-request-key"))
+    print(run_calculation_response[0])
+    sys.exit()
+
+calculation_id = run_calculation_response[2].get("location").split("/")[-1]
+print("Calculation Id: " + calculation_id)
+
+status_response = calculations_api.get_calculation_status_by_id_with_http_info(calculation_id)
+while status_response[1] == 200 and (status_response[0].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 = calculations_api.get_calculation_status_by_id_with_http_info(calculation_id)
+
+if status_response[1] != 200:
+    print("Calculation Failed!!!")
+    print("Status Code: " + status_response[1])
+    print("Request Key: " + status_response[2].get("x-datadirect-request-key"))
+    print(status_response[0])
+    sys.exit()
+
+for calculation_unit in status_response[0].pub.values():
+    print(calculation_unit)
+    if calculation_unit.status == "Failed":
+        print("Calculation Failed!!!")
+    elif calculation_unit.status == "Success":
+        utility_api = UtilityApi(api_client)
+        result_response = utility_api.get_by_url_with_http_info(calculation_unit.result, _preload_content=False)
+
+        if result_response[1] != 200:
+            print("Calculation Failed!!!")
+            print("Status Code: " + result_response[1])
+            print("Request Key: " + result_response[2].get("x-datadirect-request-key"))
+            print(result_response[0])
+            sys.exit()
+
+        print("Calculation Succeeded")
+        filename = Path('Output.pdf')
+        filename.write_bytes(result_response[0].data)

Utilities/examples/pub_engine_example.py

@@ -8,21 +8,25 @@
 # Set 'ANALYTICS_API_URL' environment variable with api url as value
 base_url = 'https://api.factset.com' if not os.getenv("ANALYTICS_API_URL") else os.getenv("ANALYTICS_API_URL")
 
-pa_deafult_document = "PA_DOCUMENTS:DEFAULT"
+pa_default_document = "PA_DOCUMENTS:DEFAULT"
 pa_benchmark_sp500 = "BENCH:SP50"
 pa_benchmark_r1000 = "BENCH:R.1000"
-spar_deafult_document = "pmw_root:/spar_documents/Factset Default Document"
+spar_default_document = "pmw_root:/spar_documents/Factset Default Document"
 spar_benchmark_r1000 = "R.1000"
 spar_benchmark_r2000 = "R.2000"
 spar_benchmark_russell_p_r1000 = "RUSSELL_P:R.2000"
 spar_benchmark_russell_prefix = "RUSSELL"
 spar_benchmark_russell_return_type = "GTR"
-vault_deafult_document = "PA3_DOCUMENTS:DEFAULT"
-vault_deafult_account = "Client:/analytics/data/US_MID_CAP_CORE.ACTM"
+vault_default_document = "PA3_DOCUMENTS:DEFAULT"
+vault_default_account = "Client:/analytics/data/US_MID_CAP_CORE.ACTM"
 vault_start_date = "FIRST_REPOSITORY"
 vault_end_date = "LAST_REPOSITORY"
-deafult_start_date = "20180101"
-deafult_end_date = "20181231"
-deafult_dates_frequency = "Monthly"
-deafult_dates_account = "Client:/analytics/data/US_MID_CAP_CORE.ACTM"
+pub_document_name = "Super_client:/publisher/Equity Snapshot.PUB_BRIDGE_PDF"
+pub_account_name = "BENCH:SP50"
+pub_start_date = "-1M"
+pub_end_date = "0M"
+default_start_date = "20180101"
+default_end_date = "20181231"
+default_dates_frequency = "Monthly"
+default_dates_account = "Client:/analytics/data/US_MID_CAP_CORE.ACTM"
 default_lookup_directory = "client:"

Utilities/tests/common_parameters.py

@@ -4,6 +4,7 @@
 
 from google.protobuf import json_format
 from fds.protobuf.stach.Package_pb2 import Package
+from urllib3.response import HTTPResponse
 
 from fds.analyticsapi.engines.api.components_api import ComponentsApi
 from fds.analyticsapi.engines.api.configurations_api import ConfigurationsApi
@@ -19,6 +20,9 @@
 from fds.analyticsapi.engines.models.vault_calculation_parameters import VaultCalculationParameters
 from fds.analyticsapi.engines.models.vault_identifier import VaultIdentifier
 from fds.analyticsapi.engines.models.vault_date_parameters import VaultDateParameters
+from fds.analyticsapi.engines.models.pub_calculation_parameters import PubCalculationParameters
+from fds.analyticsapi.engines.models.pub_identifier import PubIdentifier
+from fds.analyticsapi.engines.models.pub_date_parameters import PubDateParameters
 from fds.analyticsapi.engines.models.calculation_status import CalculationStatus
 from fds.analyticsapi.engines.models.calculation_unit_status import CalculationUnitStatus
 from fds.analyticsapi.engines.models.calculation_status_summary import CalculationStatusSummary
@@ -36,20 +40,20 @@ def setUp(self):
 
     def run_calculation(self):
         components_api = ComponentsApi(self.api_client)
-        components = components_api.get_pa_components(common_parameters.pa_deafult_document)
+        components = components_api.get_pa_components(common_parameters.pa_default_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_dates = PADateParameters(common_parameters.default_start_date,
+                                    common_parameters.default_end_date,
+                                    common_parameters.default_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)
+        components = components_api.get_spar_components(common_parameters.spar_default_document)
         component_id = list(components.keys())[0]
 
         spar_account_identifier = SPARIdentifier(common_parameters.spar_benchmark_r1000,
@@ -59,25 +63,30 @@ def run_calculation(self):
         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_dates = SPARDateParameters(common_parameters.default_start_date,
+                                        common_parameters.default_end_date,
+                                        common_parameters.default_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)
+        components = components_api.get_vault_components(common_parameters.vault_default_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)
+        vault_account_identifier = VaultIdentifier(common_parameters.vault_default_account)
+        vault_dates = VaultDateParameters(common_parameters.vault_start_date, common_parameters.vault_end_date, common_parameters.default_dates_frequency)
 
         configurations_api = ConfigurationsApi(self.api_client)
-        configurations = configurations_api.get_vault_configurations(common_parameters.vault_deafult_account)
+        configurations = configurations_api.get_vault_configurations(common_parameters.vault_default_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)
+        pub_account_identifier = PubIdentifier(common_parameters.pub_account_name);
+        pub_dates = PubDateParameters(common_parameters.pub_start_date, common_parameters.pub_end_date);
+
+        pub_calculation_parameters = {"4": PubCalculationParameters(common_parameters.pub_document_name, pub_account_identifier, pub_dates)}
+
+        calculation = Calculation(pa_calculation_parameters, spar_calculation_parameters, vault_calculation_parameters, pub_calculation_parameters)
         return self.calculations_api.run_calculation_with_http_info(calculation=calculation)
 
     def test_create_calculation(self):
@@ -105,21 +114,30 @@ def test_calculation_success(self):
 
         self.assertEqual(self.status_response[1], 200, "Calculation should be completed")
         self.assertEqual(self.status_response[0].status, "Completed", "Calculation status should be completed")
+        self.assertEqual(type(self.status_response[0]), CalculationStatus, "Response should be of CalculationStatus type")
+
+        engines = ["pa", "spar", "vault", "pub"]
 
-        calculations = list(self.status_response[0].pa.values()) + list(self.status_response[0].spar.values()) + list(self.status_response[0].vault.values())
+        for engine in engines:
+            calculations = getattr(self.status_response[0], engine).values()
+            for calc in calculations:
+                self.assertEqual(type(calc), CalculationUnitStatus, "Response should be of CalculationUnitStatus type")
+                self.assertEqual(calc.status, "Success", "Calculation should be successful")
+                self.assertNotEqual(calc.result, None, "Response result should not be null")
 
-        for calc in calculations:
-            self.assertEqual(type(calc), CalculationUnitStatus, "Response should be of CalculationUnitStatus type")
-            self.assertEqual(calc.status, "Success", "Calculation should be successful")
-            self.assertNotEqual(calc.result, None, "Response result should not be null")
+                utility_api = UtilityApi(self.api_client)
 
-            utility_api = UtilityApi(self.api_client)
-            result_response = utility_api.get_by_url_with_http_info(calc.result)
+                if engine is not "pub":
+                    result_response = utility_api.get_by_url_with_http_info(calc.result)
+                    result = json_format.Parse(json.dumps(result_response[0]), Package())
 
-            result = json_format.Parse(json.dumps(result_response[0]), Package())
+                    self.assertEqual(result_response[1], 200, "Response should be 200 - Success")
+                    self.assertEqual(type(result), Package, "Response should be of Package type.")
+                else:
+                    result_response = utility_api.get_by_url_with_http_info(calc.result, _preload_content=False)
 
-            self.assertEqual(result_response[1], 200, "Response should be 200 - Success")
-            self.assertEqual(type(result), Package, "Response should be of Package type.")
+                    self.assertEqual(result_response[1], 200, "Response should be 200 - Success")
+                    self.assertEqual(type(result_response[0]), HTTPResponse, "Response should be of HTTPResponse type.")
 
     def test_delete_calculation(self):
         calculation_id = self.create_response[2].get("location").split("/")[-1]

Utilities/tests/test_calculations_api.py

@@ -18,14 +18,14 @@ def setUp(self):
     ######################################################################################
 
     def test_get_all_pa_components(self):
-        response = self.components_api.get_pa_components_with_http_info(document=common_parameters.pa_deafult_document)
+        response = self.components_api.get_pa_components_with_http_info(document=common_parameters.pa_default_document)
         component_id = list(response[0].keys())[0]
         self.assertEqual(response[1], 200, "Response should be 200 - Success")
         self.assertEqual(type(response[0]), dict, "Response should be of dictionary type")
         self.assertEqual(type(response[0][component_id]), ComponentSummary, "Response should be of ComponentSummary type")
 
     def test_get_pa_component_by_id(self):
-        components = self.components_api.get_pa_components(document=common_parameters.pa_deafult_document)
+        components = self.components_api.get_pa_components(document=common_parameters.pa_default_document)
         component_id = list(components.keys())[0]
         response = self.components_api.get_pa_component_by_id_with_http_info(component_id)
         self.assertEqual(response[1], 200, "Response should be 200 - Success")
@@ -37,14 +37,14 @@ def test_get_pa_component_by_id(self):
     ######################################################################################
 
     def test_get_all_vault_components(self):
-        response = self.components_api.get_vault_components_with_http_info(document=common_parameters.vault_deafult_document)
+        response = self.components_api.get_vault_components_with_http_info(document=common_parameters.vault_default_document)
         component_id = list(response[0].keys())[0]
         self.assertEqual(response[1], 200, "Response should be 200 - Success")
         self.assertEqual(type(response[0]), dict, "Response should be of dictionary type")
         self.assertEqual(type(response[0][component_id]), ComponentSummary, "Response should be of ComponentSummary type")
 
     def test_get_vault_component_by_id(self):
-        components = self.components_api.get_vault_components(document=common_parameters.vault_deafult_document)
+        components = self.components_api.get_vault_components(document=common_parameters.vault_default_document)
         component_id = list(components.keys())[0]
         response = self.components_api.get_vault_component_by_id_with_http_info(component_id)
         self.assertEqual(response[1], 200, "Response should be 200 - Success")
@@ -56,7 +56,7 @@ def test_get_vault_component_by_id(self):
     ######################################################################################
 
     def test_get_all_spar_components(self):
-        response = self.components_api.get_spar_components_with_http_info(document=common_parameters.spar_deafult_document)
+        response = self.components_api.get_spar_components_with_http_info(document=common_parameters.spar_default_document)
         component_id = list(response[0].keys())[0]
         self.assertEqual(response[1], 200, "Response should be 200 - Success")
         self.assertEqual(type(response[0]), dict, "Response should be of dictionary type")

Utilities/tests/test_components_api.py

@@ -13,14 +13,14 @@ def setUp(self):
         self.configurations_api = ConfigurationsApi(CommonFunctions.build_api_client())
 
     def test_get_all_vault_configurations(self):
-        response = self.configurations_api.get_vault_configurations_with_http_info(account=common_parameters.vault_deafult_account)
+        response = self.configurations_api.get_vault_configurations_with_http_info(account=common_parameters.vault_default_account)
         configuration_id = list(response[0].keys())[0]
         self.assertEqual(response[1], 200, "Response code should be 200 - Success")
         self.assertEqual(type(response[0]), dict, "Response should be of Dictionary type")
         self.assertEqual(type(response[0][configuration_id]), VaultConfigurationSummary, "Response should be of VaultConfigurationSummary type")
 
     def test_get_vault_configuration_by_id(self):
-        configurations = self.configurations_api.get_vault_configurations(account=common_parameters.vault_deafult_account)
+        configurations = self.configurations_api.get_vault_configurations(account=common_parameters.vault_default_account)
         configuration_id = list(configurations.keys())[0]
         response = self.configurations_api.get_vault_configuration_by_id_with_http_info(configuration_id)
         self.assertEqual(response[1], 200, "Response code should be 200 - Success")