docs: def create_client_from_env(username=None,
                             api_key=None,
                             endpoint_url=None,
                             timeout=None,
                             auth=None,
                             config_file=None,
                             proxy=None,
                             user_agent=None,
                             transport=None,
                             verify=True):
      """Creates a SoftLayer API client using your environment.
  
      Settings are loaded via keyword arguments, environemtal variables and
      config file.
  
      :param username: an optional API username if you wish to bypass the
          package's built-in username
      :param api_key: an optional API key if you wish to bypass the package's
          built in API key
      :param endpoint_url: the API endpoint base URL you wish to connect to.
          Set this to API_PRIVATE_ENDPOINT to connect via SoftLayer's private
          network.
      :param proxy: proxy to be used to make API calls
      :param integer timeout: timeout for API requests
      :param auth: an object which responds to get_headers() to be inserted into
          the xml-rpc headers. Example: `BasicAuthentication`
      :param config_file: A path to a configuration file used to load settings
      :param user_agent: an optional User Agent to report when making API
          calls if you wish to bypass the packages built in User Agent string
      :param transport: An object that's callable with this signature:
                        transport(SoftLayer.transports.Request)
      :param bool verify: decide to verify the server's SSL/TLS cert. DO NOT SET
                          TO FALSE WITHOUT UNDERSTANDING THE IMPLICATIONS.
  
      Usage:
  
          >>> import SoftLayer
          >>> client = SoftLayer.create_client_from_env()
          >>> resp = client.call('Account', 'getObject')
          >>> resp['companyName']
          'Your Company'
  
      """
      settings = config.get_client_settings(username=username,
                                            api_key=api_key,
                                            endpoint_url=endpoint_url,
                                            timeout=timeout,
                                            proxy=proxy,
                                            verify=verify,
                                            config_file=config_file)
  
      if transport is None:
          url = settings.get('endpoint_url')
          if url is not None and '/rest' in url:
              # If this looks like a rest endpoint, use the rest transport
              transport = transports.RestTransport(
                  endpoint_url=settings.get('endpoint_url'),
                  proxy=settings.get('proxy'),
                  timeout=settings.get('timeout'),
                  user_agent=user_agent,
                  verify=verify,
              )
          else:
              # Default the transport to use XMLRPC
              transport = transports.XmlRpcTransport(
                  endpoint_url=settings.get('endpoint_url'),
                  proxy=settings.get('proxy'),
                  timeout=settings.get('timeout'),
                  user_agent=user_agent,
                  verify=verify,
              )
  
      # If we have enough information to make an auth driver, let's do it
      if auth is None and settings.get('username') and settings.get('api_key'):
          # NOTE(kmcdonald): some transports mask other transports, so this is
          # a way to find the 'real' one
          real_transport = getattr(transport, 'transport', transport)
  
          if isinstance(real_transport, transports.XmlRpcTransport):
              auth = slauth.BasicAuthentication(
                  settings.get('username'),
                  settings.get('api_key'),
              )
  
          elif isinstance(real_transport, transports.RestTransport):
              auth = slauth.BasicHTTPAuthentication(
                  settings.get('username'),
                  settings.get('api_key'),
              )
  
      return BaseClient(auth=auth, transport=transport)