All URIs are relative to http://localhost

Method	HTTP request	Description
close_project	GET /open/project/close	Closes the currently open project.
create_new_variable_parameter	POST /open/variations/create-variable-parameter	Creates a new variable parameter.
create_variable_parameter	POST /open/variations	Creates a new variable parameter.
delete_variable_parameter	DELETE /open/variations/delete-variable-parameter	Deletes a variation parameter with identifier variationId.
does_variable_parameter_has_selected_data	POST /open/variations/has-selected-data	Returns whether the variable parameter with identifier variationId has the selected data in the table.
export_dashboard_page	GET /open/experiments/export-page	Returns an Excel representation of the dashboard page with id pageId.
find_and_open_project_by_name	GET /open/project/open-by-name	Opens project with name projectName.
get_comparison_result_data	POST /open/experiments/comparison-result	Returns comparison result data.
get_existing_variable_parameter_table_data	GET /open/variations/existing-table-data	Returns a table data of a variation with the given variationId.
get_experiment	GET /open/experiments/experiment	Returns an experiment of a given type available for a given scenario.
get_experiment_dashboard_page	GET /open/experiments/dashboard-page	Returns statistic page with the given pageName for the result of experiment run.
get_experiment_dashboard_pages	GET /open/experiments/dashboard-pages	Returns statistics pages for the result of experiment run.
get_experiment_options	POST /open/experiments/options	Returns a list of possible values for various experiment options.
get_experiment_run_configuration	GET /open/experiments/get-run-configuration	Returns experiment settings.
get_experiment_run_result	GET /open/experiments/result	Returns all the results of the specific experiment run.
get_experiment_run_result_chart_graph_data	GET /open/experiments/chart-graph-data	Returns graph data for the chart with identifier chartId.
get_experiment_run_result_chart_table_data	GET /open/experiments/chart-table-data	Returns table data for the chart with identifier chartId.
get_experiment_run_result_options	GET /open/experiments/result-options	Returns options for the result of experiment run.
get_experiment_run_result_page_charts	GET /open/experiments/charts	Returns charts on the statistics page with the identifier pageId.
get_experiment_run_result_pages	GET /open/experiments/pages	Returns statistics pages for the result of experiment run.
get_experiment_runs_for_scenario	GET /open/experiments/results	Returns the results of experiment runs for scenario.
get_experiment_status	GET /open/experiments/status	Returns the experiment status.
get_experiments	GET /open/experiments/list	Returns a list of experiments available for a given scenario.
get_import_status	GET /open/import/import-status	Returns scenario import status.
get_new_variable_parameter_table_data	GET /open/variations/new-table-data	Returns a table data of a variation with the given variationId.
get_projects	GET /open/project/list	Returns a list of projects that the user has access to.
get_scenario_validation_status	GET /open/experiments/validation-status	Returns the validation status of the scenario.
get_scenarios_from_imported_database	POST /open/import/scenarios-available-for-import	Returns a list of scenarios available for import in the imported database.
get_statistics_configurations	GET /open/experiments/statistics-list	Returns a list of available statistics.
get_tables_meta	GET /open/import/table-metas	Returns a list of meta information for tables.
get_validation_errors	GET /open/experiments/validation-errors	Returns validation errors.
get_validation_warnings	GET /open/experiments/validation-warnings	Returns validation warnings.
get_variable_parameter_object_type	GET /open/variations/object-type	Return a list of object types that have variable parameters.
get_variable_parameter_object_types	GET /open/variations/object-types	Returns a list of object types that have variable parameters.
get_variable_parameter_objects	GET /open/variations/objects	Returns a list of variable parameter objects of the given object type with identifier objectTypeId.
get_variable_parameter_parameters	GET /open/variations/parameters	Returns a list of parameters of an object with id objectId with type with id objectTypeId.
get_variable_parameter_variation_types	GET /open/variations/variation-types	Returns a list of parameter variation types for a parameter with id parameterId belonging to an object with id objectId with a type with id objectTypeId.
get_variation_result_data	POST /open/experiments/variation-result	Returns variation result data.
import_cancel	POST /open/import/import-cancel	Cancels scenario import job.
import_database	POST /open/import/import-database	Imports scenarios from the list sourceScenarioNameList from an external database.
import_database_existing	POST /open/import/import-database-existing	Imports scenario sourceScenarioName from an external database into existing scenario.
import_excel	POST /open/import/import-excel	Asynchronously imports scenario from excel file.
import_excel_existing	POST /open/import/import-excel-existing	Asynchronously imports scenario from excel file into existing scenario.
import_scenario	POST /open/import/import-scenario	Synchronously imports scenario from excel file.
import_scenario_existing	POST /open/import/import-scenario-existing	Synchronously imports scenario from excel file into existing scenario.
open_project	GET /open/project/open	Opens project with identifier projectId.
remove_scenario_by_id	DELETE /open/scenario	Deletes a scenario.
run_experiment	GET /open/experiments/run	Starts the experiment asynchronously.
run_experiment_synchronously	GET /open/experiments/run-synchronously	Starts the experiment synchronously.
stop_experiment	GET /open/experiments/stop	Stops the experiment.
translate	GET /open/translate	Returns translation for string stringToBeTranslated.
update_existing_variable_parameter_table_data_by_index	POST /open/variations/update-table-data-by-index	Updates a variation table data by index.
update_experiment_run_configuration	POST /open/experiments/update-run-configuration	Updates experiment settings.
update_variable_parameter	PUT /open/variations/update-variable-parameter	Updates the variation parameter represented by the variation object.

ApiProjectResponse close_project()

Closes the currently open project.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_project_response import ApiProjectResponse
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)

    try:
        # Closes the currently open project.
        api_response = api_instance.close_project()
        print("The response of OpenApiApi->close_project:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->close_project: %s\n" % e)

