The Perl script I wrote to help me tabulate the votes on the contest I just ran

I was considering sharing the Perl script I had written, but didn't want to clutter up my post about the winners. Someone asked for it in a comment on that post, so I'm sharing it.

I generally write code with lots of comments, so that a year later when the "maintenance coder" (which might be me!) comes to fix something, there'll be a mostly-accurate guide. Now that I've got these concussions, verbose comments are that much more useful -- because now merely "a day later" I've forgotten a lot of what I was doing.

Also, I generally split code into sections, a habit I started way back working in C, and have dragged it forward to Perl, Python, etc. And, another throwback to C, my scripting code generally just has a line like "exit main();" and then all processing happens inside the main() function/subroutine, and it calls out to others. I've also written my own logging module which I have reproduced several times (since the previous one was locked up in the previous job, and I don't steal code like some people steal pets[1]). (Logging module isn't included here, or used -- the script is self-contained.)

Thus, I won't annotate the code any further; I'll just post it below. Oh also, I'll note that I did this in an Ubuntu 16.04.3 VM, running on this Windows 10 laptop. When I went to copy/paste, it "helpfully" added a CR (carriage return; or, an extra blank line) to every line ending. Rather than going through the below and hitting "down, del" 178 times until each line ending was corrected, I just did an "svn up" on the laptop, as I had checked the code in to my personal Subversion repository. Subversion handles the line endings of text files correctly, so once it appeared on the laptop I was able to easily copy/paste, with no line-ending difficulty.

Also, wanted to note that there are many "print" statements throughout the code, so that as I was developing the solution I could see whether things were happening correctly. I left those in, so the actual output of the votees and number of votes, appears after that -- with a line of text indicating the above are the top 50, and the below are the rest.

I use ActiveState's Komodo IDE to edit and run the script while developing it. Excellent Integrated Development Environment! It's commercial, but they also have a free version Komodo Edit, which just edits, doesn't run the script (and I haven't used it, as I bought a personal license for the IDE years ago and have been upgrading every few years -- still on version 9 right now; I think, like Spinal Tap, they've turned it up to 11 :) ).

If you have any questions on anything in the below, post a comment and I'll do my best to clear up any confusion!

#!/usr/bin/perl
=head1 tabulate_votes2.pl

Second script to tabulate votes, to help me with Steemit.  This is for the contest: https://steemit.com/life/@libertyteeth/libertyteeth-community-minnow-support-vote-for-up-to-five-of-your-favorite-minnows-50-will-get-a-5-slot-in-my-steemvoter

1. I do a voting contest, people nominate others, and the contest ends.
2. Gather the votes in a text document, with the voter on the first line, then their votes separated by spaces, commas, and "extra text", finally a blank line.
3. Run this script on it.

From my work log, a full description which I'll massage:

---
The script will need several aspects to it:

1. Detect self-votes and eliminate all votes from that account. Also keep a list of these, so it can present it.
2. Verify that the voter, and each voted account, is a valid account and alert me so I can try various changes to see if I can find the account that was intended.
3. If a voter has more than five votes, then replace the earlier ones with the later ones, so there is a maximum of five votes from any voter.
4. Then sort based on number of votes (likely I'll use Perl, and a hash, with the key being the account name, and the value being an integer, starting at 0 and
   increment for each vote; then sort on the values in descending order and choose the top 50).
5. Verify each voted account qualifies as a minnow, and set aside any account that's "close" like between 100% and 110%, but no more.
6. Then spit out the list of the top 50, and those who were "close", and I'll finish manually. Also, those who self-voted, because it was the first freaking rule! :)

By "finish manually" I mean that there might have been an account which, when voted on, qualified. I might be able to determine that via steemd.com; or, perhaps, using
steemworld.com or steemnow.com. Alternately, I might just say "congratulations on escaping minnow status during this contest!" We'll see.
---

This script will produce the following output, separated into sections, with one line for each unique account within each section:

Actual votes:
account,number of votes

"Close" accounts:
account,number of votes

Self-voters:
account

Actually, this script now ONLY produces the "actual votes" -- this round, there weren't any self-voters, so don't need to account for that; and, to get the "close"
accounts, I need Python in order to access the STEEM blockchain.

=cut


=head2 ALWAYS USE STRICT AND WARNINGS
=cut
use strict;
use warnings;


=head2 MODULES USED FROM CPAN
=cut
use Getopt::Long;


=head2 MODULES WRITTEN IN-HOUSE
=cut


=head2 VARIABLE DECLARATIONS
=cut
my $vote_file; # file with votes, from the post -- format described above


=head2 SUBROUTINE DECLARATIONS
=cut
sub main();


=head2 MAIN FUNCTION
=cut
exit main();


=head2 SUBROUTINE DEFINITIONS
=cut
=head2 main

Main routine, which tabulates the votes and writes output.

=cut
sub main() {
    GetOptions( "vote_file=s" => \$vote_file,
              ) or die "Error in command line arguments.\n";
    die "ERROR: no vote_file specified!\n" if !defined $vote_file;
    open FH, "<$vote_file" or die "ERROR: can't open file [$vote_file]!\n";
    my @lines = <FH>;
    close FH;
    
    my (%voters, %votes, %close, %self);
    # The %voters hash: key will be the voter; value will be an array with up to five elements; remove first if adding sixth.
    # %votes: key=votee, value=number of votes.
    # %close: key=votee, value=number of votes. NOTE: NOT IMPLEMENTING, as I need Python to talk to the STEEM blockchain.
    # %self: key=voter, value=array with up to five elements; remove first if adding sixth (these are who they WOULD have voted for, if one of them wasn't a self-vote).
    my $voter;
    LINE: foreach my $line ( @lines ) {
        chomp $line; # remove trailing '\n'
        if ( $line eq "" ) {
            if ( !defined $voter ) {
                # Could be two blank lines between voters' blocks; or, could be a blank line at the beginning of the file.
                print "Skipping blank line\n";
                next;
            }
            print "END current voter [$voter]\n\n";
            $voter = undef; # saw a blank line while processing; so, we're done processing the current voter.
            next;
        }
        # Okay, we checked for a blank line.  Next, what to do when the line's not blank.  First, if we're NOT processing a voter,
        # then this line is the voter's name, so set it to start processing.
        if ( !defined $voter ) {
            $voter = $line;
            print "BEGIN processing voter [$voter]\n";
            next;
        }
        # If we're here, the line was not empty, and we are processing a voter's votes.  So, extract any "@word" from this text, and add them as votees for that voter.
        my @votees = split /@/, $line;
        shift @votees; # remove the first element, which is "everything before the first '@'"
        foreach my $votee ( @votees ) {
            $votee =~ s/ .*$//; # remove any space to EOL
            $votee =~ s/,$//;   # remove any comma at the end of the votee's name
            $votee =~ s/\.$//;  # remove any period at the end of the votee's name
            print "  voted for [$votee]\n";
            if ( $voter eq $votee ) {
                print "  SELF-VOTE DETECTED!  All votes by [$voter] will be ignored.\n";
                delete $voters{$voter};
                $self{$voter} = 1;
                next LINE; # Stop processing this voter's votes, they voted for themselves.
            }
            
            if ( grep( /^$votee$/, @{$voters{$voter}} ) ) {
                print "  NOTE: already voted for [$votee] so not adding to the array.\n";
                next;
            }
            push @{$voters{$voter}}, $votee;
            # At this point, if the voter has voted for more than five votees, remove one (from the front) so that there are only five.
            if ( scalar @{$voters{$voter}} > 5 ) {
                my $v = shift @{$voters{$voter}};
                print "  MORE THAN FIVE VOTES, so dropping [$v]\n";
            }
        }

        # FYI, there weren't any self-votes, so that's good!  Looks like it processes the vote file (votes.txt) just fine.
        # Next step: output the top 50 that were voted for, as well as the rest -- I will look up whether they are "minnow status"
        # either manually, or with a Python script -- as it requires Python in order to interact with the STEEM blockchain.
    }
    
    # Okay, now we have the %voters hash completely filled out.  So, let's process it into the %votes hash.
    foreach my $k ( sort keys %voters ) {
        foreach my $v ( sort @{$voters{$k}} ) {
            $votes{$v}++;
        }
    }
    
    # Now, do the reverse: make a hash where the key is the number of votes, and the value is an array containing those voted for.
    my %votes_by_num;
    foreach my $k ( sort keys %votes ) {
        push @{$votes_by_num{$votes{$k}}}, $k;
    }
    
    # Now we can output it.  Walk through %votes_by_num, then walk through the array that is each key's value, printing out the account and
    # the number of votes it obtained, as well as a leading count.  If the count reaches 50, say "above are the winners".
    my $i = 1; # counter, so can print another header once it hits 50
    print "Winners:\n";
    foreach my $k ( reverse sort { $a <=> $b } keys %votes_by_num ) { # The "{ $a <=> $b }" does a numerical sort; default is alphabetical, which put "51" after "5"...
        foreach my $a ( @{$votes_by_num{$k}} ) {
            print "$i: $k $a\n";
            $i++;
            if ( $i eq 51 ) {
                print "\n\nBELOW ARE THE REST OF THE VOTING RESULTS:\n";
            }
        }
    }
    print "breakpoint here!\n";
    
    exit 0;
}

 
Enjoy!

---

[1] -- I haven't followed her TV career, but a very good friend many years ago shared the "Fuck Me, Ray Bradbury" video of hers (also hilarious!), and I looked for others back then and found this one which is ... odd. :)

(And, has a sad explanation of the behavior, towards the end.)

---