text: #  coding: utf-8
  #  ----------------------------------------------------------------------------
  #  <copyright company="Aspose" file="configuration.py">
  #    Copyright (c) 2018-2019 Aspose Pty Ltd. All rights reserved.
  #  </copyright>
  #  <summary>
  #    Permission is hereby granted, free of charge, to any person obtaining a
  #   copy  of this software and associated documentation files (the "Software"),
  #   to deal  in the Software without restriction, including without limitation
  #   the rights  to use, copy, modify, merge, publish, distribute, sublicense,
  #   and/or sell  copies of the Software, and to permit persons to whom the
  #   Software is  furnished to do so, subject to the following conditions:
  #
  #   The above copyright notice and this permission notice shall be included in
  #   all  copies or substantial portions of the Software.
  #
  #   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  #   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  #   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  #   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  #   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  #   FROM,  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  #   DEALINGS IN THE SOFTWARE.
  #  </summary>
  #  ----------------------------------------------------------------------------
  
  from __future__ import absolute_import
  
  import logging
  import multiprocessing
  import sys
  
  import six
  import urllib3
  from six.moves import http_client as httplib
  
  
  class Configuration(object):
      """ Class which contains configuration parameters
      """
  
      default_base_url = 'https://api.aspose.cloud'
  
      default_api_version = 'v3.0'
  
      def __init__(self, app_key=None, app_sid=None, base_url=None,
                   api_version=None, debug=False, proxy=None):
          """Constructor"""
          # Base url
          if base_url:
              self.host = base_url
          else:
              self.host = Configuration.default_base_url
          if str.endswith(self.host, '/'):
              self.host = self.host[:-1]
  
          # Default api version is v3
          if api_version:
              if api_version.startswith('v1') or api_version.startswith('v2'):
                  raise Exception('This Aspose.CAD Cloud SDK version is '
                                  'intended to be used with API v3.0 or later!')
              self.api_version = api_version
          else:
              self.api_version = Configuration.default_api_version
          if self.api_version and str.endswith(self.api_version, '/'):
              self.api_version = self.api_version[:-1]
          if self.api_version and not str.startswith(self.api_version, '/'):
              self.api_version = '/' + self.api_version
  
          # Temp file folder for downloading files
          self.temp_folder_path = None
  
          # Authentication Settings
          # dict to store API key(s)
          self.api_key = {'api_key': app_key if app_key else "",
                          'app_sid': app_sid if app_sid else ""}
          # dict to store API prefix (e.g. Bearer)
          self.api_key_prefix = {}
  
          # access token for OAuth
          self.access_token = ""
  
          # Logging Settings
          self.logger = {
              "package_logger": logging.getLogger("asposecadcloud"),
              "urllib3_logger": logging.getLogger("urllib3")}
          # Log format
          self.logger_formatter = None
          self.__logger_format = None
          self.logger_format = '%(asctime)s %(levelname)s %(message)s'
          # Log stream handler
          self.logger_stream_handler = None
          # Log file handler
          self.logger_file_handler = None
          # Debug file location
          self.__logger_file = None
          self.logger_file = None
  
          # Debug switch
          self.debug = debug
          self.__debug = debug
  
          # On-premise switch
          self.on_premise = not (app_key or app_sid) and base_url
  
          # SSL/TLS verification
          # Set this to false to skip verifying SSL certificate when calling API
          # from https server.
          self.verify_ssl = True
          # Set this to customize the certificate file to verify the peer.
          self.ssl_ca_cert = None
          # client certificate file
          self.cert_file = None
          # client key file
          self.key_file = None
          # Set this to True/False to enable/disable SSL hostname verification.
          self.assert_hostname = None
  
          # 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.connection_pool_maxsize = multiprocessing.cpu_count() * 5
  
          # Proxy URL
          self.proxy = proxy
          # Safe chars for path_param
          self.safe_chars_for_path_param = ''
  
      @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)
                  if self.logger_stream_handler:
                      logger.removeHandler(self.logger_stream_handler)
          else:
              # If not set logging file,
              # then add stream handler and remove file handler.
              self.logger_stream_handler = logging.StreamHandler()
              self.logger_stream_handler.setFormatter(self.logger_formatter)
              for _, logger in six.iteritems(self.logger):
                  logger.addHandler(self.logger_stream_handler)
                  if self.logger_file_handler:
                      logger.removeHandler(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.api_key.get(identifier) and
                  self.api_key_prefix.get(identifier)):
              return self.api_key_prefix[identifier] + ' ' + self.api_key[
                  identifier]
          elif self.api_key.get(identifier):
              return self.api_key[identifier]
  
      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 {
  
              'JWT':
                  {
                      'type': 'oauth2',
                      'in': 'header',
                      'key': 'Authorization',
                      'value': 'Bearer ' + self.access_token
                  },
  
          }
  
      @staticmethod
      def to_debug_report():
          """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: 3.0\n" \
                 "SDK Package Version: 20.11.0". \
              format(env=sys.platform, pyversion=sys.version)
  