This endpoint does not need any parameter.

ApiProjectResponse

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiVariation create_new_variable_parameter(body=body)

Creates a new variable parameter.

Make sure that if this variation parameter contains a table, then it has the selected values (that is, you passed the indexes for the selected cells inside the variationCreateRequest.tableSelection object), since otherwise you will not be able to create the parameter.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_variation import ApiVariation
from openapi_client.models.api_variation_create_request import ApiVariationCreateRequest
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    body = openapi_client.ApiVariationCreateRequest() # ApiVariationCreateRequest | Variation parameter crate request. (optional)

    try:
        # Creates a new variable parameter.
        api_response = api_instance.create_new_variable_parameter(body=body)
        print("The response of OpenApiApi->create_new_variable_parameter:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->create_new_variable_parameter: %s\n" % e)

Name	Type	Description	Notes
body	ApiVariationCreateRequest	Variation parameter crate request.	[optional]

ApiVariation

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiVariation create_variable_parameter(rc_id, body=body)

Creates a new variable parameter.

Make sure that if this variation parameter contains a table, then it has the selected values (that is, you previously called updateVariableParameterTableDataByIndex), since otherwise you will not be able to create the parameter.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_variation import ApiVariation
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.
    body = openapi_client.ApiVariation() # ApiVariation | Variation parameter data. (optional)

    try:
        # Creates a new variable parameter.
        api_response = api_instance.create_variable_parameter(rc_id, body=body)
        print("The response of OpenApiApi->create_variable_parameter:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->create_variable_parameter: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.
body	ApiVariation	Variation parameter data.	[optional]

ApiVariation

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_variable_parameter(rc_id, variation_id)

Deletes a variation parameter with identifier variationId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.
    variation_id = 56 # int | Id of the variation parameter.

    try:
        # Deletes a variation parameter with identifier variationId.
        api_instance.delete_variable_parameter(rc_id, variation_id)
    except Exception as e:
        print("Exception when calling OpenApiApi->delete_variable_parameter: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.
variation_id	int	Id of the variation parameter.

void (empty response body)

ApiKey

• Content-Type: Not defined
• Accept: Not defined

Status code	Description	Response headers
0	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

bool does_variable_parameter_has_selected_data(object_id, rc_id, variation_id)

Returns whether the variable parameter with identifier variationId has the selected data in the table.

This method must be called before creating the variation parameter. If this method returns false, then the parameter cannot be created. In this case, check that the table of the variation parameter being created contains any selected values.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    object_id = 56 # int | Id of the object.
    rc_id = 56 # int | Id of the running configuration.
    variation_id = 'variation_id_example' # str | Id of the variation parameter (pass 'new' for a new variation parameter).

    try:
        # Returns whether the variable parameter with identifier variationId has the selected data in the table.
        api_response = api_instance.does_variable_parameter_has_selected_data(object_id, rc_id, variation_id)
        print("The response of OpenApiApi->does_variable_parameter_has_selected_data:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->does_variable_parameter_has_selected_data: %s\n" % e)

Name	Type	Description	Notes
object_id	int	Id of the object.
rc_id	int	Id of the running configuration.
variation_id	str	Id of the variation parameter (pass 'new' for a new variation parameter).

bool

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

bytearray export_dashboard_page(experiment_result_id, page_id)

Returns an Excel representation of the dashboard page with id pageId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    experiment_result_id = 56 # int | Id of the experiment result.
    page_id = 56 # int | Id of the page with experiment run statistics.

    try:
        # Returns an Excel representation of the dashboard page with id pageId.
        api_response = api_instance.export_dashboard_page(experiment_result_id, page_id)
        print("The response of OpenApiApi->export_dashboard_page:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->export_dashboard_page: %s\n" % e)

Name	Type	Description	Notes
experiment_result_id	int	Id of the experiment result.
page_id	int	Id of the page with experiment run statistics.

bytearray

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiProjectResponse find_and_open_project_by_name(full_match, project_name)

Opens project with name projectName.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_project_response import ApiProjectResponse
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    full_match = True # bool | Whether to match project name by complete match. (default to True)
    project_name = 'project_name_example' # str | Name of the project.

    try:
        # Opens project with name projectName.
        api_response = api_instance.find_and_open_project_by_name(full_match, project_name)
        print("The response of OpenApiApi->find_and_open_project_by_name:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->find_and_open_project_by_name: %s\n" % e)

Name	Type	Description	Notes
full_match	bool	Whether to match project name by complete match.	[default to True]
project_name	str	Name of the project.

ApiProjectResponse

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiStrictTableChartData get_comparison_result_data(rc_id)

Returns comparison result data.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_strict_table_chart_data import ApiStrictTableChartData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns comparison result data.
        api_response = api_instance.get_comparison_result_data(rc_id)
        print("The response of OpenApiApi->get_comparison_result_data:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_comparison_result_data: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

ApiStrictTableChartData

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiStrictTableData get_existing_variable_parameter_table_data(object_id, object_type_id, parameter_id, rc_id, skip, take, variation_id, variation_type)

Returns a table data of a variation with the given variationId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_strict_table_data import ApiStrictTableData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    object_id = 'object_id_example' # str | Id of the object.
    object_type_id = 'object_type_id_example' # str | Id of the object type.
    parameter_id = 'parameter_id_example' # str | Id of the parameter.
    rc_id = 56 # int | Id of the running configuration.
    skip = 0 # int | Number of records to skip. (default to 0)
    take = 1000 # int | Number of records to be retrieved. (default to 1000)
    variation_id = 56 # int | Id of the variation parameter.
    variation_type = 'variation_type_example' # str | Id of the variation type.

    try:
        # Returns a table data of a variation with the given variationId.
        api_response = api_instance.get_existing_variable_parameter_table_data(object_id, object_type_id, parameter_id, rc_id, skip, take, variation_id, variation_type)
        print("The response of OpenApiApi->get_existing_variable_parameter_table_data:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_existing_variable_parameter_table_data: %s\n" % e)

Name	Type	Description	Notes
object_id	str	Id of the object.
object_type_id	str	Id of the object type.
parameter_id	str	Id of the parameter.
rc_id	int	Id of the running configuration.
skip	int	Number of records to skip.	[default to 0]
take	int	Number of records to be retrieved.	[default to 1000]
variation_id	int	Id of the variation parameter.
variation_type	str	Id of the variation type.

ApiStrictTableData

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiARunConfigurationWrapper get_experiment(experiment_type, scenario_id)

Returns an experiment of a given type available for a given scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_a_run_configuration_wrapper import ApiARunConfigurationWrapper
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    experiment_type = 'experiment_type_example' # str | Type of the experiment.
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns an experiment of a given type available for a given scenario.
        api_response = api_instance.get_experiment(experiment_type, scenario_id)
        print("The response of OpenApiApi->get_experiment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment: %s\n" % e)

Name	Type	Description	Notes
experiment_type	str	Type of the experiment.
scenario_id	int	Id of the scenario.

ApiARunConfigurationWrapper

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiDashboardPage get_experiment_dashboard_page(experiment_result_id, full_match, page_name)

Returns statistic page with the given pageName for the result of experiment run.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_dashboard_page import ApiDashboardPage
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    experiment_result_id = 56 # int | Id of the experiment result.
    full_match = True # bool | Whether to match page name by complete match. (default to True)
    page_name = 'page_name_example' # str | Page name

    try:
        # Returns statistic page with the given pageName for the result of experiment run.
        api_response = api_instance.get_experiment_dashboard_page(experiment_result_id, full_match, page_name)
        print("The response of OpenApiApi->get_experiment_dashboard_page:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_dashboard_page: %s\n" % e)

Name	Type	Description	Notes
experiment_result_id	int	Id of the experiment result.
full_match	bool	Whether to match page name by complete match.	[default to True]
page_name	str	Page name

ApiDashboardPage

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiDashboardPage] get_experiment_dashboard_pages(experiment_result_id)

Returns statistics pages for the result of experiment run.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_dashboard_page import ApiDashboardPage
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    experiment_result_id = 56 # int | Id of the experiment result.

    try:
        # Returns statistics pages for the result of experiment run.
        api_response = api_instance.get_experiment_dashboard_pages(experiment_result_id)
        print("The response of OpenApiApi->get_experiment_dashboard_pages:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_dashboard_pages: %s\n" % e)

Name	Type	Description	Notes
experiment_result_id	int	Id of the experiment result.

List[ApiDashboardPage]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiOptionList get_experiment_options(skip, take, body=body)

Returns a list of possible values for various experiment options.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_option_list import ApiOptionList
from openapi_client.models.api_option_request import ApiOptionRequest
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    skip = 0 # int | Number of records to skip. (default to 0)
    take = 1000 # int | Number of records to be retrieved. (default to 1000)
    body = openapi_client.ApiOptionRequest() # ApiOptionRequest | An object containing a request to obtain a set of possible values. (optional)

    try:
        # Returns a list of possible values for various experiment options.
        api_response = api_instance.get_experiment_options(skip, take, body=body)
        print("The response of OpenApiApi->get_experiment_options:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_options: %s\n" % e)

Name	Type	Description	Notes
skip	int	Number of records to skip.	[default to 0]
take	int	Number of records to be retrieved.	[default to 1000]
body	ApiOptionRequest	An object containing a request to obtain a set of possible values.	[optional]

ApiOptionList

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiARunConfigurationWrapper get_experiment_run_configuration(rc_id)

Returns experiment settings.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_a_run_configuration_wrapper import ApiARunConfigurationWrapper
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns experiment settings.
        api_response = api_instance.get_experiment_run_configuration(rc_id)
        print("The response of OpenApiApi->get_experiment_run_configuration:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_run_configuration: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

ApiARunConfigurationWrapper

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiExperimentResultData get_experiment_run_result(rc_id, skip, take)

Returns all the results of the specific experiment run.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_experiment_result_data import ApiExperimentResultData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.
    skip = 0 # int | Number of records to skip. (default to 0)
    take = 1000 # int | Number of records to be retrieved. (default to 1000)

    try:
        # Returns all the results of the specific experiment run.
        api_response = api_instance.get_experiment_run_result(rc_id, skip, take)
        print("The response of OpenApiApi->get_experiment_run_result:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_run_result: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.
skip	int	Number of records to skip.	[default to 0]
take	int	Number of records to be retrieved.	[default to 1000]

ApiExperimentResultData

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiGraphChartData get_experiment_run_result_chart_graph_data(chart_id, rc_id)

Returns graph data for the chart with identifier chartId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_graph_chart_data import ApiGraphChartData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    chart_id = 56 # int | Id of the chart with experiment run statistics.
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns graph data for the chart with identifier chartId.
        api_response = api_instance.get_experiment_run_result_chart_graph_data(chart_id, rc_id)
        print("The response of OpenApiApi->get_experiment_run_result_chart_graph_data:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_run_result_chart_graph_data: %s\n" % e)

Name	Type	Description	Notes
chart_id	int	Id of the chart with experiment run statistics.
rc_id	int	Id of the running configuration.

ApiGraphChartData

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiStrictTableChartData get_experiment_run_result_chart_table_data(chart_id, rc_id, skip, take)

Returns table data for the chart with identifier chartId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_strict_table_chart_data import ApiStrictTableChartData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    chart_id = 56 # int | Id of the chart with experiment run statistics.
    rc_id = 56 # int | Id of the running configuration.
    skip = 0 # int | Number of records to skip. (default to 0)
    take = 1000 # int | Number of records to be retrieved. (default to 1000)

    try:
        # Returns table data for the chart with identifier chartId.
        api_response = api_instance.get_experiment_run_result_chart_table_data(chart_id, rc_id, skip, take)
        print("The response of OpenApiApi->get_experiment_run_result_chart_table_data:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_run_result_chart_table_data: %s\n" % e)

Name	Type	Description	Notes
chart_id	int	Id of the chart with experiment run statistics.
rc_id	int	Id of the running configuration.
skip	int	Number of records to skip.	[default to 0]
take	int	Number of records to be retrieved.	[default to 1000]

ApiStrictTableChartData

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiExperimentResultOption] get_experiment_run_result_options(rc_id, skip, take)

Returns options for the result of experiment run.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_experiment_result_option import ApiExperimentResultOption
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.
    skip = 0 # int | Number of records to skip. (default to 0)
    take = 1000 # int | Number of records to be retrieved. (default to 1000)

    try:
        # Returns options for the result of experiment run.
        api_response = api_instance.get_experiment_run_result_options(rc_id, skip, take)
        print("The response of OpenApiApi->get_experiment_run_result_options:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_run_result_options: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.
skip	int	Number of records to skip.	[default to 0]
take	int	Number of records to be retrieved.	[default to 1000]

List[ApiExperimentResultOption]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiChartMetadataShort] get_experiment_run_result_page_charts(page_id, rc_id)

Returns charts on the statistics page with the identifier pageId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_chart_metadata_short import ApiChartMetadataShort
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    page_id = 56 # int | Id of the page with experiment run statistics.
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns charts on the statistics page with the identifier pageId.
        api_response = api_instance.get_experiment_run_result_page_charts(page_id, rc_id)
        print("The response of OpenApiApi->get_experiment_run_result_page_charts:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_run_result_page_charts: %s\n" % e)

Name	Type	Description	Notes
page_id	int	Id of the page with experiment run statistics.
rc_id	int	Id of the running configuration.

List[ApiChartMetadataShort]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiPage] get_experiment_run_result_pages(rc_id)

Returns statistics pages for the result of experiment run.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_page import ApiPage
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns statistics pages for the result of experiment run.
        api_response = api_instance.get_experiment_run_result_pages(rc_id)
        print("The response of OpenApiApi->get_experiment_run_result_pages:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_run_result_pages: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

List[ApiPage]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiBasicRun] get_experiment_runs_for_scenario(scenario_id)

Returns the results of experiment runs for scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_basic_run import ApiBasicRun
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns the results of experiment runs for scenario.
        api_response = api_instance.get_experiment_runs_for_scenario(scenario_id)
        print("The response of OpenApiApi->get_experiment_runs_for_scenario:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_runs_for_scenario: %s\n" % e)

Name	Type	Description	Notes
scenario_id	int	Id of the scenario.

List[ApiBasicRun]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ExecutionState get_experiment_status(rc_id)

Returns the experiment status.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.execution_state import ExecutionState
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns the experiment status.
        api_response = api_instance.get_experiment_status(rc_id)
        print("The response of OpenApiApi->get_experiment_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiment_status: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

ExecutionState

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiBasicRunConfiguration] get_experiments(project_id, scenario_id)

Returns a list of experiments available for a given scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_basic_run_configuration import ApiBasicRunConfiguration
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    project_id = 56 # int | Id of the project.
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns a list of experiments available for a given scenario.
        api_response = api_instance.get_experiments(project_id, scenario_id)
        print("The response of OpenApiApi->get_experiments:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_experiments: %s\n" % e)

Name	Type	Description	Notes
project_id	int	Id of the project.
scenario_id	int	Id of the scenario.

List[ApiBasicRunConfiguration]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiImportScenarioStatus get_import_status(job_id)

Returns scenario import status.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_import_scenario_status import ApiImportScenarioStatus
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    job_id = 56 # int | Id of the import job.

    try:
        # Returns scenario import status.
        api_response = api_instance.get_import_status(job_id)
        print("The response of OpenApiApi->get_import_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_import_status: %s\n" % e)

Name	Type	Description	Notes
job_id	int	Id of the import job.

ApiImportScenarioStatus

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiStrictTableData get_new_variable_parameter_table_data(object_id, object_type_id, parameter_id, rc_id, skip, take, variation_type)

Returns a table data of a variation with the given variationId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_strict_table_data import ApiStrictTableData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    object_id = 'object_id_example' # str | Id of the object.
    object_type_id = 'object_type_id_example' # str | Id of the object type.
    parameter_id = 'parameter_id_example' # str | Id of the parameter.
    rc_id = 56 # int | Id of the running configuration.
    skip = 0 # int | Number of records to skip. (default to 0)
    take = 1000 # int | Number of records to be retrieved. (default to 1000)
    variation_type = 'variation_type_example' # str | Id of the variation type.

    try:
        # Returns a table data of a variation with the given variationId.
        api_response = api_instance.get_new_variable_parameter_table_data(object_id, object_type_id, parameter_id, rc_id, skip, take, variation_type)
        print("The response of OpenApiApi->get_new_variable_parameter_table_data:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_new_variable_parameter_table_data: %s\n" % e)

Name	Type	Description	Notes
object_id	str	Id of the object.
object_type_id	str	Id of the object type.
parameter_id	str	Id of the parameter.
rc_id	int	Id of the running configuration.
skip	int	Number of records to skip.	[default to 0]
take	int	Number of records to be retrieved.	[default to 1000]
variation_type	str	Id of the variation type.

ApiStrictTableData

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiProjectResponse] get_projects()

Returns a list of projects that the user has access to.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_project_response import ApiProjectResponse
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)

    try:
        # Returns a list of projects that the user has access to.
        api_response = api_instance.get_projects()
        print("The response of OpenApiApi->get_projects:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_projects: %s\n" % e)

