Submit spam that is incorrectly tagged as ham.

Using this function will make you a good citizen as it helps Akismet to learn from its mistakes.  This will improve the service for everybody.
544130
public function submitSpam()
    {
        $this->sendRequest($this->getQueryString(), $this->wordPressAPIKey . '.' . $this->akismetServer, '/' . $this->akismetVersion . '/submit-spam');
    }
220084
function checknick(next) {
        if (args.nick) {
          userent.list$({ nick: args.nick }, function(err, users) {
            if (err) return done(err, { ok: false, user: user })
            for (var i = 0; i < users.length; i++) {
              var each = users[i]
              if (each.id !== user.id) {
                return done(null, {
                  ok: false,
                  why: 'nick-exists',
                  nick: args.nick
                })
              }
            }

            next()
          })
          return
        }
        next()
      }
537674
function onSubmit() {
					oRequestLock = that.oRequestor.getModelInterface()
						.lockGroup(sGroupId, true, that);
					if (fnPatchSent) {
						fnPatchSent();
					}
				}
483955
def moderate(self, comment, entry, request):
        
        if self.auto_moderate_comments:
            return True

        if check_is_spam(comment, entry, request,
                         self.spam_checker_backends):
            return True

        return False
884349
def spam(user_ip, user_agent, params = {})
      response = invoke_comment_method('submit-spam',
        user_ip,
        user_agent,
        params)

      unless response.body == 'Thanks for making the web a better place.'
        raise_with_response response
      end
    end
1246217
function() {
        var updateRegex = _.bind(function () {
                // Allows checking for a nick that contains 'the_nick' or '<punctuation>the_nick<punctuation>'
                // .. where <punctuation> is any character not allowed in an IRC nick
                var regex_valid_nick_chars = 'a-z0-9_\\-{}[\\]^`|\\\\';
                var regex_nicks = Object.keys(this.nick_cache)
                    .map(_.escapeRegExp)
                    .join('|');

                this.nick_regex = new RegExp(
                    '^[^'+regex_valid_nick_chars+']?(' + regex_nicks + ')[^'+regex_valid_nick_chars+']?$', 'i'
                );
            }, this);

        function getNick (member) {
            return member.get('nick').toLowerCase();
        };

        this.nick_cache = Object.create(null);
        this.nick_regex = null;

        this.on('reset', function() {
            this.nick_cache = _.reduce(this.models, function(memo, member) {
                memo[getNick(member)] = member;
                return memo;
            }, Object.create(null));
            updateRegex();
        });

        this.on('add', function(member) {
            this.nick_cache[getNick(member)] = member;
            updateRegex();
        });

        this.on('remove', function(member) {
            delete this.nick_cache[getNick(member)];
            updateRegex();
        });

        this.on('change:nick', function(member) {
            this.nick_cache[getNick(member)] = member;
            delete this.nick_cache[member.previous('nick').toLowerCase()];
            updateRegex();
        });
    }
670472
public function process_action($slot, $submitteddata, $timestamp = null) {
        $qa = $this->get_question_attempt($slot);
        $qa->process_action($submitteddata, $timestamp);
        $this->observer->notify_attempt_modified($qa);
    }
413341
def handle(send, msg, args):
    """"""
    output = textutils.gen_xkcd_sub(msg, True)
    if output is None:
        return
    if args['type'] == 'action':
        send("correction: * %s %s" % (args['nick'], output))
    else:
        send("%s actually meant: %s" % (args['nick'], output))
714252
def post_message(params)
      self.class.post('/chat.postMessage', body: params.merge({token: @token})).tap do |response|
        raise "error posting message: #{response.fetch('error', 'unknown error')}" unless response['ok']
      end
    end
385273
function(verificationId) {
    return new Promise((resolve, reject) => {
      this._start()
          .uri('/api/user/verify-email')
          .urlSegment(verificationId)
          .post()
          .go(this._responseHandler(resolve, reject));
    });
  }
190987
@RequestMapping(value = "/fraudcheck", method = PUT, consumes = FRAUD_SERVICE_JSON_VERSION_1, produces = FRAUD_SERVICE_JSON_VERSION_1)
	public FraudCheckResult fraudCheck(@RequestBody FraudCheck fraudCheck) {
		// end::server_api[]
		// tag::new_impl[]
		if (amountGreaterThanThreshold(fraudCheck)) {
			return new FraudCheckResult(FraudCheckStatus.FRAUD, AMOUNT_TOO_HIGH);
		}
		// end::new_impl[]
		// tag::initial_impl[]
		return new FraudCheckResult(FraudCheckStatus.OK, NO_REASON);
		// end::initial_impl[]
	}
