docs: async def evaluate(self):
          """Evaluate the query observer.
  
          :param return_emitted: True if the emitted diffs should be returned (testing only)
          """
  
          @database_sync_to_async
          def remove_subscribers():
              models.Observer.subscribers.through.objects.filter(
                  observer_id=self.id
              ).delete()
  
          @database_sync_to_async
          def get_subscriber_sessions():
              return list(
                  models.Observer.subscribers.through.objects.filter(observer_id=self.id)
                  .distinct('subscriber_id')
                  .values_list('subscriber_id', flat=True)
              )
  
          try:
              settings = get_queryobserver_settings()
  
              start = time.time()
              # Evaluate the observer
              added, changed, removed = await database_sync_to_async(self._evaluate)()
              duration = time.time() - start
  
              # Log slow observers.
              if duration > settings['warnings']['max_processing_time']:
                  self._warning("Slow observed viewset", duration=duration)
  
              # Remove subscribers of really slow observers.
              if duration > settings['errors']['max_processing_time']:
                  logger.error(
                      "Removing subscribers to extremely slow observed viewset ({})".format(
                          self._get_logging_id()
                      ),
                      extra=self._get_logging_extra(duration=duration),
                  )
                  await remove_subscribers()
  
              if self._meta.change_detection == Options.CHANGE_DETECTION_POLL:
                  # Register poller.
                  await get_channel_layer().send(
                      CHANNEL_MAIN,
                      {
                          'type': TYPE_POLL,
                          'observer': self.id,
                          'interval': self._meta.poll_interval,
                      },
                  )
  
              message = {
                  'type': TYPE_ITEM_UPDATE,
                  'observer': self.id,
                  'primary_key': self._meta.primary_key,
                  'added': added,
                  'changed': changed,
                  'removed': removed,
              }
  
              # Only generate notifications in case there were any changes.
              if added or changed or removed:
                  for session_id in await get_subscriber_sessions():
                      await get_channel_layer().group_send(
                          GROUP_SESSIONS.format(session_id=session_id), message
                      )
  
          except Exception:
              logger.exception(
                  "Error while evaluating observer ({})".format(self._get_logging_id()),
                  extra=self._get_logging_extra(),
              )