docs: def _post(self, url,
                param_dict=None,
                files=None,
                securityHandler=None,
                additional_headers=None,
                custom_handlers=None,
                proxy_url=None,
                proxy_port=80,
                compress=True,
                out_folder=None,
                file_name=None,
                force_form_post=False):
          """
          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.
             force_form_post - boolean -
          Output:
             returns dictionary or string depending on web operation.
          """
  
          # ensure that no spaces are in the url
          url = url.replace(" ", "%20")
  
          if param_dict is None:
              param_dict = {}
          if files is None:
              files = {}
          if additional_headers is None:
              additional_headers = {}
          if custom_handlers is None:
              custom_handlers = []
          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
              custom_handlers.append(request.HTTPSHandler(context=ctx))
          if len(files) == 0 and force_form_post == False:
              self._last_method = "POST"
          elif len(files) == 0 and force_form_post == True:
              self._last_method = "FORM-MULTIPART"
          elif len(files) > 0:
              self._last_method = "FORM-MULTIPART"
              force_form_post = True
  
          headers = {
              "User-Agent": self.useragent,
              'Accept': '*/*'
          }
          if securityHandler and securityHandler.referer_url:
              headers['referer'] = securityHandler.referer_url
          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
          hasContext = 'context' in self._has_context(request.urlopen)
          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
  
          opener = request.build_opener(*handlers)
          opener.addheaders = [(k,v) for k,v in headers.items()]
          request.install_opener(opener)
          if force_form_post == False:
              data = urlencode(param_dict)
              if self.PY3:
                  data = data.encode('ascii')
              opener.data = data
              req = request.Request(self._asString(url),
                                    data = data,
                                    headers=headers)
              for k,v in headers.items():
                  req.add_header(k,v)
              if hasContext and self._verify == False:
                  resp = request.urlopen(req, context=ctx)
              else:
                  resp = request.urlopen(req)
          else:
              mpf = MultiPartForm(param_dict=param_dict,
                                  files=files)
              req = request.Request(self._asString(url), headers=headers)
              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
              if 'context' in self._has_context(request.urlopen) and \
                 self._verify == False:
                  resp = request.urlopen(req, context=ctx)
              else:
                  resp = request.urlopen(req)
              del body, mpf
          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