This endpoint does not need any parameter.

List[ApiProjectResponse]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

str get_scenario_validation_status(scenario_id)

Returns the validation status of the scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns the validation status of the scenario.
        api_response = api_instance.get_scenario_validation_status(scenario_id)
        print("The response of OpenApiApi->get_scenario_validation_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_scenario_validation_status: %s\n" % e)

Name	Type	Description	Notes
scenario_id	int	Id of the scenario.

str

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiOptionList get_scenarios_from_imported_database(body=body)

Returns a list of scenarios available for import in the imported database.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_option_list import ApiOptionList
from openapi_client.models.db_connection_properties import DBConnectionProperties
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    body = openapi_client.DBConnectionProperties() # DBConnectionProperties | Database connection properties. (optional)

    try:
        # Returns a list of scenarios available for import in the imported database.
        api_response = api_instance.get_scenarios_from_imported_database(body=body)
        print("The response of OpenApiApi->get_scenarios_from_imported_database:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_scenarios_from_imported_database: %s\n" % e)

Name	Type	Description	Notes
body	DBConnectionProperties	Database connection properties.	[optional]

ApiOptionList

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiStatisticsConfiguration] get_statistics_configurations(rc_id)

Returns a list of available statistics.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_statistics_configuration import ApiStatisticsConfiguration
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns a list of available statistics.
        api_response = api_instance.get_statistics_configurations(rc_id)
        print("The response of OpenApiApi->get_statistics_configurations:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_statistics_configurations: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

List[ApiStatisticsConfiguration]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiTableMeta] get_tables_meta()

