anyLogistix
Expand
Font size

openapi_client.OpenApiApi

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_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 Imports scenario from excel file.
import_excel_existing POST /open/import/import-excel-existing Imports scenario from excel file into existing scenario.
import_scenario POST /open/import/import-scenario Import excel
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.
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.

close_project

ApiProjectResponse close_project()

Closes the currently open project.

Example

  • 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)

Parameters

This endpoint does not need any parameter.

Return type

ApiProjectResponse

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

create_new_variable_parameter

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.

Example

  • 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)

Parameters

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

Return type

ApiVariation

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

create_variable_parameter

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.

Example

  • 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)

Parameters

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

Return type

ApiVariation

Authorization

ApiKey

HTTP request headers

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

HTTP response details

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

delete_variable_parameter(rc_id, variation_id)

Deletes a variation parameter with identifier variationId.

Example

  • 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)

Parameters

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

Return type

void (empty response body)

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
0 successful operation -

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

does_variable_parameter_has_selected_data

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.

Example

  • 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)

Parameters

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).

Return type

bool

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

export_dashboard_page

bytearray export_dashboard_page(experiment_result_id, page_id)

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

Example

  • 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)

Parameters

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

Return type

bytearray

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

find_and_open_project_by_name

ApiProjectResponse find_and_open_project_by_name(full_match, project_name)

Opens project with name projectName.

Example

  • 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)

Parameters

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.

Return type

ApiProjectResponse

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_comparison_result_data

ApiStrictTableChartData get_comparison_result_data(rc_id)

Returns comparison result data.

Example

  • 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)

Parameters

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

Return type

ApiStrictTableChartData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_existing_variable_parameter_table_data

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.

Example

  • 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)

Parameters

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.

Return type

ApiStrictTableData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment

ApiARunConfigurationWrapper get_experiment(experiment_type, scenario_id)

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

Example

  • 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)

Parameters

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

Return type

ApiARunConfigurationWrapper

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_dashboard_page

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.

Example

  • 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)

Parameters

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

Return type

ApiDashboardPage

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_dashboard_pages

List[ApiDashboardPage] get_experiment_dashboard_pages(experiment_result_id)

Returns statistics pages for the result of experiment run.

Example

  • 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)

Parameters

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

Return type

List[ApiDashboardPage]

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_options

ApiOptionList get_experiment_options(skip, take, body=body)

Returns a list of possible values for various experiment options.

Example

  • 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)

Parameters

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]

Return type

ApiOptionList

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_run_configuration

ApiARunConfigurationWrapper get_experiment_run_configuration(rc_id)

Returns experiment settings.

Example

  • 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)

Parameters

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

Return type

ApiARunConfigurationWrapper

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_run_result

ApiExperimentResultData get_experiment_run_result(rc_id, skip, take)

Returns all the results of the specific experiment run.

Example

  • 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)

Parameters

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]

Return type

ApiExperimentResultData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_run_result_chart_graph_data

ApiGraphChartData get_experiment_run_result_chart_graph_data(chart_id, rc_id)

Returns graph data for the chart with identifier chartId.

Example

  • 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)

Parameters

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

Return type

ApiGraphChartData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_run_result_chart_table_data

ApiStrictTableChartData get_experiment_run_result_chart_table_data(chart_id, rc_id, skip, take)

Returns table data for the chart with identifier chartId.

Example

  • 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)

Parameters

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]

Return type

ApiStrictTableChartData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_run_result_options

ApiChartDataObject get_experiment_run_result_options(rc_id, skip, take)

Returns options for the result of experiment run.

Example

  • Api Key Authentication (ApiKey):
import time
import os
import openapi_client
from openapi_client.models.api_chart_data_object import ApiChartDataObject
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)

Parameters

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]

Return type

ApiChartDataObject

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_run_result_page_charts

List[ApiChartMetadataShort] get_experiment_run_result_page_charts(page_id, rc_id)

Returns charts on the statistics page with the identifier pageId.

Example

  • 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)

Parameters

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

Return type

List[ApiChartMetadataShort]

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_run_result_pages

List[ApiPage] get_experiment_run_result_pages(rc_id)

Returns statistics pages for the result of experiment run.

Example

  • 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)

Parameters

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

Return type

List[ApiPage]

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_runs_for_scenario

List[ApiBasicRun] get_experiment_runs_for_scenario(scenario_id)

Returns the results of experiment runs for scenario.

Example

  • 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)

Parameters

Name Type Description Notes
scenario_id int Id of the scenario.

Return type

List[ApiBasicRun]

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiment_status

ExecutionState get_experiment_status(rc_id)

Returns the experiment status.

Example

  • 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)

Parameters

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

Return type

ExecutionState

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_experiments

List[ApiBasicRunConfiguration] get_experiments(project_id, scenario_id)

Returns a list of experiments available for a given scenario.

Example

  • 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)

Parameters

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

Return type

List[ApiBasicRunConfiguration]

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_import_status

ApiImportScenarioStatus get_import_status(job_id)

Returns scenario import status.

Example

  • 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)

Parameters

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

Return type

ApiImportScenarioStatus

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_new_variable_parameter_table_data

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.

Example

  • 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)

Parameters

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.

Return type

ApiStrictTableData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_projects

List[ApiProjectResponse] get_projects()

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

Example

  • 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)

Parameters

This endpoint does not need any parameter.

Return type

List[ApiProjectResponse]

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_scenario_validation_status

str get_scenario_validation_status(scenario_id)

Returns the validation status of the scenario.

Example

  • 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)

Parameters

Name Type Description Notes
scenario_id int Id of the scenario.

Return type

str

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_scenarios_from_imported_database

