Jump to content

User:AnomieBOT/source/tasks/AutoAssessor2.pm

From Wikipedia, the free encyclopedia
package tasks::AutoAssessor2;

=pod

=begin metadata

Bot:      AnomieBOT
Task:     AutoAssessor2
BRFA:     Wikipedia:Bots/Requests for approval/AnomieBOT 15
Status:   Approved 2008-12-07
Created:  2008-11-26
OnDemand: true

Redirects and disambiguation pages will be automatically assessed with
class=redirect/disambig and importance=NA, stubs will be automatically assessed
with class=stub if not already assessed, and non-article pages will be
automatically assessed with the appropriate class and importance=NA.

=end metadata

=cut

use utf8;
use strict;

use AnomieBOT::Task;
use vars qw/@ISA/;
@ISA=qw/AnomieBOT::Task/;

# Request link, for edit summary.
my $req="[[User:AnomieBOT/req/WikiProject Radio Stations 1|request]]";

# Increment this number every time a new run is started, so we don't have to
# mess around with deleting previous runs' database entries.
my $seq=4;

# If any of the 'verify' or 'params' functions need the page contents, set this
# flag.
my $need_page_contents=0;

# Configuration for each template that is going to be applied. Options are:
#   ns => Hash mapping namespace numbers (or 'stub', 'redirect', 'disambig',
#       or '' for ns 0) to an array [ $class, $classre, $imp, $impre].
#   stubauto => If defined, add this "=yes" when tagging a stub.
#   importance => If specified, this is the name of the "importance" parameter
#       instead of "importance".
#   canonicalize => If defined, any instance of the template will be renamed to
#       this when edits are done to the page.
#   addempty => If true, add empty "class=" and "importance=" to all banners.
#   verify => If defined, must be a subroutine that will be called with the
#       page and talkpage results. The subroutine must return a boolean value,
#       true if the page should be tagged and false otherwise.
#   params => Subroutines that will be called with the page and talkpage
#       results, the template name, and the existing template parameters. It
#       should adjust the parameter array as necessary.
my %cfg_templates;
%cfg_templates=(
        'WikiProject Radio Stations' => {
            meta => 1,
            stubauto => undef,
            canonicalize => 'WikiProject Radio Stations',
            addempty => 0,
            verify => undef,
            params => undef,
        },
);

sub new {
    my $class=shift;
    my $self=$class->SUPER::new();
    $self->{'did_templates'}=0;
    $self->{'config loaded'}=0;
    bless $self, $class;
    return $self;
}

=pod

=for info
Approved 2008-12-07<br />[[Wikipedia:Bots/Requests for approval/AnomieBOT 15]]

=cut

sub approved {
    return -1;
}