Returns a list of meta information for tables.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_table_meta import ApiTableMeta
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)

    try:
        # Returns a list of meta information for tables.
        api_response = api_instance.get_tables_meta()
        print("The response of OpenApiApi->get_tables_meta:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_tables_meta: %s\n" % e)

This endpoint does not need any parameter.

List[ApiTableMeta]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiValidationError] get_validation_errors(scenario_id)

Returns validation errors.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_validation_error import ApiValidationError
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns validation errors.
        api_response = api_instance.get_validation_errors(scenario_id)
        print("The response of OpenApiApi->get_validation_errors:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_validation_errors: %s\n" % e)

Name	Type	Description	Notes
scenario_id	int	Id of the scenario.

List[ApiValidationError]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiValidationWarning] get_validation_warnings(scenario_id)

Returns validation warnings.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_validation_warning import ApiValidationWarning
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns validation warnings.
        api_response = api_instance.get_validation_warnings(scenario_id)
        print("The response of OpenApiApi->get_validation_warnings:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_validation_warnings: %s\n" % e)

Name	Type	Description	Notes
scenario_id	int	Id of the scenario.

List[ApiValidationWarning]

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiIdNameObject get_variable_parameter_object_type(full_match, parameter_name, scenario_id)

Return a list of object types that have variable parameters.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_id_name_object import ApiIdNameObject
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    full_match = True # bool | Whether to match parameter name by complete match. (default to True)
    parameter_name = 'parameter_name_example' # str | Parameter name
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Return a list of object types that have variable parameters.
        api_response = api_instance.get_variable_parameter_object_type(full_match, parameter_name, scenario_id)
        print("The response of OpenApiApi->get_variable_parameter_object_type:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_variable_parameter_object_type: %s\n" % e)

