docs: def _postprocess_request(self, r):
          """
          This converts the response to either the response or a parsed :class:`pytgbot.api_types.receivable.Receivable`.
  
          :param r: the request response
          :type  r: requests.Response
  
          :return: The json response from the server, or, if `self.return_python_objects` is `True`, a parsed return type.
          :rtype:  DictObject.DictObject | pytgbot.api_types.receivable.Receivable
          """
          from DictObject import DictObject
          import requests
  
          assert isinstance(r, requests.Response)
  
          try:
              logger.debug(r.json())
              res = DictObject.objectify(r.json())
          except Exception:
              logger.exception("Parsing answer failed.\nRequest: {r!s}\nContent: {r.content}".format(r=r))
              raise
          # end if
          res["response"] = r  # TODO: does this failes on json lists? Does TG does that?
          # TG should always return an dict, with at least a status or something.
          if self.return_python_objects:
              if res.ok != True:
                  raise TgApiServerException(
                      error_code=res.error_code if "error_code" in res else None,
                      response=res.response if "response" in res else None,
                      description=res.description if "description" in res else None,
                      request=r.request
                  )
              # end if not ok
              if "result" not in res:
                  raise TgApiParseException('Key "result" is missing.')
              # end if no result
              return res.result
          # end if return_python_objects
          return res
      # end def _postprocess_request
  
          def _do_fileupload(self, file_param_name, value, _command=None, **kwargs):
          """
          :param file_param_name: For what field the file should be uploaded.
          :type  file_param_name: str
  
          :param value: File to send. You can either pass a file_id as String to resend a file
                        file that is already on the Telegram servers, or upload a new file,
                        specifying the file path as :class:`pytgbot.api_types.sendable.files.InputFile`.
          :type  value: pytgbot.api_types.sendable.files.InputFile | str
  
          :param _command: Overwrite the sended command.
                           Default is to convert `file_param_name` to camel case (`"voice_note"` -> `"sendVoiceNote"`)
  
          :param kwargs: will get json encoded.
  
          :return: The json response from the server, or, if `self.return_python_objects` is `True`, a parsed return type.
          :rtype:  DictObject.DictObject | pytgbot.api_types.receivable.Receivable
  
          :raises TgApiTypeError, TgApiParseException, TgApiServerException: Everything from :meth:`Bot.do`, and :class:`TgApiTypeError`
          """
          from pytgbot.api_types.sendable.files import InputFile
          from luckydonaldUtils.encoding import unicode_type
          from luckydonaldUtils.encoding import to_native as n
  
          if isinstance(value, str):
              kwargs[file_param_name] = str(value)
          elif isinstance(value, unicode_type):
              kwargs[file_param_name] = n(value)
          elif isinstance(value, InputFile):
              kwargs["files"] = value.get_request_files(file_param_name)
          else:
              raise TgApiTypeError("Parameter {key} is not type (str, {text_type}, {input_file_type}), but type {type}".format(
                  key=file_param_name, type=type(value), input_file_type=InputFile, text_type=unicode_type))
          # end if
          if not _command:
              # command as camelCase  # "voice_note" -> "sendVoiceNote"  # https://stackoverflow.com/a/10984923/3423324
              command = re.sub(r'(?!^)_([a-zA-Z])', lambda m: m.group(1).upper(), "send_" + file_param_name)
          else:
              command = _command
          # end def
          return self.do(command, **kwargs)