168832
def post(self, request, question_level, question_number, format=None):
        

        user = User.objects.get(username=request.user.username)
        question = Question.objects.filter(question_level=question_level).filter(question_number=question_number)
        if int(user.profile.user_access_level) < int(question_level):
            content = {'user_nick':profile.user_nick, 'please move along': 'Nothing to see here' }
            return Response(content, status=status.HTTP_406_NOT_ACCEPTABLE)

        time_last = None
        time_last_query = Submission.objects.filter(submission_user__username=request.user.username).filter(submission_question__question_level=question_level).filter(submission_question__question_number=question_number).filter(submission_state='WA').order_by('submission_timestamp').last()
        check_resubmission = AcceptedQuestion.objects.filter(record_user=request.user).filter(record_question=question)
        if check_resubmission:
            content = {'user_nick':profile.user_nick, 'Do not try to resubmit': 'Already Accepted' }
            return Response(content, status=status.HTTP_406_NOT_ACCEPTABLE)
        if time_last_query:
            time_last = time_last_query.submission_timestamp
        time_limit = self.get_contest_consecutive_submission_halt_time()

#        print time_last, time_limit, datetime.datetime.now(), time_limit <= datetime.datetime.now()

        if(time_last is None or time_last + time_limit <= datetime.datetime.now()):

            type_of_contest =  self.get_contest_type()
            type_of_submission = self.get_question_type()
            if type_of_submission != STRING:
                content = { 'user_nick':profile.user_nick, 'please move along': 'WRONG TYPE SUBMISSION'}
                return Response(content, status=status.HTTP_405_METHOD_NOT_ALLOWED)

            serializer = SubmissionSerializer(data=request.data)
            if serializer.is_valid():
                serializer.save(submission_user = request.user,
                                submission_question = self.get_object(question_level,question_number)[0],
                )
                # checker_queue.delay(int(serializer.data['id']))
                return Response(serializer.data, status=status.HTTP_201_CREATED)
            else:
                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        else:
            content = {'user_nick':profile.user_nick, 'Try to submit after some time': 'Nothing to see here' }
            return Response(content, status=status.HTTP_406_NOT_ACCEPTABLE)
1361766
public function submitSpam()
    {
        $this->http_post($this->getQueryString(), $this->wordPressAPIKey . '.' . $this->akismetServer, '/' . $this->akismetVersion . '/submit-spam');
    }
312345
def check_is_spam(content, content_object, request,
                  backends=None):
    
    if backends is None:
        backends = SPAM_CHECKER_BACKENDS

    for backend_path in backends:
        spam_checker = get_spam_checker(backend_path)
        if spam_checker is not None:
            is_spam = spam_checker(content, content_object, request)
            if is_spam:
                return True

    return False
177583
def register_post(self, regex, callback):
        
        if callback is None:                                                                    # pragma: no cover
            if regex in self.post_registrations:
                del self.post_registrations[regex]
        else:
            self.post_registrations[regex] = (re.compile(regex), callback)
182797
async def on_reaction_add(reaction, user):
    

    # Simplify reaction info
    server = reaction.message.server
    emoji = reaction.emoji

    data = datatools.get_data()

    if not data["discord"]["servers"][server.id][_data.modulename]["activated"]:
        return

    # Commands section
    if user != reaction.message.channel.server.me:
        if server.id not in _data.cache or _data.cache[server.id].state == 'destroyed':
            return

        try:
            valid_reaction = reaction.message.id == _data.cache[server.id].embed.sent_embed.id
        except AttributeError:
            pass
        else:
            if valid_reaction:
                # Remove reaction
                try:
                    await client.remove_reaction(reaction.message, emoji, user)
                except discord.errors.NotFound:
                    pass
                except discord.errors.Forbidden:
                    pass

                # Commands
                if emoji == "⏯":
                    await _data.cache[server.id].toggle()
                if emoji == "⏹":
                    await _data.cache[server.id].stop()
                if emoji == "⏭":
                    await _data.cache[server.id].skip("1")
                if emoji == "⏮":
                    await _data.cache[server.id].rewind("1")
                if emoji == "🔀":
                    await _data.cache[server.id].shuffle()
                if emoji == "🔉":
                    await _data.cache[server.id].setvolume('-')
                if emoji == "🔊":
                    await _data.cache[server.id].setvolume('+')
100465
def respond_to_ask(self, message):
    """"""
    valid_actions, hole_card, round_state = self.__parse_ask_message(message)
    return self.declare_action(valid_actions, hole_card, round_state)