text: # coding: utf-8
  
  """
      NeoLoad API
  
      No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501
  
      The version of the OpenAPI document: 1.0
      Generated by: https://openapi-generator.tech
  """
  
  
  from __future__ import absolute_import
  
  import logging
  import multiprocessing
  import sys
  import urllib3
  
  import six
  from six.moves import http_client as httplib
  
  
  class Configuration(object):
      """NOTE: This class is auto generated by OpenAPI Generator
  
      Ref: https://openapi-generator.tech
      Do not edit the class manually.
  
      :param host: Base url
      :param api_key: Dict to store API key(s)
      :param api_key_prefix: Dict to store API prefix (e.g. Bearer)
      :param username: Username for HTTP basic authentication
      :param password: Password for HTTP basic authentication
      """
  
      def __init__(self, host="https://neoload-api.saas.neotys.com/v1",
                   api_key=None, api_key_prefix=None,
                   username="", password=""):
          """Constructor
          """
          self.host = host
          """Default Base url
          """
          self.temp_folder_path = None
          """Temp file folder for downloading files
          """
          # Authentication Settings
          self.api_key = {}
          if api_key:
              self.api_key = api_key
          """dict to store API key(s)
          """
          self.api_key_prefix = {}
          if api_key_prefix:
              self.api_key_prefix = api_key_prefix
          """dict to store API prefix (e.g. Bearer)
          """
          self.refresh_api_key_hook = None
          """function hook to refresh API key if expired
          """
          self.username = username
          """Username for HTTP basic authentication
          """
          self.password = password
          """Password for HTTP basic authentication
          """
          self.logger = {}
          """Logging Settings
          """
          self.logger["package_logger"] = logging.getLogger("openapi_client")
          self.logger["urllib3_logger"] = logging.getLogger("urllib3")
          self.logger_format = '%(asctime)s %(levelname)s %(message)s'
          """Log format
          """
          self.logger_stream_handler = None
          """Log stream handler
          """
          self.logger_file_handler = None
          """Log file handler
          """
          self.logger_file = None
          """Debug file location
          """
          self.debug = False
          """Debug switch
          """
  
          self.verify_ssl = True
          """SSL/TLS verification
             Set this to false to skip verifying SSL certificate when calling API
             from https server.
          """
          self.ssl_ca_cert = None
          """Set this to customize the certificate file to verify the peer.
          """
          self.cert_file = None
          """client certificate file
          """
          self.key_file = None
          """client key file
          """
          self.assert_hostname = None
          """Set this to True/False to enable/disable SSL hostname verification.
          """
  
          self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
          """urllib3 connection pool's maximum number of connections saved
             per pool. urllib3 uses 1 connection as default value, but this is
             not the best value when you are making a lot of possibly parallel
             requests to the same host, which is often the case here.
             cpu_count * 5 is used as default value to increase performance.
          """
  
          self.proxy = None
          """Proxy URL
          """
          self.proxy_headers = None
          """Proxy headers
          """
          self.safe_chars_for_path_param = ''
          """Safe chars for path_param
          """
          self.retries = None
          """Adding retries to override urllib3 default value 3
          """
          # Disable client side validation
          self.client_side_validation = True
  
      @property
      def logger_file(self):
          """The logger file.
  
          If the logger_file is None, then add stream handler and remove file
          handler. Otherwise, add file handler and remove stream handler.
  
          :param value: The logger_file path.
          :type: str
          """
          return self.__logger_file
  
      @logger_file.setter
      def logger_file(self, value):
          """The logger file.
  
          If the logger_file is None, then add stream handler and remove file
          handler. Otherwise, add file handler and remove stream handler.
  
          :param value: The logger_file path.
          :type: str
          """
          self.__logger_file = value
          if self.__logger_file:
              # If set logging file,
              # then add file handler and remove stream handler.
              self.logger_file_handler = logging.FileHandler(self.__logger_file)
              self.logger_file_handler.setFormatter(self.logger_formatter)
              for _, logger in six.iteritems(self.logger):
                  logger.addHandler(self.logger_file_handler)
  
      @property
      def debug(self):
          """Debug status
  
          :param value: The debug status, True or False.
          :type: bool
          """
          return self.__debug
  
      @debug.setter
      def debug(self, value):
          """Debug status
  
          :param value: The debug status, True or False.
          :type: bool
          """
          self.__debug = value
          if self.__debug:
              # if debug status is True, turn on debug logging
              for _, logger in six.iteritems(self.logger):
                  logger.setLevel(logging.DEBUG)
              # turn on httplib debug
              httplib.HTTPConnection.debuglevel = 1
          else:
              # if debug status is False, turn off debug logging,
              # setting log level to default `logging.WARNING`
              for _, logger in six.iteritems(self.logger):
                  logger.setLevel(logging.WARNING)
              # turn off httplib debug
              httplib.HTTPConnection.debuglevel = 0
  
      @property
      def logger_format(self):
          """The logger format.
  
          The logger_formatter will be updated when sets logger_format.
  
          :param value: The format string.
          :type: str
          """
          return self.__logger_format
  
      @logger_format.setter
      def logger_format(self, value):
          """The logger format.
  
          The logger_formatter will be updated when sets logger_format.
  
          :param value: The format string.
          :type: str
          """
          self.__logger_format = value
          self.logger_formatter = logging.Formatter(self.__logger_format)
  
      def get_api_key_with_prefix(self, identifier):
          """Gets API key (with prefix if set).
  
          :param identifier: The identifier of apiKey.
          :return: The token for api key authentication.
          """
          if self.refresh_api_key_hook is not None:
              self.refresh_api_key_hook(self)
          key = self.api_key.get(identifier)
          if key:
              prefix = self.api_key_prefix.get(identifier)
              if prefix:
                  return "%s %s" % (prefix, key)
              else:
                  return key
  
      def get_basic_auth_token(self):
          """Gets HTTP basic authentication header (string).
  
          :return: The token for basic HTTP authentication.
          """
          return urllib3.util.make_headers(
              basic_auth=self.username + ':' + self.password
          ).get('authorization')
  
      def auth_settings(self):
          """Gets Auth Settings dict for api client.
  
          :return: The Auth Settings information dict.
          """
          return {
              'NeoloadAuthorizer':
                  {
                      'type': 'api_key',
                      'in': 'header',
                      'key': 'accountToken',
                      'value': self.get_api_key_with_prefix('accountToken')
                  },
          }
  
      def to_debug_report(self):
          """Gets the essential information for debugging.
  
          :return: The report for debugging.
          """
          return "Python SDK Debug Report:\n"\
                 "OS: {env}\n"\
                 "Python Version: {pyversion}\n"\
                 "Version of the API: 1.0\n"\
                 "SDK Package Version: 1.0.0".\
                 format(env=sys.platform, pyversion=sys.version)
  
      def get_host_settings(self):
          """Gets an array of host settings
  
          :return: An array of host settings
          """
          return [
              {
                  'url': "https://preprod-neoload-api.saas.neotys.com/v1",
                  'description': "No description provided",
              }
          ]
  
      def get_host_from_settings(self, index, variables={}):
          """Gets host URL based on the index and variables
          :param index: array index of the host settings
          :param variables: hash of variable and the corresponding value
          :return: URL based on host settings
          """
  
          servers = self.get_host_settings()
  
          # check array index out of bound
          if index < 0 or index >= len(servers):
              raise ValueError(
                  "Invalid index {} when selecting the host settings. Must be less than {}"  # noqa: E501
                  .format(index, len(servers)))
  
          server = servers[index]
          url = server['url']
  
          # go through variable and assign a value
          for variable_name in server['variables']:
              if variable_name in variables:
                  if variables[variable_name] in server['variables'][
                          variable_name]['enum_values']:
                      url = url.replace("{" + variable_name + "}",
                                        variables[variable_name])
                  else:
                      raise ValueError(
                          "The variable `{}` in the host URL has invalid value {}. Must be {}."  # noqa: E501
                          .format(
                              variable_name, variables[variable_name],
                              server['variables'][variable_name]['enum_values']))
              else:
                  # use default value
                  url = url.replace(
                      "{" + variable_name + "}",
                      server['variables'][variable_name]['default_value'])
  
          return url
  