docs: def notify(cls, user_or_email_, object_id=None, **filters):
          """Start notifying the given user or email address when this event
          occurs and meets the criteria given in ``filters``.
  
          Return the created (or the existing matching) Watch so you can call
          :meth:`~tidings.models.Watch.activate()` on it if you're so inclined.
  
          Implementations in subclasses may take different arguments; see the
          docstring of :meth:`is_notifying()`.
  
          Send an activation email if an anonymous watch is created and
          :data:`~django.conf.settings.TIDINGS_CONFIRM_ANONYMOUS_WATCHES` is
          ``True``. If the activation request fails, raise a
          ActivationRequestFailed exception.
  
          Calling :meth:`notify()` twice for an anonymous user will send the
          email each time.
  
          """
          # A test-for-existence-then-create race condition exists here, but it
          # doesn't matter: de-duplication on fire() and deletion of all matches
          # on stop_notifying() nullify its effects.
          try:
              # Pick 1 if >1 are returned:
              watch = cls._watches_belonging_to_user(
                  user_or_email_,
                  object_id=object_id,
                  **filters)[0:1].get()
          except Watch.DoesNotExist:
              create_kwargs = {}
              if cls.content_type:
                  create_kwargs['content_type'] = \
                      ContentType.objects.get_for_model(cls.content_type)
              create_kwargs['email' if isinstance(user_or_email_, string_types)
                            else 'user'] = user_or_email_
              # Letters that can't be mistaken for other letters or numbers in
              # most fonts, in case people try to type these:
              distinguishable_letters = \
                  'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRTUVWXYZ'
              secret = ''.join(random.choice(distinguishable_letters)
                               for x in range(10))
              # Registered users don't need to confirm, but anonymous users do.
              is_active = ('user' in create_kwargs or
                           not settings.TIDINGS_CONFIRM_ANONYMOUS_WATCHES)
              if object_id:
                  create_kwargs['object_id'] = object_id
              watch = Watch.objects.create(
                  secret=secret,
                  is_active=is_active,
                  event_type=cls.event_type,
                  **create_kwargs)
              for k, v in iteritems(filters):
                  WatchFilter.objects.create(watch=watch, name=k,
                                             value=hash_to_unsigned(v))
          # Send email for inactive watches.
          if not watch.is_active:
              email = watch.user.email if watch.user else watch.email
              message = cls._activation_email(watch, email)
              try:
                  message.send()
              except SMTPException as e:
                  watch.delete()
                  raise ActivationRequestFailed(e.recipients)
          return watch