Name	Type	Description	Notes
full_match	bool	Whether to match parameter name by complete match.	[default to True]
parameter_name	str	Parameter name
scenario_id	int	Id of the scenario.

ApiIdNameObject

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiOptionList get_variable_parameter_object_types(scenario_id)

Returns a list of object types that have variable parameters.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_option_list import ApiOptionList
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns a list of object types that have variable parameters.
        api_response = api_instance.get_variable_parameter_object_types(scenario_id)
        print("The response of OpenApiApi->get_variable_parameter_object_types:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_variable_parameter_object_types: %s\n" % e)

Name	Type	Description	Notes
scenario_id	int	Id of the scenario.

ApiOptionList

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiOptionList get_variable_parameter_objects(object_type_id, scenario_id, skip, take)

Returns a list of variable parameter objects of the given object type with identifier objectTypeId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_option_list import ApiOptionList
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    object_type_id = 'object_type_id_example' # str | Id of the object type.
    scenario_id = 56 # int | Id of the scenario.
    skip = 0 # int | Number of records to skip. (default to 0)
    take = 1000 # int | Number of records to be retrieved. (default to 1000)

    try:
        # Returns a list of variable parameter objects of the given object type with identifier objectTypeId.
        api_response = api_instance.get_variable_parameter_objects(object_type_id, scenario_id, skip, take)
        print("The response of OpenApiApi->get_variable_parameter_objects:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_variable_parameter_objects: %s\n" % e)

Name	Type	Description	Notes
object_type_id	str	Id of the object type.
scenario_id	int	Id of the scenario.
skip	int	Number of records to skip.	[default to 0]
take	int	Number of records to be retrieved.	[default to 1000]

ApiOptionList

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiOptionList get_variable_parameter_parameters(object_id, object_type_id, scenario_id)

Returns a list of parameters of an object with id objectId with type with id objectTypeId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_option_list import ApiOptionList
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    object_id = 'object_id_example' # str | Id of the object.
    object_type_id = 'object_type_id_example' # str | Id of the object type.
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns a list of parameters of an object with id objectId with type with id objectTypeId.
        api_response = api_instance.get_variable_parameter_parameters(object_id, object_type_id, scenario_id)
        print("The response of OpenApiApi->get_variable_parameter_parameters:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_variable_parameter_parameters: %s\n" % e)

