docs: def _get(self, url,
               param_dict=None,
               securityHandler=None,
               additional_headers=None,
               handlers=None,
               proxy_url=None,
               proxy_port=None,
               compress=True,
               custom_handlers=None,
               out_folder=None,
               file_name=None):
          """
          Performs a GET operation
          Inputs:
  
          Output:
             returns dictionary, string or None
          """
          # ensure that no spaces are in the url
          url = url.replace(" ", "%20")
  
          pass_headers = {}
          if custom_handlers is None:
              custom_handlers = []
          if handlers is None:
              handlers = []
          if param_dict is None:
              param_dict = {}
          self._last_method = "GET"
          CHUNK = 4056
          param_dict, handler, cj = self._processHandler(securityHandler, param_dict)
          if additional_headers is not None:
              headers = [] + additional_headers
          else:
              headers = []
          pass_headers = {}
          if securityHandler and securityHandler.referer_url:
              pass_headers['referer'] = securityHandler.referer_url
          for h in headers:
              pass_headers[h[0]] = h[1]
  
          if compress:
              pass_headers['Accept-encoding'] = 'gzip'
          else:
              pass_headers['Accept-encoding'] = ""
          #headers.append(('User-Agent', USER_AGENT))
          pass_headers['User-Agent'] = self.useragent
          if len(param_dict.keys()) == 0:
              param_dict = None
          if handlers is None:
              handlers = []
          if handler is not None:
              handlers.append(handler)
          handlers.append(RedirectHandler())
          if self._verify == False and \
             sys.version_info[0:3] >= (2, 7, 9) and \
              hasattr(ssl,'create_default_context'):
              ctx = ssl.create_default_context()
              ctx.check_hostname = False
              ctx.verify_mode = ssl.CERT_NONE
              handlers.append(request.HTTPSHandler(context=ctx))
          if cj is not None:
              handlers.append(request.HTTPCookieProcessor(cj))
          if proxy_url is not None:
              if proxy_port is None:
                  proxy_port = 80
              proxies = {"http":"http://%s:%s" % (proxy_url, proxy_port),
                         "https":"https://%s:%s" % (proxy_url, proxy_port)}
              proxy_support = request.ProxyHandler(proxies)
              handlers.append(proxy_support)
          opener = request.build_opener(*handlers)
  
          opener.addheaders = headers
          request.install_opener(opener)
          ctx = None
          hasContext = False
          if self._verify == False and \
             'context' in self._has_context(request.urlopen) and \
              sys.version_info[0:3] >= (2, 7, 9) and \
              hasattr(ssl,'create_default_context'):
              ctx = ssl.create_default_context()
              ctx.check_hostname = False
              ctx.verify_mode = ssl.CERT_NONE
              hasContext = True
  
          if hasContext == False:
  
              if param_dict is None:
                  req = request.Request(self._asString(url),
                                        headers=pass_headers)
                  resp = request.urlopen(req)
              elif len(str(urlencode(param_dict))) + len(url) >= 1999:
                  return self._post(
                      url=url,
                      param_dict=param_dict,
                      files=None,
                      securityHandler=securityHandler,
                      additional_headers=additional_headers,
                      custom_handlers=custom_handlers,
                      proxy_url=proxy_url,
                      proxy_port=proxy_port,
                      compress=compress,
                      out_folder=out_folder,
                      file_name=file_name,
                      force_form_post=False)
              else:
                  format_url = self._asString(url) + "?%s" % urlencode(param_dict)
                  req = request.Request(format_url,
                                        headers=pass_headers)
                  resp = request.urlopen(req)
          else:
              if param_dict is None:
                  req = request.Request(self._asString(url),
                                        headers=pass_headers)
                  resp = request.urlopen(req,
                                         context=ctx)
              elif len(str(urlencode(param_dict))) + len(url) >= 1999:
                  return self._post(
                      url=url,
                      param_dict=param_dict,
                      files=None,
                      securityHandler=securityHandler,
                      additional_headers=additional_headers,
                      custom_handlers=custom_handlers,
                      proxy_url=proxy_url,
                      proxy_port=proxy_port,
                      compress=compress,
                      out_folder=out_folder,
                      file_name=file_name,
                      force_form_post=False)
              else:
                  format_url = self._asString(url) + "?%s" % urlencode(param_dict)
                  req = request.Request(format_url,
                                        headers=pass_headers)
                  resp = request.urlopen(req,
                                         context=ctx)
          self._last_code = resp.getcode()
          self._last_url = resp.geturl()
          #  Get some headers from the response
          maintype = self._mainType(resp)
          contentDisposition = resp.headers.get('content-disposition')
          contentMD5 = resp.headers.get('Content-MD5')
          #contentEncoding = resp.headers.get('content-encoding')
          contentType = resp.headers.get('content-Type').split(';')[0].lower()
          contentLength = resp.headers.get('content-length')
          if maintype.lower() in ('image',
                                  'application/x-zip-compressed') or \
             contentType in ('application/x-zip-compressed', 'application/octet-stream') or \
             contentMD5 is not None or\
             (contentDisposition is not None and \
              contentDisposition.lower().find('attachment;') > -1):
  
              fname = self._get_file_name(
                  contentDisposition=contentDisposition,
                  url=url)
              if out_folder is None:
                  out_folder = tempfile.gettempdir()
              if contentLength is not None:
                  max_length = int(contentLength)
                  if max_length < CHUNK:
                      CHUNK = max_length
              file_name = os.path.join(out_folder, fname)
              with open(file_name, 'wb') as writer:
                  for data in self._chunk(response=resp,
                                          size=CHUNK):
                      writer.write(data)
                      writer.flush()
                  writer.flush()
                  del writer
              return file_name
          else:
              read = ""
              for data in self._chunk(response=resp,
                                      size=CHUNK):
                  if self.PY3 == True:
                      read += data.decode('utf-8')
                  else:
                      read += data
  
                  del data
              try:
                  results = json.loads(read)
                  if 'error' in results:
                      if 'message' in results['error']:
                          if results['error']['message'] == 'Request not made over ssl':
                              if url.startswith('http://'):
                                  url = url.replace('http://', 'https://')
                                  return self._get(url,
                                                   param_dict,
                                                   securityHandler,
                                                   additional_headers,
                                                   handlers,
                                                   proxy_url,
                                                   proxy_port,
                                                   compress,
                                                   custom_handlers,
                                                   out_folder,
                                                   file_name)
                  return results
              except:
                  return read