sub run {
    my ($self, $api)=@_;
    my $res;

    $api->task('AutoAssessor2', 0, 10, qw/d::WikiProjectTagging d::Redirects/);

    # Load configs, if necessary
    if(!$self->{'config loaded'}){
        while(my ($banner,$cfg)=each %cfg_templates){
            next unless exists($cfg->{'meta'});
            my $ae=$cfg->{'addempty'} // 0;
            $cfg=$api->WPBMetaConfig($cfg->{'meta'}, %$cfg) if exists($cfg->{'meta'});
            $cfg->{'addempty'}=$ae;
            $cfg_templates{$banner}=$cfg;
        }
        $self->{'config loaded'}=1;
    }

    if(!exists($api->store->{'metaseq'}) || $api->store->{'metaseq'}<$seq){
        delete $api->store->{'template'};
        delete $api->store->{'geicontinue'};
        $api->store->{'metaseq'}=$seq;
    }

    # List of templates to assess in this task
    if(!$self->{'did_templates'}){
        while(my ($t,$c)=each %cfg_templates){
            my %redirs=$api->redirects_to_resolved("Template:$t");
            if(exists($redirs{''})){
                $api->warn("Failed to get redirects to Template:$t".$redirs{''}{'error'}."\n");
                return 60;
            }
            $c->{'names'}=[ keys %redirs ];
        }
        $self->{'did_templates'}=1;
    }
    my %templates=();
    while(my ($t,$c)=each %cfg_templates){
        $templates{$_}=$c foreach (@{$c->{'names'}});
    }

    # Spend a max of 10 minutes on this task before restarting
    my $endtime=time()+600;

    foreach my $template (sort keys %cfg_templates){
        next if(exists($api->store->{'template'}) && $template lt $api->store->{'template'});
        $api->store->{'template'}=$template;
        my %q1=(
            generator    => 'embeddedin',
            geititle     => "Template:$template",
            geilimit     => '1000', # 'max' seems to time out fairly often
            prop         => 'info',
            inprop       => 'subjectid',
        );
        $q1{'geicontinue'}=$api->store->{'geicontinue'} if exists($api->store->{'geicontinue'});
        my %q2=(
            pageids  => '',
            prop     => 'info|categories|templates',
            cllimit  => 'max',
            tllimit  => 'max',
        );
        if($need_page_contents){
            $q2{'prop'}.='|revisions';
            $q2{'rvprop'}='content';
            $q2{'rvslots'}='main';
        }

        # Get the list of pages to check
        do {
            $api->store->{'geicontinue'}=$q1{'geicontinue'} if exists($q1{'geicontinue'});
            $res=$api->query(%q1);
            if($res->{'code'} ne 'success'){
                $api->warn("Failed to retrieve transclusion list for $template: ".$res->{'error'}."\n");
                return 60;
            }
            if(exists($res->{'query-continue'})){
                $q1{'geicontinue'}=$res->{'query-continue'}{'embeddedin'}{'geicontinue'};
            } else {
                delete $q1{'geicontinue'};
            }

            # Collect page IDs of articles for found talk pages
            my @pageids=map { exists($_->{'subjectid'})?($_->{'subjectid'}):() } values %{$res->{'query'}{'pages'}};
            @pageids=grep { !exists($api->store->{$_}) || $api->store->{$_}<$seq } @pageids;

            # Look up info for found pages, in blocks of 500 because that's the
            # max pageids per query allowed.
            while(@pageids){
                $q2{'pageids'}=join('|', splice(@pageids, 0, 500));
                $res=$api->query(%q2);
                foreach my $page (values %{$res->{'query'}{'pages'}}){
                    return 0 if $api->halting;

                    my $pageid=$page->{'pageid'};
                    my $title=$page->{'title'};
                    next if(exists($api->store->{$pageid}) && $api->store->{$pageid}>=$seq);

                    my $ns=$page->{'ns'};
                    my $auto=0;
                    my $talk;
                    if(($ns&1)==1){
                        # Talk page, ignore it.
                        $api->store->{$pageid}=$seq;
                        next;
                    }
                    if($ns==0){
                        if(exists($page->{'redirect'})){
                            $ns='redirect';
                        } elsif(grep { $_->{'title'} eq 'Category:All disambiguation pages' } @{$page->{'categories'}}){
                            $ns='disambig';
                        } elsif(grep { $_->{'title'}=~/^Category:.* stubs?$/i } @{$page->{'categories'}}){
                            $ns='stub';
                            $auto=1;
                        }
                        $talk="Talk:$title";
                    } else {
                        ($talk=$title)=~s/([^:]*):/$1 talk:/;
                    }

                    $api->log("Assessing $title");

                    # Ok, check the page
                    my $tok=$api->edittoken($talk, EditRedir => 1, 'categories'=>1, 'templates'=>1);
                    if($tok->{'code'} eq 'shutoff'){
                        $api->warn("Task disabled: ".$tok->{'content'}."\n");
                        return 300;
                    }
                    if($tok->{'code'} ne 'success'){
                        $api->warn("Failed to get edit token for $talk: ".$tok->{'error'}."\n");
                        next;
                    }
                    next if exists($tok->{'missing'});

                    # Get page text
                    my $intxt=$tok->{'revisions'}[0]{'slots'}{'main'}{'*'};
                    my ($outtxt,$nowiki)=$api->strip_nowiki($intxt);
                    my $any=0;
                    my @found=();

                    $outtxt=$api->process_templates($outtxt, sub {
                        my $name=shift;
                        my @params=@{shift()};
                        shift; # $wikitext
                        shift; # $data
                        my $oname=shift;

                        return undef unless exists($templates{"Template:$name"});
                        my %cfg=%{$templates{"Template:$name"}};
                        return undef if(defined($cfg{'verify'}) && !$cfg{'verify'}($api,$page,$tok));
                        my ($class,$classre,$imp,$impre);
                        my $impname;
                        if(exists($cfg{'ns'}{$ns})){
                            ($class,$classre,$imp,$impre)=@{$cfg{'ns'}{$ns}};
                            $impname=exists($cfg{'importance'})?$cfg{'importance'}:'importance';
                        } else {
                            ($class,$classre,$imp,$impre)=(undef,undef,undef,undef);
                            $impname=undef;
                        }

                        my $orig_param=join('|', @params);

                        # Auto-assess
                        if($class && defined($classre) && !grep(/^\s*class\s*=\s*$classre\s*$/s, @params)){
                            push @params, "class=$class" unless(grep(s/^(\s*class\s*=(?:\s*(?=\S))?).*?(\s*)$/$1$class$2/s, @params));
                            if(defined($cfg{'stubauto'})){
                                my $a=$cfg{'stubauto'};
                                if($auto){
                                    push @params, "$a=yes" if(!grep(s/^(\s*\Q$a\E\s*=(?:\s*(?=\S))?).*?(\s*)$/$1yes$2/s, @params));
                                } else {
                                    @params = grep(!/^\s*\Q$a\E\s*=/, @params);
                                }
                            }
                        }
                        if($imp && defined($impre) && !grep(/^\s*$impname\s*=\s*$impre\s*$/s, @params)){
                            push @params, "$impname=$imp" unless(grep(s/^(\s*$impname\s*=(?:\s*(?=\S))?).*?(\s*)$/$1$imp$2/s, @params));
                        }

                        # If requested to add empty parameters, do so
                        if($cfg{'addempty'} // 0){
                            push @params, "class=" unless grep(/^\s*class\s*=/, @params);
                            push @params, "$impname=" if(defined($impname) && !grep(/^\s*$impname\s*=/, @params));
                        }

                        # Do extra parameters, if necessary
                        $cfg{'params'}($api,$page,$tok,$name,\@params) if defined($cfg{'params'});

                        my $new_param=join('|', @params);
                        if($orig_param ne $new_param){
                            $any=1;
                            my @s=();
                            push @s, "class=$class" if($class && defined($classre));
                            push @s, "$impname=$imp" if($imp && defined($impre));
                            push @found, "{{$name}} (".join(' ', @s).')';
                        }

                        # Add empty parameters for future human taggers,
                        # after setting $any so we don't make useless
                        # edits.
                        push @params, "class=" unless grep(/^\s*class\s*=/, @params);
                        push @params, "$impname=" if(defined($impname) && !grep(/^\s*$impname\s*=/, @params));

                        if(defined($cfg{'canonicalize'})){
                            my $n=$cfg{'canonicalize'};
                            $oname=~s/_/ /g;
                            $oname=~s/^(\s*)\S(?:.*\S)?(\s*)$/$1$n$2/is;
                        }
                        return "{{$oname|".join("|",@params)."}}";
                    });
                    $outtxt=$api->replace_nowiki($outtxt, $nowiki);

                    # Need to edit?
                    if($outtxt ne $intxt && $any){
                        $found[-1]='and '.$found[-1] if @found>1;
                        my $summary="Assessing ".join((@found>2)?', ':' ', @found)." per $req";

                        my @cleanup=();
                        $outtxt=$api->WPBfixshell($outtxt, \@cleanup);
                        if(ref($outtxt) eq 'HASH'){
                            $api->warn("Processing $title failed: ".$outtxt->{'error'}."\n");
                            next;
                        }
                        $summary.="; general banner cleanup (".join(', ', @cleanup).")" if @cleanup;

                        $api->log("$summary in $talk");
                        my $r=$api->edit($tok, $outtxt, $summary, 1, 1);
                        if($r->{'code'} ne 'success'){
                            $api->warn("Write failed on $talk: ".$r->{'error'}."\n");
                            next;
                        }
                    } else {
                        $api->log("Nothing to do in $talk");
                    }

                    # Save checked revision
                    $api->store->{$pageid}=$seq;

                    # If we've been at it long enough, let another task have a
                    # go.
                    return 0 if time()>=$endtime;
                }
            }
        } while(exists($q1{'geicontinue'}));
        delete $api->store->{'geicontinue'};
    }
    delete $api->store->{'template'};

    # No more pages to check, try again in 10 minutes or so in case of errors.
    $api->log("AutoAssessor2 may be DONE!");
    return 600;
}

1;