Name	Type	Description	Notes
object_id	str	Id of the object.
object_type_id	str	Id of the object type.
scenario_id	int	Id of the scenario.

ApiOptionList

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiOptionList get_variable_parameter_variation_types(object_id, object_type_id, parameter_id, scenario_id)

Returns a list of parameter variation types for a parameter with id parameterId belonging to an object with id objectId with a type with id objectTypeId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_option_list import ApiOptionList
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    object_id = 'object_id_example' # str | Id of the object.
    object_type_id = 'object_type_id_example' # str | Id of the object type.
    parameter_id = 'parameter_id_example' # str | Id of the parameter.
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Returns a list of parameter variation types for a parameter with id parameterId belonging to an object with id objectId with a type with id objectTypeId.
        api_response = api_instance.get_variable_parameter_variation_types(object_id, object_type_id, parameter_id, scenario_id)
        print("The response of OpenApiApi->get_variable_parameter_variation_types:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_variable_parameter_variation_types: %s\n" % e)

Name	Type	Description	Notes
object_id	str	Id of the object.
object_type_id	str	Id of the object type.
parameter_id	str	Id of the parameter.
scenario_id	int	Id of the scenario.

ApiOptionList

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiStrictTableChartData get_variation_result_data(rc_id)

Returns variation result data.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_strict_table_chart_data import ApiStrictTableChartData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Returns variation result data.
        api_response = api_instance.get_variation_result_data(rc_id)
        print("The response of OpenApiApi->get_variation_result_data:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->get_variation_result_data: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

ApiStrictTableChartData

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

import_cancel(body=body)

Cancels scenario import job.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_import_scenario_cancel_request import ApiImportScenarioCancelRequest
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    body = openapi_client.ApiImportScenarioCancelRequest() # ApiImportScenarioCancelRequest | Cancel import request object. (optional)

    try:
        # Cancels scenario import job.
        api_instance.import_cancel(body=body)
    except Exception as e:
        print("Exception when calling OpenApiApi->import_cancel: %s\n" % e)

Name	Type	Description	Notes
body	ApiImportScenarioCancelRequest	Cancel import request object.	[optional]

void (empty response body)

ApiKey

• Content-Type: application/json
• Accept: Not defined

Status code	Description	Response headers
0	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiImportResponse] import_database(new_scenario_name, project_id, source_scenario_name_list, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import, body=body)

Imports scenarios from the list sourceScenarioNameList from an external database.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_import_response import ApiImportResponse
from openapi_client.models.db_connection_properties import DBConnectionProperties
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    new_scenario_name = 'new_scenario_name_example' # str | Desired scenario name.
    project_id = 56 # int | Id of the project.
    source_scenario_name_list = ['source_scenario_name_list_example'] # List[str] | List of scenarios to import.
    need_to_import_experiments = True # bool | Whether to import experiments. (optional)
    override_existing_project_conversion_rules = True # bool | Whether to override existing project conversion rules. (optional)
    table_ids_to_import = ['table_ids_to_import_example'] # List[str] | List of table IDs to import. (optional)
    body = openapi_client.DBConnectionProperties() # DBConnectionProperties | Database connection properties. (optional)

    try:
        # Imports scenarios from the list sourceScenarioNameList from an external database.
        api_response = api_instance.import_database(new_scenario_name, project_id, source_scenario_name_list, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import, body=body)
        print("The response of OpenApiApi->import_database:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->import_database: %s\n" % e)

Name	Type	Description	Notes
new_scenario_name	str	Desired scenario name.
project_id	int	Id of the project.
source_scenario_name_list	List[str]	List of scenarios to import.
need_to_import_experiments	bool	Whether to import experiments.	[optional]
override_existing_project_conversion_rules	bool	Whether to override existing project conversion rules.	[optional]
table_ids_to_import	List[str]	List of table IDs to import.	[optional]
body	DBConnectionProperties	Database connection properties.	[optional]

List[ApiImportResponse]

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiImportResponse] import_database_existing(project_id, scenario_id, source_scenario_name, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import, body=body)

Imports scenario sourceScenarioName from an external database into existing scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_import_response import ApiImportResponse
from openapi_client.models.db_connection_properties import DBConnectionProperties
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    project_id = 56 # int | Id of the project.
    scenario_id = 56 # int | Id of the scenario.
    source_scenario_name = 'source_scenario_name_example' # str | Scenario to import.
    need_to_import_experiments = True # bool | Whether to import experiments. (optional)
    override_existing_project_conversion_rules = True # bool | Whether to override existing project conversion rules. (optional)
    table_ids_to_import = ['table_ids_to_import_example'] # List[str] | List of table IDs to import. (optional)
    body = openapi_client.DBConnectionProperties() # DBConnectionProperties | Database connection properties. (optional)

    try:
        # Imports scenario sourceScenarioName from an external database into existing scenario.
        api_response = api_instance.import_database_existing(project_id, scenario_id, source_scenario_name, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import, body=body)
        print("The response of OpenApiApi->import_database_existing:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->import_database_existing: %s\n" % e)

Name	Type	Description	Notes
project_id	int	Id of the project.
scenario_id	int	Id of the scenario.
source_scenario_name	str	Scenario to import.
need_to_import_experiments	bool	Whether to import experiments.	[optional]
override_existing_project_conversion_rules	bool	Whether to override existing project conversion rules.	[optional]
table_ids_to_import	List[str]	List of table IDs to import.	[optional]
body	DBConnectionProperties	Database connection properties.	[optional]

