docs: def eom(self):
          """
          Send the message to DSPAM for classification and a return a milter
          response based on the results.
  
          If <DspamMilter>.static_user is set, that single DSPAM user account
          will be used for processing the message. If it is unset, all envelope
          recipients will be passed to DSPAM, and the final decision is based on
          the least invasive result in all their classification results.
  
          """
          for header in self.remove_headers:
              self.chgheader(header, 1, '')
              logger.info('<{}> Removing existing {} header'.format(
                  self.id, header))
  
          queue_id = self.getsymval('i')
          logger.debug(
              '<{}> Sending message with MTA queue id {} to DSPAM'.format(
                  self.id, queue_id))
  
          try:
              if not self.dspam:
                  self.dspam = DspamClient()
                  self.dspam.connect()
                  self.dspam.lhlo()
                  if not self.dspam.dlmtp:
                      logger.warning(
                          '<{}> Connection to DSPAM is established, but DLMTP '
                          'seems unavailable'.format(self.id))
              else:
                  self.dspam.rset()
          except DspamClientError as err:
              logger.error(
                  '<{}> An error ocurred while connecting to DSPAM: {}'.format(
                      self.id, err))
              return Milter.TEMPFAIL
  
          try:
              self.dspam.mailfrom(client_args='--process --deliver=summary')
              if self.static_user:
                  self.dspam.rcptto((self.static_user,))
              else:
                  self.dspam.rcptto(self.recipients)
              self.dspam.data(self.message)
          except DspamClientError as err:
              logger.error(
                  '<{}> An error ocurred while talking to DSPAM: {}'.format(
                      self.id, err))
              return Milter.TEMPFAIL
  
          # Clear caches
          self.message = ''
          self.recipients = []
  
          # With multiple recipients, if different verdicts were returned, always
          #   use the 'lowest' verdict as final, so mail is not lost unexpected.
          final_verdict = None
          for rcpt in self.dspam.results:
              results = self.dspam.results[rcpt]
              logger.info(
                  '<{0}> DSPAM returned results for message with queue id {1} '
                  'and RCPT {2}: {3}'.format(
                      self.id, queue_id, rcpt,
                      ' '.join('{}={}'.format(k, v) for k, v in results.iteritems())))
              verdict = self.compute_verdict(results)
              if final_verdict is None or verdict < final_verdict:
                  final_verdict = verdict
                  final_results = results
  
          if final_verdict == self.VERDICT_REJECT:
              logger.info(
                  '<{0}> Rejecting message with queue id {1} based on DSPAM '
                  'results: user={2[user]} class={2[class]} '
                  'confidence={2[confidence]}'.format(
                      self.id, queue_id, final_results))
              self.setreply('550', '5.7.1', 'Message is {0[class]}'.format(
                  final_results))
              return Milter.REJECT
          elif final_verdict == self.VERDICT_QUARANTINE:
              logger.info(
                  '<{0}> Quarantining message with queue id {1} based on DSPAM '
                  'results: user={2[user]} class={2[class]} '
                  'confidence={2[confidence]}'.format(
                      self.id, queue_id, final_results))
              self.add_dspam_headers(final_results)
              self.quarantine('Message is {0[class]} according to DSPAM'.format(
                  final_results))
              return Milter.ACCEPT
          else:
              logger.info(
                  '<{0}> Accepting message with queue id {1} based on DSPAM '
                  'results: user={2[user]} class={2[class]} '
                  'confidence={2[confidence]}'.format(
                      self.id, queue_id, final_results))
              self.add_dspam_headers(final_results)
              return Milter.ACCEPT