ApiOptionList get_scenarios_from_imported_database(body=body)

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

Example

  • 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)

Parameters

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

Return type

ApiOptionList

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_validation_errors

ApiStrictTableData get_validation_errors(scenario_id)

Returns validation errors.

Example

  • 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)
    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)

Parameters

Name Type Description Notes
scenario_id int Id of the scenario.

Return type

ApiStrictTableData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_validation_warnings

ApiStrictTableData get_validation_warnings(scenario_id)

Returns validation warnings.

Example

  • 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)
    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)

Parameters

Name Type Description Notes
scenario_id int Id of the scenario.

Return type

ApiStrictTableData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_variable_parameter_object_type

ApiIdNameObject get_variable_parameter_object_type(full_match, parameter_name, scenario_id)

Return a list of object types that have variable parameters.

Example

  • 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)

Parameters

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.

Return type

ApiIdNameObject

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_variable_parameter_object_types

ApiOptionList get_variable_parameter_object_types(scenario_id)

Returns a list of object types that have variable parameters.

Example

  • 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)

Parameters

Name Type Description Notes
scenario_id int Id of the scenario.

Return type

ApiOptionList

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_variable_parameter_objects

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.

Example

  • 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)

Parameters

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]

Return type

ApiOptionList

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_variable_parameter_parameters

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.

Example

  • 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)

Parameters

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.

Return type

ApiOptionList

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_variable_parameter_variation_types

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.

Example

  • 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)

Parameters

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.

Return type

ApiOptionList

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

get_variation_result_data

ApiStrictTableChartData get_variation_result_data(rc_id)

Returns variation result data.

Example

  • 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)

Parameters

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

Return type

ApiStrictTableChartData

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

import_cancel

import_cancel(body=body)

Cancels scenario import job.

Example

  • 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)

Parameters

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

Return type

void (empty response body)

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
0 successful operation -

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

import_database

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, sheets_to_import=sheets_to_import, body=body)

Imports scenarios from the list sourceScenarioNameList from an external database.

Example

  • 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)
    sheets_to_import = ['sheets_to_import_example'] # List[str] | List of sheets 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, sheets_to_import=sheets_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)

Parameters

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]
sheets_to_import List[str] List of sheets to import. [optional]
body DBConnectionProperties Database connection properties. [optional]

Return type

List[ApiImportResponse]

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

import_database_existing

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, sheets_to_import=sheets_to_import, body=body)

Imports scenario sourceScenarioName from an external database into existing scenario.

Example

  • 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)
    sheets_to_import = ['sheets_to_import_example'] # List[str] | List of sheets 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, sheets_to_import=sheets_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)

Parameters

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]
sheets_to_import List[str] List of sheets to import. [optional]
body DBConnectionProperties Database connection properties. [optional]

Return type

List[ApiImportResponse]

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

import_excel

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, sheets_to_import=sheets_to_import)

Imports scenario from excel file.

Example

  • 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)
    sheets_to_import = ['sheets_to_import_example'] # List[str] | List of sheets to import. (optional)

    try:
        # 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, sheets_to_import=sheets_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)

Parameters

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]
sheets_to_import List[str] List of sheets to import. [optional]

Return type

ApiImportResponse

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

import_excel_existing

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, sheets_to_import=sheets_to_import)

Imports scenario from excel file into existing scenario.

Example

  • 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)
    sheets_to_import = ['sheets_to_import_example'] # List[str] | List of sheets to import. (optional)

    try:
        # 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, sheets_to_import=sheets_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)

Parameters

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]
sheets_to_import List[str] List of sheets to import. [optional]

Return type

List[ApiImportResponse]

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

import_scenario

ApiScenarioData import_scenario(project_id, file)

Import excel

Example

  • 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:
        # Import excel
        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)

Parameters

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

Return type

ApiScenarioData

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

open_project

ApiProjectResponse open_project(project_id)

Opens project with identifier projectId.

Example

  • 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)

Parameters

Name Type Description Notes
project_id int Id of the project.

Return type

ApiProjectResponse

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

remove_scenario_by_id

bool remove_scenario_by_id(scenario_id)

Deletes a scenario.

Example

  • 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)

Parameters

Name Type Description Notes
scenario_id int Id of the scenario.

Return type

bool

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

run_experiment

ApiRunExperiment run_experiment(rc_id, skip_scenario_warnings=skip_scenario_warnings)

Starts the experiment asynchronously.

Example

  • 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)

Parameters

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

Return type

ApiRunExperiment

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

run_experiment_synchronously

ApiExperimentResult run_experiment_synchronously(rc_id)

Starts the experiment synchronously.

Example

  • 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)

Parameters

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

Return type

ApiExperimentResult

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

Status code Description Response headers
200 successful operation -

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

stop_experiment

str stop_experiment(rc_id)

Stops the experiment.

Example

  • 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)

Parameters

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

Return type

str

Authorization

ApiKey

HTTP request headers

  • Content-Type: Not defined
  • Accept: /

HTTP response details

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

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.

Example

  • 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)

Parameters

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]

Return type

void (empty response body)

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
0 successful operation -

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

update_experiment_run_configuration

ApiARunConfigurationWrapper update_experiment_run_configuration(body=body)

Updates experiment settings.

Example

  • 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)

Parameters

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

Return type

ApiARunConfigurationWrapper

Authorization

ApiKey

HTTP request headers

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

HTTP response details

Status code Description Response headers
200 successful operation -

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

update_variable_parameter

ApiVariation update_variable_parameter(rc_id, body=body)

Updates the variation parameter represented by the variation object.

Example

  • 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)

Parameters

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

Return type

ApiVariation

Authorization

ApiKey

HTTP request headers

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

HTTP response details

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?