List[ApiImportResponse]

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiImportResponse import_excel(new_scenario_name, project_id, file, contains_formulas=contains_formulas, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import)

Asynchronously imports scenario from excel file.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_import_response import ApiImportResponse
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    new_scenario_name = 'new_scenario_name_example' # str | Desired scenario name.
    project_id = 56 # int | Id of the project.
    file = None # bytearray | Excel file data to be imported.
    contains_formulas = True # bool | Whether importing excel file contains formulas. (optional)
    need_to_import_experiments = True # bool | Whether to import experiments. (optional)
    override_existing_project_conversion_rules = True # bool | Whether to override existing project conversion rules. (optional)
    table_ids_to_import = ['table_ids_to_import_example'] # List[str] | List of table IDs to import. (optional)

    try:
        # Asynchronously imports scenario from excel file.
        api_response = api_instance.import_excel(new_scenario_name, project_id, file, contains_formulas=contains_formulas, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import)
        print("The response of OpenApiApi->import_excel:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->import_excel: %s\n" % e)

Name	Type	Description	Notes
new_scenario_name	str	Desired scenario name.
project_id	int	Id of the project.
file	bytearray	Excel file data to be imported.
contains_formulas	bool	Whether importing excel file contains formulas.	[optional]
need_to_import_experiments	bool	Whether to import experiments.	[optional]
override_existing_project_conversion_rules	bool	Whether to override existing project conversion rules.	[optional]
table_ids_to_import	List[str]	List of table IDs to import.	[optional]

ApiImportResponse

ApiKey

• Content-Type: multipart/form-data
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

List[ApiImportResponse] import_excel_existing(new_scenario_name, project_id, scenario_id, file, contains_formulas=contains_formulas, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import)

Asynchronously imports scenario from excel file into existing scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_import_response import ApiImportResponse
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    new_scenario_name = 'new_scenario_name_example' # str | Desired scenario name.
    project_id = 56 # int | Id of the project.
    scenario_id = 56 # int | Id of the scenario.
    file = None # bytearray | Excel file data to be imported.
    contains_formulas = True # bool | Whether importing excel file contains formulas. (optional)
    need_to_import_experiments = True # bool | Whether to import experiments. (optional)
    override_existing_project_conversion_rules = True # bool | Whether to override existing project conversion rules. (optional)
    table_ids_to_import = ['table_ids_to_import_example'] # List[str] | List of table IDs to import. (optional)

    try:
        # Asynchronously imports scenario from excel file into existing scenario.
        api_response = api_instance.import_excel_existing(new_scenario_name, project_id, scenario_id, file, contains_formulas=contains_formulas, need_to_import_experiments=need_to_import_experiments, override_existing_project_conversion_rules=override_existing_project_conversion_rules, table_ids_to_import=table_ids_to_import)
        print("The response of OpenApiApi->import_excel_existing:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->import_excel_existing: %s\n" % e)

Name	Type	Description	Notes
new_scenario_name	str	Desired scenario name.
project_id	int	Id of the project.
scenario_id	int	Id of the scenario.
file	bytearray	Excel file data to be imported.
contains_formulas	bool	Whether importing excel file contains formulas.	[optional]
need_to_import_experiments	bool	Whether to import experiments.	[optional]
override_existing_project_conversion_rules	bool	Whether to override existing project conversion rules.	[optional]
table_ids_to_import	List[str]	List of table IDs to import.	[optional]

List[ApiImportResponse]

ApiKey

• Content-Type: multipart/form-data
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiScenarioData import_scenario(project_id, file)

Synchronously imports scenario from excel file.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_scenario_data import ApiScenarioData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    project_id = 56 # int | Id of the project.
    file = None # bytearray | Excel file data to be imported.

    try:
        # Synchronously imports scenario from excel file.
        api_response = api_instance.import_scenario(project_id, file)
        print("The response of OpenApiApi->import_scenario:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->import_scenario: %s\n" % e)

Name	Type	Description	Notes
project_id	int	Id of the project.
file	bytearray	Excel file data to be imported.

ApiScenarioData

ApiKey

• Content-Type: multipart/form-data
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiScenarioData import_scenario_existing(project_id, scenario_id, file, clean_tables=clean_tables, table_ids_to_import=table_ids_to_import)

Synchronously imports scenario from excel file into existing scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_scenario_data import ApiScenarioData
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    project_id = 56 # int | Id of the project.
    scenario_id = 56 # int | Id of the scenario.
    file = None # bytearray | Excel file data to be imported.
    clean_tables = True # bool | Whether to clear the corresponding tables before importing. (optional)
    table_ids_to_import = ['table_ids_to_import_example'] # List[str] | List of table IDs to import. (optional)

    try:
        # Synchronously imports scenario from excel file into existing scenario.
        api_response = api_instance.import_scenario_existing(project_id, scenario_id, file, clean_tables=clean_tables, table_ids_to_import=table_ids_to_import)
        print("The response of OpenApiApi->import_scenario_existing:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->import_scenario_existing: %s\n" % e)

Name	Type	Description	Notes
project_id	int	Id of the project.
scenario_id	int	Id of the scenario.
file	bytearray	Excel file data to be imported.
clean_tables	bool	Whether to clear the corresponding tables before importing.	[optional]
table_ids_to_import	List[str]	List of table IDs to import.	[optional]

ApiScenarioData

ApiKey

• Content-Type: multipart/form-data
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiProjectResponse open_project(project_id)

Opens project with identifier projectId.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_project_response import ApiProjectResponse
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    project_id = 56 # int | Id of the project.

    try:
        # Opens project with identifier projectId.
        api_response = api_instance.open_project(project_id)
        print("The response of OpenApiApi->open_project:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->open_project: %s\n" % e)

