docs: def rpc(self, request, args):
          """RPC
  
          :param request:
          :args ???:
  
          """
          if request.method != 'POST':
              return self.error(405, request)
          payload = request.get_data(as_text=True) or '{}'
          request_method = request.args.get('method')
          if not request_method:
              return self.error(
                  400, request,
                  message="A query string parameter method= is missing."
              )
          name_map = self.service.__nirum_method_names__
          try:
              method_facial_name = name_map.behind_names[request_method]
          except KeyError:
              return self.error(
                  400,
                  request,
                  message="Service doesn't have procedure named '{}'.".format(
                      request_method
                  )
              )
          try:
              service_method = getattr(self.service, method_facial_name)
          except AttributeError:
              return self.error(
                  400,
                  request,
                  message="Service has no procedure '{}'.".format(
                      request_method
                  )
              )
          if not callable(service_method):
              return self.error(
                  400, request,
                  message="Remote procedure '{}' is not callable.".format(
                      request_method
                  )
              )
          try:
              request_json = json.loads(payload)
          except ValueError:
              return self.error(
                  400,
                  request,
                  message="Invalid JSON payload: '{}'.".format(payload)
              )
          type_hints = self.service.__nirum_service_methods__[method_facial_name]
          try:
              arguments = self._parse_procedure_arguments(
                  type_hints,
                  request_json
              )
          except (NirumProcedureArgumentValueError,
                  NirumProcedureArgumentRequiredError) as e:
              return self.error(400, request, message=str(e))
          method_error_types = self.service.__nirum_method_error_types__
          if not callable(method_error_types):  # generated by older compiler
              method_error_types = method_error_types.get
          method_error = method_error_types(method_facial_name, ())
          try:
              result = service_method(**arguments)
          except method_error as e:
              return self._raw_response(400, serialize_meta(e))
          return_type = type_hints['_return']
          if type_hints.get('_v', 1) >= 2:
              return_type = return_type()
          if not self._check_return_type(return_type, result):
              return self.error(
                  400,
                  request,
                  message="Incorrect return type '{0}' "
                          "for '{1}'. expected '{2}'.".format(
                              typing._type_repr(result.__class__),
                              request_method,
                              typing._type_repr(return_type)
                          )
              )
          else:
              return self._raw_response(200, serialize_meta(result))