docs: def _post(self, url,
                param_dict={},
                files={},
                securityHandler=None,
                additional_headers={},
                custom_handlers=[],
                proxy_url=None,
                proxy_port=80,
                compress=True,
                out_folder=None,
                file_name=None):
          """
          Performs a POST operation on a URL.
  
          Inputs:
             param_dict - key/value pair of values
                ex: {"foo": "bar"}
             files - key/value pair of file objects where the key is
                the input name and the value is the file path
                ex: {"file": r"c:\temp\myfile.zip"}
             securityHandler - object that handles the token or other site
                security.  It must inherit from the base security class.
                ex: arcrest.AGOLSecurityHandler("SomeUsername", "SOMEPASSWORD")
             additional_headers - are additional key/value headers that a user
                wants to pass during the operation.
                ex: {"accept-encoding": "gzip"}
             custom_handlers - this is additional web operation handlers as a
                list of objects.
                Ex: [CustomAuthHandler]
             proxy_url - url of the proxy
             proxy_port - default 80, port number of the proxy
             compress - default true, determines if gzip should be used of not for
                the web operation.
             out_folder - if the URL requested returns a file, this will be the
                disk save location
             file_name - if the operation returns a file and the file name is not
               given in the header or a user wishes to override the return saved
               file name, provide value here.
          Output:
             returns dictionary or string depending on web operation.
          """
          self._last_method = "POST"
          headers = {}
          opener = None
          return_value = None
          handlers = [RedirectHandler()]
          param_dict, handler, cj = self._processHandler(securityHandler, param_dict)
          if handler is not None:
              handlers.append(handler)
          if cj is not None:
              handlers.append(request.HTTPCookieProcessor(cj))
          if isinstance(custom_handlers, list) and \
             len(custom_handlers) > 0:
              for h in custom_handlers:
                  handlers.append(h)
          if compress:
              headers['Accept-Encoding'] = 'gzip'
          else:
              headers['Accept-Encoding'] = ''
          for k,v in additional_headers.items():
              headers[k] = v
              del k,v
          opener = request.build_opener(*handlers)
          request.install_opener(opener)
          opener.addheaders = [(k,v) for k,v in headers.items()]
          if len(files) == 0:
              data = urlencode(param_dict)
              if self.PY3:
                  data = data.encode('ascii')
              opener.data = data
              resp = opener.open(url, data=data)
          else:
              mpf = MultiPartForm(param_dict=param_dict,
                                  files=files)
              req = request.Request(url)
              body = mpf.make_result
              req.add_header('User-agent', self.useragent)
              req.add_header('Content-type', mpf.get_content_type())
              req.add_header('Content-length', len(body))
              req.data = body
              resp = request.urlopen(req)
          self._last_code = resp.getcode()
          self._last_url = resp.geturl()
          return_value = self._process_response(resp=resp,
                                                out_folder=out_folder)
          if isinstance(return_value, dict):
              if "error" in return_value and \
                 'message' in return_value['error']:
                  if return_value['error']['message'].lower() == 'request not made over ssl':
                      if url.startswith('http://'):
                          url = url.replace('http://', 'https://')
                          return self._post(url,
                                       param_dict,
                                       files,
                                       securityHandler,
                                       additional_headers,
                                       custom_handlers,
                                       proxy_url,
                                       proxy_port,
                                       compress,
                                       out_folder,
                                       file_name)
              return return_value
          else:
              return return_value
          return return_value