Name	Type	Description	Notes
project_id	int	Id of the project.

ApiProjectResponse

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

bool remove_scenario_by_id(scenario_id)

Deletes a scenario.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    scenario_id = 56 # int | Id of the scenario.

    try:
        # Deletes a scenario.
        api_response = api_instance.remove_scenario_by_id(scenario_id)
        print("The response of OpenApiApi->remove_scenario_by_id:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->remove_scenario_by_id: %s\n" % e)

Name	Type	Description	Notes
scenario_id	int	Id of the scenario.

bool

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiRunExperiment run_experiment(rc_id, skip_scenario_warnings=skip_scenario_warnings)

Starts the experiment asynchronously.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_run_experiment import ApiRunExperiment
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.
    skip_scenario_warnings = True # bool | Whether to skip scenario warnings. (optional)

    try:
        # Starts the experiment asynchronously.
        api_response = api_instance.run_experiment(rc_id, skip_scenario_warnings=skip_scenario_warnings)
        print("The response of OpenApiApi->run_experiment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->run_experiment: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.
skip_scenario_warnings	bool	Whether to skip scenario warnings.	[optional]

ApiRunExperiment

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiExperimentResult run_experiment_synchronously(rc_id)

Starts the experiment synchronously.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_experiment_result import ApiExperimentResult
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Starts the experiment synchronously.
        api_response = api_instance.run_experiment_synchronously(rc_id)
        print("The response of OpenApiApi->run_experiment_synchronously:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->run_experiment_synchronously: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

ApiExperimentResult

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

str stop_experiment(rc_id)

Stops the experiment.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.

    try:
        # Stops the experiment.
        api_response = api_instance.stop_experiment(rc_id)
        print("The response of OpenApiApi->stop_experiment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->stop_experiment: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.

str

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

str translate(string_to_be_translated)

Returns translation for string stringToBeTranslated.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    string_to_be_translated = 'string_to_be_translated_example' # str | String to be translated.

    try:
        # Returns translation for string stringToBeTranslated.
        api_response = api_instance.translate(string_to_be_translated)
        print("The response of OpenApiApi->translate:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->translate: %s\n" % e)

Name	Type	Description	Notes
string_to_be_translated	str	String to be translated.

str

ApiKey

• Content-Type: Not defined
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

update_existing_variable_parameter_table_data_by_index(object_id, object_type_id, parameter_id, rc_id, variation_id, variation_type, body=body)

Updates a variation table data by index.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_base_index_selection_value_request import ApiBaseIndexSelectionValueRequest
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    object_id = 'object_id_example' # str | Id of the object.
    object_type_id = 'object_type_id_example' # str | Id of the object type.
    parameter_id = 'parameter_id_example' # str | Id of the parameter.
    rc_id = 56 # int | Id of the running configuration.
    variation_id = 56 # int | Id of the variation parameter.
    variation_type = 'variation_type_example' # str | Id of the variation type.
    body = [openapi_client.ApiBaseIndexSelectionValueRequest()] # List[ApiBaseIndexSelectionValueRequest] | Data containing information about the rows in the table whose value needs to be set. (optional)

    try:
        # Updates a variation table data by index.
        api_instance.update_existing_variable_parameter_table_data_by_index(object_id, object_type_id, parameter_id, rc_id, variation_id, variation_type, body=body)
    except Exception as e:
        print("Exception when calling OpenApiApi->update_existing_variable_parameter_table_data_by_index: %s\n" % e)

Name	Type	Description	Notes
object_id	str	Id of the object.
object_type_id	str	Id of the object type.
parameter_id	str	Id of the parameter.
rc_id	int	Id of the running configuration.
variation_id	int	Id of the variation parameter.
variation_type	str	Id of the variation type.
body	List[ApiBaseIndexSelectionValueRequest]	Data containing information about the rows in the table whose value needs to be set.	[optional]

void (empty response body)

ApiKey

• Content-Type: application/json
• Accept: Not defined

Status code	Description	Response headers
0	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiARunConfigurationWrapper update_experiment_run_configuration(body=body)

Updates experiment settings.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_a_run_configuration_wrapper import ApiARunConfigurationWrapper
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    body = openapi_client.ApiARunConfigurationWrapper() # ApiARunConfigurationWrapper | Updated experiment run configuration data. (optional)

    try:
        # Updates experiment settings.
        api_response = api_instance.update_experiment_run_configuration(body=body)
        print("The response of OpenApiApi->update_experiment_run_configuration:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->update_experiment_run_configuration: %s\n" % e)

Name	Type	Description	Notes
body	ApiARunConfigurationWrapper	Updated experiment run configuration data.	[optional]

ApiARunConfigurationWrapper

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ApiVariation update_variable_parameter(rc_id, body=body)

Updates the variation parameter represented by the variation object.

• Api Key Authentication (ApiKey):

import time
import os
import openapi_client
from openapi_client.models.api_variation import ApiVariation
from openapi_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKey
configuration.api_key['ApiKey'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKey'] = 'Bearer'

# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = openapi_client.OpenApiApi(api_client)
    rc_id = 56 # int | Id of the running configuration.
    body = openapi_client.ApiVariation() # ApiVariation | Variation parameter data. (optional)

    try:
        # Updates the variation parameter represented by the variation object.
        api_response = api_instance.update_variable_parameter(rc_id, body=body)
        print("The response of OpenApiApi->update_variable_parameter:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling OpenApiApi->update_variable_parameter: %s\n" % e)

Name	Type	Description	Notes
rc_id	int	Id of the running configuration.
body	ApiVariation	Variation parameter data.	[optional]

ApiVariation

ApiKey

• Content-Type: application/json
• Accept: /

Status code	Description	Response headers
200	successful operation	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

How can we improve this article?

Send