# HG changeset patch
# User shellac
# Date 1616436770 0
# Node ID 4f3585e2f14b5eccc4962093494006a337d39f56

"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"

diff -r 000000000000 -r 4f3585e2f14b README.md
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.md	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,3 @@
+# Sam consensus V3
+
+Sam consensus V3 galaxy wrapper
\ No newline at end of file
diff -r 000000000000 -r 4f3585e2f14b call_consensus_from_sam_3.pl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/call_consensus_from_sam_3.pl	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,517 @@
+#!/usr/bin/perl
+# This calls a consensus based on the sam file and does not use qual scores etc it simply counts up each event and calls a simple most observations consensus
+# the sam file must be sorted in order to cope with indels.
+# usgae is ./call_consensus_from_sam_3.pl aligned.sam genome.fasta 10
+# the number 10 is the minimum mapq you want to consider
+
+
+
+open (INFILEFASTA, "$ARGV[1]"); # opens files
+
+open (INFILESAM, "$ARGV[0]");
+$full_len_cut = 1000;
+$min_mapq = $ARGV[2];
+$full_len_count = 0;
+open (OUT, ">$ARGV[0].Observed_differences_list.txt");
+open (OUTINDELS, ">$ARGV[0].Indels_applied_list.txt");
+open (OUTMINOR, ">$ARGV[0].minor_variants.txt");
+print OUTMINOR "Genome\tPosition\tA\tC\tG\tT\tDepth\n";
+open (OUTMINORB, ">$ARGV[0].dominant_minor_variant.txt");
+print OUTMINORB "Genome\tPosition\tA\tC\tG\tT\tDominat nucleotide\tFrequency\tTotal Depth\n";
+print OUT "Genome\tPosition\tReference nucleotide\tGATC Depth count\tG count\tA count\tT count\tC count\tConsensus (. means no change from reference)\tDeletions\tTotal insertions recorded\tThis insertion most popular\tThis many recorded most popular insertions\n";
+open (OUTNEWG, ">$ARGV[0].corrected_genome_snps_only.txt");
+open (OUTNEWGINDEL, ">$ARGV[0].corrected_genome_snps_and_indels.txt");
+open (OUTINDELKEY, ">$ARGV[0].key_indels.txt");
+open (OUTINDELKEYSIG, ">$ARGV[0].Significant_key_indels.txt");
+open (OUTFULLSAM, ">$ARGV[0].full_len_sam.sam");
+$start_time = time;
+
+%for_translation = (TTT=>"F", TTC=>"F", TCT=>"S", TCC=>"S", TAT=>"Y", TAC=>"Y", TGT=>"C", TGC=>"C", TTA=>"L", TCA=>"S", TAA=>"*", TGA=>"*", TTG=>"L", TCG=>"S", TAG=>"*", TGG=>"W", CTT=>"L", CTC=>"L", CCT=>"P", CCC=>"P", CAT=>"H", CAC=>"H", CGT=>"R", CGC=>"R", CTA=>"L", CTG=>"L", CCA=>"P", CCG=>"P", CAA=>"Q", CAG=>"Q", CGA=>"R", CGG=>"R", ATT=>"I", ATC=>"I", ACT=>"T", ACC=>"T", AAT=>"N", AAC=>"N", AGT=>"S", AGC=>"S", ATA=>"I", ACA=>"T", AAA=>"K", AGA=>"R", ATG=>"M", ACG=>"T", AAG=>"K", AGG=>"R", GTT=>"V", GTC=>"V", GCT=>"A", GCC=>"A", GAT=>"D", GAC=>"D", GGT=>"G", GGC=>"G", GTA=>"V", GTG=>"V", GCA=>"A", GCG=>"A", GAA=>"E", GAG=>"E", GGA=>"G", GGG=>"G");
+%rev_translation = (GGC=>"A", ACT=>"S", TCA=>"*", ACA=>"C", TCG=>"R", GAT=>"I", GTT=>"N", GCT=>"S", GTA=>"Y", TGT=>"T", CGA=>"S", CGG=>"P", CAG=>"L", TGC=>"A", CAC=>"V", CTT=>"K", AAC=>"V", GTG=>"H", TCT=>"R", GGT=>"T", TGG=>"P", CCA=>"W", GAG=>"L", GCG=>"R", CAA=>"L", TTA=>"*", CTG=>"Q", CGT=>"T", CAT=>"M", TTT=>"K", TAC=>"V", CTA=>"*", AAG=>"L", TCC=>"G", GAC=>"V", GCA=>"C", TGA=>"S", AAT=>"I", ATA=>"Y", ATT=>"N", AGT=>"T", TTG=>"Q", GTC=>"D", ACC=>"G", GGA=>"S", AAA=>"F", CCT=>"R", ACG=>"R", CCG=>"R", ATG=>"H", TAT=>"I", GGG=>"P", CCC=>"G", TAA=>"L", CTC=>"E", TAG=>"L", ATC=>"D", AGA=>"S", GAA=>"F", CGC=>"A", GCC=>"G", AGC=>"A", TTC=>"E", AGG=>"P");
+%base_pair = (G=>"A", A=>"T", T=>"A", C=>"G");
+
+print OUTINDELS "Chromosome\tType\tLocation\tIndel_count\tIndel_size\tRead_depth\tIndel size\tIndel proportion\n";
+
+
+%transcripts = ();
+%orf_hash =();
+%peptides_pep_score = ();
+%unique_fastas = ();
+%peptides_and_utn = ();
+%utn_and_peptides = ();
+%fasta_head_and_peptides = ();
+%indel_tab = ();
+
+$fasta_out ="";
+$fasta_header = "Not_started_yet";
+while ($fasta_line = <INFILEFASTA>)
+{
+    chomp $fasta_line;
+    print "\n$fasta_line\n";
+    if (substr($fasta_line,0,1) eq ">") {
+        
+        if ($fasta_header ne "Not_started_yet") {
+            #print "\n\nFasta header $fasta_header\n\n";
+            @temp = split (/\s+/, $fasta_header);
+            $fasta_head_no_sp = $temp[0];
+            #print "\n\nAfter split $fasta_head_no_sp\n\n";
+            substr($fasta_head_no_sp,0,1) = "";
+            $transcripts {$fasta_head_no_sp} = $fasta_out;
+            
+            #print "\n\n$fasta_head_no_sp\n\n";
+        }
+        
+        
+        $fasta_header = $fasta_line;
+        
+        
+        $fasta_out ="";
+    }
+    if (substr($fasta_line,0,1) ne ">") {$fasta_out = $fasta_out.$fasta_line;}
+}
+($fasta_head_no_sp, $restofit) = split (/ /, $fasta_header);
+substr($fasta_head_no_sp,0,1,"");
+$transcripts {$fasta_head_no_sp} = $fasta_out;
+
+#print "\n$fasta_header\n\n$fasta_head_no_sp\n";
+
+$faster_header = "";
+$chrom_proc = 0;
+$chromosome = "notstartedyet";
+$old_chromosome = "";
+#exit;
+
+
+$sam_count = 0;
+
+$sam_header= "";
+$transcript_count = 0;
+
+open (INFILESAM, "$ARGV[0]");
+
+while ($sam_line = <INFILESAM>)
+{
+    if (substr($sam_line,0,1) eq "@") {next;}
+    #if (($sam_count % 10000) == 0) {print "$sam_count entries processed\n";}
+    #print "$sam_count\n";
+    $sam_count ++;
+    chomp $sam_line;
+    @sam_cells = split (/\t/, $sam_line);
+    if ($sam_cells[2] eq "*") {next;}
+    if (($sam_cells[2] ne $chromosome) and ($chromosome ne "notstartedyet")) {
+        &process_data;
+        $chromosome = $sam_cells[2];
+        $genome = $transcripts{$chromosome};
+        $len_gen = length $genome;
+        delete $transcripts{$chromosome};
+        $chrom_proc ++;
+        print "hi $chromosome is being processed this is chromosome number $chrom_proc\n";
+        %g = ();
+        %a = ();
+        %t = ();
+        %c = ();
+        %ins = ();
+        %del = ();
+        %depth = ();
+        
+    }
+    # Data processed
+    if ($chromosome eq "notstartedyet") {
+        
+        $chromosome = $sam_cells[2];
+        $genome = $transcripts{$chromosome};
+        $len_gen = length $genome;
+        delete $transcripts{$chromosome};
+        $chrom_proc ++;
+        print "hi $chromosome is being processed this is chromosome number $chrom_proc\n";
+        %g = ();
+        %a = ();
+        %t = ();
+        %c = ();
+        %ins = ();
+        %del = ();
+        %depth = ();
+
+        
+    }
+    
+    
+    
+    $utn = $sam_cells[0];
+    $mapq = $sam_cells[4];
+    $sequence = uc $sam_cells[9];
+    $seq_len = length $sequence;
+    $sequence =~ tr/Uu/TT/;
+    #print "$sam_cells[5]\n";
+    if ($min_mapq > $mapq) {next;}
+    #print "OK";
+    $flag = $sam_cells [1];
+    $genome_position = $sam_cells[3] - 1;
+    $fl_pos = $genome_position;
+    if ($genome_position < $full_len_cut) {$full_len_flag = "S";
+        #if (length $sequence > 28000) {print "possible full len\n";}
+        
+    } else {$full_len_flag = "I";}
+    $sam_position  = 0;
+    @cigar = split(/(M|I|D|N|S|H|P|X|=)/, $sam_cells[5]);
+    $array_cigar = 1;
+    $temp_len = 0;
+    while (length($cigar[$array_cigar]) >=1){
+        $cigar_value = $cigar[$array_cigar - 1];
+        if (($cigar[$array_cigar] eq "M") or ($cigar[$array_cigar] eq "I") or ($cigar[$array_cigar] eq "S")){$temp_len = $temp_len + $cigar_value;}
+        $array_cigar = $array_cigar + 2;
+    }
+    $tran_len = length $sequence;
+    if ($tran_len ne $temp_len) {print "cigar fail\n";next;}
+    $array_cigar = 1;
+    while (length($cigar[$array_cigar]) >=1){
+        #print "cigar entry is $cigar[$array_cigar]\n";
+        $cigar_value = $cigar[$array_cigar - 1];
+        if ($cigar[$array_cigar] =~ /[H]/){
+            #nothing to do
+        }
+        if (($cigar[$array_cigar] =~ /[S]/) and (($array_cigar + 1) < scalar (@cigar)))
+        {
+            $soft_clip = $cigar_value;
+            $sam_position = $sam_position + $cigar_value;
+            $seq_len = $seq_len - $cigar_value;
+        }
+        
+        
+        if ($cigar[$array_cigar] =~ /[M]/){
+            $temp_count = 1;
+            #print "M";
+            while ($temp_count <= $cigar_value)
+            {
+                $depth{$genome_position} ++;
+                $alt = substr($sequence, $sam_position, 1);
+                #print "alternative $alt\n";
+                if ($alt eq "G") {$g{$genome_position} ++;}
+                if ($alt eq "A") {$a{$genome_position} ++;}
+                if ($alt eq "T") {$t{$genome_position} ++;}
+                if ($alt eq "C") {$c{$genome_position} ++;}
+                $temp_count ++;
+                $genome_position ++;
+                $sam_position ++;
+                $fl_pos ++;
+            }
+        
+        }
+
+        #if (($cigar[$array_cigar] =~ /[D]/) and ($cigar_value >4)) {$cigar[$array_cigar] = "N";}
+        
+        if ($cigar[$array_cigar] =~ /[D]/){
+            $temp_cv = $cigar_value - 1;
+            $tmp_name = "$chromosome\tDeletion\t$genome_position\t$cigar_value\t ";
+            if (exists $indel_tab{$tmp_name}){$indel_tab{$tmp_name} ++;} else {$indel_tab{$tmp_name} = 1;}
+            while ($temp_cv >= 0){
+            if (exists $del{$genome_position + $temp_cv}) {$del{$genome_position + $temp_cv} ++;} else {$del{$genome_position + $temp_cv} = 1;}
+                $temp_cv --;
+            }
+            $genome_position = $genome_position + $cigar_value;
+            $fl_pos = $fl_pos + $cigar_value;
+        }
+        
+        if ($cigar[$array_cigar] =~ /[I]/){
+            
+            $insertion = substr ($sequence, $sam_position, $cigar_value);
+            $tmp_name = "$chromosome\tInsertion\t$genome_position\t$cigar_value\t$insertion";
+            if (exists $indel_tab{$tmp_name}){$indel_tab{$tmp_name} ++;} else {$indel_tab{$tmp_name} = 1;}
+        if (exists $ins{$genome_position}) {$ins{$genome_position} = $ins{$genome_position}."\t$insertion";} else {$ins{$genome_position} = $insertion;}
+        
+            $sam_position = $sam_position + $cigar_value;
+        
+        }
+        
+        if ($cigar[$array_cigar] =~ /[N]/){
+            
+            $genome_position = $genome_position + $cigar_value;
+            
+        }
+        $array_cigar = $array_cigar +2;
+        
+    }
+    #if ($fl_pos > ($len_gen - 30)) {print "Stops\n";}
+    #if (($fl_pos > ($len_gen - $full_len_cut)) and ($full_len_flag eq "S")) {print OUTFULLSAM "$sam_line\n"; print "Full length found\n"; $full_len_count ++;}
+    if ($seq_len > ($len_gen - $full_len_cut)) {print OUTFULLSAM "$sam_line\n"; print "Full length found $seq_len X $len_gen\n"; $full_len_count ++;}
+    
+}
+
+
+
+
+#all done just need to process the last chromosome...
+&process_data;
+
+foreach $keys (keys %transcripts){
+    $genome = $transcripts{$keys};
+    print OUTNEWGINDEL ">No_mapped_reads_to_".$keys."_genome_so_no_corrections\n$genome\n";
+    print OUTNEWG ">No_mapped_reads_to_".$keys."_genome_so_no_corrections\n$genome\n";
+}
+
+
+
+$time_elapsed = time - $start_time;
+
+print "Processed $sam_count entries for $chrom_proc chromosomes in $time_elapsed seconds\nFull length entries is $full_len_count\n";
+
+exit;
+
+
+sub process_data { #now to process all the data on this chromosome before moving on to the next one
+    $genome_position = 0;
+    $len_genome = length($genome);
+    $old_genome = $genome;
+    open (TEMP, ">temp.txt");
+    
+    
+    while ($genome_position <= $len_genome){
+        #print "at $genome_position\n";
+        %ins_hash = ();
+        %del_hash = ();
+        $ref_nucleotide = substr ($genome, $genome_position, 1);
+        $sam_con = $ref_nucleotide;
+        $temp_pos = $genome_position + 1;
+        
+        if ($depth{$genome_position} > 0) {
+        $A = $a{$genome_position}/$depth{$genome_position};
+        $C = $c{$genome_position}/$depth{$genome_position};
+        $G = $g{$genome_position}/$depth{$genome_position};
+        $T = $t{$genome_position}/$depth{$genome_position};
+        $test = -1;
+        $consensus = "N";
+        if ($A > $test){$test = $A; $consensus = "A";}
+        if ($C > $test){$test = $C; $consensus = "C";}
+        if ($G > $test){$test = $G; $consensus = "G";}
+        if ($T > $test){$test = $T; $consensus = "T";}
+        if ($consensus eq "A") {$A = $A * -1; $test = $A; print OUTMINOR "$chromosome\t$temp_pos\t$A\t$C\t$G\t$T\t$depth{$genome_position}\n";}
+        if ($consensus eq "C") {$C = $C * -1; $test = $C; print OUTMINOR "$chromosome\t$temp_pos\t$A\t$C\t$G\t$T\t$depth{$genome_position}\n";}
+        if ($consensus eq "G") {$G = $G * -1; $test = $G; print OUTMINOR "$chromosome\t$temp_pos\t$A\t$C\t$G\t$T\t$depth{$genome_position}\n";}
+        if ($consensus eq "T") {$T = $T * -1; $test = $T; print OUTMINOR "$chromosome\t$temp_pos\t$A\t$C\t$G\t$T\t$depth{$genome_position}\n";}
+        if ($consensus eq "N") {print OUTMINOR "$chromosome\t$temp_pos\t0\t0\t0\t0\n";}
+            $major = $test * -1;
+            if ($A > $test){$test = $A; $secconsensus = "A";}
+            if ($C > $test){$test = $C; $secconsensus = "C";}
+            if ($G > $test){$test = $G; $secconsensus = "G";}
+            if ($T > $test){$test = $T; $secconsensus = "T";}
+           
+            if ($secconsensus eq "A") {print OUTMINORB "$chromosome\t$temp_pos\t$A\t0\t0\t0\t$consensus\t$major\t$depth{$genome_position}\n";}
+            if ($secconsensus eq "C") {print OUTMINORB "$chromosome\t$temp_pos\t0\t$C\t0\t0\t$consensus\t$major\t$depth{$genome_position}\n";}
+            if ($secconsensus eq "G") {print OUTMINORB "$chromosome\t$temp_pos\t0\t0\t$G\t0\t$consensus\t$major\t$depth{$genome_position}\n";}
+            if ($secconsensus eq "T") {print OUTMINORB "$chromosome\t$temp_pos\t0\t0\t0\t$T\t$consensus\t$major\t$depth{$genome_position}\n";}
+            if ($secconsensus eq "N") {print OUTMINORB "$chromosome\t$temp_pos\t0\t0\t0\t0\t$consensus\t$major\t$depth{$genome_position}\n";}
+            
+        } else {print OUTMINOR "$chromosome\t$temp_pos\t0\t0\t0\t0\n"; print OUTMINORB "$chromosome\t$temp_pos\t0\t0\t0\t0\n";}
+        
+        if ($depth{$genome_position} < 3) {
+            if ($len_genome <100000){
+                $sam_con = ".";
+                print OUT "$chromosome\t$temp_pos\t$ref_nucleotide\t$depth{$genome_position}\t$g{$genome_position}\t$a{$genome_position} \t$t{$genome_position} \t$c{$genome_position}\t$sam_con\t$del{$genome_position}\t$ins_count\t$temp_most_ins\t$temp_most\n";
+            }
+            $genome_position ++;
+            next;
+        }
+        
+        $temp_most = 0;
+        $temp_most_ins = "";
+        $ins_count = 0;
+        if (exists $ins{$genome_position}){
+            $temp_ins = $ins{$genome_position};
+            @insertions = split (/\t/, $temp_ins);
+            $ins_count = scalar @insertions;
+            foreach $key (@insertions)
+            {
+                $ins_hash{$key} ++;
+                # print "found $key\n";
+            }
+            $temp_most = 0;
+            $temp_most_ins = "";
+            foreach $key (keys %ins_hash){
+                # print "$key   $ins_hash{$key}\n";
+                if ($ins_hash{$key} > $temp_most) {$temp_most = $ins_hash{$key}; $temp_most_ins = $key;}
+            }
+            
+            
+           
+            #if ($ins_count > $depth{$genome_position}) {print OUT "POSSIBLE $ins_count INSERTION AT $genome_position\t $ins{$genome_position}\n";}
+            if ($temp_most > ($depth{$genome_position}) ) {
+                print OUT "Chromosome $chromosome TOTAL $ins_count INSERTION with $depth{$genome_position} no insertions AT $temp_pos most abundant is $temp_most_ins with $temp_most instertions\t $ins{$genome_position}\n";
+                
+                print TEMP "Chromosome $chromosome TOTAL $ins_count INSERTION with $depth{$genome_position} no insertions AT $temp_pos most abundant is $temp_most_ins with $temp_most instertions\t$temp_most_ins\t$genome_position\t$ins{$genome_position}\n";
+            }
+            if ($temp_most > (($depth{$genome_position})/10)) {
+                $indel_proportion = $temp_most/$depth{$genome_position};
+             #print OUTINDELS "Chromosome\tType\tLocation\tIndel_count\tIndel_size\tRead_depth\tIndel size\tIndel proportion\n";
+            print OUTINDELS "$chromosome\tInsertion\t$genome_position\t$ins_count\t$temp_most_ins\t$depth{$genome_position}\t$temp_most_ins\t$indel_proportion\n";
+            }
+            
+            
+        }
+        
+        if (exists $del{$genome_position}){
+
+            if ($del{$genome_position} > $depth{$genome_position}) {
+                print OUT "Chromosome $chromosome POSSIBLE $del{$genome_position} deletion against $depth{$genome_position} no deletions found AT $temp_pos\n";
+                #print OUTINDELS "Chromosome $chromosome POSSIBLE $del{$genome_position} deletion against $depth{$genome_position} no deletions found AT $temp_pos\n";
+                print TEMP "Chromosome $chromosome POSSIBLE $del{$genome_position} deletion against $depth{$genome_position} no deletions found AT $temp_pos most frequent is $temp_most_dels deletion with $del{$genome_position}\t1\t$genome_position\t$del{$genome_position}\n";
+            }
+            #if ($del_count > 10) {print OUT "POSSIBLE $del_count deletion AT $genome_position\t $del{$genome_position}\n";}
+            
+            if ($del{$genome_position} > (($depth{$genome_position})/10)) {
+                           $indel_proportion = $del{$genome_position}/$depth{$genome_position};
+                        #print OUTINDELS "Chromosome\tType\tLocation\tIndel_count\tIndel_size\tRead_depth\tIndel size\tIndel proportion\n";
+                       print OUTINDELS "$chromosome\tDeletion\t$genome_position\t$del{$genome_position}\t$temp_most_dels\t$depth{$genome_position}\t$temp_most_dels\t$indel_proportion\n";
+                       }
+            
+            
+        }
+        
+        
+       
+        
+        
+        
+        $g_flag = 0;
+        $a_flag = 0;
+        $t_flag = 0;
+        $c_flag = 0;
+        $amb = "N";
+        $top_nuc = 0;
+        $top_nucleotide = "";
+        $sec_nuc = 0;
+        $second_nucleotide = "";
+        $ref_nuc = 0;
+        if ($ref_nucleotide eq "G") {$ref_nuc = $g{$genome_position};}
+        if ($ref_nucleotide eq "A") {$ref_nuc = $a{$genome_position};}
+        if ($ref_nucleotide eq "T") {$ref_nuc = $t{$genome_position};}
+        if ($ref_nucleotide eq "C") {$ref_nuc = $c{$genome_position};}
+        if ($g{$genome_position} >= $top_nuc){
+            $sam_con = "G";
+            #$g_flag = 1;
+            $second_nucleotide = $top_nucleotide;
+            $sec_nuc = $top_nuc;
+            $top_nuc = $g{$genome_position};
+            $top_nucleotide = "G";
+            #if ($ref_nucleotide eq "G") {$amb ="G";}
+        }
+        if ($a{$genome_position} >= $top_nuc){
+            $sam_con = "A";
+            #$a_flag = 1;
+            $second_nucleotide = $top_nucleotide;
+            $sec_nuc = $top_nuc;
+            $top_nuc = $a{$genome_position};
+            $top_nucleotide = "A";
+            #if ($ref_nucleotide eq "A") {$amb ="A";}
+        }
+        if ($t{$genome_position} >= $top_nuc){
+                $sam_con = "T";
+            #$t_flag = 1;
+            $second_nucleotide = $top_nucleotide;
+                $sec_nuc = $top_nuc;
+                $top_nuc = $t{$genome_position};
+            $top_nucleotide = "T";
+            #    if ($ref_nucleotide eq "T") {$amb ="T";}
+        }
+        if ($c{$genome_position} >= $top_nuc){
+                $sam_con = "C";
+            #$c_flag = 1;
+             $second_nucleotide = $top_nucleotide;
+                $sec_nuc = $top_nuc;
+                $top_nuc = $c{$genome_position};
+             $top_nucleotide = "C";
+            #    if ($ref_nucleotide eq "C") {$amb ="C";}
+        }
+        
+        #print "This is G's recoded at this location $g{$genome_position}\n";
+        if (($g{$genome_position} >= $a{$genome_position}) and ($g{$genome_position} >= $t{$genome_position}) and ($g{$genome_position} >= $c{$genome_position}) and ($g{$genome_position} >= 1)) {
+            $sam_con = "G"; $g_flag = 1;
+            if ($ref_nucleotide eq "G") {$amb ="G";}
+        }
+        if (($a{$genome_position} >= $g{$genome_position}) and ($a{$genome_position} >= $t{$genome_position}) and ($a{$genome_position} >= $c{$genome_position}) and ($a{$genome_position} >= 1)) {
+            $sam_con = "A"; $a_flag = 1;
+            if ($ref_nucleotide eq "A") {$amb ="A";}
+        }
+        if (($t{$genome_position} >= $g{$genome_position}) and ($t{$genome_position} >= $a{$genome_position}) and ($t{$genome_position} >= $c{$genome_position}) and ($t{$genome_position} >= 1)) {
+            $sam_con = "T"; $t_flag = 1;
+            if ($ref_nucleotide eq "T") {$amb ="T";}
+        }
+        if (($c{$genome_position} >= $g{$genome_position}) and ($c{$genome_position} >= $a{$genome_position}) and ($c{$genome_position} >= $t{$genome_position}) and ($c{$genome_position} >= 1)) {
+            $sam_con = "C"; $c_flag = 1;
+            if ($ref_nucleotide eq "C") {$amb ="C";}
+        }
+        
+        if (($g_flag + $a_flag + $t_flag + $c_flag) > 1) {
+            print OUT "ambiguity chromosome $chromosome at $temp_pos   $g_flag G $a_flag A $t_flag T $c_flag C counts are G $g{$genome_position} A $a{$genome_position} T $t{$genome_position} C $c{$genome_position} \n";
+            if ($amb ne "N") {$sam_con = $amb;}
+        }
+        
+        if ($sam_con ne $ref_nucleotide) {
+            #print "change\n";
+            print OUT "$chromosome\t$temp_pos\t$ref_nucleotide\t$depth{$genome_position}\t$g{$genome_position}\t$a{$genome_position} \t$t{$genome_position} \t$c{$genome_position}\t$sam_con\t$del{$genome_position}\t$ins_count\t$temp_most_ins\t$temp_most\n";
+        } else {
+            if (($len_genome <100000) or ($temp_most > $depth{$genome_position}) or ($del{$genome_position} > $depth{$genome_position})){
+                print OUT "$chromosome\t$temp_pos\t$ref_nucleotide\t$depth{$genome_position}\t$g{$genome_position}\t$a{$genome_position} \t$t{$genome_position} \t$c{$genome_position}\t.\t$del{$genome_position}\t$ins_count\t$temp_most_ins\t$temp_most\n";
+            }
+        }
+        
+        
+        substr ($genome, $genome_position, 1, $sam_con);
+        
+        $genome_position ++;
+        #print "at second $genome_position\n";
+        
+    }
+    
+    
+    close TEMP;
+    $new_genome_w_indels = $genome;
+    open (TEMP, "temp.txt");
+    @indels = reverse<TEMP>;
+    foreach $line (@indels)
+    {
+        chomp $line;
+        @indels_cells = split(/\t/, $line);
+        $change = $indels_cells[1];
+        $type = $indels_cells[0];
+        $genome_position = $indels_cells[2];
+        if (index ($type, " INSERTION ") > 0) {
+            substr ($new_genome_w_indels, $genome_position, 0, $change);
+        }
+        if (index ($type, " deletion ") > 0) {
+            substr ($new_genome_w_indels, $genome_position, 1, "");
+        }
+        
+    }
+    
+    
+    
+    print OUTNEWGINDEL ">New_".$chromosome."_genome_with_indels_is\n$new_genome_w_indels\n";
+    print OUTNEWG ">New_".$chromosome."_genome_is\n$genome\n";
+    open (CTSO, ">$ARGV[0].CTSO.txt");
+    $warning = "";
+    #open (OUTINDELKEYSIG, ">$ARGV[0].Significant_key_indels.txt");
+    # open (OUTINDELKEY, ">$ARGV[0].key_indels.txt");
+    # $tmp_name = "$chromosome\tDeletion\t$genome_position\t$temp_cv\t$insertion"; temp_cv is the size of the indel
+    print OUTINDELKEY "Chromosome\tInsertion or deletion\tLocation\tIndel size\tInsertion seq\tObservation count\tDepth at this lcation\tProportion of observation vs depth\n";
+    print OUTINDELKEYSIG "Chromosome\tInsertion or deletion\tLocation\tIndel size\tInsertion seq\tObservation count\tDepth at this lcation\tProportion of observation vs depth\n";
+    foreach $key (keys %indel_tab){
+        $value = $indel_tab{$key};
+        @array = split(/\t/, $key);
+        $genome_position = $array[2]; $indel_len = $array[3];
+        if ($depth{$genome_position} > 0) {$a = ($value / $depth{$genome_position}); $tmp_proportion  = sprintf ("%.2f",$a);} else {$tmp_proportion = "zero depth here";}
+ 
+           print OUTINDELKEY "$key\t$value\t$depth{$genome_position}\t$tmp_proportion\n";
+           if ($tmp_proportion > 0.1) {
+               
+               if ($indel_len > 6) {print "\n\nCtSo\nInsertion or deletion\t$array[1]\nLocation\t$genome_position\nIndel size\t$indel_len\nObservation count\t$value\nDepth at this location\t$depth{$genome_position}\nProportion of observation vs depth\t$tmp_proportion\n\n";
+                   print CTSO "\n\nCtSo\nInsertion or deletion\t$array[1]\nLocation\t$genome_position\nIndel size\t$indel_len\nObservation count\t$value\nDepth at this location\t$depth{$genome_position}\nProportion of observation vs depth\t$tmp_proportion\n\n";
+                   print OUTINDELKEYSIG "$key\t$value\t$depth{$genome_position}\t$tmp_proportion\n";
+                   if (($value > 9) or ($depth{$genome_position} > 9)) {$warning = $warning."$key\t$value\t$depth{$genome_position}\t$tmp_proportion\n";}
+               }
+               #print OUTINDELKEYSIG "$key\t$value\t$depth{$genome_position}\t$tmp_proportion\n";
+           }
+    
+}
+if ($warning ne "") {print OUTINDELKEYSIG "\n\nEspecially take a moment to look at these in the above list...CtSo!\n\n$warning\n";}
+}
+
diff -r 000000000000 -r 4f3585e2f14b env/bin/Activate.ps1
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/Activate.ps1	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,241 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virutal environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/bagit.cpython-39.pyc
Binary file env/bin/__pycache__/bagit.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2html.cpython-39.pyc
Binary file env/bin/__pycache__/rst2html.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2html4.cpython-39.pyc
Binary file env/bin/__pycache__/rst2html4.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2html5.cpython-39.pyc
Binary file env/bin/__pycache__/rst2html5.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2latex.cpython-39.pyc
Binary file env/bin/__pycache__/rst2latex.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2man.cpython-39.pyc
Binary file env/bin/__pycache__/rst2man.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2odt.cpython-39.pyc
Binary file env/bin/__pycache__/rst2odt.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2odt_prepstyles.cpython-39.pyc
Binary file env/bin/__pycache__/rst2odt_prepstyles.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2pseudoxml.cpython-39.pyc
Binary file env/bin/__pycache__/rst2pseudoxml.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2s5.cpython-39.pyc
Binary file env/bin/__pycache__/rst2s5.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2xetex.cpython-39.pyc
Binary file env/bin/__pycache__/rst2xetex.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rst2xml.cpython-39.pyc
Binary file env/bin/__pycache__/rst2xml.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/__pycache__/rstpep2html.cpython-39.pyc
Binary file env/bin/__pycache__/rstpep2html.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/activate
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/activate	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,66 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r 2> /dev/null
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(env) ${PS1:-}"
+    export PS1
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2> /dev/null
+fi
diff -r 000000000000 -r 4f3585e2f14b env/bin/activate-global-python-argcomplete
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/activate-global-python-argcomplete	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,76 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# PYTHON_ARGCOMPLETE_OK
+
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+'''
+Activate the generic bash-completion script for the argcomplete module.
+'''
+
+import os, sys, argparse, argcomplete, shutil, fileinput
+
+parser = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+
+dest_opt = parser.add_argument("--dest", default="/etc/bash_completion.d",
+                               help="Specify the bash completion modules directory to install into")
+parser.add_argument("--user", help="Install into user directory (~/.bash_completion.d/)", action='store_true')
+parser.add_argument("--no-defaults", dest="use_defaults", action="store_false", default=True,
+                    help="When no matches are generated, do not fallback to readline\'s default completion")
+parser.add_argument("--complete-arguments", nargs=argparse.REMAINDER,
+                    help="arguments to call complete with; use of this option discards default options")
+argcomplete.autocomplete(parser)
+args = parser.parse_args()
+
+if args.user:
+    args.dest = os.path.expanduser("~/.bash_completion.d/")
+    if not os.path.exists(args.dest):
+        try:
+            os.mkdir(args.dest)
+        except Exception as e:
+            parser.error("Path {d} does not exist and could not be created: {e}".format(d=args.dest, e=e))
+elif not os.path.exists(args.dest) and args.dest != '-':
+    if sys.platform == 'darwin' and args.dest == dest_opt.default and os.path.exists("/usr/local" + dest_opt.default):
+        args.dest = "/usr/local" + dest_opt.default
+    else:
+        parser.error("Path {d} does not exist".format(d=args.dest))
+
+activator = os.path.join(os.path.dirname(argcomplete.__file__), 'bash_completion.d', 'python-argcomplete')
+
+if args.complete_arguments is None:
+    complete_options = '-o default -o bashdefault' if args.use_defaults else '-o bashdefault'
+else:
+    complete_options = " ".join(args.complete_arguments)
+complete_call = "complete{} -D -F _python_argcomplete_global".format(" " + complete_options if complete_options else "")
+def replaceCompleteCall(line):
+    if line.startswith("complete") and "_python_argcomplete_global" in line:
+        return complete_call + ('\n' if line.endswith('\n') else '')
+    else:
+        return line
+
+if args.dest == '-':
+    for l in open(activator):
+        sys.stdout.write(replaceCompleteCall(l))
+else:
+    dest = os.path.join(args.dest, "python-argcomplete")
+
+    sys.stdout.write("Installing bash completion script " + dest)
+    if not args.use_defaults:
+        sys.stdout.write(" without -o default")
+    elif args.complete_arguments:
+        sys.stdout.write(" with options: " + complete_options)
+    sys.stdout.write("\n")
+
+    try:
+        shutil.copy(activator, dest)
+        if args.complete_arguments or not args.use_defaults:
+            for l in fileinput.input(dest, inplace=True):
+                # fileinput with inplace=True redirects stdout to the edited file
+                sys.stdout.write(replaceCompleteCall(l))
+    except Exception as e:
+        err = str(e)
+        if args.dest == dest_opt.default:
+            err += ("\nPlease try --user to install into a user directory, "
+                    "or --dest to specify the bash completion modules directory")
+        parser.error(err)
diff -r 000000000000 -r 4f3585e2f14b env/bin/activate.csh
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/activate.csh	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,25 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(env) $prompt"
+endif
+
+alias pydoc python -m pydoc
+
+rehash
diff -r 000000000000 -r 4f3585e2f14b env/bin/activate.fish
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/activate.fish	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,64 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        functions -e fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+    end
+
+    set -e VIRTUAL_ENV
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(env) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end
diff -r 000000000000 -r 4f3585e2f14b env/bin/asadmin
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/asadmin	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,290 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2011 Joel Barciauskas http://joel.barciausk.as/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+#
+# Auto Scaling Groups Tool
+#
+VERSION="0.1"
+usage = """%prog [options] [command]
+Commands:
+    list|ls                           List all Auto Scaling Groups
+    list-lc|ls-lc                     List all Launch Configurations
+    delete    <name>                  Delete ASG <name>
+    delete-lc <name>                  Delete Launch Configuration <name>
+    get       <name>                  Get details of ASG <name>
+    create    <name>                  Create an ASG
+    create-lc <name>                  Create a Launch Configuration
+    update    <name> <prop> <value>   Update a property of an ASG
+    update-image <asg-name> <lc-name> Update image ID for ASG by creating a new LC
+    migrate-instances <name>          Shut down current instances one by one and wait for ASG to start up a new instance with the current AMI (useful in conjunction with update-image)
+
+Examples:
+
+    1) Create launch configuration
+        bin/asadmin create-lc my-lc-1 -i ami-1234abcd -t c1.xlarge -k my-key -s web-group -m
+
+    2) Create auto scaling group in us-east-1a and us-east-1c with a load balancer and min size of 2 and max size of 6
+        bin/asadmin create my-asg -z us-east-1a -z us-east-1c -l my-lc-1 -b my-lb -H ELB -p 180 -x 2 -X 6
+"""
+
+def get_group(autoscale, name):
+    g = autoscale.get_all_groups(names=[name])
+    if len(g) < 1:
+        print "No auto scaling groups by the name of %s found" % name
+        return sys.exit(1)
+    return g[0]
+
+def get_lc(autoscale, name):
+    l = autoscale.get_all_launch_configurations(names=[name])
+    if len(l) < 1:
+        print "No launch configurations by the name of %s found" % name
+        sys.exit(1)
+    return l[0]
+
+def list(autoscale):
+    """List all ASGs"""
+    print "%-20s %s" %  ("Name", "LC Name")
+    print "-"*80
+    groups = autoscale.get_all_groups()
+    for g in groups:
+        print "%-20s %s" % (g.name, g.launch_config_name)
+
+def list_lc(autoscale):
+    """List all LCs"""
+    print "%-30s %-20s %s" %  ("Name", "Image ID", "Instance Type")
+    print "-"*80
+    for l in autoscale.get_all_launch_configurations():
+        print "%-30s %-20s %s" % (l.name, l.image_id, l.instance_type)
+
+def get(autoscale, name):
+    """Get details about ASG <name>"""
+    g = get_group(autoscale, name)
+    print "="*80
+    print "%-30s %s" % ('Name:', g.name)
+    print "%-30s %s" % ('Launch configuration:', g.launch_config_name)
+    print "%-30s %s" % ('Minimum size:', g.min_size)
+    print "%-30s %s" % ('Maximum size:', g.max_size)
+    print "%-30s %s" % ('Desired capacity:', g.desired_capacity)
+    print "%-30s %s" % ('Load balancers:', ','.join(g.load_balancers))
+
+    print
+
+    print "Instances"
+    print "---------"
+    print "%-20s %-20s %-20s %s" % ("ID", "Status", "Health", "AZ")
+    for i in g.instances:
+        print "%-20s %-20s %-20s %s" % \
+        (i.instance_id, i.lifecycle_state, i.health_status, i.availability_zone)
+
+    print
+
+def create(autoscale, name, zones, lc_name, load_balancers, hc_type, hc_period,
+        min_size, max_size, cooldown, capacity):
+    """Create an ASG named <name>"""
+    g = AutoScalingGroup(name=name, launch_config=lc_name,
+            availability_zones=zones, load_balancers=load_balancers,
+            default_cooldown=cooldown, health_check_type=hc_type,
+            health_check_period=hc_period, desired_capacity=capacity,
+            min_size=min_size, max_size=max_size)
+    g = autoscale.create_auto_scaling_group(g)
+    return list(autoscale)
+
+def create_lc(autoscale, name, image_id, instance_type, key_name,
+        security_groups, instance_monitoring):
+    l = LaunchConfiguration(name=name, image_id=image_id,
+            instance_type=instance_type,key_name=key_name,
+            security_groups=security_groups,
+            instance_monitoring=instance_monitoring)
+    l = autoscale.create_launch_configuration(l)
+    return list_lc(autoscale)
+
+def update(autoscale, name, prop, value):
+    g = get_group(autoscale, name)
+    setattr(g, prop, value)
+    g.update()
+    return get(autoscale, name)
+
+def delete(autoscale, name, force_delete=False):
+    """Delete this ASG"""
+    g = get_group(autoscale, name)
+    autoscale.delete_auto_scaling_group(g.name, force_delete)
+    print "Auto scaling group %s deleted" % name
+    return list(autoscale)
+
+def delete_lc(autoscale, name):
+    """Delete this LC"""
+    l = get_lc(autoscale, name)
+    autoscale.delete_launch_configuration(name)
+    print "Launch configuration %s deleted" % name
+    return list_lc(autoscale)
+
+def update_image(autoscale, name, lc_name, image_id, is_migrate_instances=False):
+    """ Get the current launch config,
+        Update its name and image id
+        Re-create it as a new launch config
+        Update the ASG with the new LC
+        Delete the old LC """
+
+    g = get_group(autoscale, name)
+    l = get_lc(autoscale, g.launch_config_name)
+
+    old_lc_name = l.name
+    l.name = lc_name
+    l.image_id = image_id
+    autoscale.create_launch_configuration(l)
+    g.launch_config_name = l.name
+    g.update()
+
+    if(is_migrate_instances):
+        migrate_instances(autoscale, name)
+    else:
+        return get(autoscale, name)
+
+def migrate_instances(autoscale, name):
+    """ Shut down instances of the old image type one by one
+        and let the ASG start up instances with the new image """
+    g = get_group(autoscale, name)
+
+    old_instances = g.instances
+    ec2 = boto.connect_ec2()
+    for old_instance in old_instances:
+        print "Terminating instance " + old_instance.instance_id
+        ec2.terminate_instances([old_instance.instance_id])
+        while True:
+            g = get_group(autoscale, name)
+            new_instances = g.instances
+            for new_instance in new_instances:
+                hasOldInstance = False
+                instancesReady = True
+                if(old_instance.instance_id == new_instance.instance_id):
+                    hasOldInstance = True
+                    print "Waiting for old instance to shut down..."
+                    break
+                elif(new_instance.lifecycle_state != 'InService'):
+                    instancesReady = False
+                    print "Waiting for instances to be ready...."
+                    break
+            if(not hasOldInstance and instancesReady):
+                break
+            else:
+                time.sleep(20)
+    return get(autoscale, name)
+
+if __name__ == "__main__":
+    try:
+        import readline
+    except ImportError:
+        pass
+    import boto
+    import sys
+    import time
+    from optparse import OptionParser
+    from boto.mashups.iobject import IObject
+    from boto.ec2.autoscale import AutoScalingGroup
+    from boto.ec2.autoscale import LaunchConfiguration
+    parser = OptionParser(version=VERSION, usage=usage)
+    """ Create launch config options """
+    parser.add_option("-i", "--image-id",
+            help="Image (AMI) ID", action="store",
+            type="string", default=None, dest="image_id")
+    parser.add_option("-t", "--instance-type",
+            help="EC2 Instance Type (e.g., m1.large, c1.xlarge), default is m1.large",
+            action="store", type="string", default="m1.large", dest="instance_type")
+    parser.add_option("-k", "--key-name",
+            help="EC2 Key Name",
+            action="store", type="string", dest="key_name")
+    parser.add_option("-s", "--security-group",
+            help="EC2 Security Group",
+            action="append", default=[], dest="security_groups")
+    parser.add_option("-m", "--monitoring",
+            help="Enable instance monitoring",
+            action="store_true", default=False, dest="instance_monitoring")
+
+    """ Create auto scaling group options """
+    parser.add_option("-z", "--zone", help="Add availability zone", action="append", default=[], dest="zones")
+    parser.add_option("-l", "--lc-name",
+            help="Launch configuration name",
+            action="store", default=None, type="string", dest="lc_name")
+    parser.add_option("-b", "--load-balancer",
+            help="Load balancer name",
+            action="append", default=[], dest="load_balancers")
+    parser.add_option("-H", "--health-check-type",
+            help="Health check type (EC2 or ELB)",
+            action="store", default="EC2", type="string", dest="hc_type")
+    parser.add_option("-p", "--health-check-period",
+            help="Health check period in seconds (default 300s)",
+            action="store", default=300, type="int", dest="hc_period")
+    parser.add_option("-X", "--max-size",
+            help="Max size of ASG (default 10)",
+            action="store", default=10, type="int", dest="max_size")
+    parser.add_option("-x", "--min-size",
+            help="Min size of ASG (default 2)",
+            action="store", default=2, type="int", dest="min_size")
+    parser.add_option("-c", "--cooldown",
+            help="Cooldown time after a scaling activity in seconds (default 300s)",
+            action="store", default=300, type="int", dest="cooldown")
+    parser.add_option("-C", "--desired-capacity",
+            help="Desired capacity of the ASG",
+            action="store", default=None, type="int", dest="capacity")
+    parser.add_option("-f", "--force",
+            help="Force delete ASG",
+            action="store_true", default=False, dest="force")
+    parser.add_option("-y", "--migrate-instances",
+            help="Automatically migrate instances to new image when running update-image",
+            action="store_true", default=False, dest="migrate_instances")
+
+    (options, args) = parser.parse_args()
+
+    if len(args) < 1:
+        parser.print_help()
+        sys.exit(1)
+
+    autoscale = boto.connect_autoscale()
+
+    print "%s" % (autoscale.region.endpoint)
+
+    command = args[0].lower()
+    if command in ("ls", "list"):
+        list(autoscale)
+    elif command in ("ls-lc", "list-lc"):
+        list_lc(autoscale)
+    elif command == "get":
+        get(autoscale, args[1])
+    elif command == "create":
+        create(autoscale, args[1], options.zones, options.lc_name,
+                options.load_balancers, options.hc_type,
+                options.hc_period, options.min_size, options.max_size,
+                options.cooldown, options.capacity)
+    elif command == "create-lc":
+        create_lc(autoscale, args[1], options.image_id, options.instance_type,
+                options.key_name, options.security_groups,
+                options.instance_monitoring)
+    elif command == "update":
+        update(autoscale, args[1], args[2], args[3])
+    elif command == "delete":
+        delete(autoscale, args[1], options.force)
+    elif command == "delete-lc":
+        delete_lc(autoscale, args[1])
+    elif command == "update-image":
+        update_image(autoscale, args[1], args[2],
+                options.image_id, options.migrate_instances)
+    elif command == "migrate-instances":
+        migrate_instances(autoscale, args[1])
diff -r 000000000000 -r 4f3585e2f14b env/bin/bagit.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/bagit.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1617 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import argparse
+import codecs
+import gettext
+import hashlib
+import logging
+import multiprocessing
+import os
+import re
+import signal
+import sys
+import tempfile
+import unicodedata
+import warnings
+from collections import defaultdict
+from datetime import date
+from functools import partial
+from os.path import abspath, isdir, isfile, join
+
+from pkg_resources import DistributionNotFound, get_distribution
+
+try:
+    from urllib.parse import urlparse
+except ImportError:
+    from urlparse import urlparse
+
+
+def find_locale_dir():
+    for prefix in (os.path.dirname(__file__), sys.prefix):
+        locale_dir = os.path.join(prefix, "locale")
+        if os.path.isdir(locale_dir):
+            return locale_dir
+
+
+TRANSLATION_CATALOG = gettext.translation(
+    "bagit-python", localedir=find_locale_dir(), fallback=True
+)
+if sys.version_info < (3,):
+    _ = TRANSLATION_CATALOG.ugettext
+else:
+    _ = TRANSLATION_CATALOG.gettext
+
+MODULE_NAME = "bagit" if __name__ == "__main__" else __name__
+
+LOGGER = logging.getLogger(MODULE_NAME)
+
+try:
+    VERSION = get_distribution(MODULE_NAME).version
+except DistributionNotFound:
+    VERSION = "0.0.dev0"
+
+PROJECT_URL = "https://github.com/LibraryOfCongress/bagit-python"
+
+__doc__ = (
+    _(
+        """
+BagIt is a directory, filename convention for bundling an arbitrary set of
+files with a manifest, checksums, and additional metadata. More about BagIt
+can be found at:
+
+    http://purl.org/net/bagit
+
+bagit.py is a pure python drop in library and command line tool for creating,
+and working with BagIt directories.
+
+
+Command-Line Usage:
+
+Basic usage is to give bagit.py a directory to bag up:
+
+    $ bagit.py my_directory
+
+This does a bag-in-place operation where the current contents will be moved
+into the appropriate BagIt structure and the metadata files will be created.
+
+You can bag multiple directories if you wish:
+
+    $ bagit.py directory1 directory2
+
+Optionally you can provide metadata which will be stored in bag-info.txt:
+
+    $ bagit.py --source-organization "Library of Congress" directory
+
+You can also select which manifest algorithms will be used:
+
+    $ bagit.py --sha1 --md5 --sha256 --sha512 directory
+
+
+Using BagIt from your Python code:
+
+    import bagit
+    bag = bagit.make_bag('example-directory', {'Contact-Name': 'Ed Summers'})
+    print(bag.entries)
+
+For more information or to contribute to bagit-python's development, please
+visit %(PROJECT_URL)s
+"""
+    )
+    % globals()
+)
+
+# standard bag-info.txt metadata
+STANDARD_BAG_INFO_HEADERS = [
+    "Source-Organization",
+    "Organization-Address",
+    "Contact-Name",
+    "Contact-Phone",
+    "Contact-Email",
+    "External-Description",
+    "External-Identifier",
+    "Bag-Size",
+    "Bag-Group-Identifier",
+    "Bag-Count",
+    "Internal-Sender-Identifier",
+    "Internal-Sender-Description",
+    "BagIt-Profile-Identifier",
+    # Bagging-Date is autogenerated
+    # Payload-Oxum is autogenerated
+]
+
+try:
+    CHECKSUM_ALGOS = hashlib.algorithms_guaranteed
+except AttributeError:
+    # FIXME: remove when we drop Python 2 (https://github.com/LibraryOfCongress/bagit-python/issues/102)
+    # Python 2.7.0-2.7.8
+    CHECKSUM_ALGOS = set(hashlib.algorithms)
+DEFAULT_CHECKSUMS = ["sha256", "sha512"]
+
+#: Block size used when reading files for hashing:
+HASH_BLOCK_SIZE = 512 * 1024
+
+#: Convenience function used everywhere we want to open a file to read text
+#: rather than undecoded bytes:
+open_text_file = partial(codecs.open, encoding="utf-8", errors="strict")
+
+# This is the same as decoding the byte values in codecs.BOM:
+UNICODE_BYTE_ORDER_MARK = "\uFEFF"
+
+
+def make_bag(
+    bag_dir, bag_info=None, processes=1, checksums=None, checksum=None, encoding="utf-8"
+):
+    """
+    Convert a given directory into a bag. You can pass in arbitrary
+    key/value pairs to put into the bag-info.txt metadata file as
+    the bag_info dictionary.
+    """
+
+    if checksum is not None:
+        warnings.warn(
+            _(
+                "The `checksum` argument for `make_bag` should be replaced with `checksums`"
+            ),
+            DeprecationWarning,
+        )
+        checksums = checksum
+
+    if checksums is None:
+        checksums = DEFAULT_CHECKSUMS
+
+    bag_dir = os.path.abspath(bag_dir)
+    cwd = os.path.abspath(os.path.curdir)
+
+    if cwd.startswith(bag_dir) and cwd != bag_dir:
+        raise RuntimeError(
+            _("Bagging a parent of the current directory is not supported")
+        )
+
+    LOGGER.info(_("Creating bag for directory %s"), bag_dir)
+
+    if not os.path.isdir(bag_dir):
+        LOGGER.error(_("Bag directory %s does not exist"), bag_dir)
+        raise RuntimeError(_("Bag directory %s does not exist") % bag_dir)
+
+    # FIXME: we should do the permissions checks before changing directories
+    old_dir = os.path.abspath(os.path.curdir)
+
+    try:
+        # TODO: These two checks are currently redundant since an unreadable directory will also
+        #       often be unwritable, and this code will require review when we add the option to
+        #       bag to a destination other than the source. It would be nice if we could avoid
+        #       walking the directory tree more than once even if most filesystems will cache it
+
+        unbaggable = _can_bag(bag_dir)
+
+        if unbaggable:
+            LOGGER.error(
+                _("Unable to write to the following directories and files:\n%s"),
+                unbaggable,
+            )
+            raise BagError(_("Missing permissions to move all files and directories"))
+
+        unreadable_dirs, unreadable_files = _can_read(bag_dir)
+
+        if unreadable_dirs or unreadable_files:
+            if unreadable_dirs:
+                LOGGER.error(
+                    _("The following directories do not have read permissions:\n%s"),
+                    unreadable_dirs,
+                )
+            if unreadable_files:
+                LOGGER.error(
+                    _("The following files do not have read permissions:\n%s"),
+                    unreadable_files,
+                )
+            raise BagError(
+                _("Read permissions are required to calculate file fixities")
+            )
+        else:
+            LOGGER.info(_("Creating data directory"))
+
+            # FIXME: if we calculate full paths we won't need to deal with changing directories
+            os.chdir(bag_dir)
+            cwd = os.getcwd()
+            temp_data = tempfile.mkdtemp(dir=cwd)
+
+            for f in os.listdir("."):
+                if os.path.abspath(f) == temp_data:
+                    continue
+                new_f = os.path.join(temp_data, f)
+                LOGGER.info(
+                    _("Moving %(source)s to %(destination)s"),
+                    {"source": f, "destination": new_f},
+                )
+                os.rename(f, new_f)
+
+            LOGGER.info(
+                _("Moving %(source)s to %(destination)s"),
+                {"source": temp_data, "destination": "data"},
+            )
+            os.rename(temp_data, "data")
+
+            # permissions for the payload directory should match those of the
+            # original directory
+            os.chmod("data", os.stat(cwd).st_mode)
+
+            total_bytes, total_files = make_manifests(
+                "data", processes, algorithms=checksums, encoding=encoding
+            )
+
+            LOGGER.info(_("Creating bagit.txt"))
+            txt = """BagIt-Version: 0.97\nTag-File-Character-Encoding: UTF-8\n"""
+            with open_text_file("bagit.txt", "w") as bagit_file:
+                bagit_file.write(txt)
+
+            LOGGER.info(_("Creating bag-info.txt"))
+            if bag_info is None:
+                bag_info = {}
+
+            # allow 'Bagging-Date' and 'Bag-Software-Agent' to be overidden
+            if "Bagging-Date" not in bag_info:
+                bag_info["Bagging-Date"] = date.strftime(date.today(), "%Y-%m-%d")
+            if "Bag-Software-Agent" not in bag_info:
+                bag_info["Bag-Software-Agent"] = "bagit.py v%s <%s>" % (
+                    VERSION,
+                    PROJECT_URL,
+                )
+
+            bag_info["Payload-Oxum"] = "%s.%s" % (total_bytes, total_files)
+            _make_tag_file("bag-info.txt", bag_info)
+
+            for c in checksums:
+                _make_tagmanifest_file(c, bag_dir, encoding="utf-8")
+    except Exception:
+        LOGGER.exception(_("An error occurred creating a bag in %s"), bag_dir)
+        raise
+    finally:
+        os.chdir(old_dir)
+
+    return Bag(bag_dir)
+
+
+class Bag(object):
+    """A representation of a bag."""
+
+    valid_files = ["bagit.txt", "fetch.txt"]
+    valid_directories = ["data"]
+
+    def __init__(self, path=None):
+        super(Bag, self).__init__()
+        self.tags = {}
+        self.info = {}
+        #: Dictionary of manifest entries and the checksum values for each
+        #: algorithm:
+        self.entries = {}
+
+        # To reliably handle Unicode normalization differences, we maintain
+        # lookup dictionaries in both directions for the filenames read from
+        # the filesystem and the manifests so we can handle cases where the
+        # normalization form changed between the bag being created and read.
+        # See https://github.com/LibraryOfCongress/bagit-python/issues/51.
+
+        #: maps Unicode-normalized values to the raw value from the filesystem
+        self.normalized_filesystem_names = {}
+
+        #: maps Unicode-normalized values to the raw value in the manifest
+        self.normalized_manifest_names = {}
+
+        self.algorithms = []
+        self.tag_file_name = None
+        self.path = abspath(path)
+        if path:
+            # if path ends in a path separator, strip it off
+            if path[-1] == os.sep:
+                self.path = path[:-1]
+            self._open()
+
+    def __str__(self):
+        # FIXME: develop a more informative string representation for a Bag
+        return self.path
+
+    @property
+    def algs(self):
+        warnings.warn(_("Use Bag.algorithms instead of Bag.algs"), DeprecationWarning)
+        return self.algorithms
+
+    @property
+    def version(self):
+        warnings.warn(
+            _("Use the Bag.version_info tuple instead of Bag.version"),
+            DeprecationWarning,
+        )
+        return self._version
+
+    def _open(self):
+        # Open the bagit.txt file, and load any tags from it, including
+        # the required version and encoding.
+        bagit_file_path = os.path.join(self.path, "bagit.txt")
+
+        if not isfile(bagit_file_path):
+            raise BagError(_("Expected bagit.txt does not exist: %s") % bagit_file_path)
+
+        self.tags = tags = _load_tag_file(bagit_file_path)
+
+        required_tags = ("BagIt-Version", "Tag-File-Character-Encoding")
+        missing_tags = [i for i in required_tags if i not in tags]
+        if missing_tags:
+            raise BagError(
+                _("Missing required tag in bagit.txt: %s") % ", ".join(missing_tags)
+            )
+
+        # To avoid breaking existing code we'll leave self.version as the string
+        # and parse it into a numeric version_info tuple. In version 2.0 we can
+        # break that.
+
+        self._version = tags["BagIt-Version"]
+
+        try:
+            self.version_info = tuple(int(i) for i in self._version.split(".", 1))
+        except ValueError:
+            raise BagError(
+                _("Bag version numbers must be MAJOR.MINOR numbers, not %s")
+                % self._version
+            )
+
+        if (0, 93) <= self.version_info <= (0, 95):
+            self.tag_file_name = "package-info.txt"
+        elif (0, 96) <= self.version_info < (2,):
+            self.tag_file_name = "bag-info.txt"
+        else:
+            raise BagError(_("Unsupported bag version: %s") % self._version)
+
+        self.encoding = tags["Tag-File-Character-Encoding"]
+
+        try:
+            codecs.lookup(self.encoding)
+        except LookupError:
+            raise BagValidationError(_("Unsupported encoding: %s") % self.encoding)
+
+        info_file_path = os.path.join(self.path, self.tag_file_name)
+        if os.path.exists(info_file_path):
+            self.info = _load_tag_file(info_file_path, encoding=self.encoding)
+
+        self._load_manifests()
+
+    def manifest_files(self):
+        for filename in ["manifest-%s.txt" % a for a in CHECKSUM_ALGOS]:
+            f = os.path.join(self.path, filename)
+            if isfile(f):
+                yield f
+
+    def tagmanifest_files(self):
+        for filename in ["tagmanifest-%s.txt" % a for a in CHECKSUM_ALGOS]:
+            f = os.path.join(self.path, filename)
+            if isfile(f):
+                yield f
+
+    def compare_manifests_with_fs(self):
+        """
+        Compare the filenames in the manifests to the filenames present on the
+        local filesystem and returns two lists of the files which are only
+        present in the manifests and the files which are only present on the
+        local filesystem, respectively.
+        """
+
+        # We compare the filenames after Unicode normalization so we can
+        # reliably detect normalization changes after bag creation:
+        files_on_fs = set(normalize_unicode(i) for i in self.payload_files())
+        files_in_manifest = set(
+            normalize_unicode(i) for i in self.payload_entries().keys()
+        )
+
+        if self.version_info >= (0, 97):
+            files_in_manifest.update(self.missing_optional_tagfiles())
+
+        only_on_fs = list()
+        only_in_manifest = list()
+
+        for i in files_on_fs.difference(files_in_manifest):
+            only_on_fs.append(self.normalized_filesystem_names[i])
+
+        for i in files_in_manifest.difference(files_on_fs):
+            only_in_manifest.append(self.normalized_manifest_names[i])
+
+        return only_in_manifest, only_on_fs
+
+    def compare_fetch_with_fs(self):
+        """Compares the fetch entries with the files actually
+           in the payload, and returns a list of all the files
+           that still need to be fetched.
+        """
+
+        files_on_fs = set(self.payload_files())
+        files_in_fetch = set(self.files_to_be_fetched())
+
+        return list(files_in_fetch - files_on_fs)
+
+    def payload_files(self):
+        """Returns a list of filenames which are present on the local filesystem"""
+        payload_dir = os.path.join(self.path, "data")
+
+        for dirpath, _, filenames in os.walk(payload_dir):
+            for f in filenames:
+                # Jump through some hoops here to make the payload files are
+                # returned with the directory structure relative to the base
+                # directory rather than the
+                normalized_f = os.path.normpath(f)
+                rel_path = os.path.relpath(
+                    os.path.join(dirpath, normalized_f), start=self.path
+                )
+
+                self.normalized_filesystem_names[normalize_unicode(rel_path)] = rel_path
+                yield rel_path
+
+    def payload_entries(self):
+        """Return a dictionary of items """
+        # Don't use dict comprehension (compatibility with Python < 2.7)
+        return dict(
+            (key, value)
+            for (key, value) in self.entries.items()
+            if key.startswith("data" + os.sep)
+        )
+
+    def save(self, processes=1, manifests=False):
+        """
+        save will persist any changes that have been made to the bag
+        metadata (self.info).
+
+        If you have modified the payload of the bag (added, modified,
+        removed files in the data directory) and want to regenerate manifests
+        set the manifests parameter to True. The default is False since you
+        wouldn't want a save to accidentally create a new manifest for
+        a corrupted bag.
+
+        If you want to control the number of processes that are used when
+        recalculating checksums use the processes parameter.
+        """
+        # Error checking
+        if not self.path:
+            raise BagError(_("Bag.save() called before setting the path!"))
+
+        if not os.access(self.path, os.R_OK | os.W_OK | os.X_OK):
+            raise BagError(
+                _("Cannot save bag to non-existent or inaccessible directory %s")
+                % self.path
+            )
+
+        unbaggable = _can_bag(self.path)
+        if unbaggable:
+            LOGGER.error(
+                _(
+                    "Missing write permissions for the following directories and files:\n%s"
+                ),
+                unbaggable,
+            )
+            raise BagError(_("Missing permissions to move all files and directories"))
+
+        unreadable_dirs, unreadable_files = _can_read(self.path)
+        if unreadable_dirs or unreadable_files:
+            if unreadable_dirs:
+                LOGGER.error(
+                    _("The following directories do not have read permissions:\n%s"),
+                    unreadable_dirs,
+                )
+            if unreadable_files:
+                LOGGER.error(
+                    _("The following files do not have read permissions:\n%s"),
+                    unreadable_files,
+                )
+            raise BagError(
+                _("Read permissions are required to calculate file fixities")
+            )
+
+        # Change working directory to bag directory so helper functions work
+        old_dir = os.path.abspath(os.path.curdir)
+        os.chdir(self.path)
+
+        # Generate new manifest files
+        if manifests:
+            total_bytes, total_files = make_manifests(
+                "data", processes, algorithms=self.algorithms, encoding=self.encoding
+            )
+
+            # Update Payload-Oxum
+            LOGGER.info(_("Updating Payload-Oxum in %s"), self.tag_file_name)
+            self.info["Payload-Oxum"] = "%s.%s" % (total_bytes, total_files)
+
+        _make_tag_file(self.tag_file_name, self.info)
+
+        # Update tag-manifest for changes to manifest & bag-info files
+        for alg in self.algorithms:
+            _make_tagmanifest_file(alg, self.path, encoding=self.encoding)
+
+        # Reload the manifests
+        self._load_manifests()
+
+        os.chdir(old_dir)
+
+    def tagfile_entries(self):
+        return dict(
+            (key, value)
+            for (key, value) in self.entries.items()
+            if not key.startswith("data" + os.sep)
+        )
+
+    def missing_optional_tagfiles(self):
+        """
+        From v0.97 we need to validate any tagfiles listed
+        in the optional tagmanifest(s). As there is no mandatory
+        directory structure for additional tagfiles we can
+        only check for entries with missing files (not missing
+        entries for existing files).
+        """
+        for tagfilepath in self.tagfile_entries().keys():
+            if not os.path.isfile(os.path.join(self.path, tagfilepath)):
+                yield tagfilepath
+
+    def fetch_entries(self):
+        """Load fetch.txt if present and iterate over its contents
+
+        yields (url, size, filename) tuples
+
+        raises BagError for errors such as an unsafe filename referencing
+        data outside of the bag directory
+        """
+
+        fetch_file_path = os.path.join(self.path, "fetch.txt")
+
+        if isfile(fetch_file_path):
+            with open_text_file(
+                fetch_file_path, "r", encoding=self.encoding
+            ) as fetch_file:
+                for line in fetch_file:
+                    url, file_size, filename = line.strip().split(None, 2)
+
+                    if self._path_is_dangerous(filename):
+                        raise BagError(
+                            _('Path "%(payload_file)s" in "%(source_file)s" is unsafe')
+                            % {
+                                "payload_file": filename,
+                                "source_file": os.path.join(self.path, "fetch.txt"),
+                            }
+                        )
+
+                    yield url, file_size, filename
+
+    def files_to_be_fetched(self):
+        """
+        Convenience wrapper for fetch_entries which returns only the
+        local filename
+        """
+
+        for url, file_size, filename in self.fetch_entries():
+            yield filename
+
+    def has_oxum(self):
+        return "Payload-Oxum" in self.info
+
+    def validate(self, processes=1, fast=False, completeness_only=False):
+        """Checks the structure and contents are valid.
+
+        If you supply the parameter fast=True the Payload-Oxum (if present) will
+        be used to check that the payload files are present and accounted for,
+        instead of re-calculating fixities and comparing them against the
+        manifest. By default validate() will re-calculate fixities (fast=False).
+        """
+
+        self._validate_structure()
+        self._validate_bagittxt()
+
+        self.validate_fetch()
+
+        self._validate_contents(
+            processes=processes, fast=fast, completeness_only=completeness_only
+        )
+
+        return True
+
+    def is_valid(self, fast=False, completeness_only=False):
+        """Returns validation success or failure as boolean.
+        Optional fast parameter passed directly to validate().
+        """
+
+        try:
+            self.validate(fast=fast, completeness_only=completeness_only)
+        except BagError:
+            return False
+
+        return True
+
+    def _load_manifests(self):
+        self.entries = {}
+        manifests = list(self.manifest_files())
+
+        if self.version_info >= (0, 97):
+            # v0.97+ requires that optional tagfiles are verified.
+            manifests += list(self.tagmanifest_files())
+
+        for manifest_filename in manifests:
+            if manifest_filename.find("tagmanifest-") != -1:
+                search = "tagmanifest-"
+            else:
+                search = "manifest-"
+            alg = (
+                os.path.basename(manifest_filename)
+                .replace(search, "")
+                .replace(".txt", "")
+            )
+            if alg not in self.algorithms:
+                self.algorithms.append(alg)
+
+            with open_text_file(
+                manifest_filename, "r", encoding=self.encoding
+            ) as manifest_file:
+                if manifest_file.encoding.startswith("UTF"):
+                    # We'll check the first character to see if it's a BOM:
+                    if manifest_file.read(1) == UNICODE_BYTE_ORDER_MARK:
+                        # We'll skip it either way by letting line decoding
+                        # happen at the new offset but we will issue a warning
+                        # for UTF-8 since the presence of a BOM  is contrary to
+                        # the BagIt specification:
+                        if manifest_file.encoding == "UTF-8":
+                            LOGGER.warning(
+                                _(
+                                    "%s is encoded using UTF-8 but contains an unnecessary"
+                                    " byte-order mark, which is not in compliance with the"
+                                    " BagIt RFC"
+                                ),
+                                manifest_file.name,
+                            )
+                    else:
+                        manifest_file.seek(0)  # Pretend the first read never happened
+
+                for line in manifest_file:
+                    line = line.strip()
+
+                    # Ignore blank lines and comments.
+                    if line == "" or line.startswith("#"):
+                        continue
+
+                    entry = line.split(None, 1)
+
+                    # Format is FILENAME *CHECKSUM
+                    if len(entry) != 2:
+                        LOGGER.error(
+                            _(
+                                "%(bag)s: Invalid %(algorithm)s manifest entry: %(line)s"
+                            ),
+                            {"bag": self, "algorithm": alg, "line": line},
+                        )
+                        continue
+
+                    entry_hash = entry[0]
+                    entry_path = os.path.normpath(entry[1].lstrip("*"))
+                    entry_path = _decode_filename(entry_path)
+
+                    if self._path_is_dangerous(entry_path):
+                        raise BagError(
+                            _(
+                                'Path "%(payload_file)s" in manifest "%(manifest_file)s" is unsafe'
+                            )
+                            % {
+                                "payload_file": entry_path,
+                                "manifest_file": manifest_file.name,
+                            }
+                        )
+
+                    entry_hashes = self.entries.setdefault(entry_path, {})
+
+                    if alg in entry_hashes:
+                        warning_ctx = {
+                            "bag": self,
+                            "algorithm": alg,
+                            "filename": entry_path,
+                        }
+                        if entry_hashes[alg] == entry_hash:
+                            msg = _(
+                                "%(bag)s: %(algorithm)s manifest lists %(filename)s"
+                                " multiple times with the same value"
+                            )
+                            if self.version_info >= (1,):
+                                raise BagError(msg % warning_ctx)
+                            else:
+                                LOGGER.warning(msg, warning_ctx)
+                        else:
+                            raise BagError(
+                                _(
+                                    "%(bag)s: %(algorithm)s manifest lists %(filename)s"
+                                    " multiple times with conflicting values"
+                                )
+                                % warning_ctx
+                            )
+
+                    entry_hashes[alg] = entry_hash
+
+        self.normalized_manifest_names.update(
+            (normalize_unicode(i), i) for i in self.entries.keys()
+        )
+
+    def _validate_structure(self):
+        """
+        Checks the structure of the bag to determine whether it conforms to the
+        BagIt spec. Returns true on success, otherwise it will raise a
+        BagValidationError exception.
+        """
+
+        self._validate_structure_payload_directory()
+        self._validate_structure_tag_files()
+
+    def _validate_structure_payload_directory(self):
+        data_dir_path = os.path.join(self.path, "data")
+
+        if not isdir(data_dir_path):
+            raise BagValidationError(
+                _("Expected data directory %s does not exist") % data_dir_path
+            )
+
+    def _validate_structure_tag_files(self):
+        # Note: we deviate somewhat from v0.96 of the spec in that it allows
+        # other files and directories to be present in the base directory
+
+        if not list(self.manifest_files()):
+            raise BagValidationError(_("No manifest files found"))
+        if "bagit.txt" not in os.listdir(self.path):
+            raise BagValidationError(
+                _('Expected %s to contain "bagit.txt"') % self.path
+            )
+
+    def validate_fetch(self):
+        """Validate the fetch.txt file
+
+        Raises `BagError` for errors and otherwise returns no value
+        """
+
+        for url, file_size, filename in self.fetch_entries():
+            # fetch_entries will raise a BagError for unsafe filenames
+            # so at this point we will check only that the URL is minimally
+            # well formed:
+            parsed_url = urlparse(url)
+
+            if not all((parsed_url.scheme, parsed_url.netloc)):
+                raise BagError(_("Malformed URL in fetch.txt: %s") % url)
+
+    def _validate_contents(self, processes=1, fast=False, completeness_only=False):
+        if fast and not self.has_oxum():
+            raise BagValidationError(
+                _("Fast validation requires bag-info.txt to include Payload-Oxum")
+            )
+
+        # Perform the fast file count + size check so we can fail early:
+        self._validate_oxum()
+
+        if fast:
+            return
+
+        self._validate_completeness()
+
+        if completeness_only:
+            return
+
+        self._validate_entries(processes)
+
+    def _validate_oxum(self):
+        oxum = self.info.get("Payload-Oxum")
+
+        if oxum is None:
+            return
+
+        # If multiple Payload-Oxum tags (bad idea)
+        # use the first listed in bag-info.txt
+        if isinstance(oxum, list):
+            LOGGER.warning(_("bag-info.txt defines multiple Payload-Oxum values!"))
+            oxum = oxum[0]
+
+        oxum_byte_count, oxum_file_count = oxum.split(".", 1)
+
+        if not oxum_byte_count.isdigit() or not oxum_file_count.isdigit():
+            raise BagError(_("Malformed Payload-Oxum value: %s") % oxum)
+
+        oxum_byte_count = int(oxum_byte_count)
+        oxum_file_count = int(oxum_file_count)
+        total_bytes = 0
+        total_files = 0
+
+        for payload_file in self.payload_files():
+            payload_file = os.path.join(self.path, payload_file)
+            total_bytes += os.stat(payload_file).st_size
+            total_files += 1
+
+        if oxum_file_count != total_files or oxum_byte_count != total_bytes:
+            raise BagValidationError(
+                _(
+                    "Payload-Oxum validation failed."
+                    " Expected %(oxum_file_count)d files and %(oxum_byte_count)d bytes"
+                    " but found %(found_file_count)d files and %(found_byte_count)d bytes"
+                )
+                % {
+                    "found_file_count": total_files,
+                    "found_byte_count": total_bytes,
+                    "oxum_file_count": oxum_file_count,
+                    "oxum_byte_count": oxum_byte_count,
+                }
+            )
+
+    def _validate_completeness(self):
+        """
+        Verify that the actual file manifests match the files in the data directory
+        """
+        errors = list()
+
+        # First we'll make sure there's no mismatch between the filesystem
+        # and the list of files in the manifest(s)
+        only_in_manifests, only_on_fs = self.compare_manifests_with_fs()
+        for path in only_in_manifests:
+            e = FileMissing(path)
+            LOGGER.warning(force_unicode(e))
+            errors.append(e)
+        for path in only_on_fs:
+            e = UnexpectedFile(path)
+            LOGGER.warning(force_unicode(e))
+            errors.append(e)
+
+        if errors:
+            raise BagValidationError(_("Bag validation failed"), errors)
+
+    def _validate_entries(self, processes):
+        """
+        Verify that the actual file contents match the recorded hashes stored in the manifest files
+        """
+        errors = list()
+
+        if os.name == "posix":
+            worker_init = posix_multiprocessing_worker_initializer
+        else:
+            worker_init = None
+
+        args = (
+            (
+                self.path,
+                self.normalized_filesystem_names.get(rel_path, rel_path),
+                hashes,
+                self.algorithms,
+            )
+            for rel_path, hashes in self.entries.items()
+        )
+
+        try:
+            if processes == 1:
+                hash_results = [_calc_hashes(i) for i in args]
+            else:
+                try:
+                    pool = multiprocessing.Pool(
+                        processes if processes else None, initializer=worker_init
+                    )
+                    hash_results = pool.map(_calc_hashes, args)
+                finally:
+                    pool.terminate()
+
+        # Any unhandled exceptions are probably fatal
+        except:
+            LOGGER.exception(_("Unable to calculate file hashes for %s"), self)
+            raise
+
+        for rel_path, f_hashes, hashes in hash_results:
+            for alg, computed_hash in f_hashes.items():
+                stored_hash = hashes[alg]
+                if stored_hash.lower() != computed_hash:
+                    e = ChecksumMismatch(
+                        rel_path, alg, stored_hash.lower(), computed_hash
+                    )
+                    LOGGER.warning(force_unicode(e))
+                    errors.append(e)
+
+        if errors:
+            raise BagValidationError(_("Bag validation failed"), errors)
+
+    def _validate_bagittxt(self):
+        """
+        Verify that bagit.txt conforms to specification
+        """
+        bagit_file_path = os.path.join(self.path, "bagit.txt")
+
+        # Note that we are intentionally opening this file in binary mode so we can confirm
+        # that it does not start with the UTF-8 byte-order-mark
+        with open(bagit_file_path, "rb") as bagit_file:
+            first_line = bagit_file.read(4)
+            if first_line.startswith(codecs.BOM_UTF8):
+                raise BagValidationError(
+                    _("bagit.txt must not contain a byte-order mark")
+                )
+
+    def _path_is_dangerous(self, path):
+        """
+        Return true if path looks dangerous, i.e. potentially operates
+        outside the bagging directory structure, e.g. ~/.bashrc, ../../../secrets.json,
+            \\?\c:\, D:\sys32\cmd.exe
+        """
+        if os.path.isabs(path):
+            return True
+        if os.path.expanduser(path) != path:
+            return True
+        if os.path.expandvars(path) != path:
+            return True
+        real_path = os.path.realpath(os.path.join(self.path, path))
+        real_path = os.path.normpath(real_path)
+        bag_path = os.path.realpath(self.path)
+        bag_path = os.path.normpath(bag_path)
+        common = os.path.commonprefix((bag_path, real_path))
+        return not (common == bag_path)
+
+
+class BagError(Exception):
+    pass
+
+
+class BagValidationError(BagError):
+    def __init__(self, message, details=None):
+        super(BagValidationError, self).__init__()
+
+        if details is None:
+            details = []
+
+        self.message = message
+        self.details = details
+
+    def __str__(self):
+        if len(self.details) > 0:
+            details = "; ".join([force_unicode(e) for e in self.details])
+            return "%s: %s" % (self.message, details)
+        return self.message
+
+
+class ManifestErrorDetail(BagError):
+    def __init__(self, path):
+        super(ManifestErrorDetail, self).__init__()
+
+        self.path = path
+
+
+class ChecksumMismatch(ManifestErrorDetail):
+    def __init__(self, path, algorithm=None, expected=None, found=None):
+        super(ChecksumMismatch, self).__init__(path)
+
+        self.path = path
+        self.algorithm = algorithm
+        self.expected = expected
+        self.found = found
+
+    def __str__(self):
+        return _(
+            '%(path)s %(algorithm)s validation failed: expected="%(expected)s" found="%(found)s"'
+        ) % {
+            "path": force_unicode(self.path),
+            "algorithm": self.algorithm,
+            "expected": self.expected,
+            "found": self.found,
+        }
+
+
+class FileMissing(ManifestErrorDetail):
+    def __str__(self):
+        return _(
+            "%s exists in manifest but was not found on filesystem"
+        ) % force_unicode(self.path)
+
+
+class UnexpectedFile(ManifestErrorDetail):
+    def __str__(self):
+        return _("%s exists on filesystem but is not in the manifest") % self.path
+
+
+class FileNormalizationConflict(BagError):
+    """
+    Exception raised when two files differ only in normalization and thus
+    are not safely portable
+    """
+
+    def __init__(self, file_a, file_b):
+        super(FileNormalizationConflict, self).__init__()
+
+        self.file_a = file_a
+        self.file_b = file_b
+
+    def __str__(self):
+        return _(
+            'Unicode normalization conflict for file "%(file_a)s" and "%(file_b)s"'
+        ) % {"file_a": self.file_a, "file_b": self.file_b}
+
+
+def posix_multiprocessing_worker_initializer():
+    """Ignore SIGINT in multiprocessing workers on POSIX systems"""
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+
+# The Unicode normalization form used here doesn't matter – all we care about
+# is consistency since the input value will be preserved:
+
+
+def normalize_unicode_py3(s):
+    return unicodedata.normalize("NFC", s)
+
+
+def normalize_unicode_py2(s):
+    if isinstance(s, str):
+        s = s.decode("utf-8")
+    return unicodedata.normalize("NFC", s)
+
+
+if sys.version_info > (3, 0):
+    normalize_unicode = normalize_unicode_py3
+else:
+    normalize_unicode = normalize_unicode_py2
+
+
+def build_unicode_normalized_lookup_dict(filenames):
+    """
+    Return a dictionary mapping unicode-normalized filenames to as-encoded
+    values to efficiently detect conflicts between the filesystem and manifests.
+
+    This is necessary because some filesystems and utilities may automatically
+    apply a different Unicode normalization form to filenames than was applied
+    when the bag was originally created.
+
+    The best known example of this is when a bag is created using a
+    normalization form other than NFD and then transferred to a Mac where the
+    HFS+ filesystem will transparently normalize filenames to a variant of NFD
+    for every call:
+
+    https://developer.apple.com/legacy/library/technotes/tn/tn1150.html#UnicodeSubtleties
+
+    Windows is documented as storing filenames exactly as provided:
+
+    https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx
+
+    Linux performs no normalization in the kernel but it is technically
+    valid for a filesystem to perform normalization, such as when an HFS+
+    volume is mounted.
+
+    See http://www.unicode.org/reports/tr15/ for a full discussion of
+    equivalence and normalization in Unicode.
+    """
+
+    output = dict()
+
+    for filename in filenames:
+        normalized_filename = normalize_unicode(filename)
+        if normalized_filename in output:
+            raise FileNormalizationConflict(filename, output[normalized_filename])
+        else:
+            output[normalized_filename] = filename
+
+    return output
+
+
+def get_hashers(algorithms):
+    """
+    Given a list of algorithm names, return a dictionary of hasher instances
+
+    This avoids redundant code between the creation and validation code where in
+    both cases we want to avoid reading the same file more than once. The
+    intended use is a simple for loop:
+
+        for block in file:
+            for hasher in hashers.values():
+                hasher.update(block)
+    """
+
+    hashers = {}
+
+    for alg in algorithms:
+        try:
+            hasher = hashlib.new(alg)
+        except ValueError:
+            LOGGER.warning(
+                _("Disabling requested hash algorithm %s: hashlib does not support it"),
+                alg,
+            )
+            continue
+
+        hashers[alg] = hasher
+
+    if not hashers:
+        raise ValueError(
+            _(
+                "Unable to continue: hashlib does not support any of the requested algorithms!"
+            )
+        )
+
+    return hashers
+
+
+def _calc_hashes(args):
+    # auto unpacking of sequences illegal in Python3
+    (base_path, rel_path, hashes, algorithms) = args
+    full_path = os.path.join(base_path, rel_path)
+
+    # Create a clone of the default empty hash objects:
+    f_hashers = dict((alg, hashlib.new(alg)) for alg in hashes if alg in algorithms)
+
+    try:
+        f_hashes = _calculate_file_hashes(full_path, f_hashers)
+    except BagValidationError as e:
+        f_hashes = dict((alg, force_unicode(e)) for alg in f_hashers.keys())
+
+    return rel_path, f_hashes, hashes
+
+
+def _calculate_file_hashes(full_path, f_hashers):
+    """
+    Returns a dictionary of (algorithm, hexdigest) values for the provided
+    filename
+    """
+    LOGGER.info(_("Verifying checksum for file %s"), full_path)
+
+    try:
+        with open(full_path, "rb") as f:
+            while True:
+                block = f.read(HASH_BLOCK_SIZE)
+                if not block:
+                    break
+                for i in f_hashers.values():
+                    i.update(block)
+    except (OSError, IOError) as e:
+        raise BagValidationError(
+            _("Could not read %(filename)s: %(error)s")
+            % {"filename": full_path, "error": force_unicode(e)}
+        )
+
+    return dict((alg, h.hexdigest()) for alg, h in f_hashers.items())
+
+
+def _load_tag_file(tag_file_name, encoding="utf-8-sig"):
+    with open_text_file(tag_file_name, "r", encoding=encoding) as tag_file:
+        # Store duplicate tags as list of vals
+        # in order of parsing under the same key.
+        tags = {}
+        for name, value in _parse_tags(tag_file):
+            if name not in tags:
+                tags[name] = value
+                continue
+
+            if not isinstance(tags[name], list):
+                tags[name] = [tags[name], value]
+            else:
+                tags[name].append(value)
+
+        return tags
+
+
+def _parse_tags(tag_file):
+    """Parses a tag file, according to RFC 2822.  This
+       includes line folding, permitting extra-long
+       field values.
+
+       See http://www.faqs.org/rfcs/rfc2822.html for
+       more information.
+    """
+
+    tag_name = None
+    tag_value = None
+
+    # Line folding is handled by yielding values only after we encounter
+    # the start of a new tag, or if we pass the EOF.
+    for num, line in enumerate(tag_file):
+        # Skip over any empty or blank lines.
+        if len(line) == 0 or line.isspace():
+            continue
+        elif line[0].isspace() and tag_value is not None:  # folded line
+            tag_value += line
+        else:
+            # Starting a new tag; yield the last one.
+            if tag_name:
+                yield (tag_name, tag_value.strip())
+
+            if ":" not in line:
+                raise BagValidationError(
+                    _("%(filename)s contains invalid tag: %(line)s")
+                    % {
+                        "line": line.strip(),
+                        "filename": os.path.basename(tag_file.name),
+                    }
+                )
+
+            parts = line.strip().split(":", 1)
+            tag_name = parts[0].strip()
+            tag_value = parts[1]
+
+    # Passed the EOF.  All done after this.
+    if tag_name:
+        yield (tag_name, tag_value.strip())
+
+
+def _make_tag_file(bag_info_path, bag_info):
+    headers = sorted(bag_info.keys())
+    with open_text_file(bag_info_path, "w") as f:
+        for h in headers:
+            values = bag_info[h]
+            if not isinstance(values, list):
+                values = [values]
+            for txt in values:
+                # strip CR, LF and CRLF so they don't mess up the tag file
+                txt = re.sub(r"\n|\r|(\r\n)", "", force_unicode(txt))
+                f.write("%s: %s\n" % (h, txt))
+
+
+def make_manifests(data_dir, processes, algorithms=DEFAULT_CHECKSUMS, encoding="utf-8"):
+    LOGGER.info(
+        _("Using %(process_count)d processes to generate manifests: %(algorithms)s"),
+        {"process_count": processes, "algorithms": ", ".join(algorithms)},
+    )
+
+    manifest_line_generator = partial(generate_manifest_lines, algorithms=algorithms)
+
+    if processes > 1:
+        pool = multiprocessing.Pool(processes=processes)
+        checksums = pool.map(manifest_line_generator, _walk(data_dir))
+        pool.close()
+        pool.join()
+    else:
+        checksums = [manifest_line_generator(i) for i in _walk(data_dir)]
+
+    # At this point we have a list of tuples which start with the algorithm name:
+    manifest_data = {}
+    for batch in checksums:
+        for entry in batch:
+            manifest_data.setdefault(entry[0], []).append(entry[1:])
+
+    # These will be keyed on the algorithm name so we can perform sanity checks
+    # below to catch failures in the hashing process:
+    num_files = defaultdict(lambda: 0)
+    total_bytes = defaultdict(lambda: 0)
+
+    for algorithm, values in manifest_data.items():
+        manifest_filename = "manifest-%s.txt" % algorithm
+
+        with open_text_file(manifest_filename, "w", encoding=encoding) as manifest:
+            for digest, filename, byte_count in values:
+                manifest.write("%s  %s\n" % (digest, _encode_filename(filename)))
+                num_files[algorithm] += 1
+                total_bytes[algorithm] += byte_count
+
+    # We'll use sets of the values for the error checks and eventually return the payload oxum values:
+    byte_value_set = set(total_bytes.values())
+    file_count_set = set(num_files.values())
+
+    # allow a bag with an empty payload
+    if not byte_value_set and not file_count_set:
+        return 0, 0
+
+    if len(file_count_set) != 1:
+        raise RuntimeError(_("Expected the same number of files for each checksum"))
+
+    if len(byte_value_set) != 1:
+        raise RuntimeError(_("Expected the same number of bytes for each checksums"))
+
+    return byte_value_set.pop(), file_count_set.pop()
+
+
+def _make_tagmanifest_file(alg, bag_dir, encoding="utf-8"):
+    tagmanifest_file = join(bag_dir, "tagmanifest-%s.txt" % alg)
+    LOGGER.info(_("Creating %s"), tagmanifest_file)
+
+    checksums = []
+    for f in _find_tag_files(bag_dir):
+        if re.match(r"^tagmanifest-.+\.txt$", f):
+            continue
+        with open(join(bag_dir, f), "rb") as fh:
+            m = hashlib.new(alg)
+            while True:
+                block = fh.read(HASH_BLOCK_SIZE)
+                if not block:
+                    break
+                m.update(block)
+            checksums.append((m.hexdigest(), f))
+
+    with open_text_file(
+        join(bag_dir, tagmanifest_file), mode="w", encoding=encoding
+    ) as tagmanifest:
+        for digest, filename in checksums:
+            tagmanifest.write("%s %s\n" % (digest, filename))
+
+
+def _find_tag_files(bag_dir):
+    for dir in os.listdir(bag_dir):
+        if dir != "data":
+            if os.path.isfile(dir) and not dir.startswith("tagmanifest-"):
+                yield dir
+            for dir_name, _, filenames in os.walk(dir):
+                for filename in filenames:
+                    if filename.startswith("tagmanifest-"):
+                        continue
+                    # remove everything up to the bag_dir directory
+                    p = join(dir_name, filename)
+                    yield os.path.relpath(p, bag_dir)
+
+
+def _walk(data_dir):
+    for dirpath, dirnames, filenames in os.walk(data_dir):
+        # if we don't sort here the order of entries is non-deterministic
+        # which makes it hard to test the fixity of tagmanifest-md5.txt
+        filenames.sort()
+        dirnames.sort()
+        for fn in filenames:
+            path = os.path.join(dirpath, fn)
+            # BagIt spec requires manifest to always use '/' as path separator
+            if os.path.sep != "/":
+                parts = path.split(os.path.sep)
+                path = "/".join(parts)
+            yield path
+
+
+def _can_bag(test_dir):
+    """Scan the provided directory for files which cannot be bagged due to insufficient permissions"""
+    unbaggable = []
+
+    if not os.access(test_dir, os.R_OK):
+        # We cannot continue without permission to read the source directory
+        unbaggable.append(test_dir)
+        return unbaggable
+
+    if not os.access(test_dir, os.W_OK):
+        unbaggable.append(test_dir)
+
+    for dirpath, dirnames, filenames in os.walk(test_dir):
+        for directory in dirnames:
+            full_path = os.path.join(dirpath, directory)
+            if not os.access(full_path, os.W_OK):
+                unbaggable.append(full_path)
+
+    return unbaggable
+
+
+def _can_read(test_dir):
+    """
+    returns ((unreadable_dirs), (unreadable_files))
+    """
+    unreadable_dirs = []
+    unreadable_files = []
+
+    if not os.access(test_dir, os.R_OK):
+        unreadable_dirs.append(test_dir)
+    else:
+        for dirpath, dirnames, filenames in os.walk(test_dir):
+            for dn in dirnames:
+                full_path = os.path.join(dirpath, dn)
+                if not os.access(full_path, os.R_OK):
+                    unreadable_dirs.append(full_path)
+            for fn in filenames:
+                full_path = os.path.join(dirpath, fn)
+                if not os.access(full_path, os.R_OK):
+                    unreadable_files.append(full_path)
+    return (tuple(unreadable_dirs), tuple(unreadable_files))
+
+
+def generate_manifest_lines(filename, algorithms=DEFAULT_CHECKSUMS):
+    LOGGER.info(_("Generating manifest lines for file %s"), filename)
+
+    # For performance we'll read the file only once and pass it block
+    # by block to every requested hash algorithm:
+    hashers = get_hashers(algorithms)
+
+    total_bytes = 0
+
+    with open(filename, "rb") as f:
+        while True:
+            block = f.read(HASH_BLOCK_SIZE)
+
+            if not block:
+                break
+
+            total_bytes += len(block)
+            for hasher in hashers.values():
+                hasher.update(block)
+
+    decoded_filename = _decode_filename(filename)
+
+    # We'll generate a list of results in roughly manifest format but prefixed with the algorithm:
+    results = [
+        (alg, hasher.hexdigest(), decoded_filename, total_bytes)
+        for alg, hasher in hashers.items()
+    ]
+
+    return results
+
+
+def _encode_filename(s):
+    s = s.replace("\r", "%0D")
+    s = s.replace("\n", "%0A")
+    return s
+
+
+def _decode_filename(s):
+    s = re.sub(r"%0D", "\r", s, re.IGNORECASE)
+    s = re.sub(r"%0A", "\n", s, re.IGNORECASE)
+    return s
+
+
+def force_unicode_py2(s):
+    """Reliably return a Unicode string given a possible unicode or byte string"""
+    if isinstance(s, str):
+        return s.decode("utf-8")
+    else:
+        return unicode(s)
+
+
+if sys.version_info > (3, 0):
+    force_unicode = str
+else:
+    force_unicode = force_unicode_py2
+
+# following code is used for command line program
+
+
+class BagArgumentParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        argparse.ArgumentParser.__init__(self, *args, **kwargs)
+        self.set_defaults(bag_info={})
+
+
+class BagHeaderAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        opt = option_string.lstrip("--")
+        opt_caps = "-".join([o.capitalize() for o in opt.split("-")])
+        namespace.bag_info[opt_caps] = values
+
+
+def _make_parser():
+    parser = BagArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="bagit-python version %s\n\n%s\n" % (VERSION, __doc__.strip()),
+    )
+    parser.add_argument(
+        "--processes",
+        type=int,
+        dest="processes",
+        default=1,
+        help=_(
+            "Use multiple processes to calculate checksums faster (default: %(default)s)"
+        ),
+    )
+    parser.add_argument("--log", help=_("The name of the log file (default: stdout)"))
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help=_("Suppress all progress information other than errors"),
+    )
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help=_(
+            "Validate existing bags in the provided directories instead of"
+            " creating new ones"
+        ),
+    )
+    parser.add_argument(
+        "--fast",
+        action="store_true",
+        help=_(
+            "Modify --validate behaviour to only test whether the bag directory"
+            " has the number of files and total size specified in Payload-Oxum"
+            " without performing checksum validation to detect corruption."
+        ),
+    )
+    parser.add_argument(
+        "--completeness-only",
+        action="store_true",
+        help=_(
+            "Modify --validate behaviour to test whether the bag directory"
+            " has the expected payload specified in the checksum manifests"
+            " without performing checksum validation to detect corruption."
+        ),
+    )
+
+    checksum_args = parser.add_argument_group(
+        _("Checksum Algorithms"),
+        _(
+            "Select the manifest algorithms to be used when creating bags"
+            " (default=%s)"
+        )
+        % ", ".join(DEFAULT_CHECKSUMS),
+    )
+
+    for i in CHECKSUM_ALGOS:
+        alg_name = re.sub(r"^([A-Z]+)(\d+)$", r"\1-\2", i.upper())
+        checksum_args.add_argument(
+            "--%s" % i,
+            action="append_const",
+            dest="checksums",
+            const=i,
+            help=_("Generate %s manifest when creating a bag") % alg_name,
+        )
+
+    metadata_args = parser.add_argument_group(_("Optional Bag Metadata"))
+    for header in STANDARD_BAG_INFO_HEADERS:
+        metadata_args.add_argument(
+            "--%s" % header.lower(), type=str, action=BagHeaderAction, default=argparse.SUPPRESS
+        )
+
+    parser.add_argument(
+        "directory",
+        nargs="+",
+        help=_(
+            "Directory which will be converted into a bag in place"
+            " by moving any existing files into the BagIt structure"
+            " and creating the manifests and other metadata."
+        ),
+    )
+
+    return parser
+
+
+def _configure_logging(opts):
+    log_format = "%(asctime)s - %(levelname)s - %(message)s"
+    if opts.quiet:
+        level = logging.ERROR
+    else:
+        level = logging.INFO
+    if opts.log:
+        logging.basicConfig(filename=opts.log, level=level, format=log_format)
+    else:
+        logging.basicConfig(level=level, format=log_format)
+
+
+def main():
+    if "--version" in sys.argv:
+        print(_("bagit-python version %s") % VERSION)
+        sys.exit(0)
+
+    parser = _make_parser()
+    args = parser.parse_args()
+
+    if args.processes < 0:
+        parser.error(_("The number of processes must be 0 or greater"))
+
+    if args.fast and not args.validate:
+        parser.error(_("--fast is only allowed as an option for --validate!"))
+
+    _configure_logging(args)
+
+    rc = 0
+    for bag_dir in args.directory:
+        # validate the bag
+        if args.validate:
+            try:
+                bag = Bag(bag_dir)
+                # validate throws a BagError or BagValidationError
+                bag.validate(
+                    processes=args.processes,
+                    fast=args.fast,
+                    completeness_only=args.completeness_only,
+                )
+                if args.fast:
+                    LOGGER.info(_("%s valid according to Payload-Oxum"), bag_dir)
+                else:
+                    LOGGER.info(_("%s is valid"), bag_dir)
+            except BagError as e:
+                LOGGER.error(
+                    _("%(bag)s is invalid: %(error)s"), {"bag": bag_dir, "error": e}
+                )
+                rc = 1
+
+        # make the bag
+        else:
+            try:
+                make_bag(
+                    bag_dir,
+                    bag_info=args.bag_info,
+                    processes=args.processes,
+                    checksums=args.checksums,
+                )
+            except Exception as exc:
+                LOGGER.error(
+                    _("Failed to create bag in %(bag_directory)s: %(error)s"),
+                    {"bag_directory": bag_dir, "error": exc},
+                    exc_info=True,
+                )
+                rc = 1
+
+    sys.exit(rc)
+
+
+if __name__ == "__main__":
+    main()
diff -r 000000000000 -r 4f3585e2f14b env/bin/bioblend-galaxy-tests
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/bioblend-galaxy-tests	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from bioblend._tests.pytest_galaxy_test_wrapper import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/bundle_image
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/bundle_image	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,27 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+from boto.manage.server import Server
+if __name__ == "__main__":
+    from optparse import OptionParser
+    parser = OptionParser(version="%prog 1.0", usage="Usage: %prog [options] instance-id [instance-id-2]")
+
+    # Commands
+    parser.add_option("-b", "--bucket", help="Destination Bucket", dest="bucket", default=None)
+    parser.add_option("-p", "--prefix", help="AMI Prefix", dest="prefix", default=None)
+    parser.add_option("-k", "--key", help="Private Key File", dest="key_file", default=None)
+    parser.add_option("-c", "--cert", help="Public Certificate File", dest="cert_file", default=None)
+    parser.add_option("-s", "--size", help="AMI Size", dest="size", default=None)
+    parser.add_option("-i", "--ssh-key", help="SSH Keyfile", dest="ssh_key", default=None)
+    parser.add_option("-u", "--user-name", help="SSH Username", dest="uname", default="root")
+    parser.add_option("-n", "--name", help="Name of Image", dest="name")
+    (options, args) = parser.parse_args()
+
+    for instance_id in args:
+        try:
+            s = Server.find(instance_id=instance_id).next()
+            print "Found old server object"
+        except StopIteration:
+            print "New Server Object Created"
+            s = Server.create_from_instance_id(instance_id, options.name)
+        assert(s.hostname is not None)
+        b = s.get_bundler(uname=options.uname)
+        b.bundle(bucket=options.bucket,prefix=options.prefix,key_file=options.key_file,cert_file=options.cert_file,size=int(options.size),ssh_key=options.ssh_key)
diff -r 000000000000 -r 4f3585e2f14b env/bin/cfadmin
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/cfadmin	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,108 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Author: Chris Moyer
+#
+# cfadmin is similar to sdbadmin for CloudFront, it's a simple
+# console utility to perform the most frequent tasks with CloudFront
+#
+def _print_distributions(dists):
+    """Internal function to print out all the distributions provided"""
+    print "%-12s %-50s %s" % ("Status", "Domain Name", "Origin")
+    print "-"*80
+    for d in dists:
+        print "%-12s %-50s %-30s" % (d.status, d.domain_name, d.origin)
+        for cname in d.cnames:
+            print " "*12, "CNAME => %s" % cname
+    print ""
+
+def help(cf, fnc=None):
+    """Print help message, optionally about a specific function"""
+    import inspect
+    self = sys.modules['__main__']
+    if fnc:
+        try:
+            cmd = getattr(self, fnc)
+        except:
+            cmd = None
+        if not inspect.isfunction(cmd):
+            print "No function named: %s found" % fnc
+            sys.exit(2)
+        (args, varargs, varkw, defaults) = inspect.getargspec(cmd)
+        print cmd.__doc__
+        print "Usage: %s %s" % (fnc, " ".join([ "[%s]" % a for a in args[1:]]))
+    else:
+        print "Usage: cfadmin [command]"
+        for cname in dir(self):
+            if not cname.startswith("_"):
+                cmd = getattr(self, cname)
+                if inspect.isfunction(cmd):
+                    doc = cmd.__doc__
+                    print "\t%s - %s" % (cname, doc)
+    sys.exit(1)
+
+def ls(cf):
+    """List all distributions and streaming distributions"""
+    print "Standard Distributions"
+    _print_distributions(cf.get_all_distributions())
+    print "Streaming Distributions"
+    _print_distributions(cf.get_all_streaming_distributions())
+
+def invalidate(cf, origin_or_id, *paths):
+    """Create a cloudfront invalidation request"""
+    # Allow paths to be passed using stdin
+    if not paths:
+        paths = []
+        for path in sys.stdin.readlines():
+            path = path.strip()
+            if path:
+                paths.append(path)
+    dist = None
+    for d in cf.get_all_distributions():
+        if d.id == origin_or_id or d.origin.dns_name == origin_or_id:
+            dist = d
+            break
+    if not dist:
+        print "Distribution not found: %s" % origin_or_id
+        sys.exit(1)
+    cf.create_invalidation_request(dist.id, paths)
+
+def listinvalidations(cf, origin_or_id):
+    """List invalidation requests for a given origin"""
+    dist = None
+    for d in cf.get_all_distributions():
+        if d.id == origin_or_id or d.origin.dns_name == origin_or_id:
+            dist = d
+            break
+    if not dist:
+        print "Distribution not found: %s" % origin_or_id
+        sys.exit(1)
+    results = cf.get_invalidation_requests(dist.id)
+    if results:
+        for result in results:
+            if result.status == "InProgress":
+                result = result.get_invalidation_request()
+                print result.id, result.status, result.paths
+            else:
+                print result.id, result.status
+
+
+if __name__ == "__main__":
+    import boto
+    import sys
+    cf = boto.connect_cloudfront()
+    self = sys.modules['__main__']
+    if len(sys.argv) >= 2:
+        try:
+            cmd = getattr(self, sys.argv[1])
+        except:
+            cmd = None
+        args = sys.argv[2:]
+    else:
+        cmd = help
+        args = []
+    if not cmd:
+        cmd = help
+    try:
+        cmd(cf, *args)
+    except TypeError as e:
+        print e
+        help(cf, cmd.__name__)
diff -r 000000000000 -r 4f3585e2f14b env/bin/chardetect
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/chardetect	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from chardet.cli.chardetect import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/coloredlogs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/coloredlogs	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from coloredlogs.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/cq
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/cq	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,92 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+import getopt, sys
+import boto.sqs
+from boto.sqs.connection import SQSConnection
+from boto.exception import SQSError
+
+def usage():
+    print 'cq [-c] [-q queue_name] [-o output_file] [-t timeout] [-r region]'
+  
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'hcq:o:t:r:',
+                                   ['help', 'clear', 'queue=',
+                                    'output=', 'timeout=', 'region='])
+    except:
+        usage()
+        sys.exit(2)
+    queue_name = ''
+    output_file = ''
+    timeout = 30
+    region = ''
+    clear = False
+    for o, a in opts:
+        if o in ('-h', '--help'):
+            usage()
+            sys.exit()
+        if o in ('-q', '--queue'):
+            queue_name = a
+        if o in ('-o', '--output'):
+            output_file = a
+        if o in ('-c', '--clear'):
+            clear = True
+        if o in ('-t', '--timeout'):
+            timeout = int(a)
+        if o in ('-r', '--region'):
+            region = a
+    if region:
+        c = boto.sqs.connect_to_region(region)
+    if c is None:
+        print 'Invalid region (%s)' % region
+        sys.exit(1)
+    else:
+        c = SQSConnection()
+    if queue_name:
+        try:
+            rs = [c.create_queue(queue_name)]
+        except SQSError as e:
+            print 'An Error Occurred:'
+            print '%s: %s' % (e.status, e.reason)
+            print e.body
+            sys.exit()
+    else:
+        try:
+            rs = c.get_all_queues()
+        except SQSError as e:
+            print 'An Error Occurred:'
+            print '%s: %s' % (e.status, e.reason)
+            print e.body
+            sys.exit()
+    for q in rs:
+        if clear:
+            n = q.clear()
+            print 'clearing %d messages from %s' % (n, q.id)
+        elif output_file:
+            q.dump(output_file)
+        else:
+            print q.id, q.count(vtimeout=timeout)
+
+if __name__ == "__main__":
+    main()
+        
diff -r 000000000000 -r 4f3585e2f14b env/bin/csv2rdf
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/csv2rdf	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rdflib.tools.csv2rdf import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/cwltool
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/cwltool	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from cwltool.main import run
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(run())
diff -r 000000000000 -r 4f3585e2f14b env/bin/cwutil
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/cwutil	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,140 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Author: Chris Moyer <cmoyer@newstex.com>
+# Description: CloudWatch Utility
+# For listing stats, creating alarms, and managing 
+# other CloudWatch aspects
+
+import boto
+cw = boto.connect_cloudwatch()
+
+from datetime import datetime, timedelta
+
+def _parse_time(time_string):
+    """Internal function to parse a time string"""
+
+def _parse_dict(d_string):
+    result = {}
+    if d_string:
+        for d in d_string.split(","):
+            d = d.split(":")
+            result[d[0]] = d[1]
+    return result
+
+def ls(namespace=None):
+    """
+    List metrics, optionally filtering by a specific namespace
+        namespace: Optional Namespace to filter on
+    """
+    print "%-10s %-50s %s" % ("Namespace", "Metric Name", "Dimensions")
+    print "-"*80
+    for m in cw.list_metrics():
+        if namespace is None or namespace.upper() in m.namespace:
+            print "%-10s %-50s %s" % (m.namespace, m.name, m.dimensions)
+
+def stats(namespace, metric_name, dimensions=None, statistics="Average", start_time=None, end_time=None, period=60, unit=None):
+    """
+    Lists the statistics for a specific metric
+        namespace: The namespace to use, usually "AWS/EC2", "AWS/SQS", etc.
+        metric_name: The name of the metric to track, pulled from `ls`
+        dimensions: The dimensions to use, formatted as Name:Value (such as QueueName:myQueue)
+        statistics: The statistics to measure, defaults to "Average"
+             'Minimum', 'Maximum', 'Sum', 'Average', 'SampleCount'
+        start_time: Start time, default to now - 1 day
+        end_time: End time, default to now
+        period: Period/interval for counts, default to 60 minutes
+        unit: Unit to track, default depends on what metric is being tracked
+    """
+
+    # Parse the dimensions
+    dimensions = _parse_dict(dimensions)
+
+    # Parse the times
+    if end_time:
+        end_time = _parse_time(end_time)
+    else:
+        end_time = datetime.utcnow()
+    if start_time:
+        start_time = _parse_time(start_time)
+    else:
+        start_time = datetime.utcnow() - timedelta(days=1)
+            
+    print "%-30s %s" % ('Timestamp', statistics)
+    print "-"*50
+    data = {}
+    for m in cw.get_metric_statistics(int(period), start_time, end_time, metric_name, namespace, statistics, dimensions, unit):
+        data[m['Timestamp']] = m[statistics]
+    keys = data.keys()
+    keys.sort()
+    for k in keys:
+        print "%-30s %s" % (k, data[k])
+
+def put(namespace, metric_name, dimensions=None, value=None, unit=None, statistics=None, timestamp=None):
+    """
+    Publish custom metrics
+        namespace: The namespace to use; values starting with "AWS/" are reserved
+        metric_name: The name of the metric to update
+        dimensions: The dimensions to use, formatted as Name:Value (such as QueueName:myQueue)
+        value: The value to store, mutually exclusive with `statistics`
+        statistics: The statistics to store, mutually exclusive with `value`
+            (must specify all of "Minimum", "Maximum", "Sum", "SampleCount")
+        timestamp: The timestamp of this measurement, default is current server time
+        unit: Unit to track, default depends on what metric is being tracked
+    """
+    
+    def simplify(lst):
+        return lst[0] if len(lst) == 1 else lst
+
+    print cw.put_metric_data(namespace, simplify(metric_name.split(';')),
+        dimensions = simplify(map(_parse_dict, dimensions.split(';'))) if dimensions else None,
+        value = simplify(value.split(';')) if value else None,
+        statistics = simplify(map(_parse_dict, statistics.split(';'))) if statistics else None,
+        timestamp = simplify(timestamp.split(';')) if timestamp else None,
+        unit = simplify(unit.split(';')) if unit else None)
+
+def help(fnc=None):
+    """
+    Print help message, optionally about a specific function
+    """
+    import inspect
+    self = sys.modules['__main__']
+    if fnc:
+        try:
+            cmd = getattr(self, fnc)
+        except:
+            cmd = None
+        if not inspect.isfunction(cmd):
+            print "No function named: %s found" % fnc
+            sys.exit(2)
+        (args, varargs, varkw, defaults) = inspect.getargspec(cmd)
+        print cmd.__doc__
+        print "Usage: %s %s" % (fnc, " ".join([ "[%s]" % a for a in args]))
+    else:
+        print "Usage: cwutil [command]"
+        for cname in dir(self):
+            if not cname.startswith("_") and not cname == "cmd":
+                cmd = getattr(self, cname)
+                if inspect.isfunction(cmd):
+                    doc = cmd.__doc__
+                    print "\t%s - %s" % (cname, doc)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    import sys
+    self = sys.modules['__main__']
+    if len(sys.argv) >= 2:
+        try:
+            cmd = getattr(self, sys.argv[1])
+        except:
+            cmd = None
+        args = sys.argv[2:]
+    else:
+        cmd = help
+        args = []
+    if not cmd:
+        cmd = help
+    try:
+        cmd(*args)
+    except TypeError as e:
+        print e
+        help(cmd.__name__)
diff -r 000000000000 -r 4f3585e2f14b env/bin/doesitcache
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/doesitcache	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,33 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# EASY-INSTALL-ENTRY-SCRIPT: 'CacheControl==0.11.7','console_scripts','doesitcache'
+import re
+import sys
+
+# for compatibility with easy_install; see #2198
+__requires__ = 'CacheControl==0.11.7'
+
+try:
+    from importlib.metadata import distribution
+except ImportError:
+    try:
+        from importlib_metadata import distribution
+    except ImportError:
+        from pkg_resources import load_entry_point
+
+
+def importlib_load_entry_point(spec, group, name):
+    dist_name, _, _ = spec.partition('==')
+    matches = (
+        entry_point
+        for entry_point in distribution(dist_name).entry_points
+        if entry_point.group == group and entry_point.name == name
+    )
+    return next(matches).load()
+
+
+globals().setdefault('load_entry_point', importlib_load_entry_point)
+
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(load_entry_point('CacheControl==0.11.7', 'console_scripts', 'doesitcache')())
diff -r 000000000000 -r 4f3585e2f14b env/bin/dynamodb_dump
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/dynamodb_dump	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,76 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+import argparse
+import errno
+import os
+
+import boto
+from boto.compat import json
+from boto.compat import six
+
+
+DESCRIPTION = """Dump the contents of one or more DynamoDB tables to the local filesystem.
+
+Each table is dumped into two files:
+  - {table_name}.metadata stores the table's name, schema and provisioned
+    throughput.
+  - {table_name}.data stores the table's actual contents.
+
+Both files are created in the current directory. To write them somewhere else,
+use the --out-dir parameter (the target directory will be created if needed).
+"""
+
+
+def dump_table(table, out_dir):
+    metadata_file = os.path.join(out_dir, "%s.metadata" % table.name)
+    data_file = os.path.join(out_dir, "%s.data" % table.name)
+
+    with open(metadata_file, "w") as metadata_fd:
+        json.dump(
+            {
+                "name": table.name,
+                "schema": table.schema.dict,
+                "read_units": table.read_units,
+                "write_units": table.write_units,
+            },
+            metadata_fd
+        )
+
+    with open(data_file, "w") as data_fd:
+        for item in table.scan():
+            # JSON can't serialize sets -- convert those to lists.
+            data = {}
+            for k, v in six.iteritems(item):
+                if isinstance(v, (set, frozenset)):
+                    data[k] = list(v)
+                else:
+                    data[k] = v
+
+            data_fd.write(json.dumps(data))
+            data_fd.write("\n")
+
+
+def dynamodb_dump(tables, out_dir):
+    try:
+        os.makedirs(out_dir)
+    except OSError as e:
+        # We don't care if the dir already exists.
+        if e.errno != errno.EEXIST:
+            raise
+
+    conn = boto.connect_dynamodb()
+    for t in tables:
+        dump_table(conn.get_table(t), out_dir)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog="dynamodb_dump",
+        description=DESCRIPTION
+    )
+    parser.add_argument("--out-dir", default=".")
+    parser.add_argument("tables", metavar="TABLES", nargs="+")
+
+    namespace = parser.parse_args()
+
+    dynamodb_dump(namespace.tables, namespace.out_dir)
diff -r 000000000000 -r 4f3585e2f14b env/bin/dynamodb_load
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/dynamodb_load	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,110 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+import argparse
+import os
+
+import boto
+from boto.compat import json
+from boto.compat import six
+from boto.dynamodb.schema import Schema
+
+
+DESCRIPTION = """Load data into one or more DynamoDB tables.
+
+For each table, data is read from two files:
+  - {table_name}.metadata for the table's name, schema and provisioned
+    throughput (only required if creating the table).
+  - {table_name}.data for the table's actual contents.
+
+Both files are searched for in the current directory. To read them from
+somewhere else, use the --in-dir parameter.
+
+This program does not wipe the tables prior to loading data. However, any
+items present in the data files will overwrite the table's contents.
+"""
+
+
+def _json_iterload(fd):
+    """Lazily load newline-separated JSON objects from a file-like object."""
+    buffer = ""
+    eof = False
+    while not eof:
+        try:
+            # Add a line to the buffer
+            buffer += fd.next()
+        except StopIteration:
+            # We can't let that exception bubble up, otherwise the last
+            # object in the file will never be decoded.
+            eof = True
+        try:
+            # Try to decode a JSON object.
+            json_object = json.loads(buffer.strip())
+
+            # Success: clear the buffer (everything was decoded).
+            buffer = ""
+        except ValueError:
+            if eof and buffer.strip():
+                # No more lines to load and the buffer contains something other
+                # than whitespace: the file is, in fact, malformed.
+                raise
+            # We couldn't decode a complete JSON object: load more lines.
+            continue
+
+        yield json_object
+
+
+def create_table(metadata_fd):
+    """Create a table from a metadata file-like object."""
+
+
+def load_table(table, in_fd):
+    """Load items into a table from a file-like object."""
+    for i in _json_iterload(in_fd):
+        # Convert lists back to sets.
+        data = {}
+        for k, v in six.iteritems(i):
+            if isinstance(v, list):
+                data[k] = set(v)
+            else:
+                data[k] = v
+        table.new_item(attrs=data).put()
+
+
+def dynamodb_load(tables, in_dir, create_tables):
+    conn = boto.connect_dynamodb()
+    for t in tables:
+        metadata_file = os.path.join(in_dir, "%s.metadata" % t)
+        data_file = os.path.join(in_dir, "%s.data" % t)
+        if create_tables:
+            with open(metadata_file) as meta_fd:
+                metadata = json.load(meta_fd)
+            table = conn.create_table(
+                name=t,
+                schema=Schema(metadata["schema"]),
+                read_units=metadata["read_units"],
+                write_units=metadata["write_units"],
+            )
+            table.refresh(wait_for_active=True)
+        else:
+            table = conn.get_table(t)
+
+        with open(data_file) as in_fd:
+            load_table(table, in_fd)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog="dynamodb_load",
+        description=DESCRIPTION
+    )
+    parser.add_argument(
+        "--create-tables",
+        action="store_true",
+        help="Create the tables if they don't exist already (without this flag, attempts to load data into non-existing tables fail)."
+    )
+    parser.add_argument("--in-dir", default=".")
+    parser.add_argument("tables", metavar="TABLES", nargs="+")
+
+    namespace = parser.parse_args()
+
+    dynamodb_load(namespace.tables, namespace.in_dir, namespace.create_tables)
diff -r 000000000000 -r 4f3585e2f14b env/bin/elbadmin
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/elbadmin	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,302 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2009 Chris Moyer http://coredumped.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+#
+# Elastic Load Balancer Tool
+#
+VERSION = "0.2"
+usage = """%prog [options] [command]
+Commands:
+    list|ls                       List all Elastic Load Balancers
+    delete    <name>              Delete ELB <name>
+    get       <name>              Get all instances associated with <name>
+    create    <name>              Create an ELB; -z and -l are required
+    add       <name> <instances>  Add <instances> in ELB <name>
+    remove|rm <name> <instances>  Remove <instances> from ELB <name>
+    reap      <name>              Remove terminated instances from ELB <name>
+    enable|en <name> <zone>       Enable Zone <zone> for ELB <name>
+    disable   <name> <zone>       Disable Zone <zone> for ELB <name>
+    addl      <name>              Add listeners (specified by -l) to the ELB
+                                      <name>
+    rml       <name> <port>       Remove Listener(s) specified by the port on
+                                      the ELB <name>
+"""
+
+
+def find_elb(elb, name):
+    try:
+        elbs = elb.get_all_load_balancers(name)
+    except boto.exception.BotoServerError as se:
+        if se.code == 'LoadBalancerNotFound':
+            elbs = []
+        else:
+            raise
+
+    if len(elbs) < 1:
+        print "No load balancer by the name of %s found" % name
+        return None
+    elif len(elbs) > 1:
+        print "More than one elb matches %s?" % name
+        return None
+
+    # Should not happen
+    if name not in elbs[0].name:
+        print "No load balancer by the name of %s found" % name
+        return None
+
+    return elbs[0]
+
+
+def list(elb):
+    """List all ELBs"""
+    print "%-20s %s" % ("Name", "DNS Name")
+    print "-" * 80
+    for b in elb.get_all_load_balancers():
+        print "%-20s %s" % (b.name, b.dns_name)
+
+def check_valid_region(conn, region):
+    if conn is None:
+        print 'Invalid region (%s)' % region
+        sys.exit(1)
+
+def get(elb, name):
+    """Get details about ELB <name>"""
+
+    b = find_elb(elb, name)
+    if b:
+        print "=" * 80
+        print "Name: %s" % b.name
+        print "DNS Name: %s" % b.dns_name
+        if b.canonical_hosted_zone_name:
+            chzn = b.canonical_hosted_zone_name
+            print "Canonical hosted zone name: %s" % chzn
+        if b.canonical_hosted_zone_name_id:
+            chznid = b.canonical_hosted_zone_name_id
+            print "Canonical hosted zone name id: %s" % chznid
+        print
+
+        print "Health Check: %s" % b.health_check
+        print
+
+        print "Listeners"
+        print "---------"
+        print "%-8s %-8s %s" % ("IN", "OUT", "PROTO")
+        for l in b.listeners:
+            print "%-8s %-8s %s" % (l[0], l[1], l[2])
+
+        print
+
+        print "  Zones  "
+        print "---------"
+        for z in b.availability_zones:
+            print z
+
+        print
+
+        # Make map of all instance Id's to Name tags
+        import boto
+        from boto.compat.six import iteritems
+        if not options.region:
+            ec2 = boto.connect_ec2()
+        else:
+            ec2 = boto.ec2.connect_to_region(options.region)
+            check_valid_region(ec2, options.region)
+
+        instance_health = b.get_instance_health()
+        instances = [state.instance_id for state in instance_health]
+
+        names = dict((k,'') for k in instances)
+        for i in ec2.get_only_instances():
+            if i.id in instances:
+                names[i.id] = i.tags.get('Name', '')
+
+        name_column_width = max([4] + [len(v) for k,v in iteritems(names)]) + 2
+
+        print "Instances"
+        print "---------"
+        print "%-12s %-15s %-*s %s" % ("ID",
+                                       "STATE",
+                                       name_column_width, "NAME",
+                                       "DESCRIPTION")
+        for state in instance_health:
+            print "%-12s %-15s %-*s %s" % (state.instance_id,
+                                           state.state,
+                                           name_column_width, names[state.instance_id],
+                                           state.description)
+
+        print
+
+
+def create(elb, name, zones, listeners):
+    """Create an ELB named <name>"""
+    l_list = []
+    for l in listeners:
+        l = l.split(",")
+        if l[2] == 'HTTPS':
+            l_list.append((int(l[0]), int(l[1]), l[2], l[3]))
+        else:
+            l_list.append((int(l[0]), int(l[1]), l[2]))
+
+    b = elb.create_load_balancer(name, zones, l_list)
+    return get(elb, name)
+
+
+def delete(elb, name):
+    """Delete this ELB"""
+    b = find_elb(elb, name)
+    if b:
+        b.delete()
+        print "Load Balancer %s deleted" % name
+
+
+def add_instances(elb, name, instances):
+    """Add <instance> to ELB <name>"""
+    b = find_elb(elb, name)
+    if b:
+        b.register_instances(instances)
+        return get(elb, name)
+
+
+def remove_instances(elb, name, instances):
+    """Remove instance from elb <name>"""
+    b = find_elb(elb, name)
+    if b:
+        b.deregister_instances(instances)
+        return get(elb, name)
+
+
+def reap_instances(elb, name):
+    """Remove terminated instances from elb <name>"""
+    b = find_elb(elb, name)
+    if b:
+        for state in b.get_instance_health():
+            if (state.state == 'OutOfService' and
+                state.description == 'Instance is in terminated state.'):
+                b.deregister_instances([state.instance_id])
+        return get(elb, name)
+
+
+def enable_zone(elb, name, zone):
+    """Enable <zone> for elb"""
+    b = find_elb(elb, name)
+    if b:
+        b.enable_zones([zone])
+        return get(elb, name)
+
+
+def disable_zone(elb, name, zone):
+    """Disable <zone> for elb"""
+    b = find_elb(elb, name)
+    if b:
+        b.disable_zones([zone])
+        return get(elb, name)
+
+
+def add_listener(elb, name, listeners):
+    """Add listeners to a given load balancer"""
+    l_list = []
+    for l in listeners:
+        l = l.split(",")
+        l_list.append((int(l[0]), int(l[1]), l[2]))
+    b = find_elb(elb, name)
+    if b:
+        b.create_listeners(l_list)
+        return get(elb, name)
+
+
+def rm_listener(elb, name, ports):
+    """Remove listeners from a given load balancer"""
+    b = find_elb(elb, name)
+    if b:
+        b.delete_listeners(ports)
+        return get(elb, name)
+
+
+if __name__ == "__main__":
+    try:
+        import readline
+    except ImportError:
+        pass
+    import boto
+    import sys
+    from optparse import OptionParser
+    from boto.mashups.iobject import IObject
+    parser = OptionParser(version=VERSION, usage=usage)
+    parser.add_option("-z", "--zone",
+                      help="Operate on zone",
+                      action="append", default=[], dest="zones")
+    parser.add_option("-l", "--listener",
+                      help="Specify Listener in,out,proto",
+                      action="append", default=[], dest="listeners")
+    parser.add_option("-r", "--region",
+                      help="Region to connect to",
+                      action="store", dest="region")
+
+    (options, args) = parser.parse_args()
+
+    if len(args) < 1:
+        parser.print_help()
+        sys.exit(1)
+
+    if not options.region:
+        elb = boto.connect_elb()
+    else:
+        import boto.ec2.elb
+        elb = boto.ec2.elb.connect_to_region(options.region)
+        check_valid_region(elb, options.region)
+
+    print "%s" % (elb.region.endpoint)
+
+    command = args[0].lower()
+    if command in ("ls", "list"):
+        list(elb)
+    elif command == "get":
+        get(elb, args[1])
+    elif command == "create":
+        if not options.listeners:
+            print "-l option required for command create"
+            sys.exit(1)
+        if not options.zones:
+            print "-z option required for command create"
+            sys.exit(1)
+        create(elb, args[1], options.zones, options.listeners)
+    elif command == "delete":
+        delete(elb, args[1])
+    elif command in ("add", "put"):
+        add_instances(elb, args[1], args[2:])
+    elif command in ("rm", "remove"):
+        remove_instances(elb, args[1], args[2:])
+    elif command == "reap":
+        reap_instances(elb, args[1])
+    elif command in ("en", "enable"):
+        enable_zone(elb, args[1], args[2])
+    elif command == "disable":
+        disable_zone(elb, args[1], args[2])
+    elif command == "addl":
+        if not options.listeners:
+            print "-l option required for command addl"
+            sys.exit(1)
+        add_listener(elb, args[1], options.listeners)
+    elif command == "rml":
+        if not args[2:]:
+            print "port required"
+            sys.exit(2)
+        rm_listener(elb, args[1], args[2:])
diff -r 000000000000 -r 4f3585e2f14b env/bin/fetch_file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/fetch_file	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,46 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2009 Chris Moyer http://coredumped.org
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+import sys
+
+
+if __name__ == "__main__":
+    from optparse import OptionParser
+    usage = """%prog [options] URI
+Fetch a URI using the boto library and (by default) pipe contents to STDOUT
+The URI can be either an HTTP URL, or "s3://bucket_name/key_name"
+"""
+    parser = OptionParser(version="0.1", usage=usage)
+    parser.add_option("-o", "--out-file",
+                      help="File to receive output instead of STDOUT",
+                      dest="outfile")
+
+    (options, args) = parser.parse_args()
+    if len(args) < 1:
+        parser.print_help()
+        sys.exit(1)
+    from boto.utils import fetch_file
+    f = fetch_file(args[0])
+    if options.outfile:
+        open(options.outfile, "w").write(f.read())
+    else:
+        print(f.read())
diff -r 000000000000 -r 4f3585e2f14b env/bin/galaxy-tool-test
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/galaxy-tool-test	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.verify.script import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/galaxy-wait
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/galaxy-wait	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.sleep import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/get-tool-list
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/get-tool-list	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.get_tool_list_from_galaxy import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/glacier
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/glacier	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,161 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2012 Miguel Olivares http://moliware.com/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+"""
+  glacier
+  ~~~~~~~
+
+    Amazon Glacier tool built on top of boto. Look at the usage method to see
+    how to use it.
+
+    Author: Miguel Olivares <miguel@moliware.com>
+"""
+import sys
+
+from boto.glacier import connect_to_region
+from getopt import getopt, GetoptError
+from os.path import isfile, basename
+
+
+COMMANDS = ('vaults', 'jobs', 'upload')
+
+
+def usage():
+    print("""
+glacier <command> [args]
+
+    Commands
+        vaults    - Operations with vaults
+        jobs      - Operations with jobs
+        upload    - Upload files to a vault. If the vault doesn't exits, it is
+                    created
+
+    Common args:
+        --access_key - Your AWS Access Key ID.  If not supplied, boto will
+                       use the value of the environment variable
+                       AWS_ACCESS_KEY_ID
+        --secret_key - Your AWS Secret Access Key.  If not supplied, boto
+                       will use the value of the environment variable
+                       AWS_SECRET_ACCESS_KEY
+        --region     - AWS region to use. Possible values: us-east-1, us-west-1,
+                       us-west-2, ap-northeast-1, eu-west-1.
+                       Default: us-east-1
+
+    Vaults operations:
+
+        List vaults:
+            glacier vaults 
+
+    Jobs operations:
+
+        List jobs:
+            glacier jobs <vault name>
+
+    Uploading files:
+
+        glacier upload <vault name> <files>
+
+        Examples : 
+            glacier upload pics *.jpg
+            glacier upload pics a.jpg b.jpg
+""")
+    sys.exit()
+
+
+def connect(region, debug_level=0, access_key=None, secret_key=None):
+    """ Connect to a specific region """
+    layer2 = connect_to_region(region,
+                               aws_access_key_id=access_key,
+                               aws_secret_access_key=secret_key,
+                               debug=debug_level)
+    if layer2 is None:
+        print('Invalid region (%s)' % region)
+        sys.exit(1)
+    return layer2
+
+
+def list_vaults(region, access_key=None, secret_key=None):
+    layer2 = connect(region, access_key = access_key, secret_key = secret_key)
+    for vault in layer2.list_vaults():
+        print(vault.arn)
+
+
+def list_jobs(vault_name, region, access_key=None, secret_key=None):
+    layer2 = connect(region, access_key = access_key, secret_key = secret_key)
+    print(layer2.layer1.list_jobs(vault_name))
+
+
+def upload_files(vault_name, filenames, region, access_key=None, secret_key=None):
+    layer2 = connect(region, access_key = access_key, secret_key = secret_key)
+    layer2.create_vault(vault_name)
+    glacier_vault = layer2.get_vault(vault_name)
+    for filename in filenames:
+        if isfile(filename):
+            sys.stdout.write('Uploading %s to %s...' % (filename, vault_name))
+            sys.stdout.flush()
+            archive_id = glacier_vault.upload_archive(
+                filename,
+                description = basename(filename))
+            print(' done. Vault returned ArchiveID %s' % archive_id)
+
+def main():
+    if len(sys.argv) < 2:
+        usage()
+    
+    command = sys.argv[1]
+    if command not in COMMANDS:
+        usage()
+
+    argv = sys.argv[2:]
+    options = 'a:s:r:'
+    long_options = ['access_key=', 'secret_key=', 'region=']
+    try:
+        opts, args = getopt(argv, options, long_options)
+    except GetoptError as e:
+        usage()
+
+    # Parse agument
+    access_key = secret_key = None
+    region = 'us-east-1'
+    for option, value in opts:
+        if option in ('-a', '--access_key'):
+            access_key = value
+        elif option in ('-s', '--secret_key'):
+            secret_key = value
+        elif option in ('-r', '--region'):
+            region = value
+    # handle each command
+    if command == 'vaults':
+        list_vaults(region, access_key, secret_key)
+    elif command == 'jobs':
+        if len(args) != 1:
+            usage()
+        list_jobs(args[0], region, access_key, secret_key)
+    elif command == 'upload':
+        if len(args) < 2:
+            usage()
+        upload_files(args[0], args[1:], region, access_key, secret_key)
+
+
+if __name__ == '__main__':
+    main()
diff -r 000000000000 -r 4f3585e2f14b env/bin/gxwf-abstract-export
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/gxwf-abstract-export	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gxformat2.abstract import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/gxwf-lint
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/gxwf-lint	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gxformat2.lint import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/gxwf-to-format2
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/gxwf-to-format2	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gxformat2.export import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/gxwf-to-native
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/gxwf-to-native	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gxformat2.converter import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/gxwf-viz
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/gxwf-viz	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gxformat2.cytoscape import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/humanfriendly
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/humanfriendly	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from humanfriendly.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/install_tool_deps
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/install_tool_deps	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.install_tool_deps import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/instance_events
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/instance_events	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,145 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2011 Jim Browne http://www.42lines.net
+# Borrows heavily from boto/bin/list_instances which has no attribution
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+VERSION="0.1"
+usage = """%prog [options]
+Options:
+  -h, --help            show help message (including options list) and exit
+"""
+
+from operator import itemgetter
+
+HEADERS = {
+    'ID': {'get': itemgetter('id'), 'length':14},
+    'Zone': {'get': itemgetter('zone'), 'length':14},
+    'Hostname': {'get': itemgetter('dns'), 'length':20},
+    'Code': {'get': itemgetter('code'), 'length':18},
+    'Description': {'get': itemgetter('description'), 'length':30},
+    'NotBefore': {'get': itemgetter('not_before'), 'length':25},
+    'NotAfter': {'get': itemgetter('not_after'), 'length':25},
+    'T:': {'length': 30},
+}
+
+def get_column(name, event=None):
+    if name.startswith('T:'):
+        return event[name]
+    return HEADERS[name]['get'](event)
+
+def list(region, headers, order, completed):
+    """List status events for all instances in a given region"""
+
+    import re
+
+    ec2 = boto.connect_ec2(region=region)
+
+    reservations = ec2.get_all_reservations()
+
+    instanceinfo = {}
+    events = {}
+    
+    displaytags = [ x for x in headers if x.startswith('T:') ]
+
+    # Collect the tag for every possible instance
+    for res in reservations:
+        for instance in res.instances:
+            iid = instance.id
+            instanceinfo[iid] = {}
+            for tagname in displaytags:
+                _, tag = tagname.split(':', 1)
+                instanceinfo[iid][tagname] = instance.tags.get(tag,'')
+            instanceinfo[iid]['dns'] = instance.public_dns_name
+        
+    stats = ec2.get_all_instance_status()
+
+    for stat in stats:
+        if stat.events:
+            for event in stat.events:
+                events[stat.id] = {}
+                events[stat.id]['id'] = stat.id
+                events[stat.id]['dns'] = instanceinfo[stat.id]['dns']
+                events[stat.id]['zone'] = stat.zone
+                for tag in displaytags:
+                    events[stat.id][tag] = instanceinfo[stat.id][tag]
+                events[stat.id]['code'] = event.code
+                events[stat.id]['description'] = event.description
+                events[stat.id]['not_before'] = event.not_before
+                events[stat.id]['not_after'] = event.not_after
+                if completed and re.match('^\[Completed\]',event.description):
+                    events[stat.id]['not_before'] = 'Completed'
+                    events[stat.id]['not_after'] = 'Completed'
+
+    # Create format string
+    format_string = ""
+    for h in headers:
+        if h.startswith('T:'):
+            format_string += "%%-%ds" % HEADERS['T:']['length']
+        else:
+            format_string += "%%-%ds" % HEADERS[h]['length']
+
+
+    print format_string % headers
+    print "-" * len(format_string % headers)
+                    
+    for instance in sorted(events,
+                           key=lambda ev: get_column(order, events[ev])):
+        e = events[instance]
+        print format_string % tuple(get_column(h, e) for h in headers)
+
+if __name__ == "__main__":
+    import boto
+    from optparse import OptionParser
+    from boto.ec2 import regions
+
+    parser = OptionParser(version=VERSION, usage=usage)
+    parser.add_option("-a", "--all", help="check all regions", dest="all", default=False,action="store_true")
+    parser.add_option("-r", "--region", help="region to check (default us-east-1)", dest="region", default="us-east-1")
+    parser.add_option("-H", "--headers", help="Set headers (use 'T:tagname' for including tags)", default=None, action="store", dest="headers", metavar="ID,Zone,Hostname,Code,Description,NotBefore,NotAfter,T:Name")
+    parser.add_option("-S", "--sort", help="Header for sort order", default=None, action="store", dest="order",metavar="HeaderName")
+    parser.add_option("-c", "--completed", help="List time fields as \"Completed\" for completed events (Default: false)", default=False, action="store_true", dest="completed")
+
+    (options, args) = parser.parse_args()
+
+    if options.headers:
+        headers = tuple(options.headers.split(','))
+    else:
+        headers = ('ID', 'Zone', 'Hostname', 'Code', 'NotBefore', 'NotAfter')
+
+    if options.order:
+        order = options.order
+    else:
+        order = 'ID'
+
+    if options.all:
+        for r in regions():
+            print "Region %s" % r.name
+            list(r, headers, order, options.completed)
+    else:
+        # Connect the region
+        for r in regions():
+            if r.name == options.region:
+                region = r
+                break
+        else:
+            print "Region %s not found." % options.region
+            sys.exit(1)
+
+        list(r, headers, order, options.completed)
diff -r 000000000000 -r 4f3585e2f14b env/bin/kill_instance
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/kill_instance	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,35 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+import sys
+from optparse import OptionParser
+
+import boto
+from boto.ec2 import regions
+
+
+
+def kill_instance(region, ids):
+    """Kill an instances given it's instance IDs"""
+    # Connect the region
+    ec2 = boto.connect_ec2(region=region)
+    for instance_id in ids:
+        print("Stopping instance: %s" % instance_id)
+        ec2.terminate_instances([instance_id])
+
+
+if __name__ == "__main__":
+    parser = OptionParser(usage="kill_instance [-r] id [id ...]")
+    parser.add_option("-r", "--region", help="Region (default us-east-1)", dest="region", default="us-east-1")
+    (options, args) = parser.parse_args()
+    if not args:
+        parser.print_help()
+        sys.exit(1)
+    for r in regions():
+        if r.name == options.region:
+            region = r
+            break
+    else:
+        print("Region %s not found." % options.region)
+        sys.exit(1)
+
+    kill_instance(region, args)
diff -r 000000000000 -r 4f3585e2f14b env/bin/launch_instance
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/launch_instance	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,252 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2009 Chris Moyer http://coredumped.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+#
+# Utility to launch an EC2 Instance
+#
+VERSION="0.2"
+
+
+CLOUD_INIT_SCRIPT = """#!/usr/bin/env python
+f = open("/etc/boto.cfg", "w")
+f.write(\"\"\"%s\"\"\")
+f.close()
+"""
+import boto.pyami.config
+import boto.utils
+import re, os
+from boto.compat import ConfigParser
+
+class Config(boto.pyami.config.Config):
+    """A special config class that also adds import abilities
+    Directly in the config file. To have a config file import
+    another config file, simply use "#import <path>" where <path>
+    is either a relative path or a full URL to another config
+    """
+
+    def __init__(self):
+        ConfigParser.__init__(self, {'working_dir' : '/mnt/pyami', 'debug' : '0'})
+
+    def add_config(self, file_url):
+        """Add a config file to this configuration
+        :param file_url: URL for the file to add, or a local path
+        :type file_url: str
+        """
+        if not re.match("^([a-zA-Z0-9]*:\/\/)(.*)", file_url):
+            if not file_url.startswith("/"):
+                file_url = os.path.join(os.getcwd(), file_url)
+            file_url = "file://%s" % file_url
+        (base_url, file_name) = file_url.rsplit("/", 1)
+        base_config = boto.utils.fetch_file(file_url)
+        base_config.seek(0)
+        for line in base_config.readlines():
+            match = re.match("^#import[\s\t]*([^\s^\t]*)[\s\t]*$", line)
+            if match:
+                self.add_config("%s/%s" % (base_url, match.group(1)))
+        base_config.seek(0)
+        self.readfp(base_config)
+
+    def add_creds(self, ec2):
+        """Add the credentials to this config if they don't already exist"""
+        if not self.has_section('Credentials'):
+            self.add_section('Credentials')
+            self.set('Credentials', 'aws_access_key_id', ec2.aws_access_key_id)
+            self.set('Credentials', 'aws_secret_access_key', ec2.aws_secret_access_key)
+
+
+    def __str__(self):
+        """Get config as string"""
+        from StringIO import StringIO
+        s = StringIO()
+        self.write(s)
+        return s.getvalue()
+
+SCRIPTS = []
+
+def scripts_callback(option, opt, value, parser):
+    arg = value.split(',')
+    if len(arg) == 1:
+        SCRIPTS.append(arg[0])
+    else:
+        SCRIPTS.extend(arg)
+    setattr(parser.values, option.dest, SCRIPTS)
+
+def add_script(scr_url):
+    """Read a script and any scripts that are added using #import"""
+    base_url = '/'.join(scr_url.split('/')[:-1]) + '/'
+    script_raw = boto.utils.fetch_file(scr_url)
+    script_content = ''
+    for line in script_raw.readlines():
+        match = re.match("^#import[\s\t]*([^\s^\t]*)[\s\t]*$", line)
+        #if there is an import
+        if match:
+            #Read the other script and put it in that spot
+            script_content += add_script("%s/%s" % (base_url, match.group(1)))
+        else:
+            #Otherwise, add the line and move on
+            script_content += line
+    return script_content
+
+if __name__ == "__main__":
+    try:
+        import readline
+    except ImportError:
+        pass
+    import sys
+    import time
+    import boto
+    from boto.ec2 import regions
+    from optparse import OptionParser
+    from boto.mashups.iobject import IObject
+    parser = OptionParser(version=VERSION, usage="%prog [options] config_url")
+    parser.add_option("-c", "--max-count", help="Maximum number of this type of instance to launch", dest="max_count", default="1")
+    parser.add_option("--min-count", help="Minimum number of this type of instance to launch", dest="min_count", default="1")
+    parser.add_option("--cloud-init", help="Indicates that this is an instance that uses 'CloudInit', Ubuntu's cloud bootstrap process. This wraps the config in a shell script command instead of just passing it in directly", dest="cloud_init", default=False, action="store_true")
+    parser.add_option("-g", "--groups", help="Security Groups to add this instance to",  action="append", dest="groups")
+    parser.add_option("-a", "--ami", help="AMI to launch", dest="ami_id")
+    parser.add_option("-t", "--type", help="Type of Instance (default m1.small)", dest="type", default="m1.small")
+    parser.add_option("-k", "--key", help="Keypair", dest="key_name")
+    parser.add_option("-z", "--zone", help="Zone (default us-east-1a)", dest="zone", default="us-east-1a")
+    parser.add_option("-r", "--region", help="Region (default us-east-1)", dest="region", default="us-east-1")
+    parser.add_option("-i", "--ip", help="Elastic IP", dest="elastic_ip")
+    parser.add_option("-n", "--no-add-cred", help="Don't add a credentials section", default=False, action="store_true", dest="nocred")
+    parser.add_option("--save-ebs", help="Save the EBS volume on shutdown, instead of deleting it", default=False, action="store_true", dest="save_ebs")
+    parser.add_option("-w", "--wait", help="Wait until instance is running", default=False, action="store_true", dest="wait")
+    parser.add_option("-d", "--dns", help="Returns public and private DNS (implicates --wait)", default=False, action="store_true", dest="dns")
+    parser.add_option("-T", "--tag", help="Set tag", default=None, action="append", dest="tags", metavar="key:value")
+    parser.add_option("-s", "--scripts", help="Pass in a script or a folder containing scripts to be run when the instance starts up, assumes cloud-init. Specify scripts in a list specified by commas. If multiple scripts are specified, they are run lexically (A good way to ensure they run in the order is to prefix filenames with numbers)", type='string', action="callback", callback=scripts_callback)
+    parser.add_option("--role", help="IAM Role to use, this implies --no-add-cred", dest="role")
+
+    (options, args) = parser.parse_args()
+
+    if len(args) < 1:
+        parser.print_help()
+        sys.exit(1)
+    file_url = os.path.expanduser(args[0])
+
+    cfg = Config()
+    cfg.add_config(file_url)
+
+    for r in regions():
+        if r.name == options.region:
+            region = r
+            break
+    else:
+        print("Region %s not found." % options.region)
+        sys.exit(1)
+    ec2 = boto.connect_ec2(region=region)
+    if not options.nocred and not options.role:
+        cfg.add_creds(ec2)
+
+    iobj = IObject()
+    if options.ami_id:
+        ami = ec2.get_image(options.ami_id)
+    else:
+        ami_id = options.ami_id
+        l = [(a, a.id, a.location) for a in ec2.get_all_images()]
+        ami = iobj.choose_from_list(l, prompt='Choose AMI')
+
+    if options.key_name:
+        key_name = options.key_name
+    else:
+        l = [(k, k.name, '') for k in ec2.get_all_key_pairs()]
+        key_name = iobj.choose_from_list(l, prompt='Choose Keypair').name
+
+    if options.groups:
+        groups = options.groups
+    else:
+        groups = []
+        l = [(g, g.name, g.description) for g in ec2.get_all_security_groups()]
+        g = iobj.choose_from_list(l, prompt='Choose Primary Security Group')
+        while g != None:
+            groups.append(g)
+            l.remove((g, g.name, g.description))
+            g = iobj.choose_from_list(l, prompt='Choose Additional Security Group (0 to quit)')
+
+    user_data = str(cfg)
+    # If it's a cloud init AMI,
+    # then we need to wrap the config in our
+    # little wrapper shell script
+
+    if options.cloud_init:
+        user_data = CLOUD_INIT_SCRIPT % user_data
+        scriptuples = []
+        if options.scripts:
+            scripts = options.scripts
+            scriptuples.append(('user_data', user_data))
+            for scr in scripts:
+                scr_url = scr
+                if not re.match("^([a-zA-Z0-9]*:\/\/)(.*)", scr_url):
+                    if not scr_url.startswith("/"):
+                        scr_url = os.path.join(os.getcwd(), scr_url)
+                    try:
+                        newfiles = os.listdir(scr_url)
+                        for f in newfiles:
+                            #put the scripts in the folder in the array such that they run in the correct order
+                            scripts.insert(scripts.index(scr) + 1, scr.split("/")[-1] + "/" + f)
+                    except OSError:
+                        scr_url = "file://%s" % scr_url
+                try:
+                    scriptuples.append((scr, add_script(scr_url)))
+                except Exception as e:
+                    pass
+
+            user_data = boto.utils.write_mime_multipart(scriptuples, compress=True)
+
+    shutdown_proc = "terminate"
+    if options.save_ebs:
+        shutdown_proc = "save"
+
+    instance_profile_name = None
+    if options.role:
+        instance_profile_name = options.role
+
+    r = ami.run(min_count=int(options.min_count), max_count=int(options.max_count),
+            key_name=key_name, user_data=user_data,
+            security_groups=groups, instance_type=options.type,
+            placement=options.zone, instance_initiated_shutdown_behavior=shutdown_proc,
+            instance_profile_name=instance_profile_name)
+
+    instance = r.instances[0]
+
+    if options.tags:
+        for tag_pair in options.tags:
+            name = tag_pair
+            value = ''
+            if ':' in tag_pair:
+                name, value = tag_pair.split(':', 1)
+            instance.add_tag(name, value)
+
+    if options.dns:
+        options.wait = True
+
+    if not options.wait:
+        sys.exit(0)
+
+    while True:
+        instance.update()
+        if instance.state == 'running':
+            break
+        time.sleep(3)
+
+    if options.dns:
+        print("Public DNS name: %s" % instance.public_dns_name)
+        print("Private DNS name: %s" % instance.private_dns_name)
diff -r 000000000000 -r 4f3585e2f14b env/bin/list_instances
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/list_instances	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,90 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+import sys
+from operator import attrgetter
+from optparse import OptionParser
+
+import boto
+from boto.ec2 import regions
+
+
+HEADERS = {
+    'ID': {'get': attrgetter('id'), 'length':15},
+    'Zone': {'get': attrgetter('placement'), 'length':15},
+    'Groups': {'get': attrgetter('groups'), 'length':30},
+    'Hostname': {'get': attrgetter('public_dns_name'), 'length':50},
+    'PrivateHostname': {'get': attrgetter('private_dns_name'), 'length':50},
+    'State': {'get': attrgetter('state'), 'length':15},
+    'Image': {'get': attrgetter('image_id'), 'length':15},
+    'Type': {'get': attrgetter('instance_type'), 'length':15},
+    'IP': {'get': attrgetter('ip_address'), 'length':16},
+    'PrivateIP': {'get': attrgetter('private_ip_address'), 'length':16},
+    'Key': {'get': attrgetter('key_name'), 'length':25},
+    'T:': {'length': 30},
+}
+
+def get_column(name, instance=None):
+    if name.startswith('T:'):
+        _, tag = name.split(':', 1)
+        return instance.tags.get(tag, '')
+    return HEADERS[name]['get'](instance)
+
+
+def main():
+    parser = OptionParser()
+    parser.add_option("-r", "--region", help="Region (default us-east-1)", dest="region", default="us-east-1")
+    parser.add_option("-H", "--headers", help="Set headers (use 'T:tagname' for including tags)", default=None, action="store", dest="headers", metavar="ID,Zone,Groups,Hostname,State,T:Name")
+    parser.add_option("-t", "--tab", help="Tab delimited, skip header - useful in shell scripts", action="store_true", default=False)
+    parser.add_option("-f", "--filter", help="Filter option sent to DescribeInstances API call, format is key1=value1,key2=value2,...", default=None)
+    (options, args) = parser.parse_args()
+
+
+    # Connect the region
+    for r in regions():
+        if r.name == options.region:
+            region = r
+            break
+    else:
+        print("Region %s not found." % options.region)
+        sys.exit(1)
+    ec2 = boto.connect_ec2(region=region)
+
+    # Read headers
+    if options.headers:
+        headers = tuple(options.headers.split(','))
+    else:
+        headers = ("ID", 'Zone', "Groups", "Hostname")
+
+    # Create format string
+    format_string = ""
+    for h in headers:
+        if h.startswith('T:'):
+            format_string += "%%-%ds" % HEADERS['T:']['length']
+        else:
+            format_string += "%%-%ds" % HEADERS[h]['length']
+
+
+    # Parse filters (if any)
+    if options.filter:
+        filters = dict([entry.split('=') for entry in options.filter.split(',')])
+    else:
+        filters = {}
+
+    # List and print
+
+    if not options.tab:
+        print(format_string % headers)
+        print("-" * len(format_string % headers))
+
+    for r in ec2.get_all_reservations(filters=filters):
+        groups = [g.name for g in r.groups]
+        for i in r.instances:
+            i.groups = ','.join(groups)
+            if options.tab: 
+                print("\t".join(tuple(get_column(h, i) for h in headers)))
+            else:
+                print(format_string % tuple(get_column(h, i) for h in headers))
+ 
+
+if __name__ == "__main__":
+    main()
diff -r 000000000000 -r 4f3585e2f14b env/bin/lss3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/lss3	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,113 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+import boto
+from boto.exception import S3ResponseError
+from boto.s3.connection import OrdinaryCallingFormat
+
+
+def sizeof_fmt(num):
+    for x in ['b ', 'KB', 'MB', 'GB', 'TB', 'XB']:
+        if num < 1024.0:
+            return "%3.1f %s" % (num, x)
+        num /= 1024.0
+    return "%3.1f %s" % (num, x)
+
+
+def list_bucket(b, prefix=None, marker=None):
+    """List everything in a bucket"""
+    from boto.s3.prefix import Prefix
+    from boto.s3.key import Key
+    total = 0
+
+    if prefix:
+        if not prefix.endswith("/"):
+            prefix = prefix + "/"
+        query = b.list(prefix=prefix, delimiter="/", marker=marker)
+        print("%s" % prefix)
+    else:
+        query = b.list(delimiter="/", marker=marker)
+
+    num = 0
+    for k in query:
+        num += 1
+        mode = "-rwx---"
+        if isinstance(k, Prefix):
+            mode = "drwxr--"
+            size = 0
+        else:
+            size = k.size
+            for g in k.get_acl().acl.grants:
+                if g.id == None:
+                    if g.permission == "READ":
+                        mode = "-rwxr--"
+                    elif g.permission == "FULL_CONTROL":
+                        mode = "-rwxrwx"
+        if isinstance(k, Key):
+            print("%s\t%s\t%010s\t%s" % (mode, k.last_modified,
+                                         sizeof_fmt(size), k.name))
+        else:
+           #If it's not a Key object, it doesn't have a last_modified time, so
+           #print nothing instead
+            print("%s\t%s\t%010s\t%s" % (mode, ' ' * 24,
+                                         sizeof_fmt(size), k.name))
+        total += size
+    print ("=" * 80)
+    print ("\t\tTOTAL:  \t%010s \t%i Files" % (sizeof_fmt(total), num))
+
+
+def list_buckets(s3, display_tags=False):
+    """List all the buckets"""
+    for b in s3.get_all_buckets():
+        print(b.name)
+        if display_tags:
+            try:
+                tags = b.get_tags()
+                for tag in tags[0]:
+                    print("   %s:%s" % (tag.key, tag.value))
+            except S3ResponseError as e:
+                if e.status != 404:
+                    raise
+
+
+def main():
+    import optparse
+    import sys
+
+    usage = "usage: %prog [options] [BUCKET1] [BUCKET2]"
+    description = "List all S3 buckets OR list keys in the named buckets"
+    parser = optparse.OptionParser(description=description, usage=usage)
+    parser.add_option('-m', '--marker',
+                      help='The S3 key where the listing starts after it.')
+    parser.add_option('-t', '--tags', action='store_true',
+                      help='Display tags when listing all buckets.')
+    options, buckets = parser.parse_args()
+    marker = options.marker
+
+    if not buckets:
+        list_buckets(boto.connect_s3(), options.tags)
+        sys.exit(0)
+
+    if options.tags:
+        print("-t option only works for the overall bucket list")
+        sys.exit(1)
+
+    pairs = []
+    mixedCase = False
+    for name in buckets:
+        if "/" in name:
+            pairs.append(name.split("/", 1))
+        else:
+            pairs.append([name, None])
+        if pairs[-1][0].lower() != pairs[-1][0]:
+            mixedCase = True
+
+    if mixedCase:
+        s3 = boto.connect_s3(calling_format=OrdinaryCallingFormat())
+    else:
+        s3 = boto.connect_s3()
+
+    for name, prefix in pairs:
+        list_bucket(s3.get_bucket(name), prefix, marker=marker)
+
+
+if __name__ == "__main__":
+    main()
diff -r 000000000000 -r 4f3585e2f14b env/bin/mturk
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mturk	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,514 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright 2012, 2014 Kodi Arfer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+import argparse # Hence, Python 2.7 is required.
+import sys
+import os.path
+import string
+import inspect
+import datetime, calendar
+import boto.mturk.connection, boto.mturk.price, boto.mturk.question, boto.mturk.qualification
+from boto.compat import json
+
+# --------------------------------------------------
+# Globals
+# -------------------------------------------------
+
+interactive = False
+con = None
+mturk_website = None
+
+default_nicknames_path = os.path.expanduser('~/.boto_mturkcli_hit_nicknames')
+nicknames = {}
+nickname_pool = set(string.ascii_lowercase)
+
+get_assignments_page_size = 100
+
+time_units = dict(
+    s = 1,
+    min = 60,
+    h = 60 * 60,
+    d = 24 * 60 * 60)
+
+qual_requirements = dict(
+    Adult = '00000000000000000060',
+    Locale = '00000000000000000071',
+    NumberHITsApproved = '00000000000000000040',
+    PercentAssignmentsSubmitted = '00000000000000000000',
+    PercentAssignmentsAbandoned = '00000000000000000070',
+    PercentAssignmentsReturned = '000000000000000000E0',
+    PercentAssignmentsApproved = '000000000000000000L0',
+    PercentAssignmentsRejected = '000000000000000000S0')
+
+qual_comparators = {v : k for k, v in dict(
+    LessThan = '<', LessThanOrEqualTo = '<=',
+    GreaterThan = '>', GreaterThanOrEqualTo = '>=',
+    EqualTo = '==', NotEqualTo = '!=',
+    Exists = 'exists').items()}
+
+example_config_file = '''Example configuration file:
+
+  {
+    "title": "Pick your favorite color",
+    "description": "In this task, you are asked to pick your favorite color.",
+    "reward": 0.50,
+    "assignments": 10,
+    "duration": "20 min",
+    "keywords": ["color", "favorites", "survey"],
+    "lifetime": "7 d",
+    "approval_delay": "14 d",
+    "qualifications": [
+        "PercentAssignmentsApproved > 90",
+        "Locale == US",
+        "2ARFPLSP75KLA8M8DH1HTEQVJT3SY6 exists"
+    ],
+    "question_url": "http://example.com/myhit",
+    "question_frame_height": 450
+  }'''
+
+# --------------------------------------------------
+# Subroutines
+# --------------------------------------------------
+
+def unjson(path):
+    with open(path) as o:
+        return json.load(o)
+
+def add_argparse_arguments(parser):
+    parser.add_argument('-P', '--production',
+        dest = 'sandbox', action = 'store_false', default = True,
+        help = 'use the production site (default: use the sandbox)')
+    parser.add_argument('--nicknames',
+        dest = 'nicknames_path', metavar = 'PATH',
+        default = default_nicknames_path,
+        help = 'where to store HIT nicknames (default: {})'.format(
+            default_nicknames_path))
+
+def init_by_args(args):
+    init(args.sandbox, args.nicknames_path)
+
+def init(sandbox = False, nicknames_path = default_nicknames_path):
+    global con, mturk_website, nicknames, original_nicknames
+
+    mturk_website = 'workersandbox.mturk.com' if sandbox else 'www.mturk.com'
+    con = boto.mturk.connection.MTurkConnection(
+        host = 'mechanicalturk.sandbox.amazonaws.com' if sandbox else 'mechanicalturk.amazonaws.com')
+
+    try:
+        nicknames = unjson(nicknames_path)
+    except IOError:
+        nicknames = {}
+    original_nicknames = nicknames.copy()
+
+def save_nicknames(nicknames_path = default_nicknames_path):
+    if nicknames != original_nicknames:
+        with open(nicknames_path, 'w') as o:
+            json.dump(nicknames, o, sort_keys = True, indent = 4)
+            print >>o
+
+def parse_duration(s):
+    '''Parses durations like "2 d", "48 h", "2880 min",
+"172800 s", or "172800".'''
+    x = s.split()
+    return int(x[0]) * time_units['s' if len(x) == 1 else x[1]]
+def display_duration(n):
+    for unit, m in sorted(time_units.items(), key = lambda x: -x[1]):
+        if n % m == 0:
+            return '{} {}'.format(n / m, unit)
+
+def parse_qualification(inp):
+    '''Parses qualifications like "PercentAssignmentsApproved > 90",
+"Locale == US", and "2ARFPLSP75KLA8M8DH1HTEQVJT3SY6 exists".'''
+    inp = inp.split()
+    name, comparator, value = inp.pop(0), inp.pop(0), (inp[0] if len(inp) else None)
+    qtid = qual_requirements.get(name)
+    if qtid is None:
+      # Treat "name" as a Qualification Type ID.
+        qtid = name
+    if qtid == qual_requirements['Locale']:
+        return boto.mturk.qualification.LocaleRequirement(
+            qual_comparators[comparator],
+            value,
+            required_to_preview = False)
+    return boto.mturk.qualification.Requirement(
+        qtid,
+        qual_comparators[comparator],
+        value,
+        required_to_preview = qtid == qual_requirements['Adult'])
+          # Thus required_to_preview is true only for the
+          # Worker_Adult requirement.
+
+def preview_url(hit):
+    return 'https://{}/mturk/preview?groupId={}'.format(
+        mturk_website, hit.HITTypeId)
+
+def parse_timestamp(s):
+    '''Takes a timestamp like "2012-11-24T16:34:41Z".
+
+Returns a datetime object in the local time zone.'''
+    return datetime.datetime.fromtimestamp(
+        calendar.timegm(
+        datetime.datetime.strptime(s, '%Y-%m-%dT%H:%M:%SZ').timetuple()))
+
+def get_hitid(nickname_or_hitid):
+    return nicknames.get(nickname_or_hitid) or nickname_or_hitid
+
+def get_nickname(hitid):
+    for k, v in nicknames.items():
+        if v == hitid:
+            return k
+    return None
+
+def display_datetime(dt):
+    return dt.strftime('%e %b %Y, %l:%M %P')
+
+def display_hit(hit, verbose = False):
+    et = parse_timestamp(hit.Expiration)
+    return '\n'.join([
+        '{} - {} ({}, {}, {})'.format(
+            get_nickname(hit.HITId),
+            hit.Title,
+            hit.FormattedPrice,
+            display_duration(int(hit.AssignmentDurationInSeconds)),
+            hit.HITStatus),
+        'HIT ID: ' + hit.HITId,
+        'Type ID: ' + hit.HITTypeId,
+        'Group ID: ' + hit.HITGroupId,
+        'Preview: ' + preview_url(hit),
+        'Created {}   {}'.format(
+            display_datetime(parse_timestamp(hit.CreationTime)),
+            'Expired' if et <= datetime.datetime.now() else
+                'Expires ' + display_datetime(et)),
+        'Assignments: {} -- {} avail, {} pending, {} reviewable, {} reviewed'.format(
+            hit.MaxAssignments,
+            hit.NumberOfAssignmentsAvailable,
+            hit.NumberOfAssignmentsPending,
+            int(hit.MaxAssignments) - (int(hit.NumberOfAssignmentsAvailable) + int(hit.NumberOfAssignmentsPending) + int(hit.NumberOfAssignmentsCompleted)),
+            hit.NumberOfAssignmentsCompleted)
+            if hasattr(hit, 'NumberOfAssignmentsAvailable')
+            else 'Assignments: {} total'.format(hit.MaxAssignments),
+            # For some reason, SearchHITs includes the
+            # NumberOfAssignmentsFoobar fields but GetHIT doesn't.
+        ] + ([] if not verbose else [
+            '\nDescription: ' + hit.Description,
+            '\nKeywords: ' + hit.Keywords
+        ])) + '\n'
+
+def digest_assignment(a):
+    return dict(
+        answers = {str(x.qid): str(x.fields[0]) for x in a.answers[0]},
+        **{k: str(getattr(a, k)) for k in (
+            'AcceptTime', 'SubmitTime',
+            'HITId', 'AssignmentId', 'WorkerId',
+            'AssignmentStatus')})
+
+# --------------------------------------------------
+# Commands
+# --------------------------------------------------
+
+def get_balance():
+    return con.get_account_balance()
+
+def show_hit(hit):
+    return display_hit(con.get_hit(hit)[0], verbose = True)
+
+def list_hits():
+    'Lists your 10 most recently created HITs, with the most recent last.'
+    return '\n'.join(reversed(map(display_hit, con.search_hits(
+        sort_by = 'CreationTime',
+        sort_direction = 'Descending',
+        page_size = 10))))
+
+def make_hit(title, description, keywords, reward, question_url, question_frame_height, duration, assignments, approval_delay, lifetime, qualifications = []):
+    r = con.create_hit(
+        title = title,
+        description = description,
+        keywords = con.get_keywords_as_string(keywords),
+        reward = con.get_price_as_price(reward),
+        question = boto.mturk.question.ExternalQuestion(
+            question_url,
+            question_frame_height),
+        duration = parse_duration(duration),
+        qualifications = boto.mturk.qualification.Qualifications(
+            map(parse_qualification, qualifications)),
+        max_assignments = assignments,
+        approval_delay = parse_duration(approval_delay),
+        lifetime = parse_duration(lifetime))
+    nick = None
+    available_nicks = nickname_pool - set(nicknames.keys())
+    if available_nicks:
+        nick = min(available_nicks)
+        nicknames[nick] = r[0].HITId
+    if interactive:
+        print 'Nickname:', nick
+        print 'HIT ID:', r[0].HITId
+        print 'Preview:', preview_url(r[0])
+    else:
+        return r[0]
+
+def extend_hit(hit, assignments_increment = None, expiration_increment = None):
+    con.extend_hit(hit, assignments_increment, expiration_increment)
+
+def expire_hit(hit):
+    con.expire_hit(hit)
+
+def delete_hit(hit):
+    '''Deletes a HIT using DisableHIT.
+
+Unreviewed assignments get automatically approved. Unsubmitted
+assignments get automatically approved upon submission.
+
+The API docs say DisableHIT doesn't work with Reviewable HITs,
+but apparently, it does.'''
+    con.disable_hit(hit)
+    global nicknames
+    nicknames = {k: v for k, v in nicknames.items() if v != hit}
+
+def list_assignments(hit, only_reviewable = False):
+    # Accumulate all relevant assignments, one page of results at
+    # a time.
+    assignments = []
+    page = 1
+    while True:
+        rs = con.get_assignments(
+            hit_id = hit,
+            page_size = get_assignments_page_size,
+            page_number = page,
+            status = 'Submitted' if only_reviewable else None)
+        assignments += map(digest_assignment, rs)
+        if len(assignments) >= int(rs.TotalNumResults):
+            break
+        page += 1
+    if interactive:
+        print json.dumps(assignments, sort_keys = True, indent = 4)
+        print ' '.join([a['AssignmentId'] for a in assignments])
+        print ' '.join([a['WorkerId'] + ',' + a['AssignmentId'] for a in assignments])
+    else:
+        return assignments
+
+def grant_bonus(message, amount, pairs):
+    for worker, assignment in pairs:
+        con.grant_bonus(worker, assignment, con.get_price_as_price(amount), message)
+        if interactive: print 'Bonused', worker
+
+def approve_assignments(message, assignments):
+    for a in assignments:
+        con.approve_assignment(a, message)
+        if interactive: print 'Approved', a
+
+def reject_assignments(message, assignments):
+    for a in assignments:
+        con.reject_assignment(a, message)
+        if interactive: print 'Rejected', a
+
+def unreject_assignments(message, assignments):
+    for a in assignments:
+        con.approve_rejected_assignment(a, message)
+        if interactive: print 'Unrejected', a
+
+def notify_workers(subject, text, workers):
+    con.notify_workers(workers, subject, text)
+
+def give_qualification(qualification, workers, value = 1, notify = True):
+    for w in workers:
+        con.assign_qualification(qualification, w, value, notify)
+        if interactive: print 'Gave to', w
+
+def revoke_qualification(qualification, workers, message = None):
+    for w in workers:
+        con.revoke_qualification(w, qualification, message)
+        if interactive: print 'Revoked from', w
+
+# --------------------------------------------------
+# Mainline code
+# --------------------------------------------------
+
+if __name__ == '__main__':
+    interactive = True
+
+    parser = argparse.ArgumentParser()
+    add_argparse_arguments(parser)
+    subs = parser.add_subparsers()
+
+    sub = subs.add_parser('bal',
+        help = 'display your prepaid balance')
+    sub.set_defaults(f = get_balance, a = lambda: [])
+
+    sub = subs.add_parser('hit',
+        help = 'get information about a HIT')
+    sub.add_argument('HIT',
+        help = 'nickname or ID of the HIT to show')
+    sub.set_defaults(f = show_hit, a = lambda:
+        [get_hitid(args.HIT)])
+
+    sub = subs.add_parser('hits',
+        help = 'list all your HITs')
+    sub.set_defaults(f = list_hits, a = lambda: [])
+
+    sub = subs.add_parser('new',
+        help = 'create a new HIT (external questions only)',
+        epilog = example_config_file,
+        formatter_class = argparse.RawDescriptionHelpFormatter)
+    sub.add_argument('JSON_PATH',
+        help = 'path to JSON configuration file for the HIT')
+    sub.add_argument('-u', '--question-url', dest = 'question_url',
+        metavar = 'URL',
+        help = 'URL for the external question')
+    sub.add_argument('-a', '--assignments', dest = 'assignments',
+        type = int, metavar = 'N',
+        help = 'number of assignments')
+    sub.add_argument('-r', '--reward', dest = 'reward',
+        type = float, metavar = 'PRICE',
+        help = 'reward amount, in USD')
+    sub.set_defaults(f = make_hit, a = lambda: dict(
+        unjson(args.JSON_PATH).items() + [(k, getattr(args, k))
+            for k in ('question_url', 'assignments', 'reward')
+            if getattr(args, k) is not None]))
+
+    sub = subs.add_parser('extend',
+        help = 'add assignments or time to a HIT')
+    sub.add_argument('HIT',
+        help = 'nickname or ID of the HIT to extend')
+    sub.add_argument('-a', '--assignments', dest = 'assignments',
+        metavar = 'N', type = int,
+        help = 'number of assignments to add')
+    sub.add_argument('-t', '--time', dest = 'time',
+        metavar = 'T',
+        help = 'amount of time to add to the expiration date')
+    sub.set_defaults(f = extend_hit, a = lambda:
+        [get_hitid(args.HIT), args.assignments,
+            args.time and parse_duration(args.time)])
+
+    sub = subs.add_parser('expire',
+        help = 'force a HIT to expire without deleting it')
+    sub.add_argument('HIT',
+        help = 'nickname or ID of the HIT to expire')
+    sub.set_defaults(f = expire_hit, a = lambda:
+        [get_hitid(args.HIT)])
+
+    sub = subs.add_parser('rm',
+        help = 'delete a HIT')
+    sub.add_argument('HIT',
+        help = 'nickname or ID of the HIT to delete')
+    sub.set_defaults(f = delete_hit, a = lambda:
+        [get_hitid(args.HIT)])
+
+    sub = subs.add_parser('as',
+        help = "list a HIT's submitted assignments")
+    sub.add_argument('HIT',
+        help = 'nickname or ID of the HIT to get assignments for')
+    sub.add_argument('-r', '--reviewable', dest = 'only_reviewable',
+        action = 'store_true',
+        help = 'show only unreviewed assignments')
+    sub.set_defaults(f = list_assignments, a = lambda:
+        [get_hitid(args.HIT), args.only_reviewable])
+
+    for command, fun, helpmsg in [
+            ('approve', approve_assignments, 'approve assignments'),
+            ('reject', reject_assignments, 'reject assignments'),
+            ('unreject', unreject_assignments, 'approve previously rejected assignments')]:
+        sub = subs.add_parser(command, help = helpmsg)
+        sub.add_argument('ASSIGNMENT', nargs = '+',
+            help = 'ID of an assignment')
+        sub.add_argument('-m', '--message', dest = 'message',
+            metavar = 'TEXT',
+            help = 'feedback message shown to workers')
+        sub.set_defaults(f = fun, a = lambda:
+            [args.message, args.ASSIGNMENT])
+
+    sub = subs.add_parser('bonus',
+        help = 'give some workers a bonus')
+    sub.add_argument('AMOUNT', type = float,
+        help = 'bonus amount, in USD')
+    sub.add_argument('MESSAGE',
+        help = 'the reason for the bonus (shown to workers in an email sent by MTurk)')
+    sub.add_argument('WIDAID', nargs = '+',
+        help = 'a WORKER_ID,ASSIGNMENT_ID pair')
+    sub.set_defaults(f = grant_bonus, a = lambda:
+        [args.MESSAGE, args.AMOUNT,
+            [p.split(',') for p in args.WIDAID]])
+
+    sub = subs.add_parser('notify',
+        help = 'send a message to some workers')
+    sub.add_argument('SUBJECT',
+        help = 'subject of the message')
+    sub.add_argument('MESSAGE',
+        help = 'text of the message')
+    sub.add_argument('WORKER', nargs = '+',
+        help = 'ID of a worker')
+    sub.set_defaults(f = notify_workers, a = lambda:
+        [args.SUBJECT, args.MESSAGE, args.WORKER])
+
+    sub = subs.add_parser('give-qual',
+        help = 'give a qualification to some workers')
+    sub.add_argument('QUAL',
+        help = 'ID of the qualification')
+    sub.add_argument('WORKER', nargs = '+',
+        help = 'ID of a worker')
+    sub.add_argument('-v', '--value', dest = 'value',
+        metavar = 'N', type = int, default = 1,
+        help = 'value of the qualification')
+    sub.add_argument('--dontnotify', dest = 'notify',
+        action = 'store_false', default = True,
+        help = "don't notify workers")
+    sub.set_defaults(f = give_qualification, a = lambda:
+        [args.QUAL, args.WORKER, args.value, args.notify])
+
+    sub = subs.add_parser('revoke-qual',
+        help = 'revoke a qualification from some workers')
+    sub.add_argument('QUAL',
+        help = 'ID of the qualification')
+    sub.add_argument('WORKER', nargs = '+',
+        help = 'ID of a worker')
+    sub.add_argument('-m', '--message', dest = 'message',
+        metavar = 'TEXT',
+        help = 'the reason the qualification was revoked (shown to workers in an email sent by MTurk)')
+    sub.set_defaults(f = revoke_qualification, a = lambda:
+        [args.QUAL, args.WORKER, args.message])
+
+    args = parser.parse_args()
+
+    init_by_args(args)
+
+    f = args.f
+    a = args.a()
+    if isinstance(a, dict):
+        # We do some introspective gymnastics so we can produce a
+        # less incomprehensible error message if some arguments
+        # are missing.
+        spec = inspect.getargspec(f)
+        missing = set(spec.args[: len(spec.args) - len(spec.defaults)]) - set(a.keys())
+        if missing:
+            raise ValueError('Missing arguments: ' + ', '.join(missing))
+        doit = lambda: f(**a)
+    else:
+        doit = lambda: f(*a)
+
+    try:
+        x = doit()
+    except boto.mturk.connection.MTurkRequestError as e:
+        print 'MTurk error:', e.error_message
+        sys.exit(1)
+
+    if x is not None:
+        print x
+
+    save_nicknames()
diff -r 000000000000 -r 4f3585e2f14b env/bin/mulled-build
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mulled-build	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.deps.mulled.mulled_build import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/mulled-build-channel
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mulled-build-channel	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.deps.mulled.mulled_build_channel import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/mulled-build-files
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mulled-build-files	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.deps.mulled.mulled_build_files import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/mulled-build-tool
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mulled-build-tool	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.deps.mulled.mulled_build_tool import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/mulled-list
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mulled-list	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.deps.mulled.mulled_list import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/mulled-search
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mulled-search	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.deps.mulled.mulled_search import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/mulled-update-singularity-containers
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/mulled-update-singularity-containers	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from galaxy.tool_util.deps.mulled.mulled_update_singularity_containers import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/pip
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/pip	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/pip3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/pip3	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/pip3.9
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/pip3.9	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/planemo
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/planemo	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from planemo.cli import planemo
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(planemo())
diff -r 000000000000 -r 4f3585e2f14b env/bin/prov-compare
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/prov-compare	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,127 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# encoding: utf-8
+"""
+prov-compare -- Compare two PROV-JSON, PROV-XML, or RDF (PROV-O) files for equivalence
+
+@author:     Trung Dong Huynh
+
+@copyright:  2016 University of Southampton, United Kingdom. All rights reserved.
+
+@license:    MIT Licence
+
+@contact:    trungdong@donggiang.com
+@deffield    updated: 2016-10-19
+"""
+
+from argparse import ArgumentParser, RawDescriptionHelpFormatter, FileType
+import os
+import sys
+import logging
+import traceback
+import six
+
+from prov.model import ProvDocument
+
+
+logger = logging.getLogger(__name__)
+
+__all__ = []
+__version__ = 0.1
+__date__ = '2015-06-16'
+__updated__ = '2016-10-19'
+
+DEBUG = 0
+TESTRUN = 0
+PROFILE = 0
+
+
+@six.python_2_unicode_compatible
+class CLIError(Exception):
+    """Generic exception to raise and log different fatal errors."""
+    def __init__(self, msg):
+        super(CLIError).__init__(type(self))
+        self.msg = "E: %s" % msg
+
+    def __str__(self):
+        return self.msg
+
+
+def main(argv=None):  # IGNORE:C0111
+    """Command line options."""
+
+    if argv is None:
+        argv = sys.argv
+    else:
+        sys.argv.extend(argv)
+
+    program_name = os.path.basename(sys.argv[0])
+    program_version = "v%s" % __version__
+    program_build_date = str(__updated__)
+    program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date)
+    program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
+    program_license = '''%s
+
+  Created by Trung Dong Huynh on %s.
+  Copyright 2016 University of Southampton. All rights reserved.
+
+  Licensed under the MIT License
+  https://github.com/trungdong/prov/blob/master/LICENSE
+
+  Distributed on an "AS IS" basis without warranties
+  or conditions of any kind, either express or implied.
+
+USAGE
+''' % (program_shortdesc, str(__date__))
+
+    try:
+        # Setup argument parser
+        parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
+        parser.add_argument('file1', nargs='?', type=FileType('r'))
+        parser.add_argument('file2', nargs='?', type=FileType('r'))
+        parser.add_argument('-f', '--format1', dest='format1', action='store', default='json',
+                            help='File 1\'s format: json or xml')
+        parser.add_argument('-F', '--format2', dest='format2', action='store', default='json',
+                            help='File 2\'s format: json or xml')
+        parser.add_argument('-V', '--version', action='version', version=program_version_message)
+
+        args = None
+        try:
+            # Process arguments
+            args = parser.parse_args()
+            doc1 = ProvDocument.deserialize(args.file1, format=args.format1.lower())
+            doc2 = ProvDocument.deserialize(args.file2, format=args.format2.lower())
+            return doc1 != doc2
+
+        finally:
+            if args:
+                if args.file1:
+                    args.file1.close()
+                if args.file2:
+                    args.file2.close()
+
+    except Exception as e:
+        if DEBUG or TESTRUN:
+            traceback.print_exc()
+            raise e
+        indent = len(program_name) * " "
+        sys.stderr.write(program_name + ": " + str(e) + "\n")
+        sys.stderr.write(indent + "  for help use --help")
+        return 2
+
+if __name__ == "__main__":
+    logging.basicConfig(level=(logging.DEBUG if DEBUG else logging.INFO))
+    if TESTRUN:
+        import doctest
+        doctest.testmod()
+    if PROFILE:
+        import cProfile
+        import pstats
+        profile_filename = 'prov_compare_profile.txt'
+        cProfile.run('main()', profile_filename)
+        statsfile = open("profile_stats.txt", "wb")
+        p = pstats.Stats(profile_filename, stream=statsfile)
+        stats = p.strip_dirs().sort_stats('cumulative')
+        stats.print_stats()
+        statsfile.close()
+        sys.exit(0)
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/prov-convert
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/prov-convert	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,152 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# encoding: utf-8
+"""
+convert -- Convert PROV-JSON to RDF, PROV-N, PROV-XML, or graphical formats (SVG, PDF, PNG)
+
+@author:     Trung Dong Huynh
+
+@copyright:  2016 University of Southampton, United Kingdom. All rights reserved.
+
+@license:    MIT License
+
+@contact:    trungdong@donggiang.com
+@deffield    updated: 2016-10-19
+"""
+
+from argparse import ArgumentParser, RawDescriptionHelpFormatter, FileType
+import os
+import sys
+import logging
+import traceback
+import six
+
+from prov.model import ProvDocument
+from prov import serializers
+
+
+logger = logging.getLogger(__name__)
+
+__all__ = []
+__version__ = 0.1
+__date__ = '2014-03-14'
+__updated__ = '2016-10-19'
+
+DEBUG = 0
+TESTRUN = 0
+PROFILE = 0
+
+GRAPHVIZ_SUPPORTED_FORMATS = {
+    'bmp', 'canon', 'cmap', 'cmapx', 'cmapx_np', 'dot', 'eps', 'fig', 'gtk', 'gv', 'ico', 'imap', 'imap_np', 'ismap',
+    'jpe', 'jpeg', 'jpg', 'pdf', 'plain', 'plain-ext', 'png', 'ps', 'ps2', 'svg', 'svgz', 'tif', 'tiff', 'tk',
+    'vml', 'vmlz', 'x11', 'xdot', 'xlib'
+}
+
+
+@six.python_2_unicode_compatible
+class CLIError(Exception):
+    """Generic exception to raise and log different fatal errors."""
+    def __init__(self, msg):
+        super(CLIError).__init__(type(self))
+        self.msg = "E: %s" % msg
+
+    def __str__(self):
+        return self.msg
+
+
+def convert_file(infile, outfile, output_format):
+    prov_doc = ProvDocument.deserialize(infile)
+
+    # Formats not supported by prov.serializers
+    if output_format == 'provn':
+        outfile.write(prov_doc.get_provn().encode())
+    elif output_format in GRAPHVIZ_SUPPORTED_FORMATS:
+        from prov.dot import prov_to_dot
+        dot = prov_to_dot(prov_doc)
+        content = dot.create(format=output_format)
+        outfile.write(content)
+    else:
+        # Try supported serializers:
+        try:
+            prov_doc.serialize(outfile, format=output_format)
+        except serializers.DoNotExist:
+            raise CLIError('Output format "%s" is not supported.' % output_format)
+
+
+def main(argv=None):  # IGNORE:C0111
+    """Command line options."""
+
+    if argv is None:
+        argv = sys.argv
+    else:
+        sys.argv.extend(argv)
+
+    program_name = os.path.basename(sys.argv[0])
+    program_version = "v%s" % __version__
+    program_build_date = str(__updated__)
+    program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date)
+    program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
+    program_license = '''%s
+
+  Created by Trung Dong Huynh on %s.
+  Copyright 2016 University of Southampton. All rights reserved.
+
+  Licensed under the MIT License
+  https://github.com/trungdong/prov/blob/master/LICENSE
+
+  Distributed on an "AS IS" basis without warranties
+  or conditions of any kind, either express or implied.
+
+USAGE
+''' % (program_shortdesc, str(__date__))
+
+    try:
+        # Setup argument parser
+        parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
+        parser.add_argument('-f', '--format', dest='format', action='store', default='json',
+                            help='output format: json, xml, provn, or one supported by GraphViz (e.g. svg, pdf)')
+        parser.add_argument('infile', nargs='?', type=FileType('r'), default=sys.stdin)
+        parser.add_argument('outfile', nargs='?', type=FileType('wb'), default=sys.stdout)
+        parser.add_argument('-V', '--version', action='version', version=program_version_message)
+
+        args = None
+        try:
+            # Process arguments
+            args = parser.parse_args()
+            convert_file(args.infile, args.outfile, args.format.lower())
+        finally:
+            if args:
+                if args.infile:
+                    args.infile.close()
+                if args.outfile:
+                    args.outfile.close()
+
+        return 0
+    except KeyboardInterrupt:
+        # handle keyboard interrupt
+        return 0
+    except Exception as e:
+        if DEBUG or TESTRUN:
+            traceback.print_exc()
+            raise e
+        indent = len(program_name) * " "
+        sys.stderr.write(program_name + ": " + str(e) + "\n")
+        sys.stderr.write(indent + "  for help use --help")
+        return 2
+
+if __name__ == "__main__":
+    logging.basicConfig(level=(logging.DEBUG if DEBUG else logging.INFO))
+    if TESTRUN:
+        import doctest
+        doctest.testmod()
+    if PROFILE:
+        import cProfile
+        import pstats
+        profile_filename = 'converter_profile.txt'
+        cProfile.run('main()', profile_filename)
+        statsfile = open("profile_stats.txt", "wb")
+        p = pstats.Stats(profile_filename, stream=statsfile)
+        stats = p.strip_dirs().sort_stats('cumulative')
+        stats.print_stats()
+        statsfile.close()
+        sys.exit(0)
+    sys.exit(main())
\ No newline at end of file
diff -r 000000000000 -r 4f3585e2f14b env/bin/pyami_sendmail
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/pyami_sendmail	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,52 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2010 Chris Moyer http://coredumped.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+#
+# Send Mail from a PYAMI instance, or anything that has a boto.cfg
+# properly set up
+#
+VERSION="0.1"
+usage = """%prog [options]
+Sends whatever is on stdin to the recipient specified by your boto.cfg
+or whoevery you specify in the options here.
+"""
+
+if __name__ == "__main__":
+    from boto.utils import notify
+    import sys
+    from optparse import OptionParser
+    parser = OptionParser(version=VERSION, usage=usage)
+    parser.add_option("-t", "--to", help="Optional to address to send to (default from your boto.cfg)", action="store", default=None, dest="to")
+    parser.add_option("-s", "--subject", help="Optional Subject to send this report as", action="store", default="Report", dest="subject")
+    parser.add_option("-f", "--file", help="Optionally, read from a file instead of STDIN", action="store", default=None, dest="file")
+    parser.add_option("--html", help="HTML Format the email", action="store_true", default=False, dest="html")
+    parser.add_option("--no-instance-id", help="If set, don't append the instance id", action="store_false", default=True, dest="append_instance_id")
+
+    (options, args) = parser.parse_args()
+    if options.file:
+        body = open(options.file, 'r').read()
+    else:
+        body = sys.stdin.read()
+
+    if options.html:
+        notify(options.subject, html_body=body, to_string=options.to, append_instance_id=options.append_instance_id)
+    else:
+        notify(options.subject, body=body, to_string=options.to, append_instance_id=options.append_instance_id)
diff -r 000000000000 -r 4f3585e2f14b env/bin/python
Binary file env/bin/python has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/python-argcomplete-check-easy-install-script
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/python-argcomplete-check-easy-install-script	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,55 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+'''
+This script is part of the Python argcomplete package (https://github.com/kislyuk/argcomplete).
+It is used to check if an EASY-INSTALL-SCRIPT wrapper redirects to a script that contains the string
+"PYTHON_ARGCOMPLETE_OK". If you have enabled global completion in argcomplete, the completion hook will run it every
+time you press <TAB> in your shell.
+
+Usage:
+    python-argcomplete-check-easy-install-script <input executable file>
+'''
+
+import sys
+
+if len(sys.argv) != 2:
+    sys.exit(__doc__)
+
+sys.tracebacklimit = 0
+
+with open(sys.argv[1]) as fh:
+    line1, head = fh.read(1024).split("\n", 1)[:2]
+    if line1.startswith('#') and ('py' in line1 or 'Py' in line1):
+        import re
+        lines = head.split("\n", 12)
+        for line in lines:
+            if line.startswith("# EASY-INSTALL-SCRIPT"):
+                import pkg_resources
+                dist, script = re.match("# EASY-INSTALL-SCRIPT: '(.+)','(.+)'", line).groups()
+                if "PYTHON_ARGCOMPLETE_OK" in pkg_resources.get_distribution(dist).get_metadata('scripts/' + script):
+                    exit(0)
+            elif line.startswith("# EASY-INSTALL-ENTRY-SCRIPT"):
+                dist, group, name = re.match("# EASY-INSTALL-ENTRY-SCRIPT: '(.+)','(.+)','(.+)'", line).groups()
+                import pkg_resources, pkgutil
+                module_name = pkg_resources.get_distribution(dist).get_entry_info(group, name).module_name
+                with open(pkgutil.get_loader(module_name).get_filename()) as mod_fh:
+                    if "PYTHON_ARGCOMPLETE_OK" in mod_fh.read(1024):
+                        exit(0)
+            elif line.startswith("# EASY-INSTALL-DEV-SCRIPT"):
+                for line2 in lines:
+                    if line2.startswith('__file__'):
+                        filename = re.match("__file__ = '(.+)'", line2).group(1)
+                        with open(filename) as mod_fh:
+                            if "PYTHON_ARGCOMPLETE_OK" in mod_fh.read(1024):
+                                exit(0)
+            elif line.startswith("# PBR Generated"):
+                module = re.search("from (.*) import", head).groups()[0]
+                import pkg_resources, pkgutil
+                with open(pkgutil.get_loader(module).get_filename()) as mod_fh:
+                    if "PYTHON_ARGCOMPLETE_OK" in mod_fh.read(1024):
+                        exit(0)
+
+exit(1)
diff -r 000000000000 -r 4f3585e2f14b env/bin/python-argcomplete-tcsh
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/python-argcomplete-tcsh	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,23 @@
+#!/bin/sh
+IFS=
+export IFS
+
+COMP_WORDBREAKS=
+export COMP_WORDBREAKS
+
+COMP_TYPE=
+export COMP_TYPE
+
+COMP_LINE=${COMMAND_LINE}
+export COMP_LINE
+
+COMP_POINT=${#COMMAND_LINE}
+export COMP_POINT
+
+_ARGCOMPLETE=1
+export _ARGCOMPLETE
+
+_ARGCOMPLETE_SHELL=tcsh
+export _ARGCOMPLETE_SHELL
+
+"$1" 8>&1 9>&2 1>/dev/null 2>/dev/null
diff -r 000000000000 -r 4f3585e2f14b env/bin/python3
Binary file env/bin/python3 has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/python3.9
Binary file env/bin/python3.9 has changed
diff -r 000000000000 -r 4f3585e2f14b env/bin/rdf2dot
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rdf2dot	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rdflib.tools.rdf2dot import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/rdfgraphisomorphism
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rdfgraphisomorphism	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rdflib.tools.graphisomorphism import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/rdfpipe
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rdfpipe	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rdflib.tools.rdfpipe import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/rdfs2dot
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rdfs2dot	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rdflib.tools.rdfs2dot import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/register-python-argcomplete
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/register-python-argcomplete	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,65 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# PYTHON_ARGCOMPLETE_OK
+
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+'''
+Register a Python executable for use with the argcomplete module.
+
+To perform the registration, source the output of this script in your bash shell
+(quote the output to avoid interpolation).
+
+Example:
+
+    $ eval "$(register-python-argcomplete my-favorite-script.py)"
+
+For Tcsh
+
+    $ eval `register-python-argcomplete --shell tcsh my-favorite-script.py`
+
+For Fish
+
+    $ register-python-argcomplete --shell fish my-favourite-script.py > ~/.config/fish/my-favourite-script.py.fish
+'''
+
+import sys
+import argparse
+import argcomplete
+
+
+parser = argparse.ArgumentParser(
+    description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+
+parser.add_argument(
+    '--no-defaults',
+    dest='use_defaults', action='store_false', default=True,
+    help='When no matches are generated, do not fallback to readline\'s default completion')
+parser.add_argument(
+    '--complete-arguments',
+    nargs=argparse.REMAINDER,
+    help='arguments to call complete with; use of this option discards default options')
+parser.add_argument(
+    '-s', '--shell',
+    choices=('bash', 'tcsh', 'fish'), default='bash',
+    help='output code for the specified shell')
+parser.add_argument(
+    '-e', '--external-argcomplete-script',
+    help='external argcomplete script for auto completion of the executable')
+
+parser.add_argument(
+    'executable',
+    nargs='+',
+    help='executable to completed (when invoked by exactly this name)')
+
+argcomplete.autocomplete(parser)
+
+if len(sys.argv) == 1:
+    parser.print_help()
+    sys.exit(1)
+
+args = parser.parse_args()
+
+
+sys.stdout.write(argcomplete.shellcode(
+    args.executable, args.use_defaults, args.shell, args.complete_arguments, args.external_argcomplete_script))
diff -r 000000000000 -r 4f3585e2f14b env/bin/route53
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/route53	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,205 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Author: Chris Moyer
+#
+# route53 is similar to sdbadmin for Route53, it's a simple
+# console utility to perform the most frequent tasks with Route53
+#
+# Example usage.  Use route53 get after each command to see how the
+# zone changes.
+#
+# Add a non-weighted record, change its value, then delete.  Default TTL:
+#
+# route53 add_record ZPO9LGHZ43QB9 rr.example.com A 4.3.2.1
+# route53 change_record ZPO9LGHZ43QB9 rr.example.com A 9.8.7.6
+# route53 del_record ZPO9LGHZ43QB9 rr.example.com A 9.8.7.6
+#
+# Add a weighted record with two different weights.  Note that the TTL
+# must be specified as route53 uses positional parameters rather than
+# option flags:
+#
+# route53 add_record ZPO9LGHZ43QB9 wrr.example.com A 1.2.3.4 600 foo9 10
+# route53 add_record ZPO9LGHZ43QB9 wrr.example.com A 4.3.2.1 600 foo8 10
+#
+# route53 change_record ZPO9LGHZ43QB9 wrr.example.com A 9.9.9.9 600 foo8 10
+#
+# route53 del_record ZPO9LGHZ43QB9 wrr.example.com A 1.2.3.4 600 foo9 10
+# route53 del_record ZPO9LGHZ43QB9 wrr.example.com A 9.9.9.9 600 foo8 10
+#
+# Add a non-weighted alias, change its value, then delete.  Alaises inherit
+# their TTLs from the backing ELB:
+#
+# route53 add_alias ZPO9LGHZ43QB9 alias.example.com A Z3DZXE0Q79N41H lb-1218761514.us-east-1.elb.amazonaws.com.
+# route53 change_alias ZPO9LGHZ43QB9 alias.example.com. A Z3DZXE0Q79N41H lb2-1218761514.us-east-1.elb.amazonaws.com.
+# route53 delete_alias ZPO9LGHZ43QB9 alias.example.com. A Z3DZXE0Q79N41H lb2-1218761514.us-east-1.elb.amazonaws.com.
+
+def _print_zone_info(zoneinfo):
+    print "="*80
+    print "| ID:   %s" % zoneinfo['Id'].split("/")[-1]
+    print "| Name: %s" % zoneinfo['Name']
+    print "| Ref:  %s" % zoneinfo['CallerReference']
+    print "="*80
+    print zoneinfo['Config']
+    print
+
+
+def create(conn, hostname, caller_reference=None, comment=''):
+    """Create a hosted zone, returning the nameservers"""
+    response = conn.create_hosted_zone(hostname, caller_reference, comment)
+    print "Pending, please add the following Name Servers:"
+    for ns in response.NameServers:
+        print "\t", ns
+
+def delete_zone(conn, hosted_zone_id):
+    """Delete a hosted zone by ID"""
+    response = conn.delete_hosted_zone(hosted_zone_id)
+    print response
+
+def ls(conn):
+    """List all hosted zones"""
+    response = conn.get_all_hosted_zones()
+    for zoneinfo in response['ListHostedZonesResponse']['HostedZones']:
+        _print_zone_info(zoneinfo)
+
+def get(conn, hosted_zone_id, type=None, name=None, maxitems=None):
+    """Get all the records for a single zone"""
+    response = conn.get_all_rrsets(hosted_zone_id, type, name, maxitems=maxitems)
+    # If a maximum number of items was set, we limit to that number
+    # by turning the response into an actual list (copying it)
+    # instead of allowing it to page
+    if maxitems:
+        response = response[:]
+    print '%-40s %-5s %-20s %s' % ("Name", "Type", "TTL", "Value(s)")
+    for record in response:
+        print '%-40s %-5s %-20s %s' % (record.name, record.type, record.ttl, record.to_print())
+
+def _add_del(conn, hosted_zone_id, change, name, type, identifier, weight, values, ttl, comment):
+    from boto.route53.record import ResourceRecordSets
+    changes = ResourceRecordSets(conn, hosted_zone_id, comment)
+    change = changes.add_change(change, name, type, ttl,
+                                identifier=identifier, weight=weight)
+    for value in values.split(','):
+        change.add_value(value)
+    print changes.commit()
+
+def _add_del_alias(conn, hosted_zone_id, change, name, type, identifier, weight, alias_hosted_zone_id, alias_dns_name, comment):
+    from boto.route53.record import ResourceRecordSets
+    changes = ResourceRecordSets(conn, hosted_zone_id, comment)
+    change = changes.add_change(change, name, type,
+                                identifier=identifier, weight=weight)
+    change.set_alias(alias_hosted_zone_id, alias_dns_name)
+    print changes.commit()
+
+def add_record(conn, hosted_zone_id, name, type, values, ttl=600,
+               identifier=None, weight=None, comment=""):
+    """Add a new record to a zone.  identifier and weight are optional."""
+    _add_del(conn, hosted_zone_id, "CREATE", name, type, identifier,
+             weight, values, ttl, comment)
+
+def del_record(conn, hosted_zone_id, name, type, values, ttl=600,
+               identifier=None, weight=None, comment=""):
+    """Delete a record from a zone: name, type, ttl, identifier, and weight must match."""
+    _add_del(conn, hosted_zone_id, "DELETE", name, type, identifier,
+             weight, values, ttl, comment)
+
+def add_alias(conn, hosted_zone_id, name, type, alias_hosted_zone_id,
+              alias_dns_name, identifier=None, weight=None, comment=""):
+    """Add a new alias to a zone.  identifier and weight are optional."""
+    _add_del_alias(conn, hosted_zone_id, "CREATE", name, type, identifier,
+                   weight, alias_hosted_zone_id, alias_dns_name, comment)
+
+def del_alias(conn, hosted_zone_id, name, type, alias_hosted_zone_id,
+              alias_dns_name, identifier=None, weight=None, comment=""):
+    """Delete an alias from a zone: name, type, alias_hosted_zone_id, alias_dns_name, weight and identifier must match."""
+    _add_del_alias(conn, hosted_zone_id, "DELETE", name, type, identifier,
+                   weight, alias_hosted_zone_id, alias_dns_name, comment)
+
+def change_record(conn, hosted_zone_id, name, type, newvalues, ttl=600,
+                   identifier=None, weight=None, comment=""):
+    """Delete and then add a record to a zone.  identifier and weight are optional."""
+    from boto.route53.record import ResourceRecordSets
+    changes = ResourceRecordSets(conn, hosted_zone_id, comment)
+    # Assume there are not more than 10 WRRs for a given (name, type)
+    responses = conn.get_all_rrsets(hosted_zone_id, type, name, maxitems=10)
+    for response in responses:
+        if response.name != name or response.type != type:
+            continue
+        if response.identifier != identifier or response.weight != weight:
+            continue
+        change1 = changes.add_change("DELETE", name, type, response.ttl,
+                                     identifier=response.identifier,
+                                     weight=response.weight)
+        for old_value in response.resource_records:
+            change1.add_value(old_value)
+
+    change2 = changes.add_change("UPSERT", name, type, ttl,
+            identifier=identifier, weight=weight)
+    for new_value in newvalues.split(','):
+        change2.add_value(new_value)
+    print changes.commit()
+
+def change_alias(conn, hosted_zone_id, name, type, new_alias_hosted_zone_id, new_alias_dns_name, identifier=None, weight=None, comment=""):
+    """Delete and then add an alias to a zone.  identifier and weight are optional."""
+    from boto.route53.record import ResourceRecordSets
+    changes = ResourceRecordSets(conn, hosted_zone_id, comment)
+    # Assume there are not more than 10 WRRs for a given (name, type)
+    responses = conn.get_all_rrsets(hosted_zone_id, type, name, maxitems=10)
+    for response in responses:
+        if response.name != name or response.type != type:
+            continue
+        if response.identifier != identifier or response.weight != weight:
+            continue
+        change1 = changes.add_change("DELETE", name, type,
+                                     identifier=response.identifier,
+                                     weight=response.weight)
+        change1.set_alias(response.alias_hosted_zone_id, response.alias_dns_name)
+    change2 = changes.add_change("UPSERT", name, type, identifier=identifier, weight=weight)
+    change2.set_alias(new_alias_hosted_zone_id, new_alias_dns_name)
+    print changes.commit()
+
+def help(conn, fnc=None):
+    """Prints this help message"""
+    import inspect
+    self = sys.modules['__main__']
+    if fnc:
+        try:
+            cmd = getattr(self, fnc)
+        except:
+            cmd = None
+        if not inspect.isfunction(cmd):
+            print "No function named: %s found" % fnc
+            sys.exit(2)
+        (args, varargs, varkw, defaults) = inspect.getargspec(cmd)
+        print cmd.__doc__
+        print "Usage: %s %s" % (fnc, " ".join([ "[%s]" % a for a in args[1:]]))
+    else:
+        print "Usage: route53 [command]"
+        for cname in dir(self):
+            if not cname.startswith("_"):
+                cmd = getattr(self, cname)
+                if inspect.isfunction(cmd):
+                    doc = cmd.__doc__
+                    print "\t%-20s  %s" % (cname, doc)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    import boto
+    import sys
+    conn = boto.connect_route53()
+    self = sys.modules['__main__']
+    if len(sys.argv) >= 2:
+        try:
+            cmd = getattr(self, sys.argv[1])
+        except:
+            cmd = None
+        args = sys.argv[2:]
+    else:
+        cmd = help
+        args = []
+    if not cmd:
+        cmd = help
+    try:
+        cmd(conn, *args)
+    except TypeError as e:
+        print e
+        help(conn, cmd.__name__)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2html.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2html.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,23 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2html.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html', description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2html4.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2html4.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,26 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2html4.py 7994 2016-12-10 17:41:45Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing (X)HTML.
+
+The output conforms to XHTML 1.0 transitional
+and almost to HTML 4.01 transitional (except for closing empty tags).
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html4', description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2html5.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2html5.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,35 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf8 -*-
+# :Copyright: © 2015 Günter Milde.
+# :License: Released under the terms of the `2-Clause BSD license`_, in short:
+#
+#    Copying and distribution of this file, with or without modification,
+#    are permitted in any medium without royalty provided the copyright
+#    notice and this notice are preserved.
+#    This file is offered as-is, without any warranty.
+#
+# .. _2-Clause BSD license: http://www.spdx.org/licenses/BSD-2-Clause
+#
+# Revision: $Revision: 8410 $
+# Date: $Date: 2019-11-04 22:14:43 +0100 (Mo, 04. Nov 2019) $
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML 5 documents.
+
+The output also conforms to XHTML 1.0 transitional
+(except for the doctype declaration).
+"""
+
+try:
+    import locale # module missing in Jython
+    locale.setlocale(locale.LC_ALL, '')
+except locale.Error:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+description = (u'Generates HTML 5 documents from standalone '
+               u'reStructuredText sources '
+               + default_description)
+
+publish_cmdline(writer_name='html5', description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2latex.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2latex.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,26 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2latex.py 5905 2009-04-16 12:04:49Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing LaTeX.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline
+
+description = ('Generates LaTeX documents from standalone reStructuredText '
+               'sources. '
+               'Reads from <source> (default is stdin) and writes to '
+               '<destination> (default is stdout).  See '
+               '<http://docutils.sourceforge.net/docs/user/latex.html> for '
+               'the full reference.')
+
+publish_cmdline(writer_name='latex', description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2man.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2man.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,26 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# Author:
+# Contact: grubert@users.sf.net
+# Copyright: This module has been placed in the public domain.
+
+"""
+man.py
+======
+
+This module provides a simple command line interface that uses the
+man page writer to output from ReStructuredText source.
+"""
+
+import locale
+try:
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+from docutils.writers import manpage
+
+description = ("Generates plain unix manual documents.  " + default_description)
+
+publish_cmdline(writer=manpage.Writer(), description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2odt.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2odt.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,30 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2odt.py 5839 2009-01-07 19:09:28Z dkuhlman $
+# Author: Dave Kuhlman <dkuhlman@rexx.com>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A front end to the Docutils Publisher, producing OpenOffice documents.
+"""
+
+import sys
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline_to_binary, default_description
+from docutils.writers.odf_odt import Writer, Reader
+
+
+description = ('Generates OpenDocument/OpenOffice/ODF documents from '
+               'standalone reStructuredText sources.  ' + default_description)
+
+
+writer = Writer()
+reader = Reader()
+output = publish_cmdline_to_binary(reader=reader, writer=writer,
+    description=description)
+
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2odt_prepstyles.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2odt_prepstyles.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,67 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2odt_prepstyles.py 8346 2019-08-26 12:11:32Z milde $
+# Author: Dave Kuhlman <dkuhlman@rexx.com>
+# Copyright: This module has been placed in the public domain.
+
+"""
+Fix a word-processor-generated styles.odt for odtwriter use: Drop page size
+specifications from styles.xml in STYLE_FILE.odt.
+"""
+
+# Author: Michael Schutte <michi@uiae.at>
+
+from __future__ import print_function
+
+from lxml import etree
+import sys
+import zipfile
+from tempfile import mkstemp
+import shutil
+import os
+
+NAMESPACES = {
+    "style": "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+    "fo": "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0"
+}
+
+
+def prepstyle(filename):
+
+    zin = zipfile.ZipFile(filename)
+    styles = zin.read("styles.xml")
+
+    root = etree.fromstring(styles)
+    for el in root.xpath("//style:page-layout-properties",
+                         namespaces=NAMESPACES):
+        for attr in el.attrib:
+            if attr.startswith("{%s}" % NAMESPACES["fo"]):
+                del el.attrib[attr]
+
+    tempname = mkstemp()
+    zout = zipfile.ZipFile(os.fdopen(tempname[0], "w"), "w",
+                           zipfile.ZIP_DEFLATED)
+
+    for item in zin.infolist():
+        if item.filename == "styles.xml":
+            zout.writestr(item, etree.tostring(root))
+        else:
+            zout.writestr(item, zin.read(item.filename))
+
+    zout.close()
+    zin.close()
+    shutil.move(tempname[1], filename)
+
+
+def main():
+    args = sys.argv[1:]
+    if len(args) != 1:
+        print(__doc__, file=sys.stderr)
+        print("Usage: %s STYLE_FILE.odt\n" % sys.argv[0], file=sys.stderr)
+        sys.exit(1)
+    filename = args[0]
+    prepstyle(filename)
+
+
+if __name__ == '__main__':
+    main()
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2pseudoxml.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2pseudoxml.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,23 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2pseudoxml.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing pseudo-XML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates pseudo-XML from standalone reStructuredText '
+               'sources (for testing purposes).  ' + default_description)
+
+publish_cmdline(description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2s5.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2s5.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,24 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2s5.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: Chris Liechti <cliechti@gmx.net>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML slides using
+the S5 template system.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates S5 (X)HTML slideshow documents from standalone '
+               'reStructuredText sources.  ' + default_description)
+
+publish_cmdline(writer_name='s5', description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2xetex.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2xetex.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,27 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2xetex.py 7847 2015-03-17 17:30:47Z milde $
+# Author: Guenter Milde
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing Lua/XeLaTeX code.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline
+
+description = ('Generates LaTeX documents from standalone reStructuredText '
+               'sources for compilation with the Unicode-aware TeX variants '
+               'XeLaTeX or LuaLaTeX. '
+               'Reads from <source> (default is stdin) and writes to '
+               '<destination> (default is stdout).  See '
+               '<http://docutils.sourceforge.net/docs/user/latex.html> for '
+               'the full reference.')
+
+publish_cmdline(writer_name='xetex', description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rst2xml.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rst2xml.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,23 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rst2xml.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing Docutils XML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates Docutils-native XML from standalone '
+               'reStructuredText sources.  ' + default_description)
+
+publish_cmdline(writer_name='xml', description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/rstpep2html.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/rstpep2html.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,25 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+
+# $Id: rstpep2html.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML from PEP
+(Python Enhancement Proposal) documents.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML from reStructuredText-format PEP files.  '
+               + default_description)
+
+publish_cmdline(reader_name='pep', writer_name='pep_html',
+                description=description)
diff -r 000000000000 -r 4f3585e2f14b env/bin/run-data-managers
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/run-data-managers	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.run_data_managers import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/s3put
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/s3put	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,438 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2006,2007,2008 Mitch Garnaat http://garnaat.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+import getopt
+import sys
+import os
+import boto
+
+from boto.compat import six
+
+try:
+    # multipart portions copyright Fabian Topfstedt
+    # https://gist.github.com/924094
+
+    import math
+    import mimetypes
+    from multiprocessing import Pool
+    from boto.s3.connection import S3Connection
+    from filechunkio import FileChunkIO
+    multipart_capable = True
+    usage_flag_multipart_capable = """ [--multipart]"""
+    usage_string_multipart_capable = """
+        multipart - Upload files as multiple parts. This needs filechunkio.
+                    Requires ListBucket, ListMultipartUploadParts,
+                    ListBucketMultipartUploads and PutObject permissions."""
+except ImportError as err:
+    multipart_capable = False
+    usage_flag_multipart_capable = ""
+    if six.PY2:
+        attribute = 'message'
+    else:
+        attribute = 'msg'
+    usage_string_multipart_capable = '\n\n     "' + \
+        getattr(err, attribute)[len('No module named '):] + \
+        '" is missing for multipart support '
+
+
+DEFAULT_REGION = 'us-east-1'
+
+usage_string = """
+SYNOPSIS
+    s3put [-a/--access_key <access_key>] [-s/--secret_key <secret_key>]
+          -b/--bucket <bucket_name> [-c/--callback <num_cb>]
+          [-d/--debug <debug_level>] [-i/--ignore <ignore_dirs>]
+          [-n/--no_op] [-p/--prefix <prefix>] [-k/--key_prefix <key_prefix>]
+          [-q/--quiet] [-g/--grant grant] [-w/--no_overwrite] [-r/--reduced]
+          [--header] [--region <name>] [--host <s3_host>]""" + \
+          usage_flag_multipart_capable + """ path [path...]
+
+    Where
+        access_key - Your AWS Access Key ID.  If not supplied, boto will
+                     use the value of the environment variable
+                     AWS_ACCESS_KEY_ID
+        secret_key - Your AWS Secret Access Key.  If not supplied, boto
+                     will use the value of the environment variable
+                     AWS_SECRET_ACCESS_KEY
+        bucket_name - The name of the S3 bucket the file(s) should be
+                      copied to.
+        path - A path to a directory or file that represents the items
+               to be uploaded.  If the path points to an individual file,
+               that file will be uploaded to the specified bucket.  If the
+               path points to a directory, it will recursively traverse
+               the directory and upload all files to the specified bucket.
+        debug_level - 0 means no debug output (default), 1 means normal
+                      debug output from boto, and 2 means boto debug output
+                      plus request/response output from httplib
+        ignore_dirs - a comma-separated list of directory names that will
+                      be ignored and not uploaded to S3.
+        num_cb - The number of progress callbacks to display.  The default
+                 is zero which means no callbacks.  If you supplied a value
+                 of "-c 10" for example, the progress callback would be
+                 called 10 times for each file transferred.
+        prefix - A file path prefix that will be stripped from the full
+                 path of the file when determining the key name in S3.
+                 For example, if the full path of a file is:
+                     /home/foo/bar/fie.baz
+                 and the prefix is specified as "-p /home/foo/" the
+                 resulting key name in S3 will be:
+                     /bar/fie.baz
+                 The prefix must end in a trailing separator and if it
+                 does not then one will be added.
+        key_prefix - A prefix to be added to the S3 key name, after any
+                     stripping of the file path is done based on the
+                     "-p/--prefix" option.
+        reduced - Use Reduced Redundancy storage
+        grant - A canned ACL policy that will be granted on each file
+                transferred to S3.  The value of provided must be one
+                of the "canned" ACL policies supported by S3:
+                private|public-read|public-read-write|authenticated-read
+        no_overwrite - No files will be overwritten on S3, if the file/key
+                       exists on s3 it will be kept. This is useful for
+                       resuming interrupted transfers. Note this is not a
+                       sync, even if the file has been updated locally if
+                       the key exists on s3 the file on s3 will not be
+                       updated.
+        header - key=value pairs of extra header(s) to pass along in the
+                 request
+        region - Manually set a region for buckets that are not in the US
+                 classic region. Normally the region is autodetected, but
+                 setting this yourself is more efficient.
+        host - Hostname override, for using an endpoint other then AWS S3
+""" + usage_string_multipart_capable + """
+
+
+     If the -n option is provided, no files will be transferred to S3 but
+     informational messages will be printed about what would happen.
+"""
+
+
+def usage(status=1):
+    print(usage_string)
+    sys.exit(status)
+
+
+def submit_cb(bytes_so_far, total_bytes):
+    print('%d bytes transferred / %d bytes total' % (bytes_so_far, total_bytes))
+
+
+def get_key_name(fullpath, prefix, key_prefix):
+    if fullpath.startswith(prefix):
+        key_name = fullpath[len(prefix):]
+    else:
+        key_name = fullpath
+    l = key_name.split(os.sep)
+    return key_prefix + '/'.join(l)
+
+
+def _upload_part(bucketname, aws_key, aws_secret, multipart_id, part_num,
+                 source_path, offset, bytes, debug, cb, num_cb,
+                 amount_of_retries=10):
+    """
+    Uploads a part with retries.
+    """
+    if debug == 1:
+        print("_upload_part(%s, %s, %s)" % (source_path, offset, bytes))
+
+    def _upload(retries_left=amount_of_retries):
+        try:
+            if debug == 1:
+                print('Start uploading part #%d ...' % part_num)
+            conn = S3Connection(aws_key, aws_secret)
+            conn.debug = debug
+            bucket = conn.get_bucket(bucketname)
+            for mp in bucket.get_all_multipart_uploads():
+                if mp.id == multipart_id:
+                    with FileChunkIO(source_path, 'r', offset=offset,
+                                     bytes=bytes) as fp:
+                        mp.upload_part_from_file(fp=fp, part_num=part_num,
+                                                 cb=cb, num_cb=num_cb)
+                    break
+        except Exception as exc:
+            if retries_left:
+                _upload(retries_left=retries_left - 1)
+            else:
+                print('Failed uploading part #%d' % part_num)
+                raise exc
+        else:
+            if debug == 1:
+                print('... Uploaded part #%d' % part_num)
+
+    _upload()
+
+def check_valid_region(conn, region):
+    if conn is None:
+        print('Invalid region (%s)' % region)
+        sys.exit(1)
+
+def multipart_upload(bucketname, aws_key, aws_secret, source_path, keyname,
+                     reduced, debug, cb, num_cb, acl='private', headers={},
+                     guess_mimetype=True, parallel_processes=4,
+                     region=DEFAULT_REGION):
+    """
+    Parallel multipart upload.
+    """
+    conn = boto.s3.connect_to_region(region, aws_access_key_id=aws_key,
+                                     aws_secret_access_key=aws_secret)
+    check_valid_region(conn, region)
+    conn.debug = debug
+    bucket = conn.get_bucket(bucketname)
+
+    if guess_mimetype:
+        mtype = mimetypes.guess_type(keyname)[0] or 'application/octet-stream'
+        headers.update({'Content-Type': mtype})
+
+    mp = bucket.initiate_multipart_upload(keyname, headers=headers,
+                                          reduced_redundancy=reduced)
+
+    source_size = os.stat(source_path).st_size
+    bytes_per_chunk = max(int(math.sqrt(5242880) * math.sqrt(source_size)),
+                          5242880)
+    chunk_amount = int(math.ceil(source_size / float(bytes_per_chunk)))
+
+    pool = Pool(processes=parallel_processes)
+    for i in range(chunk_amount):
+        offset = i * bytes_per_chunk
+        remaining_bytes = source_size - offset
+        bytes = min([bytes_per_chunk, remaining_bytes])
+        part_num = i + 1
+        pool.apply_async(_upload_part, [bucketname, aws_key, aws_secret, mp.id,
+                                        part_num, source_path, offset, bytes,
+                                        debug, cb, num_cb])
+    pool.close()
+    pool.join()
+
+    if len(mp.get_all_parts()) == chunk_amount:
+        mp.complete_upload()
+        key = bucket.get_key(keyname)
+        key.set_acl(acl)
+    else:
+        mp.cancel_upload()
+
+
+def singlepart_upload(bucket, key_name, fullpath, *kargs, **kwargs):
+    """
+    Single upload.
+    """
+    k = bucket.new_key(key_name)
+    k.set_contents_from_filename(fullpath, *kargs, **kwargs)
+
+
+def expand_path(path):
+    path = os.path.expanduser(path)
+    path = os.path.expandvars(path)
+    return os.path.abspath(path)
+
+
+def main():
+
+    # default values
+    aws_access_key_id = None
+    aws_secret_access_key = None
+    bucket_name = ''
+    ignore_dirs = []
+    debug = 0
+    cb = None
+    num_cb = 0
+    quiet = False
+    no_op = False
+    prefix = '/'
+    key_prefix = ''
+    grant = None
+    no_overwrite = False
+    reduced = False
+    headers = {}
+    host = None
+    multipart_requested = False
+    region = None
+
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'a:b:c::d:g:hi:k:np:qs:wr',
+            ['access_key=', 'bucket=', 'callback=', 'debug=', 'help', 'grant=',
+             'ignore=', 'key_prefix=', 'no_op', 'prefix=', 'quiet',
+             'secret_key=', 'no_overwrite', 'reduced', 'header=', 'multipart',
+             'host=', 'region='])
+    except:
+        usage(1)
+
+    # parse opts
+    for o, a in opts:
+        if o in ('-h', '--help'):
+            usage(0)
+        if o in ('-a', '--access_key'):
+            aws_access_key_id = a
+        if o in ('-b', '--bucket'):
+            bucket_name = a
+        if o in ('-c', '--callback'):
+            num_cb = int(a)
+            cb = submit_cb
+        if o in ('-d', '--debug'):
+            debug = int(a)
+        if o in ('-g', '--grant'):
+            grant = a
+        if o in ('-i', '--ignore'):
+            ignore_dirs = a.split(',')
+        if o in ('-n', '--no_op'):
+            no_op = True
+        if o in ('-w', '--no_overwrite'):
+            no_overwrite = True
+        if o in ('-p', '--prefix'):
+            prefix = a
+            if prefix[-1] != os.sep:
+                prefix = prefix + os.sep
+            prefix = expand_path(prefix)
+        if o in ('-k', '--key_prefix'):
+            key_prefix = a
+        if o in ('-q', '--quiet'):
+            quiet = True
+        if o in ('-s', '--secret_key'):
+            aws_secret_access_key = a
+        if o in ('-r', '--reduced'):
+            reduced = True
+        if o == '--header':
+            (k, v) = a.split("=", 1)
+            headers[k] = v
+        if o == '--host':
+            host = a
+        if o == '--multipart':
+            if multipart_capable:
+                multipart_requested = True
+            else:
+                print("multipart upload requested but not capable")
+                sys.exit(4)
+        if o == '--region':
+            regions = boto.s3.regions()
+            for region_info in regions:
+                if region_info.name == a:
+                    region = a
+                    break
+            else:
+                raise ValueError('Invalid region %s specified' % a)
+
+    if len(args) < 1:
+        usage(2)
+
+    if not bucket_name:
+        print("bucket name is required!")
+        usage(3)
+
+    connect_args = {
+        'aws_access_key_id': aws_access_key_id,
+        'aws_secret_access_key': aws_secret_access_key
+    }
+
+    if host:
+        connect_args['host'] = host
+
+    c = boto.s3.connect_to_region(region or DEFAULT_REGION, **connect_args)
+    check_valid_region(c, region or DEFAULT_REGION)
+    c.debug = debug
+    b = c.get_bucket(bucket_name, validate=False)
+
+    # Attempt to determine location and warn if no --host or --region
+    # arguments were passed. Then try to automagically figure out
+    # what should have been passed and fix it.
+    if host is None and region is None:
+        try:
+            location = b.get_location()
+
+            # Classic region will be '', any other will have a name
+            if location:
+                print('Bucket exists in %s but no host or region given!' % location)
+
+                # Override for EU, which is really Ireland according to the docs
+                if location == 'EU':
+                    location = 'eu-west-1'
+
+                print('Automatically setting region to %s' % location)
+
+                # Here we create a new connection, and then take the existing
+                # bucket and set it to use the new connection
+                c = boto.s3.connect_to_region(location, **connect_args)
+                c.debug = debug
+                b.connection = c
+        except Exception as e:
+            if debug > 0:
+                print(e)
+            print('Could not get bucket region info, skipping...')
+
+    existing_keys_to_check_against = []
+    files_to_check_for_upload = []
+
+    for path in args:
+        path = expand_path(path)
+        # upload a directory of files recursively
+        if os.path.isdir(path):
+            if no_overwrite:
+                if not quiet:
+                    print('Getting list of existing keys to check against')
+                for key in b.list(get_key_name(path, prefix, key_prefix)):
+                    existing_keys_to_check_against.append(key.name)
+            for root, dirs, files in os.walk(path):
+                for ignore in ignore_dirs:
+                    if ignore in dirs:
+                        dirs.remove(ignore)
+                for path in files:
+                    if path.startswith("."):
+                        continue
+                    files_to_check_for_upload.append(os.path.join(root, path))
+
+        # upload a single file
+        elif os.path.isfile(path):
+            fullpath = os.path.abspath(path)
+            key_name = get_key_name(fullpath, prefix, key_prefix)
+            files_to_check_for_upload.append(fullpath)
+            existing_keys_to_check_against.append(key_name)
+
+        # we are trying to upload something unknown
+        else:
+            print("I don't know what %s is, so i can't upload it" % path)
+
+    for fullpath in files_to_check_for_upload:
+        key_name = get_key_name(fullpath, prefix, key_prefix)
+
+        if no_overwrite and key_name in existing_keys_to_check_against:
+            if b.get_key(key_name):
+                if not quiet:
+                    print('Skipping %s as it exists in s3' % fullpath)
+                continue
+
+        if not quiet:
+            print('Copying %s to %s/%s' % (fullpath, bucket_name, key_name))
+
+        if not no_op:
+            # 0-byte files don't work and also don't need multipart upload
+            if os.stat(fullpath).st_size != 0 and multipart_capable and \
+                    multipart_requested:
+                multipart_upload(bucket_name, aws_access_key_id,
+                                 aws_secret_access_key, fullpath, key_name,
+                                 reduced, debug, cb, num_cb,
+                                 grant or 'private', headers,
+                                 region=region or DEFAULT_REGION)
+            else:
+                singlepart_upload(b, key_name, fullpath, cb=cb, num_cb=num_cb,
+                                  policy=grant, reduced_redundancy=reduced,
+                                  headers=headers)
+
+if __name__ == "__main__":
+    main()
diff -r 000000000000 -r 4f3585e2f14b env/bin/schema-salad-doc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/schema-salad-doc	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from schema_salad.makedoc import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/schema-salad-tool
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/schema-salad-tool	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from schema_salad.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/sdbadmin
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/sdbadmin	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,194 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2009 Chris Moyer http://kopertop.blogspot.com/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+#
+# Tools to dump and recover an SDB domain
+#
+VERSION = "%prog version 1.0"
+import boto
+import time
+from boto import sdb
+from boto.compat import json
+
+def choice_input(options, default=None, title=None):
+    """
+    Choice input
+    """
+    if title == None:
+        title = "Please choose"
+    print title
+    objects = []
+    for n, obj in enumerate(options):
+        print "%s: %s" % (n, obj)
+        objects.append(obj)
+    choice = int(raw_input(">>> "))
+    try:
+        choice = objects[choice]
+    except:
+        choice = default
+    return choice
+
+def confirm(message="Are you sure?"):
+    choice = raw_input("%s [yN] " % message)
+    return choice and len(choice) > 0 and choice[0].lower() == "y"
+
+
+def dump_db(domain, file_name, use_json=False, sort_attributes=False):
+    """
+    Dump SDB domain to file
+    """
+    f = open(file_name, "w")
+    if use_json:
+        for item in domain:
+            data = {"name": item.name, "attributes": item}
+            print >> f, json.dumps(data, sort_keys=sort_attributes)
+    else:
+        doc = domain.to_xml(f)
+
+def empty_db(domain):
+    """
+    Remove all entries from domain
+    """
+    for item in domain:
+        item.delete()
+
+def load_db(domain, file, use_json=False):
+    """
+    Load a domain from a file, this doesn't overwrite any existing
+    data in the file so if you want to do a full recovery and restore
+    you need to call empty_db before calling this
+
+    :param domain: The SDB Domain object to load to
+    :param file: The File to load the DB from
+    """
+    if use_json:
+        for line in file.readlines():
+            if line:
+                data = json.loads(line)
+                item = domain.new_item(data['name'])
+                item.update(data['attributes'])
+                item.save()
+                
+    else:
+        domain.from_xml(file)
+
+def check_valid_region(conn, region):
+    if conn is None:
+        print 'Invalid region (%s)' % region
+        sys.exit(1)
+
+def create_db(domain_name, region_name):
+    """Create a new DB
+
+    :param domain: Name of the domain to create
+    :type domain: str
+    """
+    sdb = boto.sdb.connect_to_region(region_name)
+    check_valid_region(sdb, region_name)
+    return sdb.create_domain(domain_name)
+
+if __name__ == "__main__":
+    from optparse import OptionParser
+    parser = OptionParser(version=VERSION, usage="Usage: %prog [--dump|--load|--empty|--list|-l] [options]")
+
+    # Commands
+    parser.add_option("--dump", help="Dump domain to file", dest="dump", default=False, action="store_true")
+    parser.add_option("--load", help="Load domain contents from file", dest="load", default=False, action="store_true")
+    parser.add_option("--empty", help="Empty all contents of domain", dest="empty", default=False, action="store_true")
+    parser.add_option("-l", "--list", help="List All domains", dest="list", default=False, action="store_true")
+    parser.add_option("-c", "--create", help="Create domain", dest="create", default=False, action="store_true")
+
+    parser.add_option("-a", "--all-domains", help="Operate on all domains", action="store_true", default=False, dest="all_domains")
+    if json:
+        parser.add_option("-j", "--use-json", help="Load/Store as JSON instead of XML", action="store_true", default=False, dest="json")
+    parser.add_option("-s", "--sort-attibutes", help="Sort the element attributes", action="store_true", default=False, dest="sort_attributes")
+    parser.add_option("-d", "--domain", help="Do functions on domain (may be more then one)", action="append", dest="domains")
+    parser.add_option("-f", "--file", help="Input/Output file we're operating on", dest="file_name")
+    parser.add_option("-r", "--region", help="Region (e.g. us-east-1[default] or eu-west-1)", default="us-east-1", dest="region_name")
+    (options, args) = parser.parse_args()
+
+    if options.create:
+        for domain_name in options.domains:
+            create_db(domain_name, options.region_name)
+        exit()
+
+    sdb = boto.sdb.connect_to_region(options.region_name)
+    check_valid_region(sdb, options.region_name)
+    if options.list:
+        for db in sdb.get_all_domains():
+            print db
+        exit()
+
+    if not options.dump and not options.load and not options.empty:
+            parser.print_help()
+            exit()
+
+
+
+
+    #
+    # Setup
+    #
+    if options.domains:
+        domains = []
+        for domain_name in options.domains:
+            domains.append(sdb.get_domain(domain_name))
+    elif options.all_domains:
+        domains = sdb.get_all_domains()
+    else:
+        domains = [choice_input(options=sdb.get_all_domains(), title="No domain specified, please choose one")]
+
+
+    #
+    # Execute the commands
+    #
+    stime = time.time()
+    if options.empty:
+        if confirm("WARNING!!! Are you sure you want to empty the following domains?: %s" % domains):
+            stime = time.time()
+            for domain in domains:
+                print "--------> Emptying %s <--------" % domain.name
+                empty_db(domain)
+        else:
+            print "Canceling operations"
+            exit()
+
+    if options.dump:
+        for domain in domains:
+            print "--------> Dumping %s <---------" % domain.name
+            if options.file_name:
+                file_name = options.file_name
+            else:
+                file_name = "%s.db" % domain.name
+            dump_db(domain, file_name, options.json, options.sort_attributes)
+
+    if options.load:
+        for domain in domains:
+            print "---------> Loading %s <----------" % domain.name
+            if options.file_name:
+                file_name = options.file_name
+            else:
+                file_name = "%s.db" % domain.name
+            load_db(domain, open(file_name, "rb"), options.json)
+
+
+    total_time = round(time.time() - stime, 2)
+    print "--------> Finished in %s <--------" % total_time
diff -r 000000000000 -r 4f3585e2f14b env/bin/setup-data-libraries
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/setup-data-libraries	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.setup_data_libraries import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/shed-tools
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/shed-tools	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.shed_tools import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/tabulate
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/tabulate	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tabulate import _main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(_main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/taskadmin
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/taskadmin	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,116 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# Copyright (c) 2009 Chris Moyer http://coredumped.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+#
+# Task/Job Administration utility
+#
+VERSION="0.1"
+__version__ = VERSION
+usage = """%prog [options] [command]
+Commands:
+    list|ls                                List all Tasks in SDB
+    delete      <id>                       Delete Task with id <id>
+    get         <name>                     Get Task <name>
+    create|mk   <name> <hour> <command>    Create a new Task <name> with command <command> running every <hour>
+"""
+
+def list():
+    """List all Tasks in SDB"""
+    from boto.manage.task import Task
+    print "%-8s %-40s %s" %  ("Hour", "Name", "Command")
+    print "-"*100
+    for t in Task.all():
+        print "%-8s %-40s %s" % (t.hour, t.name, t.command)
+
+def get(name):
+    """Get a task
+    :param name: The name of the task to fetch
+    :type name: str
+    """
+    from boto.manage.task import Task
+    q = Task.find()
+    q.filter("name like", "%s%%" % name)
+    for t in q:
+        print "="*80
+        print "|               ", t.id
+        print "|%s" %  ("-"*79)
+        print "| Name:         ", t.name
+        print "| Hour:         ", t.hour
+        print "| Command:      ", t.command
+        if t.last_executed:
+            print "| Last Run:     ", t.last_executed.ctime()
+            print "| Last Status:  ", t.last_status
+            print "| Last Run Log: ", t.last_output
+        print "="*80
+
+def delete(id):
+    from boto.manage.task import Task
+    t = Task.get_by_id(id)
+    print "Deleting task: %s" % t.name
+    if raw_input("Are you sure? ").lower() in ["y", "yes"]:
+        t.delete()
+        print "Deleted"
+    else:
+        print "Canceled"
+
+def create(name, hour, command):
+    """Create a new task
+    :param name: Name of the task to create
+    :type name: str
+    :param hour: What hour to run it at, "*" for every hour
+    :type hour: str
+    :param command: The command to execute
+    :type command: str
+    """
+    from boto.manage.task import Task
+    t = Task()
+    t.name = name
+    t.hour = hour
+    t.command = command
+    t.put()
+    print "Created task: %s" % t.id
+
+if __name__ == "__main__":
+    try:
+        import readline
+    except ImportError:
+        pass
+    import boto
+    import sys
+    from optparse import OptionParser
+    from boto.mashups.iobject import IObject
+    parser = OptionParser(version=__version__, usage=usage)
+
+    (options, args) = parser.parse_args()
+
+    if len(args) < 1:
+        parser.print_help()
+        sys.exit(1)
+
+    command = args[0].lower()
+    if command in ("ls", "list"):
+        list()
+    elif command == "get":
+        get(args[1])
+    elif command == "create":
+        create(args[1], args[2], args[3])
+    elif command == "delete":
+        delete(args[1])
diff -r 000000000000 -r 4f3585e2f14b env/bin/virtualenv
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/virtualenv	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from virtualenv.__main__ import run_with_catch
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(run_with_catch())
diff -r 000000000000 -r 4f3585e2f14b env/bin/workflow-install
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/workflow-install	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.workflow_install import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/bin/workflow-to-tools
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/bin/workflow-to-tools	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+#!/Users/cmdms/OneDrive-UOB/Development/Projects/2021/sam-consensus-v3/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from ephemeris.generate_tool_list_from_ga_workflow_files import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/PKG-INFO
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/PKG-INFO	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: CacheControl
+Version: 0.11.7
+Summary: httplib2 caching for requests
+Home-page: https://github.com/ionrock/cachecontrol
+Author: Eric Larson
+Author-email: eric@ionrock.org
+License: UNKNOWN
+Description: ==============
+         CacheControl
+        ==============
+        
+        .. image:: https://img.shields.io/pypi/v/cachecontrol.svg
+            :target: https://pypi.python.org/pypi/cachecontrol
+            :alt: Latest Version
+        
+        .. image:: https://travis-ci.org/ionrock/cachecontrol.png?branch=master
+          :target: https://travis-ci.org/ionrock/cachecontrol
+        
+        CacheControl is a port of the caching algorithms in httplib2_ for use with
+        requests_ session object.
+        
+        It was written because httplib2's better support for caching is often
+        mitigated by its lack of threadsafety. The same is true of requests in
+        terms of caching.
+        
+        
+        Quickstart
+        ==========
+        
+        .. code-block:: python
+        
+          import requests
+        
+          from cachecontrol import CacheControl
+        
+        
+          sess = requests.session()
+          cached_sess = CacheControl(sess)
+        
+          response = cached_sess.get('http://google.com')
+        
+        If the URL contains any caching based headers, it will cache the
+        result in a simple dictionary.
+        
+        For more info, check out the docs_
+        
+        .. _docs: http://cachecontrol.readthedocs.org/en/latest/
+        .. _httplib2: https://github.com/jcgregorio/httplib2
+        .. _requests: http://docs.python-requests.org/
+        
+Keywords: requests http caching web
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Topic :: Internet :: WWW/HTTP
+Provides-Extra: filecache
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/SOURCES.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/SOURCES.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,24 @@
+LICENSE.txt
+MANIFEST.in
+README.rst
+setup.cfg
+setup.py
+CacheControl.egg-info/PKG-INFO
+CacheControl.egg-info/SOURCES.txt
+CacheControl.egg-info/dependency_links.txt
+CacheControl.egg-info/entry_points.txt
+CacheControl.egg-info/requires.txt
+CacheControl.egg-info/top_level.txt
+cachecontrol/__init__.py
+cachecontrol/_cmd.py
+cachecontrol/adapter.py
+cachecontrol/cache.py
+cachecontrol/compat.py
+cachecontrol/controller.py
+cachecontrol/filewrapper.py
+cachecontrol/heuristics.py
+cachecontrol/serialize.py
+cachecontrol/wrapper.py
+cachecontrol/caches/__init__.py
+cachecontrol/caches/file_cache.py
+cachecontrol/caches/redis_cache.py
\ No newline at end of file
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/dependency_links.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/dependency_links.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/entry_points.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/entry_points.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,3 @@
+[console_scripts]
+doesitcache = cachecontrol._cmd:main
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/installed-files.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/installed-files.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,33 @@
+../../../../bin/doesitcache
+../cachecontrol/__init__.py
+../cachecontrol/__pycache__/__init__.cpython-39.pyc
+../cachecontrol/__pycache__/_cmd.cpython-39.pyc
+../cachecontrol/__pycache__/adapter.cpython-39.pyc
+../cachecontrol/__pycache__/cache.cpython-39.pyc
+../cachecontrol/__pycache__/compat.cpython-39.pyc
+../cachecontrol/__pycache__/controller.cpython-39.pyc
+../cachecontrol/__pycache__/filewrapper.cpython-39.pyc
+../cachecontrol/__pycache__/heuristics.cpython-39.pyc
+../cachecontrol/__pycache__/serialize.cpython-39.pyc
+../cachecontrol/__pycache__/wrapper.cpython-39.pyc
+../cachecontrol/_cmd.py
+../cachecontrol/adapter.py
+../cachecontrol/cache.py
+../cachecontrol/caches/__init__.py
+../cachecontrol/caches/__pycache__/__init__.cpython-39.pyc
+../cachecontrol/caches/__pycache__/file_cache.cpython-39.pyc
+../cachecontrol/caches/__pycache__/redis_cache.cpython-39.pyc
+../cachecontrol/caches/file_cache.py
+../cachecontrol/caches/redis_cache.py
+../cachecontrol/compat.py
+../cachecontrol/controller.py
+../cachecontrol/filewrapper.py
+../cachecontrol/heuristics.py
+../cachecontrol/serialize.py
+../cachecontrol/wrapper.py
+PKG-INFO
+SOURCES.txt
+dependency_links.txt
+entry_points.txt
+requires.txt
+top_level.txt
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/requires.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/requires.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,4 @@
+requests
+
+[filecache]
+lockfile>=0.9
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/CacheControl-0.11.7-py3.9.egg-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+cachecontrol
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/LICENSE.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/LICENSE.rst	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,28 @@
+Copyright 2007 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: Jinja2
+Version: 2.11.3
+Summary: A very fast and expressive template engine.
+Home-page: https://palletsprojects.com/p/jinja/
+Author: Armin Ronacher
+Author-email: armin.ronacher@active-4.com
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Documentation, https://jinja.palletsprojects.com/
+Project-URL: Code, https://github.com/pallets/jinja
+Project-URL: Issue tracker, https://github.com/pallets/jinja/issues
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+Description-Content-Type: text/x-rst
+Requires-Dist: MarkupSafe (>=0.23)
+Provides-Extra: i18n
+Requires-Dist: Babel (>=0.8) ; extra == 'i18n'
+
+Jinja
+=====
+
+Jinja is a fast, expressive, extensible templating engine. Special
+placeholders in the template allow writing code similar to Python
+syntax. Then the template is passed data to render the final document.
+
+It includes:
+
+-   Template inheritance and inclusion.
+-   Define and import macros within templates.
+-   HTML templates can use autoescaping to prevent XSS from untrusted
+    user input.
+-   A sandboxed environment can safely render untrusted templates.
+-   AsyncIO support for generating templates and calling async
+    functions.
+-   I18N support with Babel.
+-   Templates are compiled to optimized Python code just-in-time and
+    cached, or can be compiled ahead-of-time.
+-   Exceptions point to the correct line in templates to make debugging
+    easier.
+-   Extensible filters, tests, functions, and even syntax.
+
+Jinja's philosophy is that while application logic belongs in Python if
+possible, it shouldn't make the template designer's job difficult by
+restricting functionality too much.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    $ pip install -U Jinja2
+
+.. _pip: https://pip.pypa.io/en/stable/quickstart/
+
+
+In A Nutshell
+-------------
+
+.. code-block:: jinja
+
+    {% extends "base.html" %}
+    {% block title %}Members{% endblock %}
+    {% block content %}
+      <ul>
+      {% for user in users %}
+        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
+      {% endfor %}
+      </ul>
+    {% endblock %}
+
+
+Links
+-----
+
+-   Website: https://palletsprojects.com/p/jinja/
+-   Documentation: https://jinja.palletsprojects.com/
+-   Releases: https://pypi.org/project/Jinja2/
+-   Code: https://github.com/pallets/jinja
+-   Issue tracker: https://github.com/pallets/jinja/issues
+-   Test status: https://dev.azure.com/pallets/jinja/_build
+-   Official chat: https://discord.gg/t6rrQZH
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,61 @@
+Jinja2-2.11.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Jinja2-2.11.3.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
+Jinja2-2.11.3.dist-info/METADATA,sha256=PscpJ1C3RSp8xcjV3fAuTz13rKbGxmzJXnMQFH-WKhs,3535
+Jinja2-2.11.3.dist-info/RECORD,,
+Jinja2-2.11.3.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+Jinja2-2.11.3.dist-info/entry_points.txt,sha256=Qy_DkVo6Xj_zzOtmErrATe8lHZhOqdjpt3e4JJAGyi8,61
+Jinja2-2.11.3.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
+jinja2/__init__.py,sha256=LZUXmxJc2GIchfSAeMWsxCWiQYO-w1-736f2Q3I8ms8,1549
+jinja2/__pycache__/__init__.cpython-39.pyc,,
+jinja2/__pycache__/_compat.cpython-39.pyc,,
+jinja2/__pycache__/_identifier.cpython-39.pyc,,
+jinja2/__pycache__/asyncfilters.cpython-39.pyc,,
+jinja2/__pycache__/asyncsupport.cpython-39.pyc,,
+jinja2/__pycache__/bccache.cpython-39.pyc,,
+jinja2/__pycache__/compiler.cpython-39.pyc,,
+jinja2/__pycache__/constants.cpython-39.pyc,,
+jinja2/__pycache__/debug.cpython-39.pyc,,
+jinja2/__pycache__/defaults.cpython-39.pyc,,
+jinja2/__pycache__/environment.cpython-39.pyc,,
+jinja2/__pycache__/exceptions.cpython-39.pyc,,
+jinja2/__pycache__/ext.cpython-39.pyc,,
+jinja2/__pycache__/filters.cpython-39.pyc,,
+jinja2/__pycache__/idtracking.cpython-39.pyc,,
+jinja2/__pycache__/lexer.cpython-39.pyc,,
+jinja2/__pycache__/loaders.cpython-39.pyc,,
+jinja2/__pycache__/meta.cpython-39.pyc,,
+jinja2/__pycache__/nativetypes.cpython-39.pyc,,
+jinja2/__pycache__/nodes.cpython-39.pyc,,
+jinja2/__pycache__/optimizer.cpython-39.pyc,,
+jinja2/__pycache__/parser.cpython-39.pyc,,
+jinja2/__pycache__/runtime.cpython-39.pyc,,
+jinja2/__pycache__/sandbox.cpython-39.pyc,,
+jinja2/__pycache__/tests.cpython-39.pyc,,
+jinja2/__pycache__/utils.cpython-39.pyc,,
+jinja2/__pycache__/visitor.cpython-39.pyc,,
+jinja2/_compat.py,sha256=B6Se8HjnXVpzz9-vfHejn-DV2NjaVK-Iewupc5kKlu8,3191
+jinja2/_identifier.py,sha256=EdgGJKi7O1yvr4yFlvqPNEqV6M1qHyQr8Gt8GmVTKVM,1775
+jinja2/asyncfilters.py,sha256=XJtYXTxFvcJ5xwk6SaDL4S0oNnT0wPYvXBCSzc482fI,4250
+jinja2/asyncsupport.py,sha256=ZBFsDLuq3Gtji3Ia87lcyuDbqaHZJRdtShZcqwpFnSQ,7209
+jinja2/bccache.py,sha256=3Pmp4jo65M9FQuIxdxoDBbEDFwe4acDMQf77nEJfrHA,12139
+jinja2/compiler.py,sha256=Ta9W1Lit542wItAHXlDcg0sEOsFDMirCdlFPHAurg4o,66284
+jinja2/constants.py,sha256=RR1sTzNzUmKco6aZicw4JpQpJGCuPuqm1h1YmCNUEFY,1458
+jinja2/debug.py,sha256=neR7GIGGjZH3_ILJGVUYy3eLQCCaWJMXOb7o0kGInWc,8529
+jinja2/defaults.py,sha256=85B6YUUCyWPSdrSeVhcqFVuu_bHUAQXeey--FIwSeVQ,1126
+jinja2/environment.py,sha256=XDSLKc4SqNLMOwTSq3TbWEyA5WyXfuLuVD0wAVjEFwM,50629
+jinja2/exceptions.py,sha256=VjNLawcmf2ODffqVMCQK1cRmvFaUfQWF4u8ouP3QPcE,5425
+jinja2/ext.py,sha256=AtwL5O5enT_L3HR9-oBvhGyUTdGoyaqG_ICtnR_EVd4,26441
+jinja2/filters.py,sha256=9ORilsZrUoydSI9upz8_qGy7gozDWLYoFmlIBFSVRnQ,41439
+jinja2/idtracking.py,sha256=J3O4VHsrbf3wzwiBc7Cro26kHb6_5kbULeIOzocchIU,9211
+jinja2/lexer.py,sha256=nUFLRKhhKmmEWkLI65nQePgcQs7qsRdjVYZETMt_v0g,30331
+jinja2/loaders.py,sha256=C-fST_dmFjgWkp0ZuCkrgICAoOsoSIF28wfAFink0oU,17666
+jinja2/meta.py,sha256=QjyYhfNRD3QCXjBJpiPl9KgkEkGXJbAkCUq4-Ur10EQ,4131
+jinja2/nativetypes.py,sha256=Ul__gtVw4xH-0qvUvnCNHedQeNDwmEuyLJztzzSPeRg,2753
+jinja2/nodes.py,sha256=Mk1oJPVgIjnQw9WOqILvcu3rLepcFZ0ahxQm2mbwDwc,31095
+jinja2/optimizer.py,sha256=gQLlMYzvQhluhzmAIFA1tXS0cwgWYOjprN-gTRcHVsc,1457
+jinja2/parser.py,sha256=fcfdqePNTNyvosIvczbytVA332qpsURvYnCGcjDHSkA,35660
+jinja2/runtime.py,sha256=0y-BRyIEZ9ltByL2Id6GpHe1oDRQAwNeQvI0SKobNMw,30618
+jinja2/sandbox.py,sha256=knayyUvXsZ-F0mk15mO2-ehK9gsw04UhB8td-iUOtLc,17127
+jinja2/tests.py,sha256=iO_Y-9Vo60zrVe1lMpSl5sKHqAxe2leZHC08OoZ8K24,4799
+jinja2/utils.py,sha256=Wy4yC3IByqUWwnKln6SdaixdzgK74P6F5nf-gQZrYnU,22436
+jinja2/visitor.py,sha256=DUHupl0a4PGp7nxRtZFttUzAi1ccxzqc2hzetPYUz8U,3240
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/entry_points.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/entry_points.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,3 @@
+[babel.extractors]
+jinja2 = jinja2.ext:babel_extract [i18n]
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Jinja2-2.11.3.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+jinja2
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,28 @@
+Copyright 2010 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,94 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 1.1.1
+Summary: Safely add untrusted strings to HTML/XML markup.
+Home-page: https://palletsprojects.com/p/markupsafe/
+Author: Armin Ronacher
+Author-email: armin.ronacher@active-4.com
+Maintainer: The Pallets Team
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Code, https://github.com/pallets/markupsafe
+Project-URL: Issue tracker, https://github.com/pallets/markupsafe/issues
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*
+Description-Content-Type: text/x-rst
+
+MarkupSafe
+==========
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    pip install -U MarkupSafe
+
+.. _pip: https://pip.pypa.io/en/stable/quickstart/
+
+
+Examples
+--------
+
+.. code-block:: pycon
+
+    >>> from markupsafe import Markup, escape
+    >>> # escape replaces special characters and wraps in Markup
+    >>> escape('<script>alert(document.cookie);</script>')
+    Markup(u'&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+    >>> # wrap in Markup to mark text "safe" and prevent escaping
+    >>> Markup('<strong>Hello</strong>')
+    Markup('<strong>hello</strong>')
+    >>> escape(Markup('<strong>Hello</strong>'))
+    Markup('<strong>hello</strong>')
+    >>> # Markup is a text subclass (str on Python 3, unicode on Python 2)
+    >>> # methods and operators escape their arguments
+    >>> template = Markup("Hello <em>%s</em>")
+    >>> template % '"World"'
+    Markup('Hello <em>&#34;World&#34;</em>')
+
+
+Donate
+------
+
+The Pallets organization develops and supports MarkupSafe and other
+libraries that use it. In order to grow the community of contributors
+and users, and allow the maintainers to devote more time to the
+projects, `please donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+*   Website: https://palletsprojects.com/p/markupsafe/
+*   Documentation: https://markupsafe.palletsprojects.com/
+*   Releases: https://pypi.org/project/MarkupSafe/
+*   Code: https://github.com/pallets/markupsafe
+*   Issue tracker: https://github.com/pallets/markupsafe/issues
+*   Test status: https://dev.azure.com/pallets/markupsafe/_build
+*   Official chat: https://discord.gg/t6rrQZH
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,16 @@
+MarkupSafe-1.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+MarkupSafe-1.1.1.dist-info/LICENSE.rst,sha256=SJqOEQhQntmKN7uYPhHg9-HTHwvY-Zp5yESOf_N9B-o,1475
+MarkupSafe-1.1.1.dist-info/METADATA,sha256=-XXnVvCxQP2QbHutIQq_7Pk9OATy-x0NC7gN_3_SCRE,3167
+MarkupSafe-1.1.1.dist-info/RECORD,,
+MarkupSafe-1.1.1.dist-info/WHEEL,sha256=bRe_g_g-vZInZP5wOdewl-4AeWx8E2_UC3Ffr2csPyk,109
+MarkupSafe-1.1.1.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
+markupsafe/__init__.py,sha256=oTblO5f9KFM-pvnq9bB0HgElnqkJyqHnFN1Nx2NIvnY,10126
+markupsafe/__pycache__/__init__.cpython-39.pyc,,
+markupsafe/__pycache__/_compat.cpython-39.pyc,,
+markupsafe/__pycache__/_constants.cpython-39.pyc,,
+markupsafe/__pycache__/_native.cpython-39.pyc,,
+markupsafe/_compat.py,sha256=uEW1ybxEjfxIiuTbRRaJpHsPFf4yQUMMKaPgYEC5XbU,558
+markupsafe/_constants.py,sha256=zo2ajfScG-l1Sb_52EP3MlDCqO7Y1BVHUXXKRsVDRNk,4690
+markupsafe/_native.py,sha256=d-8S_zzYt2y512xYcuSxq0NeG2DUUvG80wVdTn-4KI8,1873
+markupsafe/_speedups.c,sha256=k0fzEIK3CP6MmMqeY0ob43TP90mVN0DTyn7BAl3RqSg,9884
+markupsafe/_speedups.cpython-39-darwin.so,sha256=6pV4w38f3OduU0ZOZKLTJSqTak4UPPIW_FkIrMdXpJE,35224
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+markupsafe
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/LICENSE
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/LICENSE	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,20 @@
+Copyright (c) 2017-2021 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 5.4.1
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Download-URL: https://pypi.org/project/PyYAML/
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,60 @@
+PyYAML-5.4.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyYAML-5.4.1.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-5.4.1.dist-info/METADATA,sha256=XnrM5LY-uS85ica26gKUK0dGG-xmPjmGfDTSLpIHQFk,2087
+PyYAML-5.4.1.dist-info/RECORD,,
+PyYAML-5.4.1.dist-info/WHEEL,sha256=bRe_g_g-vZInZP5wOdewl-4AeWx8E2_UC3Ffr2csPyk,109
+PyYAML-5.4.1.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+_yaml/__pycache__/__init__.cpython-39.pyc,,
+yaml/__init__.py,sha256=gfp2CbRVhzknghkiiJD2l6Z0pI-mv_iZHPSJ4aj0-nY,13170
+yaml/__pycache__/__init__.cpython-39.pyc,,
+yaml/__pycache__/__init__.cpython-39.pyc,sha256=X88WKfrAE5fIr0H7hRLa95JDu8P_aRlbz5VM-kuUGUs,11863
+yaml/__pycache__/composer.cpython-39.pyc,,
+yaml/__pycache__/composer.cpython-39.pyc,sha256=-rGk3Kor5pFxwqWVw0LNcM9_UAf_GfHTcizdG_hUpt0,3557
+yaml/__pycache__/constructor.cpython-39.pyc,,
+yaml/__pycache__/constructor.cpython-39.pyc,sha256=-kbjmUKQhdsXYd1ssqgrFz36HJD89lH9QVlFYB9Ysjo,20804
+yaml/__pycache__/cyaml.cpython-39.pyc,,
+yaml/__pycache__/cyaml.cpython-39.pyc,sha256=M5YXVIjWPq-T25HjRzx2DmiW8I311HXnL2zMuOF01qU,3347
+yaml/__pycache__/dumper.cpython-39.pyc,,
+yaml/__pycache__/dumper.cpython-39.pyc,sha256=dAvDYQ2k7zDCKFVpQ5m_EyMWFCJuO7tQ1RZvUB-yaw8,1766
+yaml/__pycache__/emitter.cpython-39.pyc,,
+yaml/__pycache__/emitter.cpython-39.pyc,sha256=mxOLyekb_du-qz6ABjMCMyIhyiD-KPMa47SLHWKEi9M,25337
+yaml/__pycache__/error.cpython-39.pyc,,
+yaml/__pycache__/error.cpython-39.pyc,sha256=4EfYGIgytR8JQJd1HfziVQpdMquHdikg54Q9RaRU-VI,2317
+yaml/__pycache__/events.cpython-39.pyc,,
+yaml/__pycache__/events.cpython-39.pyc,sha256=Ou8wWpg3KCrCtz9i5l2CCxzsE-9Q9D_rQ9R5ovDfLZk,3970
+yaml/__pycache__/loader.cpython-39.pyc,,
+yaml/__pycache__/loader.cpython-39.pyc,sha256=TofT3-AAUOz1WftW5j63BdV_l46P8mrfuRKpQrrusU8,2191
+yaml/__pycache__/nodes.cpython-39.pyc,,
+yaml/__pycache__/nodes.cpython-39.pyc,sha256=HiZzpvRY7qoJDteq9-GK8q66jzk4EMMF9IeUMeBxyeM,1723
+yaml/__pycache__/parser.cpython-39.pyc,,
+yaml/__pycache__/parser.cpython-39.pyc,sha256=qVXCLueOw6VpLWtAgxHYnjyj375tT3vrENtaNty3yeE,11862
+yaml/__pycache__/reader.cpython-39.pyc,,
+yaml/__pycache__/reader.cpython-39.pyc,sha256=jR4LGF7ylWwrxyQZ7AJAd_p5u9H08SOcqP59y5nBiBQ,4529
+yaml/__pycache__/representer.cpython-39.pyc,,
+yaml/__pycache__/representer.cpython-39.pyc,sha256=gAx36SwKedpxb7qiN9OBKld9pZOQTs233XVDTKTTYkQ,10079
+yaml/__pycache__/resolver.cpython-39.pyc,,
+yaml/__pycache__/resolver.cpython-39.pyc,sha256=NBDIM6eqL1xPTtmJwoGuvhFR1WFSUrBpXO2a5E6p6VY,5500
+yaml/__pycache__/scanner.cpython-39.pyc,,
+yaml/__pycache__/scanner.cpython-39.pyc,sha256=yyaD6plHDNW49-RLT2NHBSFfw0pJGizoL1332irs_7Q,25247
+yaml/__pycache__/serializer.cpython-39.pyc,,
+yaml/__pycache__/serializer.cpython-39.pyc,sha256=phOsn3Czz0or6yqVgiyy9RkWbbBEHp9P83dHOrD9OnU,3318
+yaml/__pycache__/tokens.cpython-39.pyc,,
+yaml/__pycache__/tokens.cpython-39.pyc,sha256=er5RIfoFs-jnKy-xqj4Eb2ioKS-pYGTkO_eet5glZG0,4939
+yaml/_yaml.cpython-39-darwin.so,sha256=r6Nyi2WlBIUD8aiRPOT4xp8bFr42DY5SAT-O55v3Nus,465184
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/representer.py,sha256=82UM3ZxUQKqsKAF4ltWOxCS6jGPIFtXpGs7mvqyv4Xs,14184
+yaml/resolver.py,sha256=Z1W8AOMA6Proy4gIO2OhUO4IPS_bFNAl0Ca3rwChpPg,8999
+yaml/scanner.py,sha256=KeQIKGNlSyPE8QDwionHxy9CgbqE5teJEz05FR9-nAg,51277
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/PyYAML-5.4.1.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,2 @@
+_yaml
+yaml
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/LICENSE.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/LICENSE.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,19 @@
+Copyright (c) 2005-2016 Ben Bangert <ben@groovie.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,537 @@
+Metadata-Version: 2.1
+Name: Routes
+Version: 2.5.1
+Summary: Routing Recognition and Generation Tools
+Home-page: https://routes.readthedocs.io/
+Author: Ben Bangert
+Author-email: ben@groovie.org
+License: MIT
+Keywords: routes webob dispatch
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: six
+Requires-Dist: repoze.lru (>=0.3)
+Provides-Extra: docs
+Requires-Dist: Sphinx ; extra == 'docs'
+Requires-Dist: webob ; extra == 'docs'
+Provides-Extra: middleware
+Requires-Dist: webob ; extra == 'middleware'
+
+Routes is a Python re-implementation of the Rails routes system for mapping
+URL's to Controllers/Actions and generating URL's. Routes makes it easy to
+create pretty and concise URL's that are RESTful with little effort.
+
+Speedy and dynamic URL generation means you get a URL with minimal cruft
+(no big dangling query args). Shortcut features like Named Routes cut down
+on repetitive typing.
+
+See `the documentation for installation and usage of Routes <http://readthedocs.org/docs/routes/en/latest/>`_.
+
+
+Routes Changelog
+%%%%%%%%%%%%%%%%
+
+Release 2.5.1 (October 13, 2020)
+================================
+* Add compatibility for Python 3.7+. PR #99.
+
+Release 2.5.0 (October 13, 2020)
+================================
+
+* Add graceful fallback for invalid character encoding from request object. Patch by Phillip Baker.
+  PR #94.
+* Enhanced performance for matching routes that share the same static prefix. Patch by George Sakkis.
+  PR #89.
+* Fixed issue with child routes not passing route conditions to the Mapper.connect call. Patch by
+  Robin Abbi. PR #88.
+* Fixed documentation to reflect default value for minimization. Patch by Marcin Raczyński. PR #86.
+* Allow backslash to escape special characters in route paths. Patch by Orhan KavrakoÄŸlu. PR #83.
+* Resolve invalid escape sequences. Patch by Stephen Finucane. PR #85.
+* Remove support for Python 2.6, 3.3, and 3.4. Patch by Stephen Finucane. PR #85.
+* Remove obsolete Python 2.3 compat code. Patch by Jakub Wilk. PR #80.
+
+Release 2.4.1 (January 1, 2017)
+===============================
+
+* Release as a universal wheel. PR #75.
+* Convert readthedocs links for their .org -> .io migration for hosted projects. PR #67.
+
+Release 2.3.1 (March 30, 2016)
+==============================
+* Backwards compatability fix - connect should work with mandatory
+  routename and optional path. Patch by Davanum Srinivas (PR #65).
+
+Release 2.3 (March 28, 2016)
+============================
+* Fix sub_domain equivalence check. Patch by Nikita Uvarov
+* Add support for protocol-relative URLs generation (i.e. starting with double
+  slash ``//``). PR #60. Patch by Sviatoslav Sydorenko.
+* Add support for the ``middleware`` extra requirement, making possible to
+  depend on ``webob`` optionally. PR #59. Patch by Sviatoslav Sydorenko.
+* Fix matching of an empty string route, which led to exception in earlier
+  versions. PR #58. Patch by Sviatoslav Sydorenko.
+* Add support for the ``requirements`` option when using
+  mapper.resource to create routes. PR #57. Patch by Sean Dague.
+* Concatenation fix when using submappers with path prefixes. Multiple
+  submappers combined the path prefix inside the controller argument in
+  non-obvious ways. The controller argument will now be properly carried
+  through when using submappers. PR #28.
+
+Release 2.2 (July 21, 2015)
+===========================
+* Fix Python 3 support. Patch by Victor Stinner.
+
+Release 2.1 (January 17, 2015)
+==============================
+* Fix 3 other route matching groups in route.py to use anonymous groups for
+  optional sections to avoid exceeding regex limits. Fixes #15.
+* Printing a mapper now includes the Controller/action parameters from the
+  route. Fixes #11.
+* Fix regression that didn't allow passing in params 'host', 'protocol', or
+  'anchor'. They can now be passed in with a trailing '_' as was possible
+  before commit d1d1742903fa5ca24ef848a6ae895303f2661b2a. Fixes #7.
+* URL generation with/without SCRIPT_NAME was resulting in the URL cache
+  failing to return the appropriate cached URL generation. The URL cache
+  should always include the SCRIPT_NAME, even if its empty, in the cache
+  to avoid this, and now does. Fixes #6.
+* Extract Route creation into separate method in Mapper.  Subclasses of Route
+  can be created by Mappers now.
+* Use the first X_FORWARDED_FOR value if there are multiple proxies in the
+  path. Fixes #5.
+
+Release 2.0 (November 17, 2013)
+===============================
+* Python 3.2/3.3 Support. Fixes Issue #2. Thanks to Alejandro Sánchez for
+  the pull request!
+
+Release 1.13 (March 12, 2012)
+=============================
+* Fix bug with dots forcing extension by default. The portion with the dot can
+  now be recognized. Patch by Michael Basnight.
+
+Release 1.12.3 (June 5, 2010)
+=============================
+* Fix bug with URLGenerator not properly including SCRIPT_NAME when generating
+  URL's and the singleton is not present.
+
+Release 1.12.2 (May 5, 2010)
+============================
+* Fix bug with routes URLGenerator not properly including SCRIPT_NAME when
+  generating qualified URL's.
+
+Release 1.12.1 (March 11, 2010)
+===============================
+* Fix bug with routes not generating URL's with callables in defaults.
+* Fix bug with routes not handling sub-domain defaults during generation.
+
+Release 1.12 (February 28, 2010)
+================================
+* Split up the Routes docs.
+* Fix bug with relative URL's using qualified merging host and URL without
+  including the appropriate slash. Fixes #13.
+* Fix bug with mapper.extend and Routes modifying their original args.
+  Fixes #24.
+* Fix url.current() not returning current args when explicit is True.
+* Added explicit way to directly use the Mapper to match with environ.
+* Fix bug with improper len placement for submapper.
+* Adding regular expression builder for entire regexp for faster rejection
+  in a single regexp match should none of the routes match.
+* Give Mapper a tabular string representation.
+* Make SubMapper objects nestable and add route-generation helpers.
+* Add SubMapper-based collections.
+* Make the deprecated Mapper.minimization False (disabled) by default.
+* Make the mapper explicit (true) by default.
+
+Release 1.11 (September 28, 2009)
+=================================
+* Extensive documentation rewrite.
+* Added Mapper.extend function that allows one to add lists of Routes objects
+  to the mapper in one batch, optionally with a path_prefix.
+* Added Mapper.submapper function that returns a SubMapper object to enable
+  easier declaration of routes that have multiple keyword argument options
+  in common.
+* Mapper controller_scan argument now handles None, and lists of controller
+  names in addition to a callable.
+* Route object now takes a name parameter, which is the name it responds to.
+  This name is automatically added when called by using Mapper's connect
+  class method.
+* Added optional LRU object for use with Routes when URL's change too often
+  for the Routes urlcache dict to be a viable option.
+
+Release 1.10.3 (February 8, 2009)
+=================================
+* Tweak to use WebOb Request rather than Paste.
+* Performance tweaks for URL recognition.
+* Bugfix for routes.middleware not re.escaping the path_info before moving it
+  to the script name.
+
+Release 1.10.2 (January 11, 2009)
+=================================
+* Bugfix for unicode encoding problems with non-minimized Route generation.
+  Spotted by Wichert Akkerman.
+* Bugfix for when environ is {} in unit tests.
+
+Release 1.10.1 (September 27, 2008)
+===================================
+* Removing LRU cache due to performance and threading issues. Cache does hit
+  a max-size for the given routes.
+
+Release 1.10 (September 24, 2008)
+=================================
+* Adding LRU cache instead of just dict for caching generated routes. This
+  avoids slow memory leakage over long-running and non-existent route
+  generation.
+* Adding URLGenerator object.
+* Adding redirect routes.
+* Static routes can now interpolate variable parts in the path if using {}
+  variable part syntax.
+* Added sub_domain condition option to accept False or None, to require that
+  there be no sub-domain provided for the route to match.
+
+Release 1.9.2 (July 8, 2008)
+============================
+* Fixed bug in url_for which caused it to return a literal when it shouldn't
+  have.
+
+Release 1.9.1 (June 28, 2008)
+=============================
+* Fixed bug in formatted route recognition with formatting being absorbed
+  into the id.
+
+Release 1.9 (June 12, 2008)
+===========================
+* Fix undefined arg bug in url_for.
+* Fixed bug with url_for not working properly outside of a request when
+  sub-domains are active. Thanks Pavel Skvazh.
+* Add non-minimization option to Routes and the Mapper for generation and
+  recognition.
+* Add Routes 2.0 style syntax for making routes and regexp. For example, this
+  route will now work: '{controller}/{action}/{id}'.
+* Fixed Routes to not use quote_plus when making URL's.
+* WARNING: Mapper now comes with hardcode_names set to True by default. This
+  means routes generated by name must work for the URL.
+* Actually respect having urlcache disabled.
+* WARNING: Calling url_for with a set of args that returns None now throws an
+  exception. Code that previously checked to see if a url could be made must
+  be updated accordingly.
+* Updated url_for to return url in a literal for use in templating that may
+  try to escape it again.
+* Added option to use X_FORWARDED_PROTO for proxying behind https to work
+  easier.
+* Fixed map.resource to be less restrictive on id than just spaces.
+* Fixed Mapper.create_regs not being thread safe, particularly when
+  always_scan=True.
+
+Release 1.8 (March 28, 2008)
+============================
+* Fixed bug of map.resource not allowing spaces in id.
+* Fixed url generation to properly handle unicode defaults in addition to
+  unicode arguments.
+* Fixed url_for to handle lists as keyword args when generating query
+  parameters.
+* WARNING: Changed map.resource to not use ';', for actions, but the
+  normal '/'. This means that formatted URL's will also now have the format
+  come AFTER the action. Ie: /messsages/4.xml;rss -> /messages/4/rss.xml
+
+Release 1.7.3 (May 28th, 2008)
+==============================
+* Fixed triple escaping bug, since WSGI servers are responsible for basic
+  unescaping.
+
+Release 1.7.2 (Feb. 27th, 2008)
+===============================
+* Fixed bug with keyword args not being coerced to raw string properly.
+
+Release 1.7.1 (Nov. 16th, 2007)
+===============================
+* Fixed bug with sub-domains from route defaults getting encoded to unicode
+  resulting in a unicode route which then caused url_for to throw an
+  exception.
+* Removed duplicate assignment in map.resource. Patch by Mike Naberezny.
+* Applied test patch fix for path checking. Thanks Mike Naberezny.
+* Added additional checking of remaining URL, to properly swallow periods in
+  the appropriate context. Fixes #57.
+* Added mapper.hardcode_names option which restricts url generation to the
+  named route during generation rather than using the routes default options
+  during generation.
+* Fixed the special '_method' attribute not being recognized during POST
+  requests of Content-Type 'multipart/form-data'.
+
+Release 1.7 (June 8th, 2007)
+============================
+* Fixed url_unquoting to only apply for strings.
+* Added _encoding option to individual routes to toggle decoding/encoding on a
+  per route basis.
+* Fixed route matching so that '.' and other special chars are only part of the
+  match should they not be followed by that character. Fixed regexp creation so
+  that route parts with '.' in them aren't matched properly. Fixes #48.
+* Fixed Unicode decoding/encoding so that the URL decoding and encoding can be
+  set on the mapper with mapper.encoding. Fixes #40.
+* Don't assume environ['CONTENT_TYPE'] always exists: it may be omitted
+  according to the WSGI PEP.
+* Fixed Unicode decode/encoding of path_info dynamic/wildcard parts so that
+  PATH_INFO will stay a raw string as it should. Fixes #51.
+* Fixed url_for (thus redirect_to) to throw an exception if a Unicode
+  string is returned as that's an invalid URL. Fixes #46.
+* Fixed Routes middleware to only parse POST's if the content type is
+  application/x-www-form-urlencoded for a HTML form. This properly avoids
+  parsing wsgi.input when it doesn't need to be.
+
+Release 1.6.3 (April 10th, 2007)
+================================
+* Fixed matching so that an attempt to match an empty path raises a
+  RouteException. Fixes #44.
+* Added ability to use characters in URL's such as '-' and '_' in
+  map.resource. Patch by Wyatt Baldwin. Fixes #45.
+* Updated Mapper.resource handling with name_prefix and path_prefix checking
+  to specify defaults. Also ensures that should either of them be set, they
+  override the prefixes should parent_resource be specified. Patch by Wyatt
+  Baldwin. Fixes #42.
+* Added utf-8 decoding of incoming path arguments, with fallback to ignoring
+  them in the very rare cases a malformed request URL is sent. Patch from
+  David Smith.
+* Fixed treatment of '#' character as something that can be left off and
+  used in route paths. Found by Mike Orr.
+* Added ability to specify parent resource to map.resource command. Patch from
+  Wyatt Baldwin.
+* Fixed formatted route issue with map.resource when additional collection
+  methods are specified. Added unit tests to verify the collection methods
+  work properly.
+* Updated URL parsing to properly use HTTP_HOST for hostname + port info before
+  falling back to SERVER_PORT and SERVER_NAME. Fixes #43.
+* Added member_name and collection_name setting to Route object when made with
+  map.resource.
+* Updated routes.middleware to make the Routes matched accessible as
+  environ['routes.route'].
+* Updating mapper object to use thread local for request data (such as
+  environ) and middleware now deletes environ references at the end of the
+  request.
+* Added explicit option to Routes and Mapper. Routes _explicit setting will
+  prevent the Route defaults from being implicitly set, while setting Mapper
+  to explicit will prevent Route implicit defaults and stop url_for from using
+  Route memory. Fixes #38.
+* Updated config object so that the route is attached if possible.
+* Adding standard logging usage with debug messages.
+* Added additional test for normal '.' match and fixed new special matching to
+  match it properly. Thanks David Smith.
+* Fixed hanging special char issue with 'special' URL chars at the end of a URL
+  that are missing the variable afterwards.
+* Changed Routes generation and recognition to handle other 'special' URL chars
+  , . and ; as if they were /. This lets them be optionally left out of the
+  resulting generated URL. Feature requested by David Smith.
+* Fixed lookahead assertion in regexp builder to properly handle two grouped
+  patterns in a row.
+* Applied patch to generation and matching to handle Unicode characters
+  properly. Reported with patch by David Smith.
+
+Release 1.6.2 (Jan. 5, 2007)
+============================
+* Fixed issue with method checking not properly handling different letter
+  cases in REQUEST_METHOD. Reported by Sean Davis.
+* redirect_to now supports config.redirect returning a redirect, not just
+  raising one.
+
+Release 1.6.1 (Dec. 29, 2006)
+=============================
+* Fixed zipsafe flag to be False.
+
+Release 1.6 (Dec. 14th, 2006)
+=============================
+* Fixed append_slash to take effect in the route generation itself instead of
+  relying on url_for function. Reported by ToddG.
+* Added additional url_for tests to ensure map.resource generates proper named
+  routes.
+* WARNING: Changed map.resource initialization to accept individual member and
+  collection names to generate proper singular and plural route names. Those
+  using map.resource will need to update their routes and url_for statements
+  accordingly.
+* Added additional map.resource recognition tests.
+* Added WSGI middleware that does route resolving using new `WSGI.org Routing
+  Vars Spec <http://wsgi.org/wsgi/Specifications/routing_args>`_.
+* Added _absolute keyword option route connect to ignore SCRIPT_NAME settings.
+  Suggested by Ian Bicking.
+
+Release 1.5.2 (Oct. 16th, 2006)
+===============================
+* Fixed qualified keyword to keep host port names when used, unless a host
+  is specifically passed in. Reported by Jon Rosebaugh.
+* Added qualified keyword option to url_for to have it generate a full
+  URL. Resolves #29.
+* Fixed examples in url_for doc strings so they'll be accurate.
+
+Release 1.5.1 (Oct. 4th, 2006)
+==============================
+* Fixed bug with escaping part names in the regular expression, reported by
+  James Taylor.
+
+Release 1.5 (Sept. 19th, 2006)
+==============================
+* Significant updates to map.resource and unit tests that comb it thoroughly
+  to ensure its creating all the proper routes (it now is). Increased unit
+  testing coverage to 95%.
+* Added unit tests to ensure controller_scan works properly with nested
+  controller files and appropriately scans the directory structure. This
+  brings the Routes util module up to full code coverage.
+* Fixed url_for so that when the protocol is changed, port information is
+  removed from the host.
+* Added more thorough testing to _RequestConfig object and the ability to
+  set your own object. This increases testing coverage of the __init__ module
+  to 100%.
+* Fixed bug with sub_domain not maintaining port information in url_for and
+  added unit tests. Reported by Jonathan Rosebaugh.
+* Added unit tests to ensure sub_domain option works with named routes, cleaned
+  up url_for memory argument filtering. Fixed bug with named routes and sub_domain
+  option not working together, reported by Jonathan Rosebaugh.
+* Changed order in which sub-domain is added to match-dict so it can be used
+  in a conditions function.
+
+Release 1.4.1 (Sept. 6th, 2006)
+===============================
+* Added sub_domains option to mapper, along with sub_domains_ignore list for
+  subdomains that are considered equivilant to the main domain. When sub_domains
+  is active, url_for will now take a sub_domain option that can alter the host
+  the route will go to.
+* Added ability for filter functions to provide a _host, _protocol, _anchor arg
+  which is then used to create the URL with the appropriate host/protocol/anchor
+  destination.
+* Patch applied from Ticket #28. Resolves issue with Mapper's controller_scan
+  function requiring a valid directory argument. Submitted by Zoran Isailovski.
+
+Release 1.4 (July 21, 2006)
+===========================
+* Fixed bug with map.resource related to member methods, found in Rails version.
+* Fixed bug with map.resource member methods not requiring a member id.
+* Fixed bug related to handling keyword argument controller.
+* Added map.resource command which can automatically generate a batch of routes intended
+  to be used in a REST-ful manner by a web framework.
+* Added URL generation handling for a 'method' argument. If 'method' is specified, it
+  is not dropped and will be changed to '_method' for use by the framework.
+* Added conditions option to map.connect. Accepts a dict with optional keyword args
+  'method' or 'function'. Method is a list of HTTP methods that are valid for the route.
+  Function is a function that will be called with environ, matchdict where matchdict is
+  the dict created by the URL match.
+* Fixed redirect_to function for using absolute URL's. redirect_to now passes all args to
+  url_for, then passes the resulting URL to the redirect function. Reported by climbus.
+
+Release 1.3.2 (April 30th, 2006)
+================================
+* Fixed _filter bug with inclusion in match dict during matching, reported by David Creemer.
+* Fixed improper url quoting by using urllib.encode, patch by Jason Culverhouse.
+
+Release 1.3.1 (April 4th, 2006)
+===============================
+* Mapper has an optional attribute ``append_slash``. When set to ``True``, any URL's
+  generated will have a slash appended to the end.
+* Fixed prefix option so that if the PATH_INFO is empty after prefix regexp, its set to
+  '/' so the match proceeds ok.
+* Fixed prefix bug that caused routes after the initial one to not see the proper url
+  for matching. Caught by Jochen Kupperschmidt.
+
+Release 1.3 (Feb. 25th, 2006)
+=============================
+* url_for keyword filters:
+  Named routes can now have a _filter argument that should specify a function that takes
+  a dict as its sole argument. The dict will contain the full set of keywords passed to
+  url_for, which the function can then modify as it pleases. The new dict will then be
+  used as if it was the original set of keyword args given to url_for.
+* Fixed Python 2.3 incompatibility due to using keyword arg for a sort statement
+  when using the built-in controller scanner.
+
+Release 1.2 (Feb. 17th, 2006)
+=============================
+* If a named route doesn't exist, and a url_for call is used, instead of using the
+  keyword arguments to generate a URL, they will be used as query args for the raw
+  URL supplied. (Backwards Incompatible)
+* If Mapper has debug=True, using match will return two additional values, the route
+  that matched, if one did match. And a list of routes that were tried, and information
+  about why they didn't pass.
+* url_for enhancements:
+  Can now be used with 'raw' URL's to generate proper url's for static content that
+  will then automatically include SCRIPT_NAME if necessary
+  Static named routes can now be used to shortcut common path information as desired.
+* Controller Scanner will now sort controller names so that the longest one is first. This
+  ensures that the deepest nested controller is executed first before more shallow ones to
+  increase predictability.
+* Controller Scanner now scans directories properly, the version in 1.1 left off the
+  directory prefix when created the list of controllers.
+  (Thanks to Justin for drawing my attention to it)
+
+Release 1.1 (Jan. 13th, 2006)
+=============================
+* Routes Mapper additions:
+  Now takes several optional arguments that determine how it will
+  generate the regexp's.
+  Can now hold a function for use when determining what the available
+  controllers are. Comes with a default directory scanner
+  Given a directory for the default scanner or a function, the Mapper
+  will now automatically run it to get the controller list when needed
+* Syntax available for splitting routes to allow more complex route paths, such
+  as ':controller/:(action)-:(id).html'
+* Easier setup/integration with Routes per request. Setting the environ in a
+  WSGI environ will run match, and setup everything needed for url_for/etc.
+
+Release 1.0.2 (Dec. 30th, 2005)
+===============================
+* Routes where a default was present but None were filling in improper values.
+* Passing a 0 would evaluate to None during generation, resulting in missing
+  URL parts
+
+Release 1.0.1 (Dec. 18th, 2005)
+===============================
+* Request Local Callable - You can now designate your own callable function that
+  should then be used to store the request_config data. This is most useful for
+  environments where its possible multiple requests might be running in a single
+  thread. The callable should return a request specific object for attributes to
+  be attached. See routes.__init__.py for more information.
+
+Release 1.0 (Nov. 21st, 2005)
+=============================
+* routes.__init__ will now load the common symbols most people will
+  want to actually use.
+  Thus, you can either::
+
+       from routes import *
+
+  Or::
+
+       from routes import request_config, Mapper
+
+  The following names are available for importing from routes::
+
+      request_config, Mapper, url_for, redirect_to
+
+* Route Names - You can now name a route, which will save a copy of the defaults
+  defined for later use by url_for or redirect_to.
+  Thus, a route and url_for looking like this::
+
+       m.connect('home', controller='blog', action='splash')
+       url_for(controller='blog', action='splash')   # => /home
+
+  Can now be used with a name::
+
+       m.connect('home_url','home', controller='blog', action='splash')
+       url_for('home_url')  # => /home
+
+  Additional keywords can still be added to url_for and will override defaults in
+  the named route.
+* Trailing / - Route recognition earlier failed on trailing slashes, not really a bug,
+  not really a feature I guess. Anyways, trailing slashes are o.k. now as in the Rails
+  version.
+* redirect_to now has two sets of tests to ensure it works properly
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,18 @@
+Routes-2.5.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Routes-2.5.1.dist-info/LICENSE.txt,sha256=JkhQv9ruOaVLZglLvNhsDeZrmr0lmPAgvdmNOeMmUAk,1078
+Routes-2.5.1.dist-info/METADATA,sha256=TzH1mWlM9kl0_X7Uxm2Xq9BzSYmjrPVZynPpr2uguWw,25346
+Routes-2.5.1.dist-info/RECORD,,
+Routes-2.5.1.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+Routes-2.5.1.dist-info/top_level.txt,sha256=X0IsYfGZPW6lNH8wyJiaSyH7PrsKbBUZaUOgwdt4V6Q,7
+routes/__init__.py,sha256=rrpWr0110dQks26SvtCh6OeS7s5jFnvZTEtZ7BuS-Rg,5541
+routes/__pycache__/__init__.cpython-39.pyc,,
+routes/__pycache__/base.cpython-39.pyc,,
+routes/__pycache__/mapper.cpython-39.pyc,,
+routes/__pycache__/middleware.cpython-39.pyc,,
+routes/__pycache__/route.cpython-39.pyc,,
+routes/__pycache__/util.cpython-39.pyc,,
+routes/base.py,sha256=deoEwjOZqQfaoonw1q0_J7Bcnr6V5_xr044Jjo9hUm8,134
+routes/mapper.py,sha256=q5hMFknLcJUHB-QW2kJl87qHyWpDP2czuFHvX2e4gMs,50137
+routes/middleware.py,sha256=JVRiBQz8HjHE1OCWcfBQroPEE2lSGgq8Z4ylaNodqtM,6497
+routes/route.py,sha256=x64PzEo8kRz--34G4tGnrydRUOhC_sc7dChpjKq0an4,29723
+routes/util.py,sha256=SrPTZ3PJrK3drS8k228d2gQWQNcAVeAUJnU8IK_hzbE,19897
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/Routes-2.5.1.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+routes
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/allure.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/allure.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/appdirs.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/appdirs.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/bagit.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/bagit.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/configparser.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/configparser.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/decorator.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/decorator.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/dot_parser.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/dot_parser.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/filelock.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/filelock.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/mistune.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/mistune.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/mypy_extensions.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/mypy_extensions.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/oyaml.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/oyaml.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/pydot.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/pydot.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/pyparsing.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/pyparsing.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/six.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/six.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/tabulate.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/tabulate.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/__pycache__/typing_extensions.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/__pycache__/typing_extensions.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/_distutils_hack/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/_distutils_hack/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,123 @@
+import sys
+import os
+import re
+import importlib
+import warnings
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils.")
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [name for name in sys.modules if re.match(r'distutils\b', name)]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'stdlib')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    clear_distutils()
+    distutils = importlib.import_module('setuptools._distutils')
+    distutils.__name__ = 'distutils'
+    sys.modules['distutils'] = distutils
+
+    # sanity check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        if path is not None:
+            return
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        import importlib.abc
+        import importlib.util
+
+        class DistutilsLoader(importlib.abc.Loader):
+
+            def create_module(self, spec):
+                return importlib.import_module('setuptools._distutils')
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader('distutils', DistutilsLoader())
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @staticmethod
+    def pip_imported_during_build():
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+        return any(
+            frame.f_globals['__file__'].endswith('setup.py')
+            for frame, line in traceback.walk_stack(None)
+        )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/_distutils_hack/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/_distutils_hack/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/_distutils_hack/__pycache__/override.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/_distutils_hack/__pycache__/override.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/_distutils_hack/override.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/_distutils_hack/override.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+__import__('_distutils_hack').do_override()
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/_yaml/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/_yaml/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/_yaml/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/_yaml/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,39 @@
+from allure_commons._allure import title
+from allure_commons._allure import description, description_html
+from allure_commons._allure import label
+from allure_commons._allure import severity
+from allure_commons._allure import tag
+from allure_commons._allure import id
+from allure_commons._allure import suite, parent_suite, sub_suite
+from allure_commons._allure import epic, feature, story
+from allure_commons._allure import link, issue, testcase
+from allure_commons._allure import Dynamic as dynamic
+from allure_commons._allure import step
+from allure_commons._allure import attach
+from allure_commons.types import Severity as severity_level
+from allure_commons.types import AttachmentType as attachment_type
+
+
+__all__ = [
+    'title',
+    'description',
+    'description_html',
+    'label',
+    'severity',
+    'suite',
+    'parent_suite',
+    'sub_suite',
+    'tag',
+    'id',
+    'epic',
+    'feature',
+    'story',
+    'link',
+    'issue',
+    'testcase',
+    'step',
+    'dynamic',
+    'severity_level',
+    'attach',
+    'attachment_type'
+]
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,12 @@
+from allure_commons._hooks import hookimpl  # noqa: F401
+from allure_commons._core import plugin_manager  # noqa: F401
+from allure_commons._allure import fixture  # noqa: F401
+from allure_commons._allure import test  # noqa: F401
+
+
+__all__ = [
+    'hookimpl',
+    'plugin_manager',
+    'fixture',
+    'test'
+]
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/_allure.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/_allure.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/_compat.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/_compat.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/_core.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/_core.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/_hooks.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/_hooks.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/lifecycle.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/lifecycle.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/logger.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/logger.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/mapping.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/mapping.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/model2.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/model2.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/reporter.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/reporter.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/types.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/types.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/__pycache__/utils.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/allure_commons/__pycache__/utils.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/_allure.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/_allure.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,244 @@
+from functools import wraps
+from typing import Any, Callable, TypeVar
+
+from allure_commons._core import plugin_manager
+from allure_commons.types import LabelType, LinkType
+from allure_commons.utils import uuid4
+from allure_commons.utils import func_parameters, represent
+
+_TFunc = TypeVar("_TFunc", bound=Callable[..., Any])
+
+
+def safely(result):
+    if result:
+        return result[0]
+    else:
+        def dummy(function):
+            return function
+        return dummy
+
+
+def title(test_title):
+    return safely(plugin_manager.hook.decorate_as_title(test_title=test_title))
+
+
+def description(test_description):
+    return safely(plugin_manager.hook.decorate_as_description(test_description=test_description))
+
+
+def description_html(test_description_html):
+    return safely(plugin_manager.hook.decorate_as_description_html(test_description_html=test_description_html))
+
+
+def label(label_type, *labels):
+    return safely(plugin_manager.hook.decorate_as_label(label_type=label_type, labels=labels))
+
+
+def severity(severity_level):
+    return label(LabelType.SEVERITY, severity_level)
+
+
+def epic(*epics):
+    return label(LabelType.EPIC, *epics)
+
+
+def feature(*features):
+    return label(LabelType.FEATURE, *features)
+
+
+def story(*stories):
+    return label(LabelType.STORY, *stories)
+
+
+def suite(suite_name):
+    return label(LabelType.SUITE, suite_name)
+
+
+def parent_suite(parent_suite_name):
+    return label(LabelType.PARENT_SUITE, parent_suite_name)
+
+
+def sub_suite(sub_suite_name):
+    return label(LabelType.SUB_SUITE, sub_suite_name)
+
+
+def tag(*tags):
+    return label(LabelType.TAG, *tags)
+
+
+def id(id):
+    return label(LabelType.ID, id)
+
+
+def link(url, link_type=LinkType.LINK, name=None):
+    return safely(plugin_manager.hook.decorate_as_link(url=url, link_type=link_type, name=name))
+
+
+def issue(url, name=None):
+    return link(url, link_type=LinkType.ISSUE, name=name)
+
+
+def testcase(url, name=None):
+    return link(url, link_type=LinkType.TEST_CASE, name=name)
+
+
+class Dynamic(object):
+
+    @staticmethod
+    def title(test_title):
+        plugin_manager.hook.add_title(test_title=test_title)
+
+    @staticmethod
+    def description(test_description):
+        plugin_manager.hook.add_description(test_description=test_description)
+
+    @staticmethod
+    def description_html(test_description_html):
+        plugin_manager.hook.add_description_html(test_description_html=test_description_html)
+
+    @staticmethod
+    def label(label_type, *labels):
+        plugin_manager.hook.add_label(label_type=label_type, labels=labels)
+
+    @staticmethod
+    def severity(severity_level):
+        Dynamic.label(LabelType.SEVERITY, severity_level)
+
+    @staticmethod
+    def feature(*features):
+        Dynamic.label(LabelType.FEATURE, *features)
+
+    @staticmethod
+    def story(*stories):
+        Dynamic.label(LabelType.STORY, *stories)
+
+    @staticmethod
+    def tag(*tags):
+        Dynamic.label(LabelType.TAG, *tags)
+
+    @staticmethod
+    def link(url, link_type=LinkType.LINK, name=None):
+        plugin_manager.hook.add_link(url=url, link_type=link_type, name=name)
+
+    @staticmethod
+    def issue(url, name=None):
+        Dynamic.link(url, link_type=LinkType.ISSUE, name=name)
+
+    @staticmethod
+    def testcase(url, name=None):
+        Dynamic.link(url, link_type=LinkType.TEST_CASE, name=name)
+
+    @staticmethod
+    def suite(suite_name):
+        Dynamic.label(LabelType.SUITE, suite_name)
+
+    @staticmethod
+    def parent_suite(parent_suite_name):
+        Dynamic.label(LabelType.PARENT_SUITE, parent_suite_name)
+
+    @staticmethod
+    def sub_suite(sub_suite_name):
+        Dynamic.label(LabelType.SUB_SUITE, sub_suite_name)
+
+
+def step(title):
+    if callable(title):
+        return StepContext(title.__name__, {})(title)
+    else:
+        return StepContext(title, {})
+
+
+class StepContext:
+
+    def __init__(self, title, params):
+        self.title = title
+        self.params = params
+        self.uuid = uuid4()
+
+    def __enter__(self):
+        plugin_manager.hook.start_step(uuid=self.uuid, title=self.title, params=self.params)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        plugin_manager.hook.stop_step(uuid=self.uuid, title=self.title, exc_type=exc_type, exc_val=exc_val,
+                                      exc_tb=exc_tb)
+
+    def __call__(self, func: _TFunc) -> _TFunc:
+        @wraps(func)
+        def impl(*a, **kw):
+            __tracebackhide__ = True
+            params = func_parameters(func, *a, **kw)
+            args = list(map(lambda x: represent(x), a))
+            with StepContext(self.title.format(*args, **params), params):
+                return func(*a, **kw)
+        return impl
+
+
+class Attach(object):
+
+    def __call__(self, body, name=None, attachment_type=None, extension=None):
+        plugin_manager.hook.attach_data(body=body, name=name, attachment_type=attachment_type, extension=extension)
+
+    def file(self, source, name=None, attachment_type=None, extension=None):
+        plugin_manager.hook.attach_file(source=source, name=name, attachment_type=attachment_type, extension=extension)
+
+
+attach = Attach()
+
+
+class fixture(object):
+    def __init__(self, fixture_function, parent_uuid=None, name=None):
+        self._fixture_function = fixture_function
+        self._parent_uuid = parent_uuid
+        self._name = name if name else fixture_function.__name__
+        self._uuid = uuid4()
+        self.parameters = None
+
+    def __call__(self, *args, **kwargs):
+        self.parameters = func_parameters(self._fixture_function, *args, **kwargs)
+
+        with self:
+            return self._fixture_function(*args, **kwargs)
+
+    def __enter__(self):
+        plugin_manager.hook.start_fixture(parent_uuid=self._parent_uuid,
+                                          uuid=self._uuid,
+                                          name=self._name,
+                                          parameters=self.parameters)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        plugin_manager.hook.stop_fixture(parent_uuid=self._parent_uuid,
+                                         uuid=self._uuid,
+                                         name=self._name,
+                                         exc_type=exc_type,
+                                         exc_val=exc_val,
+                                         exc_tb=exc_tb)
+
+
+class test(object):
+    def __init__(self, _test, context):
+        self._test = _test
+        self._uuid = uuid4()
+        self.context = context
+        self.parameters = None
+
+    def __call__(self, *args, **kwargs):
+        self.parameters = func_parameters(self._test, *args, **kwargs)
+
+        with self:
+            return self._test(*args, **kwargs)
+
+    def __enter__(self):
+        plugin_manager.hook.start_test(parent_uuid=None,
+                                       uuid=self._uuid,
+                                       name=None,
+                                       parameters=self.parameters,
+                                       context=self.context)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        plugin_manager.hook.stop_test(parent_uuid=None,
+                                      uuid=self._uuid,
+                                      name=None,
+                                      context=self.context,
+                                      exc_type=exc_type,
+                                      exc_val=exc_val,
+                                      exc_tb=exc_tb)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/_compat.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/_compat.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,80 @@
+from __future__ import absolute_import, division, print_function
+import types
+
+
+def format_exception_only(etype, value):
+    """Format the exception part of a traceback.
+
+    The arguments are the exception type and value such as given by
+    sys.last_type and sys.last_value. The return value is a list of
+    strings, each ending in a newline.
+
+    Normally, the list contains a single string; however, for
+    SyntaxError exceptions, it contains several lines that (when
+    printed) display detailed information about where the syntax
+    error occurred.
+
+    The message indicating which exception occurred is always the last
+    string in the list.
+
+    """
+
+    # An instance should not have a meaningful value parameter, but
+    # sometimes does, particularly for string exceptions, such as
+    # >>> raise string1, string2  # deprecated
+    #
+    # Clear these out first because issubtype(string1, SyntaxError)
+    # would throw another exception and mask the original problem.
+    if (isinstance(etype, BaseException) or
+        isinstance(etype, types.InstanceType) or
+        etype is None or type(etype) is str):  # noqa: E129
+        return [_format_final_exc_line(etype, value)]
+
+    stype = etype.__name__
+
+    if not issubclass(etype, SyntaxError):
+        return [_format_final_exc_line(stype, value)]
+
+    # It was a syntax error; show exactly where the problem was found.
+    lines = []
+    try:
+        msg, (filename, lineno, offset, badline) = value.args
+    except Exception:
+        pass
+    else:
+        filename = filename or "<string>"
+        lines.append('  File "%s", line %d\n' % (filename, lineno))
+        if badline is not None:
+            lines.append('    %s\n' % badline.strip())
+            if offset is not None:
+                caretspace = badline.rstrip('\n')[:offset].lstrip()
+                # non-space whitespace (likes tabs) must be kept for alignment
+                caretspace = ((c.isspace() and c or ' ') for c in caretspace)
+                # only three spaces to account for offset1 == pos 0
+                lines.append('   %s^\n' % ''.join(caretspace))
+        value = msg
+
+    lines.append(_format_final_exc_line(stype, value))
+    return lines
+
+
+def _format_final_exc_line(etype, value):
+    """Return a list of a single line -- normal case for format_exception_only"""
+    valuestr = _some_str(value)
+    if value is None or not valuestr:
+        line = "%s\n" % etype
+    else:
+        line = "%s: %s\n" % (etype, valuestr)
+    return line
+
+
+def _some_str(value):
+    try:
+        return str(value)
+    except UnicodeError:
+        try:
+            value = unicode(value)  # noqa: F821
+            return value.encode('utf-8', 'replace')
+        except Exception:
+            pass
+    return '<unprintable %s object>' % type(value).__name__
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/_core.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/_core.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,25 @@
+import threading
+from six import with_metaclass
+from pluggy import PluginManager
+from allure_commons import _hooks
+
+
+class MetaPluginManager(type):
+    _storage = threading.local()
+
+    @staticmethod
+    def get_plugin_manager():
+        if not hasattr(MetaPluginManager._storage, 'plugin_manager'):
+            MetaPluginManager._storage.plugin_manager = PluginManager('allure')
+            MetaPluginManager._storage.plugin_manager.add_hookspecs(_hooks.AllureUserHooks)
+            MetaPluginManager._storage.plugin_manager.add_hookspecs(_hooks.AllureDeveloperHooks)
+
+        return MetaPluginManager._storage.plugin_manager
+
+    def __getattr__(cls, attr):
+        pm = MetaPluginManager.get_plugin_manager()
+        return getattr(pm, attr)
+
+
+class plugin_manager(with_metaclass(MetaPluginManager)):
+    pass
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/_hooks.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/_hooks.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,98 @@
+from pluggy import HookspecMarker, HookimplMarker
+
+hookspec = HookspecMarker("allure")
+hookimpl = HookimplMarker("allure")
+
+
+class AllureUserHooks(object):
+
+    @hookspec
+    def decorate_as_title(self, test_title):
+        """ title """
+
+    @hookspec
+    def add_title(self, test_title):
+        """ title """
+
+    @hookspec
+    def decorate_as_description(self, test_description):
+        """ description """
+
+    @hookspec
+    def add_description(self, test_description):
+        """ description """
+
+    @hookspec
+    def decorate_as_description_html(self, test_description_html):
+        """ description html"""
+
+    @hookspec
+    def add_description_html(self, test_description_html):
+        """ description html"""
+
+    @hookspec
+    def decorate_as_label(self, label_type, labels):
+        """ label """
+
+    @hookspec
+    def add_label(self, label_type, labels):
+        """ label """
+
+    @hookspec
+    def decorate_as_link(self, url, link_type, name):
+        """ url """
+
+    @hookspec
+    def add_link(self, url, link_type, name):
+        """ url """
+
+    @hookspec
+    def start_step(self, uuid, title, params):
+        """ step """
+
+    @hookspec
+    def stop_step(self, uuid, exc_type, exc_val, exc_tb):
+        """ step """
+
+    @hookspec
+    def attach_data(self, body, name, attachment_type, extension):
+        """ attach data """
+
+    @hookspec
+    def attach_file(self, source, name, attachment_type, extension):
+        """ attach file """
+
+
+class AllureDeveloperHooks(object):
+
+    @hookspec
+    def start_fixture(self, parent_uuid, uuid, name, parameters):
+        """ start fixture"""
+
+    @hookspec
+    def stop_fixture(self, parent_uuid, uuid, name, exc_type, exc_val, exc_tb):
+        """ stop fixture """
+
+    @hookspec
+    def start_test(self, parent_uuid, uuid, name, parameters, context):
+        """ start test"""
+
+    @hookspec
+    def stop_test(self, parent_uuid, uuid, name, context, exc_type, exc_val, exc_tb):
+        """ stop test """
+
+    @hookspec
+    def report_result(self, result):
+        """ reporting """
+
+    @hookspec
+    def report_container(self, container):
+        """ reporting """
+
+    @hookspec
+    def report_attached_file(self, source, file_name):
+        """ reporting """
+
+    @hookspec
+    def report_attached_data(self, body, file_name):
+        """ reporting """
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/lifecycle.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/lifecycle.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,147 @@
+from collections import OrderedDict
+from contextlib import contextmanager
+from allure_commons._core import plugin_manager
+from allure_commons.model2 import TestResultContainer
+from allure_commons.model2 import TestResult
+from allure_commons.model2 import Attachment, ATTACHMENT_PATTERN
+from allure_commons.model2 import TestStepResult
+from allure_commons.model2 import ExecutableItem
+from allure_commons.model2 import TestBeforeResult
+from allure_commons.model2 import TestAfterResult
+from allure_commons.utils import uuid4
+from allure_commons.utils import now
+from allure_commons.types import AttachmentType
+
+
+class AllureLifecycle(object):
+    def __init__(self):
+        self._items = OrderedDict()
+
+    def _get_item(self, uuid=None, item_type=None):
+        uuid = uuid or self._last_item_uuid(item_type=item_type)
+        return self._items.get(uuid)
+
+    def _pop_item(self, uuid=None, item_type=None):
+        uuid = uuid or self._last_item_uuid(item_type=item_type)
+        return self._items.pop(uuid, None)
+
+    def _last_item_uuid(self, item_type=None):
+        for uuid in reversed(self._items):
+            item = self._items.get(uuid)
+            if item_type is None:
+                return uuid
+            elif type(item) == item_type or isinstance(item, item_type):
+                return uuid
+
+    @contextmanager
+    def schedule_test_case(self, uuid=None):
+        test_result = TestResult()
+        test_result.uuid = uuid or uuid4()
+        self._items[test_result.uuid] = test_result
+        yield test_result
+
+    @contextmanager
+    def update_test_case(self, uuid=None):
+        yield self._get_item(uuid=uuid, item_type=TestResult)
+
+    def write_test_case(self, uuid=None):
+        test_result = self._pop_item(uuid=uuid, item_type=TestResult)
+        if test_result:
+            plugin_manager.hook.report_result(result=test_result)
+
+    @contextmanager
+    def start_step(self, parent_uuid=None, uuid=None):
+        parent = self._get_item(uuid=parent_uuid, item_type=ExecutableItem)
+        step = TestStepResult()
+        step.start = now()
+        parent.steps.append(step)
+        self._items[uuid or uuid4()] = step
+        yield step
+
+    @contextmanager
+    def update_step(self, uuid=None):
+        yield self._get_item(uuid=uuid, item_type=TestStepResult)
+
+    def stop_step(self, uuid=None):
+        step = self._pop_item(uuid=uuid, item_type=TestStepResult)
+        if step and not step.stop:
+            step.stop = now()
+
+    @contextmanager
+    def start_container(self, uuid=None):
+        container = TestResultContainer(uuid=uuid or uuid4())
+        self._items[container.uuid] = container
+        yield container
+
+    def containers(self):
+        for item in self._items.values():
+            if type(item) == TestResultContainer:
+                yield item
+
+    @contextmanager
+    def update_container(self, uuid=None):
+        yield self._get_item(uuid=uuid, item_type=TestResultContainer)
+
+    def write_container(self, uuid=None):
+        container = self._pop_item(uuid=uuid, item_type=TestResultContainer)
+        if container and (container.befores or container.afters):
+            plugin_manager.hook.report_container(container=container)
+
+    @contextmanager
+    def start_before_fixture(self, parent_uuid=None, uuid=None):
+        fixture = TestBeforeResult()
+        parent = self._get_item(uuid=parent_uuid, item_type=TestResultContainer)
+        if parent:
+            parent.befores.append(fixture)
+        self._items[uuid or uuid4()] = fixture
+        yield fixture
+
+    @contextmanager
+    def update_before_fixture(self, uuid=None):
+        yield self._get_item(uuid=uuid, item_type=TestBeforeResult)
+
+    def stop_before_fixture(self, uuid=None):
+        fixture = self._pop_item(uuid=uuid, item_type=TestBeforeResult)
+        if fixture and not fixture.stop:
+            fixture.stop = now()
+
+    @contextmanager
+    def start_after_fixture(self, parent_uuid=None, uuid=None):
+        fixture = TestAfterResult()
+        parent = self._get_item(uuid=parent_uuid, item_type=TestResultContainer)
+        if parent:
+            parent.afters.append(fixture)
+        self._items[uuid or uuid4()] = fixture
+        yield fixture
+
+    @contextmanager
+    def update_after_fixture(self, uuid=None):
+        yield self._get_item(uuid=uuid, item_type=TestAfterResult)
+
+    def stop_after_fixture(self, uuid=None):
+        fixture = self._pop_item(uuid=uuid, item_type=TestAfterResult)
+        if fixture and not fixture.stop:
+            fixture.stop = now()
+
+    def _attach(self, uuid, name=None, attachment_type=None, extension=None):
+        mime_type = attachment_type
+        extension = extension if extension else 'attach'
+
+        if type(attachment_type) is AttachmentType:
+            extension = attachment_type.extension
+            mime_type = attachment_type.mime_type
+
+        file_name = ATTACHMENT_PATTERN.format(prefix=uuid, ext=extension)
+        attachment = Attachment(source=file_name, name=name, type=mime_type)
+        uuid = self._last_item_uuid(item_type=ExecutableItem)
+        self._items[uuid].attachments.append(attachment)
+
+        return file_name
+
+    def attach_file(self, uuid, source, name=None, attachment_type=None, extension=None):
+        file_name = self._attach(uuid, name=name, attachment_type=attachment_type, extension=extension)
+        plugin_manager.hook.report_attached_file(source=source, file_name=file_name)
+
+    def attach_data(self, uuid, body, name=None, attachment_type=None, extension=None):
+        file_name = self._attach(uuid, name=name, attachment_type=attachment_type, extension=extension)
+        plugin_manager.hook.report_attached_data(body=body, file_name=file_name)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/logger.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/logger.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,88 @@
+import errno
+import io
+import os
+import sys
+import json
+import uuid
+import shutil
+from six import text_type
+from attr import asdict
+from allure_commons import hookimpl
+
+INDENT = 4
+
+
+class AllureFileLogger(object):
+
+    def __init__(self, report_dir, clean=False):
+        self._report_dir = report_dir
+
+        try:
+            os.makedirs(report_dir)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+            elif clean:
+                for f in os.listdir(report_dir):
+                    f = os.path.join(report_dir, f)
+                    if os.path.isfile(f):
+                        os.unlink(f)
+
+    def _report_item(self, item):
+        indent = INDENT if os.environ.get("ALLURE_INDENT_OUTPUT") else None
+        filename = item.file_pattern.format(prefix=uuid.uuid4())
+        data = asdict(item, filter=lambda attr, value: not (type(value) != bool and not bool(value)))
+        with io.open(os.path.join(self._report_dir, filename), 'w', encoding='utf8') as json_file:
+            if sys.version_info.major < 3:
+                json_file.write(
+                    unicode(json.dumps(data, indent=indent, ensure_ascii=False, encoding='utf8')))  # noqa: F821
+            else:
+                json.dump(data, json_file, indent=indent, ensure_ascii=False)
+
+    @hookimpl
+    def report_result(self, result):
+        self._report_item(result)
+
+    @hookimpl
+    def report_container(self, container):
+        self._report_item(container)
+
+    @hookimpl
+    def report_attached_file(self, source, file_name):
+        destination = os.path.join(self._report_dir, file_name)
+        shutil.copy2(source, destination)
+
+    @hookimpl
+    def report_attached_data(self, body, file_name):
+        destination = os.path.join(self._report_dir, file_name)
+        with open(destination, 'wb') as attached_file:
+            if isinstance(body, text_type):
+                attached_file.write(body.encode('utf-8'))
+            else:
+                attached_file.write(body)
+
+
+class AllureMemoryLogger(object):
+
+    def __init__(self):
+        self.test_cases = []
+        self.test_containers = []
+        self.attachments = {}
+
+    @hookimpl
+    def report_result(self, result):
+        data = asdict(result, filter=lambda attr, value: not (type(value) != bool and not bool(value)))
+        self.test_cases.append(data)
+
+    @hookimpl
+    def report_container(self, container):
+        data = asdict(container, filter=lambda attr, value: not (type(value) != bool and not bool(value)))
+        self.test_containers.append(data)
+
+    @hookimpl
+    def report_attached_file(self, source, file_name):
+        pass
+
+    @hookimpl
+    def report_attached_data(self, body, file_name):
+        self.attachments[file_name] = body
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/mapping.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/mapping.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,119 @@
+from itertools import chain, islice
+import attr
+import re
+from allure_commons.types import Severity, LabelType, LinkType
+from allure_commons.types import ALLURE_UNIQUE_LABELS
+from allure_commons.model2 import Label, Link
+
+
+TAG_PREFIX = "allure"
+
+semi_sep = re.compile(r"allure[\.\w]+:")
+eq_sep = re.compile(r"allure[\.\w]+=")
+
+
+def allure_tag_sep(tag):
+    if semi_sep.search(tag):
+        return ":"
+    if eq_sep.search(tag):
+        return "="
+
+
+def __is(kind, t):
+    return kind in [v for k, v in t.__dict__.items() if not k.startswith('__')]
+
+
+def parse_tag(tag, issue_pattern=None, link_pattern=None):
+    """
+    >>> parse_tag("blocker")
+    Label(name='severity', value='blocker')
+
+    >>> parse_tag("allure.issue:http://example.com/BUG-42")
+    Link(type='issue', url='http://example.com/BUG-42', name='http://example.com/BUG-42')
+
+    >>> parse_tag("allure.link.home:http://qameta.io")
+    Link(type='link', url='http://qameta.io', name='home')
+
+    >>> parse_tag("allure.suite:mapping")
+    Label(name='suite', value='mapping')
+
+    >>> parse_tag("allure.suite:mapping")
+    Label(name='suite', value='mapping')
+
+    >>> parse_tag("allure.label.owner:me")
+    Label(name='owner', value='me')
+
+    >>> parse_tag("foo.label:1")
+    Label(name='tag', value='foo.label:1')
+
+    >>> parse_tag("allure.foo:1")
+    Label(name='tag', value='allure.foo:1')
+    """
+    sep = allure_tag_sep(tag)
+    schema, value = islice(chain(tag.split(sep, 1), [None]), 2)
+    prefix, kind, name = islice(chain(schema.split('.'), [None], [None]), 3)
+
+    if tag in [severity for severity in Severity]:
+        return Label(name=LabelType.SEVERITY, value=tag)
+
+    if prefix == TAG_PREFIX and value is not None:
+
+        if __is(kind, LinkType):
+            if issue_pattern and kind == "issue" and not value.startswith("http"):
+                value = issue_pattern.format(value)
+            if link_pattern and kind == "link" and not value.startswith("http"):
+                value = link_pattern.format(value)
+            return Link(type=kind, name=name or value, url=value)
+
+        if __is(kind, LabelType):
+            return Label(name=kind, value=value)
+
+        if kind == "id":
+            return Label(name=LabelType.ID, value=value)
+
+        if kind == "label" and name is not None:
+            return Label(name=name, value=value)
+
+    return Label(name=LabelType.TAG, value=tag)
+
+
+def labels_set(labels):
+    """
+    >>> labels_set([Label(name=LabelType.SEVERITY, value=Severity.NORMAL),
+    ...             Label(name=LabelType.SEVERITY, value=Severity.BLOCKER)
+    ... ])
+    [Label(name='severity', value=<Severity.BLOCKER: 'blocker'>)]
+
+    >>> labels_set([Label(name=LabelType.SEVERITY, value=Severity.NORMAL),
+    ...             Label(name='severity', value='minor')
+    ... ])
+    [Label(name='severity', value='minor')]
+
+    >>> labels_set([Label(name=LabelType.EPIC, value="Epic"),
+    ...             Label(name=LabelType.EPIC, value="Epic")
+    ... ])
+    [Label(name='epic', value='Epic')]
+
+    >>> labels_set([Label(name=LabelType.EPIC, value="Epic1"),
+    ...             Label(name=LabelType.EPIC, value="Epic2")
+    ... ])
+    [Label(name='epic', value='Epic1'), Label(name='epic', value='Epic2')]
+    """
+    class Wl(object):
+        def __init__(self, label):
+            self.label = label
+
+        def __repr__(self):
+            return "{name}{value}".format(**attr.asdict(self.label))
+
+        def __eq__(self, other):
+            if self.label.name in ALLURE_UNIQUE_LABELS:
+                return self.label.name == other.label.name
+            return repr(self) == repr(other)
+
+        def __hash__(self):
+            if self.label.name in ALLURE_UNIQUE_LABELS:
+                return hash(self.label.name)
+            return hash(repr(self))
+
+    return sorted([wl.label for wl in set([Wl(label) for label in reversed(labels)])])
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/model2.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/model2.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,108 @@
+from attr import attrs, attrib
+from attr import Factory
+
+
+TEST_GROUP_PATTERN = "{prefix}-container.json"
+TEST_CASE_PATTERN = "{prefix}-result.json"
+ATTACHMENT_PATTERN = '{prefix}-attachment.{ext}'
+INDENT = 4
+
+
+@attrs
+class TestResultContainer(object):
+    file_pattern = TEST_GROUP_PATTERN
+
+    uuid = attrib(default=None)
+    name = attrib(default=None)
+    children = attrib(default=Factory(list))
+    description = attrib(default=None)
+    descriptionHtml = attrib(default=None)
+    befores = attrib(default=Factory(list))
+    afters = attrib(default=Factory(list))
+    links = attrib(default=Factory(list))
+    start = attrib(default=None)
+    stop = attrib(default=None)
+
+
+@attrs
+class ExecutableItem(object):
+    name = attrib(default=None)
+    status = attrib(default=None)
+    statusDetails = attrib(default=None)
+    stage = attrib(default=None)
+    description = attrib(default=None)
+    descriptionHtml = attrib(default=None)
+    steps = attrib(default=Factory(list))
+    attachments = attrib(default=Factory(list))
+    parameters = attrib(default=Factory(list))
+    start = attrib(default=None)
+    stop = attrib(default=None)
+
+
+@attrs
+class TestResult(ExecutableItem):
+    file_pattern = TEST_CASE_PATTERN
+
+    uuid = attrib(default=None)
+    historyId = attrib(default=None)
+    testCaseId = attrib(default=None)
+    fullName = attrib(default=None)
+    labels = attrib(default=Factory(list))
+    links = attrib(default=Factory(list))
+
+
+@attrs
+class TestStepResult(ExecutableItem):
+    id = attrib(default=None)
+
+
+@attrs
+class TestBeforeResult(ExecutableItem):
+    pass
+
+
+@attrs
+class TestAfterResult(ExecutableItem):
+    pass
+
+
+@attrs
+class Parameter(object):
+    name = attrib(default=None)
+    value = attrib(default=None)
+
+
+@attrs
+class Label(object):
+    name = attrib(default=None)
+    value = attrib(default=None)
+
+
+@attrs
+class Link(object):
+    type = attrib(default=None)
+    url = attrib(default=None)
+    name = attrib(default=None)
+
+
+@attrs
+class StatusDetails(object):
+    known = attrib(default=None)
+    flaky = attrib(default=None)
+    message = attrib(default=None)
+    trace = attrib(default=None)
+
+
+@attrs
+class Attachment(object):
+    name = attrib(default=None)
+    source = attrib(default=None)
+    type = attrib(default=None)
+
+
+class Status(object):
+    FAILED = 'failed'
+    BROKEN = 'broken'
+    PASSED = 'passed'
+    SKIPPED = 'skipped'
+    UNKNOWN = 'unknown'
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/reporter.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/reporter.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,117 @@
+from collections import OrderedDict
+
+from allure_commons.types import AttachmentType
+from allure_commons.model2 import ExecutableItem
+from allure_commons.model2 import TestResult
+from allure_commons.model2 import Attachment, ATTACHMENT_PATTERN
+from allure_commons.utils import now
+from allure_commons._core import plugin_manager
+
+
+class AllureReporter(object):
+    def __init__(self):
+        self._items = OrderedDict()
+        self._orphan_items = []
+
+    def _update_item(self, uuid, **kwargs):
+        item = self._items[uuid] if uuid else self._items[next(reversed(self._items))]
+        for name, value in kwargs.items():
+            attr = getattr(item, name)
+            if isinstance(attr, list):
+                attr.append(value)
+            else:
+                setattr(item, name, value)
+
+    def _last_executable(self):
+        for _uuid in reversed(self._items):
+            if isinstance(self._items[_uuid], ExecutableItem):
+                return _uuid
+
+    def get_item(self, uuid):
+        return self._items.get(uuid)
+
+    def get_last_item(self, item_type=None):
+        for _uuid in reversed(self._items):
+            if item_type is None:
+                return self._items.get(_uuid)
+            if type(self._items[_uuid]) == item_type:
+                return self._items.get(_uuid)
+
+    def start_group(self, uuid, group):
+        self._items[uuid] = group
+
+    def stop_group(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+        group = self._items.pop(uuid)
+        plugin_manager.hook.report_container(container=group)
+
+    def update_group(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+
+    def start_before_fixture(self, parent_uuid, uuid, fixture):
+        self._items.get(parent_uuid).befores.append(fixture)
+        self._items[uuid] = fixture
+
+    def stop_before_fixture(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+        self._items.pop(uuid)
+
+    def start_after_fixture(self, parent_uuid, uuid, fixture):
+        self._items.get(parent_uuid).afters.append(fixture)
+        self._items[uuid] = fixture
+
+    def stop_after_fixture(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+        fixture = self._items.pop(uuid)
+        fixture.stop = now()
+
+    def schedule_test(self, uuid, test_case):
+        self._items[uuid] = test_case
+
+    def get_test(self, uuid):
+        return self.get_item(uuid) if uuid else self.get_last_item(TestResult)
+
+    def close_test(self, uuid):
+        test_case = self._items.pop(uuid)
+        plugin_manager.hook.report_result(result=test_case)
+
+    def drop_test(self, uuid):
+        self._items.pop(uuid)
+
+    def start_step(self, parent_uuid, uuid, step):
+        parent_uuid = parent_uuid if parent_uuid else self._last_executable()
+        if parent_uuid is None:
+            self._orphan_items.append(uuid)
+        else:
+            self._items[parent_uuid].steps.append(step)
+            self._items[uuid] = step
+
+    def stop_step(self, uuid, **kwargs):
+        if uuid in self._orphan_items:
+            self._orphan_items.remove(uuid)
+        else:
+            self._update_item(uuid, **kwargs)
+            self._items.pop(uuid)
+
+    def _attach(self, uuid, name=None, attachment_type=None, extension=None):
+        mime_type = attachment_type
+        extension = extension if extension else 'attach'
+
+        if type(attachment_type) is AttachmentType:
+            extension = attachment_type.extension
+            mime_type = attachment_type.mime_type
+
+        file_name = ATTACHMENT_PATTERN.format(prefix=uuid, ext=extension)
+        attachment = Attachment(source=file_name, name=name, type=mime_type)
+        last_uuid = self._last_executable()
+        self._items[last_uuid].attachments.append(attachment)
+
+        return file_name
+
+    def attach_file(self, uuid, source, name=None, attachment_type=None, extension=None):
+        file_name = self._attach(uuid, name=name, attachment_type=attachment_type, extension=extension)
+        plugin_manager.hook.report_attached_file(source=source, file_name=file_name)
+
+    def attach_data(self, uuid, body, name=None, attachment_type=None, extension=None):
+        file_name = self._attach(uuid, name=name, attachment_type=attachment_type, extension=extension)
+        plugin_manager.hook.report_attached_data(body=body, file_name=file_name)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/types.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/types.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,64 @@
+from enum import Enum
+
+ALLURE_UNIQUE_LABELS = ['severity', 'thread', 'host']
+
+
+class Severity(str, Enum):
+    BLOCKER = 'blocker'
+    CRITICAL = 'critical'
+    NORMAL = 'normal'
+    MINOR = 'minor'
+    TRIVIAL = 'trivial'
+
+
+class LinkType(object):
+    LINK = 'link'
+    ISSUE = 'issue'
+    TEST_CASE = 'test_case'
+
+
+class LabelType(str):
+    EPIC = 'epic'
+    FEATURE = 'feature'
+    STORY = 'story'
+    PARENT_SUITE = 'parentSuite'
+    SUITE = 'suite'
+    SUB_SUITE = 'subSuite'
+    SEVERITY = 'severity'
+    THREAD = 'thread'
+    HOST = 'host'
+    TAG = 'tag'
+    ID = 'as_id'
+    FRAMEWORK = 'framework'
+    LANGUAGE = 'language'
+
+
+class AttachmentType(Enum):
+
+    def __init__(self, mime_type, extension):
+        self.mime_type = mime_type
+        self.extension = extension
+
+    TEXT = ("text/plain", "txt")
+    CSV = ("text/csv", "csv")
+    TSV = ("text/tab-separated-values", "tsv")
+    URI_LIST = ("text/uri-list", "uri")
+
+    HTML = ("text/html", "html")
+    XML = ("application/xml", "xml")
+    JSON = ("application/json", "json")
+    YAML = ("application/yaml", "yaml")
+    PCAP = ("application/vnd.tcpdump.pcap", "pcap")
+
+    PNG = ("image/png", "png")
+    JPG = ("image/jpg", "jpg")
+    SVG = ("image/svg-xml", "svg")
+    GIF = ("image/gif", "gif")
+    BMP = ("image/bmp", "bmp")
+    TIFF = ("image/tiff", "tiff")
+
+    MP4 = ("video/mp4", "mp4")
+    OGG = ("video/ogg", "ogg")
+    WEBM = ("video/webm", "webm")
+
+    PDF = ("application/pdf", "pdf")
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_commons/utils.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_commons/utils.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,403 @@
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import six
+import time
+import uuid
+import json
+import socket
+import inspect
+import hashlib
+import platform
+import threading
+import traceback
+import collections
+
+from functools import partial
+
+
+def getargspec(func):
+    """
+    Used because getargspec for python 2.7 does not accept functools.partial
+    which is the type for pytest fixtures.
+
+    getargspec excerpted from:
+
+    sphinx.util.inspect
+    ~~~~~~~~~~~~~~~~~~~
+    Helpers for inspecting Python modules.
+    :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+
+    Like inspect.getargspec but supports functools.partial as well.
+    """
+    # noqa: E731 type: (Any) -> Any
+    if inspect.ismethod(func):
+        func = func.__func__
+    parts = 0, ()  # noqa: E731 type: Tuple[int, Tuple[unicode, ...]]
+    if type(func) is partial:
+        keywords = func.keywords
+        if keywords is None:
+            keywords = {}
+        parts = len(func.args), keywords.keys()
+        func = func.func
+    if not inspect.isfunction(func):
+        raise TypeError('%r is not a Python function' % func)
+    args, varargs, varkw = inspect.getargs(func.__code__)
+    func_defaults = func.__defaults__
+    if func_defaults is None:
+        func_defaults = []
+    else:
+        func_defaults = list(func_defaults)
+    if parts[0]:
+        args = args[parts[0]:]
+    if parts[1]:
+        for arg in parts[1]:
+            i = args.index(arg) - len(args)  # type: ignore
+            del args[i]
+            try:
+                del func_defaults[i]
+            except IndexError:
+                pass
+    return inspect.ArgSpec(args, varargs, varkw, func_defaults)  # type: ignore
+
+
+if six.PY3:
+    from traceback import format_exception_only
+else:
+    from _compat import format_exception_only
+
+
+def md5(*args):
+    m = hashlib.md5()
+    for arg in args:
+        part = arg.encode('utf-8')
+        m.update(part)
+    return m.hexdigest()
+
+
+def uuid4():
+    return str(uuid.uuid4())
+
+
+def now():
+    return int(round(1000 * time.time()))
+
+
+def platform_label():
+    major_version, _, __ = platform.python_version_tuple()
+    implementation = platform.python_implementation()
+    return '{implementation}{major_version}'.format(implementation=implementation.lower(),
+                                                    major_version=major_version)
+
+
+def thread_tag():
+    return '{0}-{1}'.format(os.getpid(), threading.current_thread().name)
+
+
+def host_tag():
+    return socket.gethostname()
+
+
+def escape_non_unicode_symbols(item):
+    if not (six.PY2 and isinstance(item, str)):
+        return item
+
+    def escape_symbol(s):
+        try:
+            s.decode(encoding='UTF-8')
+            return s
+        except UnicodeDecodeError:
+            return repr(s)[1:-1]
+
+    return ''.join(map(escape_symbol, item))
+
+
+def represent(item):
+    """
+    >>> represent(None)
+    'None'
+
+    >>> represent(123)
+    '123'
+
+    >>> import six
+    >>> expected = u"'hi'" if six.PY2 else "'hi'"
+    >>> represent('hi') == expected
+    True
+
+    >>> expected = u"'привет'" if six.PY2 else "'привет'"
+    >>> represent(u'привет') == expected
+    True
+
+    >>> represent(bytearray([0xd0, 0xbf]))  # doctest: +ELLIPSIS
+    "<... 'bytearray'>"
+
+    >>> from struct import pack
+    >>> result = "<type 'str'>" if six.PY2 else "<class 'bytes'>"
+    >>> represent(pack('h', 0x89)) == result
+    True
+
+    >>> result = "<type 'int'>" if six.PY2 else "<class 'int'>"
+    >>> represent(int) == result
+    True
+
+    >>> represent(represent)  # doctest: +ELLIPSIS
+    '<function represent at ...>'
+
+    >>> represent([represent])  # doctest: +ELLIPSIS
+    '[<function represent at ...>]'
+
+    >>> class ClassWithName(object):
+    ...     pass
+
+    >>> represent(ClassWithName)
+    "<class 'utils.ClassWithName'>"
+    """
+
+    if six.PY2 and isinstance(item, str):
+        try:
+            item = item.decode(encoding='UTF-8')
+        except UnicodeDecodeError:
+            pass
+
+    if isinstance(item, six.text_type):
+        return u'\'%s\'' % item
+    elif isinstance(item, (bytes, bytearray)):
+        return repr(type(item))
+    else:
+        return repr(item)
+
+
+def func_parameters(func, *args, **kwargs):
+    """
+    >>> def helper(func):
+    ...     def wrapper(*args, **kwargs):
+    ...         params = func_parameters(func, *args, **kwargs)
+    ...         print(list(params.items()))
+    ...         return func(*args, **kwargs)
+    ...     return wrapper
+
+    >>> @helper
+    ... def args(a, b):
+    ...     pass
+
+    >>> args(1, 2)
+    [('a', '1'), ('b', '2')]
+
+    >>> args(*(1,2))
+    [('a', '1'), ('b', '2')]
+
+    >>> args(1, b=2)
+    [('a', '1'), ('b', '2')]
+
+    >>> @helper
+    ... def kwargs(a=1, b=2):
+    ...     pass
+
+    >>> kwargs()
+    [('a', '1'), ('b', '2')]
+
+    >>> kwargs(a=3, b=4)
+    [('a', '3'), ('b', '4')]
+
+    >>> kwargs(b=4, a=3)
+    [('a', '3'), ('b', '4')]
+
+    >>> kwargs(a=3)
+    [('a', '3'), ('b', '2')]
+
+    >>> kwargs(b=4)
+    [('a', '1'), ('b', '4')]
+
+    >>> @helper
+    ... def args_kwargs(a, b, c=3, d=4):
+    ...     pass
+
+    >>> args_kwargs(1, 2)
+    [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
+
+    >>> args_kwargs(1, 2, d=5)
+    [('a', '1'), ('b', '2'), ('c', '3'), ('d', '5')]
+
+    >>> args_kwargs(1, 2, 5, 6)
+    [('a', '1'), ('b', '2'), ('c', '5'), ('d', '6')]
+
+    >>> @helper
+    ... def varargs(*a):
+    ...     pass
+
+    >>> varargs()
+    []
+
+    >>> varargs(1, 2)
+    [('a', '(1, 2)')]
+
+    >>> @helper
+    ... def keywords(**a):
+    ...     pass
+
+    >>> keywords()
+    []
+
+    >>> keywords(a=1, b=2)
+    [('a', '1'), ('b', '2')]
+
+    >>> @helper
+    ... def args_varargs(a, b, *c):
+    ...     pass
+
+    >>> args_varargs(1, 2)
+    [('a', '1'), ('b', '2')]
+
+    >>> args_varargs(1, 2, 2)
+    [('a', '1'), ('b', '2'), ('c', '(2,)')]
+
+    >>> @helper
+    ... def args_kwargs_varargs(a, b, c=3, **d):
+    ...     pass
+
+    >>> args_kwargs_varargs(1, 2)
+    [('a', '1'), ('b', '2'), ('c', '3')]
+
+    >>> args_kwargs_varargs(1, 2, 4, d=5, e=6)
+    [('a', '1'), ('b', '2'), ('c', '4'), ('d', '5'), ('e', '6')]
+
+    >>> @helper
+    ... def args_kwargs_varargs_keywords(a, b=2, *c, **d):
+    ...     pass
+
+    >>> args_kwargs_varargs_keywords(1)
+    [('a', '1'), ('b', '2')]
+
+    >>> args_kwargs_varargs_keywords(1, 2, 4, d=5, e=6)
+    [('a', '1'), ('b', '2'), ('c', '(4,)'), ('d', '5'), ('e', '6')]
+
+    >>> class Class(object):
+    ...     @staticmethod
+    ...     @helper
+    ...     def static_args(a, b):
+    ...         pass
+    ...
+    ...     @classmethod
+    ...     @helper
+    ...     def method_args(cls, a, b):
+    ...         pass
+    ...
+    ...     @helper
+    ...     def args(self, a, b):
+    ...         pass
+
+    >>> cls = Class()
+
+    >>> cls.args(1, 2)
+    [('a', '1'), ('b', '2')]
+
+    >>> cls.method_args(1, 2)
+    [('a', '1'), ('b', '2')]
+
+    >>> cls.static_args(1, 2)
+    [('a', '1'), ('b', '2')]
+
+    """
+    parameters = {}
+    arg_spec = getargspec(func) if six.PY2 else inspect.getfullargspec(func)
+    arg_order = list(arg_spec.args)
+    args_dict = dict(zip(arg_spec.args, args))
+
+    if arg_spec.defaults:
+        kwargs_defaults_dict = dict(zip(arg_spec.args[len(args):], arg_spec.defaults))
+        parameters.update(kwargs_defaults_dict)
+
+    if arg_spec.varargs:
+        arg_order.append(arg_spec.varargs)
+        varargs = args[len(arg_spec.args):]
+        parameters.update({arg_spec.varargs: varargs} if varargs else {})
+
+    if arg_spec.args and arg_spec.args[0] in ['cls', 'self']:
+        args_dict.pop(arg_spec.args[0], None)
+
+    if kwargs:
+        if sys.version_info < (3, 6):
+            # Sort alphabetically as old python versions does
+            # not preserve call order for kwargs
+            arg_order.extend(sorted(list(kwargs.keys())))
+        else:
+            # Keep py3.6 behaviour to preserve kwargs order
+            arg_order.extend(list(kwargs.keys()))
+        parameters.update(kwargs)
+
+    parameters.update(args_dict)
+
+    items = parameters.iteritems() if six.PY2 else parameters.items()
+    sorted_items = sorted(map(lambda kv: (kv[0], represent(kv[1])), items), key=lambda x: arg_order.index(x[0]))
+
+    return collections.OrderedDict(sorted_items)
+
+
+def format_traceback(exc_traceback):
+    return ''.join(traceback.format_tb(exc_traceback)) if exc_traceback else None
+
+
+def format_exception(etype, value):
+    """
+    >>> import sys
+
+    >>> try:
+    ...     assert False, u'Привет'
+    ... except AssertionError:
+    ...     etype, e, _ = sys.exc_info()
+    ...     format_exception(etype, e) # doctest: +ELLIPSIS
+    'AssertionError: ...\\n'
+
+    >>> try:
+    ...     assert False, 'Привет'
+    ... except AssertionError:
+    ...     etype, e, _ = sys.exc_info()
+    ...     format_exception(etype, e) # doctest: +ELLIPSIS
+    'AssertionError: ...\\n'
+
+    >>> try:
+    ...    compile("bla u'Привет'", "fake.py", "exec")
+    ... except SyntaxError:
+    ...    etype, e, _ = sys.exc_info()
+    ...    format_exception(etype, e) # doctest: +ELLIPSIS
+    '  File "fake.py", line 1...SyntaxError: invalid syntax\\n'
+
+    >>> try:
+    ...    compile("bla 'Привет'", "fake.py", "exec")
+    ... except SyntaxError:
+    ...    etype, e, _ = sys.exc_info()
+    ...    format_exception(etype, e) # doctest: +ELLIPSIS
+    '  File "fake.py", line 1...SyntaxError: invalid syntax\\n'
+
+    >>> from hamcrest import assert_that, equal_to
+
+    >>> try:
+    ...     assert_that('left', equal_to('right'))
+    ... except AssertionError:
+    ...     etype, e, _ = sys.exc_info()
+    ...     format_exception(etype, e) # doctest: +ELLIPSIS
+    "AssertionError: \\nExpected:...but:..."
+
+    >>> try:
+    ...     assert_that(u'left', equal_to(u'right'))
+    ... except AssertionError:
+    ...     etype, e, _ = sys.exc_info()
+    ...     format_exception(etype, e) # doctest: +ELLIPSIS
+    "AssertionError: \\nExpected:...but:..."
+    """
+    return '\n'.join(format_exception_only(etype, value)) if etype or value else None
+
+
+def get_testplan():
+    planned_tests = []
+    file_path = os.environ.get("ALLURE_TESTPLAN_PATH")
+
+    if file_path and os.path.exists(file_path):
+        with open(file_path, 'r') as plan_file:
+            plan = json.load(plan_file)
+            planned_tests = plan.get("tests", [])
+
+    return planned_tests
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: allure-python-commons
+Version: 2.8.36
+Summary: Common module for integrate allure with python-based frameworks
+Home-page: https://github.com/allure-framework/allure-python
+Author: QAMetaSoftware, Stanislav Seliverstov
+Author-email: sseliverstov@qameta.io
+License: Apache-2.0
+Keywords: allure reporting report-engine
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Dist: attrs (>=16.0.0)
+Requires-Dist: six (>=1.9.0)
+Requires-Dist: pluggy (>=0.4.0)
+Requires-Dist: enum34 ; python_version < "3.4"
+
+UNKNOWN
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,31 @@
+__pycache__/allure.cpython-39.pyc,,
+allure.py,sha256=tI_MyEfGvV5Fzf37BDQgC7_-dvwcTAWLOYbpfB33BbA,1048
+allure_commons/__init__.py,sha256=VSaOVESKG8r9vKRS3IMuW0Fc00WJ7zxtKj-XtS3kGZY,310
+allure_commons/__pycache__/__init__.cpython-39.pyc,,
+allure_commons/__pycache__/_allure.cpython-39.pyc,,
+allure_commons/__pycache__/_compat.cpython-39.pyc,,
+allure_commons/__pycache__/_core.cpython-39.pyc,,
+allure_commons/__pycache__/_hooks.cpython-39.pyc,,
+allure_commons/__pycache__/lifecycle.cpython-39.pyc,,
+allure_commons/__pycache__/logger.cpython-39.pyc,,
+allure_commons/__pycache__/mapping.cpython-39.pyc,,
+allure_commons/__pycache__/model2.cpython-39.pyc,,
+allure_commons/__pycache__/reporter.cpython-39.pyc,,
+allure_commons/__pycache__/types.cpython-39.pyc,,
+allure_commons/__pycache__/utils.cpython-39.pyc,,
+allure_commons/_allure.py,sha256=GbqJ9QMjaw4NA_tFfHKDXRDrLu94DJutju14jyPpYNw,7418
+allure_commons/_compat.py,sha256=MtVJLuMH8QB4s5EfG5rdwMXYAW-2MQl8a41CygNphsg,2803
+allure_commons/_core.py,sha256=Y8eRZtLaVljVxjGF_dA4__rCMrWPK7RXtsJoFl2vTx0,813
+allure_commons/_hooks.py,sha256=PU0eTFnshlGKRDXdDwBPMhaEyDYjhZ6qPd7J_5Bxfg0,2329
+allure_commons/lifecycle.py,sha256=bgofnwvophkjfmwwlqLiMP2dmC3L3DHy8liR--2N4kU,5699
+allure_commons/logger.py,sha256=TMmpTohzlrJEiptyTXVqGqFNbcDz9hoeBLAx2nV7ORU,2763
+allure_commons/mapping.py,sha256=ZWyFLgh7neZ3_bPBjTzSFGtu9a2o8e2Y_krG0bXPb5Y,3860
+allure_commons/model2.py,sha256=YG08Bda6X1-4NyJtJoJSrXX79RV6UJWo6G9QFp1pCLk,2401
+allure_commons/reporter.py,sha256=3rF3p6RUl_MHMvf1YDhvyH9wiRK5ZBIgevTX_ocKWZk,4351
+allure_commons/types.py,sha256=Ne5Haj1y4zE-uOix5KPBdgN5bmiuO3_yS4NEGBX-28E,1463
+allure_commons/utils.py,sha256=piAiEASbVkySZpRwbWfvsXvruIAipPKnaZI1-ZEPaMY,10319
+allure_python_commons-2.8.36.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+allure_python_commons-2.8.36.dist-info/METADATA,sha256=s6wrcn74NtAtwcM4i29Luyggaxl6a-l0GERmxtpo5qU,792
+allure_python_commons-2.8.36.dist-info/RECORD,,
+allure_python_commons-2.8.36.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+allure_python_commons-2.8.36.dist-info/top_level.txt,sha256=RTeAMoq_LtMxZ4bnDaup54pNGO9rhYvgY8CTJLm9Sdk,22
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/allure_python_commons-2.8.36.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,2 @@
+allure
+allure_commons
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/LICENSE.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/LICENSE.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,23 @@
+# This is the MIT license
+
+Copyright (c) 2010 ActiveState Software Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,264 @@
+Metadata-Version: 2.1
+Name: appdirs
+Version: 1.4.4
+Summary: A small Python module for determining appropriate platform-specific dirs, e.g. a "user data dir".
+Home-page: http://github.com/ActiveState/appdirs
+Author: Trent Mick
+Author-email: trentm@gmail.com
+Maintainer: Jeff Rouse
+Maintainer-email: jr@its.to
+License: MIT
+Keywords: application directory log cache user
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+
+
+.. image:: https://secure.travis-ci.org/ActiveState/appdirs.png
+    :target: http://travis-ci.org/ActiveState/appdirs
+
+the problem
+===========
+
+What directory should your app use for storing user data? If running on Mac OS X, you
+should use::
+
+    ~/Library/Application Support/<AppName>
+
+If on Windows (at least English Win XP) that should be::
+
+    C:\Documents and Settings\<User>\Application Data\Local Settings\<AppAuthor>\<AppName>
+
+or possibly::
+
+    C:\Documents and Settings\<User>\Application Data\<AppAuthor>\<AppName>
+
+for `roaming profiles <http://bit.ly/9yl3b6>`_ but that is another story.
+
+On Linux (and other Unices) the dir, according to the `XDG
+spec <http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html>`_, is::
+
+    ~/.local/share/<AppName>
+
+
+``appdirs`` to the rescue
+=========================
+
+This kind of thing is what the ``appdirs`` module is for. ``appdirs`` will
+help you choose an appropriate:
+
+- user data dir (``user_data_dir``)
+- user config dir (``user_config_dir``)
+- user cache dir (``user_cache_dir``)
+- site data dir (``site_data_dir``)
+- site config dir (``site_config_dir``)
+- user log dir (``user_log_dir``)
+
+and also:
+
+- is a single module so other Python packages can include their own private copy
+- is slightly opinionated on the directory names used. Look for "OPINION" in
+  documentation and code for when an opinion is being applied.
+
+
+some example output
+===================
+
+On Mac OS X::
+
+    >>> from appdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> site_data_dir(appname, appauthor)
+    '/Library/Application Support/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/Users/trentm/Library/Caches/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/Users/trentm/Library/Logs/SuperApp'
+
+On Windows 7::
+
+    >>> from appdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp'
+    >>> user_data_dir(appname, appauthor, roaming=True)
+    'C:\\Users\\trentm\\AppData\\Roaming\\Acme\\SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp\\Cache'
+    >>> user_log_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp\\Logs'
+
+On Linux::
+
+    >>> from appdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/home/trentm/.local/share/SuperApp
+    >>> site_data_dir(appname, appauthor)
+    '/usr/local/share/SuperApp'
+    >>> site_data_dir(appname, appauthor, multipath=True)
+    '/usr/local/share/SuperApp:/usr/share/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/home/trentm/.cache/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/home/trentm/.cache/SuperApp/log'
+    >>> user_config_dir(appname)
+    '/home/trentm/.config/SuperApp'
+    >>> site_config_dir(appname)
+    '/etc/xdg/SuperApp'
+    >>> os.environ['XDG_CONFIG_DIRS'] = '/etc:/usr/local/etc'
+    >>> site_config_dir(appname, multipath=True)
+    '/etc/SuperApp:/usr/local/etc/SuperApp'
+
+
+``AppDirs`` for convenience
+===========================
+
+::
+
+    >>> from appdirs import AppDirs
+    >>> dirs = AppDirs("SuperApp", "Acme")
+    >>> dirs.user_data_dir
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> dirs.site_data_dir
+    '/Library/Application Support/SuperApp'
+    >>> dirs.user_cache_dir
+    '/Users/trentm/Library/Caches/SuperApp'
+    >>> dirs.user_log_dir
+    '/Users/trentm/Library/Logs/SuperApp'
+
+
+
+Per-version isolation
+=====================
+
+If you have multiple versions of your app in use that you want to be
+able to run side-by-side, then you may want version-isolation for these
+dirs::
+
+    >>> from appdirs import AppDirs
+    >>> dirs = AppDirs("SuperApp", "Acme", version="1.0")
+    >>> dirs.user_data_dir
+    '/Users/trentm/Library/Application Support/SuperApp/1.0'
+    >>> dirs.site_data_dir
+    '/Library/Application Support/SuperApp/1.0'
+    >>> dirs.user_cache_dir
+    '/Users/trentm/Library/Caches/SuperApp/1.0'
+    >>> dirs.user_log_dir
+    '/Users/trentm/Library/Logs/SuperApp/1.0'
+
+
+
+appdirs Changelog
+=================
+
+appdirs 1.4.4
+-------------
+- [PR #92] Don't import appdirs from setup.py
+
+Project officially classified as Stable which is important
+for inclusion in other distros such as ActivePython.
+
+First of several incremental releases to catch up on maintenance.
+
+appdirs 1.4.3
+-------------
+- [PR #76] Python 3.6 invalid escape sequence deprecation fixes
+- Fix for Python 3.6 support
+
+appdirs 1.4.2
+-------------
+- [PR #84] Allow installing without setuptools
+- [PR #86] Fix string delimiters in setup.py description
+- Add Python 3.6 support
+
+appdirs 1.4.1
+-------------
+- [issue #38] Fix _winreg import on Windows Py3
+- [issue #55] Make appname optional
+
+appdirs 1.4.0
+-------------
+- [PR #42] AppAuthor is now optional on Windows
+- [issue 41] Support Jython on Windows, Mac, and Unix-like platforms. Windows
+  support requires `JNA <https://github.com/twall/jna>`_.
+- [PR #44] Fix incorrect behaviour of the site_config_dir method
+
+appdirs 1.3.0
+-------------
+- [Unix, issue 16] Conform to XDG standard, instead of breaking it for
+  everybody
+- [Unix] Removes gratuitous case mangling of the case, since \*nix-es are
+  usually case sensitive, so mangling is not wise
+- [Unix] Fixes the utterly wrong behaviour in ``site_data_dir``, return result
+  based on XDG_DATA_DIRS and make room for respecting the standard which
+  specifies XDG_DATA_DIRS is a multiple-value variable
+- [Issue 6] Add ``*_config_dir`` which are distinct on nix-es, according to
+  XDG specs; on Windows and Mac return the corresponding ``*_data_dir``
+
+appdirs 1.2.0
+-------------
+
+- [Unix] Put ``user_log_dir`` under the *cache* dir on Unix. Seems to be more
+  typical.
+- [issue 9] Make ``unicode`` work on py3k.
+
+appdirs 1.1.0
+-------------
+
+- [issue 4] Add ``AppDirs.user_log_dir``.
+- [Unix, issue 2, issue 7] appdirs now conforms to `XDG base directory spec
+  <http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html>`_.
+- [Mac, issue 5] Fix ``site_data_dir()`` on Mac.
+- [Mac] Drop use of 'Carbon' module in favour of hardcoded paths; supports
+  Python3 now.
+- [Windows] Append "Cache" to ``user_cache_dir`` on Windows by default. Use
+  ``opinion=False`` option to disable this.
+- Add ``appdirs.AppDirs`` convenience class. Usage:
+
+        >>> dirs = AppDirs("SuperApp", "Acme", version="1.0")
+        >>> dirs.user_data_dir
+        '/Users/trentm/Library/Application Support/SuperApp/1.0'
+
+- [Windows] Cherry-pick Komodo's change to downgrade paths to the Windows short
+  paths if there are high bit chars.
+- [Linux] Change default ``user_cache_dir()`` on Linux to be singular, e.g.
+  "~/.superapp/cache".
+- [Windows] Add ``roaming`` option to ``user_data_dir()`` (for use on Windows only)
+  and change the default ``user_data_dir`` behaviour to use a *non*-roaming
+  profile dir (``CSIDL_LOCAL_APPDATA`` instead of ``CSIDL_APPDATA``). Why? Because
+  a large roaming profile can cause login speed issues. The "only syncs on
+  logout" behaviour can cause surprises in appdata info.
+
+
+appdirs 1.0.1 (never released)
+------------------------------
+
+Started this changelog 27 July 2010. Before that this module originated in the
+`Komodo <http://www.activestate.com/komodo>`_ product as ``applib.py`` and then
+as `applib/location.py
+<http://github.com/ActiveState/applib/blob/master/applib/location.py>`_ (used by
+`PyPM <http://code.activestate.com/pypm/>`_ in `ActivePython
+<http://www.activestate.com/activepython>`_). This is basically a fork of
+applib.py 1.0.1 and applib/location.py 1.0.1.
+
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,8 @@
+__pycache__/appdirs.cpython-39.pyc,,
+appdirs-1.4.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+appdirs-1.4.4.dist-info/LICENSE.txt,sha256=Nt200KdFqTqyAyA9cZCBSxuJcn0lTK_0jHp6-71HAAs,1097
+appdirs-1.4.4.dist-info/METADATA,sha256=k5TVfXMNKGHTfp2wm6EJKTuGwGNuoQR5TqQgH8iwG8M,8981
+appdirs-1.4.4.dist-info/RECORD,,
+appdirs-1.4.4.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+appdirs-1.4.4.dist-info/top_level.txt,sha256=nKncE8CUqZERJ6VuQWL4_bkunSPDNfn7KZqb4Tr5YEM,8
+appdirs.py,sha256=g99s2sXhnvTEm79oj4bWI0Toapc-_SmKKNXvOXHkVic,24720
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/appdirs-1.4.4.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+appdirs
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/appdirs.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/appdirs.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,608 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+"""Utilities for determining application-specific dirs.
+
+See <http://github.com/ActiveState/appdirs> for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version__ = "1.4.4"
+__version_info__ = tuple(int(segment) for segment in __version__.split("."))
+
+
+import sys
+import os
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    unicode = str
+
+if sys.platform.startswith('java'):
+    import platform
+    os_name = platform.java_ver()[3][0]
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
+        system = 'win32'
+    elif os_name.startswith('Mac'): # "Mac OS X", etc.
+        system = 'darwin'
+    else: # "Linux", "SunOS", "FreeBSD", etc.
+        # Setting this to "linux2" is not ideal, but only Windows or Mac
+        # are actually checked for and the rest of the module expects
+        # *sys.platform* style strings.
+        system = 'linux2'
+else:
+    system = sys.platform
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               ~/Library/Application Support/<AppName>
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(_get_win_folder(const))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Application Support/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of data dirs should be
+            returned. By default, the first item from XDG_DATA_DIRS is
+            returned, or '/usr/local/share/<AppName>',
+            if XDG_DATA_DIRS is not set
+
+    Typical site data directories are:
+        Mac OS X:   /Library/Application Support/<AppName>
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
+
+    For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Application Support')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_DATA_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_DATA_DIRS',
+                         os.pathsep.join(['/usr/local/share', '/usr/share']))
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+        return path
+
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user config directories are:
+        Mac OS X:               same as user_data_dir
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by default "~/.config/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of config dirs should be
+            returned. By default, the first item from XDG_CONFIG_DIRS is
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
+
+    Typical site config directories are:
+        Mac OS X:   same as site_data_dir
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
+                    $XDG_CONFIG_DIRS
+        Win *:      same as site_data_dir
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system in ["win32", "darwin"]:
+        path = site_data_dir(appname, appauthor)
+        if appname and version:
+            path = os.path.join(path, version)
+    else:
+        # XDG default for $XDG_CONFIG_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+    return path
+
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Cache" to the base app data dir for Windows. See
+            discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go in
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+    app data dir (the default returned by `user_data_dir` above). Apps typically
+    put cache data somewhere *under* the given dir here. Some examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+            if opinion:
+                path = os.path.join(path, "Cache")
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Caches')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific state dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user state directories are:
+        Mac OS X:  same as user_data_dir
+        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
+        Win *:     same as user_data_dir
+
+    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
+    to extend the XDG spec and support $XDG_STATE_HOME.
+
+    That means, by default "~/.local/state/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific log dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Logs" to the base app data dir for Windows, and "log" to the
+            base cache dir for Unix. See discussion below.
+
+    Typical user log directories are:
+        Mac OS X:   ~/Library/Logs/<AppName>
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
+
+    On Windows the only suggestion in the MSDN docs is that local settings
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+    examples of what some windows apps use for a logs dir.)
+
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+    value for Windows and appends "log" to the user cache dir for Unix.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "darwin":
+        path = os.path.join(
+            os.path.expanduser('~/Library/Logs'),
+            appname)
+    elif system == "win32":
+        path = user_data_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "Logs")
+    else:
+        path = user_cache_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "log")
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+class AppDirs(object):
+    """Convenience wrapper for getting application dirs."""
+    def __init__(self, appname=None, appauthor=None, version=None,
+            roaming=False, multipath=False):
+        self.appname = appname
+        self.appauthor = appauthor
+        self.version = version
+        self.roaming = roaming
+        self.multipath = multipath
+
+    @property
+    def user_data_dir(self):
+        return user_data_dir(self.appname, self.appauthor,
+                             version=self.version, roaming=self.roaming)
+
+    @property
+    def site_data_dir(self):
+        return site_data_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_config_dir(self):
+        return user_config_dir(self.appname, self.appauthor,
+                               version=self.version, roaming=self.roaming)
+
+    @property
+    def site_config_dir(self):
+        return site_config_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_cache_dir(self):
+        return user_cache_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_state_dir(self):
+        return user_state_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_log_dir(self):
+        return user_log_dir(self.appname, self.appauthor,
+                            version=self.version)
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+    """This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    if PY3:
+      import winreg as _winreg
+    else:
+      import _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+    return dir
+
+
+def _get_win_folder_with_pywin32(csidl_name):
+    from win32com.shell import shellcon, shell
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+    # Try to make this a unicode path because SHGetFolderPath does
+    # not return unicode strings when there is unicode data in the
+    # path.
+    try:
+        dir = unicode(dir)
+
+        # Downgrade to short path name if have highbit chars. See
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+        has_high_char = False
+        for c in dir:
+            if ord(c) > 255:
+                has_high_char = True
+                break
+        if has_high_char:
+            try:
+                import win32api
+                dir = win32api.GetShortPathName(dir)
+            except ImportError:
+                pass
+    except UnicodeError:
+        pass
+    return dir
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    import ctypes
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+def _get_win_folder_with_jna(csidl_name):
+    import array
+    from com.sun import jna
+    from com.sun.jna.platform import win32
+
+    buf_size = win32.WinDef.MAX_PATH * 2
+    buf = array.zeros('c', buf_size)
+    shell = win32.Shell32.INSTANCE
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in dir:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf = array.zeros('c', buf_size)
+        kernel = win32.Kernel32.INSTANCE
+        if kernel.GetShortPathName(dir, buf, buf_size):
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    return dir
+
+if system == "win32":
+    try:
+        import win32com.shell
+        _get_win_folder = _get_win_folder_with_pywin32
+    except ImportError:
+        try:
+            from ctypes import windll
+            _get_win_folder = _get_win_folder_with_ctypes
+        except ImportError:
+            try:
+                import com.sun.jna
+                _get_win_folder = _get_win_folder_with_jna
+            except ImportError:
+                _get_win_folder = _get_win_folder_from_registry
+
+
+#---- self test code
+
+if __name__ == "__main__":
+    appname = "MyApp"
+    appauthor = "MyCompany"
+
+    props = ("user_data_dir",
+             "user_config_dir",
+             "user_cache_dir",
+             "user_state_dir",
+             "user_log_dir",
+             "site_data_dir",
+             "site_config_dir")
+
+    print("-- app dirs %s --" % __version__)
+
+    print("-- app dirs (with optional 'version')")
+    dirs = AppDirs(appname, appauthor, version="1.0")
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = AppDirs(appname, appauthor)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = AppDirs(appname)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = AppDirs(appname, appauthor=False)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/LICENSE.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/LICENSE.rst	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,413 @@
+Metadata-Version: 2.1
+Name: argcomplete
+Version: 1.12.2
+Summary: Bash tab completion for argparse
+Home-page: https://github.com/kislyuk/argcomplete
+Author: Andrey Kislyuk
+Author-email: kislyuk@gmail.com
+License: Apache Software License
+Project-URL: Documentation, https://kislyuk.github.io/argcomplete
+Project-URL: Source Code, https://github.com/kislyuk/argcomplete
+Project-URL: Issue Tracker, https://github.com/kislyuk/argcomplete/issues
+Project-URL: Change Log, https://github.com/kislyuk/argcomplete/blob/master/Changes.rst
+Platform: MacOS X
+Platform: Posix
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Terminals
+Requires-Dist: importlib-metadata (<4,>=0.23) ; python_version == "2.7"
+Requires-Dist: importlib-metadata (<4,>=0.23) ; python_version == "3.5"
+Requires-Dist: importlib-metadata (<4,>=0.23) ; python_version == "3.6"
+Requires-Dist: importlib-metadata (<4,>=0.23) ; python_version == "3.7"
+Provides-Extra: test
+Requires-Dist: coverage ; extra == 'test'
+Requires-Dist: flake8 ; extra == 'test'
+Requires-Dist: pexpect ; extra == 'test'
+Requires-Dist: wheel ; extra == 'test'
+
+argcomplete - Bash tab completion for argparse
+==============================================
+*Tab complete all the things!*
+
+Argcomplete provides easy, extensible command line tab completion of arguments for your Python script.
+
+It makes two assumptions:
+
+* You're using bash as your shell (limited support for zsh, fish, and tcsh is available)
+* You're using `argparse <http://docs.python.org/3/library/argparse.html>`_ to manage your command line arguments/options
+
+Argcomplete is particularly useful if your program has lots of options or subparsers, and if your program can
+dynamically suggest completions for your argument/option values (for example, if the user is browsing resources over
+the network).
+
+Installation
+------------
+::
+
+    pip install argcomplete
+    activate-global-python-argcomplete
+
+See `Activating global completion`_ below for details about the second step (or if it reports an error).
+
+Refresh your bash environment (start a new shell or ``source /etc/profile``).
+
+Synopsis
+--------
+Python code (e.g. ``my-awesome-script``):
+
+.. code-block:: python
+
+    #!/usr/bin/env python
+    # PYTHON_ARGCOMPLETE_OK
+    import argcomplete, argparse
+    parser = argparse.ArgumentParser()
+    ...
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+    ...
+
+Shellcode (only necessary if global completion is not activated - see `Global completion`_ below), to be put in e.g. ``.bashrc``::
+
+    eval "$(register-python-argcomplete my-awesome-script)"
+
+argcomplete.autocomplete(*parser*)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This method is the entry point to the module. It must be called **after** ArgumentParser construction is complete, but
+**before** the ``ArgumentParser.parse_args()`` method is called. The method looks for an environment variable that the
+completion hook shellcode sets, and if it's there, collects completions, prints them to the output stream (fd 8 by
+default), and exits. Otherwise, it returns to the caller immediately.
+
+.. admonition:: Side effects
+
+ Argcomplete gets completions by running your program. It intercepts the execution flow at the moment
+ ``argcomplete.autocomplete()`` is called. After sending completions, it exits using ``exit_method`` (``os._exit``
+ by default). This means if your program has any side effects that happen before ``argcomplete`` is called, those
+ side effects will happen every time the user presses ``<TAB>`` (although anything your program prints to stdout or
+ stderr will be suppressed). For this reason it's best to construct the argument parser and call
+ ``argcomplete.autocomplete()`` as early as possible in your execution flow.
+
+.. admonition:: Performance
+
+ If the program takes a long time to get to the point where ``argcomplete.autocomplete()`` is called, the tab completion
+ process will feel sluggish, and the user may lose confidence in it. So it's also important to minimize the startup time
+ of the program up to that point (for example, by deferring initialization or importing of large modules until after
+ parsing options).
+
+Specifying completers
+---------------------
+You can specify custom completion functions for your options and arguments. Two styles are supported: callable and
+readline-style. Callable completers are simpler. They are called with the following keyword arguments:
+
+* ``prefix``: The prefix text of the last word before the cursor on the command line.
+  For dynamic completers, this can be used to reduce the work required to generate possible completions.
+* ``action``: The ``argparse.Action`` instance that this completer was called for.
+* ``parser``: The ``argparse.ArgumentParser`` instance that the action was taken by.
+* ``parsed_args``: The result of argument parsing so far (the ``argparse.Namespace`` args object normally returned by
+  ``ArgumentParser.parse_args()``).
+
+Completers should return their completions as a list of strings. An example completer for names of environment
+variables might look like this:
+
+.. code-block:: python
+
+    def EnvironCompleter(**kwargs):
+        return os.environ
+
+To specify a completer for an argument or option, set the ``completer`` attribute of its associated action. An easy
+way to do this at definition time is:
+
+.. code-block:: python
+
+    from argcomplete.completers import EnvironCompleter
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--env-var1").completer = EnvironCompleter
+    parser.add_argument("--env-var2").completer = EnvironCompleter
+    argcomplete.autocomplete(parser)
+
+If you specify the ``choices`` keyword for an argparse option or argument (and don't specify a completer), it will be
+used for completions.
+
+A completer that is initialized with a set of all possible choices of values for its action might look like this:
+
+.. code-block:: python
+
+    class ChoicesCompleter(object):
+        def __init__(self, choices):
+            self.choices = choices
+
+        def __call__(self, **kwargs):
+            return self.choices
+
+The following two ways to specify a static set of choices are equivalent for completion purposes:
+
+.. code-block:: python
+
+    from argcomplete.completers import ChoicesCompleter
+
+    parser.add_argument("--protocol", choices=('http', 'https', 'ssh', 'rsync', 'wss'))
+    parser.add_argument("--proto").completer=ChoicesCompleter(('http', 'https', 'ssh', 'rsync', 'wss'))
+
+Note that if you use the ``choices=<completions>`` option, argparse will show
+all these choices in the ``--help`` output by default. To prevent this, set
+``metavar`` (like ``parser.add_argument("--protocol", metavar="PROTOCOL",
+choices=('http', 'https', 'ssh', 'rsync', 'wss'))``).
+
+The following `script <https://raw.github.com/kislyuk/argcomplete/master/docs/examples/describe_github_user.py>`_ uses
+``parsed_args`` and `Requests <http://python-requests.org/>`_ to query GitHub for publicly known members of an
+organization and complete their names, then prints the member description:
+
+.. code-block:: python
+
+    #!/usr/bin/env python
+    # PYTHON_ARGCOMPLETE_OK
+    import argcomplete, argparse, requests, pprint
+
+    def github_org_members(prefix, parsed_args, **kwargs):
+        resource = "https://api.github.com/orgs/{org}/members".format(org=parsed_args.organization)
+        return (member['login'] for member in requests.get(resource).json() if member['login'].startswith(prefix))
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--organization", help="GitHub organization")
+    parser.add_argument("--member", help="GitHub member").completer = github_org_members
+
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+
+    pprint.pprint(requests.get("https://api.github.com/users/{m}".format(m=args.member)).json())
+
+`Try it <https://raw.github.com/kislyuk/argcomplete/master/docs/examples/describe_github_user.py>`_ like this::
+
+    ./describe_github_user.py --organization heroku --member <TAB>
+
+If you have a useful completer to add to the `completer library
+<https://github.com/kislyuk/argcomplete/blob/master/argcomplete/completers.py>`_, send a pull request!
+
+Readline-style completers
+~~~~~~~~~~~~~~~~~~~~~~~~~
+The readline_ module defines a completer protocol in rlcompleter_. Readline-style completers are also supported by
+argcomplete, so you can use the same completer object both in an interactive readline-powered shell and on the bash
+command line. For example, you can use the readline-style completer provided by IPython_ to get introspective
+completions like you would get in the IPython shell:
+
+.. _readline: http://docs.python.org/3/library/readline.html
+.. _rlcompleter: http://docs.python.org/3/library/rlcompleter.html#completer-objects
+.. _IPython: http://ipython.org/
+
+.. code-block:: python
+
+    import IPython
+    parser.add_argument("--python-name").completer = IPython.core.completer.Completer()
+
+``argcomplete.CompletionFinder.rl_complete`` can also be used to plug in an argparse parser as a readline completer.
+
+Printing warnings in completers
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Normal stdout/stderr output is suspended when argcomplete runs. Sometimes, though, when the user presses ``<TAB>``, it's
+appropriate to print information about why completions generation failed. To do this, use ``warn``:
+
+.. code-block:: python
+
+    from argcomplete import warn
+
+    def AwesomeWebServiceCompleter(prefix, **kwargs):
+        if login_failed:
+            warn("Please log in to Awesome Web Service to use autocompletion")
+        return completions
+
+Using a custom completion validator
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+By default, argcomplete validates your completions by checking if they start with the prefix given to the completer. You
+can override this validation check by supplying the ``validator`` keyword to ``argcomplete.autocomplete()``:
+
+.. code-block:: python
+
+    def my_validator(current_input, keyword_to_check_against):
+        # Pass through ALL options even if they don't all start with 'current_input'
+        return True
+
+    argcomplete.autocomplete(parser, validator=my_validator)
+
+Global completion
+-----------------
+In global completion mode, you don't have to register each argcomplete-capable executable separately. Instead, bash
+will look for the string **PYTHON_ARGCOMPLETE_OK** in the first 1024 bytes of any executable that it's running
+completion for, and if it's found, follow the rest of the argcomplete protocol as described above.
+
+Additionally, completion is activated for scripts run as ``python <script>`` and ``python -m <module>``.
+This also works for alternate Python versions (e.g. ``python3`` and ``pypy``), as long as that version of Python has
+argcomplete installed.
+
+.. admonition:: Bash version compatibility
+
+ Global completion requires bash support for ``complete -D``, which was introduced in bash 4.2. On OS X or older Linux
+ systems, you will need to update bash to use this feature. Check the version of the running copy of bash with
+ ``echo $BASH_VERSION``. On OS X, install bash via `Homebrew <http://brew.sh/>`_ (``brew install bash``), add
+ ``/usr/local/bin/bash`` to ``/etc/shells``, and run ``chsh`` to change your shell.
+
+ Global completion is not currently compatible with zsh.
+
+.. note:: If you use setuptools/distribute ``scripts`` or ``entry_points`` directives to package your module,
+ argcomplete will follow the wrapper scripts to their destination and look for ``PYTHON_ARGCOMPLETE_OK`` in the
+ destination code.
+
+If you choose not to use global completion, or ship a bash completion module that depends on argcomplete, you must
+register your script explicitly using ``eval "$(register-python-argcomplete my-awesome-script)"``. Standard bash
+completion registration roules apply: namely, the script name is passed directly to ``complete``, meaning it is only tab
+completed when invoked exactly as it was registered. In the above example, ``my-awesome-script`` must be on the path,
+and the user must be attempting to complete it by that name. The above line alone would **not** allow you to complete
+``./my-awesome-script``, or ``/path/to/my-awesome-script``.
+
+
+Activating global completion
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The script ``activate-global-python-argcomplete`` will try to install the file
+``bash_completion.d/python-argcomplete`` (`see on GitHub`_) into an appropriate location on your system
+(``/etc/bash_completion.d/`` or ``~/.bash_completion.d/``). If it
+fails, but you know the correct location of your bash completion scripts directory, you can specify it with ``--dest``::
+
+    activate-global-python-argcomplete --dest=/path/to/bash_completion.d
+
+Otherwise, you can redirect its shellcode output into a file::
+
+    activate-global-python-argcomplete --dest=- > file
+
+The file's contents should then be sourced in e.g. ``~/.bashrc``.
+
+.. _`see on GitHub`: https://github.com/kislyuk/argcomplete/blob/master/argcomplete/bash_completion.d/python-argcomplete
+
+Zsh Support
+------------
+To activate completions for zsh you need to have ``bashcompinit`` enabled in zsh::
+
+    autoload -U bashcompinit
+    bashcompinit
+
+Afterwards you can enable completion for your scripts with ``register-python-argcomplete``::
+
+    eval "$(register-python-argcomplete my-awesome-script)"
+
+Tcsh Support
+------------
+To activate completions for tcsh use::
+
+    eval `register-python-argcomplete --shell tcsh my-awesome-script`
+
+The ``python-argcomplete-tcsh`` script provides completions for tcsh.
+The following is an example of the tcsh completion syntax for
+``my-awesome-script`` emitted by ``register-python-argcomplete``::
+
+    complete my-awesome-script 'p@*@`python-argcomplete-tcsh my-awesome-script`@'
+
+Fish Support
+------------
+To activate completions for fish use::
+
+    register-python-argcomplete --shell fish my-awesome-script | source
+
+or create new completion file, e.g::
+
+    register-python-argcomplete --shell fish ~/.config/fish/completions/my-awesome-script.fish
+
+Completion Description For Fish
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+By default help string is added as completion description.
+
+.. image:: docs/fish_help_string.png
+
+You can disable this feature by removing ``_ARGCOMPLETE_DFS`` variable, e.g::
+
+    register-python-argcomplete --shell fish my-awesome-script | grep -v _ARGCOMPLETE_DFS | .
+
+Git Bash Support
+----------------
+Due to limitations of file descriptor inheritance on Windows,
+Git Bash not supported out of the box. You can opt in to using
+temporary files instead of file descriptors for for IPC
+by setting the environment variable ``ARGCOMPLETE_USE_TEMPFILES``,
+e.g. by adding ``export ARGCOMPLETE_USE_TEMPFILES=1`` to ``~/.bashrc``.
+
+For full support, consider using Bash with the
+Windows Subsystem for Linux (WSL).
+
+External argcomplete script
+---------------------------
+To register an argcomplete script for an arbitrary name, the ``--external-argcomplete-script`` argument of the ``register-python-argcomplete`` script can be used::
+
+    eval "$(register-python-argcomplete --external-argcomplete-script /path/to/script arbitrary-name)"
+
+This allows, for example, to use the auto completion functionality of argcomplete for an application not written in Python. 
+The command line interface of this program must be additionally implemented in a Python script with argparse and argcomplete and whenever the application is called the registered external argcomplete script is used for auto completion.
+
+This option can also be used in combination with the other supported shells.
+
+Python Support
+--------------
+Argcomplete requires Python 2.7 or 3.5+.
+
+Common Problems
+---------------
+If global completion is not completing your script, bash may have registered a
+default completion function::
+
+    $ complete | grep my-awesome-script
+    complete -F _minimal my-awesome-script
+
+You can fix this by restarting your shell, or by running
+``complete -r my-awesome-script``.
+
+Debugging
+---------
+Set the ``_ARC_DEBUG`` variable in your shell to enable verbose debug output every time argcomplete runs. This will
+disrupt the command line composition state of your terminal, but make it possible to see the internal state of the
+completer if it encounters problems.
+
+Acknowledgments
+---------------
+Inspired and informed by the optcomplete_ module by Martin Blais.
+
+.. _optcomplete: http://pypi.python.org/pypi/optcomplete
+
+Links
+-----
+* `Project home page (GitHub) <https://github.com/kislyuk/argcomplete>`_
+* `Documentation <https://kislyuk.github.io/argcomplete/>`_
+* `Package distribution (PyPI) <https://pypi.python.org/pypi/argcomplete>`_
+* `Change log <https://github.com/kislyuk/argcomplete/blob/master/Changes.rst>`_
+* `xontrib-argcomplete <https://github.com/anki-code/xontrib-argcomplete>`_ - support argcomplete in `xonsh <https://github.com/xonsh/xonsh>`_ shell
+
+Bugs
+~~~~
+Please report bugs, issues, feature requests, etc. on `GitHub <https://github.com/kislyuk/argcomplete/issues>`_.
+
+License
+-------
+Licensed under the terms of the `Apache License, Version 2.0 <http://www.apache.org/licenses/LICENSE-2.0>`_.
+
+.. image:: https://github.com/kislyuk/argcomplete/workflows/Python%20package/badge.svg
+        :target: https://github.com/kislyuk/argcomplete/actions
+.. image:: https://codecov.io/github/kislyuk/argcomplete/coverage.svg?branch=master
+        :target: https://codecov.io/github/kislyuk/argcomplete?branch=master
+.. image:: https://img.shields.io/pypi/v/argcomplete.svg
+        :target: https://pypi.python.org/pypi/argcomplete
+.. image:: https://img.shields.io/pypi/l/argcomplete.svg
+        :target: https://pypi.python.org/pypi/argcomplete
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,27 @@
+../../../bin/activate-global-python-argcomplete,sha256=kzSsSv4_1HmxHSd8jAuJcCk3rmTusMrrPvA0M10922U,3449
+../../../bin/python-argcomplete-check-easy-install-script,sha256=SVom_9XP-DNkl_1VqkCuQtlNN5emeGBa8WghIc8ijGU,2545
+../../../bin/python-argcomplete-tcsh,sha256=KI3tAmFni27_MLTbwTZ0pxoXh0zD_UKB9UtLuh4nmeU,314
+../../../bin/register-python-argcomplete,sha256=WfB_6LhyxKoyfIuJirxkPASkJjSmS2VhQ02bqgCw7Gg,1907
+argcomplete-1.12.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+argcomplete-1.12.2.dist-info/LICENSE.rst,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+argcomplete-1.12.2.dist-info/METADATA,sha256=oPNY4wCSXMXMk-x6XedLlROHWAvP5E7tw_jhBccZEgQ,18496
+argcomplete-1.12.2.dist-info/RECORD,,
+argcomplete-1.12.2.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+argcomplete-1.12.2.dist-info/top_level.txt,sha256=iwsGO5-UxEhB809OsWbOmLjd8r8X1xtXY65mP01Ahlg,12
+argcomplete/__init__.py,sha256=XaC1oIfWD5EpzV_GUdh2ZOMn-iaKgMteZJX-RzDZ1S4,31772
+argcomplete/__pycache__/__init__.cpython-39.pyc,,
+argcomplete/__pycache__/_check_console_script.cpython-39.pyc,,
+argcomplete/__pycache__/_check_module.cpython-39.pyc,,
+argcomplete/__pycache__/compat.cpython-39.pyc,,
+argcomplete/__pycache__/completers.cpython-39.pyc,,
+argcomplete/__pycache__/my_argparse.cpython-39.pyc,,
+argcomplete/__pycache__/my_shlex.cpython-39.pyc,,
+argcomplete/__pycache__/shell_integration.cpython-39.pyc,,
+argcomplete/_check_console_script.py,sha256=1YABFqoWmQae6VW_OP8gvdrIlabC3vgDoFYvd5AWv38,2120
+argcomplete/_check_module.py,sha256=05cgMAM62yW5zd2ShyPsjw93to2HOGnIY1oxlfVSPfw,2593
+argcomplete/bash_completion.d/python-argcomplete,sha256=J8psAyzpm92islfLxajmWGeQcTr0HsjQDbULiyCvyow,4108
+argcomplete/compat.py,sha256=0NkEPn-UBnSNN7aZtt6VjlMTbJZW7yGsWDQt_WSCW9c,524
+argcomplete/completers.py,sha256=5A28IV3Nvuyx6OJnaiXZ1OJjXlJ12b-_8HDg93wlZS0,3681
+argcomplete/my_argparse.py,sha256=qUXmvsQKVqjROL5oJSWh14a_bsrV8GnjxpPkpQVyGUg,15351
+argcomplete/my_shlex.py,sha256=AJE5PbeFYGIf_mT04G72AAlCikKcs2XZEEVYa4AUj7M,13218
+argcomplete/shell_integration.py,sha256=uVJxJu7S9lkr5rYPwGnNfL28lhe3SXDsy4Mm6XC6LD4,4288
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete-1.12.2.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+argcomplete
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,684 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os, sys, argparse, contextlib
+from . import completers, my_shlex as shlex
+from .compat import USING_PYTHON2, str, sys_encoding, ensure_str, ensure_bytes
+from .completers import FilesCompleter, SuppressCompleter
+from .my_argparse import IntrospectiveArgumentParser, action_is_satisfied, action_is_open, action_is_greedy
+from .shell_integration import shellcode
+
+_DEBUG = "_ARC_DEBUG" in os.environ
+
+debug_stream = sys.stderr
+
+def debug(*args):
+    if _DEBUG:
+        if USING_PYTHON2:
+            # debug_stream has to be binary mode in Python 2.
+            # Attempting to write unicode directly uses the default ascii conversion.
+            # Convert any unicode to bytes, leaving non-string input alone.
+            args = [ensure_bytes(x) if isinstance(x, str) else x for x in args]
+        print(file=debug_stream, *args)
+
+BASH_FILE_COMPLETION_FALLBACK = 79
+BASH_DIR_COMPLETION_FALLBACK = 80
+
+safe_actions = (argparse._StoreAction,
+                argparse._StoreConstAction,
+                argparse._StoreTrueAction,
+                argparse._StoreFalseAction,
+                argparse._AppendAction,
+                argparse._AppendConstAction,
+                argparse._CountAction)
+
+@contextlib.contextmanager
+def mute_stdout():
+    stdout = sys.stdout
+    sys.stdout = open(os.devnull, "w")
+    try:
+        yield
+    finally:
+        sys.stdout = stdout
+
+@contextlib.contextmanager
+def mute_stderr():
+    stderr = sys.stderr
+    sys.stderr = open(os.devnull, "w")
+    try:
+        yield
+    finally:
+        sys.stderr.close()
+        sys.stderr = stderr
+
+class ArgcompleteException(Exception):
+    pass
+
+def split_line(line, point=None):
+    if point is None:
+        point = len(line)
+    lexer = shlex.shlex(line, posix=True)
+    lexer.whitespace_split = True
+    lexer.wordbreaks = os.environ.get("_ARGCOMPLETE_COMP_WORDBREAKS", "")
+    words = []
+
+    def split_word(word):
+        # TODO: make this less ugly
+        point_in_word = len(word) + point - lexer.instream.tell()
+        if isinstance(lexer.state, (str, bytes)) and lexer.state in lexer.whitespace:
+            point_in_word += 1
+        if point_in_word > len(word):
+            debug("In trailing whitespace")
+            words.append(word)
+            word = ""
+        prefix, suffix = word[:point_in_word], word[point_in_word:]
+        prequote = ""
+        # posix
+        if lexer.state is not None and lexer.state in lexer.quotes:
+            prequote = lexer.state
+        # non-posix
+        # if len(prefix) > 0 and prefix[0] in lexer.quotes:
+        #    prequote, prefix = prefix[0], prefix[1:]
+
+        return prequote, prefix, suffix, words, lexer.last_wordbreak_pos
+
+    while True:
+        try:
+            word = lexer.get_token()
+            if word == lexer.eof:
+                # TODO: check if this is ever unsafe
+                # raise ArgcompleteException("Unexpected end of input")
+                return "", "", "", words, None
+            if lexer.instream.tell() >= point:
+                debug("word", word, "split, lexer state: '{s}'".format(s=lexer.state))
+                return split_word(word)
+            words.append(word)
+        except ValueError:
+            debug("word", lexer.token, "split (lexer stopped, state: '{s}')".format(s=lexer.state))
+            if lexer.instream.tell() >= point:
+                return split_word(lexer.token)
+            else:
+                msg = ("Unexpected internal state. "
+                       "Please report this bug at https://github.com/kislyuk/argcomplete/issues.")
+                raise ArgcompleteException(msg)
+
+def default_validator(completion, prefix):
+    return completion.startswith(prefix)
+
+class CompletionFinder(object):
+    """
+    Inherit from this class if you wish to override any of the stages below. Otherwise, use
+    ``argcomplete.autocomplete()`` directly (it's a convenience instance of this class). It has the same signature as
+    :meth:`CompletionFinder.__call__()`.
+    """
+    def __init__(self, argument_parser=None, always_complete_options=True, exclude=None, validator=None,
+                 print_suppressed=False, default_completer=FilesCompleter(), append_space=None):
+        self._parser = argument_parser
+        self.always_complete_options = always_complete_options
+        self.exclude = exclude
+        if validator is None:
+            validator = default_validator
+        self.validator = validator
+        self.print_suppressed = print_suppressed
+        self.completing = False
+        self._display_completions = {}
+        self.default_completer = default_completer
+        if append_space is None:
+            append_space = os.environ.get("_ARGCOMPLETE_SUPPRESS_SPACE") != "1"
+        self.append_space = append_space
+
+    def __call__(self, argument_parser, always_complete_options=True, exit_method=os._exit, output_stream=None,
+                 exclude=None, validator=None, print_suppressed=False, append_space=None,
+                 default_completer=FilesCompleter()):
+        """
+        :param argument_parser: The argument parser to autocomplete on
+        :type argument_parser: :class:`argparse.ArgumentParser`
+        :param always_complete_options:
+            Controls the autocompletion of option strings if an option string opening character (normally ``-``) has not
+            been entered. If ``True`` (default), both short (``-x``) and long (``--x``) option strings will be
+            suggested. If ``False``, no option strings will be suggested. If ``long``, long options and short options
+            with no long variant will be suggested. If ``short``, short options and long options with no short variant
+            will be suggested.
+        :type always_complete_options: boolean or string
+        :param exit_method:
+            Method used to stop the program after printing completions. Defaults to :meth:`os._exit`. If you want to
+            perform a normal exit that calls exit handlers, use :meth:`sys.exit`.
+        :type exit_method: callable
+        :param exclude: List of strings representing options to be omitted from autocompletion
+        :type exclude: iterable
+        :param validator:
+            Function to filter all completions through before returning (called with two string arguments, completion
+            and prefix; return value is evaluated as a boolean)
+        :type validator: callable
+        :param print_suppressed:
+            Whether or not to autocomplete options that have the ``help=argparse.SUPPRESS`` keyword argument set.
+        :type print_suppressed: boolean
+        :param append_space:
+            Whether to append a space to unique matches. The default is ``True``.
+        :type append_space: boolean
+
+        .. note::
+            If you are not subclassing CompletionFinder to override its behaviors,
+            use ``argcomplete.autocomplete()`` directly. It has the same signature as this method.
+
+        Produces tab completions for ``argument_parser``. See module docs for more info.
+
+        Argcomplete only executes actions if their class is known not to have side effects. Custom action classes can be
+        added to argcomplete.safe_actions, if their values are wanted in the ``parsed_args`` completer argument, or
+        their execution is otherwise desirable.
+        """
+        self.__init__(argument_parser, always_complete_options=always_complete_options, exclude=exclude,
+                      validator=validator, print_suppressed=print_suppressed, append_space=append_space,
+                      default_completer=default_completer)
+
+        if "_ARGCOMPLETE" not in os.environ:
+            # not an argument completion invocation
+            return
+
+        global debug_stream
+        try:
+            debug_stream = os.fdopen(9, "w")
+        except:
+            debug_stream = sys.stderr
+        debug()
+
+        if output_stream is None:
+            filename = os.environ.get("_ARGCOMPLETE_STDOUT_FILENAME")
+            if filename is not None:
+                debug("Using output file {}".format(filename))
+                output_stream = open(filename, "wb")
+
+        if output_stream is None:
+            try:
+                output_stream = os.fdopen(8, "wb")
+            except:
+                debug("Unable to open fd 8 for writing, quitting")
+                exit_method(1)
+
+        # print("", stream=debug_stream)
+        # for v in "COMP_CWORD COMP_LINE COMP_POINT COMP_TYPE COMP_KEY _ARGCOMPLETE_COMP_WORDBREAKS COMP_WORDS".split():
+        #     print(v, os.environ[v], stream=debug_stream)
+
+        ifs = os.environ.get("_ARGCOMPLETE_IFS", "\013")
+        if len(ifs) != 1:
+            debug("Invalid value for IFS, quitting [{v}]".format(v=ifs))
+            exit_method(1)
+
+        dfs = os.environ.get("_ARGCOMPLETE_DFS")
+        if dfs and len(dfs) != 1:
+            debug("Invalid value for DFS, quitting [{v}]".format(v=dfs))
+            exit_method(1)
+
+        comp_line = os.environ["COMP_LINE"]
+        comp_point = int(os.environ["COMP_POINT"])
+
+        comp_line = ensure_str(comp_line)
+        cword_prequote, cword_prefix, cword_suffix, comp_words, last_wordbreak_pos = split_line(comp_line, comp_point)
+
+        # _ARGCOMPLETE is set by the shell script to tell us where comp_words
+        # should start, based on what we're completing.
+        # 1: <script> [args]
+        # 2: python <script> [args]
+        # 3: python -m <module> [args]
+        start = int(os.environ["_ARGCOMPLETE"]) - 1
+        comp_words = comp_words[start:]
+
+        if cword_prefix and cword_prefix[0] in self._parser.prefix_chars and "=" in cword_prefix:
+            # Special case for when the current word is "--optional=PARTIAL_VALUE". Give the optional to the parser.
+            comp_words.append(cword_prefix.split("=", 1)[0])
+
+        debug("\nLINE: {!r}".format(comp_line),
+              "\nPOINT: {!r}".format(comp_point),
+              "\nPREQUOTE: {!r}".format(cword_prequote),
+              "\nPREFIX: {!r}".format(cword_prefix),
+              "\nSUFFIX: {!r}".format(cword_suffix),
+              "\nWORDS:", comp_words)
+
+        completions = self._get_completions(comp_words, cword_prefix, cword_prequote, last_wordbreak_pos)
+
+        if dfs:
+            display_completions = {key_part: value.replace(ifs, " ") if value else ""
+                                   for key, value in self._display_completions.items()
+                                   for key_part in key}
+            completions = [dfs.join((key, display_completions.get(key) or "")) for key in completions]
+
+        debug("\nReturning completions:", completions)
+        output_stream.write(ifs.join(completions).encode(sys_encoding))
+        output_stream.flush()
+        debug_stream.flush()
+        exit_method(0)
+
+    def _get_completions(self, comp_words, cword_prefix, cword_prequote, last_wordbreak_pos):
+        active_parsers = self._patch_argument_parser()
+
+        parsed_args = argparse.Namespace()
+        self.completing = True
+
+        if USING_PYTHON2:
+            # Python 2 argparse only properly works with byte strings.
+            comp_words = [ensure_bytes(word) for word in comp_words]
+
+        try:
+            debug("invoking parser with", comp_words[1:])
+            with mute_stderr():
+                a = self._parser.parse_known_args(comp_words[1:], namespace=parsed_args)
+            debug("parsed args:", a)
+        except BaseException as e:
+            debug("\nexception", type(e), str(e), "while parsing args")
+
+        self.completing = False
+
+        if "--" in comp_words:
+            self.always_complete_options = False
+
+        completions = self.collect_completions(active_parsers, parsed_args, cword_prefix, debug)
+        completions = self.filter_completions(completions)
+        completions = self.quote_completions(completions, cword_prequote, last_wordbreak_pos)
+        return completions
+
+    def _patch_argument_parser(self):
+        """
+        Since argparse doesn't support much introspection, we monkey-patch it to replace the parse_known_args method and
+        all actions with hooks that tell us which action was last taken or about to be taken, and let us have the parser
+        figure out which subparsers need to be activated (then recursively monkey-patch those).
+        We save all active ArgumentParsers to extract all their possible option names later.
+        """
+        self.active_parsers = []
+        self.visited_positionals = []
+
+        completer = self
+
+        def patch(parser):
+            completer.visited_positionals.append(parser)
+            completer.active_parsers.append(parser)
+
+            if isinstance(parser, IntrospectiveArgumentParser):
+                return
+
+            classname = "MonkeyPatchedIntrospectiveArgumentParser"
+            if USING_PYTHON2:
+                classname = bytes(classname)
+            parser.__class__ = type(classname, (IntrospectiveArgumentParser, parser.__class__), {})
+
+            for action in parser._actions:
+
+                if hasattr(action, "_orig_class"):
+                    continue
+
+                # TODO: accomplish this with super
+                class IntrospectAction(action.__class__):
+                    def __call__(self, parser, namespace, values, option_string=None):
+                        debug("Action stub called on", self)
+                        debug("\targs:", parser, namespace, values, option_string)
+                        debug("\torig class:", self._orig_class)
+                        debug("\torig callable:", self._orig_callable)
+
+                        if not completer.completing:
+                            self._orig_callable(parser, namespace, values, option_string=option_string)
+                        elif issubclass(self._orig_class, argparse._SubParsersAction):
+                            debug("orig class is a subparsers action: patching and running it")
+                            patch(self._name_parser_map[values[0]])
+                            self._orig_callable(parser, namespace, values, option_string=option_string)
+                        elif self._orig_class in safe_actions:
+                            if not self.option_strings:
+                                completer.visited_positionals.append(self)
+
+                            self._orig_callable(parser, namespace, values, option_string=option_string)
+
+                action._orig_class = action.__class__
+                action._orig_callable = action.__call__
+                action.__class__ = IntrospectAction
+
+        patch(self._parser)
+
+        debug("Active parsers:", self.active_parsers)
+        debug("Visited positionals:", self.visited_positionals)
+
+        return self.active_parsers
+
+    def _get_subparser_completions(self, parser, cword_prefix):
+        def filter_aliases(aliases, prefix):
+            return tuple(x for x in aliases if x.startswith(prefix))
+
+        aliases_by_parser = {}
+        for key in parser.choices.keys():
+            p = parser.choices[key]
+            aliases_by_parser.setdefault(p, []).append(key)
+
+        for action in parser._get_subactions():
+            subcmd_with_aliases = filter_aliases(aliases_by_parser[parser.choices[action.dest]], cword_prefix)
+            if subcmd_with_aliases:
+                self._display_completions[subcmd_with_aliases] = action.help
+
+        completions = [subcmd for subcmd in parser.choices.keys() if subcmd.startswith(cword_prefix)]
+        return completions
+
+    def _include_options(self, action, cword_prefix):
+        if len(cword_prefix) > 0 or self.always_complete_options is True:
+            return [ensure_str(opt) for opt in action.option_strings if ensure_str(opt).startswith(cword_prefix)]
+        long_opts = [ensure_str(opt) for opt in action.option_strings if len(opt) > 2]
+        short_opts = [ensure_str(opt) for opt in action.option_strings if len(opt) <= 2]
+        if self.always_complete_options == "long":
+            return long_opts if long_opts else short_opts
+        elif self.always_complete_options == "short":
+            return short_opts if short_opts else long_opts
+        return []
+
+    def _get_option_completions(self, parser, cword_prefix):
+        self._display_completions.update(
+            [[tuple(ensure_str(x) for x in action.option_strings
+             if ensure_str(x).startswith(cword_prefix)), action.help]
+             for action in parser._actions
+             if action.option_strings])
+
+        option_completions = []
+        for action in parser._actions:
+            if not self.print_suppressed:
+                completer = getattr(action, "completer", None)
+                if isinstance(completer, SuppressCompleter) and completer.suppress():
+                    continue
+                if action.help == argparse.SUPPRESS:
+                    continue
+            if not self._action_allowed(action, parser):
+                continue
+            if not isinstance(action, argparse._SubParsersAction):
+                option_completions += self._include_options(action, cword_prefix)
+        return option_completions
+
+    @staticmethod
+    def _action_allowed(action, parser):
+        # Logic adapted from take_action in ArgumentParser._parse_known_args
+        # (members are saved by my_argparse.IntrospectiveArgumentParser)
+        for conflict_action in parser._action_conflicts.get(action, []):
+            if conflict_action in parser._seen_non_default_actions:
+                return False
+        return True
+
+    def _complete_active_option(self, parser, next_positional, cword_prefix, parsed_args, completions):
+        debug("Active actions (L={l}): {a}".format(l=len(parser.active_actions), a=parser.active_actions))
+
+        isoptional = cword_prefix and cword_prefix[0] in parser.prefix_chars
+        optional_prefix = ""
+        greedy_actions = [x for x in parser.active_actions if action_is_greedy(x, isoptional)]
+        if greedy_actions:
+            assert len(greedy_actions) == 1, "expect at most 1 greedy action"
+            # This means the action will fail to parse if the word under the cursor is not given
+            # to it, so give it exclusive control over completions (flush previous completions)
+            debug("Resetting completions because", greedy_actions[0], "must consume the next argument")
+            self._display_completions = {}
+            completions = []
+        elif isoptional:
+            if "=" in cword_prefix:
+                # Special case for when the current word is "--optional=PARTIAL_VALUE".
+                # The completer runs on PARTIAL_VALUE. The prefix is added back to the completions
+                # (and chopped back off later in quote_completions() by the COMP_WORDBREAKS logic).
+                optional_prefix, _, cword_prefix = cword_prefix.partition("=")
+            else:
+                # Only run completers if current word does not start with - (is not an optional)
+                return completions
+
+        complete_remaining_positionals = False
+        # Use the single greedy action (if there is one) or all active actions.
+        for active_action in greedy_actions or parser.active_actions:
+            if not active_action.option_strings:  # action is a positional
+                if action_is_open(active_action):
+                    # Any positional arguments after this may slide down into this action
+                    # if more arguments are added (since the user may not be done yet),
+                    # so it is extremely difficult to tell which completers to run.
+                    # Running all remaining completers will probably show more than the user wants
+                    # but it also guarantees we won't miss anything.
+                    complete_remaining_positionals = True
+                if not complete_remaining_positionals:
+                    if action_is_satisfied(active_action) and not action_is_open(active_action):
+                        debug("Skipping", active_action)
+                        continue
+
+            debug("Activating completion for", active_action, active_action._orig_class)
+            # completer = getattr(active_action, "completer", DefaultCompleter())
+            completer = getattr(active_action, "completer", None)
+
+            if completer is None:
+                if active_action.choices is not None and not isinstance(active_action, argparse._SubParsersAction):
+                    completer = completers.ChoicesCompleter(active_action.choices)
+                elif not isinstance(active_action, argparse._SubParsersAction):
+                    completer = self.default_completer
+
+            if completer:
+                if isinstance(completer, SuppressCompleter) and completer.suppress():
+                    continue
+
+                if callable(completer):
+                    completions_from_callable = [c for c in completer(
+                        prefix=cword_prefix, action=active_action, parser=parser, parsed_args=parsed_args)
+                        if self.validator(c, cword_prefix)]
+
+                    if completions_from_callable:
+                        completions += completions_from_callable
+                        if isinstance(completer, completers.ChoicesCompleter):
+                            self._display_completions.update(
+                                [[(x,), active_action.help] for x in completions_from_callable])
+                        else:
+                            self._display_completions.update(
+                                [[(x,), ""] for x in completions_from_callable])
+                else:
+                    debug("Completer is not callable, trying the readline completer protocol instead")
+                    for i in range(9999):
+                        next_completion = completer.complete(cword_prefix, i)
+                        if next_completion is None:
+                            break
+                        if self.validator(next_completion, cword_prefix):
+                            self._display_completions.update({(next_completion,): ""})
+                            completions.append(next_completion)
+                if optional_prefix:
+                    completions = [optional_prefix + "=" + completion for completion in completions]
+                debug("Completions:", completions)
+        return completions
+
+    def collect_completions(self, active_parsers, parsed_args, cword_prefix, debug):
+        """
+        Visits the active parsers and their actions, executes their completers or introspects them to collect their
+        option strings. Returns the resulting completions as a list of strings.
+
+        This method is exposed for overriding in subclasses; there is no need to use it directly.
+        """
+        completions = []
+
+        debug("all active parsers:", active_parsers)
+        active_parser = active_parsers[-1]
+        debug("active_parser:", active_parser)
+        if self.always_complete_options or (len(cword_prefix) > 0 and cword_prefix[0] in active_parser.prefix_chars):
+            completions += self._get_option_completions(active_parser, cword_prefix)
+        debug("optional options:", completions)
+
+        next_positional = self._get_next_positional()
+        debug("next_positional:", next_positional)
+
+        if isinstance(next_positional, argparse._SubParsersAction):
+            completions += self._get_subparser_completions(next_positional, cword_prefix)
+
+        completions = self._complete_active_option(active_parser, next_positional, cword_prefix, parsed_args,
+                                                   completions)
+        debug("active options:", completions)
+        debug("display completions:", self._display_completions)
+
+        return completions
+
+    def _get_next_positional(self):
+        """
+        Get the next positional action if it exists.
+        """
+        active_parser = self.active_parsers[-1]
+        last_positional = self.visited_positionals[-1]
+
+        all_positionals = active_parser._get_positional_actions()
+        if not all_positionals:
+            return None
+
+        if active_parser == last_positional:
+            return all_positionals[0]
+
+        i = 0
+        for i in range(len(all_positionals)):
+            if all_positionals[i] == last_positional:
+                break
+
+        if i + 1 < len(all_positionals):
+            return all_positionals[i + 1]
+
+        return None
+
+    def filter_completions(self, completions):
+        """
+        Ensures collected completions are Unicode text, de-duplicates them, and excludes those specified by ``exclude``.
+        Returns the filtered completions as an iterable.
+
+        This method is exposed for overriding in subclasses; there is no need to use it directly.
+        """
+        # On Python 2, we have to make sure all completions are unicode objects before we continue and output them.
+        # Otherwise, because python disobeys the system locale encoding and uses ascii as the default encoding, it will
+        # try to implicitly decode string objects using ascii, and fail.
+        completions = [ensure_str(c) for c in completions]
+
+        # De-duplicate completions and remove excluded ones
+        if self.exclude is None:
+            self.exclude = set()
+        seen = set(self.exclude)
+        return [c for c in completions if c not in seen and not seen.add(c)]
+
+    def quote_completions(self, completions, cword_prequote, last_wordbreak_pos):
+        """
+        If the word under the cursor started with a quote (as indicated by a nonempty ``cword_prequote``), escapes
+        occurrences of that quote character in the completions, and adds the quote to the beginning of each completion.
+        Otherwise, escapes all characters that bash splits words on (``COMP_WORDBREAKS``), and removes portions of
+        completions before the first colon if (``COMP_WORDBREAKS``) contains a colon.
+
+        If there is only one completion, and it doesn't end with a **continuation character** (``/``, ``:``, or ``=``),
+        adds a space after the completion.
+
+        This method is exposed for overriding in subclasses; there is no need to use it directly.
+        """
+        special_chars = "\\"
+        # If the word under the cursor was quoted, escape the quote char.
+        # Otherwise, escape all special characters and specially handle all COMP_WORDBREAKS chars.
+        if cword_prequote == "":
+            # Bash mangles completions which contain characters in COMP_WORDBREAKS.
+            # This workaround has the same effect as __ltrim_colon_completions in bash_completion
+            # (extended to characters other than the colon).
+            if last_wordbreak_pos:
+                completions = [c[last_wordbreak_pos + 1:] for c in completions]
+            special_chars += "();<>|&!`$* \t\n\"'"
+        elif cword_prequote == '"':
+            special_chars += '"`$!'
+
+        if os.environ.get("_ARGCOMPLETE_SHELL") in ("tcsh", "fish"):
+            # tcsh and fish escapes special characters itself.
+            special_chars = ""
+        elif cword_prequote == "'":
+            # Nothing can be escaped in single quotes, so we need to close
+            # the string, escape the single quote, then open a new string.
+            special_chars = ""
+            completions = [c.replace("'", r"'\''") for c in completions]
+
+        for char in special_chars:
+            completions = [c.replace(char, "\\" + char) for c in completions]
+
+        if self.append_space:
+            # Similar functionality in bash was previously turned off by supplying the "-o nospace" option to complete.
+            # Now it is conditionally disabled using "compopt -o nospace" if the match ends in a continuation character.
+            # This code is retained for environments where this isn't done natively.
+            continuation_chars = "=/:"
+            if len(completions) == 1 and completions[0][-1] not in continuation_chars:
+                if cword_prequote == "":
+                    completions[0] += " "
+
+        return completions
+
+    def rl_complete(self, text, state):
+        """
+        Alternate entry point for using the argcomplete completer in a readline-based REPL. See also
+        `rlcompleter <https://docs.python.org/2/library/rlcompleter.html#completer-objects>`_.
+        Usage:
+
+        .. code-block:: python
+
+            import argcomplete, argparse, readline
+            parser = argparse.ArgumentParser()
+            ...
+            completer = argcomplete.CompletionFinder(parser)
+            readline.set_completer_delims("")
+            readline.set_completer(completer.rl_complete)
+            readline.parse_and_bind("tab: complete")
+            result = input("prompt> ")
+
+        (Use ``raw_input`` instead of ``input`` on Python 2, or use `eight <https://github.com/kislyuk/eight>`_).
+        """
+        if state == 0:
+            cword_prequote, cword_prefix, cword_suffix, comp_words, first_colon_pos = split_line(text)
+            comp_words.insert(0, sys.argv[0])
+            matches = self._get_completions(comp_words, cword_prefix, cword_prequote, first_colon_pos)
+            self._rl_matches = [text + match[len(cword_prefix):] for match in matches]
+
+        if state < len(self._rl_matches):
+            return self._rl_matches[state]
+        else:
+            return None
+
+    def get_display_completions(self):
+        """
+        This function returns a mapping of option names to their help strings for displaying to the user
+
+        Usage:
+
+        .. code-block:: python
+
+            def display_completions(substitution, matches, longest_match_length):
+                _display_completions = argcomplete.autocomplete.get_display_completions()
+                print("")
+                if _display_completions:
+                    help_len = [len(x) for x in _display_completions.values() if x]
+
+                    if help_len:
+                        maxlen = max([len(x) for x in _display_completions])
+                        print("\\n".join("{0:{2}} -- {1}".format(k, v, maxlen)
+                                        for k, v in sorted(_display_completions.items())))
+                    else:
+                        print("    ".join(k for k in sorted(_display_completions)))
+                else:
+                    print(" ".join(x for x in sorted(matches)))
+
+                import readline
+                print("cli /> {0}".format(readline.get_line_buffer()), end="")
+                readline.redisplay()
+
+            ...
+            readline.set_completion_display_matches_hook(display_completions)
+
+        """
+        return {" ".join(k): v for k, v in self._display_completions.items()}
+
+class ExclusiveCompletionFinder(CompletionFinder):
+    @staticmethod
+    def _action_allowed(action, parser):
+        if not CompletionFinder._action_allowed(action, parser):
+            return False
+
+        append_classes = (argparse._AppendAction, argparse._AppendConstAction)
+        if action._orig_class in append_classes:
+            return True
+
+        if action not in parser._seen_non_default_actions:
+            return True
+
+        return False
+
+autocomplete = CompletionFinder()
+autocomplete.__doc__ = """ Use this to access argcomplete. See :meth:`argcomplete.CompletionFinder.__call__()`. """
+
+def warn(*args):
+    """
+    Prints **args** to standard error when running completions. This will interrupt the user's command line interaction;
+    use it to indicate an error condition that is preventing your completer from working.
+    """
+    print("\n", file=debug_stream, *args)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/_check_console_script.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/_check_console_script.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/_check_module.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/_check_module.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/compat.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/compat.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/completers.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/completers.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/my_argparse.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/my_argparse.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/my_shlex.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/my_shlex.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/__pycache__/shell_integration.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/argcomplete/__pycache__/shell_integration.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/_check_console_script.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/_check_console_script.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,57 @@
+"""
+Utility for locating the module (or package's __init__.py)
+associated with a given console_script name
+and verifying it contains the PYTHON_ARGCOMPLETE_OK marker.
+
+Such scripts are automatically generated and cannot contain
+the marker themselves, so we defer to the containing module or package.
+
+For more information on setuptools console_scripts, see
+https://setuptools.readthedocs.io/en/latest/setuptools.html#automatic-script-creation
+
+Intended to be invoked by argcomplete's global completion function.
+"""
+import os
+import sys
+
+try:
+    from importlib.metadata import entry_points as importlib_entry_points
+except ImportError:
+    from importlib_metadata import entry_points as importlib_entry_points
+
+from ._check_module import ArgcompleteMarkerNotFound, find
+
+
+def main():
+    # Argument is the full path to the console script.
+    script_path = sys.argv[1]
+
+    # Find the module and function names that correspond to this
+    # assuming it is actually a console script.
+    name = os.path.basename(script_path)
+    entry_points = [ep for ep in importlib_entry_points()["console_scripts"] if ep.name == name]
+    if not entry_points:
+        raise ArgcompleteMarkerNotFound('no entry point found matching script')
+    entry_point = entry_points[0]
+    module_name, function_name = entry_point.value.split(":", 1)
+
+    # Check this looks like the script we really expected.
+    with open(script_path) as f:
+        script = f.read()
+    if 'from {} import {}'.format(module_name, function_name) not in script:
+        raise ArgcompleteMarkerNotFound('does not appear to be a console script')
+    if 'sys.exit({}())'.format(function_name) not in script:
+        raise ArgcompleteMarkerNotFound('does not appear to be a console script')
+
+    # Look for the argcomplete marker in the script it imports.
+    with open(find(module_name, return_package=True)) as f:
+        head = f.read(1024)
+    if 'PYTHON_ARGCOMPLETE_OK' not in head:
+        raise ArgcompleteMarkerNotFound('marker not found')
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except ArgcompleteMarkerNotFound as e:
+        sys.exit(e)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/_check_module.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/_check_module.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,92 @@
+"""
+Utility for locating a module (or package's __main__.py) with a given name
+and verifying it contains the PYTHON_ARGCOMPLETE_OK marker.
+
+The module name should be specified in a form usable with `python -m`.
+
+Intended to be invoked by argcomplete's global completion function.
+"""
+import os
+import sys
+import tokenize
+
+try:
+    from importlib.util import find_spec
+except ImportError:
+    from collections import namedtuple
+    from imp import find_module
+
+    ModuleSpec = namedtuple(
+        'ModuleSpec', ['origin', 'has_location', 'submodule_search_locations'])
+
+    def find_spec(name):
+        """Minimal implementation as required by `find`."""
+        try:
+            f, path, _ = find_module(name)
+        except ImportError:
+            return None
+        has_location = path is not None
+        if f is None:
+            return ModuleSpec(None, has_location, [path])
+        f.close()
+        return ModuleSpec(path, has_location, None)
+
+
+class ArgcompleteMarkerNotFound(RuntimeError):
+    pass
+
+
+def find(name, return_package=False):
+    names = name.split('.')
+    spec = find_spec(names[0])
+    if spec is None:
+        raise ArgcompleteMarkerNotFound(
+            'no module named "{}"'.format(names[0]))
+    if not spec.has_location:
+        raise ArgcompleteMarkerNotFound('cannot locate file')
+    if spec.submodule_search_locations is None:
+        if len(names) != 1:
+            raise ArgcompleteMarkerNotFound(
+                '{} is not a package'.format(names[0]))
+        return spec.origin
+    if len(spec.submodule_search_locations) != 1:
+        raise ArgcompleteMarkerNotFound('expecting one search location')
+    path = os.path.join(spec.submodule_search_locations[0], *names[1:])
+    if os.path.isdir(path):
+        filename = '__main__.py'
+        if return_package:
+            filename = '__init__.py'
+        return os.path.join(path, filename)
+    else:
+        return path + '.py'
+
+
+def main():
+    try:
+        name = sys.argv[1]
+    except IndexError:
+        raise ArgcompleteMarkerNotFound('missing argument on the command line')
+
+    filename = find(name)
+    if hasattr(tokenize, 'open'):
+        open_func = tokenize.open
+    else:
+        open_func = open
+
+    try:
+        fp = open_func(filename)
+    except OSError:
+        raise ArgcompleteMarkerNotFound('cannot open file')
+
+    with fp:
+        head = fp.read(1024)
+
+    if 'PYTHON_ARGCOMPLETE_OK' not in head:
+        raise ArgcompleteMarkerNotFound('marker not found')
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except ArgcompleteMarkerNotFound as e:
+        sys.exit(e)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/bash_completion.d/python-argcomplete
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/bash_completion.d/python-argcomplete	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,106 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+# Copy of __expand_tilde_by_ref from bash-completion
+__python_argcomplete_expand_tilde_by_ref () {
+    if [ "${!1:0:1}" = "~" ]; then
+        if [ "${!1}" != "${!1//\/}" ]; then
+            eval $1="${!1/%\/*}"/'${!1#*/}';
+        else
+            eval $1="${!1}";
+        fi;
+    fi
+}
+
+# Run something, muting output or redirecting it to the debug stream
+# depending on the value of _ARC_DEBUG.
+# If ARGCOMPLETE_USE_TEMPFILES is set, use tempfiles for IPC.
+__python_argcomplete_run() {
+    if [[ -z "${ARGCOMPLETE_USE_TEMPFILES-}" ]]; then
+        __python_argcomplete_run_inner "$@"
+        return
+    fi
+    local tmpfile="$(mktemp)"
+    _ARGCOMPLETE_STDOUT_FILENAME="$tmpfile" __python_argcomplete_run_inner "$@"
+    local code=$?
+    cat "$tmpfile"
+    rm "$tmpfile"
+    return $code
+}
+
+__python_argcomplete_run_inner() {
+    if [[ -z "${_ARC_DEBUG-}" ]]; then
+        "$@" 8>&1 9>&2 1>/dev/null 2>&1
+    else
+        "$@" 8>&1 9>&2 1>&9 2>&1
+    fi
+}
+
+# Scan the beginning of an executable file ($1) for a regexp ($2). By default,
+# scan for the magic string indicating that the executable supports the
+# argcomplete completion protocol. By default, scan the first kilobyte;
+# if $3 is set to -n, scan until the first line break up to a kilobyte.
+__python_argcomplete_scan_head() {
+    read -s -r ${3:--N} 1024 < "$1"
+    [[ "$REPLY" =~ ${2:-PYTHON_ARGCOMPLETE_OK} ]]
+}
+
+__python_argcomplete_scan_head_noerr() {
+    __python_argcomplete_scan_head "$@" 2>/dev/null
+}
+
+_python_argcomplete_global() {
+    local executable=$1
+    __python_argcomplete_expand_tilde_by_ref executable
+
+    local ARGCOMPLETE=0
+    if [[ "$executable" == python* ]] || [[ "$executable" == pypy* ]]; then
+        if [[ "${COMP_WORDS[1]}" == -m ]]; then
+            if __python_argcomplete_run "$executable" -m argcomplete._check_module "${COMP_WORDS[2]}"; then
+                ARGCOMPLETE=3
+            else
+                return
+            fi
+        elif [[ -f "${COMP_WORDS[1]}" ]] && __python_argcomplete_scan_head_noerr "${COMP_WORDS[1]}"; then
+            local ARGCOMPLETE=2
+        else
+            return
+        fi
+    elif type -P "$executable" >/dev/null 2>&1; then
+        local SCRIPT_NAME=$(type -P "$executable")
+        if (type -t pyenv && [[ "$SCRIPT_NAME" = $(pyenv root)/shims/* ]]) >/dev/null 2>&1; then
+            local SCRIPT_NAME=$(pyenv which "$executable")
+        fi
+        if __python_argcomplete_scan_head_noerr "$SCRIPT_NAME"; then
+            local ARGCOMPLETE=1
+        elif __python_argcomplete_scan_head_noerr "$SCRIPT_NAME" '^#!(.*)$' -n && [[ "${BASH_REMATCH[1]}" =~ ^.*(python|pypy)[0-9\.]*$ ]]; then
+            local interpreter="$BASH_REMATCH"
+            if (__python_argcomplete_scan_head_noerr "$SCRIPT_NAME" "(PBR Generated)|(EASY-INSTALL-(SCRIPT|ENTRY-SCRIPT|DEV-SCRIPT))" \
+                && "$interpreter" "$(type -P python-argcomplete-check-easy-install-script)" "$SCRIPT_NAME") >/dev/null 2>&1; then
+                local ARGCOMPLETE=1
+            elif __python_argcomplete_run "$interpreter" -m argcomplete._check_console_script "$SCRIPT_NAME"; then
+                local ARGCOMPLETE=1
+            fi
+        fi
+    fi
+
+    if [[ $ARGCOMPLETE != 0 ]]; then
+        local IFS=$(echo -e '\v')
+        COMPREPLY=( $(_ARGCOMPLETE_IFS="$IFS" \
+            COMP_LINE="$COMP_LINE" \
+            COMP_POINT="$COMP_POINT" \
+            COMP_TYPE="$COMP_TYPE" \
+            _ARGCOMPLETE_COMP_WORDBREAKS="$COMP_WORDBREAKS" \
+            _ARGCOMPLETE=$ARGCOMPLETE \
+            _ARGCOMPLETE_SUPPRESS_SPACE=1 \
+            __python_argcomplete_run "$executable" "${COMP_WORDS[@]:1:ARGCOMPLETE-1}") )
+        if [[ $? != 0 ]]; then
+            unset COMPREPLY
+        elif [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
+            compopt -o nospace
+        fi
+    else
+        type -t _completion_loader | grep -q 'function' && _completion_loader "$@"
+    fi
+}
+complete -o default -o bashdefault -D -F _python_argcomplete_global
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/compat.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/compat.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,25 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import locale
+import sys
+
+sys_encoding = locale.getpreferredencoding()
+
+USING_PYTHON2 = True if sys.version_info < (3, 0) else False
+
+if USING_PYTHON2:
+    str = unicode  # noqa
+else:
+    str = str
+
+
+def ensure_bytes(x, encoding=sys_encoding):
+    if not isinstance(x, bytes):
+        x = x.encode(encoding)
+    return x
+
+
+def ensure_str(x, encoding=sys_encoding):
+    if not isinstance(x, str):
+        x = x.decode(encoding)
+    return x
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/completers.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/completers.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,108 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os
+import subprocess
+from .compat import str, sys_encoding
+
+def _call(*args, **kwargs):
+    try:
+        return subprocess.check_output(*args, **kwargs).decode(sys_encoding).splitlines()
+    except subprocess.CalledProcessError:
+        return []
+
+class ChoicesCompleter(object):
+    def __init__(self, choices):
+        self.choices = choices
+
+    def _convert(self, choice):
+        if isinstance(choice, bytes):
+            choice = choice.decode(sys_encoding)
+        if not isinstance(choice, str):
+            choice = str(choice)
+        return choice
+
+    def __call__(self, **kwargs):
+        return (self._convert(c) for c in self.choices)
+
+EnvironCompleter = ChoicesCompleter(os.environ)
+
+class FilesCompleter(object):
+    """
+    File completer class, optionally takes a list of allowed extensions
+    """
+
+    def __init__(self, allowednames=(), directories=True):
+        # Fix if someone passes in a string instead of a list
+        if isinstance(allowednames, (str, bytes)):
+            allowednames = [allowednames]
+
+        self.allowednames = [x.lstrip("*").lstrip(".") for x in allowednames]
+        self.directories = directories
+
+    def __call__(self, prefix, **kwargs):
+        completion = []
+        if self.allowednames:
+            if self.directories:
+                files = _call(["bash", "-c", "compgen -A directory -- '{p}'".format(p=prefix)])
+                completion += [f + "/" for f in files]
+            for x in self.allowednames:
+                completion += _call(["bash", "-c", "compgen -A file -X '!*.{0}' -- '{p}'".format(x, p=prefix)])
+        else:
+            completion += _call(["bash", "-c", "compgen -A file -- '{p}'".format(p=prefix)])
+            anticomp = _call(["bash", "-c", "compgen -A directory -- '{p}'".format(p=prefix)])
+            completion = list(set(completion) - set(anticomp))
+
+            if self.directories:
+                completion += [f + "/" for f in anticomp]
+        return completion
+
+class _FilteredFilesCompleter(object):
+    def __init__(self, predicate):
+        """
+        Create the completer
+
+        A predicate accepts as its only argument a candidate path and either
+        accepts it or rejects it.
+        """
+        assert predicate, "Expected a callable predicate"
+        self.predicate = predicate
+
+    def __call__(self, prefix, **kwargs):
+        """
+        Provide completions on prefix
+        """
+        target_dir = os.path.dirname(prefix)
+        try:
+            names = os.listdir(target_dir or ".")
+        except:
+            return  # empty iterator
+        incomplete_part = os.path.basename(prefix)
+        # Iterate on target_dir entries and filter on given predicate
+        for name in names:
+            if not name.startswith(incomplete_part):
+                continue
+            candidate = os.path.join(target_dir, name)
+            if not self.predicate(candidate):
+                continue
+            yield candidate + "/" if os.path.isdir(candidate) else candidate
+
+class DirectoriesCompleter(_FilteredFilesCompleter):
+    def __init__(self):
+        _FilteredFilesCompleter.__init__(self, predicate=os.path.isdir)
+
+class SuppressCompleter(object):
+    """
+    A completer used to suppress the completion of specific arguments
+    """
+
+    def __init__(self):
+        pass
+
+    def suppress(self):
+        """
+        Decide if the completion should be suppressed
+        """
+        return True
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/my_argparse.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/my_argparse.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,331 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+from argparse import ArgumentParser, ArgumentError, SUPPRESS, _SubParsersAction
+from argparse import OPTIONAL, ZERO_OR_MORE, ONE_OR_MORE, REMAINDER, PARSER
+from argparse import _get_action_name, _
+
+_num_consumed_args = {}
+
+
+def action_is_satisfied(action):
+    ''' Returns False if the parse would raise an error if no more arguments are given to this action, True otherwise.
+    '''
+    num_consumed_args = _num_consumed_args.get(action, 0)
+
+    if action.nargs in [OPTIONAL, ZERO_OR_MORE, REMAINDER]:
+        return True
+    if action.nargs == ONE_OR_MORE:
+        return num_consumed_args >= 1
+    if action.nargs == PARSER:
+        # Not sure what this should be, but this previously always returned False
+        # so at least this won't break anything that wasn't already broken.
+        return False
+    if action.nargs is None:
+        return num_consumed_args == 1
+
+    assert isinstance(action.nargs, int), 'failed to handle a possible nargs value: %r' % action.nargs
+    return num_consumed_args == action.nargs
+
+
+def action_is_open(action):
+    ''' Returns True if action could consume more arguments (i.e., its pattern is open).
+    '''
+    num_consumed_args = _num_consumed_args.get(action, 0)
+
+    if action.nargs in [ZERO_OR_MORE, ONE_OR_MORE, PARSER, REMAINDER]:
+        return True
+    if action.nargs == OPTIONAL or action.nargs is None:
+        return num_consumed_args == 0
+
+    assert isinstance(action.nargs, int), 'failed to handle a possible nargs value: %r' % action.nargs
+    return num_consumed_args < action.nargs
+
+
+def action_is_greedy(action, isoptional=False):
+    ''' Returns True if action will necessarily consume the next argument.
+    isoptional indicates whether the argument is an optional (starts with -).
+    '''
+    num_consumed_args = _num_consumed_args.get(action, 0)
+
+    if action.option_strings:
+        if not isoptional and not action_is_satisfied(action):
+            return True
+        return action.nargs == REMAINDER
+    else:
+        return action.nargs == REMAINDER and num_consumed_args >= 1
+
+
+class IntrospectiveArgumentParser(ArgumentParser):
+    ''' The following is a verbatim copy of ArgumentParser._parse_known_args (Python 2.7.3),
+    except for the lines that contain the string "Added by argcomplete".
+    '''
+
+    def _parse_known_args(self, arg_strings, namespace):
+        _num_consumed_args.clear()  # Added by argcomplete
+        self._argcomplete_namespace = namespace
+        self.active_actions = []  # Added by argcomplete
+        # replace arg strings that are file references
+        if self.fromfile_prefix_chars is not None:
+            arg_strings = self._read_args_from_files(arg_strings)
+
+        # map all mutually exclusive arguments to the other arguments
+        # they can't occur with
+        action_conflicts = {}
+        self._action_conflicts = action_conflicts  # Added by argcomplete
+        for mutex_group in self._mutually_exclusive_groups:
+            group_actions = mutex_group._group_actions
+            for i, mutex_action in enumerate(mutex_group._group_actions):
+                conflicts = action_conflicts.setdefault(mutex_action, [])
+                conflicts.extend(group_actions[:i])
+                conflicts.extend(group_actions[i + 1:])
+
+        # find all option indices, and determine the arg_string_pattern
+        # which has an 'O' if there is an option at an index,
+        # an 'A' if there is an argument, or a '-' if there is a '--'
+        option_string_indices = {}
+        arg_string_pattern_parts = []
+        arg_strings_iter = iter(arg_strings)
+        for i, arg_string in enumerate(arg_strings_iter):
+
+            # all args after -- are non-options
+            if arg_string == '--':
+                arg_string_pattern_parts.append('-')
+                for arg_string in arg_strings_iter:
+                    arg_string_pattern_parts.append('A')
+
+            # otherwise, add the arg to the arg strings
+            # and note the index if it was an option
+            else:
+                option_tuple = self._parse_optional(arg_string)
+                if option_tuple is None:
+                    pattern = 'A'
+                else:
+                    option_string_indices[i] = option_tuple
+                    pattern = 'O'
+                arg_string_pattern_parts.append(pattern)
+
+        # join the pieces together to form the pattern
+        arg_strings_pattern = ''.join(arg_string_pattern_parts)
+
+        # converts arg strings to the appropriate and then takes the action
+        seen_actions = set()
+        seen_non_default_actions = set()
+        self._seen_non_default_actions = seen_non_default_actions  # Added by argcomplete
+
+        def take_action(action, argument_strings, option_string=None):
+            seen_actions.add(action)
+            argument_values = self._get_values(action, argument_strings)
+
+            # error if this argument is not allowed with other previously
+            # seen arguments, assuming that actions that use the default
+            # value don't really count as "present"
+            if argument_values is not action.default:
+                seen_non_default_actions.add(action)
+                for conflict_action in action_conflicts.get(action, []):
+                    if conflict_action in seen_non_default_actions:
+                        msg = _('not allowed with argument %s')
+                        action_name = _get_action_name(conflict_action)
+                        raise ArgumentError(action, msg % action_name)
+
+            # take the action if we didn't receive a SUPPRESS value
+            # (e.g. from a default)
+            if argument_values is not SUPPRESS \
+                    or isinstance(action, _SubParsersAction):
+                try:
+                    action(self, namespace, argument_values, option_string)
+                except:
+                    # Begin added by argcomplete
+                    # When a subparser action is taken and fails due to incomplete arguments, it does not merge the
+                    # contents of its parsed namespace into the parent namespace. Do that here to allow completers to
+                    # access the partially parsed arguments for the subparser.
+                    if isinstance(action, _SubParsersAction):
+                        subnamespace = action._name_parser_map[argument_values[0]]._argcomplete_namespace
+                        for key, value in vars(subnamespace).items():
+                            setattr(namespace, key, value)
+                    # End added by argcomplete
+                    raise
+
+        # function to convert arg_strings into an optional action
+        def consume_optional(start_index):
+
+            # get the optional identified at this index
+            option_tuple = option_string_indices[start_index]
+            action, option_string, explicit_arg = option_tuple
+
+            # identify additional optionals in the same arg string
+            # (e.g. -xyz is the same as -x -y -z if no args are required)
+            match_argument = self._match_argument
+            action_tuples = []
+            while True:
+
+                # if we found no optional action, skip it
+                if action is None:
+                    extras.append(arg_strings[start_index])
+                    return start_index + 1
+
+                # if there is an explicit argument, try to match the
+                # optional's string arguments to only this
+                if explicit_arg is not None:
+                    arg_count = match_argument(action, 'A')
+
+                    # if the action is a single-dash option and takes no
+                    # arguments, try to parse more single-dash options out
+                    # of the tail of the option string
+                    chars = self.prefix_chars
+                    if arg_count == 0 and option_string[1] not in chars:
+                        action_tuples.append((action, [], option_string))
+                        char = option_string[0]
+                        option_string = char + explicit_arg[0]
+                        new_explicit_arg = explicit_arg[1:] or None
+                        optionals_map = self._option_string_actions
+                        if option_string in optionals_map:
+                            action = optionals_map[option_string]
+                            explicit_arg = new_explicit_arg
+                        else:
+                            msg = _('ignored explicit argument %r')
+                            raise ArgumentError(action, msg % explicit_arg)
+
+                    # if the action expect exactly one argument, we've
+                    # successfully matched the option; exit the loop
+                    elif arg_count == 1:
+                        stop = start_index + 1
+                        args = [explicit_arg]
+                        action_tuples.append((action, args, option_string))
+                        break
+
+                    # error if a double-dash option did not use the
+                    # explicit argument
+                    else:
+                        msg = _('ignored explicit argument %r')
+                        raise ArgumentError(action, msg % explicit_arg)
+
+                # if there is no explicit argument, try to match the
+                # optional's string arguments with the following strings
+                # if successful, exit the loop
+                else:
+                    start = start_index + 1
+                    selected_patterns = arg_strings_pattern[start:]
+                    self.active_actions = [action]  # Added by argcomplete
+                    _num_consumed_args[action] = 0  # Added by argcomplete
+                    arg_count = match_argument(action, selected_patterns)
+                    stop = start + arg_count
+                    args = arg_strings[start:stop]
+
+                    # Begin added by argcomplete
+                    # If the pattern is not open (e.g. no + at the end), remove the action from active actions (since
+                    # it wouldn't be able to consume any more args)
+                    _num_consumed_args[action] = len(args)
+                    if not action_is_open(action):
+                        self.active_actions.remove(action)
+                    # End added by argcomplete
+
+                    action_tuples.append((action, args, option_string))
+                    break
+
+            # add the Optional to the list and return the index at which
+            # the Optional's string args stopped
+            assert action_tuples
+            for action, args, option_string in action_tuples:
+                take_action(action, args, option_string)
+            return stop
+
+        # the list of Positionals left to be parsed; this is modified
+        # by consume_positionals()
+        positionals = self._get_positional_actions()
+
+        # function to convert arg_strings into positional actions
+        def consume_positionals(start_index):
+            # match as many Positionals as possible
+            match_partial = self._match_arguments_partial
+            selected_pattern = arg_strings_pattern[start_index:]
+            arg_counts = match_partial(positionals, selected_pattern)
+
+            # slice off the appropriate arg strings for each Positional
+            # and add the Positional and its args to the list
+            for action, arg_count in zip(positionals, arg_counts):  # Added by argcomplete
+                self.active_actions.append(action)  # Added by argcomplete
+            for action, arg_count in zip(positionals, arg_counts):
+                args = arg_strings[start_index: start_index + arg_count]
+                start_index += arg_count
+                _num_consumed_args[action] = len(args)   # Added by argcomplete
+                take_action(action, args)
+
+            # slice off the Positionals that we just parsed and return the
+            # index at which the Positionals' string args stopped
+            positionals[:] = positionals[len(arg_counts):]
+            return start_index
+
+        # consume Positionals and Optionals alternately, until we have
+        # passed the last option string
+        extras = []
+        start_index = 0
+        if option_string_indices:
+            max_option_string_index = max(option_string_indices)
+        else:
+            max_option_string_index = -1
+        while start_index <= max_option_string_index:
+
+            # consume any Positionals preceding the next option
+            next_option_string_index = min([
+                index
+                for index in option_string_indices
+                if index >= start_index])
+            if start_index != next_option_string_index:
+                positionals_end_index = consume_positionals(start_index)
+
+                # only try to parse the next optional if we didn't consume
+                # the option string during the positionals parsing
+                if positionals_end_index > start_index:
+                    start_index = positionals_end_index
+                    continue
+                else:
+                    start_index = positionals_end_index
+
+            # if we consumed all the positionals we could and we're not
+            # at the index of an option string, there were extra arguments
+            if start_index not in option_string_indices:
+                strings = arg_strings[start_index:next_option_string_index]
+                extras.extend(strings)
+                start_index = next_option_string_index
+
+            # consume the next optional and any arguments for it
+            start_index = consume_optional(start_index)
+
+        # consume any positionals following the last Optional
+        stop_index = consume_positionals(start_index)
+
+        # if we didn't consume all the argument strings, there were extras
+        extras.extend(arg_strings[stop_index:])
+
+        # if we didn't use all the Positional objects, there were too few
+        # arg strings supplied.
+
+        if positionals:
+            self.active_actions.append(positionals[0])  # Added by argcomplete
+            self.error(_('too few arguments'))
+
+        # make sure all required actions were present
+        for action in self._actions:
+            if action.required:
+                if action not in seen_actions:
+                    name = _get_action_name(action)
+                    self.error(_('argument %s is required') % name)
+
+        # make sure all required groups had one option present
+        for group in self._mutually_exclusive_groups:
+            if group.required:
+                for action in group._group_actions:
+                    if action in seen_non_default_actions:
+                        break
+
+                # if no actions were used, report the error
+                else:
+                    names = [_get_action_name(action)
+                             for action in group._group_actions
+                             if action.help is not SUPPRESS]
+                    msg = _('one of the arguments %s is required')
+                    self.error(msg % ' '.join(names))
+
+        # return the updated namespace and the extra arguments
+        return namespace, extras
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/my_shlex.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/my_shlex.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*-
+
+# This copy of shlex.py from Python 3.6 is distributed with argcomplete.
+# It contains only the shlex class, with modifications as noted.
+
+"""A lexical analyzer class for simple shell-like syntaxes."""
+
+# Module and documentation by Eric S. Raymond, 21 Dec 1998
+# Input stacking and error message cleanup added by ESR, March 2000
+# push_source() and pop_source() made explicit by ESR, January 2001.
+# Posix compliance, split(), string arguments, and
+# iterator interface by Gustavo Niemeyer, April 2003.
+# changes to tokenize more like Posix shells by Vinay Sajip, July 2016.
+
+import os
+import sys
+from collections import deque
+
+# Modified by argcomplete: 2/3 compatibility
+# Note: cStringIO is not compatible with Unicode
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+# Modified by argcomplete: 2/3 compatibility
+try:
+    basestring
+except NameError:
+    basestring = str
+
+class shlex:
+    "A lexical analyzer class for simple shell-like syntaxes."
+    def __init__(self, instream=None, infile=None, posix=False,
+                 punctuation_chars=False):
+        # Modified by argcomplete: 2/3 compatibility
+        if isinstance(instream, basestring):
+            instream = StringIO(instream)
+        if instream is not None:
+            self.instream = instream
+            self.infile = infile
+        else:
+            self.instream = sys.stdin
+            self.infile = None
+        self.posix = posix
+        if posix:
+            self.eof = None
+        else:
+            self.eof = ''
+        self.commenters = '#'
+        self.wordchars = ('abcdfeghijklmnopqrstuvwxyz'
+                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_')
+        # Modified by argcomplete: 2/3 compatibility
+        # if self.posix:
+        #     self.wordchars += ('ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'
+        #                        'À�ÂÃÄÅÆÇÈÉÊËÌ�Î��ÑÒÓÔÕÖØÙÚÛÜ�Þ')
+        self.whitespace = ' \t\r\n'
+        self.whitespace_split = False
+        self.quotes = '\'"'
+        self.escape = '\\'
+        self.escapedquotes = '"'
+        self.state = ' '
+        self.pushback = deque()
+        self.lineno = 1
+        self.debug = 0
+        self.token = ''
+        self.filestack = deque()
+        self.source = None
+        if not punctuation_chars:
+            punctuation_chars = ''
+        elif punctuation_chars is True:
+            punctuation_chars = '();<>|&'
+        self.punctuation_chars = punctuation_chars
+        if punctuation_chars:
+            # _pushback_chars is a push back queue used by lookahead logic
+            self._pushback_chars = deque()
+            # these chars added because allowed in file names, args, wildcards
+            self.wordchars += '~-./*?='
+            #remove any punctuation chars from wordchars
+            t = self.wordchars.maketrans(dict.fromkeys(punctuation_chars))
+            self.wordchars = self.wordchars.translate(t)
+
+        # Modified by argcomplete: Record last wordbreak position
+        self.last_wordbreak_pos = None
+        self.wordbreaks = ''
+
+    def push_token(self, tok):
+        "Push a token onto the stack popped by the get_token method"
+        if self.debug >= 1:
+            print("shlex: pushing token " + repr(tok))
+        self.pushback.appendleft(tok)
+
+    def push_source(self, newstream, newfile=None):
+        "Push an input source onto the lexer's input source stack."
+        # Modified by argcomplete: 2/3 compatibility
+        if isinstance(newstream, basestring):
+            newstream = StringIO(newstream)
+        self.filestack.appendleft((self.infile, self.instream, self.lineno))
+        self.infile = newfile
+        self.instream = newstream
+        self.lineno = 1
+        if self.debug:
+            if newfile is not None:
+                print('shlex: pushing to file %s' % (self.infile,))
+            else:
+                print('shlex: pushing to stream %s' % (self.instream,))
+
+    def pop_source(self):
+        "Pop the input source stack."
+        self.instream.close()
+        (self.infile, self.instream, self.lineno) = self.filestack.popleft()
+        if self.debug:
+            print('shlex: popping to %s, line %d' \
+                  % (self.instream, self.lineno))
+        self.state = ' '
+
+    def get_token(self):
+        "Get a token from the input stream (or from stack if it's nonempty)"
+        if self.pushback:
+            tok = self.pushback.popleft()
+            if self.debug >= 1:
+                print("shlex: popping token " + repr(tok))
+            return tok
+        # No pushback.  Get a token.
+        raw = self.read_token()
+        # Handle inclusions
+        if self.source is not None:
+            while raw == self.source:
+                spec = self.sourcehook(self.read_token())
+                if spec:
+                    (newfile, newstream) = spec
+                    self.push_source(newstream, newfile)
+                raw = self.get_token()
+        # Maybe we got EOF instead?
+        while raw == self.eof:
+            if not self.filestack:
+                return self.eof
+            else:
+                self.pop_source()
+                raw = self.get_token()
+        # Neither inclusion nor EOF
+        if self.debug >= 1:
+            if raw != self.eof:
+                print("shlex: token=" + repr(raw))
+            else:
+                print("shlex: token=EOF")
+        return raw
+
+    def read_token(self):
+        quoted = False
+        escapedstate = ' '
+        while True:
+            if self.punctuation_chars and self._pushback_chars:
+                nextchar = self._pushback_chars.pop()
+            else:
+                nextchar = self.instream.read(1)
+            if nextchar == '\n':
+                self.lineno += 1
+            if self.debug >= 3:
+                print("shlex: in state %r I see character: %r" % (self.state,
+                                                                  nextchar))
+            if self.state is None:
+                self.token = ''        # past end of file
+                break
+            elif self.state == ' ':
+                if not nextchar:
+                    self.state = None  # end of file
+                    break
+                elif nextchar in self.whitespace:
+                    if self.debug >= 2:
+                        print("shlex: I see whitespace in whitespace state")
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+                elif nextchar in self.commenters:
+                    self.instream.readline()
+                    self.lineno += 1
+                elif self.posix and nextchar in self.escape:
+                    escapedstate = 'a'
+                    self.state = nextchar
+                elif nextchar in self.wordchars:
+                    self.token = nextchar
+                    self.state = 'a'
+                elif nextchar in self.punctuation_chars:
+                    self.token = nextchar
+                    self.state = 'c'
+                elif nextchar in self.quotes:
+                    if not self.posix:
+                        self.token = nextchar
+                    self.state = nextchar
+                elif self.whitespace_split:
+                    self.token = nextchar
+                    self.state = 'a'
+                else:
+                    self.token = nextchar
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+            elif self.state in self.quotes:
+                quoted = True
+                if not nextchar:      # end of file
+                    if self.debug >= 2:
+                        print("shlex: I see EOF in quotes state")
+                    # XXX what error should be raised here?
+                    raise ValueError("No closing quotation")
+                if nextchar == self.state:
+                    if not self.posix:
+                        self.token += nextchar
+                        self.state = ' '
+                        break
+                    else:
+                        self.state = 'a'
+                elif (self.posix and nextchar in self.escape and self.state
+                      in self.escapedquotes):
+                    escapedstate = self.state
+                    self.state = nextchar
+                else:
+                    self.token += nextchar
+            elif self.state in self.escape:
+                if not nextchar:      # end of file
+                    if self.debug >= 2:
+                        print("shlex: I see EOF in escape state")
+                    # XXX what error should be raised here?
+                    raise ValueError("No escaped character")
+                # In posix shells, only the quote itself or the escape
+                # character may be escaped within quotes.
+                if (escapedstate in self.quotes and
+                        nextchar != self.state and nextchar != escapedstate):
+                    self.token += self.state
+                self.token += nextchar
+                self.state = escapedstate
+            elif self.state in ('a', 'c'):
+                if not nextchar:
+                    self.state = None   # end of file
+                    break
+                elif nextchar in self.whitespace:
+                    if self.debug >= 2:
+                        print("shlex: I see whitespace in word state")
+                    self.state = ' '
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+                elif nextchar in self.commenters:
+                    self.instream.readline()
+                    self.lineno += 1
+                    if self.posix:
+                        self.state = ' '
+                        if self.token or (self.posix and quoted):
+                            break   # emit current token
+                        else:
+                            continue
+                elif self.posix and nextchar in self.quotes:
+                    self.state = nextchar
+                elif self.posix and nextchar in self.escape:
+                    escapedstate = 'a'
+                    self.state = nextchar
+                elif self.state == 'c':
+                    if nextchar in self.punctuation_chars:
+                        self.token += nextchar
+                    else:
+                        if nextchar not in self.whitespace:
+                            self._pushback_chars.append(nextchar)
+                        self.state = ' '
+                        break
+                elif (nextchar in self.wordchars or nextchar in self.quotes
+                      or self.whitespace_split):
+                    self.token += nextchar
+                    # Modified by argcomplete: Record last wordbreak position
+                    if nextchar in self.wordbreaks:
+                        self.last_wordbreak_pos = len(self.token) - 1
+                else:
+                    if self.punctuation_chars:
+                        self._pushback_chars.append(nextchar)
+                    else:
+                        self.pushback.appendleft(nextchar)
+                    if self.debug >= 2:
+                        print("shlex: I see punctuation in word state")
+                    self.state = ' '
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+        result = self.token
+        self.token = ''
+        if self.posix and not quoted and result == '':
+            result = None
+        if self.debug > 1:
+            if result:
+                print("shlex: raw token=" + repr(result))
+            else:
+                print("shlex: raw token=EOF")
+        # Modified by argcomplete: Record last wordbreak position
+        if self.state == ' ':
+            self.last_wordbreak_pos = None
+        return result
+
+    def sourcehook(self, newfile):
+        "Hook called on a filename to be sourced."
+        if newfile[0] == '"':
+            newfile = newfile[1:-1]
+        # This implements cpp-like semantics for relative-path inclusion.
+        # Modified by argcomplete: 2/3 compatibility
+        if isinstance(self.infile, basestring) and not os.path.isabs(newfile):
+            newfile = os.path.join(os.path.dirname(self.infile), newfile)
+        return (newfile, open(newfile, "r"))
+
+    def error_leader(self, infile=None, lineno=None):
+        "Emit a C-compiler-like, Emacs-friendly error-message leader."
+        if infile is None:
+            infile = self.infile
+        if lineno is None:
+            lineno = self.lineno
+        return "\"%s\", line %d: " % (infile, lineno)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        token = self.get_token()
+        if token == self.eof:
+            raise StopIteration
+        return token
+
+    # Modified by argcomplete: 2/3 compatibility
+    next = __next__
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/argcomplete/shell_integration.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/argcomplete/shell_integration.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+
+try:
+    from shlex import quote
+except ImportError:
+    from pipes import quote
+
+bashcode = r'''
+# Run something, muting output or redirecting it to the debug stream
+# depending on the value of _ARC_DEBUG.
+# If ARGCOMPLETE_USE_TEMPFILES is set, use tempfiles for IPC.
+__python_argcomplete_run() {
+    if [[ -z "${ARGCOMPLETE_USE_TEMPFILES-}" ]]; then
+        __python_argcomplete_run_inner "$@"
+        return
+    fi
+    local tmpfile="$(mktemp)"
+    _ARGCOMPLETE_STDOUT_FILENAME="$tmpfile" __python_argcomplete_run_inner "$@"
+    local code=$?
+    cat "$tmpfile"
+    rm "$tmpfile"
+    return $code
+}
+
+__python_argcomplete_run_inner() {
+    if [[ -z "${_ARC_DEBUG-}" ]]; then
+        "$@" 8>&1 9>&2 1>/dev/null 2>&1
+    else
+        "$@" 8>&1 9>&2 1>&9 2>&1
+    fi
+}
+
+_python_argcomplete%(function_suffix)s() {
+    local IFS=$'\013'
+    local SUPPRESS_SPACE=0
+    if compopt +o nospace 2> /dev/null; then
+        SUPPRESS_SPACE=1
+    fi
+    COMPREPLY=( $(IFS="$IFS" \
+                  COMP_LINE="$COMP_LINE" \
+                  COMP_POINT="$COMP_POINT" \
+                  COMP_TYPE="$COMP_TYPE" \
+                  _ARGCOMPLETE_COMP_WORDBREAKS="$COMP_WORDBREAKS" \
+                  _ARGCOMPLETE=1 \
+                  _ARGCOMPLETE_SUPPRESS_SPACE=$SUPPRESS_SPACE \
+                  __python_argcomplete_run "%(argcomplete_script)s") )
+    if [[ $? != 0 ]]; then
+        unset COMPREPLY
+    elif [[ $SUPPRESS_SPACE == 1 ]] && [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
+        compopt -o nospace
+    fi
+}
+complete %(complete_opts)s -F _python_argcomplete%(function_suffix)s %(executables)s
+'''
+
+tcshcode = '''\
+complete "%(executable)s" 'p@*@`python-argcomplete-tcsh "%(argcomplete_script)s"`@' ;
+'''
+
+fishcode = r'''
+function __fish_%(executable)s_complete
+    set -x _ARGCOMPLETE 1
+    set -x _ARGCOMPLETE_DFS \t
+    set -x _ARGCOMPLETE_IFS \n
+    set -x _ARGCOMPLETE_SUPPRESS_SPACE 1
+    set -x _ARGCOMPLETE_SHELL fish
+    set -x COMP_LINE (commandline -p)
+    set -x COMP_POINT (string length (commandline -cp))
+    set -x COMP_TYPE
+    if set -q _ARC_DEBUG
+        %(argcomplete_script)s 8>&1 9>&2 1>/dev/null 2>&1
+    else
+        %(argcomplete_script)s 8>&1 9>&2 1>&9 2>&1
+    end
+end
+complete -c %(executable)s -f -a '(__fish_%(executable)s_complete)'
+'''
+
+shell_codes = {'bash': bashcode, 'tcsh': tcshcode, 'fish': fishcode}
+
+
+def shellcode(executables, use_defaults=True, shell='bash', complete_arguments=None, argcomplete_script=None):
+    '''
+    Provide the shell code required to register a python executable for use with the argcomplete module.
+
+    :param list(str) executables: Executables to be completed (when invoked exactly with this name)
+    :param bool use_defaults: Whether to fallback to readline's default completion when no matches are generated.
+    :param str shell: Name of the shell to output code for (bash or tcsh)
+    :param complete_arguments: Arguments to call complete with
+    :type complete_arguments: list(str) or None
+    :param argcomplete_script: Script to call complete with, if not the executable to complete.
+        If supplied, will be used to complete *all* passed executables.
+    :type argcomplete_script: str or None
+    '''
+
+    if complete_arguments is None:
+        complete_options = '-o nospace -o default -o bashdefault' if use_defaults else '-o nospace -o bashdefault'
+    else:
+        complete_options = " ".join(complete_arguments)
+
+    if shell == 'bash':
+        quoted_executables = [quote(i) for i in executables]
+        executables_list = " ".join(quoted_executables)
+        script = argcomplete_script
+        if script:
+            function_suffix = '_' + script
+        else:
+            script = '$1'
+            function_suffix = ''
+        code = bashcode % dict(complete_opts=complete_options, executables=executables_list,
+                               argcomplete_script=script, function_suffix=function_suffix)
+    else:
+        code = ""
+        for executable in executables:
+            script = argcomplete_script
+            # If no script was specified, default to the executable being completed.
+            if not script:
+                script = executable
+            code += shell_codes.get(shell, '') % dict(executable=executable, argcomplete_script=script)
+
+    return code
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,76 @@
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+from functools import partial
+
+from . import converters, exceptions, filters, setters, validators
+from ._config import get_run_validators, set_run_validators
+from ._funcs import asdict, assoc, astuple, evolve, has, resolve_types
+from ._make import (
+    NOTHING,
+    Attribute,
+    Factory,
+    attrib,
+    attrs,
+    fields,
+    fields_dict,
+    make_class,
+    validate,
+)
+from ._version_info import VersionInfo
+
+
+__version__ = "20.3.0"
+__version_info__ = VersionInfo._from_version_string(__version__)
+
+__title__ = "attrs"
+__description__ = "Classes Without Boilerplate"
+__url__ = "https://www.attrs.org/"
+__uri__ = __url__
+__doc__ = __description__ + " <" + __uri__ + ">"
+
+__author__ = "Hynek Schlawack"
+__email__ = "hs@ox.cx"
+
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2015 Hynek Schlawack"
+
+
+s = attributes = attrs
+ib = attr = attrib
+dataclass = partial(attrs, auto_attribs=True)  # happy Easter ;)
+
+__all__ = [
+    "Attribute",
+    "Factory",
+    "NOTHING",
+    "asdict",
+    "assoc",
+    "astuple",
+    "attr",
+    "attrib",
+    "attributes",
+    "attrs",
+    "converters",
+    "evolve",
+    "exceptions",
+    "fields",
+    "fields_dict",
+    "filters",
+    "get_run_validators",
+    "has",
+    "ib",
+    "make_class",
+    "resolve_types",
+    "s",
+    "set_run_validators",
+    "setters",
+    "validate",
+    "validators",
+]
+
+if sys.version_info[:2] >= (3, 6):
+    from ._next_gen import define, field, frozen, mutable
+
+    __all__.extend((define, field, frozen, mutable))
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__init__.pyi
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/__init__.pyi	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,433 @@
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Sequence,
+    Mapping,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+# `import X as X` is required to make these public
+from . import exceptions as exceptions
+from . import filters as filters
+from . import converters as converters
+from . import setters as setters
+from . import validators as validators
+
+from ._version_info import VersionInfo
+
+__version__: str
+__version_info__: VersionInfo
+__title__: str
+__description__: str
+__url__: str
+__uri__: str
+__author__: str
+__email__: str
+__license__: str
+__copyright__: str
+
+_T = TypeVar("_T")
+_C = TypeVar("_C", bound=type)
+
+_ValidatorType = Callable[[Any, Attribute[_T], _T], Any]
+_ConverterType = Callable[[Any], Any]
+_FilterType = Callable[[Attribute[_T], _T], bool]
+_ReprType = Callable[[Any], str]
+_ReprArgType = Union[bool, _ReprType]
+_OnSetAttrType = Callable[[Any, Attribute[Any], Any], Any]
+_OnSetAttrArgType = Union[
+    _OnSetAttrType, List[_OnSetAttrType], setters._NoOpType
+]
+_FieldTransformer = Callable[[type, List[Attribute]], List[Attribute]]
+# FIXME: in reality, if multiple validators are passed they must be in a list
+# or tuple, but those are invariant and so would prevent subtypes of
+# _ValidatorType from working when passed in a list or tuple.
+_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
+
+# _make --
+
+NOTHING: object
+
+# NOTE: Factory lies about its return type to make this possible:
+# `x: List[int] # = Factory(list)`
+# Work around mypy issue #4554 in the common case by using an overload.
+@overload
+def Factory(factory: Callable[[], _T]) -> _T: ...
+@overload
+def Factory(
+    factory: Union[Callable[[Any], _T], Callable[[], _T]],
+    takes_self: bool = ...,
+) -> _T: ...
+
+class Attribute(Generic[_T]):
+    name: str
+    default: Optional[_T]
+    validator: Optional[_ValidatorType[_T]]
+    repr: _ReprArgType
+    cmp: bool
+    eq: bool
+    order: bool
+    hash: Optional[bool]
+    init: bool
+    converter: Optional[_ConverterType]
+    metadata: Dict[Any, Any]
+    type: Optional[Type[_T]]
+    kw_only: bool
+    on_setattr: _OnSetAttrType
+
+# NOTE: We had several choices for the annotation to use for type arg:
+# 1) Type[_T]
+#   - Pros: Handles simple cases correctly
+#   - Cons: Might produce less informative errors in the case of conflicting
+#     TypeVars e.g. `attr.ib(default='bad', type=int)`
+# 2) Callable[..., _T]
+#   - Pros: Better error messages than #1 for conflicting TypeVars
+#   - Cons: Terrible error messages for validator checks.
+#   e.g. attr.ib(type=int, validator=validate_str)
+#        -> error: Cannot infer function type argument
+# 3) type (and do all of the work in the mypy plugin)
+#   - Pros: Simple here, and we could customize the plugin with our own errors.
+#   - Cons: Would need to write mypy plugin code to handle all the cases.
+# We chose option #1.
+
+# `attr` lies about its return type to make the following possible:
+#     attr()    -> Any
+#     attr(8)   -> int
+#     attr(validator=<some callable>)  -> Whatever the callable expects.
+# This makes this type of assignments possible:
+#     x: int = attr(8)
+#
+# This form catches explicit None or no default but with no other arguments
+# returns Any.
+@overload
+def attrib(
+    default: None = ...,
+    validator: None = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: None = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the
+# other arguments.
+@overload
+def attrib(
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def attrib(
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def attrib(
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: object = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: None = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the
+# other arguments.
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def field(
+    *,
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def field(
+    *,
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+@overload
+def attrs(
+    maybe_cls: _C,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    collect_by_mro: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+) -> _C: ...
+@overload
+def attrs(
+    maybe_cls: None = ...,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    collect_by_mro: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+) -> Callable[[_C], _C]: ...
+@overload
+def define(
+    maybe_cls: _C,
+    *,
+    these: Optional[Dict[str, Any]] = ...,
+    repr: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+) -> _C: ...
+@overload
+def define(
+    maybe_cls: None = ...,
+    *,
+    these: Optional[Dict[str, Any]] = ...,
+    repr: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+) -> Callable[[_C], _C]: ...
+
+mutable = define
+frozen = define  # they differ only in their defaults
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+class _Fields(Tuple[Attribute[Any], ...]):
+    def __getattr__(self, name: str) -> Attribute[Any]: ...
+
+def fields(cls: type) -> _Fields: ...
+def fields_dict(cls: type) -> Dict[str, Attribute[Any]]: ...
+def validate(inst: Any) -> None: ...
+def resolve_types(
+    cls: _C,
+    globalns: Optional[Dict[str, Any]] = ...,
+    localns: Optional[Dict[str, Any]] = ...,
+) -> _C: ...
+
+# TODO: add support for returning a proper attrs class from the mypy plugin
+# we use Any instead of _CountingAttr so that e.g. `make_class('Foo',
+# [attr.ib()])` is valid
+def make_class(
+    name: str,
+    attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
+    bases: Tuple[type, ...] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    collect_by_mro: bool = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+) -> type: ...
+
+# _funcs --
+
+# TODO: add support for returning TypedDict from the mypy plugin
+# FIXME: asdict/astuple do not honor their factory args. Waiting on one of
+# these:
+# https://github.com/python/mypy/issues/4236
+# https://github.com/python/typing/issues/253
+def asdict(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    dict_factory: Type[Mapping[Any, Any]] = ...,
+    retain_collection_types: bool = ...,
+    value_serializer: Optional[Callable[[type, Attribute, Any], Any]] = ...,
+) -> Dict[str, Any]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+def astuple(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    tuple_factory: Type[Sequence[Any]] = ...,
+    retain_collection_types: bool = ...,
+) -> Tuple[Any, ...]: ...
+def has(cls: type) -> bool: ...
+def assoc(inst: _T, **changes: Any) -> _T: ...
+def evolve(inst: _T, **changes: Any) -> _T: ...
+
+# _config --
+
+def set_run_validators(run: bool) -> None: ...
+def get_run_validators() -> bool: ...
+
+# aliases --
+
+s = attributes = attrs
+ib = attr = attrib
+dataclass = attrs  # Technically, partial(attrs, auto_attribs=True) ;)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/_compat.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/_compat.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/_config.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/_config.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/_funcs.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/_funcs.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/_make.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/_make.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/_next_gen.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/_next_gen.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/_version_info.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/_version_info.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/converters.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/converters.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/exceptions.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/exceptions.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/filters.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/filters.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/setters.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/setters.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/__pycache__/validators.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/attr/__pycache__/validators.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/_compat.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/_compat.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,231 @@
+from __future__ import absolute_import, division, print_function
+
+import platform
+import sys
+import types
+import warnings
+
+
+PY2 = sys.version_info[0] == 2
+PYPY = platform.python_implementation() == "PyPy"
+
+
+if PYPY or sys.version_info[:2] >= (3, 6):
+    ordered_dict = dict
+else:
+    from collections import OrderedDict
+
+    ordered_dict = OrderedDict
+
+
+if PY2:
+    from collections import Mapping, Sequence
+
+    from UserDict import IterableUserDict
+
+    # We 'bundle' isclass instead of using inspect as importing inspect is
+    # fairly expensive (order of 10-15 ms for a modern machine in 2016)
+    def isclass(klass):
+        return isinstance(klass, (type, types.ClassType))
+
+    # TYPE is used in exceptions, repr(int) is different on Python 2 and 3.
+    TYPE = "type"
+
+    def iteritems(d):
+        return d.iteritems()
+
+    # Python 2 is bereft of a read-only dict proxy, so we make one!
+    class ReadOnlyDict(IterableUserDict):
+        """
+        Best-effort read-only dict wrapper.
+        """
+
+        def __setitem__(self, key, val):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise TypeError(
+                "'mappingproxy' object does not support item assignment"
+            )
+
+        def update(self, _):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'update'"
+            )
+
+        def __delitem__(self, _):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise TypeError(
+                "'mappingproxy' object does not support item deletion"
+            )
+
+        def clear(self):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'clear'"
+            )
+
+        def pop(self, key, default=None):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'pop'"
+            )
+
+        def popitem(self):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'popitem'"
+            )
+
+        def setdefault(self, key, default=None):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'setdefault'"
+            )
+
+        def __repr__(self):
+            # Override to be identical to the Python 3 version.
+            return "mappingproxy(" + repr(self.data) + ")"
+
+    def metadata_proxy(d):
+        res = ReadOnlyDict()
+        res.data.update(d)  # We blocked update, so we have to do it like this.
+        return res
+
+    def just_warn(*args, **kw):  # pragma: no cover
+        """
+        We only warn on Python 3 because we are not aware of any concrete
+        consequences of not setting the cell on Python 2.
+        """
+
+
+else:  # Python 3 and later.
+    from collections.abc import Mapping, Sequence  # noqa
+
+    def just_warn(*args, **kw):
+        """
+        We only warn on Python 3 because we are not aware of any concrete
+        consequences of not setting the cell on Python 2.
+        """
+        warnings.warn(
+            "Running interpreter doesn't sufficiently support code object "
+            "introspection.  Some features like bare super() or accessing "
+            "__class__ will not work with slotted classes.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+    def isclass(klass):
+        return isinstance(klass, type)
+
+    TYPE = "class"
+
+    def iteritems(d):
+        return d.items()
+
+    def metadata_proxy(d):
+        return types.MappingProxyType(dict(d))
+
+
+def make_set_closure_cell():
+    """Return a function of two arguments (cell, value) which sets
+    the value stored in the closure cell `cell` to `value`.
+    """
+    # pypy makes this easy. (It also supports the logic below, but
+    # why not do the easy/fast thing?)
+    if PYPY:
+
+        def set_closure_cell(cell, value):
+            cell.__setstate__((value,))
+
+        return set_closure_cell
+
+    # Otherwise gotta do it the hard way.
+
+    # Create a function that will set its first cellvar to `value`.
+    def set_first_cellvar_to(value):
+        x = value
+        return
+
+        # This function will be eliminated as dead code, but
+        # not before its reference to `x` forces `x` to be
+        # represented as a closure cell rather than a local.
+        def force_x_to_be_a_cell():  # pragma: no cover
+            return x
+
+    try:
+        # Extract the code object and make sure our assumptions about
+        # the closure behavior are correct.
+        if PY2:
+            co = set_first_cellvar_to.func_code
+        else:
+            co = set_first_cellvar_to.__code__
+        if co.co_cellvars != ("x",) or co.co_freevars != ():
+            raise AssertionError  # pragma: no cover
+
+        # Convert this code object to a code object that sets the
+        # function's first _freevar_ (not cellvar) to the argument.
+        if sys.version_info >= (3, 8):
+            # CPython 3.8+ has an incompatible CodeType signature
+            # (added a posonlyargcount argument) but also added
+            # CodeType.replace() to do this without counting parameters.
+            set_first_freevar_code = co.replace(
+                co_cellvars=co.co_freevars, co_freevars=co.co_cellvars
+            )
+        else:
+            args = [co.co_argcount]
+            if not PY2:
+                args.append(co.co_kwonlyargcount)
+            args.extend(
+                [
+                    co.co_nlocals,
+                    co.co_stacksize,
+                    co.co_flags,
+                    co.co_code,
+                    co.co_consts,
+                    co.co_names,
+                    co.co_varnames,
+                    co.co_filename,
+                    co.co_name,
+                    co.co_firstlineno,
+                    co.co_lnotab,
+                    # These two arguments are reversed:
+                    co.co_cellvars,
+                    co.co_freevars,
+                ]
+            )
+            set_first_freevar_code = types.CodeType(*args)
+
+        def set_closure_cell(cell, value):
+            # Create a function using the set_first_freevar_code,
+            # whose first closure cell is `cell`. Calling it will
+            # change the value of that cell.
+            setter = types.FunctionType(
+                set_first_freevar_code, {}, "setter", (), (cell,)
+            )
+            # And call it to set the cell.
+            setter(value)
+
+        # Make sure it works on this interpreter:
+        def make_func_with_cell():
+            x = None
+
+            def func():
+                return x  # pragma: no cover
+
+            return func
+
+        if PY2:
+            cell = make_func_with_cell().func_closure[0]
+        else:
+            cell = make_func_with_cell().__closure__[0]
+        set_closure_cell(cell, 100)
+        if cell.cell_contents != 100:
+            raise AssertionError  # pragma: no cover
+
+    except Exception:
+        return just_warn
+    else:
+        return set_closure_cell
+
+
+set_closure_cell = make_set_closure_cell()
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/_config.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/_config.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,23 @@
+from __future__ import absolute_import, division, print_function
+
+
+__all__ = ["set_run_validators", "get_run_validators"]
+
+_run_validators = True
+
+
+def set_run_validators(run):
+    """
+    Set whether or not validators are run.  By default, they are run.
+    """
+    if not isinstance(run, bool):
+        raise TypeError("'run' must be bool.")
+    global _run_validators
+    _run_validators = run
+
+
+def get_run_validators():
+    """
+    Return whether or not validators are run.
+    """
+    return _run_validators
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/_funcs.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/_funcs.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,390 @@
+from __future__ import absolute_import, division, print_function
+
+import copy
+
+from ._compat import iteritems
+from ._make import NOTHING, _obj_setattr, fields
+from .exceptions import AttrsAttributeNotFoundError
+
+
+def asdict(
+    inst,
+    recurse=True,
+    filter=None,
+    dict_factory=dict,
+    retain_collection_types=False,
+    value_serializer=None,
+):
+    """
+    Return the ``attrs`` attribute values of *inst* as a dict.
+
+    Optionally recurse into other ``attrs``-decorated classes.
+
+    :param inst: Instance of an ``attrs``-decorated class.
+    :param bool recurse: Recurse into classes that are also
+        ``attrs``-decorated.
+    :param callable filter: A callable whose return code determines whether an
+        attribute or element is included (``True``) or dropped (``False``).  Is
+        called with the `attr.Attribute` as the first argument and the
+        value as the second argument.
+    :param callable dict_factory: A callable to produce dictionaries from.  For
+        example, to produce ordered dictionaries instead of normal Python
+        dictionaries, pass in ``collections.OrderedDict``.
+    :param bool retain_collection_types: Do not convert to ``list`` when
+        encountering an attribute whose type is ``tuple`` or ``set``.  Only
+        meaningful if ``recurse`` is ``True``.
+    :param Optional[callable] value_serializer: A hook that is called for every
+        attribute or dict key/value.  It receives the current instance, field
+        and value and must return the (updated) value.  The hook is run *after*
+        the optional *filter* has been applied.
+
+    :rtype: return type of *dict_factory*
+
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  versionadded:: 16.0.0 *dict_factory*
+    ..  versionadded:: 16.1.0 *retain_collection_types*
+    ..  versionadded:: 20.3.0 *value_serializer*
+    """
+    attrs = fields(inst.__class__)
+    rv = dict_factory()
+    for a in attrs:
+        v = getattr(inst, a.name)
+        if filter is not None and not filter(a, v):
+            continue
+
+        if value_serializer is not None:
+            v = value_serializer(inst, a, v)
+
+        if recurse is True:
+            if has(v.__class__):
+                rv[a.name] = asdict(
+                    v,
+                    True,
+                    filter,
+                    dict_factory,
+                    retain_collection_types,
+                    value_serializer,
+                )
+            elif isinstance(v, (tuple, list, set, frozenset)):
+                cf = v.__class__ if retain_collection_types is True else list
+                rv[a.name] = cf(
+                    [
+                        _asdict_anything(
+                            i,
+                            filter,
+                            dict_factory,
+                            retain_collection_types,
+                            value_serializer,
+                        )
+                        for i in v
+                    ]
+                )
+            elif isinstance(v, dict):
+                df = dict_factory
+                rv[a.name] = df(
+                    (
+                        _asdict_anything(
+                            kk,
+                            filter,
+                            df,
+                            retain_collection_types,
+                            value_serializer,
+                        ),
+                        _asdict_anything(
+                            vv,
+                            filter,
+                            df,
+                            retain_collection_types,
+                            value_serializer,
+                        ),
+                    )
+                    for kk, vv in iteritems(v)
+                )
+            else:
+                rv[a.name] = v
+        else:
+            rv[a.name] = v
+    return rv
+
+
+def _asdict_anything(
+    val,
+    filter,
+    dict_factory,
+    retain_collection_types,
+    value_serializer,
+):
+    """
+    ``asdict`` only works on attrs instances, this works on anything.
+    """
+    if getattr(val.__class__, "__attrs_attrs__", None) is not None:
+        # Attrs class.
+        rv = asdict(
+            val,
+            True,
+            filter,
+            dict_factory,
+            retain_collection_types,
+            value_serializer,
+        )
+    elif isinstance(val, (tuple, list, set, frozenset)):
+        cf = val.__class__ if retain_collection_types is True else list
+        rv = cf(
+            [
+                _asdict_anything(
+                    i,
+                    filter,
+                    dict_factory,
+                    retain_collection_types,
+                    value_serializer,
+                )
+                for i in val
+            ]
+        )
+    elif isinstance(val, dict):
+        df = dict_factory
+        rv = df(
+            (
+                _asdict_anything(
+                    kk, filter, df, retain_collection_types, value_serializer
+                ),
+                _asdict_anything(
+                    vv, filter, df, retain_collection_types, value_serializer
+                ),
+            )
+            for kk, vv in iteritems(val)
+        )
+    else:
+        rv = val
+        if value_serializer is not None:
+            rv = value_serializer(None, None, rv)
+
+    return rv
+
+
+def astuple(
+    inst,
+    recurse=True,
+    filter=None,
+    tuple_factory=tuple,
+    retain_collection_types=False,
+):
+    """
+    Return the ``attrs`` attribute values of *inst* as a tuple.
+
+    Optionally recurse into other ``attrs``-decorated classes.
+
+    :param inst: Instance of an ``attrs``-decorated class.
+    :param bool recurse: Recurse into classes that are also
+        ``attrs``-decorated.
+    :param callable filter: A callable whose return code determines whether an
+        attribute or element is included (``True``) or dropped (``False``).  Is
+        called with the `attr.Attribute` as the first argument and the
+        value as the second argument.
+    :param callable tuple_factory: A callable to produce tuples from.  For
+        example, to produce lists instead of tuples.
+    :param bool retain_collection_types: Do not convert to ``list``
+        or ``dict`` when encountering an attribute which type is
+        ``tuple``, ``dict`` or ``set``.  Only meaningful if ``recurse`` is
+        ``True``.
+
+    :rtype: return type of *tuple_factory*
+
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  versionadded:: 16.2.0
+    """
+    attrs = fields(inst.__class__)
+    rv = []
+    retain = retain_collection_types  # Very long. :/
+    for a in attrs:
+        v = getattr(inst, a.name)
+        if filter is not None and not filter(a, v):
+            continue
+        if recurse is True:
+            if has(v.__class__):
+                rv.append(
+                    astuple(
+                        v,
+                        recurse=True,
+                        filter=filter,
+                        tuple_factory=tuple_factory,
+                        retain_collection_types=retain,
+                    )
+                )
+            elif isinstance(v, (tuple, list, set, frozenset)):
+                cf = v.__class__ if retain is True else list
+                rv.append(
+                    cf(
+                        [
+                            astuple(
+                                j,
+                                recurse=True,
+                                filter=filter,
+                                tuple_factory=tuple_factory,
+                                retain_collection_types=retain,
+                            )
+                            if has(j.__class__)
+                            else j
+                            for j in v
+                        ]
+                    )
+                )
+            elif isinstance(v, dict):
+                df = v.__class__ if retain is True else dict
+                rv.append(
+                    df(
+                        (
+                            astuple(
+                                kk,
+                                tuple_factory=tuple_factory,
+                                retain_collection_types=retain,
+                            )
+                            if has(kk.__class__)
+                            else kk,
+                            astuple(
+                                vv,
+                                tuple_factory=tuple_factory,
+                                retain_collection_types=retain,
+                            )
+                            if has(vv.__class__)
+                            else vv,
+                        )
+                        for kk, vv in iteritems(v)
+                    )
+                )
+            else:
+                rv.append(v)
+        else:
+            rv.append(v)
+
+    return rv if tuple_factory is list else tuple_factory(rv)
+
+
+def has(cls):
+    """
+    Check whether *cls* is a class with ``attrs`` attributes.
+
+    :param type cls: Class to introspect.
+    :raise TypeError: If *cls* is not a class.
+
+    :rtype: bool
+    """
+    return getattr(cls, "__attrs_attrs__", None) is not None
+
+
+def assoc(inst, **changes):
+    """
+    Copy *inst* and apply *changes*.
+
+    :param inst: Instance of a class with ``attrs`` attributes.
+    :param changes: Keyword changes in the new copy.
+
+    :return: A copy of inst with *changes* incorporated.
+
+    :raise attr.exceptions.AttrsAttributeNotFoundError: If *attr_name* couldn't
+        be found on *cls*.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  deprecated:: 17.1.0
+        Use `evolve` instead.
+    """
+    import warnings
+
+    warnings.warn(
+        "assoc is deprecated and will be removed after 2018/01.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    new = copy.copy(inst)
+    attrs = fields(inst.__class__)
+    for k, v in iteritems(changes):
+        a = getattr(attrs, k, NOTHING)
+        if a is NOTHING:
+            raise AttrsAttributeNotFoundError(
+                "{k} is not an attrs attribute on {cl}.".format(
+                    k=k, cl=new.__class__
+                )
+            )
+        _obj_setattr(new, k, v)
+    return new
+
+
+def evolve(inst, **changes):
+    """
+    Create a new instance, based on *inst* with *changes* applied.
+
+    :param inst: Instance of a class with ``attrs`` attributes.
+    :param changes: Keyword changes in the new copy.
+
+    :return: A copy of inst with *changes* incorporated.
+
+    :raise TypeError: If *attr_name* couldn't be found in the class
+        ``__init__``.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  versionadded:: 17.1.0
+    """
+    cls = inst.__class__
+    attrs = fields(cls)
+    for a in attrs:
+        if not a.init:
+            continue
+        attr_name = a.name  # To deal with private attributes.
+        init_name = attr_name if attr_name[0] != "_" else attr_name[1:]
+        if init_name not in changes:
+            changes[init_name] = getattr(inst, attr_name)
+
+    return cls(**changes)
+
+
+def resolve_types(cls, globalns=None, localns=None):
+    """
+    Resolve any strings and forward annotations in type annotations.
+
+    This is only required if you need concrete types in `Attribute`'s *type*
+    field. In other words, you don't need to resolve your types if you only
+    use them for static type checking.
+
+    With no arguments, names will be looked up in the module in which the class
+    was created. If this is not what you want, e.g. if the name only exists
+    inside a method, you may pass *globalns* or *localns* to specify other
+    dictionaries in which to look up these names. See the docs of
+    `typing.get_type_hints` for more details.
+
+    :param type cls: Class to resolve.
+    :param Optional[dict] globalns: Dictionary containing global variables.
+    :param Optional[dict] localns: Dictionary containing local variables.
+
+    :raise TypeError: If *cls* is not a class.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+    :raise NameError: If types cannot be resolved because of missing variables.
+
+    :returns: *cls* so you can use this function also as a class decorator.
+        Please note that you have to apply it **after** `attr.s`. That means
+        the decorator has to come in the line **before** `attr.s`.
+
+    ..  versionadded:: 20.1.0
+    """
+    try:
+        # Since calling get_type_hints is expensive we cache whether we've
+        # done it already.
+        cls.__attrs_types_resolved__
+    except AttributeError:
+        import typing
+
+        hints = typing.get_type_hints(cls, globalns=globalns, localns=localns)
+        for field in fields(cls):
+            if field.name in hints:
+                # Since fields have been frozen we must work around it.
+                _obj_setattr(field, "type", hints[field.name])
+        cls.__attrs_types_resolved__ = True
+
+    # Return the class so you can use it as a decorator too.
+    return cls
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/_make.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/_make.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,2765 @@
+from __future__ import absolute_import, division, print_function
+
+import copy
+import linecache
+import sys
+import threading
+import uuid
+import warnings
+
+from operator import itemgetter
+
+from . import _config, setters
+from ._compat import (
+    PY2,
+    PYPY,
+    isclass,
+    iteritems,
+    metadata_proxy,
+    ordered_dict,
+    set_closure_cell,
+)
+from .exceptions import (
+    DefaultAlreadySetError,
+    FrozenInstanceError,
+    NotAnAttrsClassError,
+    PythonTooOldError,
+    UnannotatedAttributeError,
+)
+
+
+# This is used at least twice, so cache it here.
+_obj_setattr = object.__setattr__
+_init_converter_pat = "__attr_converter_%s"
+_init_factory_pat = "__attr_factory_{}"
+_tuple_property_pat = (
+    "    {attr_name} = _attrs_property(_attrs_itemgetter({index}))"
+)
+_classvar_prefixes = ("typing.ClassVar", "t.ClassVar", "ClassVar")
+# we don't use a double-underscore prefix because that triggers
+# name mangling when trying to create a slot for the field
+# (when slots=True)
+_hash_cache_field = "_attrs_cached_hash"
+
+_empty_metadata_singleton = metadata_proxy({})
+
+# Unique object for unequivocal getattr() defaults.
+_sentinel = object()
+
+
+class _Nothing(object):
+    """
+    Sentinel class to indicate the lack of a value when ``None`` is ambiguous.
+
+    ``_Nothing`` is a singleton. There is only ever one of it.
+    """
+
+    _singleton = None
+
+    def __new__(cls):
+        if _Nothing._singleton is None:
+            _Nothing._singleton = super(_Nothing, cls).__new__(cls)
+        return _Nothing._singleton
+
+    def __repr__(self):
+        return "NOTHING"
+
+
+NOTHING = _Nothing()
+"""
+Sentinel to indicate the lack of a value when ``None`` is ambiguous.
+"""
+
+
+class _CacheHashWrapper(int):
+    """
+    An integer subclass that pickles / copies as None
+
+    This is used for non-slots classes with ``cache_hash=True``, to avoid
+    serializing a potentially (even likely) invalid hash value. Since ``None``
+    is the default value for uncalculated hashes, whenever this is copied,
+    the copy's value for the hash should automatically reset.
+
+    See GH #613 for more details.
+    """
+
+    if PY2:
+        # For some reason `type(None)` isn't callable in Python 2, but we don't
+        # actually need a constructor for None objects, we just need any
+        # available function that returns None.
+        def __reduce__(self, _none_constructor=getattr, _args=(0, "", None)):
+            return _none_constructor, _args
+
+    else:
+
+        def __reduce__(self, _none_constructor=type(None), _args=()):
+            return _none_constructor, _args
+
+
+def attrib(
+    default=NOTHING,
+    validator=None,
+    repr=True,
+    cmp=None,
+    hash=None,
+    init=True,
+    metadata=None,
+    type=None,
+    converter=None,
+    factory=None,
+    kw_only=False,
+    eq=None,
+    order=None,
+    on_setattr=None,
+):
+    """
+    Create a new attribute on a class.
+
+    ..  warning::
+
+        Does *not* do anything unless the class is also decorated with
+        `attr.s`!
+
+    :param default: A value that is used if an ``attrs``-generated ``__init__``
+        is used and no value is passed while instantiating or the attribute is
+        excluded using ``init=False``.
+
+        If the value is an instance of `Factory`, its callable will be
+        used to construct a new value (useful for mutable data types like lists
+        or dicts).
+
+        If a default is not set (or set manually to `attr.NOTHING`), a value
+        *must* be supplied when instantiating; otherwise a `TypeError`
+        will be raised.
+
+        The default can also be set using decorator notation as shown below.
+
+    :type default: Any value
+
+    :param callable factory: Syntactic sugar for
+        ``default=attr.Factory(factory)``.
+
+    :param validator: `callable` that is called by ``attrs``-generated
+        ``__init__`` methods after the instance has been initialized.  They
+        receive the initialized instance, the `Attribute`, and the
+        passed value.
+
+        The return value is *not* inspected so the validator has to throw an
+        exception itself.
+
+        If a `list` is passed, its items are treated as validators and must
+        all pass.
+
+        Validators can be globally disabled and re-enabled using
+        `get_run_validators`.
+
+        The validator can also be set using decorator notation as shown below.
+
+    :type validator: `callable` or a `list` of `callable`\\ s.
+
+    :param repr: Include this attribute in the generated ``__repr__``
+        method. If ``True``, include the attribute; if ``False``, omit it. By
+        default, the built-in ``repr()`` function is used. To override how the
+        attribute value is formatted, pass a ``callable`` that takes a single
+        value and returns a string. Note that the resulting string is used
+        as-is, i.e. it will be used directly *instead* of calling ``repr()``
+        (the default).
+    :type repr: a `bool` or a `callable` to use a custom function.
+    :param bool eq: If ``True`` (default), include this attribute in the
+        generated ``__eq__`` and ``__ne__`` methods that check two instances
+        for equality.
+    :param bool order: If ``True`` (default), include this attributes in the
+        generated ``__lt__``, ``__le__``, ``__gt__`` and ``__ge__`` methods.
+    :param bool cmp: Setting to ``True`` is equivalent to setting ``eq=True,
+        order=True``. Deprecated in favor of *eq* and *order*.
+    :param Optional[bool] hash: Include this attribute in the generated
+        ``__hash__`` method.  If ``None`` (default), mirror *eq*'s value.  This
+        is the correct behavior according the Python spec.  Setting this value
+        to anything else than ``None`` is *discouraged*.
+    :param bool init: Include this attribute in the generated ``__init__``
+        method.  It is possible to set this to ``False`` and set a default
+        value.  In that case this attributed is unconditionally initialized
+        with the specified default value or factory.
+    :param callable converter: `callable` that is called by
+        ``attrs``-generated ``__init__`` methods to convert attribute's value
+        to the desired format.  It is given the passed-in value, and the
+        returned value will be used as the new value of the attribute.  The
+        value is converted before being passed to the validator, if any.
+    :param metadata: An arbitrary mapping, to be used by third-party
+        components.  See `extending_metadata`.
+    :param type: The type of the attribute.  In Python 3.6 or greater, the
+        preferred method to specify the type is using a variable annotation
+        (see `PEP 526 <https://www.python.org/dev/peps/pep-0526/>`_).
+        This argument is provided for backward compatibility.
+        Regardless of the approach used, the type will be stored on
+        ``Attribute.type``.
+
+        Please note that ``attrs`` doesn't do anything with this metadata by
+        itself. You can use it as part of your own code or for
+        `static type checking <types>`.
+    :param kw_only: Make this attribute keyword-only (Python 3+)
+        in the generated ``__init__`` (if ``init`` is ``False``, this
+        parameter is ignored).
+    :param on_setattr: Allows to overwrite the *on_setattr* setting from
+        `attr.s`. If left `None`, the *on_setattr* value from `attr.s` is used.
+        Set to `attr.setters.NO_OP` to run **no** `setattr` hooks for this
+        attribute -- regardless of the setting in `attr.s`.
+    :type on_setattr: `callable`, or a list of callables, or `None`, or
+        `attr.setters.NO_OP`
+
+    .. versionadded:: 15.2.0 *convert*
+    .. versionadded:: 16.3.0 *metadata*
+    .. versionchanged:: 17.1.0 *validator* can be a ``list`` now.
+    .. versionchanged:: 17.1.0
+       *hash* is ``None`` and therefore mirrors *eq* by default.
+    .. versionadded:: 17.3.0 *type*
+    .. deprecated:: 17.4.0 *convert*
+    .. versionadded:: 17.4.0 *converter* as a replacement for the deprecated
+       *convert* to achieve consistency with other noun-based arguments.
+    .. versionadded:: 18.1.0
+       ``factory=f`` is syntactic sugar for ``default=attr.Factory(f)``.
+    .. versionadded:: 18.2.0 *kw_only*
+    .. versionchanged:: 19.2.0 *convert* keyword argument removed
+    .. versionchanged:: 19.2.0 *repr* also accepts a custom callable.
+    .. deprecated:: 19.2.0 *cmp* Removal on or after 2021-06-01.
+    .. versionadded:: 19.2.0 *eq* and *order*
+    .. versionadded:: 20.1.0 *on_setattr*
+    .. versionchanged:: 20.3.0 *kw_only* backported to Python 2
+    """
+    eq, order = _determine_eq_order(cmp, eq, order, True)
+
+    if hash is not None and hash is not True and hash is not False:
+        raise TypeError(
+            "Invalid value for hash.  Must be True, False, or None."
+        )
+
+    if factory is not None:
+        if default is not NOTHING:
+            raise ValueError(
+                "The `default` and `factory` arguments are mutually "
+                "exclusive."
+            )
+        if not callable(factory):
+            raise ValueError("The `factory` argument must be a callable.")
+        default = Factory(factory)
+
+    if metadata is None:
+        metadata = {}
+
+    # Apply syntactic sugar by auto-wrapping.
+    if isinstance(on_setattr, (list, tuple)):
+        on_setattr = setters.pipe(*on_setattr)
+
+    if validator and isinstance(validator, (list, tuple)):
+        validator = and_(*validator)
+
+    if converter and isinstance(converter, (list, tuple)):
+        converter = pipe(*converter)
+
+    return _CountingAttr(
+        default=default,
+        validator=validator,
+        repr=repr,
+        cmp=None,
+        hash=hash,
+        init=init,
+        converter=converter,
+        metadata=metadata,
+        type=type,
+        kw_only=kw_only,
+        eq=eq,
+        order=order,
+        on_setattr=on_setattr,
+    )
+
+
+def _make_attr_tuple_class(cls_name, attr_names):
+    """
+    Create a tuple subclass to hold `Attribute`s for an `attrs` class.
+
+    The subclass is a bare tuple with properties for names.
+
+    class MyClassAttributes(tuple):
+        __slots__ = ()
+        x = property(itemgetter(0))
+    """
+    attr_class_name = "{}Attributes".format(cls_name)
+    attr_class_template = [
+        "class {}(tuple):".format(attr_class_name),
+        "    __slots__ = ()",
+    ]
+    if attr_names:
+        for i, attr_name in enumerate(attr_names):
+            attr_class_template.append(
+                _tuple_property_pat.format(index=i, attr_name=attr_name)
+            )
+    else:
+        attr_class_template.append("    pass")
+    globs = {"_attrs_itemgetter": itemgetter, "_attrs_property": property}
+    eval(compile("\n".join(attr_class_template), "", "exec"), globs)
+
+    return globs[attr_class_name]
+
+
+# Tuple class for extracted attributes from a class definition.
+# `base_attrs` is a subset of `attrs`.
+_Attributes = _make_attr_tuple_class(
+    "_Attributes",
+    [
+        # all attributes to build dunder methods for
+        "attrs",
+        # attributes that have been inherited
+        "base_attrs",
+        # map inherited attributes to their originating classes
+        "base_attrs_map",
+    ],
+)
+
+
+def _is_class_var(annot):
+    """
+    Check whether *annot* is a typing.ClassVar.
+
+    The string comparison hack is used to avoid evaluating all string
+    annotations which would put attrs-based classes at a performance
+    disadvantage compared to plain old classes.
+    """
+    return str(annot).startswith(_classvar_prefixes)
+
+
+def _has_own_attribute(cls, attrib_name):
+    """
+    Check whether *cls* defines *attrib_name* (and doesn't just inherit it).
+
+    Requires Python 3.
+    """
+    attr = getattr(cls, attrib_name, _sentinel)
+    if attr is _sentinel:
+        return False
+
+    for base_cls in cls.__mro__[1:]:
+        a = getattr(base_cls, attrib_name, None)
+        if attr is a:
+            return False
+
+    return True
+
+
+def _get_annotations(cls):
+    """
+    Get annotations for *cls*.
+    """
+    if _has_own_attribute(cls, "__annotations__"):
+        return cls.__annotations__
+
+    return {}
+
+
+def _counter_getter(e):
+    """
+    Key function for sorting to avoid re-creating a lambda for every class.
+    """
+    return e[1].counter
+
+
+def _collect_base_attrs(cls, taken_attr_names):
+    """
+    Collect attr.ibs from base classes of *cls*, except *taken_attr_names*.
+    """
+    base_attrs = []
+    base_attr_map = {}  # A dictionary of base attrs to their classes.
+
+    # Traverse the MRO and collect attributes.
+    for base_cls in reversed(cls.__mro__[1:-1]):
+        for a in getattr(base_cls, "__attrs_attrs__", []):
+            if a.inherited or a.name in taken_attr_names:
+                continue
+
+            a = a.evolve(inherited=True)
+            base_attrs.append(a)
+            base_attr_map[a.name] = base_cls
+
+    # For each name, only keep the freshest definition i.e. the furthest at the
+    # back.  base_attr_map is fine because it gets overwritten with every new
+    # instance.
+    filtered = []
+    seen = set()
+    for a in reversed(base_attrs):
+        if a.name in seen:
+            continue
+        filtered.insert(0, a)
+        seen.add(a.name)
+
+    return filtered, base_attr_map
+
+
+def _collect_base_attrs_broken(cls, taken_attr_names):
+    """
+    Collect attr.ibs from base classes of *cls*, except *taken_attr_names*.
+
+    N.B. *taken_attr_names* will be mutated.
+
+    Adhere to the old incorrect behavior.
+
+    Notably it collects from the front and considers inherited attributes which
+    leads to the buggy behavior reported in #428.
+    """
+    base_attrs = []
+    base_attr_map = {}  # A dictionary of base attrs to their classes.
+
+    # Traverse the MRO and collect attributes.
+    for base_cls in cls.__mro__[1:-1]:
+        for a in getattr(base_cls, "__attrs_attrs__", []):
+            if a.name in taken_attr_names:
+                continue
+
+            a = a.evolve(inherited=True)
+            taken_attr_names.add(a.name)
+            base_attrs.append(a)
+            base_attr_map[a.name] = base_cls
+
+    return base_attrs, base_attr_map
+
+
+def _transform_attrs(
+    cls, these, auto_attribs, kw_only, collect_by_mro, field_transformer
+):
+    """
+    Transform all `_CountingAttr`s on a class into `Attribute`s.
+
+    If *these* is passed, use that and don't look for them on the class.
+
+    *collect_by_mro* is True, collect them in the correct MRO order, otherwise
+    use the old -- incorrect -- order.  See #428.
+
+    Return an `_Attributes`.
+    """
+    cd = cls.__dict__
+    anns = _get_annotations(cls)
+
+    if these is not None:
+        ca_list = [(name, ca) for name, ca in iteritems(these)]
+
+        if not isinstance(these, ordered_dict):
+            ca_list.sort(key=_counter_getter)
+    elif auto_attribs is True:
+        ca_names = {
+            name
+            for name, attr in cd.items()
+            if isinstance(attr, _CountingAttr)
+        }
+        ca_list = []
+        annot_names = set()
+        for attr_name, type in anns.items():
+            if _is_class_var(type):
+                continue
+            annot_names.add(attr_name)
+            a = cd.get(attr_name, NOTHING)
+
+            if not isinstance(a, _CountingAttr):
+                if a is NOTHING:
+                    a = attrib()
+                else:
+                    a = attrib(default=a)
+            ca_list.append((attr_name, a))
+
+        unannotated = ca_names - annot_names
+        if len(unannotated) > 0:
+            raise UnannotatedAttributeError(
+                "The following `attr.ib`s lack a type annotation: "
+                + ", ".join(
+                    sorted(unannotated, key=lambda n: cd.get(n).counter)
+                )
+                + "."
+            )
+    else:
+        ca_list = sorted(
+            (
+                (name, attr)
+                for name, attr in cd.items()
+                if isinstance(attr, _CountingAttr)
+            ),
+            key=lambda e: e[1].counter,
+        )
+
+    own_attrs = [
+        Attribute.from_counting_attr(
+            name=attr_name, ca=ca, type=anns.get(attr_name)
+        )
+        for attr_name, ca in ca_list
+    ]
+
+    if collect_by_mro:
+        base_attrs, base_attr_map = _collect_base_attrs(
+            cls, {a.name for a in own_attrs}
+        )
+    else:
+        base_attrs, base_attr_map = _collect_base_attrs_broken(
+            cls, {a.name for a in own_attrs}
+        )
+
+    attr_names = [a.name for a in base_attrs + own_attrs]
+
+    AttrsClass = _make_attr_tuple_class(cls.__name__, attr_names)
+
+    if kw_only:
+        own_attrs = [a.evolve(kw_only=True) for a in own_attrs]
+        base_attrs = [a.evolve(kw_only=True) for a in base_attrs]
+
+    attrs = AttrsClass(base_attrs + own_attrs)
+
+    # Mandatory vs non-mandatory attr order only matters when they are part of
+    # the __init__ signature and when they aren't kw_only (which are moved to
+    # the end and can be mandatory or non-mandatory in any order, as they will
+    # be specified as keyword args anyway). Check the order of those attrs:
+    had_default = False
+    for a in (a for a in attrs if a.init is not False and a.kw_only is False):
+        if had_default is True and a.default is NOTHING:
+            raise ValueError(
+                "No mandatory attributes allowed after an attribute with a "
+                "default value or factory.  Attribute in question: %r" % (a,)
+            )
+
+        if had_default is False and a.default is not NOTHING:
+            had_default = True
+
+    if field_transformer is not None:
+        attrs = field_transformer(cls, attrs)
+    return _Attributes((attrs, base_attrs, base_attr_map))
+
+
+if PYPY:
+
+    def _frozen_setattrs(self, name, value):
+        """
+        Attached to frozen classes as __setattr__.
+        """
+        if isinstance(self, BaseException) and name in (
+            "__cause__",
+            "__context__",
+        ):
+            BaseException.__setattr__(self, name, value)
+            return
+
+        raise FrozenInstanceError()
+
+
+else:
+
+    def _frozen_setattrs(self, name, value):
+        """
+        Attached to frozen classes as __setattr__.
+        """
+        raise FrozenInstanceError()
+
+
+def _frozen_delattrs(self, name):
+    """
+    Attached to frozen classes as __delattr__.
+    """
+    raise FrozenInstanceError()
+
+
+class _ClassBuilder(object):
+    """
+    Iteratively build *one* class.
+    """
+
+    __slots__ = (
+        "_attr_names",
+        "_attrs",
+        "_base_attr_map",
+        "_base_names",
+        "_cache_hash",
+        "_cls",
+        "_cls_dict",
+        "_delete_attribs",
+        "_frozen",
+        "_has_post_init",
+        "_is_exc",
+        "_on_setattr",
+        "_slots",
+        "_weakref_slot",
+        "_has_own_setattr",
+        "_has_custom_setattr",
+    )
+
+    def __init__(
+        self,
+        cls,
+        these,
+        slots,
+        frozen,
+        weakref_slot,
+        getstate_setstate,
+        auto_attribs,
+        kw_only,
+        cache_hash,
+        is_exc,
+        collect_by_mro,
+        on_setattr,
+        has_custom_setattr,
+        field_transformer,
+    ):
+        attrs, base_attrs, base_map = _transform_attrs(
+            cls,
+            these,
+            auto_attribs,
+            kw_only,
+            collect_by_mro,
+            field_transformer,
+        )
+
+        self._cls = cls
+        self._cls_dict = dict(cls.__dict__) if slots else {}
+        self._attrs = attrs
+        self._base_names = set(a.name for a in base_attrs)
+        self._base_attr_map = base_map
+        self._attr_names = tuple(a.name for a in attrs)
+        self._slots = slots
+        self._frozen = frozen
+        self._weakref_slot = weakref_slot
+        self._cache_hash = cache_hash
+        self._has_post_init = bool(getattr(cls, "__attrs_post_init__", False))
+        self._delete_attribs = not bool(these)
+        self._is_exc = is_exc
+        self._on_setattr = on_setattr
+
+        self._has_custom_setattr = has_custom_setattr
+        self._has_own_setattr = False
+
+        self._cls_dict["__attrs_attrs__"] = self._attrs
+
+        if frozen:
+            self._cls_dict["__setattr__"] = _frozen_setattrs
+            self._cls_dict["__delattr__"] = _frozen_delattrs
+
+            self._has_own_setattr = True
+
+        if getstate_setstate:
+            (
+                self._cls_dict["__getstate__"],
+                self._cls_dict["__setstate__"],
+            ) = self._make_getstate_setstate()
+
+    def __repr__(self):
+        return "<_ClassBuilder(cls={cls})>".format(cls=self._cls.__name__)
+
+    def build_class(self):
+        """
+        Finalize class based on the accumulated configuration.
+
+        Builder cannot be used after calling this method.
+        """
+        if self._slots is True:
+            return self._create_slots_class()
+        else:
+            return self._patch_original_class()
+
+    def _patch_original_class(self):
+        """
+        Apply accumulated methods and return the class.
+        """
+        cls = self._cls
+        base_names = self._base_names
+
+        # Clean class of attribute definitions (`attr.ib()`s).
+        if self._delete_attribs:
+            for name in self._attr_names:
+                if (
+                    name not in base_names
+                    and getattr(cls, name, _sentinel) is not _sentinel
+                ):
+                    try:
+                        delattr(cls, name)
+                    except AttributeError:
+                        # This can happen if a base class defines a class
+                        # variable and we want to set an attribute with the
+                        # same name by using only a type annotation.
+                        pass
+
+        # Attach our dunder methods.
+        for name, value in self._cls_dict.items():
+            setattr(cls, name, value)
+
+        # If we've inherited an attrs __setattr__ and don't write our own,
+        # reset it to object's.
+        if not self._has_own_setattr and getattr(
+            cls, "__attrs_own_setattr__", False
+        ):
+            cls.__attrs_own_setattr__ = False
+
+            if not self._has_custom_setattr:
+                cls.__setattr__ = object.__setattr__
+
+        return cls
+
+    def _create_slots_class(self):
+        """
+        Build and return a new class with a `__slots__` attribute.
+        """
+        base_names = self._base_names
+        cd = {
+            k: v
+            for k, v in iteritems(self._cls_dict)
+            if k not in tuple(self._attr_names) + ("__dict__", "__weakref__")
+        }
+
+        # If our class doesn't have its own implementation of __setattr__
+        # (either from the user or by us), check the bases, if one of them has
+        # an attrs-made __setattr__, that needs to be reset. We don't walk the
+        # MRO because we only care about our immediate base classes.
+        # XXX: This can be confused by subclassing a slotted attrs class with
+        # XXX: a non-attrs class and subclass the resulting class with an attrs
+        # XXX: class.  See `test_slotted_confused` for details.  For now that's
+        # XXX: OK with us.
+        if not self._has_own_setattr:
+            cd["__attrs_own_setattr__"] = False
+
+            if not self._has_custom_setattr:
+                for base_cls in self._cls.__bases__:
+                    if base_cls.__dict__.get("__attrs_own_setattr__", False):
+                        cd["__setattr__"] = object.__setattr__
+                        break
+
+        # Traverse the MRO to check for an existing __weakref__.
+        weakref_inherited = False
+        for base_cls in self._cls.__mro__[1:-1]:
+            if base_cls.__dict__.get("__weakref__", None) is not None:
+                weakref_inherited = True
+                break
+
+        names = self._attr_names
+        if (
+            self._weakref_slot
+            and "__weakref__" not in getattr(self._cls, "__slots__", ())
+            and "__weakref__" not in names
+            and not weakref_inherited
+        ):
+            names += ("__weakref__",)
+
+        # We only add the names of attributes that aren't inherited.
+        # Setting __slots__ to inherited attributes wastes memory.
+        slot_names = [name for name in names if name not in base_names]
+        if self._cache_hash:
+            slot_names.append(_hash_cache_field)
+        cd["__slots__"] = tuple(slot_names)
+
+        qualname = getattr(self._cls, "__qualname__", None)
+        if qualname is not None:
+            cd["__qualname__"] = qualname
+
+        # Create new class based on old class and our methods.
+        cls = type(self._cls)(self._cls.__name__, self._cls.__bases__, cd)
+
+        # The following is a fix for
+        # https://github.com/python-attrs/attrs/issues/102.  On Python 3,
+        # if a method mentions `__class__` or uses the no-arg super(), the
+        # compiler will bake a reference to the class in the method itself
+        # as `method.__closure__`.  Since we replace the class with a
+        # clone, we rewrite these references so it keeps working.
+        for item in cls.__dict__.values():
+            if isinstance(item, (classmethod, staticmethod)):
+                # Class- and staticmethods hide their functions inside.
+                # These might need to be rewritten as well.
+                closure_cells = getattr(item.__func__, "__closure__", None)
+            else:
+                closure_cells = getattr(item, "__closure__", None)
+
+            if not closure_cells:  # Catch None or the empty list.
+                continue
+            for cell in closure_cells:
+                try:
+                    match = cell.cell_contents is self._cls
+                except ValueError:  # ValueError: Cell is empty
+                    pass
+                else:
+                    if match:
+                        set_closure_cell(cell, cls)
+
+        return cls
+
+    def add_repr(self, ns):
+        self._cls_dict["__repr__"] = self._add_method_dunders(
+            _make_repr(self._attrs, ns=ns)
+        )
+        return self
+
+    def add_str(self):
+        repr = self._cls_dict.get("__repr__")
+        if repr is None:
+            raise ValueError(
+                "__str__ can only be generated if a __repr__ exists."
+            )
+
+        def __str__(self):
+            return self.__repr__()
+
+        self._cls_dict["__str__"] = self._add_method_dunders(__str__)
+        return self
+
+    def _make_getstate_setstate(self):
+        """
+        Create custom __setstate__ and __getstate__ methods.
+        """
+        # __weakref__ is not writable.
+        state_attr_names = tuple(
+            an for an in self._attr_names if an != "__weakref__"
+        )
+
+        def slots_getstate(self):
+            """
+            Automatically created by attrs.
+            """
+            return tuple(getattr(self, name) for name in state_attr_names)
+
+        hash_caching_enabled = self._cache_hash
+
+        def slots_setstate(self, state):
+            """
+            Automatically created by attrs.
+            """
+            __bound_setattr = _obj_setattr.__get__(self, Attribute)
+            for name, value in zip(state_attr_names, state):
+                __bound_setattr(name, value)
+
+            # The hash code cache is not included when the object is
+            # serialized, but it still needs to be initialized to None to
+            # indicate that the first call to __hash__ should be a cache
+            # miss.
+            if hash_caching_enabled:
+                __bound_setattr(_hash_cache_field, None)
+
+        return slots_getstate, slots_setstate
+
+    def make_unhashable(self):
+        self._cls_dict["__hash__"] = None
+        return self
+
+    def add_hash(self):
+        self._cls_dict["__hash__"] = self._add_method_dunders(
+            _make_hash(
+                self._cls,
+                self._attrs,
+                frozen=self._frozen,
+                cache_hash=self._cache_hash,
+            )
+        )
+
+        return self
+
+    def add_init(self):
+        self._cls_dict["__init__"] = self._add_method_dunders(
+            _make_init(
+                self._cls,
+                self._attrs,
+                self._has_post_init,
+                self._frozen,
+                self._slots,
+                self._cache_hash,
+                self._base_attr_map,
+                self._is_exc,
+                self._on_setattr is not None
+                and self._on_setattr is not setters.NO_OP,
+            )
+        )
+
+        return self
+
+    def add_eq(self):
+        cd = self._cls_dict
+
+        cd["__eq__"] = self._add_method_dunders(
+            _make_eq(self._cls, self._attrs)
+        )
+        cd["__ne__"] = self._add_method_dunders(_make_ne())
+
+        return self
+
+    def add_order(self):
+        cd = self._cls_dict
+
+        cd["__lt__"], cd["__le__"], cd["__gt__"], cd["__ge__"] = (
+            self._add_method_dunders(meth)
+            for meth in _make_order(self._cls, self._attrs)
+        )
+
+        return self
+
+    def add_setattr(self):
+        if self._frozen:
+            return self
+
+        sa_attrs = {}
+        for a in self._attrs:
+            on_setattr = a.on_setattr or self._on_setattr
+            if on_setattr and on_setattr is not setters.NO_OP:
+                sa_attrs[a.name] = a, on_setattr
+
+        if not sa_attrs:
+            return self
+
+        if self._has_custom_setattr:
+            # We need to write a __setattr__ but there already is one!
+            raise ValueError(
+                "Can't combine custom __setattr__ with on_setattr hooks."
+            )
+
+        # docstring comes from _add_method_dunders
+        def __setattr__(self, name, val):
+            try:
+                a, hook = sa_attrs[name]
+            except KeyError:
+                nval = val
+            else:
+                nval = hook(self, a, val)
+
+            _obj_setattr(self, name, nval)
+
+        self._cls_dict["__attrs_own_setattr__"] = True
+        self._cls_dict["__setattr__"] = self._add_method_dunders(__setattr__)
+        self._has_own_setattr = True
+
+        return self
+
+    def _add_method_dunders(self, method):
+        """
+        Add __module__ and __qualname__ to a *method* if possible.
+        """
+        try:
+            method.__module__ = self._cls.__module__
+        except AttributeError:
+            pass
+
+        try:
+            method.__qualname__ = ".".join(
+                (self._cls.__qualname__, method.__name__)
+            )
+        except AttributeError:
+            pass
+
+        try:
+            method.__doc__ = "Method generated by attrs for class %s." % (
+                self._cls.__qualname__,
+            )
+        except AttributeError:
+            pass
+
+        return method
+
+
+_CMP_DEPRECATION = (
+    "The usage of `cmp` is deprecated and will be removed on or after "
+    "2021-06-01.  Please use `eq` and `order` instead."
+)
+
+
+def _determine_eq_order(cmp, eq, order, default_eq):
+    """
+    Validate the combination of *cmp*, *eq*, and *order*. Derive the effective
+    values of eq and order.  If *eq* is None, set it to *default_eq*.
+    """
+    if cmp is not None and any((eq is not None, order is not None)):
+        raise ValueError("Don't mix `cmp` with `eq' and `order`.")
+
+    # cmp takes precedence due to bw-compatibility.
+    if cmp is not None:
+        warnings.warn(_CMP_DEPRECATION, DeprecationWarning, stacklevel=3)
+
+        return cmp, cmp
+
+    # If left None, equality is set to the specified default and ordering
+    # mirrors equality.
+    if eq is None:
+        eq = default_eq
+
+    if order is None:
+        order = eq
+
+    if eq is False and order is True:
+        raise ValueError("`order` can only be True if `eq` is True too.")
+
+    return eq, order
+
+
+def _determine_whether_to_implement(
+    cls, flag, auto_detect, dunders, default=True
+):
+    """
+    Check whether we should implement a set of methods for *cls*.
+
+    *flag* is the argument passed into @attr.s like 'init', *auto_detect* the
+    same as passed into @attr.s and *dunders* is a tuple of attribute names
+    whose presence signal that the user has implemented it themselves.
+
+    Return *default* if no reason for either for or against is found.
+
+    auto_detect must be False on Python 2.
+    """
+    if flag is True or flag is False:
+        return flag
+
+    if flag is None and auto_detect is False:
+        return default
+
+    # Logically, flag is None and auto_detect is True here.
+    for dunder in dunders:
+        if _has_own_attribute(cls, dunder):
+            return False
+
+    return default
+
+
+def attrs(
+    maybe_cls=None,
+    these=None,
+    repr_ns=None,
+    repr=None,
+    cmp=None,
+    hash=None,
+    init=None,
+    slots=False,
+    frozen=False,
+    weakref_slot=True,
+    str=False,
+    auto_attribs=False,
+    kw_only=False,
+    cache_hash=False,
+    auto_exc=False,
+    eq=None,
+    order=None,
+    auto_detect=False,
+    collect_by_mro=False,
+    getstate_setstate=None,
+    on_setattr=None,
+    field_transformer=None,
+):
+    r"""
+    A class decorator that adds `dunder
+    <https://wiki.python.org/moin/DunderAlias>`_\ -methods according to the
+    specified attributes using `attr.ib` or the *these* argument.
+
+    :param these: A dictionary of name to `attr.ib` mappings.  This is
+        useful to avoid the definition of your attributes within the class body
+        because you can't (e.g. if you want to add ``__repr__`` methods to
+        Django models) or don't want to.
+
+        If *these* is not ``None``, ``attrs`` will *not* search the class body
+        for attributes and will *not* remove any attributes from it.
+
+        If *these* is an ordered dict (`dict` on Python 3.6+,
+        `collections.OrderedDict` otherwise), the order is deduced from
+        the order of the attributes inside *these*.  Otherwise the order
+        of the definition of the attributes is used.
+
+    :type these: `dict` of `str` to `attr.ib`
+
+    :param str repr_ns: When using nested classes, there's no way in Python 2
+        to automatically detect that.  Therefore it's possible to set the
+        namespace explicitly for a more meaningful ``repr`` output.
+    :param bool auto_detect: Instead of setting the *init*, *repr*, *eq*,
+        *order*, and *hash* arguments explicitly, assume they are set to
+        ``True`` **unless any** of the involved methods for one of the
+        arguments is implemented in the *current* class (i.e. it is *not*
+        inherited from some base class).
+
+        So for example by implementing ``__eq__`` on a class yourself,
+        ``attrs`` will deduce ``eq=False`` and won't create *neither*
+        ``__eq__`` *nor* ``__ne__`` (but Python classes come with a sensible
+        ``__ne__`` by default, so it *should* be enough to only implement
+        ``__eq__`` in most cases).
+
+        .. warning::
+
+           If you prevent ``attrs`` from creating the ordering methods for you
+           (``order=False``, e.g. by implementing ``__le__``), it becomes
+           *your* responsibility to make sure its ordering is sound. The best
+           way is to use the `functools.total_ordering` decorator.
+
+
+        Passing ``True`` or ``False`` to *init*, *repr*, *eq*, *order*,
+        *cmp*, or *hash* overrides whatever *auto_detect* would determine.
+
+        *auto_detect* requires Python 3. Setting it ``True`` on Python 2 raises
+        a `PythonTooOldError`.
+
+    :param bool repr: Create a ``__repr__`` method with a human readable
+        representation of ``attrs`` attributes..
+    :param bool str: Create a ``__str__`` method that is identical to
+        ``__repr__``.  This is usually not necessary except for
+        `Exception`\ s.
+    :param Optional[bool] eq: If ``True`` or ``None`` (default), add ``__eq__``
+        and ``__ne__`` methods that check two instances for equality.
+
+        They compare the instances as if they were tuples of their ``attrs``
+        attributes if and only if the types of both classes are *identical*!
+    :param Optional[bool] order: If ``True``, add ``__lt__``, ``__le__``,
+        ``__gt__``, and ``__ge__`` methods that behave like *eq* above and
+        allow instances to be ordered. If ``None`` (default) mirror value of
+        *eq*.
+    :param Optional[bool] cmp: Setting to ``True`` is equivalent to setting
+        ``eq=True, order=True``. Deprecated in favor of *eq* and *order*, has
+        precedence over them for backward-compatibility though. Must not be
+        mixed with *eq* or *order*.
+    :param Optional[bool] hash: If ``None`` (default), the ``__hash__`` method
+        is generated according how *eq* and *frozen* are set.
+
+        1. If *both* are True, ``attrs`` will generate a ``__hash__`` for you.
+        2. If *eq* is True and *frozen* is False, ``__hash__`` will be set to
+           None, marking it unhashable (which it is).
+        3. If *eq* is False, ``__hash__`` will be left untouched meaning the
+           ``__hash__`` method of the base class will be used (if base class is
+           ``object``, this means it will fall back to id-based hashing.).
+
+        Although not recommended, you can decide for yourself and force
+        ``attrs`` to create one (e.g. if the class is immutable even though you
+        didn't freeze it programmatically) by passing ``True`` or not.  Both of
+        these cases are rather special and should be used carefully.
+
+        See our documentation on `hashing`, Python's documentation on
+        `object.__hash__`, and the `GitHub issue that led to the default \
+        behavior <https://github.com/python-attrs/attrs/issues/136>`_ for more
+        details.
+    :param bool init: Create a ``__init__`` method that initializes the
+        ``attrs`` attributes.  Leading underscores are stripped for the
+        argument name.  If a ``__attrs_post_init__`` method exists on the
+        class, it will be called after the class is fully initialized.
+    :param bool slots: Create a `slotted class <slotted classes>` that's more
+        memory-efficient. Slotted classes are generally superior to the default
+        dict classes, but have some gotchas you should know about, so we
+        encourage you to read the `glossary entry <slotted classes>`.
+    :param bool frozen: Make instances immutable after initialization.  If
+        someone attempts to modify a frozen instance,
+        `attr.exceptions.FrozenInstanceError` is raised.
+
+        .. note::
+
+            1. This is achieved by installing a custom ``__setattr__`` method
+               on your class, so you can't implement your own.
+
+            2. True immutability is impossible in Python.
+
+            3. This *does* have a minor a runtime performance `impact
+               <how-frozen>` when initializing new instances.  In other words:
+               ``__init__`` is slightly slower with ``frozen=True``.
+
+            4. If a class is frozen, you cannot modify ``self`` in
+               ``__attrs_post_init__`` or a self-written ``__init__``. You can
+               circumvent that limitation by using
+               ``object.__setattr__(self, "attribute_name", value)``.
+
+            5. Subclasses of a frozen class are frozen too.
+
+    :param bool weakref_slot: Make instances weak-referenceable.  This has no
+        effect unless ``slots`` is also enabled.
+    :param bool auto_attribs: If ``True``, collect `PEP 526`_-annotated
+        attributes (Python 3.6 and later only) from the class body.
+
+        In this case, you **must** annotate every field.  If ``attrs``
+        encounters a field that is set to an `attr.ib` but lacks a type
+        annotation, an `attr.exceptions.UnannotatedAttributeError` is
+        raised.  Use ``field_name: typing.Any = attr.ib(...)`` if you don't
+        want to set a type.
+
+        If you assign a value to those attributes (e.g. ``x: int = 42``), that
+        value becomes the default value like if it were passed using
+        ``attr.ib(default=42)``.  Passing an instance of `Factory` also
+        works as expected.
+
+        Attributes annotated as `typing.ClassVar`, and attributes that are
+        neither annotated nor set to an `attr.ib` are **ignored**.
+
+        .. _`PEP 526`: https://www.python.org/dev/peps/pep-0526/
+    :param bool kw_only: Make all attributes keyword-only (Python 3+)
+        in the generated ``__init__`` (if ``init`` is ``False``, this
+        parameter is ignored).
+    :param bool cache_hash: Ensure that the object's hash code is computed
+        only once and stored on the object.  If this is set to ``True``,
+        hashing must be either explicitly or implicitly enabled for this
+        class.  If the hash code is cached, avoid any reassignments of
+        fields involved in hash code computation or mutations of the objects
+        those fields point to after object creation.  If such changes occur,
+        the behavior of the object's hash code is undefined.
+    :param bool auto_exc: If the class subclasses `BaseException`
+        (which implicitly includes any subclass of any exception), the
+        following happens to behave like a well-behaved Python exceptions
+        class:
+
+        - the values for *eq*, *order*, and *hash* are ignored and the
+          instances compare and hash by the instance's ids (N.B. ``attrs`` will
+          *not* remove existing implementations of ``__hash__`` or the equality
+          methods. It just won't add own ones.),
+        - all attributes that are either passed into ``__init__`` or have a
+          default value are additionally available as a tuple in the ``args``
+          attribute,
+        - the value of *str* is ignored leaving ``__str__`` to base classes.
+    :param bool collect_by_mro: Setting this to `True` fixes the way ``attrs``
+       collects attributes from base classes.  The default behavior is
+       incorrect in certain cases of multiple inheritance.  It should be on by
+       default but is kept off for backward-compatability.
+
+       See issue `#428 <https://github.com/python-attrs/attrs/issues/428>`_ for
+       more details.
+
+    :param Optional[bool] getstate_setstate:
+       .. note::
+          This is usually only interesting for slotted classes and you should
+          probably just set *auto_detect* to `True`.
+
+       If `True`, ``__getstate__`` and
+       ``__setstate__`` are generated and attached to the class. This is
+       necessary for slotted classes to be pickleable. If left `None`, it's
+       `True` by default for slotted classes and ``False`` for dict classes.
+
+       If *auto_detect* is `True`, and *getstate_setstate* is left `None`,
+       and **either** ``__getstate__`` or ``__setstate__`` is detected directly
+       on the class (i.e. not inherited), it is set to `False` (this is usually
+       what you want).
+
+    :param on_setattr: A callable that is run whenever the user attempts to set
+        an attribute (either by assignment like ``i.x = 42`` or by using
+        `setattr` like ``setattr(i, "x", 42)``). It receives the same arguments
+        as validators: the instance, the attribute that is being modified, and
+        the new value.
+
+        If no exception is raised, the attribute is set to the return value of
+        the callable.
+
+        If a list of callables is passed, they're automatically wrapped in an
+        `attr.setters.pipe`.
+
+    :param Optional[callable] field_transformer:
+        A function that is called with the original class object and all
+        fields right before ``attrs`` finalizes the class.  You can use
+        this, e.g., to automatically add converters or validators to
+        fields based on their types.  See `transform-fields` for more details.
+
+    .. versionadded:: 16.0.0 *slots*
+    .. versionadded:: 16.1.0 *frozen*
+    .. versionadded:: 16.3.0 *str*
+    .. versionadded:: 16.3.0 Support for ``__attrs_post_init__``.
+    .. versionchanged:: 17.1.0
+       *hash* supports ``None`` as value which is also the default now.
+    .. versionadded:: 17.3.0 *auto_attribs*
+    .. versionchanged:: 18.1.0
+       If *these* is passed, no attributes are deleted from the class body.
+    .. versionchanged:: 18.1.0 If *these* is ordered, the order is retained.
+    .. versionadded:: 18.2.0 *weakref_slot*
+    .. deprecated:: 18.2.0
+       ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` now raise a
+       `DeprecationWarning` if the classes compared are subclasses of
+       each other. ``__eq`` and ``__ne__`` never tried to compared subclasses
+       to each other.
+    .. versionchanged:: 19.2.0
+       ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` now do not consider
+       subclasses comparable anymore.
+    .. versionadded:: 18.2.0 *kw_only*
+    .. versionadded:: 18.2.0 *cache_hash*
+    .. versionadded:: 19.1.0 *auto_exc*
+    .. deprecated:: 19.2.0 *cmp* Removal on or after 2021-06-01.
+    .. versionadded:: 19.2.0 *eq* and *order*
+    .. versionadded:: 20.1.0 *auto_detect*
+    .. versionadded:: 20.1.0 *collect_by_mro*
+    .. versionadded:: 20.1.0 *getstate_setstate*
+    .. versionadded:: 20.1.0 *on_setattr*
+    .. versionadded:: 20.3.0 *field_transformer*
+    """
+    if auto_detect and PY2:
+        raise PythonTooOldError(
+            "auto_detect only works on Python 3 and later."
+        )
+
+    eq_, order_ = _determine_eq_order(cmp, eq, order, None)
+    hash_ = hash  # work around the lack of nonlocal
+
+    if isinstance(on_setattr, (list, tuple)):
+        on_setattr = setters.pipe(*on_setattr)
+
+    def wrap(cls):
+
+        if getattr(cls, "__class__", None) is None:
+            raise TypeError("attrs only works with new-style classes.")
+
+        is_frozen = frozen or _has_frozen_base_class(cls)
+        is_exc = auto_exc is True and issubclass(cls, BaseException)
+        has_own_setattr = auto_detect and _has_own_attribute(
+            cls, "__setattr__"
+        )
+
+        if has_own_setattr and is_frozen:
+            raise ValueError("Can't freeze a class with a custom __setattr__.")
+
+        builder = _ClassBuilder(
+            cls,
+            these,
+            slots,
+            is_frozen,
+            weakref_slot,
+            _determine_whether_to_implement(
+                cls,
+                getstate_setstate,
+                auto_detect,
+                ("__getstate__", "__setstate__"),
+                default=slots,
+            ),
+            auto_attribs,
+            kw_only,
+            cache_hash,
+            is_exc,
+            collect_by_mro,
+            on_setattr,
+            has_own_setattr,
+            field_transformer,
+        )
+        if _determine_whether_to_implement(
+            cls, repr, auto_detect, ("__repr__",)
+        ):
+            builder.add_repr(repr_ns)
+        if str is True:
+            builder.add_str()
+
+        eq = _determine_whether_to_implement(
+            cls, eq_, auto_detect, ("__eq__", "__ne__")
+        )
+        if not is_exc and eq is True:
+            builder.add_eq()
+        if not is_exc and _determine_whether_to_implement(
+            cls, order_, auto_detect, ("__lt__", "__le__", "__gt__", "__ge__")
+        ):
+            builder.add_order()
+
+        builder.add_setattr()
+
+        if (
+            hash_ is None
+            and auto_detect is True
+            and _has_own_attribute(cls, "__hash__")
+        ):
+            hash = False
+        else:
+            hash = hash_
+        if hash is not True and hash is not False and hash is not None:
+            # Can't use `hash in` because 1 == True for example.
+            raise TypeError(
+                "Invalid value for hash.  Must be True, False, or None."
+            )
+        elif hash is False or (hash is None and eq is False) or is_exc:
+            # Don't do anything. Should fall back to __object__'s __hash__
+            # which is by id.
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " hashing must be either explicitly or implicitly "
+                    "enabled."
+                )
+        elif hash is True or (
+            hash is None and eq is True and is_frozen is True
+        ):
+            # Build a __hash__ if told so, or if it's safe.
+            builder.add_hash()
+        else:
+            # Raise TypeError on attempts to hash.
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " hashing must be either explicitly or implicitly "
+                    "enabled."
+                )
+            builder.make_unhashable()
+
+        if _determine_whether_to_implement(
+            cls, init, auto_detect, ("__init__",)
+        ):
+            builder.add_init()
+        else:
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " init must be True."
+                )
+
+        return builder.build_class()
+
+    # maybe_cls's type depends on the usage of the decorator.  It's a class
+    # if it's used as `@attrs` but ``None`` if used as `@attrs()`.
+    if maybe_cls is None:
+        return wrap
+    else:
+        return wrap(maybe_cls)
+
+
+_attrs = attrs
+"""
+Internal alias so we can use it in functions that take an argument called
+*attrs*.
+"""
+
+
+if PY2:
+
+    def _has_frozen_base_class(cls):
+        """
+        Check whether *cls* has a frozen ancestor by looking at its
+        __setattr__.
+        """
+        return (
+            getattr(cls.__setattr__, "__module__", None)
+            == _frozen_setattrs.__module__
+            and cls.__setattr__.__name__ == _frozen_setattrs.__name__
+        )
+
+
+else:
+
+    def _has_frozen_base_class(cls):
+        """
+        Check whether *cls* has a frozen ancestor by looking at its
+        __setattr__.
+        """
+        return cls.__setattr__ == _frozen_setattrs
+
+
+def _attrs_to_tuple(obj, attrs):
+    """
+    Create a tuple of all values of *obj*'s *attrs*.
+    """
+    return tuple(getattr(obj, a.name) for a in attrs)
+
+
+def _generate_unique_filename(cls, func_name):
+    """
+    Create a "filename" suitable for a function being generated.
+    """
+    unique_id = uuid.uuid4()
+    extra = ""
+    count = 1
+
+    while True:
+        unique_filename = "<attrs generated {0} {1}.{2}{3}>".format(
+            func_name,
+            cls.__module__,
+            getattr(cls, "__qualname__", cls.__name__),
+            extra,
+        )
+        # To handle concurrency we essentially "reserve" our spot in
+        # the linecache with a dummy line.  The caller can then
+        # set this value correctly.
+        cache_line = (1, None, (str(unique_id),), unique_filename)
+        if (
+            linecache.cache.setdefault(unique_filename, cache_line)
+            == cache_line
+        ):
+            return unique_filename
+
+        # Looks like this spot is taken. Try again.
+        count += 1
+        extra = "-{0}".format(count)
+
+
+def _make_hash(cls, attrs, frozen, cache_hash):
+    attrs = tuple(
+        a for a in attrs if a.hash is True or (a.hash is None and a.eq is True)
+    )
+
+    tab = "        "
+
+    unique_filename = _generate_unique_filename(cls, "hash")
+    type_hash = hash(unique_filename)
+
+    hash_def = "def __hash__(self"
+    hash_func = "hash(("
+    closing_braces = "))"
+    if not cache_hash:
+        hash_def += "):"
+    else:
+        if not PY2:
+            hash_def += ", *"
+
+        hash_def += (
+            ", _cache_wrapper="
+            + "__import__('attr._make')._make._CacheHashWrapper):"
+        )
+        hash_func = "_cache_wrapper(" + hash_func
+        closing_braces += ")"
+
+    method_lines = [hash_def]
+
+    def append_hash_computation_lines(prefix, indent):
+        """
+        Generate the code for actually computing the hash code.
+        Below this will either be returned directly or used to compute
+        a value which is then cached, depending on the value of cache_hash
+        """
+
+        method_lines.extend(
+            [
+                indent + prefix + hash_func,
+                indent + "        %d," % (type_hash,),
+            ]
+        )
+
+        for a in attrs:
+            method_lines.append(indent + "        self.%s," % a.name)
+
+        method_lines.append(indent + "    " + closing_braces)
+
+    if cache_hash:
+        method_lines.append(tab + "if self.%s is None:" % _hash_cache_field)
+        if frozen:
+            append_hash_computation_lines(
+                "object.__setattr__(self, '%s', " % _hash_cache_field, tab * 2
+            )
+            method_lines.append(tab * 2 + ")")  # close __setattr__
+        else:
+            append_hash_computation_lines(
+                "self.%s = " % _hash_cache_field, tab * 2
+            )
+        method_lines.append(tab + "return self.%s" % _hash_cache_field)
+    else:
+        append_hash_computation_lines("return ", tab)
+
+    script = "\n".join(method_lines)
+    globs = {}
+    locs = {}
+    bytecode = compile(script, unique_filename, "exec")
+    eval(bytecode, globs, locs)
+
+    # In order of debuggers like PDB being able to step through the code,
+    # we add a fake linecache entry.
+    linecache.cache[unique_filename] = (
+        len(script),
+        None,
+        script.splitlines(True),
+        unique_filename,
+    )
+
+    return locs["__hash__"]
+
+
+def _add_hash(cls, attrs):
+    """
+    Add a hash method to *cls*.
+    """
+    cls.__hash__ = _make_hash(cls, attrs, frozen=False, cache_hash=False)
+    return cls
+
+
+def _make_ne():
+    """
+    Create __ne__ method.
+    """
+
+    def __ne__(self, other):
+        """
+        Check equality and either forward a NotImplemented or
+        return the result negated.
+        """
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return NotImplemented
+
+        return not result
+
+    return __ne__
+
+
+def _make_eq(cls, attrs):
+    """
+    Create __eq__ method for *cls* with *attrs*.
+    """
+    attrs = [a for a in attrs if a.eq]
+
+    unique_filename = _generate_unique_filename(cls, "eq")
+    lines = [
+        "def __eq__(self, other):",
+        "    if other.__class__ is not self.__class__:",
+        "        return NotImplemented",
+    ]
+    # We can't just do a big self.x = other.x and... clause due to
+    # irregularities like nan == nan is false but (nan,) == (nan,) is true.
+    if attrs:
+        lines.append("    return  (")
+        others = ["    ) == ("]
+        for a in attrs:
+            lines.append("        self.%s," % (a.name,))
+            others.append("        other.%s," % (a.name,))
+
+        lines += others + ["    )"]
+    else:
+        lines.append("    return True")
+
+    script = "\n".join(lines)
+    globs = {}
+    locs = {}
+    bytecode = compile(script, unique_filename, "exec")
+    eval(bytecode, globs, locs)
+
+    # In order of debuggers like PDB being able to step through the code,
+    # we add a fake linecache entry.
+    linecache.cache[unique_filename] = (
+        len(script),
+        None,
+        script.splitlines(True),
+        unique_filename,
+    )
+    return locs["__eq__"]
+
+
+def _make_order(cls, attrs):
+    """
+    Create ordering methods for *cls* with *attrs*.
+    """
+    attrs = [a for a in attrs if a.order]
+
+    def attrs_to_tuple(obj):
+        """
+        Save us some typing.
+        """
+        return _attrs_to_tuple(obj, attrs)
+
+    def __lt__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) < attrs_to_tuple(other)
+
+        return NotImplemented
+
+    def __le__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) <= attrs_to_tuple(other)
+
+        return NotImplemented
+
+    def __gt__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) > attrs_to_tuple(other)
+
+        return NotImplemented
+
+    def __ge__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) >= attrs_to_tuple(other)
+
+        return NotImplemented
+
+    return __lt__, __le__, __gt__, __ge__
+
+
+def _add_eq(cls, attrs=None):
+    """
+    Add equality methods to *cls* with *attrs*.
+    """
+    if attrs is None:
+        attrs = cls.__attrs_attrs__
+
+    cls.__eq__ = _make_eq(cls, attrs)
+    cls.__ne__ = _make_ne()
+
+    return cls
+
+
+_already_repring = threading.local()
+
+
+def _make_repr(attrs, ns):
+    """
+    Make a repr method that includes relevant *attrs*, adding *ns* to the full
+    name.
+    """
+
+    # Figure out which attributes to include, and which function to use to
+    # format them. The a.repr value can be either bool or a custom callable.
+    attr_names_with_reprs = tuple(
+        (a.name, repr if a.repr is True else a.repr)
+        for a in attrs
+        if a.repr is not False
+    )
+
+    def __repr__(self):
+        """
+        Automatically created by attrs.
+        """
+        try:
+            working_set = _already_repring.working_set
+        except AttributeError:
+            working_set = set()
+            _already_repring.working_set = working_set
+
+        if id(self) in working_set:
+            return "..."
+        real_cls = self.__class__
+        if ns is None:
+            qualname = getattr(real_cls, "__qualname__", None)
+            if qualname is not None:
+                class_name = qualname.rsplit(">.", 1)[-1]
+            else:
+                class_name = real_cls.__name__
+        else:
+            class_name = ns + "." + real_cls.__name__
+
+        # Since 'self' remains on the stack (i.e.: strongly referenced) for the
+        # duration of this call, it's safe to depend on id(...) stability, and
+        # not need to track the instance and therefore worry about properties
+        # like weakref- or hash-ability.
+        working_set.add(id(self))
+        try:
+            result = [class_name, "("]
+            first = True
+            for name, attr_repr in attr_names_with_reprs:
+                if first:
+                    first = False
+                else:
+                    result.append(", ")
+                result.extend(
+                    (name, "=", attr_repr(getattr(self, name, NOTHING)))
+                )
+            return "".join(result) + ")"
+        finally:
+            working_set.remove(id(self))
+
+    return __repr__
+
+
+def _add_repr(cls, ns=None, attrs=None):
+    """
+    Add a repr method to *cls*.
+    """
+    if attrs is None:
+        attrs = cls.__attrs_attrs__
+
+    cls.__repr__ = _make_repr(attrs, ns)
+    return cls
+
+
+def fields(cls):
+    """
+    Return the tuple of ``attrs`` attributes for a class.
+
+    The tuple also allows accessing the fields by their names (see below for
+    examples).
+
+    :param type cls: Class to introspect.
+
+    :raise TypeError: If *cls* is not a class.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    :rtype: tuple (with name accessors) of `attr.Attribute`
+
+    ..  versionchanged:: 16.2.0 Returned tuple allows accessing the fields
+        by name.
+    """
+    if not isclass(cls):
+        raise TypeError("Passed object must be a class.")
+    attrs = getattr(cls, "__attrs_attrs__", None)
+    if attrs is None:
+        raise NotAnAttrsClassError(
+            "{cls!r} is not an attrs-decorated class.".format(cls=cls)
+        )
+    return attrs
+
+
+def fields_dict(cls):
+    """
+    Return an ordered dictionary of ``attrs`` attributes for a class, whose
+    keys are the attribute names.
+
+    :param type cls: Class to introspect.
+
+    :raise TypeError: If *cls* is not a class.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    :rtype: an ordered dict where keys are attribute names and values are
+        `attr.Attribute`\\ s. This will be a `dict` if it's
+        naturally ordered like on Python 3.6+ or an
+        :class:`~collections.OrderedDict` otherwise.
+
+    .. versionadded:: 18.1.0
+    """
+    if not isclass(cls):
+        raise TypeError("Passed object must be a class.")
+    attrs = getattr(cls, "__attrs_attrs__", None)
+    if attrs is None:
+        raise NotAnAttrsClassError(
+            "{cls!r} is not an attrs-decorated class.".format(cls=cls)
+        )
+    return ordered_dict(((a.name, a) for a in attrs))
+
+
+def validate(inst):
+    """
+    Validate all attributes on *inst* that have a validator.
+
+    Leaves all exceptions through.
+
+    :param inst: Instance of a class with ``attrs`` attributes.
+    """
+    if _config._run_validators is False:
+        return
+
+    for a in fields(inst.__class__):
+        v = a.validator
+        if v is not None:
+            v(inst, a, getattr(inst, a.name))
+
+
+def _is_slot_cls(cls):
+    return "__slots__" in cls.__dict__
+
+
+def _is_slot_attr(a_name, base_attr_map):
+    """
+    Check if the attribute name comes from a slot class.
+    """
+    return a_name in base_attr_map and _is_slot_cls(base_attr_map[a_name])
+
+
+def _make_init(
+    cls,
+    attrs,
+    post_init,
+    frozen,
+    slots,
+    cache_hash,
+    base_attr_map,
+    is_exc,
+    has_global_on_setattr,
+):
+    if frozen and has_global_on_setattr:
+        raise ValueError("Frozen classes can't use on_setattr.")
+
+    needs_cached_setattr = cache_hash or frozen
+    filtered_attrs = []
+    attr_dict = {}
+    for a in attrs:
+        if not a.init and a.default is NOTHING:
+            continue
+
+        filtered_attrs.append(a)
+        attr_dict[a.name] = a
+
+        if a.on_setattr is not None:
+            if frozen is True:
+                raise ValueError("Frozen classes can't use on_setattr.")
+
+            needs_cached_setattr = True
+        elif (
+            has_global_on_setattr and a.on_setattr is not setters.NO_OP
+        ) or _is_slot_attr(a.name, base_attr_map):
+            needs_cached_setattr = True
+
+    unique_filename = _generate_unique_filename(cls, "init")
+
+    script, globs, annotations = _attrs_to_init_script(
+        filtered_attrs,
+        frozen,
+        slots,
+        post_init,
+        cache_hash,
+        base_attr_map,
+        is_exc,
+        needs_cached_setattr,
+        has_global_on_setattr,
+    )
+    locs = {}
+    bytecode = compile(script, unique_filename, "exec")
+    globs.update({"NOTHING": NOTHING, "attr_dict": attr_dict})
+
+    if needs_cached_setattr:
+        # Save the lookup overhead in __init__ if we need to circumvent
+        # setattr hooks.
+        globs["_cached_setattr"] = _obj_setattr
+
+    eval(bytecode, globs, locs)
+
+    # In order of debuggers like PDB being able to step through the code,
+    # we add a fake linecache entry.
+    linecache.cache[unique_filename] = (
+        len(script),
+        None,
+        script.splitlines(True),
+        unique_filename,
+    )
+
+    __init__ = locs["__init__"]
+    __init__.__annotations__ = annotations
+
+    return __init__
+
+
+def _setattr(attr_name, value_var, has_on_setattr):
+    """
+    Use the cached object.setattr to set *attr_name* to *value_var*.
+    """
+    return "_setattr('%s', %s)" % (attr_name, value_var)
+
+
+def _setattr_with_converter(attr_name, value_var, has_on_setattr):
+    """
+    Use the cached object.setattr to set *attr_name* to *value_var*, but run
+    its converter first.
+    """
+    return "_setattr('%s', %s(%s))" % (
+        attr_name,
+        _init_converter_pat % (attr_name,),
+        value_var,
+    )
+
+
+def _assign(attr_name, value, has_on_setattr):
+    """
+    Unless *attr_name* has an on_setattr hook, use normal assignment. Otherwise
+    relegate to _setattr.
+    """
+    if has_on_setattr:
+        return _setattr(attr_name, value, True)
+
+    return "self.%s = %s" % (attr_name, value)
+
+
+def _assign_with_converter(attr_name, value_var, has_on_setattr):
+    """
+    Unless *attr_name* has an on_setattr hook, use normal assignment after
+    conversion. Otherwise relegate to _setattr_with_converter.
+    """
+    if has_on_setattr:
+        return _setattr_with_converter(attr_name, value_var, True)
+
+    return "self.%s = %s(%s)" % (
+        attr_name,
+        _init_converter_pat % (attr_name,),
+        value_var,
+    )
+
+
+if PY2:
+
+    def _unpack_kw_only_py2(attr_name, default=None):
+        """
+        Unpack *attr_name* from _kw_only dict.
+        """
+        if default is not None:
+            arg_default = ", %s" % default
+        else:
+            arg_default = ""
+        return "%s = _kw_only.pop('%s'%s)" % (
+            attr_name,
+            attr_name,
+            arg_default,
+        )
+
+    def _unpack_kw_only_lines_py2(kw_only_args):
+        """
+        Unpack all *kw_only_args* from _kw_only dict and handle errors.
+
+        Given a list of strings "{attr_name}" and "{attr_name}={default}"
+        generates list of lines of code that pop attrs from _kw_only dict and
+        raise TypeError similar to builtin if required attr is missing or
+        extra key is passed.
+
+        >>> print("\n".join(_unpack_kw_only_lines_py2(["a", "b=42"])))
+        try:
+            a = _kw_only.pop('a')
+            b = _kw_only.pop('b', 42)
+        except KeyError as _key_error:
+            raise TypeError(
+                ...
+        if _kw_only:
+            raise TypeError(
+                ...
+        """
+        lines = ["try:"]
+        lines.extend(
+            "    " + _unpack_kw_only_py2(*arg.split("="))
+            for arg in kw_only_args
+        )
+        lines += """\
+except KeyError as _key_error:
+    raise TypeError(
+        '__init__() missing required keyword-only argument: %s' % _key_error
+    )
+if _kw_only:
+    raise TypeError(
+        '__init__() got an unexpected keyword argument %r'
+        % next(iter(_kw_only))
+    )
+""".split(
+            "\n"
+        )
+        return lines
+
+
+def _attrs_to_init_script(
+    attrs,
+    frozen,
+    slots,
+    post_init,
+    cache_hash,
+    base_attr_map,
+    is_exc,
+    needs_cached_setattr,
+    has_global_on_setattr,
+):
+    """
+    Return a script of an initializer for *attrs* and a dict of globals.
+
+    The globals are expected by the generated script.
+
+    If *frozen* is True, we cannot set the attributes directly so we use
+    a cached ``object.__setattr__``.
+    """
+    lines = []
+    if needs_cached_setattr:
+        lines.append(
+            # Circumvent the __setattr__ descriptor to save one lookup per
+            # assignment.
+            # Note _setattr will be used again below if cache_hash is True
+            "_setattr = _cached_setattr.__get__(self, self.__class__)"
+        )
+
+    if frozen is True:
+        if slots is True:
+            fmt_setter = _setattr
+            fmt_setter_with_converter = _setattr_with_converter
+        else:
+            # Dict frozen classes assign directly to __dict__.
+            # But only if the attribute doesn't come from an ancestor slot
+            # class.
+            # Note _inst_dict will be used again below if cache_hash is True
+            lines.append("_inst_dict = self.__dict__")
+
+            def fmt_setter(attr_name, value_var, has_on_setattr):
+                if _is_slot_attr(attr_name, base_attr_map):
+                    return _setattr(attr_name, value_var, has_on_setattr)
+
+                return "_inst_dict['%s'] = %s" % (attr_name, value_var)
+
+            def fmt_setter_with_converter(
+                attr_name, value_var, has_on_setattr
+            ):
+                if has_on_setattr or _is_slot_attr(attr_name, base_attr_map):
+                    return _setattr_with_converter(
+                        attr_name, value_var, has_on_setattr
+                    )
+
+                return "_inst_dict['%s'] = %s(%s)" % (
+                    attr_name,
+                    _init_converter_pat % (attr_name,),
+                    value_var,
+                )
+
+    else:
+        # Not frozen.
+        fmt_setter = _assign
+        fmt_setter_with_converter = _assign_with_converter
+
+    args = []
+    kw_only_args = []
+    attrs_to_validate = []
+
+    # This is a dictionary of names to validator and converter callables.
+    # Injecting this into __init__ globals lets us avoid lookups.
+    names_for_globals = {}
+    annotations = {"return": None}
+
+    for a in attrs:
+        if a.validator:
+            attrs_to_validate.append(a)
+
+        attr_name = a.name
+        has_on_setattr = a.on_setattr is not None or (
+            a.on_setattr is not setters.NO_OP and has_global_on_setattr
+        )
+        arg_name = a.name.lstrip("_")
+
+        has_factory = isinstance(a.default, Factory)
+        if has_factory and a.default.takes_self:
+            maybe_self = "self"
+        else:
+            maybe_self = ""
+
+        if a.init is False:
+            if has_factory:
+                init_factory_name = _init_factory_pat.format(a.name)
+                if a.converter is not None:
+                    lines.append(
+                        fmt_setter_with_converter(
+                            attr_name,
+                            init_factory_name + "(%s)" % (maybe_self,),
+                            has_on_setattr,
+                        )
+                    )
+                    conv_name = _init_converter_pat % (a.name,)
+                    names_for_globals[conv_name] = a.converter
+                else:
+                    lines.append(
+                        fmt_setter(
+                            attr_name,
+                            init_factory_name + "(%s)" % (maybe_self,),
+                            has_on_setattr,
+                        )
+                    )
+                names_for_globals[init_factory_name] = a.default.factory
+            else:
+                if a.converter is not None:
+                    lines.append(
+                        fmt_setter_with_converter(
+                            attr_name,
+                            "attr_dict['%s'].default" % (attr_name,),
+                            has_on_setattr,
+                        )
+                    )
+                    conv_name = _init_converter_pat % (a.name,)
+                    names_for_globals[conv_name] = a.converter
+                else:
+                    lines.append(
+                        fmt_setter(
+                            attr_name,
+                            "attr_dict['%s'].default" % (attr_name,),
+                            has_on_setattr,
+                        )
+                    )
+        elif a.default is not NOTHING and not has_factory:
+            arg = "%s=attr_dict['%s'].default" % (arg_name, attr_name)
+            if a.kw_only:
+                kw_only_args.append(arg)
+            else:
+                args.append(arg)
+
+            if a.converter is not None:
+                lines.append(
+                    fmt_setter_with_converter(
+                        attr_name, arg_name, has_on_setattr
+                    )
+                )
+                names_for_globals[
+                    _init_converter_pat % (a.name,)
+                ] = a.converter
+            else:
+                lines.append(fmt_setter(attr_name, arg_name, has_on_setattr))
+
+        elif has_factory:
+            arg = "%s=NOTHING" % (arg_name,)
+            if a.kw_only:
+                kw_only_args.append(arg)
+            else:
+                args.append(arg)
+            lines.append("if %s is not NOTHING:" % (arg_name,))
+
+            init_factory_name = _init_factory_pat.format(a.name)
+            if a.converter is not None:
+                lines.append(
+                    "    "
+                    + fmt_setter_with_converter(
+                        attr_name, arg_name, has_on_setattr
+                    )
+                )
+                lines.append("else:")
+                lines.append(
+                    "    "
+                    + fmt_setter_with_converter(
+                        attr_name,
+                        init_factory_name + "(" + maybe_self + ")",
+                        has_on_setattr,
+                    )
+                )
+                names_for_globals[
+                    _init_converter_pat % (a.name,)
+                ] = a.converter
+            else:
+                lines.append(
+                    "    " + fmt_setter(attr_name, arg_name, has_on_setattr)
+                )
+                lines.append("else:")
+                lines.append(
+                    "    "
+                    + fmt_setter(
+                        attr_name,
+                        init_factory_name + "(" + maybe_self + ")",
+                        has_on_setattr,
+                    )
+                )
+            names_for_globals[init_factory_name] = a.default.factory
+        else:
+            if a.kw_only:
+                kw_only_args.append(arg_name)
+            else:
+                args.append(arg_name)
+
+            if a.converter is not None:
+                lines.append(
+                    fmt_setter_with_converter(
+                        attr_name, arg_name, has_on_setattr
+                    )
+                )
+                names_for_globals[
+                    _init_converter_pat % (a.name,)
+                ] = a.converter
+            else:
+                lines.append(fmt_setter(attr_name, arg_name, has_on_setattr))
+
+        if a.init is True and a.converter is None and a.type is not None:
+            annotations[arg_name] = a.type
+
+    if attrs_to_validate:  # we can skip this if there are no validators.
+        names_for_globals["_config"] = _config
+        lines.append("if _config._run_validators is True:")
+        for a in attrs_to_validate:
+            val_name = "__attr_validator_" + a.name
+            attr_name = "__attr_" + a.name
+            lines.append(
+                "    %s(self, %s, self.%s)" % (val_name, attr_name, a.name)
+            )
+            names_for_globals[val_name] = a.validator
+            names_for_globals[attr_name] = a
+
+    if post_init:
+        lines.append("self.__attrs_post_init__()")
+
+    # because this is set only after __attrs_post_init is called, a crash
+    # will result if post-init tries to access the hash code.  This seemed
+    # preferable to setting this beforehand, in which case alteration to
+    # field values during post-init combined with post-init accessing the
+    # hash code would result in silent bugs.
+    if cache_hash:
+        if frozen:
+            if slots:
+                # if frozen and slots, then _setattr defined above
+                init_hash_cache = "_setattr('%s', %s)"
+            else:
+                # if frozen and not slots, then _inst_dict defined above
+                init_hash_cache = "_inst_dict['%s'] = %s"
+        else:
+            init_hash_cache = "self.%s = %s"
+        lines.append(init_hash_cache % (_hash_cache_field, "None"))
+
+    # For exceptions we rely on BaseException.__init__ for proper
+    # initialization.
+    if is_exc:
+        vals = ",".join("self." + a.name for a in attrs if a.init)
+
+        lines.append("BaseException.__init__(self, %s)" % (vals,))
+
+    args = ", ".join(args)
+    if kw_only_args:
+        if PY2:
+            lines = _unpack_kw_only_lines_py2(kw_only_args) + lines
+
+            args += "%s**_kw_only" % (", " if args else "",)  # leading comma
+        else:
+            args += "%s*, %s" % (
+                ", " if args else "",  # leading comma
+                ", ".join(kw_only_args),  # kw_only args
+            )
+    return (
+        """\
+def __init__(self, {args}):
+    {lines}
+""".format(
+            args=args, lines="\n    ".join(lines) if lines else "pass"
+        ),
+        names_for_globals,
+        annotations,
+    )
+
+
+class Attribute(object):
+    """
+    *Read-only* representation of an attribute.
+
+    Instances of this class are frequently used for introspection purposes
+    like:
+
+    - `fields` returns a tuple of them.
+    - Validators get them passed as the first argument.
+    - The *field transformer* hook receives a list of them.
+
+    :attribute name: The name of the attribute.
+    :attribute inherited: Whether or not that attribute has been inherited from
+        a base class.
+
+    Plus *all* arguments of `attr.ib` (except for ``factory``
+    which is only syntactic sugar for ``default=Factory(...)``.
+
+    .. versionadded:: 20.1.0 *inherited*
+    .. versionadded:: 20.1.0 *on_setattr*
+    .. versionchanged:: 20.2.0 *inherited* is not taken into account for
+        equality checks and hashing anymore.
+
+    For the full version history of the fields, see `attr.ib`.
+    """
+
+    __slots__ = (
+        "name",
+        "default",
+        "validator",
+        "repr",
+        "eq",
+        "order",
+        "hash",
+        "init",
+        "metadata",
+        "type",
+        "converter",
+        "kw_only",
+        "inherited",
+        "on_setattr",
+    )
+
+    def __init__(
+        self,
+        name,
+        default,
+        validator,
+        repr,
+        cmp,  # XXX: unused, remove along with other cmp code.
+        hash,
+        init,
+        inherited,
+        metadata=None,
+        type=None,
+        converter=None,
+        kw_only=False,
+        eq=None,
+        order=None,
+        on_setattr=None,
+    ):
+        eq, order = _determine_eq_order(cmp, eq, order, True)
+
+        # Cache this descriptor here to speed things up later.
+        bound_setattr = _obj_setattr.__get__(self, Attribute)
+
+        # Despite the big red warning, people *do* instantiate `Attribute`
+        # themselves.
+        bound_setattr("name", name)
+        bound_setattr("default", default)
+        bound_setattr("validator", validator)
+        bound_setattr("repr", repr)
+        bound_setattr("eq", eq)
+        bound_setattr("order", order)
+        bound_setattr("hash", hash)
+        bound_setattr("init", init)
+        bound_setattr("converter", converter)
+        bound_setattr(
+            "metadata",
+            (
+                metadata_proxy(metadata)
+                if metadata
+                else _empty_metadata_singleton
+            ),
+        )
+        bound_setattr("type", type)
+        bound_setattr("kw_only", kw_only)
+        bound_setattr("inherited", inherited)
+        bound_setattr("on_setattr", on_setattr)
+
+    def __setattr__(self, name, value):
+        raise FrozenInstanceError()
+
+    @classmethod
+    def from_counting_attr(cls, name, ca, type=None):
+        # type holds the annotated value. deal with conflicts:
+        if type is None:
+            type = ca.type
+        elif ca.type is not None:
+            raise ValueError(
+                "Type annotation and type argument cannot both be present"
+            )
+        inst_dict = {
+            k: getattr(ca, k)
+            for k in Attribute.__slots__
+            if k
+            not in (
+                "name",
+                "validator",
+                "default",
+                "type",
+                "inherited",
+            )  # exclude methods and deprecated alias
+        }
+        return cls(
+            name=name,
+            validator=ca._validator,
+            default=ca._default,
+            type=type,
+            cmp=None,
+            inherited=False,
+            **inst_dict
+        )
+
+    @property
+    def cmp(self):
+        """
+        Simulate the presence of a cmp attribute and warn.
+        """
+        warnings.warn(_CMP_DEPRECATION, DeprecationWarning, stacklevel=2)
+
+        return self.eq and self.order
+
+    # Don't use attr.evolve since fields(Attribute) doesn't work
+    def evolve(self, **changes):
+        """
+        Copy *self* and apply *changes*.
+
+        This works similarly to `attr.evolve` but that function does not work
+        with ``Attribute``.
+
+        It is mainly meant to be used for `transform-fields`.
+
+        .. versionadded:: 20.3.0
+        """
+        new = copy.copy(self)
+
+        new._setattrs(changes.items())
+
+        return new
+
+    # Don't use _add_pickle since fields(Attribute) doesn't work
+    def __getstate__(self):
+        """
+        Play nice with pickle.
+        """
+        return tuple(
+            getattr(self, name) if name != "metadata" else dict(self.metadata)
+            for name in self.__slots__
+        )
+
+    def __setstate__(self, state):
+        """
+        Play nice with pickle.
+        """
+        self._setattrs(zip(self.__slots__, state))
+
+    def _setattrs(self, name_values_pairs):
+        bound_setattr = _obj_setattr.__get__(self, Attribute)
+        for name, value in name_values_pairs:
+            if name != "metadata":
+                bound_setattr(name, value)
+            else:
+                bound_setattr(
+                    name,
+                    metadata_proxy(value)
+                    if value
+                    else _empty_metadata_singleton,
+                )
+
+
+_a = [
+    Attribute(
+        name=name,
+        default=NOTHING,
+        validator=None,
+        repr=True,
+        cmp=None,
+        eq=True,
+        order=False,
+        hash=(name != "metadata"),
+        init=True,
+        inherited=False,
+    )
+    for name in Attribute.__slots__
+]
+
+Attribute = _add_hash(
+    _add_eq(
+        _add_repr(Attribute, attrs=_a),
+        attrs=[a for a in _a if a.name != "inherited"],
+    ),
+    attrs=[a for a in _a if a.hash and a.name != "inherited"],
+)
+
+
+class _CountingAttr(object):
+    """
+    Intermediate representation of attributes that uses a counter to preserve
+    the order in which the attributes have been defined.
+
+    *Internal* data structure of the attrs library.  Running into is most
+    likely the result of a bug like a forgotten `@attr.s` decorator.
+    """
+
+    __slots__ = (
+        "counter",
+        "_default",
+        "repr",
+        "eq",
+        "order",
+        "hash",
+        "init",
+        "metadata",
+        "_validator",
+        "converter",
+        "type",
+        "kw_only",
+        "on_setattr",
+    )
+    __attrs_attrs__ = tuple(
+        Attribute(
+            name=name,
+            default=NOTHING,
+            validator=None,
+            repr=True,
+            cmp=None,
+            hash=True,
+            init=True,
+            kw_only=False,
+            eq=True,
+            order=False,
+            inherited=False,
+            on_setattr=None,
+        )
+        for name in (
+            "counter",
+            "_default",
+            "repr",
+            "eq",
+            "order",
+            "hash",
+            "init",
+            "on_setattr",
+        )
+    ) + (
+        Attribute(
+            name="metadata",
+            default=None,
+            validator=None,
+            repr=True,
+            cmp=None,
+            hash=False,
+            init=True,
+            kw_only=False,
+            eq=True,
+            order=False,
+            inherited=False,
+            on_setattr=None,
+        ),
+    )
+    cls_counter = 0
+
+    def __init__(
+        self,
+        default,
+        validator,
+        repr,
+        cmp,  # XXX: unused, remove along with cmp
+        hash,
+        init,
+        converter,
+        metadata,
+        type,
+        kw_only,
+        eq,
+        order,
+        on_setattr,
+    ):
+        _CountingAttr.cls_counter += 1
+        self.counter = _CountingAttr.cls_counter
+        self._default = default
+        self._validator = validator
+        self.converter = converter
+        self.repr = repr
+        self.eq = eq
+        self.order = order
+        self.hash = hash
+        self.init = init
+        self.metadata = metadata
+        self.type = type
+        self.kw_only = kw_only
+        self.on_setattr = on_setattr
+
+    def validator(self, meth):
+        """
+        Decorator that adds *meth* to the list of validators.
+
+        Returns *meth* unchanged.
+
+        .. versionadded:: 17.1.0
+        """
+        if self._validator is None:
+            self._validator = meth
+        else:
+            self._validator = and_(self._validator, meth)
+        return meth
+
+    def default(self, meth):
+        """
+        Decorator that allows to set the default for an attribute.
+
+        Returns *meth* unchanged.
+
+        :raises DefaultAlreadySetError: If default has been set before.
+
+        .. versionadded:: 17.1.0
+        """
+        if self._default is not NOTHING:
+            raise DefaultAlreadySetError()
+
+        self._default = Factory(meth, takes_self=True)
+
+        return meth
+
+
+_CountingAttr = _add_eq(_add_repr(_CountingAttr))
+
+
+@attrs(slots=True, init=False, hash=True)
+class Factory(object):
+    """
+    Stores a factory callable.
+
+    If passed as the default value to `attr.ib`, the factory is used to
+    generate a new value.
+
+    :param callable factory: A callable that takes either none or exactly one
+        mandatory positional argument depending on *takes_self*.
+    :param bool takes_self: Pass the partially initialized instance that is
+        being initialized as a positional argument.
+
+    .. versionadded:: 17.1.0  *takes_self*
+    """
+
+    factory = attrib()
+    takes_self = attrib()
+
+    def __init__(self, factory, takes_self=False):
+        """
+        `Factory` is part of the default machinery so if we want a default
+        value here, we have to implement it ourselves.
+        """
+        self.factory = factory
+        self.takes_self = takes_self
+
+
+def make_class(name, attrs, bases=(object,), **attributes_arguments):
+    """
+    A quick way to create a new class called *name* with *attrs*.
+
+    :param str name: The name for the new class.
+
+    :param attrs: A list of names or a dictionary of mappings of names to
+        attributes.
+
+        If *attrs* is a list or an ordered dict (`dict` on Python 3.6+,
+        `collections.OrderedDict` otherwise), the order is deduced from
+        the order of the names or attributes inside *attrs*.  Otherwise the
+        order of the definition of the attributes is used.
+    :type attrs: `list` or `dict`
+
+    :param tuple bases: Classes that the new class will subclass.
+
+    :param attributes_arguments: Passed unmodified to `attr.s`.
+
+    :return: A new class with *attrs*.
+    :rtype: type
+
+    .. versionadded:: 17.1.0 *bases*
+    .. versionchanged:: 18.1.0 If *attrs* is ordered, the order is retained.
+    """
+    if isinstance(attrs, dict):
+        cls_dict = attrs
+    elif isinstance(attrs, (list, tuple)):
+        cls_dict = dict((a, attrib()) for a in attrs)
+    else:
+        raise TypeError("attrs argument must be a dict or a list.")
+
+    post_init = cls_dict.pop("__attrs_post_init__", None)
+    type_ = type(
+        name,
+        bases,
+        {} if post_init is None else {"__attrs_post_init__": post_init},
+    )
+    # For pickling to work, the __module__ variable needs to be set to the
+    # frame where the class is created.  Bypass this step in environments where
+    # sys._getframe is not defined (Jython for example) or sys._getframe is not
+    # defined for arguments greater than 0 (IronPython).
+    try:
+        type_.__module__ = sys._getframe(1).f_globals.get(
+            "__name__", "__main__"
+        )
+    except (AttributeError, ValueError):
+        pass
+
+    # We do it here for proper warnings with meaningful stacklevel.
+    cmp = attributes_arguments.pop("cmp", None)
+    (
+        attributes_arguments["eq"],
+        attributes_arguments["order"],
+    ) = _determine_eq_order(
+        cmp,
+        attributes_arguments.get("eq"),
+        attributes_arguments.get("order"),
+        True,
+    )
+
+    return _attrs(these=cls_dict, **attributes_arguments)(type_)
+
+
+# These are required by within this module so we define them here and merely
+# import into .validators / .converters.
+
+
+@attrs(slots=True, hash=True)
+class _AndValidator(object):
+    """
+    Compose many validators to a single one.
+    """
+
+    _validators = attrib()
+
+    def __call__(self, inst, attr, value):
+        for v in self._validators:
+            v(inst, attr, value)
+
+
+def and_(*validators):
+    """
+    A validator that composes multiple validators into one.
+
+    When called on a value, it runs all wrapped validators.
+
+    :param callables validators: Arbitrary number of validators.
+
+    .. versionadded:: 17.1.0
+    """
+    vals = []
+    for validator in validators:
+        vals.extend(
+            validator._validators
+            if isinstance(validator, _AndValidator)
+            else [validator]
+        )
+
+    return _AndValidator(tuple(vals))
+
+
+def pipe(*converters):
+    """
+    A converter that composes multiple converters into one.
+
+    When called on a value, it runs all wrapped converters, returning the
+    *last* value.
+
+    :param callables converters: Arbitrary number of converters.
+
+    .. versionadded:: 20.1.0
+    """
+
+    def pipe_converter(val):
+        for converter in converters:
+            val = converter(val)
+
+        return val
+
+    return pipe_converter
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/_next_gen.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/_next_gen.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,160 @@
+"""
+This is a Python 3.6 and later-only, keyword-only, and **provisional** API that
+calls `attr.s` with different default values.
+
+Provisional APIs that shall become "import attrs" one glorious day.
+"""
+
+from functools import partial
+
+from attr.exceptions import UnannotatedAttributeError
+
+from . import setters
+from ._make import NOTHING, _frozen_setattrs, attrib, attrs
+
+
+def define(
+    maybe_cls=None,
+    *,
+    these=None,
+    repr=None,
+    hash=None,
+    init=None,
+    slots=True,
+    frozen=False,
+    weakref_slot=True,
+    str=False,
+    auto_attribs=None,
+    kw_only=False,
+    cache_hash=False,
+    auto_exc=True,
+    eq=None,
+    order=False,
+    auto_detect=True,
+    getstate_setstate=None,
+    on_setattr=None,
+    field_transformer=None,
+):
+    r"""
+    The only behavioral differences are the handling of the *auto_attribs*
+    option:
+
+    :param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves
+       exactly like `attr.s`. If left `None`, `attr.s` will try to guess:
+
+       1. If all attributes are annotated and no `attr.ib` is found, it assumes
+          *auto_attribs=True*.
+       2. Otherwise it assumes *auto_attribs=False* and tries to collect
+          `attr.ib`\ s.
+
+    and that mutable classes (``frozen=False``) validate on ``__setattr__``.
+
+    .. versionadded:: 20.1.0
+    """
+
+    def do_it(cls, auto_attribs):
+        return attrs(
+            maybe_cls=cls,
+            these=these,
+            repr=repr,
+            hash=hash,
+            init=init,
+            slots=slots,
+            frozen=frozen,
+            weakref_slot=weakref_slot,
+            str=str,
+            auto_attribs=auto_attribs,
+            kw_only=kw_only,
+            cache_hash=cache_hash,
+            auto_exc=auto_exc,
+            eq=eq,
+            order=order,
+            auto_detect=auto_detect,
+            collect_by_mro=True,
+            getstate_setstate=getstate_setstate,
+            on_setattr=on_setattr,
+            field_transformer=field_transformer,
+        )
+
+    def wrap(cls):
+        """
+        Making this a wrapper ensures this code runs during class creation.
+
+        We also ensure that frozen-ness of classes is inherited.
+        """
+        nonlocal frozen, on_setattr
+
+        had_on_setattr = on_setattr not in (None, setters.NO_OP)
+
+        # By default, mutable classes validate on setattr.
+        if frozen is False and on_setattr is None:
+            on_setattr = setters.validate
+
+        # However, if we subclass a frozen class, we inherit the immutability
+        # and disable on_setattr.
+        for base_cls in cls.__bases__:
+            if base_cls.__setattr__ is _frozen_setattrs:
+                if had_on_setattr:
+                    raise ValueError(
+                        "Frozen classes can't use on_setattr "
+                        "(frozen-ness was inherited)."
+                    )
+
+                on_setattr = setters.NO_OP
+                break
+
+        if auto_attribs is not None:
+            return do_it(cls, auto_attribs)
+
+        try:
+            return do_it(cls, True)
+        except UnannotatedAttributeError:
+            return do_it(cls, False)
+
+    # maybe_cls's type depends on the usage of the decorator.  It's a class
+    # if it's used as `@attrs` but ``None`` if used as `@attrs()`.
+    if maybe_cls is None:
+        return wrap
+    else:
+        return wrap(maybe_cls)
+
+
+mutable = define
+frozen = partial(define, frozen=True, on_setattr=None)
+
+
+def field(
+    *,
+    default=NOTHING,
+    validator=None,
+    repr=True,
+    hash=None,
+    init=True,
+    metadata=None,
+    converter=None,
+    factory=None,
+    kw_only=False,
+    eq=None,
+    order=None,
+    on_setattr=None,
+):
+    """
+    Identical to `attr.ib`, except keyword-only and with some arguments
+    removed.
+
+    .. versionadded:: 20.1.0
+    """
+    return attrib(
+        default=default,
+        validator=validator,
+        repr=repr,
+        hash=hash,
+        init=init,
+        metadata=metadata,
+        converter=converter,
+        factory=factory,
+        kw_only=kw_only,
+        eq=eq,
+        order=order,
+        on_setattr=on_setattr,
+    )
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/_version_info.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/_version_info.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,85 @@
+from __future__ import absolute_import, division, print_function
+
+from functools import total_ordering
+
+from ._funcs import astuple
+from ._make import attrib, attrs
+
+
+@total_ordering
+@attrs(eq=False, order=False, slots=True, frozen=True)
+class VersionInfo(object):
+    """
+    A version object that can be compared to tuple of length 1--4:
+
+    >>> attr.VersionInfo(19, 1, 0, "final")  <= (19, 2)
+    True
+    >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1)
+    True
+    >>> vi = attr.VersionInfo(19, 2, 0, "final")
+    >>> vi < (19, 1, 1)
+    False
+    >>> vi < (19,)
+    False
+    >>> vi == (19, 2,)
+    True
+    >>> vi == (19, 2, 1)
+    False
+
+    .. versionadded:: 19.2
+    """
+
+    year = attrib(type=int)
+    minor = attrib(type=int)
+    micro = attrib(type=int)
+    releaselevel = attrib(type=str)
+
+    @classmethod
+    def _from_version_string(cls, s):
+        """
+        Parse *s* and return a _VersionInfo.
+        """
+        v = s.split(".")
+        if len(v) == 3:
+            v.append("final")
+
+        return cls(
+            year=int(v[0]), minor=int(v[1]), micro=int(v[2]), releaselevel=v[3]
+        )
+
+    def _ensure_tuple(self, other):
+        """
+        Ensure *other* is a tuple of a valid length.
+
+        Returns a possibly transformed *other* and ourselves as a tuple of
+        the same length as *other*.
+        """
+
+        if self.__class__ is other.__class__:
+            other = astuple(other)
+
+        if not isinstance(other, tuple):
+            raise NotImplementedError
+
+        if not (1 <= len(other) <= 4):
+            raise NotImplementedError
+
+        return astuple(self)[: len(other)], other
+
+    def __eq__(self, other):
+        try:
+            us, them = self._ensure_tuple(other)
+        except NotImplementedError:
+            return NotImplemented
+
+        return us == them
+
+    def __lt__(self, other):
+        try:
+            us, them = self._ensure_tuple(other)
+        except NotImplementedError:
+            return NotImplemented
+
+        # Since alphabetically "dev0" < "final" < "post1" < "post2", we don't
+        # have to do anything special with releaselevel for now.
+        return us < them
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/_version_info.pyi
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/_version_info.pyi	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,9 @@
+class VersionInfo:
+    @property
+    def year(self) -> int: ...
+    @property
+    def minor(self) -> int: ...
+    @property
+    def micro(self) -> int: ...
+    @property
+    def releaselevel(self) -> str: ...
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/converters.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/converters.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,85 @@
+"""
+Commonly useful converters.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from ._make import NOTHING, Factory, pipe
+
+
+__all__ = [
+    "pipe",
+    "optional",
+    "default_if_none",
+]
+
+
+def optional(converter):
+    """
+    A converter that allows an attribute to be optional. An optional attribute
+    is one which can be set to ``None``.
+
+    :param callable converter: the converter that is used for non-``None``
+        values.
+
+    .. versionadded:: 17.1.0
+    """
+
+    def optional_converter(val):
+        if val is None:
+            return None
+        return converter(val)
+
+    return optional_converter
+
+
+def default_if_none(default=NOTHING, factory=None):
+    """
+    A converter that allows to replace ``None`` values by *default* or the
+    result of *factory*.
+
+    :param default: Value to be used if ``None`` is passed. Passing an instance
+       of `attr.Factory` is supported, however the ``takes_self`` option
+       is *not*.
+    :param callable factory: A callable that takes not parameters whose result
+       is used if ``None`` is passed.
+
+    :raises TypeError: If **neither** *default* or *factory* is passed.
+    :raises TypeError: If **both** *default* and *factory* are passed.
+    :raises ValueError: If an instance of `attr.Factory` is passed with
+       ``takes_self=True``.
+
+    .. versionadded:: 18.2.0
+    """
+    if default is NOTHING and factory is None:
+        raise TypeError("Must pass either `default` or `factory`.")
+
+    if default is not NOTHING and factory is not None:
+        raise TypeError(
+            "Must pass either `default` or `factory` but not both."
+        )
+
+    if factory is not None:
+        default = Factory(factory)
+
+    if isinstance(default, Factory):
+        if default.takes_self:
+            raise ValueError(
+                "`takes_self` is not supported by default_if_none."
+            )
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default.factory()
+
+    else:
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default
+
+    return default_if_none_converter
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/converters.pyi
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/converters.pyi	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,11 @@
+from typing import TypeVar, Optional, Callable, overload
+from . import _ConverterType
+
+_T = TypeVar("_T")
+
+def pipe(*validators: _ConverterType) -> _ConverterType: ...
+def optional(converter: _ConverterType) -> _ConverterType: ...
+@overload
+def default_if_none(default: _T) -> _ConverterType: ...
+@overload
+def default_if_none(*, factory: Callable[[], _T]) -> _ConverterType: ...
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/exceptions.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/exceptions.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,92 @@
+from __future__ import absolute_import, division, print_function
+
+
+class FrozenError(AttributeError):
+    """
+    A frozen/immutable instance or attribute haave been attempted to be
+    modified.
+
+    It mirrors the behavior of ``namedtuples`` by using the same error message
+    and subclassing `AttributeError`.
+
+    .. versionadded:: 20.1.0
+    """
+
+    msg = "can't set attribute"
+    args = [msg]
+
+
+class FrozenInstanceError(FrozenError):
+    """
+    A frozen instance has been attempted to be modified.
+
+    .. versionadded:: 16.1.0
+    """
+
+
+class FrozenAttributeError(FrozenError):
+    """
+    A frozen attribute has been attempted to be modified.
+
+    .. versionadded:: 20.1.0
+    """
+
+
+class AttrsAttributeNotFoundError(ValueError):
+    """
+    An ``attrs`` function couldn't find an attribute that the user asked for.
+
+    .. versionadded:: 16.2.0
+    """
+
+
+class NotAnAttrsClassError(ValueError):
+    """
+    A non-``attrs`` class has been passed into an ``attrs`` function.
+
+    .. versionadded:: 16.2.0
+    """
+
+
+class DefaultAlreadySetError(RuntimeError):
+    """
+    A default has been set using ``attr.ib()`` and is attempted to be reset
+    using the decorator.
+
+    .. versionadded:: 17.1.0
+    """
+
+
+class UnannotatedAttributeError(RuntimeError):
+    """
+    A class with ``auto_attribs=True`` has an ``attr.ib()`` without a type
+    annotation.
+
+    .. versionadded:: 17.3.0
+    """
+
+
+class PythonTooOldError(RuntimeError):
+    """
+    It was attempted to use an ``attrs`` feature that requires a newer Python
+    version.
+
+    .. versionadded:: 18.2.0
+    """
+
+
+class NotCallableError(TypeError):
+    """
+    A ``attr.ib()`` requiring a callable has been set with a value
+    that is not callable.
+
+    .. versionadded:: 19.2.0
+    """
+
+    def __init__(self, msg, value):
+        super(TypeError, self).__init__(msg, value)
+        self.msg = msg
+        self.value = value
+
+    def __str__(self):
+        return str(self.msg)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/exceptions.pyi
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/exceptions.pyi	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,17 @@
+from typing import Any
+
+class FrozenError(AttributeError):
+    msg: str = ...
+
+class FrozenInstanceError(FrozenError): ...
+class FrozenAttributeError(FrozenError): ...
+class AttrsAttributeNotFoundError(ValueError): ...
+class NotAnAttrsClassError(ValueError): ...
+class DefaultAlreadySetError(RuntimeError): ...
+class UnannotatedAttributeError(RuntimeError): ...
+class PythonTooOldError(RuntimeError): ...
+
+class NotCallableError(TypeError):
+    msg: str = ...
+    value: Any = ...
+    def __init__(self, msg: str, value: Any) -> None: ...
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/filters.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/filters.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,52 @@
+"""
+Commonly useful filters for `attr.asdict`.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from ._compat import isclass
+from ._make import Attribute
+
+
+def _split_what(what):
+    """
+    Returns a tuple of `frozenset`s of classes and attributes.
+    """
+    return (
+        frozenset(cls for cls in what if isclass(cls)),
+        frozenset(cls for cls in what if isinstance(cls, Attribute)),
+    )
+
+
+def include(*what):
+    """
+    Whitelist *what*.
+
+    :param what: What to whitelist.
+    :type what: `list` of `type` or `attr.Attribute`\\ s
+
+    :rtype: `callable`
+    """
+    cls, attrs = _split_what(what)
+
+    def include_(attribute, value):
+        return value.__class__ in cls or attribute in attrs
+
+    return include_
+
+
+def exclude(*what):
+    """
+    Blacklist *what*.
+
+    :param what: What to blacklist.
+    :type what: `list` of classes or `attr.Attribute`\\ s.
+
+    :rtype: `callable`
+    """
+    cls, attrs = _split_what(what)
+
+    def exclude_(attribute, value):
+        return value.__class__ not in cls and attribute not in attrs
+
+    return exclude_
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/filters.pyi
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/filters.pyi	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,5 @@
+from typing import Union, Any
+from . import Attribute, _FilterType
+
+def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
+def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/py.typed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/setters.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/setters.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,77 @@
+"""
+Commonly used hooks for on_setattr.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from . import _config
+from .exceptions import FrozenAttributeError
+
+
+def pipe(*setters):
+    """
+    Run all *setters* and return the return value of the last one.
+
+    .. versionadded:: 20.1.0
+    """
+
+    def wrapped_pipe(instance, attrib, new_value):
+        rv = new_value
+
+        for setter in setters:
+            rv = setter(instance, attrib, rv)
+
+        return rv
+
+    return wrapped_pipe
+
+
+def frozen(_, __, ___):
+    """
+    Prevent an attribute to be modified.
+
+    .. versionadded:: 20.1.0
+    """
+    raise FrozenAttributeError()
+
+
+def validate(instance, attrib, new_value):
+    """
+    Run *attrib*'s validator on *new_value* if it has one.
+
+    .. versionadded:: 20.1.0
+    """
+    if _config._run_validators is False:
+        return new_value
+
+    v = attrib.validator
+    if not v:
+        return new_value
+
+    v(instance, attrib, new_value)
+
+    return new_value
+
+
+def convert(instance, attrib, new_value):
+    """
+    Run *attrib*'s converter -- if it has one --  on *new_value* and return the
+    result.
+
+    .. versionadded:: 20.1.0
+    """
+    c = attrib.converter
+    if c:
+        return c(new_value)
+
+    return new_value
+
+
+NO_OP = object()
+"""
+Sentinel for disabling class-wide *on_setattr* hooks for certain attributes.
+
+Does not work in `pipe` or within lists.
+
+.. versionadded:: 20.1.0
+"""
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/setters.pyi
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/setters.pyi	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,18 @@
+from . import _OnSetAttrType, Attribute
+from typing import TypeVar, Any, NewType, NoReturn, cast
+
+_T = TypeVar("_T")
+
+def frozen(
+    instance: Any, attribute: Attribute, new_value: Any
+) -> NoReturn: ...
+def pipe(*setters: _OnSetAttrType) -> _OnSetAttrType: ...
+def validate(instance: Any, attribute: Attribute[_T], new_value: _T) -> _T: ...
+
+# convert is allowed to return Any, because they can be chained using pipe.
+def convert(
+    instance: Any, attribute: Attribute[Any], new_value: Any
+) -> Any: ...
+
+_NoOpType = NewType("_NoOpType", object)
+NO_OP: _NoOpType
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/validators.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/validators.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,379 @@
+"""
+Commonly useful validators.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+import re
+
+from ._make import _AndValidator, and_, attrib, attrs
+from .exceptions import NotCallableError
+
+
+__all__ = [
+    "and_",
+    "deep_iterable",
+    "deep_mapping",
+    "in_",
+    "instance_of",
+    "is_callable",
+    "matches_re",
+    "optional",
+    "provides",
+]
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _InstanceOfValidator(object):
+    type = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not isinstance(value, self.type):
+            raise TypeError(
+                "'{name}' must be {type!r} (got {value!r} that is a "
+                "{actual!r}).".format(
+                    name=attr.name,
+                    type=self.type,
+                    actual=value.__class__,
+                    value=value,
+                ),
+                attr,
+                self.type,
+                value,
+            )
+
+    def __repr__(self):
+        return "<instance_of validator for type {type!r}>".format(
+            type=self.type
+        )
+
+
+def instance_of(type):
+    """
+    A validator that raises a `TypeError` if the initializer is called
+    with a wrong type for this particular attribute (checks are performed using
+    `isinstance` therefore it's also valid to pass a tuple of types).
+
+    :param type: The type to check for.
+    :type type: type or tuple of types
+
+    :raises TypeError: With a human readable error message, the attribute
+        (of type `attr.Attribute`), the expected type, and the value it
+        got.
+    """
+    return _InstanceOfValidator(type)
+
+
+@attrs(repr=False, frozen=True, slots=True)
+class _MatchesReValidator(object):
+    regex = attrib()
+    flags = attrib()
+    match_func = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not self.match_func(value):
+            raise ValueError(
+                "'{name}' must match regex {regex!r}"
+                " ({value!r} doesn't)".format(
+                    name=attr.name, regex=self.regex.pattern, value=value
+                ),
+                attr,
+                self.regex,
+                value,
+            )
+
+    def __repr__(self):
+        return "<matches_re validator for pattern {regex!r}>".format(
+            regex=self.regex
+        )
+
+
+def matches_re(regex, flags=0, func=None):
+    r"""
+    A validator that raises `ValueError` if the initializer is called
+    with a string that doesn't match *regex*.
+
+    :param str regex: a regex string to match against
+    :param int flags: flags that will be passed to the underlying re function
+        (default 0)
+    :param callable func: which underlying `re` function to call (options
+        are `re.fullmatch`, `re.search`, `re.match`, default
+        is ``None`` which means either `re.fullmatch` or an emulation of
+        it on Python 2). For performance reasons, they won't be used directly
+        but on a pre-`re.compile`\ ed pattern.
+
+    .. versionadded:: 19.2.0
+    """
+    fullmatch = getattr(re, "fullmatch", None)
+    valid_funcs = (fullmatch, None, re.search, re.match)
+    if func not in valid_funcs:
+        raise ValueError(
+            "'func' must be one of %s."
+            % (
+                ", ".join(
+                    sorted(
+                        e and e.__name__ or "None" for e in set(valid_funcs)
+                    )
+                ),
+            )
+        )
+
+    pattern = re.compile(regex, flags)
+    if func is re.match:
+        match_func = pattern.match
+    elif func is re.search:
+        match_func = pattern.search
+    else:
+        if fullmatch:
+            match_func = pattern.fullmatch
+        else:
+            pattern = re.compile(r"(?:{})\Z".format(regex), flags)
+            match_func = pattern.match
+
+    return _MatchesReValidator(pattern, flags, match_func)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _ProvidesValidator(object):
+    interface = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not self.interface.providedBy(value):
+            raise TypeError(
+                "'{name}' must provide {interface!r} which {value!r} "
+                "doesn't.".format(
+                    name=attr.name, interface=self.interface, value=value
+                ),
+                attr,
+                self.interface,
+                value,
+            )
+
+    def __repr__(self):
+        return "<provides validator for interface {interface!r}>".format(
+            interface=self.interface
+        )
+
+
+def provides(interface):
+    """
+    A validator that raises a `TypeError` if the initializer is called
+    with an object that does not provide the requested *interface* (checks are
+    performed using ``interface.providedBy(value)`` (see `zope.interface
+    <https://zopeinterface.readthedocs.io/en/latest/>`_).
+
+    :param interface: The interface to check for.
+    :type interface: ``zope.interface.Interface``
+
+    :raises TypeError: With a human readable error message, the attribute
+        (of type `attr.Attribute`), the expected interface, and the
+        value it got.
+    """
+    return _ProvidesValidator(interface)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _OptionalValidator(object):
+    validator = attrib()
+
+    def __call__(self, inst, attr, value):
+        if value is None:
+            return
+
+        self.validator(inst, attr, value)
+
+    def __repr__(self):
+        return "<optional validator for {what} or None>".format(
+            what=repr(self.validator)
+        )
+
+
+def optional(validator):
+    """
+    A validator that makes an attribute optional.  An optional attribute is one
+    which can be set to ``None`` in addition to satisfying the requirements of
+    the sub-validator.
+
+    :param validator: A validator (or a list of validators) that is used for
+        non-``None`` values.
+    :type validator: callable or `list` of callables.
+
+    .. versionadded:: 15.1.0
+    .. versionchanged:: 17.1.0 *validator* can be a list of validators.
+    """
+    if isinstance(validator, list):
+        return _OptionalValidator(_AndValidator(validator))
+    return _OptionalValidator(validator)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _InValidator(object):
+    options = attrib()
+
+    def __call__(self, inst, attr, value):
+        try:
+            in_options = value in self.options
+        except TypeError:  # e.g. `1 in "abc"`
+            in_options = False
+
+        if not in_options:
+            raise ValueError(
+                "'{name}' must be in {options!r} (got {value!r})".format(
+                    name=attr.name, options=self.options, value=value
+                )
+            )
+
+    def __repr__(self):
+        return "<in_ validator with options {options!r}>".format(
+            options=self.options
+        )
+
+
+def in_(options):
+    """
+    A validator that raises a `ValueError` if the initializer is called
+    with a value that does not belong in the options provided.  The check is
+    performed using ``value in options``.
+
+    :param options: Allowed options.
+    :type options: list, tuple, `enum.Enum`, ...
+
+    :raises ValueError: With a human readable error message, the attribute (of
+       type `attr.Attribute`), the expected options, and the value it
+       got.
+
+    .. versionadded:: 17.1.0
+    """
+    return _InValidator(options)
+
+
+@attrs(repr=False, slots=False, hash=True)
+class _IsCallableValidator(object):
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not callable(value):
+            message = (
+                "'{name}' must be callable "
+                "(got {value!r} that is a {actual!r})."
+            )
+            raise NotCallableError(
+                msg=message.format(
+                    name=attr.name, value=value, actual=value.__class__
+                ),
+                value=value,
+            )
+
+    def __repr__(self):
+        return "<is_callable validator>"
+
+
+def is_callable():
+    """
+    A validator that raises a `attr.exceptions.NotCallableError` if the
+    initializer is called with a value for this particular attribute
+    that is not callable.
+
+    .. versionadded:: 19.1.0
+
+    :raises `attr.exceptions.NotCallableError`: With a human readable error
+        message containing the attribute (`attr.Attribute`) name,
+        and the value it got.
+    """
+    return _IsCallableValidator()
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _DeepIterable(object):
+    member_validator = attrib(validator=is_callable())
+    iterable_validator = attrib(
+        default=None, validator=optional(is_callable())
+    )
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if self.iterable_validator is not None:
+            self.iterable_validator(inst, attr, value)
+
+        for member in value:
+            self.member_validator(inst, attr, member)
+
+    def __repr__(self):
+        iterable_identifier = (
+            ""
+            if self.iterable_validator is None
+            else " {iterable!r}".format(iterable=self.iterable_validator)
+        )
+        return (
+            "<deep_iterable validator for{iterable_identifier}"
+            " iterables of {member!r}>"
+        ).format(
+            iterable_identifier=iterable_identifier,
+            member=self.member_validator,
+        )
+
+
+def deep_iterable(member_validator, iterable_validator=None):
+    """
+    A validator that performs deep validation of an iterable.
+
+    :param member_validator: Validator to apply to iterable members
+    :param iterable_validator: Validator to apply to iterable itself
+        (optional)
+
+    .. versionadded:: 19.1.0
+
+    :raises TypeError: if any sub-validators fail
+    """
+    return _DeepIterable(member_validator, iterable_validator)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _DeepMapping(object):
+    key_validator = attrib(validator=is_callable())
+    value_validator = attrib(validator=is_callable())
+    mapping_validator = attrib(default=None, validator=optional(is_callable()))
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if self.mapping_validator is not None:
+            self.mapping_validator(inst, attr, value)
+
+        for key in value:
+            self.key_validator(inst, attr, key)
+            self.value_validator(inst, attr, value[key])
+
+    def __repr__(self):
+        return (
+            "<deep_mapping validator for objects mapping {key!r} to {value!r}>"
+        ).format(key=self.key_validator, value=self.value_validator)
+
+
+def deep_mapping(key_validator, value_validator, mapping_validator=None):
+    """
+    A validator that performs deep validation of a dictionary.
+
+    :param key_validator: Validator to apply to dictionary keys
+    :param value_validator: Validator to apply to dictionary values
+    :param mapping_validator: Validator to apply to top-level mapping
+        attribute (optional)
+
+    .. versionadded:: 19.1.0
+
+    :raises TypeError: if any sub-validators fail
+    """
+    return _DeepMapping(key_validator, value_validator, mapping_validator)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attr/validators.pyi
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attr/validators.pyi	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,66 @@
+from typing import (
+    Container,
+    List,
+    Union,
+    TypeVar,
+    Type,
+    Any,
+    Optional,
+    Tuple,
+    Iterable,
+    Mapping,
+    Callable,
+    Match,
+    AnyStr,
+    overload,
+)
+from . import _ValidatorType
+
+_T = TypeVar("_T")
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_I = TypeVar("_I", bound=Iterable)
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+_M = TypeVar("_M", bound=Mapping)
+
+# To be more precise on instance_of use some overloads.
+# If there are more than 3 items in the tuple then we fall back to Any
+@overload
+def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ...
+@overload
+def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ...
+@overload
+def instance_of(
+    type: Tuple[Type[_T1], Type[_T2]]
+) -> _ValidatorType[Union[_T1, _T2]]: ...
+@overload
+def instance_of(
+    type: Tuple[Type[_T1], Type[_T2], Type[_T3]]
+) -> _ValidatorType[Union[_T1, _T2, _T3]]: ...
+@overload
+def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ...
+def provides(interface: Any) -> _ValidatorType[Any]: ...
+def optional(
+    validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]
+) -> _ValidatorType[Optional[_T]]: ...
+def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
+def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
+def matches_re(
+    regex: AnyStr,
+    flags: int = ...,
+    func: Optional[
+        Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]]
+    ] = ...,
+) -> _ValidatorType[AnyStr]: ...
+def deep_iterable(
+    member_validator: _ValidatorType[_T],
+    iterable_validator: Optional[_ValidatorType[_I]] = ...,
+) -> _ValidatorType[_I]: ...
+def deep_mapping(
+    key_validator: _ValidatorType[_K],
+    value_validator: _ValidatorType[_V],
+    mapping_validator: Optional[_ValidatorType[_M]] = ...,
+) -> _ValidatorType[_M]: ...
+def is_callable() -> _ValidatorType[_T]: ...
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/AUTHORS.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/AUTHORS.rst	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,11 @@
+Credits
+=======
+
+``attrs`` is written and maintained by `Hynek Schlawack <https://hynek.me/>`_.
+
+The development is kindly supported by `Variomedia AG <https://www.variomedia.de/>`_.
+
+A full list of contributors can be found in `GitHub's overview <https://github.com/python-attrs/attrs/graphs/contributors>`_.
+
+It’s the spiritual successor of `characteristic <https://characteristic.readthedocs.io/>`_ and aspires to fix some of it clunkiness and unfortunate decisions.
+Both were inspired by Twisted’s `FancyEqMixin <https://twistedmatrix.com/documents/current/api/twisted.python.util.FancyEqMixin.html>`_ but both are implemented using class decorators because `subclassing is bad for you <https://www.youtube.com/watch?v=3MNVP9-hglc>`_, m’kay?
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/LICENSE
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/LICENSE	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Hynek Schlawack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,241 @@
+Metadata-Version: 2.1
+Name: attrs
+Version: 20.3.0
+Summary: Classes Without Boilerplate
+Home-page: https://www.attrs.org/
+Author: Hynek Schlawack
+Author-email: hs@ox.cx
+Maintainer: Hynek Schlawack
+Maintainer-email: hs@ox.cx
+License: MIT
+Project-URL: Documentation, https://www.attrs.org/
+Project-URL: Bug Tracker, https://github.com/python-attrs/attrs/issues
+Project-URL: Source Code, https://github.com/python-attrs/attrs
+Project-URL: Funding, https://github.com/sponsors/hynek
+Project-URL: Tidelift, https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=pypi
+Keywords: class,attribute,boilerplate
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+Description-Content-Type: text/x-rst
+Provides-Extra: dev
+Requires-Dist: coverage[toml] (>=5.0.2) ; extra == 'dev'
+Requires-Dist: hypothesis ; extra == 'dev'
+Requires-Dist: pympler ; extra == 'dev'
+Requires-Dist: pytest (>=4.3.0) ; extra == 'dev'
+Requires-Dist: six ; extra == 'dev'
+Requires-Dist: zope.interface ; extra == 'dev'
+Requires-Dist: furo ; extra == 'dev'
+Requires-Dist: sphinx ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: furo ; extra == 'docs'
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: zope.interface ; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: coverage[toml] (>=5.0.2) ; extra == 'tests'
+Requires-Dist: hypothesis ; extra == 'tests'
+Requires-Dist: pympler ; extra == 'tests'
+Requires-Dist: pytest (>=4.3.0) ; extra == 'tests'
+Requires-Dist: six ; extra == 'tests'
+Requires-Dist: zope.interface ; extra == 'tests'
+Provides-Extra: tests_no_zope
+Requires-Dist: coverage[toml] (>=5.0.2) ; extra == 'tests_no_zope'
+Requires-Dist: hypothesis ; extra == 'tests_no_zope'
+Requires-Dist: pympler ; extra == 'tests_no_zope'
+Requires-Dist: pytest (>=4.3.0) ; extra == 'tests_no_zope'
+Requires-Dist: six ; extra == 'tests_no_zope'
+
+.. image:: https://www.attrs.org/en/latest/_static/attrs_logo.png
+   :alt: attrs Logo
+
+======================================
+``attrs``: Classes Without Boilerplate
+======================================
+
+.. image:: https://readthedocs.org/projects/attrs/badge/?version=stable
+   :target: https://www.attrs.org/en/stable/?badge=stable
+   :alt: Documentation Status
+
+.. image:: https://github.com/python-attrs/attrs/workflows/CI/badge.svg?branch=master
+   :target: https://github.com/python-attrs/attrs/actions?workflow=CI
+   :alt: CI Status
+
+.. image:: https://codecov.io/github/python-attrs/attrs/branch/master/graph/badge.svg
+   :target: https://codecov.io/github/python-attrs/attrs
+   :alt: Test Coverage
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/psf/black
+   :alt: Code style: black
+
+.. teaser-begin
+
+``attrs`` is the Python package that will bring back the **joy** of **writing classes** by relieving you from the drudgery of implementing object protocols (aka `dunder <https://nedbatchelder.com/blog/200605/dunder.html>`_ methods).
+
+Its main goal is to help you to write **concise** and **correct** software without slowing down your code.
+
+.. teaser-end
+
+For that, it gives you a class decorator and a way to declaratively define the attributes on that class:
+
+.. -code-begin-
+
+.. code-block:: pycon
+
+   >>> import attr
+
+   >>> @attr.s
+   ... class SomeClass(object):
+   ...     a_number = attr.ib(default=42)
+   ...     list_of_numbers = attr.ib(factory=list)
+   ...
+   ...     def hard_math(self, another_number):
+   ...         return self.a_number + sum(self.list_of_numbers) * another_number
+
+
+   >>> sc = SomeClass(1, [1, 2, 3])
+   >>> sc
+   SomeClass(a_number=1, list_of_numbers=[1, 2, 3])
+
+   >>> sc.hard_math(3)
+   19
+   >>> sc == SomeClass(1, [1, 2, 3])
+   True
+   >>> sc != SomeClass(2, [3, 2, 1])
+   True
+
+   >>> attr.asdict(sc)
+   {'a_number': 1, 'list_of_numbers': [1, 2, 3]}
+
+   >>> SomeClass()
+   SomeClass(a_number=42, list_of_numbers=[])
+
+   >>> C = attr.make_class("C", ["a", "b"])
+   >>> C("foo", "bar")
+   C(a='foo', b='bar')
+
+
+After *declaring* your attributes ``attrs`` gives you:
+
+- a concise and explicit overview of the class's attributes,
+- a nice human-readable ``__repr__``,
+- a complete set of comparison methods (equality and ordering),
+- an initializer,
+- and much more,
+
+*without* writing dull boilerplate code again and again and *without* runtime performance penalties.
+
+On Python 3.6 and later, you can often even drop the calls to ``attr.ib()`` by using `type annotations <https://www.attrs.org/en/latest/types.html>`_.
+
+This gives you the power to use actual classes with actual types in your code instead of confusing ``tuple``\ s or `confusingly behaving <https://www.attrs.org/en/stable/why.html#namedtuples>`_ ``namedtuple``\ s.
+Which in turn encourages you to write *small classes* that do `one thing well <https://www.destroyallsoftware.com/talks/boundaries>`_.
+Never again violate the `single responsibility principle <https://en.wikipedia.org/wiki/Single_responsibility_principle>`_ just because implementing ``__init__`` et al is a painful drag.
+
+
+.. -getting-help-
+
+Getting Help
+============
+
+Please use the ``python-attrs`` tag on `StackOverflow <https://stackoverflow.com/questions/tagged/python-attrs>`_ to get help.
+
+Answering questions of your fellow developers is also a great way to help the project!
+
+
+.. -project-information-
+
+Project Information
+===================
+
+``attrs`` is released under the `MIT <https://choosealicense.com/licenses/mit/>`_ license,
+its documentation lives at `Read the Docs <https://www.attrs.org/>`_,
+the code on `GitHub <https://github.com/python-attrs/attrs>`_,
+and the latest release on `PyPI <https://pypi.org/project/attrs/>`_.
+It’s rigorously tested on Python 2.7, 3.5+, and PyPy.
+
+We collect information on **third-party extensions** in our `wiki <https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs>`_.
+Feel free to browse and add your own!
+
+If you'd like to contribute to ``attrs`` you're most welcome and we've written `a little guide <https://www.attrs.org/en/latest/contributing.html>`_ to get you started!
+
+
+``attrs`` for Enterprise
+------------------------
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of ``attrs`` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications.
+Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use.
+`Learn more. <https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=referral&utm_campaign=enterprise&utm_term=repo>`_
+
+
+Release Information
+===================
+
+20.3.0 (2020-11-05)
+-------------------
+
+Backward-incompatible Changes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- ``attr.define()``, ``attr.frozen()``, ``attr.mutable()``, and ``attr.field()`` remain **provisional**.
+
+  This release does **not** change change anything about them and they are already used widely in production though.
+
+  If you wish to use them together with mypy, you can simply drop `this plugin <https://gist.github.com/hynek/1e3844d0c99e479e716169034b5fa963#file-attrs_ng_plugin-py>`_ into your project.
+
+  Feel free to provide feedback to them in the linked issue #668.
+
+  We will release the ``attrs`` namespace once we have the feeling that the APIs have properly settled.
+  `#668 <https://github.com/python-attrs/attrs/issues/668>`_
+
+
+Changes
+^^^^^^^
+
+- ``attr.s()`` now has a *field_transformer* hook that is called for all ``Attribute``\ s and returns a (modified or updated) list of ``Attribute`` instances.
+  ``attr.asdict()`` has a *value_serializer* hook that can change the way values are converted.
+  Both hooks are meant to help with data (de-)serialization workflows.
+  `#653 <https://github.com/python-attrs/attrs/issues/653>`_
+- ``kw_only=True`` now works on Python 2.
+  `#700 <https://github.com/python-attrs/attrs/issues/700>`_
+- ``raise from`` now works on frozen classes on PyPy.
+  `#703 <https://github.com/python-attrs/attrs/issues/703>`_,
+  `#712 <https://github.com/python-attrs/attrs/issues/712>`_
+- ``attr.asdict()`` and ``attr.astuple()`` now treat ``frozenset``\ s like ``set``\ s with regards to the *retain_collection_types* argument.
+  `#704 <https://github.com/python-attrs/attrs/issues/704>`_
+- The type stubs for ``attr.s()`` and ``attr.make_class()`` are not missing the *collect_by_mro* argument anymore.
+  `#711 <https://github.com/python-attrs/attrs/issues/711>`_
+
+`Full changelog <https://www.attrs.org/en/stable/changelog.html>`_.
+
+Credits
+=======
+
+``attrs`` is written and maintained by `Hynek Schlawack <https://hynek.me/>`_.
+
+The development is kindly supported by `Variomedia AG <https://www.variomedia.de/>`_.
+
+A full list of contributors can be found in `GitHub's overview <https://github.com/python-attrs/attrs/graphs/contributors>`_.
+
+It’s the spiritual successor of `characteristic <https://characteristic.readthedocs.io/>`_ and aspires to fix some of it clunkiness and unfortunate decisions.
+Both were inspired by Twisted’s `FancyEqMixin <https://twistedmatrix.com/documents/current/api/twisted.python.util.FancyEqMixin.html>`_ but both are implemented using class decorators because `subclassing is bad for you <https://www.youtube.com/watch?v=3MNVP9-hglc>`_, m’kay?
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,39 @@
+attr/__init__.py,sha256=70KmZOgz2sUvtRTC_IuXEeN2ttOyBWHn4XA59aqGXPs,1568
+attr/__init__.pyi,sha256=ca_4sg7z0e_EL7ehy-flXVGAju5PBX2hVo51dUmPMi0,12986
+attr/__pycache__/__init__.cpython-39.pyc,,
+attr/__pycache__/_compat.cpython-39.pyc,,
+attr/__pycache__/_config.cpython-39.pyc,,
+attr/__pycache__/_funcs.cpython-39.pyc,,
+attr/__pycache__/_make.cpython-39.pyc,,
+attr/__pycache__/_next_gen.cpython-39.pyc,,
+attr/__pycache__/_version_info.cpython-39.pyc,,
+attr/__pycache__/converters.cpython-39.pyc,,
+attr/__pycache__/exceptions.cpython-39.pyc,,
+attr/__pycache__/filters.cpython-39.pyc,,
+attr/__pycache__/setters.cpython-39.pyc,,
+attr/__pycache__/validators.cpython-39.pyc,,
+attr/_compat.py,sha256=rZhpP09xbyWSzMv796XQbryIr21oReJFvA70G3lrHxg,7308
+attr/_config.py,sha256=_KvW0mQdH2PYjHc0YfIUaV_o2pVfM7ziMEYTxwmEhOA,514
+attr/_funcs.py,sha256=PvFQlflEswO_qIR2sUr4a4x8ggQpEoDKe3YKM2rLJu4,13081
+attr/_make.py,sha256=61XB4-SHQpFbWbStGWotTTbzVT2m49DUovRgnxpMqmU,88313
+attr/_next_gen.py,sha256=x6TU2rVOXmFmrNNvkfshJsxyRbAAK0wDI4SJV2OI97c,4138
+attr/_version_info.py,sha256=azMi1lNelb3cJvvYUMXsXVbUANkRzbD5IEiaXVpeVr4,2162
+attr/_version_info.pyi,sha256=x_M3L3WuB7r_ULXAWjx959udKQ4HLB8l-hsc1FDGNvk,209
+attr/converters.py,sha256=CaK6iLtEMmemrqU8LQ1D2nWtbo9dGPAv4UaZ0rFzhOA,2214
+attr/converters.pyi,sha256=fVGSfawF3NMy2EBApkC7dAwMuujWCHnGEnnAgsbkVpg,380
+attr/exceptions.py,sha256=gmlET97ikqdQVvy7Ff9p7zVvqc2SsNtTd-r30pva1GE,1950
+attr/exceptions.pyi,sha256=zZq8bCUnKAy9mDtBEw42ZhPhAUIHoTKedDQInJD883M,539
+attr/filters.py,sha256=weDxwATsa69T_0bPVjiM1fGsciAMQmwhY5G8Jm5BxuI,1098
+attr/filters.pyi,sha256=xDpmKQlFdssgxGa5tsl1ADh_3zwAwAT4vUhd8h-8-Tk,214
+attr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attr/setters.py,sha256=0ElzHwdVK3dsYcQi2CXkFvhx8fNxUI5OVhw8SWeaKmA,1434
+attr/setters.pyi,sha256=SYr6adhx4f0dSkmmBICg6eK8WMev5jT-KJQJTdul078,567
+attr/validators.py,sha256=6DBx1jt4oZxx1ppvx6JWqm9-UAsYpXC4HTwxJilCeRg,11497
+attr/validators.pyi,sha256=vZgsJqUwrJevh4v_Hd7_RSXqDrBctE6-3AEZ7uYKodo,1868
+attrs-20.3.0.dist-info/AUTHORS.rst,sha256=wsqCNbGz_mklcJrt54APIZHZpoTIJLkXqEhhn4Nd8hc,752
+attrs-20.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+attrs-20.3.0.dist-info/LICENSE,sha256=v2WaKLSSQGAvVrvfSQy-LsUJsVuY-Z17GaUsdA4yeGM,1082
+attrs-20.3.0.dist-info/METADATA,sha256=2XTmALrRRbIZj9J8pJgpKYnyATu_NAL8vfUnqRFpE5w,10220
+attrs-20.3.0.dist-info/RECORD,,
+attrs-20.3.0.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+attrs-20.3.0.dist-info/top_level.txt,sha256=tlRYMddkRlKPqJ96wP2_j9uEsmcNHgD2SbuWd4CzGVU,5
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/attrs-20.3.0.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+attr
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/backports/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/backports/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)  # type: ignore
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/backports/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/backports/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/backports/configparser/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/backports/configparser/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1442 @@
+"""Configuration file parser.
+
+A configuration file consists of sections, lead by a "[section]" header,
+and followed by "name: value" entries, with continuations and such in
+the style of RFC 822.
+
+Intrinsic defaults can be specified by passing them into the
+ConfigParser constructor as a dictionary.
+
+class:
+
+ConfigParser -- responsible for parsing a list of
+                    configuration files, and managing the parsed database.
+
+    methods:
+
+    __init__(defaults=None, dict_type=_default_dict, allow_no_value=False,
+             delimiters=('=', ':'), comment_prefixes=('#', ';'),
+             inline_comment_prefixes=None, strict=True,
+             empty_lines_in_values=True, default_section='DEFAULT',
+             interpolation=<unset>, converters=<unset>):
+        Create the parser. When `defaults' is given, it is initialized into the
+        dictionary or intrinsic defaults. The keys must be strings, the values
+        must be appropriate for %()s string interpolation.
+
+        When `dict_type' is given, it will be used to create the dictionary
+        objects for the list of sections, for the options within a section, and
+        for the default values.
+
+        When `delimiters' is given, it will be used as the set of substrings
+        that divide keys from values.
+
+        When `comment_prefixes' is given, it will be used as the set of
+        substrings that prefix comments in empty lines. Comments can be
+        indented.
+
+        When `inline_comment_prefixes' is given, it will be used as the set of
+        substrings that prefix comments in non-empty lines.
+
+        When `strict` is True, the parser won't allow for any section or option
+        duplicates while reading from a single source (file, string or
+        dictionary). Default is True.
+
+        When `empty_lines_in_values' is False (default: True), each empty line
+        marks the end of an option. Otherwise, internal empty lines of
+        a multiline option are kept as part of the value.
+
+        When `allow_no_value' is True (default: False), options without
+        values are accepted; the value presented for these is None.
+
+        When `default_section' is given, the name of the special section is
+        named accordingly. By default it is called ``"DEFAULT"`` but this can
+        be customized to point to any other valid section name. Its current
+        value can be retrieved using the ``parser_instance.default_section``
+        attribute and may be modified at runtime.
+
+        When `interpolation` is given, it should be an Interpolation subclass
+        instance. It will be used as the handler for option value
+        pre-processing when using getters. RawConfigParser objects don't do
+        any sort of interpolation, whereas ConfigParser uses an instance of
+        BasicInterpolation. The library also provides a ``zc.buildbot``
+        inspired ExtendedInterpolation implementation.
+
+        When `converters` is given, it should be a dictionary where each key
+        represents the name of a type converter and each value is a callable
+        implementing the conversion from string to the desired datatype. Every
+        converter gets its corresponding get*() method on the parser object and
+        section proxies.
+
+    sections()
+        Return all the configuration section names, sans DEFAULT.
+
+    has_section(section)
+        Return whether the given section exists.
+
+    has_option(section, option)
+        Return whether the given option exists in the given section.
+
+    options(section)
+        Return list of configuration options for the named section.
+
+    read(filenames, encoding=None)
+        Read and parse the iterable of named configuration files, given by
+        name.  A single filename is also allowed.  Non-existing files
+        are ignored.  Return list of successfully read files.
+
+    read_file(f, filename=None)
+        Read and parse one configuration file, given as a file object.
+        The filename defaults to f.name; it is only used in error
+        messages (if f has no `name' attribute, the string `<???>' is used).
+
+    read_string(string)
+        Read configuration from a given string.
+
+    read_dict(dictionary)
+        Read configuration from a dictionary. Keys are section names,
+        values are dictionaries with keys and values that should be present
+        in the section. If the used dictionary type preserves order, sections
+        and their keys will be added in order. Values are automatically
+        converted to strings.
+
+    get(section, option, raw=False, vars=None, fallback=_UNSET)
+        Return a string value for the named option.  All % interpolations are
+        expanded in the return values, based on the defaults passed into the
+        constructor and the DEFAULT section.  Additional substitutions may be
+        provided using the `vars' argument, which must be a dictionary whose
+        contents override any pre-existing defaults. If `option' is a key in
+        `vars', the value from `vars' is used.
+
+    getint(section, options, raw=False, vars=None, fallback=_UNSET)
+        Like get(), but convert value to an integer.
+
+    getfloat(section, options, raw=False, vars=None, fallback=_UNSET)
+        Like get(), but convert value to a float.
+
+    getboolean(section, options, raw=False, vars=None, fallback=_UNSET)
+        Like get(), but convert value to a boolean (currently case
+        insensitively defined as 0, false, no, off for False, and 1, true,
+        yes, on for True).  Returns False or True.
+
+    items(section=_UNSET, raw=False, vars=None)
+        If section is given, return a list of tuples with (name, value) for
+        each option in the section. Otherwise, return a list of tuples with
+        (section_name, section_proxy) for each section, including DEFAULTSECT.
+
+    remove_section(section)
+        Remove the given file section and all its options.
+
+    remove_option(section, option)
+        Remove the given option from the given section.
+
+    set(section, option, value)
+        Set the given option.
+
+    write(fp, space_around_delimiters=True)
+        Write the configuration state in .ini format. If
+        `space_around_delimiters' is True (the default), delimiters
+        between keys and values are surrounded by spaces.
+"""
+
+import functools
+import io
+import itertools
+import os
+import re
+import sys
+import warnings
+from collections import OrderedDict as _default_dict
+from collections import ChainMap as _ChainMap
+from collections.abc import MutableMapping
+
+__all__ = [
+    "NoSectionError",
+    "DuplicateOptionError",
+    "DuplicateSectionError",
+    "NoOptionError",
+    "InterpolationError",
+    "InterpolationDepthError",
+    "InterpolationMissingOptionError",
+    "InterpolationSyntaxError",
+    "ParsingError",
+    "MissingSectionHeaderError",
+    "ConfigParser",
+    "SafeConfigParser",
+    "RawConfigParser",
+    "Interpolation",
+    "BasicInterpolation",
+    "ExtendedInterpolation",
+    "LegacyInterpolation",
+    "SectionProxy",
+    "ConverterMapping",
+    "DEFAULTSECT",
+    "MAX_INTERPOLATION_DEPTH",
+]
+
+DEFAULTSECT = "DEFAULT"
+
+MAX_INTERPOLATION_DEPTH = 10
+
+
+# exception classes
+class Error(Exception):
+    """Base class for ConfigParser exceptions."""
+
+    def __init__(self, msg=''):
+        self.message = msg
+        Exception.__init__(self, msg)
+
+    def __repr__(self):
+        return self.message
+
+    __str__ = __repr__
+
+
+class NoSectionError(Error):
+    """Raised when no section matches a requested option."""
+
+    def __init__(self, section):
+        Error.__init__(self, 'No section: %r' % (section,))
+        self.section = section
+        self.args = (section,)
+
+
+class DuplicateSectionError(Error):
+    """Raised when a section is repeated in an input source.
+
+    Possible repetitions that raise this exception are: multiple creation
+    using the API or in strict parsers when a section is found more than once
+    in a single input file, string or dictionary.
+    """
+
+    def __init__(self, section, source=None, lineno=None):
+        msg = [repr(section), " already exists"]
+        if source is not None:
+            message = ["While reading from ", repr(source)]
+            if lineno is not None:
+                message.append(" [line {0:2d}]".format(lineno))
+            message.append(": section ")
+            message.extend(msg)
+            msg = message
+        else:
+            msg.insert(0, "Section ")
+        Error.__init__(self, "".join(msg))
+        self.section = section
+        self.source = source
+        self.lineno = lineno
+        self.args = (section, source, lineno)
+
+
+class DuplicateOptionError(Error):
+    """Raised by strict parsers when an option is repeated in an input source.
+
+    Current implementation raises this exception only when an option is found
+    more than once in a single file, string or dictionary.
+    """
+
+    def __init__(self, section, option, source=None, lineno=None):
+        msg = [repr(option), " in section ", repr(section), " already exists"]
+        if source is not None:
+            message = ["While reading from ", repr(source)]
+            if lineno is not None:
+                message.append(" [line {0:2d}]".format(lineno))
+            message.append(": option ")
+            message.extend(msg)
+            msg = message
+        else:
+            msg.insert(0, "Option ")
+        Error.__init__(self, "".join(msg))
+        self.section = section
+        self.option = option
+        self.source = source
+        self.lineno = lineno
+        self.args = (section, option, source, lineno)
+
+
+class NoOptionError(Error):
+    """A requested option was not found."""
+
+    def __init__(self, option, section):
+        Error.__init__(self, "No option %r in section: %r" % (option, section))
+        self.option = option
+        self.section = section
+        self.args = (option, section)
+
+
+class InterpolationError(Error):
+    """Base class for interpolation-related exceptions."""
+
+    def __init__(self, option, section, msg):
+        Error.__init__(self, msg)
+        self.option = option
+        self.section = section
+        self.args = (option, section, msg)
+
+
+class InterpolationMissingOptionError(InterpolationError):
+    """A string substitution required a setting which was not available."""
+
+    def __init__(self, option, section, rawval, reference):
+        msg = (
+            "Bad value substitution: option {0!r} in section {1!r} contains "
+            "an interpolation key {2!r} which is not a valid option name. "
+            "Raw value: {3!r}".format(option, section, reference, rawval)
+        )
+        InterpolationError.__init__(self, option, section, msg)
+        self.reference = reference
+        self.args = (option, section, rawval, reference)
+
+
+class InterpolationSyntaxError(InterpolationError):
+    """Raised when the source text contains invalid syntax.
+
+    Current implementation raises this exception when the source text into
+    which substitutions are made does not conform to the required syntax.
+    """
+
+
+class InterpolationDepthError(InterpolationError):
+    """Raised when substitutions are nested too deeply."""
+
+    def __init__(self, option, section, rawval):
+        msg = (
+            "Recursion limit exceeded in value substitution: option {0!r} "
+            "in section {1!r} contains an interpolation key which "
+            "cannot be substituted in {2} steps. Raw value: {3!r}"
+            "".format(option, section, MAX_INTERPOLATION_DEPTH, rawval)
+        )
+        InterpolationError.__init__(self, option, section, msg)
+        self.args = (option, section, rawval)
+
+
+class ParsingError(Error):
+    """Raised when a configuration file does not follow legal syntax."""
+
+    def __init__(self, source=None, filename=None):
+        # Exactly one of `source'/`filename' arguments has to be given.
+        # `filename' kept for compatibility.
+        if filename and source:
+            raise ValueError(
+                "Cannot specify both `filename' and `source'. " "Use `source'."
+            )
+        elif not filename and not source:
+            raise ValueError("Required argument `source' not given.")
+        elif filename:
+            source = filename
+        Error.__init__(self, 'Source contains parsing errors: %r' % source)
+        self.source = source
+        self.errors = []
+        self.args = (source,)
+
+    @property
+    def filename(self):
+        """Deprecated, use `source'."""
+        warnings.warn(
+            "The 'filename' attribute will be removed in future versions.  "
+            "Use 'source' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.source
+
+    @filename.setter
+    def filename(self, value):
+        """Deprecated, user `source'."""
+        warnings.warn(
+            "The 'filename' attribute will be removed in future versions.  "
+            "Use 'source' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.source = value
+
+    def append(self, lineno, line):
+        self.errors.append((lineno, line))
+        self.message += '\n\t[line %2d]: %s' % (lineno, line)
+
+
+class MissingSectionHeaderError(ParsingError):
+    """Raised when a key-value pair is found before any section header."""
+
+    def __init__(self, filename, lineno, line):
+        Error.__init__(
+            self,
+            'File contains no section headers.\nfile: %r, line: %d\n%r'
+            % (filename, lineno, line),
+        )
+        self.source = filename
+        self.lineno = lineno
+        self.line = line
+        self.args = (filename, lineno, line)
+
+
+# Used in parser getters to indicate the default behaviour when a specific
+# option is not found it to raise an exception. Created to enable `None' as
+# a valid fallback value.
+_UNSET = object()
+
+
+class Interpolation(object):
+    """Dummy interpolation that passes the value through with no changes."""
+
+    def before_get(self, parser, section, option, value, defaults):
+        return value
+
+    def before_set(self, parser, section, option, value):
+        return value
+
+    def before_read(self, parser, section, option, value):
+        return value
+
+    def before_write(self, parser, section, option, value):
+        return value
+
+
+class BasicInterpolation(Interpolation):
+    """Interpolation as implemented in the classic ConfigParser.
+
+    The option values can contain format strings which refer to other values in
+    the same section, or values in the special default section.
+
+    For example:
+
+        something: %(dir)s/whatever
+
+    would resolve the "%(dir)s" to the value of dir.  All reference
+    expansions are done late, on demand. If a user needs to use a bare % in
+    a configuration file, she can escape it by writing %%. Other % usage
+    is considered a user error and raises `InterpolationSyntaxError'."""
+
+    _KEYCRE = re.compile(r"%\(([^)]+)\)s")
+
+    def before_get(self, parser, section, option, value, defaults):
+        L = []
+        self._interpolate_some(parser, option, L, value, section, defaults, 1)
+        return ''.join(L)
+
+    def before_set(self, parser, section, option, value):
+        tmp_value = value.replace('%%', '')  # escaped percent signs
+        tmp_value = self._KEYCRE.sub('', tmp_value)  # valid syntax
+        if '%' in tmp_value:
+            raise ValueError(
+                "invalid interpolation syntax in %r at "
+                "position %d" % (value, tmp_value.find('%'))
+            )
+        return value
+
+    def _interpolate_some(  # noqa: C901
+        self, parser, option, accum, rest, section, map, depth
+    ):
+        rawval = parser.get(section, option, raw=True, fallback=rest)
+        if depth > MAX_INTERPOLATION_DEPTH:
+            raise InterpolationDepthError(option, section, rawval)
+        while rest:
+            p = rest.find("%")
+            if p < 0:
+                accum.append(rest)
+                return
+            if p > 0:
+                accum.append(rest[:p])
+                rest = rest[p:]
+            # p is no longer used
+            c = rest[1:2]
+            if c == "%":
+                accum.append("%")
+                rest = rest[2:]
+            elif c == "(":
+                m = self._KEYCRE.match(rest)
+                if m is None:
+                    raise InterpolationSyntaxError(
+                        option,
+                        section,
+                        "bad interpolation variable reference %r" % rest,
+                    )
+                var = parser.optionxform(m.group(1))
+                rest = rest[m.end() :]
+                try:
+                    v = map[var]
+                except KeyError:
+                    raise InterpolationMissingOptionError(
+                        option, section, rawval, var
+                    ) from None
+                if "%" in v:
+                    self._interpolate_some(
+                        parser, option, accum, v, section, map, depth + 1
+                    )
+                else:
+                    accum.append(v)
+            else:
+                raise InterpolationSyntaxError(
+                    option,
+                    section,
+                    "'%%' must be followed by '%%' or '(', " "found: %r" % (rest,),
+                )
+
+
+class ExtendedInterpolation(Interpolation):
+    """Advanced variant of interpolation, supports the syntax used by
+    `zc.buildout'. Enables interpolation between sections."""
+
+    _KEYCRE = re.compile(r"\$\{([^}]+)\}")
+
+    def before_get(self, parser, section, option, value, defaults):
+        L = []
+        self._interpolate_some(parser, option, L, value, section, defaults, 1)
+        return ''.join(L)
+
+    def before_set(self, parser, section, option, value):
+        tmp_value = value.replace('$$', '')  # escaped dollar signs
+        tmp_value = self._KEYCRE.sub('', tmp_value)  # valid syntax
+        if '$' in tmp_value:
+            raise ValueError(
+                "invalid interpolation syntax in %r at "
+                "position %d" % (value, tmp_value.find('$'))
+            )
+        return value
+
+    def _interpolate_some(  # noqa: C901
+        self, parser, option, accum, rest, section, map, depth
+    ):
+        rawval = parser.get(section, option, raw=True, fallback=rest)
+        if depth > MAX_INTERPOLATION_DEPTH:
+            raise InterpolationDepthError(option, section, rawval)
+        while rest:
+            p = rest.find("$")
+            if p < 0:
+                accum.append(rest)
+                return
+            if p > 0:
+                accum.append(rest[:p])
+                rest = rest[p:]
+            # p is no longer used
+            c = rest[1:2]
+            if c == "$":
+                accum.append("$")
+                rest = rest[2:]
+            elif c == "{":
+                m = self._KEYCRE.match(rest)
+                if m is None:
+                    raise InterpolationSyntaxError(
+                        option,
+                        section,
+                        "bad interpolation variable reference %r" % rest,
+                    )
+                path = m.group(1).split(':')
+                rest = rest[m.end() :]
+                sect = section
+                opt = option
+                try:
+                    if len(path) == 1:
+                        opt = parser.optionxform(path[0])
+                        v = map[opt]
+                    elif len(path) == 2:
+                        sect = path[0]
+                        opt = parser.optionxform(path[1])
+                        v = parser.get(sect, opt, raw=True)
+                    else:
+                        raise InterpolationSyntaxError(
+                            option, section, "More than one ':' found: %r" % (rest,)
+                        )
+                except (KeyError, NoSectionError, NoOptionError):
+                    raise InterpolationMissingOptionError(
+                        option, section, rawval, ":".join(path)
+                    ) from None
+                if "$" in v:
+                    self._interpolate_some(
+                        parser,
+                        opt,
+                        accum,
+                        v,
+                        sect,
+                        dict(parser.items(sect, raw=True)),
+                        depth + 1,
+                    )
+                else:
+                    accum.append(v)
+            else:
+                raise InterpolationSyntaxError(
+                    option,
+                    section,
+                    "'$' must be followed by '$' or '{', " "found: %r" % (rest,),
+                )
+
+
+class LegacyInterpolation(Interpolation):
+    """Deprecated interpolation used in old versions of ConfigParser.
+    Use BasicInterpolation or ExtendedInterpolation instead."""
+
+    _KEYCRE = re.compile(r"%\(([^)]*)\)s|.")
+
+    def before_get(self, parser, section, option, value, vars):
+        rawval = value
+        depth = MAX_INTERPOLATION_DEPTH
+        while depth:  # Loop through this until it's done
+            depth -= 1
+            if value and "%(" in value:
+                replace = functools.partial(self._interpolation_replace, parser=parser)
+                value = self._KEYCRE.sub(replace, value)
+                try:
+                    value = value % vars
+                except KeyError as e:
+                    raise InterpolationMissingOptionError(
+                        option, section, rawval, e.args[0]
+                    ) from None
+            else:
+                break
+        if value and "%(" in value:
+            raise InterpolationDepthError(option, section, rawval)
+        return value
+
+    def before_set(self, parser, section, option, value):
+        return value
+
+    @staticmethod
+    def _interpolation_replace(match, parser):
+        s = match.group(1)
+        if s is None:
+            return match.group()
+        else:
+            return "%%(%s)s" % parser.optionxform(s)
+
+
+class RawConfigParser(MutableMapping):
+    """ConfigParser that does not do interpolation."""
+
+    # Regular expressions for parsing section headers and options
+    _SECT_TMPL = r"""
+        \[                                 # [
+        (?P<header>[^]]+)                  # very permissive!
+        \]                                 # ]
+        """
+    _OPT_TMPL = r"""
+        (?P<option>.*?)                    # very permissive!
+        \s*(?P<vi>{delim})\s*              # any number of space/tab,
+                                           # followed by any of the
+                                           # allowed delimiters,
+                                           # followed by any space/tab
+        (?P<value>.*)$                     # everything up to eol
+        """
+    _OPT_NV_TMPL = r"""
+        (?P<option>.*?)                    # very permissive!
+        \s*(?:                             # any number of space/tab,
+        (?P<vi>{delim})\s*                 # optionally followed by
+                                           # any of the allowed
+                                           # delimiters, followed by any
+                                           # space/tab
+        (?P<value>.*))?$                   # everything up to eol
+        """
+    # Interpolation algorithm to be used if the user does not specify another
+    _DEFAULT_INTERPOLATION = Interpolation()
+    # Compiled regular expression for matching sections
+    SECTCRE = re.compile(_SECT_TMPL, re.VERBOSE)
+    # Compiled regular expression for matching options with typical separators
+    OPTCRE = re.compile(_OPT_TMPL.format(delim="=|:"), re.VERBOSE)
+    # Compiled regular expression for matching options with optional values
+    # delimited using typical separators
+    OPTCRE_NV = re.compile(_OPT_NV_TMPL.format(delim="=|:"), re.VERBOSE)
+    # Compiled regular expression for matching leading whitespace in a line
+    NONSPACECRE = re.compile(r"\S")
+    # Possible boolean values in the configuration.
+    BOOLEAN_STATES = {
+        '1': True,
+        'yes': True,
+        'true': True,
+        'on': True,
+        '0': False,
+        'no': False,
+        'false': False,
+        'off': False,
+    }
+
+    def __init__(
+        self, defaults=None, dict_type=_default_dict, allow_no_value=False, **kwargs
+    ):
+
+        # keyword-only arguments
+        delimiters = kwargs.get('delimiters', ('=', ':'))
+        comment_prefixes = kwargs.get('comment_prefixes', ('#', ';'))
+        inline_comment_prefixes = kwargs.get('inline_comment_prefixes', None)
+        strict = kwargs.get('strict', True)
+        empty_lines_in_values = kwargs.get('empty_lines_in_values', True)
+        default_section = kwargs.get('default_section', DEFAULTSECT)
+        interpolation = kwargs.get('interpolation', _UNSET)
+        converters = kwargs.get('converters', _UNSET)
+
+        self._dict = dict_type
+        self._sections = self._dict()
+        self._defaults = self._dict()
+        self._converters = ConverterMapping(self)
+        self._proxies = self._dict()
+        self._proxies[default_section] = SectionProxy(self, default_section)
+        self._delimiters = tuple(delimiters)
+        if delimiters == ('=', ':'):
+            self._optcre = self.OPTCRE_NV if allow_no_value else self.OPTCRE
+        else:
+            d = "|".join(re.escape(d) for d in delimiters)
+            if allow_no_value:
+                self._optcre = re.compile(self._OPT_NV_TMPL.format(delim=d), re.VERBOSE)
+            else:
+                self._optcre = re.compile(self._OPT_TMPL.format(delim=d), re.VERBOSE)
+        self._comment_prefixes = tuple(comment_prefixes or ())
+        self._inline_comment_prefixes = tuple(inline_comment_prefixes or ())
+        self._strict = strict
+        self._allow_no_value = allow_no_value
+        self._empty_lines_in_values = empty_lines_in_values
+        self.default_section = default_section
+        self._interpolation = interpolation
+        if self._interpolation is _UNSET:
+            self._interpolation = self._DEFAULT_INTERPOLATION
+        if self._interpolation is None:
+            self._interpolation = Interpolation()
+        if converters is not _UNSET:
+            self._converters.update(converters)
+        if defaults:
+            self._read_defaults(defaults)
+
+    def defaults(self):
+        return self._defaults
+
+    def sections(self):
+        """Return a list of section names, excluding [DEFAULT]"""
+        # self._sections will never have [DEFAULT] in it
+        return list(self._sections.keys())
+
+    def add_section(self, section):
+        """Create a new section in the configuration.
+
+        Raise DuplicateSectionError if a section by the specified name
+        already exists. Raise ValueError if name is DEFAULT.
+        """
+        if section == self.default_section:
+            raise ValueError('Invalid section name: %r' % section)
+
+        if section in self._sections:
+            raise DuplicateSectionError(section)
+        self._sections[section] = self._dict()
+        self._proxies[section] = SectionProxy(self, section)
+
+    def has_section(self, section):
+        """Indicate whether the named section is present in the configuration.
+
+        The DEFAULT section is not acknowledged.
+        """
+        return section in self._sections
+
+    def options(self, section):
+        """Return a list of option names for the given section name."""
+        try:
+            opts = self._sections[section].copy()
+        except KeyError:
+            raise NoSectionError(section) from None
+        opts.update(self._defaults)
+        return list(opts.keys())
+
+    def read(self, filenames, encoding=None):
+        """Read and parse a filename or an iterable of filenames.
+
+        Files that cannot be opened are silently ignored; this is
+        designed so that you can specify an iterable of potential
+        configuration file locations (e.g. current directory, user's
+        home directory, systemwide directory), and all existing
+        configuration files in the iterable will be read.  A single
+        filename may also be given.
+
+        Return list of successfully read files.
+        """
+        if isinstance(filenames, (str, bytes, os.PathLike)):
+            filenames = [filenames]
+        read_ok = []
+        for filename in filenames:
+            if isinstance(filename, os.PathLike):
+                filename = os.fspath(filename)
+            try:
+                with open(filename, encoding=encoding) as fp:
+                    self._read(fp, filename)
+            except IOError:
+                continue
+            read_ok.append(filename)
+        return read_ok
+
+    def read_file(self, f, source=None):
+        """Like read() but the argument must be a file-like object.
+
+        The `f' argument must be iterable, returning one line at a time.
+        Optional second argument is the `source' specifying the name of the
+        file being read. If not given, it is taken from f.name. If `f' has no
+        `name' attribute, `<???>' is used.
+        """
+        if source is None:
+            try:
+                source = f.name
+            except AttributeError:
+                source = '<???>'
+        self._read(f, source)
+
+    def read_string(self, string, source='<string>'):
+        """Read configuration from a given string."""
+        sfile = io.StringIO(string)
+        self.read_file(sfile, source)
+
+    def read_dict(self, dictionary, source='<dict>'):
+        """Read configuration from a dictionary.
+
+        Keys are section names, values are dictionaries with keys and values
+        that should be present in the section. If the used dictionary type
+        preserves order, sections and their keys will be added in order.
+
+        All types held in the dictionary are converted to strings during
+        reading, including section names, option names and keys.
+
+        Optional second argument is the `source' specifying the name of the
+        dictionary being read.
+        """
+        elements_added = set()
+        for section, keys in dictionary.items():
+            section = str(section)
+            try:
+                self.add_section(section)
+            except (DuplicateSectionError, ValueError):
+                if self._strict and section in elements_added:
+                    raise
+            elements_added.add(section)
+            for key, value in keys.items():
+                key = self.optionxform(str(key))
+                if value is not None:
+                    value = str(value)
+                if self._strict and (section, key) in elements_added:
+                    raise DuplicateOptionError(section, key, source)
+                elements_added.add((section, key))
+                self.set(section, key, value)
+
+    def readfp(self, fp, filename=None):
+        """Deprecated, use read_file instead."""
+        warnings.warn(
+            "This method will be removed in future versions.  "
+            "Use 'parser.read_file()' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.read_file(fp, source=filename)
+
+    def get(self, section, option, **kwargs):
+        """Get an option value for a given section.
+
+        If `vars' is provided, it must be a dictionary. The option is looked up
+        in `vars' (if provided), `section', and in `DEFAULTSECT' in that order.
+        If the key is not found and `fallback' is provided, it is used as
+        a fallback value. `None' can be provided as a `fallback' value.
+
+        If interpolation is enabled and the optional argument `raw' is False,
+        all interpolations are expanded in the return values.
+
+        Arguments `raw', `vars', and `fallback' are keyword only.
+
+        The section DEFAULT is special.
+        """
+        # keyword-only arguments
+        raw = kwargs.get('raw', False)
+        vars = kwargs.get('vars', None)
+        fallback = kwargs.get('fallback', _UNSET)
+
+        try:
+            d = self._unify_values(section, vars)
+        except NoSectionError:
+            if fallback is _UNSET:
+                raise
+            else:
+                return fallback
+        option = self.optionxform(option)
+        try:
+            value = d[option]
+        except KeyError:
+            if fallback is _UNSET:
+                raise NoOptionError(option, section)
+            else:
+                return fallback
+
+        if raw or value is None:
+            return value
+        else:
+            return self._interpolation.before_get(self, section, option, value, d)
+
+    def _get(self, section, conv, option, **kwargs):
+        return conv(self.get(section, option, **kwargs))
+
+    def _get_conv(self, section, option, conv, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        fallback = kwargs.pop('fallback', _UNSET)
+        try:
+            return self._get(section, conv, option, **kwargs)
+        except (NoSectionError, NoOptionError):
+            if fallback is _UNSET:
+                raise
+            return fallback
+
+    # getint, getfloat and getboolean provided directly for backwards compat
+    def getint(self, section, option, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        kwargs.setdefault('fallback', _UNSET)
+        return self._get_conv(section, option, int, **kwargs)
+
+    def getfloat(self, section, option, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        kwargs.setdefault('fallback', _UNSET)
+        return self._get_conv(section, option, float, **kwargs)
+
+    def getboolean(self, section, option, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        kwargs.setdefault('fallback', _UNSET)
+        return self._get_conv(section, option, self._convert_to_boolean, **kwargs)
+
+    def items(self, section=_UNSET, raw=False, vars=None):
+        """Return a list of (name, value) tuples for each option in a section.
+
+        All % interpolations are expanded in the return values, based on the
+        defaults passed into the constructor, unless the optional argument
+        `raw' is true.  Additional substitutions may be provided using the
+        `vars' argument, which must be a dictionary whose contents overrides
+        any pre-existing defaults.
+
+        The section DEFAULT is special.
+        """
+        if section is _UNSET:
+            return super(RawConfigParser, self).items()
+        d = self._defaults.copy()
+        try:
+            d.update(self._sections[section])
+        except KeyError:
+            if section != self.default_section:
+                raise NoSectionError(section)
+        orig_keys = list(d.keys())
+        # Update with the entry specific variables
+        if vars:
+            for key, value in vars.items():
+                d[self.optionxform(key)] = value
+
+        def value_getter_interp(option):
+            return self._interpolation.before_get(self, section, option, d[option], d)
+
+        def value_getter_raw(option):
+            return d[option]
+
+        value_getter = value_getter_raw if raw else value_getter_interp
+
+        return [(option, value_getter(option)) for option in orig_keys]
+
+    def popitem(self):
+        """Remove a section from the parser and return it as
+        a (section_name, section_proxy) tuple. If no section is present, raise
+        KeyError.
+
+        The section DEFAULT is never returned because it cannot be removed.
+        """
+        for key in self.sections():
+            value = self[key]
+            del self[key]
+            return key, value
+        raise KeyError
+
+    def optionxform(self, optionstr):
+        return optionstr.lower()
+
+    def has_option(self, section, option):
+        """Check for the existence of a given option in a given section.
+        If the specified `section' is None or an empty string, DEFAULT is
+        assumed. If the specified `section' does not exist, returns False."""
+        if not section or section == self.default_section:
+            option = self.optionxform(option)
+            return option in self._defaults
+        elif section not in self._sections:
+            return False
+        else:
+            option = self.optionxform(option)
+            return option in self._sections[section] or option in self._defaults
+
+    def set(self, section, option, value=None):
+        """Set an option."""
+        if value:
+            value = self._interpolation.before_set(self, section, option, value)
+        if not section or section == self.default_section:
+            sectdict = self._defaults
+        else:
+            try:
+                sectdict = self._sections[section]
+            except KeyError:
+                raise NoSectionError(section) from None
+        sectdict[self.optionxform(option)] = value
+
+    def write(self, fp, space_around_delimiters=True):
+        """Write an .ini-format representation of the configuration state.
+
+        If `space_around_delimiters' is True (the default), delimiters
+        between keys and values are surrounded by spaces.
+        """
+        if space_around_delimiters:
+            d = " {0} ".format(self._delimiters[0])
+        else:
+            d = self._delimiters[0]
+        if self._defaults:
+            self._write_section(fp, self.default_section, self._defaults.items(), d)
+        for section in self._sections:
+            self._write_section(fp, section, self._sections[section].items(), d)
+
+    def _write_section(self, fp, section_name, section_items, delimiter):
+        """Write a single section to the specified `fp'."""
+        fp.write("[{0}]\n".format(section_name))
+        for key, value in section_items:
+            value = self._interpolation.before_write(self, section_name, key, value)
+            if value is not None or not self._allow_no_value:
+                value = delimiter + str(value).replace('\n', '\n\t')
+            else:
+                value = ""
+            fp.write("{0}{1}\n".format(key, value))
+        fp.write("\n")
+
+    def remove_option(self, section, option):
+        """Remove an option."""
+        if not section or section == self.default_section:
+            sectdict = self._defaults
+        else:
+            try:
+                sectdict = self._sections[section]
+            except KeyError:
+                raise NoSectionError(section) from None
+        option = self.optionxform(option)
+        existed = option in sectdict
+        if existed:
+            del sectdict[option]
+        return existed
+
+    def remove_section(self, section):
+        """Remove a file section."""
+        existed = section in self._sections
+        if existed:
+            del self._sections[section]
+            del self._proxies[section]
+        return existed
+
+    def __getitem__(self, key):
+        if key != self.default_section and not self.has_section(key):
+            raise KeyError(key)
+        return self._proxies[key]
+
+    def __setitem__(self, key, value):
+        # To conform with the mapping protocol, overwrites existing values in
+        # the section.
+        if key in self and self[key] is value:
+            return
+        # XXX this is not atomic if read_dict fails at any point. Then again,
+        # no update method in configparser is atomic in this implementation.
+        if key == self.default_section:
+            self._defaults.clear()
+        elif key in self._sections:
+            self._sections[key].clear()
+        self.read_dict({key: value})
+
+    def __delitem__(self, key):
+        if key == self.default_section:
+            raise ValueError("Cannot remove the default section.")
+        if not self.has_section(key):
+            raise KeyError(key)
+        self.remove_section(key)
+
+    def __contains__(self, key):
+        return key == self.default_section or self.has_section(key)
+
+    def __len__(self):
+        return len(self._sections) + 1  # the default section
+
+    def __iter__(self):
+        # XXX does it break when underlying container state changed?
+        return itertools.chain((self.default_section,), self._sections.keys())
+
+    def _read(self, fp, fpname):  # noqa: C901
+        """Parse a sectioned configuration file.
+
+        Each section in a configuration file contains a header, indicated by
+        a name in square brackets (`[]'), plus key/value options, indicated by
+        `name' and `value' delimited with a specific substring (`=' or `:' by
+        default).
+
+        Values can span multiple lines, as long as they are indented deeper
+        than the first line of the value. Depending on the parser's mode, blank
+        lines may be treated as parts of multiline values or ignored.
+
+        Configuration files may include comments, prefixed by specific
+        characters (`#' and `;' by default). Comments may appear on their own
+        in an otherwise empty line or may be entered in lines holding values or
+        section names.
+        """
+        elements_added = set()
+        cursect = None  # None, or a dictionary
+        sectname = None
+        optname = None
+        lineno = 0
+        indent_level = 0
+        e = None  # None, or an exception
+        for lineno, line in enumerate(fp, start=1):
+            comment_start = sys.maxsize
+            # strip inline comments
+            inline_prefixes = dict((p, -1) for p in self._inline_comment_prefixes)
+            while comment_start == sys.maxsize and inline_prefixes:
+                next_prefixes = {}
+                for prefix, index in inline_prefixes.items():
+                    index = line.find(prefix, index + 1)
+                    if index == -1:
+                        continue
+                    next_prefixes[prefix] = index
+                    if index == 0 or (index > 0 and line[index - 1].isspace()):
+                        comment_start = min(comment_start, index)
+                inline_prefixes = next_prefixes
+            # strip full line comments
+            for prefix in self._comment_prefixes:
+                if line.strip().startswith(prefix):
+                    comment_start = 0
+                    break
+            if comment_start == sys.maxsize:
+                comment_start = None
+            value = line[:comment_start].strip()
+            if not value:
+                if self._empty_lines_in_values:
+                    # add empty line to the value, but only if there was no
+                    # comment on the line
+                    if (
+                        comment_start is None
+                        and cursect is not None
+                        and optname
+                        and cursect[optname] is not None
+                    ):
+                        cursect[optname].append('')  # newlines added at join
+                else:
+                    # empty line marks end of value
+                    indent_level = sys.maxsize
+                continue
+            # continuation line?
+            first_nonspace = self.NONSPACECRE.search(line)
+            cur_indent_level = first_nonspace.start() if first_nonspace else 0
+            if cursect is not None and optname and cur_indent_level > indent_level:
+                cursect[optname].append(value)
+            # a section header or option header?
+            else:
+                indent_level = cur_indent_level
+                # is it a section header?
+                mo = self.SECTCRE.match(value)
+                if mo:
+                    sectname = mo.group('header')
+                    if sectname in self._sections:
+                        if self._strict and sectname in elements_added:
+                            raise DuplicateSectionError(sectname, fpname, lineno)
+                        cursect = self._sections[sectname]
+                        elements_added.add(sectname)
+                    elif sectname == self.default_section:
+                        cursect = self._defaults
+                    else:
+                        cursect = self._dict()
+                        self._sections[sectname] = cursect
+                        self._proxies[sectname] = SectionProxy(self, sectname)
+                        elements_added.add(sectname)
+                    # So sections can't start with a continuation line
+                    optname = None
+                # no section header in the file?
+                elif cursect is None:
+                    raise MissingSectionHeaderError(fpname, lineno, line)
+                # an option line?
+                else:
+                    mo = self._optcre.match(value)
+                    if mo:
+                        optname, vi, optval = mo.group('option', 'vi', 'value')
+                        if not optname:
+                            e = self._handle_error(e, fpname, lineno, line)
+                        optname = self.optionxform(optname.rstrip())
+                        if self._strict and (sectname, optname) in elements_added:
+                            raise DuplicateOptionError(
+                                sectname, optname, fpname, lineno
+                            )
+                        elements_added.add((sectname, optname))
+                        # This check is fine because the OPTCRE cannot
+                        # match if it would set optval to None
+                        if optval is not None:
+                            optval = optval.strip()
+                            cursect[optname] = [optval]
+                        else:
+                            # valueless option handling
+                            cursect[optname] = None
+                    else:
+                        # a non-fatal parsing error occurred. set up the
+                        # exception but keep going. the exception will be
+                        # raised at the end of the file and will contain a
+                        # list of all bogus lines
+                        e = self._handle_error(e, fpname, lineno, line)
+        self._join_multiline_values()
+        # if any parsing errors occurred, raise an exception
+        if e:
+            raise e
+
+    def _join_multiline_values(self):
+        defaults = self.default_section, self._defaults
+        all_sections = itertools.chain((defaults,), self._sections.items())
+        for section, options in all_sections:
+            for name, val in options.items():
+                if isinstance(val, list):
+                    val = '\n'.join(val).rstrip()
+                options[name] = self._interpolation.before_read(
+                    self, section, name, val
+                )
+
+    def _read_defaults(self, defaults):
+        """Read the defaults passed in the initializer.
+        Note: values can be non-string."""
+        for key, value in defaults.items():
+            self._defaults[self.optionxform(key)] = value
+
+    def _handle_error(self, exc, fpname, lineno, line):
+        if not exc:
+            exc = ParsingError(fpname)
+        exc.append(lineno, repr(line))
+        return exc
+
+    def _unify_values(self, section, vars):
+        """Create a sequence of lookups with 'vars' taking priority over
+        the 'section' which takes priority over the DEFAULTSECT.
+
+        """
+        sectiondict = {}
+        try:
+            sectiondict = self._sections[section]
+        except KeyError:
+            if section != self.default_section:
+                raise NoSectionError(section)
+        # Update with the entry specific variables
+        vardict = {}
+        if vars:
+            for key, value in vars.items():
+                if value is not None:
+                    value = str(value)
+                vardict[self.optionxform(key)] = value
+        return _ChainMap(vardict, sectiondict, self._defaults)
+
+    def _convert_to_boolean(self, value):
+        """Return a boolean value translating from other types if necessary."""
+        if value.lower() not in self.BOOLEAN_STATES:
+            raise ValueError('Not a boolean: %s' % value)
+        return self.BOOLEAN_STATES[value.lower()]
+
+    def _validate_value_types(self, **kwargs):
+        """Raises a TypeError for non-string values.
+
+        The only legal non-string value if we allow valueless
+        options is None, so we need to check if the value is a
+        string if:
+        - we do not allow valueless options, or
+        - we allow valueless options but the value is not None
+
+        For compatibility reasons this method is not used in classic set()
+        for RawConfigParsers. It is invoked in every case for mapping protocol
+        access and in ConfigParser.set().
+        """
+        # keyword-only arguments
+        section = kwargs.get('section', "")
+        option = kwargs.get('option', "")
+        value = kwargs.get('value', "")
+
+        if not isinstance(section, str):
+            raise TypeError("section names must be strings")
+        if not isinstance(option, str):
+            raise TypeError("option keys must be strings")
+        if not self._allow_no_value or value:
+            if not isinstance(value, str):
+                raise TypeError("option values must be strings")
+
+        return section, option, value
+
+    @property
+    def converters(self):
+        return self._converters
+
+
+class ConfigParser(RawConfigParser):
+    """ConfigParser implementing interpolation."""
+
+    _DEFAULT_INTERPOLATION = BasicInterpolation()
+
+    def set(self, section, option, value=None):
+        """Set an option.  Extends RawConfigParser.set by validating type and
+        interpolation syntax on the value."""
+        _, option, value = self._validate_value_types(option=option, value=value)
+        super(ConfigParser, self).set(section, option, value)
+
+    def add_section(self, section):
+        """Create a new section in the configuration.  Extends
+        RawConfigParser.add_section by validating if the section name is
+        a string."""
+        section, _, _ = self._validate_value_types(section=section)
+        super(ConfigParser, self).add_section(section)
+
+    def _read_defaults(self, defaults):
+        """Reads the defaults passed in the initializer, implicitly converting
+        values to strings like the rest of the API.
+
+        Does not perform interpolation for backwards compatibility.
+        """
+        try:
+            hold_interpolation = self._interpolation
+            self._interpolation = Interpolation()
+            self.read_dict({self.default_section: defaults})
+        finally:
+            self._interpolation = hold_interpolation
+
+
+class SafeConfigParser(ConfigParser):
+    """ConfigParser alias for backwards compatibility purposes."""
+
+    def __init__(self, *args, **kwargs):
+        super(SafeConfigParser, self).__init__(*args, **kwargs)
+        warnings.warn(
+            "The SafeConfigParser class has been renamed to ConfigParser "
+            "in Python 3.2. This alias will be removed in future versions."
+            " Use ConfigParser directly instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+
+class SectionProxy(MutableMapping):
+    """A proxy for a single section from a parser."""
+
+    def __init__(self, parser, name):
+        """Creates a view on a section of the specified `name` in `parser`."""
+        self._parser = parser
+        self._name = name
+        for conv in parser.converters:
+            key = 'get' + conv
+            getter = functools.partial(self.get, _impl=getattr(parser, key))
+            setattr(self, key, getter)
+
+    def __repr__(self):
+        return '<Section: {0}>'.format(self._name)
+
+    def __getitem__(self, key):
+        if not self._parser.has_option(self._name, key):
+            raise KeyError(key)
+        return self._parser.get(self._name, key)
+
+    def __setitem__(self, key, value):
+        _, key, value = self._parser._validate_value_types(option=key, value=value)
+        return self._parser.set(self._name, key, value)
+
+    def __delitem__(self, key):
+        if not (
+            self._parser.has_option(self._name, key)
+            and self._parser.remove_option(self._name, key)
+        ):
+            raise KeyError(key)
+
+    def __contains__(self, key):
+        return self._parser.has_option(self._name, key)
+
+    def __len__(self):
+        return len(self._options())
+
+    def __iter__(self):
+        return self._options().__iter__()
+
+    def _options(self):
+        if self._name != self._parser.default_section:
+            return self._parser.options(self._name)
+        else:
+            return self._parser.defaults()
+
+    @property
+    def parser(self):
+        # The parser object of the proxy is read-only.
+        return self._parser
+
+    @property
+    def name(self):
+        # The name of the section on a proxy is read-only.
+        return self._name
+
+    def get(self, option, fallback=None, **kwargs):
+        """Get an option value.
+
+        Unless `fallback` is provided, `None` will be returned if the option
+        is not found.
+
+        """
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        _impl = kwargs.pop('_impl', None)
+        # If `_impl` is provided, it should be a getter method on the parser
+        # object that provides the desired type conversion.
+        if not _impl:
+            _impl = self._parser.get
+        return _impl(self._name, option, fallback=fallback, **kwargs)
+
+
+class ConverterMapping(MutableMapping):
+    """Enables reuse of get*() methods between the parser and section proxies.
+
+    If a parser class implements a getter directly, the value for the given
+    key will be ``None``. The presence of the converter name here enables
+    section proxies to find and use the implementation on the parser class.
+    """
+
+    GETTERCRE = re.compile(r"^get(?P<name>.+)$")
+
+    def __init__(self, parser):
+        self._parser = parser
+        self._data = {}
+        for getter in dir(self._parser):
+            m = self.GETTERCRE.match(getter)
+            if not m or not callable(getattr(self._parser, getter)):
+                continue
+            self._data[m.group('name')] = None  # See class docstring.
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __setitem__(self, key, value):
+        try:
+            k = 'get' + key
+        except TypeError:
+            raise ValueError(
+                'Incompatible key: {} (type: {})' ''.format(key, type(key))
+            )
+        if k == 'get':
+            raise ValueError('Incompatible key: cannot use "" as a name')
+        self._data[key] = value
+        func = functools.partial(self._parser._get_conv, conv=value)
+        func.converter = value
+        setattr(self._parser, k, func)
+        for proxy in self._parser.values():
+            getter = functools.partial(proxy.get, _impl=func)
+            setattr(proxy, k, getter)
+
+    def __delitem__(self, key):
+        try:
+            k = 'get' + (key or None)
+        except TypeError:
+            raise KeyError(key)
+        del self._data[key]
+        for inst in itertools.chain((self._parser,), self._parser.values()):
+            try:
+                delattr(inst, k)
+            except AttributeError:
+                # don't raise since the entry was present in _data, silently
+                # clean up
+                continue
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __len__(self):
+        return len(self._data)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/backports/configparser/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/backports/configparser/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,303 @@
+Metadata-Version: 2.1
+Name: bagit
+Version: 1.8.1
+Summary: Create and validate BagIt packages
+Home-page: https://libraryofcongress.github.io/bagit-python/
+Author: Ed Summers
+Author-email: ehs@pobox.com
+License: UNKNOWN
+Platform: POSIX
+Classifier: License :: Public Domain
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Communications :: File Sharing
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Filesystems
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+
+bagit-python
+============
+
+|Build Status| |Coverage Status|
+
+bagit is a Python library and command line utility for working with
+`BagIt <http://purl.org/net/bagit>`__ style packages.
+
+Installation
+------------
+
+bagit.py is a single-file python module that you can drop into your
+project as needed or you can install globally with:
+
+::
+
+    pip install bagit
+
+Python v2.7+ is required.
+
+Command Line Usage
+------------------
+
+When you install bagit you should get a command-line program called
+bagit.py which you can use to turn an existing directory into a bag:
+
+::
+
+    bagit.py --contact-name 'John Kunze' /directory/to/bag
+
+Finding Bagit on your system
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``bagit.py`` program should be available in your normal command-line
+window (Terminal on OS X, Command Prompt or Powershell on Windows,
+etc.). If you are unsure where it was installed you can also request
+that Python search for ``bagit`` as a Python module: simply replace
+``bagit.py`` with ``python -m bagit``:
+
+::
+
+    python -m bagit --help
+
+On some systems Python may have been installed as ``python3``, ``py``,
+etc. – simply use the same name you use to start an interactive Python
+shell:
+
+::
+
+    py -m bagit --help
+    python3 -m bagit --help
+
+Configuring BagIt
+~~~~~~~~~~~~~~~~~
+
+You can pass in key/value metadata for the bag using options like
+``--contact-name`` above, which get persisted to the bag-info.txt. For a
+complete list of bag-info.txt properties you can use as commmand line
+arguments see ``--help``.
+
+Since calculating checksums can take a while when creating a bag, you
+may want to calculate them in parallel if you are on a multicore
+machine. You can do that with the ``--processes`` option:
+
+::
+
+    bagit.py --processes 4 /directory/to/bag
+
+To specify which checksum algorithm(s) to use when generating the
+manifest, use the --md5, --sha1, --sha256 and/or --sha512 flags (MD5 is
+generated by default).
+
+::
+
+    bagit.py --sha1 /path/to/bag
+    bagit.py --sha256 /path/to/bag
+    bagit.py --sha512 /path/to/bag
+
+If you would like to validate a bag you can use the --validate flag.
+
+::
+
+    bagit.py --validate /path/to/bag
+
+If you would like to take a quick look at the bag to see if it seems
+valid by just examining the structure of the bag, and comparing its
+payload-oxum (byte count and number of files) then use the ``--fast``
+flag.
+
+::
+
+    bagit.py --validate --fast /path/to/bag
+
+And finally, if you'd like to parallelize validation to take advantage
+of multiple CPUs you can:
+
+::
+
+    bagit.py --validate --processes 4 /path/to/bag
+
+Using BagIt in your programs
+----------------------------
+
+You can also use BagIt programatically in your own Python programs by
+importing the ``bagit`` module.
+
+Create
+~~~~~~
+
+To create a bag you would do this:
+
+.. code:: python
+
+    bag = bagit.make_bag('mydir', {'Contact-Name': 'John Kunze'})
+
+``make_bag`` returns a Bag instance. If you have a bag already on disk
+and would like to create a Bag instance for it, simply call the
+constructor directly:
+
+.. code:: python
+
+    bag = bagit.Bag('/path/to/bag')
+
+Update Bag Metadata
+~~~~~~~~~~~~~~~~~~~
+
+You can change the metadata persisted to the bag-info.txt by using the
+``info`` property on a ``Bag``.
+
+.. code:: python
+
+    # load the bag
+    bag = bagit.Bag('/path/to/bag')
+
+    # update bag info metadata
+    bag.info['Internal-Sender-Description'] = 'Updated on 2014-06-28.'
+    bag.info['Authors'] = ['John Kunze', 'Andy Boyko']
+    bag.save()
+
+Update Bag Manifests
+~~~~~~~~~~~~~~~~~~~~
+
+By default ``save`` will not update manifests. This guards against a
+situation where a call to ``save`` to persist bag metadata accidentally
+regenerates manifests for an invalid bag. If you have modified the
+payload of a bag by adding, modifying or deleting files in the data
+directory, and wish to regenerate the manifests set the ``manifests``
+parameter to True when calling ``save``.
+
+.. code:: python
+
+
+    import shutil, os
+
+    # add a file
+    shutil.copyfile('newfile', '/path/to/bag/data/newfile')
+
+    # remove a file
+    os.remove('/path/to/bag/data/file')
+
+    # persist changes
+    bag.save(manifests=True)
+
+The save method takes an optional processes parameter which will
+determine how many processes are used to regenerate the checksums. This
+can be handy on multicore machines.
+
+Validation
+~~~~~~~~~~
+
+If you would like to see if a bag is valid, use its ``is_valid`` method:
+
+.. code:: python
+
+    bag = bagit.Bag('/path/to/bag')
+    if bag.is_valid():
+        print("yay :)")
+    else:
+        print("boo :(")
+
+If you'd like to get a detailed list of validation errors, execute the
+``validate`` method and catch the ``BagValidationError`` exception. If
+the bag's manifest was invalid (and it wasn't caught by the payload
+oxum) the exception's ``details`` property will contain a list of
+``ManifestError``\ s that you can introspect on. Each ManifestError,
+will be of type ``ChecksumMismatch``, ``FileMissing``,
+``UnexpectedFile``.
+
+So for example if you want to print out checksums that failed to
+validate you can do this:
+
+.. code:: python
+
+
+    bag = bagit.Bag("/path/to/bag")
+
+    try:
+      bag.validate()
+
+    except bagit.BagValidationError as e:
+        for d in e.details:
+            if isinstance(d, bagit.ChecksumMismatch):
+                print("expected %s to have %s checksum of %s but found %s" %
+                      (d.path, d.algorithm, d.expected, d.found))
+
+To iterate through a bag's manifest and retrieve checksums for the
+payload files use the bag's entries dictionary:
+
+.. code:: python
+
+    bag = bagit.Bag("/path/to/bag")
+
+    for path, fixity in bag.entries.items():
+      print("path:%s md5:%s" % (path, fixity["md5"]))
+
+Contributing to bagit-python development
+----------------------------------------
+
+::
+
+    % git clone git://github.com/LibraryOfCongress/bagit-python.git
+    % cd bagit-python
+    # MAKE CHANGES
+    % python test.py
+
+Running the tests
+~~~~~~~~~~~~~~~~~
+
+You can quickly run the tests by having setuptools install dependencies:
+
+::
+
+    python setup.py test
+
+Once your code is working, you can use
+`Tox <https://tox.readthedocs.io/>`__ to run the tests with every
+supported version of Python which you have installed on the local
+system:
+
+::
+
+    tox
+
+If you have Docker installed, you can run the tests under Linux inside a
+container:
+
+::
+
+    % docker build -t bagit:latest . && docker run -it bagit:latest
+
+Benchmarks
+----------
+
+If you'd like to see how increasing parallelization of bag creation on
+your system effects the time to create a bag try using the included
+bench utility:
+
+::
+
+    % ./bench.py
+
+License
+-------
+
+|cc0|
+
+Note: By contributing to this project, you agree to license your work
+under the same terms as those that govern this project's distribution.
+
+.. |Build Status| image:: https://travis-ci.org/LibraryOfCongress/bagit-python.svg?branch=master
+   :target: http://travis-ci.org/LibraryOfCongress/bagit-python
+.. |Coverage Status| image:: https://coveralls.io/repos/github/LibraryOfCongress/bagit-python/badge.svg?branch=master
+   :target: https://coveralls.io/github/LibraryOfCongress/bagit-python?branch=master
+.. |cc0| image:: http://i.creativecommons.org/p/zero/1.0/88x31.png
+   :target: http://creativecommons.org/publicdomain/zero/1.0/
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,10 @@
+../../../bin/__pycache__/bagit.cpython-39.pyc,,
+../../../bin/bagit.py,sha256=NRPYYbJbVHKnCQyF_DwMeaFuvrpxGx6uRvKEpiyFPF8,55000
+../../../locale/en/LC_MESSAGES/bagit-python.mo,sha256=onTi-42QABidt47Lx6KeFzbP-lQ0HU1X9fW2j1M8UK0,2808
+__pycache__/bagit.cpython-39.pyc,,
+bagit-1.8.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+bagit-1.8.1.dist-info/METADATA,sha256=Ld9gFzRKg8ZeXJYHvkrqzGLGccb8RfXnjOZi8C_sWO4,8273
+bagit-1.8.1.dist-info/RECORD,,
+bagit-1.8.1.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+bagit-1.8.1.dist-info/top_level.txt,sha256=f288ippe7ERSzETsEftza1dXq61Z4zFSXDgaTF6djpE,6
+bagit.py,sha256=DmDhuSx6n61PRY52aPQaZvnxdBYv7SO9XB4K4tq_Xlc,55013
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bagit-1.8.1.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+bagit
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bagit.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bagit.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1617 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import argparse
+import codecs
+import gettext
+import hashlib
+import logging
+import multiprocessing
+import os
+import re
+import signal
+import sys
+import tempfile
+import unicodedata
+import warnings
+from collections import defaultdict
+from datetime import date
+from functools import partial
+from os.path import abspath, isdir, isfile, join
+
+from pkg_resources import DistributionNotFound, get_distribution
+
+try:
+    from urllib.parse import urlparse
+except ImportError:
+    from urlparse import urlparse
+
+
+def find_locale_dir():
+    for prefix in (os.path.dirname(__file__), sys.prefix):
+        locale_dir = os.path.join(prefix, "locale")
+        if os.path.isdir(locale_dir):
+            return locale_dir
+
+
+TRANSLATION_CATALOG = gettext.translation(
+    "bagit-python", localedir=find_locale_dir(), fallback=True
+)
+if sys.version_info < (3,):
+    _ = TRANSLATION_CATALOG.ugettext
+else:
+    _ = TRANSLATION_CATALOG.gettext
+
+MODULE_NAME = "bagit" if __name__ == "__main__" else __name__
+
+LOGGER = logging.getLogger(MODULE_NAME)
+
+try:
+    VERSION = get_distribution(MODULE_NAME).version
+except DistributionNotFound:
+    VERSION = "0.0.dev0"
+
+PROJECT_URL = "https://github.com/LibraryOfCongress/bagit-python"
+
+__doc__ = (
+    _(
+        """
+BagIt is a directory, filename convention for bundling an arbitrary set of
+files with a manifest, checksums, and additional metadata. More about BagIt
+can be found at:
+
+    http://purl.org/net/bagit
+
+bagit.py is a pure python drop in library and command line tool for creating,
+and working with BagIt directories.
+
+
+Command-Line Usage:
+
+Basic usage is to give bagit.py a directory to bag up:
+
+    $ bagit.py my_directory
+
+This does a bag-in-place operation where the current contents will be moved
+into the appropriate BagIt structure and the metadata files will be created.
+
+You can bag multiple directories if you wish:
+
+    $ bagit.py directory1 directory2
+
+Optionally you can provide metadata which will be stored in bag-info.txt:
+
+    $ bagit.py --source-organization "Library of Congress" directory
+
+You can also select which manifest algorithms will be used:
+
+    $ bagit.py --sha1 --md5 --sha256 --sha512 directory
+
+
+Using BagIt from your Python code:
+
+    import bagit
+    bag = bagit.make_bag('example-directory', {'Contact-Name': 'Ed Summers'})
+    print(bag.entries)
+
+For more information or to contribute to bagit-python's development, please
+visit %(PROJECT_URL)s
+"""
+    )
+    % globals()
+)
+
+# standard bag-info.txt metadata
+STANDARD_BAG_INFO_HEADERS = [
+    "Source-Organization",
+    "Organization-Address",
+    "Contact-Name",
+    "Contact-Phone",
+    "Contact-Email",
+    "External-Description",
+    "External-Identifier",
+    "Bag-Size",
+    "Bag-Group-Identifier",
+    "Bag-Count",
+    "Internal-Sender-Identifier",
+    "Internal-Sender-Description",
+    "BagIt-Profile-Identifier",
+    # Bagging-Date is autogenerated
+    # Payload-Oxum is autogenerated
+]
+
+try:
+    CHECKSUM_ALGOS = hashlib.algorithms_guaranteed
+except AttributeError:
+    # FIXME: remove when we drop Python 2 (https://github.com/LibraryOfCongress/bagit-python/issues/102)
+    # Python 2.7.0-2.7.8
+    CHECKSUM_ALGOS = set(hashlib.algorithms)
+DEFAULT_CHECKSUMS = ["sha256", "sha512"]
+
+#: Block size used when reading files for hashing:
+HASH_BLOCK_SIZE = 512 * 1024
+
+#: Convenience function used everywhere we want to open a file to read text
+#: rather than undecoded bytes:
+open_text_file = partial(codecs.open, encoding="utf-8", errors="strict")
+
+# This is the same as decoding the byte values in codecs.BOM:
+UNICODE_BYTE_ORDER_MARK = "\uFEFF"
+
+
+def make_bag(
+    bag_dir, bag_info=None, processes=1, checksums=None, checksum=None, encoding="utf-8"
+):
+    """
+    Convert a given directory into a bag. You can pass in arbitrary
+    key/value pairs to put into the bag-info.txt metadata file as
+    the bag_info dictionary.
+    """
+
+    if checksum is not None:
+        warnings.warn(
+            _(
+                "The `checksum` argument for `make_bag` should be replaced with `checksums`"
+            ),
+            DeprecationWarning,
+        )
+        checksums = checksum
+
+    if checksums is None:
+        checksums = DEFAULT_CHECKSUMS
+
+    bag_dir = os.path.abspath(bag_dir)
+    cwd = os.path.abspath(os.path.curdir)
+
+    if cwd.startswith(bag_dir) and cwd != bag_dir:
+        raise RuntimeError(
+            _("Bagging a parent of the current directory is not supported")
+        )
+
+    LOGGER.info(_("Creating bag for directory %s"), bag_dir)
+
+    if not os.path.isdir(bag_dir):
+        LOGGER.error(_("Bag directory %s does not exist"), bag_dir)
+        raise RuntimeError(_("Bag directory %s does not exist") % bag_dir)
+
+    # FIXME: we should do the permissions checks before changing directories
+    old_dir = os.path.abspath(os.path.curdir)
+
+    try:
+        # TODO: These two checks are currently redundant since an unreadable directory will also
+        #       often be unwritable, and this code will require review when we add the option to
+        #       bag to a destination other than the source. It would be nice if we could avoid
+        #       walking the directory tree more than once even if most filesystems will cache it
+
+        unbaggable = _can_bag(bag_dir)
+
+        if unbaggable:
+            LOGGER.error(
+                _("Unable to write to the following directories and files:\n%s"),
+                unbaggable,
+            )
+            raise BagError(_("Missing permissions to move all files and directories"))
+
+        unreadable_dirs, unreadable_files = _can_read(bag_dir)
+
+        if unreadable_dirs or unreadable_files:
+            if unreadable_dirs:
+                LOGGER.error(
+                    _("The following directories do not have read permissions:\n%s"),
+                    unreadable_dirs,
+                )
+            if unreadable_files:
+                LOGGER.error(
+                    _("The following files do not have read permissions:\n%s"),
+                    unreadable_files,
+                )
+            raise BagError(
+                _("Read permissions are required to calculate file fixities")
+            )
+        else:
+            LOGGER.info(_("Creating data directory"))
+
+            # FIXME: if we calculate full paths we won't need to deal with changing directories
+            os.chdir(bag_dir)
+            cwd = os.getcwd()
+            temp_data = tempfile.mkdtemp(dir=cwd)
+
+            for f in os.listdir("."):
+                if os.path.abspath(f) == temp_data:
+                    continue
+                new_f = os.path.join(temp_data, f)
+                LOGGER.info(
+                    _("Moving %(source)s to %(destination)s"),
+                    {"source": f, "destination": new_f},
+                )
+                os.rename(f, new_f)
+
+            LOGGER.info(
+                _("Moving %(source)s to %(destination)s"),
+                {"source": temp_data, "destination": "data"},
+            )
+            os.rename(temp_data, "data")
+
+            # permissions for the payload directory should match those of the
+            # original directory
+            os.chmod("data", os.stat(cwd).st_mode)
+
+            total_bytes, total_files = make_manifests(
+                "data", processes, algorithms=checksums, encoding=encoding
+            )
+
+            LOGGER.info(_("Creating bagit.txt"))
+            txt = """BagIt-Version: 0.97\nTag-File-Character-Encoding: UTF-8\n"""
+            with open_text_file("bagit.txt", "w") as bagit_file:
+                bagit_file.write(txt)
+
+            LOGGER.info(_("Creating bag-info.txt"))
+            if bag_info is None:
+                bag_info = {}
+
+            # allow 'Bagging-Date' and 'Bag-Software-Agent' to be overidden
+            if "Bagging-Date" not in bag_info:
+                bag_info["Bagging-Date"] = date.strftime(date.today(), "%Y-%m-%d")
+            if "Bag-Software-Agent" not in bag_info:
+                bag_info["Bag-Software-Agent"] = "bagit.py v%s <%s>" % (
+                    VERSION,
+                    PROJECT_URL,
+                )
+
+            bag_info["Payload-Oxum"] = "%s.%s" % (total_bytes, total_files)
+            _make_tag_file("bag-info.txt", bag_info)
+
+            for c in checksums:
+                _make_tagmanifest_file(c, bag_dir, encoding="utf-8")
+    except Exception:
+        LOGGER.exception(_("An error occurred creating a bag in %s"), bag_dir)
+        raise
+    finally:
+        os.chdir(old_dir)
+
+    return Bag(bag_dir)
+
+
+class Bag(object):
+    """A representation of a bag."""
+
+    valid_files = ["bagit.txt", "fetch.txt"]
+    valid_directories = ["data"]
+
+    def __init__(self, path=None):
+        super(Bag, self).__init__()
+        self.tags = {}
+        self.info = {}
+        #: Dictionary of manifest entries and the checksum values for each
+        #: algorithm:
+        self.entries = {}
+
+        # To reliably handle Unicode normalization differences, we maintain
+        # lookup dictionaries in both directions for the filenames read from
+        # the filesystem and the manifests so we can handle cases where the
+        # normalization form changed between the bag being created and read.
+        # See https://github.com/LibraryOfCongress/bagit-python/issues/51.
+
+        #: maps Unicode-normalized values to the raw value from the filesystem
+        self.normalized_filesystem_names = {}
+
+        #: maps Unicode-normalized values to the raw value in the manifest
+        self.normalized_manifest_names = {}
+
+        self.algorithms = []
+        self.tag_file_name = None
+        self.path = abspath(path)
+        if path:
+            # if path ends in a path separator, strip it off
+            if path[-1] == os.sep:
+                self.path = path[:-1]
+            self._open()
+
+    def __str__(self):
+        # FIXME: develop a more informative string representation for a Bag
+        return self.path
+
+    @property
+    def algs(self):
+        warnings.warn(_("Use Bag.algorithms instead of Bag.algs"), DeprecationWarning)
+        return self.algorithms
+
+    @property
+    def version(self):
+        warnings.warn(
+            _("Use the Bag.version_info tuple instead of Bag.version"),
+            DeprecationWarning,
+        )
+        return self._version
+
+    def _open(self):
+        # Open the bagit.txt file, and load any tags from it, including
+        # the required version and encoding.
+        bagit_file_path = os.path.join(self.path, "bagit.txt")
+
+        if not isfile(bagit_file_path):
+            raise BagError(_("Expected bagit.txt does not exist: %s") % bagit_file_path)
+
+        self.tags = tags = _load_tag_file(bagit_file_path)
+
+        required_tags = ("BagIt-Version", "Tag-File-Character-Encoding")
+        missing_tags = [i for i in required_tags if i not in tags]
+        if missing_tags:
+            raise BagError(
+                _("Missing required tag in bagit.txt: %s") % ", ".join(missing_tags)
+            )
+
+        # To avoid breaking existing code we'll leave self.version as the string
+        # and parse it into a numeric version_info tuple. In version 2.0 we can
+        # break that.
+
+        self._version = tags["BagIt-Version"]
+
+        try:
+            self.version_info = tuple(int(i) for i in self._version.split(".", 1))
+        except ValueError:
+            raise BagError(
+                _("Bag version numbers must be MAJOR.MINOR numbers, not %s")
+                % self._version
+            )
+
+        if (0, 93) <= self.version_info <= (0, 95):
+            self.tag_file_name = "package-info.txt"
+        elif (0, 96) <= self.version_info < (2,):
+            self.tag_file_name = "bag-info.txt"
+        else:
+            raise BagError(_("Unsupported bag version: %s") % self._version)
+
+        self.encoding = tags["Tag-File-Character-Encoding"]
+
+        try:
+            codecs.lookup(self.encoding)
+        except LookupError:
+            raise BagValidationError(_("Unsupported encoding: %s") % self.encoding)
+
+        info_file_path = os.path.join(self.path, self.tag_file_name)
+        if os.path.exists(info_file_path):
+            self.info = _load_tag_file(info_file_path, encoding=self.encoding)
+
+        self._load_manifests()
+
+    def manifest_files(self):
+        for filename in ["manifest-%s.txt" % a for a in CHECKSUM_ALGOS]:
+            f = os.path.join(self.path, filename)
+            if isfile(f):
+                yield f
+
+    def tagmanifest_files(self):
+        for filename in ["tagmanifest-%s.txt" % a for a in CHECKSUM_ALGOS]:
+            f = os.path.join(self.path, filename)
+            if isfile(f):
+                yield f
+
+    def compare_manifests_with_fs(self):
+        """
+        Compare the filenames in the manifests to the filenames present on the
+        local filesystem and returns two lists of the files which are only
+        present in the manifests and the files which are only present on the
+        local filesystem, respectively.
+        """
+
+        # We compare the filenames after Unicode normalization so we can
+        # reliably detect normalization changes after bag creation:
+        files_on_fs = set(normalize_unicode(i) for i in self.payload_files())
+        files_in_manifest = set(
+            normalize_unicode(i) for i in self.payload_entries().keys()
+        )
+
+        if self.version_info >= (0, 97):
+            files_in_manifest.update(self.missing_optional_tagfiles())
+
+        only_on_fs = list()
+        only_in_manifest = list()
+
+        for i in files_on_fs.difference(files_in_manifest):
+            only_on_fs.append(self.normalized_filesystem_names[i])
+
+        for i in files_in_manifest.difference(files_on_fs):
+            only_in_manifest.append(self.normalized_manifest_names[i])
+
+        return only_in_manifest, only_on_fs
+
+    def compare_fetch_with_fs(self):
+        """Compares the fetch entries with the files actually
+           in the payload, and returns a list of all the files
+           that still need to be fetched.
+        """
+
+        files_on_fs = set(self.payload_files())
+        files_in_fetch = set(self.files_to_be_fetched())
+
+        return list(files_in_fetch - files_on_fs)
+
+    def payload_files(self):
+        """Returns a list of filenames which are present on the local filesystem"""
+        payload_dir = os.path.join(self.path, "data")
+
+        for dirpath, _, filenames in os.walk(payload_dir):
+            for f in filenames:
+                # Jump through some hoops here to make the payload files are
+                # returned with the directory structure relative to the base
+                # directory rather than the
+                normalized_f = os.path.normpath(f)
+                rel_path = os.path.relpath(
+                    os.path.join(dirpath, normalized_f), start=self.path
+                )
+
+                self.normalized_filesystem_names[normalize_unicode(rel_path)] = rel_path
+                yield rel_path
+
+    def payload_entries(self):
+        """Return a dictionary of items """
+        # Don't use dict comprehension (compatibility with Python < 2.7)
+        return dict(
+            (key, value)
+            for (key, value) in self.entries.items()
+            if key.startswith("data" + os.sep)
+        )
+
+    def save(self, processes=1, manifests=False):
+        """
+        save will persist any changes that have been made to the bag
+        metadata (self.info).
+
+        If you have modified the payload of the bag (added, modified,
+        removed files in the data directory) and want to regenerate manifests
+        set the manifests parameter to True. The default is False since you
+        wouldn't want a save to accidentally create a new manifest for
+        a corrupted bag.
+
+        If you want to control the number of processes that are used when
+        recalculating checksums use the processes parameter.
+        """
+        # Error checking
+        if not self.path:
+            raise BagError(_("Bag.save() called before setting the path!"))
+
+        if not os.access(self.path, os.R_OK | os.W_OK | os.X_OK):
+            raise BagError(
+                _("Cannot save bag to non-existent or inaccessible directory %s")
+                % self.path
+            )
+
+        unbaggable = _can_bag(self.path)
+        if unbaggable:
+            LOGGER.error(
+                _(
+                    "Missing write permissions for the following directories and files:\n%s"
+                ),
+                unbaggable,
+            )
+            raise BagError(_("Missing permissions to move all files and directories"))
+
+        unreadable_dirs, unreadable_files = _can_read(self.path)
+        if unreadable_dirs or unreadable_files:
+            if unreadable_dirs:
+                LOGGER.error(
+                    _("The following directories do not have read permissions:\n%s"),
+                    unreadable_dirs,
+                )
+            if unreadable_files:
+                LOGGER.error(
+                    _("The following files do not have read permissions:\n%s"),
+                    unreadable_files,
+                )
+            raise BagError(
+                _("Read permissions are required to calculate file fixities")
+            )
+
+        # Change working directory to bag directory so helper functions work
+        old_dir = os.path.abspath(os.path.curdir)
+        os.chdir(self.path)
+
+        # Generate new manifest files
+        if manifests:
+            total_bytes, total_files = make_manifests(
+                "data", processes, algorithms=self.algorithms, encoding=self.encoding
+            )
+
+            # Update Payload-Oxum
+            LOGGER.info(_("Updating Payload-Oxum in %s"), self.tag_file_name)
+            self.info["Payload-Oxum"] = "%s.%s" % (total_bytes, total_files)
+
+        _make_tag_file(self.tag_file_name, self.info)
+
+        # Update tag-manifest for changes to manifest & bag-info files
+        for alg in self.algorithms:
+            _make_tagmanifest_file(alg, self.path, encoding=self.encoding)
+
+        # Reload the manifests
+        self._load_manifests()
+
+        os.chdir(old_dir)
+
+    def tagfile_entries(self):
+        return dict(
+            (key, value)
+            for (key, value) in self.entries.items()
+            if not key.startswith("data" + os.sep)
+        )
+
+    def missing_optional_tagfiles(self):
+        """
+        From v0.97 we need to validate any tagfiles listed
+        in the optional tagmanifest(s). As there is no mandatory
+        directory structure for additional tagfiles we can
+        only check for entries with missing files (not missing
+        entries for existing files).
+        """
+        for tagfilepath in self.tagfile_entries().keys():
+            if not os.path.isfile(os.path.join(self.path, tagfilepath)):
+                yield tagfilepath
+
+    def fetch_entries(self):
+        """Load fetch.txt if present and iterate over its contents
+
+        yields (url, size, filename) tuples
+
+        raises BagError for errors such as an unsafe filename referencing
+        data outside of the bag directory
+        """
+
+        fetch_file_path = os.path.join(self.path, "fetch.txt")
+
+        if isfile(fetch_file_path):
+            with open_text_file(
+                fetch_file_path, "r", encoding=self.encoding
+            ) as fetch_file:
+                for line in fetch_file:
+                    url, file_size, filename = line.strip().split(None, 2)
+
+                    if self._path_is_dangerous(filename):
+                        raise BagError(
+                            _('Path "%(payload_file)s" in "%(source_file)s" is unsafe')
+                            % {
+                                "payload_file": filename,
+                                "source_file": os.path.join(self.path, "fetch.txt"),
+                            }
+                        )
+
+                    yield url, file_size, filename
+
+    def files_to_be_fetched(self):
+        """
+        Convenience wrapper for fetch_entries which returns only the
+        local filename
+        """
+
+        for url, file_size, filename in self.fetch_entries():
+            yield filename
+
+    def has_oxum(self):
+        return "Payload-Oxum" in self.info
+
+    def validate(self, processes=1, fast=False, completeness_only=False):
+        """Checks the structure and contents are valid.
+
+        If you supply the parameter fast=True the Payload-Oxum (if present) will
+        be used to check that the payload files are present and accounted for,
+        instead of re-calculating fixities and comparing them against the
+        manifest. By default validate() will re-calculate fixities (fast=False).
+        """
+
+        self._validate_structure()
+        self._validate_bagittxt()
+
+        self.validate_fetch()
+
+        self._validate_contents(
+            processes=processes, fast=fast, completeness_only=completeness_only
+        )
+
+        return True
+
+    def is_valid(self, fast=False, completeness_only=False):
+        """Returns validation success or failure as boolean.
+        Optional fast parameter passed directly to validate().
+        """
+
+        try:
+            self.validate(fast=fast, completeness_only=completeness_only)
+        except BagError:
+            return False
+
+        return True
+
+    def _load_manifests(self):
+        self.entries = {}
+        manifests = list(self.manifest_files())
+
+        if self.version_info >= (0, 97):
+            # v0.97+ requires that optional tagfiles are verified.
+            manifests += list(self.tagmanifest_files())
+
+        for manifest_filename in manifests:
+            if manifest_filename.find("tagmanifest-") != -1:
+                search = "tagmanifest-"
+            else:
+                search = "manifest-"
+            alg = (
+                os.path.basename(manifest_filename)
+                .replace(search, "")
+                .replace(".txt", "")
+            )
+            if alg not in self.algorithms:
+                self.algorithms.append(alg)
+
+            with open_text_file(
+                manifest_filename, "r", encoding=self.encoding
+            ) as manifest_file:
+                if manifest_file.encoding.startswith("UTF"):
+                    # We'll check the first character to see if it's a BOM:
+                    if manifest_file.read(1) == UNICODE_BYTE_ORDER_MARK:
+                        # We'll skip it either way by letting line decoding
+                        # happen at the new offset but we will issue a warning
+                        # for UTF-8 since the presence of a BOM  is contrary to
+                        # the BagIt specification:
+                        if manifest_file.encoding == "UTF-8":
+                            LOGGER.warning(
+                                _(
+                                    "%s is encoded using UTF-8 but contains an unnecessary"
+                                    " byte-order mark, which is not in compliance with the"
+                                    " BagIt RFC"
+                                ),
+                                manifest_file.name,
+                            )
+                    else:
+                        manifest_file.seek(0)  # Pretend the first read never happened
+
+                for line in manifest_file:
+                    line = line.strip()
+
+                    # Ignore blank lines and comments.
+                    if line == "" or line.startswith("#"):
+                        continue
+
+                    entry = line.split(None, 1)
+
+                    # Format is FILENAME *CHECKSUM
+                    if len(entry) != 2:
+                        LOGGER.error(
+                            _(
+                                "%(bag)s: Invalid %(algorithm)s manifest entry: %(line)s"
+                            ),
+                            {"bag": self, "algorithm": alg, "line": line},
+                        )
+                        continue
+
+                    entry_hash = entry[0]
+                    entry_path = os.path.normpath(entry[1].lstrip("*"))
+                    entry_path = _decode_filename(entry_path)
+
+                    if self._path_is_dangerous(entry_path):
+                        raise BagError(
+                            _(
+                                'Path "%(payload_file)s" in manifest "%(manifest_file)s" is unsafe'
+                            )
+                            % {
+                                "payload_file": entry_path,
+                                "manifest_file": manifest_file.name,
+                            }
+                        )
+
+                    entry_hashes = self.entries.setdefault(entry_path, {})
+
+                    if alg in entry_hashes:
+                        warning_ctx = {
+                            "bag": self,
+                            "algorithm": alg,
+                            "filename": entry_path,
+                        }
+                        if entry_hashes[alg] == entry_hash:
+                            msg = _(
+                                "%(bag)s: %(algorithm)s manifest lists %(filename)s"
+                                " multiple times with the same value"
+                            )
+                            if self.version_info >= (1,):
+                                raise BagError(msg % warning_ctx)
+                            else:
+                                LOGGER.warning(msg, warning_ctx)
+                        else:
+                            raise BagError(
+                                _(
+                                    "%(bag)s: %(algorithm)s manifest lists %(filename)s"
+                                    " multiple times with conflicting values"
+                                )
+                                % warning_ctx
+                            )
+
+                    entry_hashes[alg] = entry_hash
+
+        self.normalized_manifest_names.update(
+            (normalize_unicode(i), i) for i in self.entries.keys()
+        )
+
+    def _validate_structure(self):
+        """
+        Checks the structure of the bag to determine whether it conforms to the
+        BagIt spec. Returns true on success, otherwise it will raise a
+        BagValidationError exception.
+        """
+
+        self._validate_structure_payload_directory()
+        self._validate_structure_tag_files()
+
+    def _validate_structure_payload_directory(self):
+        data_dir_path = os.path.join(self.path, "data")
+
+        if not isdir(data_dir_path):
+            raise BagValidationError(
+                _("Expected data directory %s does not exist") % data_dir_path
+            )
+
+    def _validate_structure_tag_files(self):
+        # Note: we deviate somewhat from v0.96 of the spec in that it allows
+        # other files and directories to be present in the base directory
+
+        if not list(self.manifest_files()):
+            raise BagValidationError(_("No manifest files found"))
+        if "bagit.txt" not in os.listdir(self.path):
+            raise BagValidationError(
+                _('Expected %s to contain "bagit.txt"') % self.path
+            )
+
+    def validate_fetch(self):
+        """Validate the fetch.txt file
+
+        Raises `BagError` for errors and otherwise returns no value
+        """
+
+        for url, file_size, filename in self.fetch_entries():
+            # fetch_entries will raise a BagError for unsafe filenames
+            # so at this point we will check only that the URL is minimally
+            # well formed:
+            parsed_url = urlparse(url)
+
+            if not all((parsed_url.scheme, parsed_url.netloc)):
+                raise BagError(_("Malformed URL in fetch.txt: %s") % url)
+
+    def _validate_contents(self, processes=1, fast=False, completeness_only=False):
+        if fast and not self.has_oxum():
+            raise BagValidationError(
+                _("Fast validation requires bag-info.txt to include Payload-Oxum")
+            )
+
+        # Perform the fast file count + size check so we can fail early:
+        self._validate_oxum()
+
+        if fast:
+            return
+
+        self._validate_completeness()
+
+        if completeness_only:
+            return
+
+        self._validate_entries(processes)
+
+    def _validate_oxum(self):
+        oxum = self.info.get("Payload-Oxum")
+
+        if oxum is None:
+            return
+
+        # If multiple Payload-Oxum tags (bad idea)
+        # use the first listed in bag-info.txt
+        if isinstance(oxum, list):
+            LOGGER.warning(_("bag-info.txt defines multiple Payload-Oxum values!"))
+            oxum = oxum[0]
+
+        oxum_byte_count, oxum_file_count = oxum.split(".", 1)
+
+        if not oxum_byte_count.isdigit() or not oxum_file_count.isdigit():
+            raise BagError(_("Malformed Payload-Oxum value: %s") % oxum)
+
+        oxum_byte_count = int(oxum_byte_count)
+        oxum_file_count = int(oxum_file_count)
+        total_bytes = 0
+        total_files = 0
+
+        for payload_file in self.payload_files():
+            payload_file = os.path.join(self.path, payload_file)
+            total_bytes += os.stat(payload_file).st_size
+            total_files += 1
+
+        if oxum_file_count != total_files or oxum_byte_count != total_bytes:
+            raise BagValidationError(
+                _(
+                    "Payload-Oxum validation failed."
+                    " Expected %(oxum_file_count)d files and %(oxum_byte_count)d bytes"
+                    " but found %(found_file_count)d files and %(found_byte_count)d bytes"
+                )
+                % {
+                    "found_file_count": total_files,
+                    "found_byte_count": total_bytes,
+                    "oxum_file_count": oxum_file_count,
+                    "oxum_byte_count": oxum_byte_count,
+                }
+            )
+
+    def _validate_completeness(self):
+        """
+        Verify that the actual file manifests match the files in the data directory
+        """
+        errors = list()
+
+        # First we'll make sure there's no mismatch between the filesystem
+        # and the list of files in the manifest(s)
+        only_in_manifests, only_on_fs = self.compare_manifests_with_fs()
+        for path in only_in_manifests:
+            e = FileMissing(path)
+            LOGGER.warning(force_unicode(e))
+            errors.append(e)
+        for path in only_on_fs:
+            e = UnexpectedFile(path)
+            LOGGER.warning(force_unicode(e))
+            errors.append(e)
+
+        if errors:
+            raise BagValidationError(_("Bag validation failed"), errors)
+
+    def _validate_entries(self, processes):
+        """
+        Verify that the actual file contents match the recorded hashes stored in the manifest files
+        """
+        errors = list()
+
+        if os.name == "posix":
+            worker_init = posix_multiprocessing_worker_initializer
+        else:
+            worker_init = None
+
+        args = (
+            (
+                self.path,
+                self.normalized_filesystem_names.get(rel_path, rel_path),
+                hashes,
+                self.algorithms,
+            )
+            for rel_path, hashes in self.entries.items()
+        )
+
+        try:
+            if processes == 1:
+                hash_results = [_calc_hashes(i) for i in args]
+            else:
+                try:
+                    pool = multiprocessing.Pool(
+                        processes if processes else None, initializer=worker_init
+                    )
+                    hash_results = pool.map(_calc_hashes, args)
+                finally:
+                    pool.terminate()
+
+        # Any unhandled exceptions are probably fatal
+        except:
+            LOGGER.exception(_("Unable to calculate file hashes for %s"), self)
+            raise
+
+        for rel_path, f_hashes, hashes in hash_results:
+            for alg, computed_hash in f_hashes.items():
+                stored_hash = hashes[alg]
+                if stored_hash.lower() != computed_hash:
+                    e = ChecksumMismatch(
+                        rel_path, alg, stored_hash.lower(), computed_hash
+                    )
+                    LOGGER.warning(force_unicode(e))
+                    errors.append(e)
+
+        if errors:
+            raise BagValidationError(_("Bag validation failed"), errors)
+
+    def _validate_bagittxt(self):
+        """
+        Verify that bagit.txt conforms to specification
+        """
+        bagit_file_path = os.path.join(self.path, "bagit.txt")
+
+        # Note that we are intentionally opening this file in binary mode so we can confirm
+        # that it does not start with the UTF-8 byte-order-mark
+        with open(bagit_file_path, "rb") as bagit_file:
+            first_line = bagit_file.read(4)
+            if first_line.startswith(codecs.BOM_UTF8):
+                raise BagValidationError(
+                    _("bagit.txt must not contain a byte-order mark")
+                )
+
+    def _path_is_dangerous(self, path):
+        """
+        Return true if path looks dangerous, i.e. potentially operates
+        outside the bagging directory structure, e.g. ~/.bashrc, ../../../secrets.json,
+            \\?\c:\, D:\sys32\cmd.exe
+        """
+        if os.path.isabs(path):
+            return True
+        if os.path.expanduser(path) != path:
+            return True
+        if os.path.expandvars(path) != path:
+            return True
+        real_path = os.path.realpath(os.path.join(self.path, path))
+        real_path = os.path.normpath(real_path)
+        bag_path = os.path.realpath(self.path)
+        bag_path = os.path.normpath(bag_path)
+        common = os.path.commonprefix((bag_path, real_path))
+        return not (common == bag_path)
+
+
+class BagError(Exception):
+    pass
+
+
+class BagValidationError(BagError):
+    def __init__(self, message, details=None):
+        super(BagValidationError, self).__init__()
+
+        if details is None:
+            details = []
+
+        self.message = message
+        self.details = details
+
+    def __str__(self):
+        if len(self.details) > 0:
+            details = "; ".join([force_unicode(e) for e in self.details])
+            return "%s: %s" % (self.message, details)
+        return self.message
+
+
+class ManifestErrorDetail(BagError):
+    def __init__(self, path):
+        super(ManifestErrorDetail, self).__init__()
+
+        self.path = path
+
+
+class ChecksumMismatch(ManifestErrorDetail):
+    def __init__(self, path, algorithm=None, expected=None, found=None):
+        super(ChecksumMismatch, self).__init__(path)
+
+        self.path = path
+        self.algorithm = algorithm
+        self.expected = expected
+        self.found = found
+
+    def __str__(self):
+        return _(
+            '%(path)s %(algorithm)s validation failed: expected="%(expected)s" found="%(found)s"'
+        ) % {
+            "path": force_unicode(self.path),
+            "algorithm": self.algorithm,
+            "expected": self.expected,
+            "found": self.found,
+        }
+
+
+class FileMissing(ManifestErrorDetail):
+    def __str__(self):
+        return _(
+            "%s exists in manifest but was not found on filesystem"
+        ) % force_unicode(self.path)
+
+
+class UnexpectedFile(ManifestErrorDetail):
+    def __str__(self):
+        return _("%s exists on filesystem but is not in the manifest") % self.path
+
+
+class FileNormalizationConflict(BagError):
+    """
+    Exception raised when two files differ only in normalization and thus
+    are not safely portable
+    """
+
+    def __init__(self, file_a, file_b):
+        super(FileNormalizationConflict, self).__init__()
+
+        self.file_a = file_a
+        self.file_b = file_b
+
+    def __str__(self):
+        return _(
+            'Unicode normalization conflict for file "%(file_a)s" and "%(file_b)s"'
+        ) % {"file_a": self.file_a, "file_b": self.file_b}
+
+
+def posix_multiprocessing_worker_initializer():
+    """Ignore SIGINT in multiprocessing workers on POSIX systems"""
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+
+# The Unicode normalization form used here doesn't matter – all we care about
+# is consistency since the input value will be preserved:
+
+
+def normalize_unicode_py3(s):
+    return unicodedata.normalize("NFC", s)
+
+
+def normalize_unicode_py2(s):
+    if isinstance(s, str):
+        s = s.decode("utf-8")
+    return unicodedata.normalize("NFC", s)
+
+
+if sys.version_info > (3, 0):
+    normalize_unicode = normalize_unicode_py3
+else:
+    normalize_unicode = normalize_unicode_py2
+
+
+def build_unicode_normalized_lookup_dict(filenames):
+    """
+    Return a dictionary mapping unicode-normalized filenames to as-encoded
+    values to efficiently detect conflicts between the filesystem and manifests.
+
+    This is necessary because some filesystems and utilities may automatically
+    apply a different Unicode normalization form to filenames than was applied
+    when the bag was originally created.
+
+    The best known example of this is when a bag is created using a
+    normalization form other than NFD and then transferred to a Mac where the
+    HFS+ filesystem will transparently normalize filenames to a variant of NFD
+    for every call:
+
+    https://developer.apple.com/legacy/library/technotes/tn/tn1150.html#UnicodeSubtleties
+
+    Windows is documented as storing filenames exactly as provided:
+
+    https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx
+
+    Linux performs no normalization in the kernel but it is technically
+    valid for a filesystem to perform normalization, such as when an HFS+
+    volume is mounted.
+
+    See http://www.unicode.org/reports/tr15/ for a full discussion of
+    equivalence and normalization in Unicode.
+    """
+
+    output = dict()
+
+    for filename in filenames:
+        normalized_filename = normalize_unicode(filename)
+        if normalized_filename in output:
+            raise FileNormalizationConflict(filename, output[normalized_filename])
+        else:
+            output[normalized_filename] = filename
+
+    return output
+
+
+def get_hashers(algorithms):
+    """
+    Given a list of algorithm names, return a dictionary of hasher instances
+
+    This avoids redundant code between the creation and validation code where in
+    both cases we want to avoid reading the same file more than once. The
+    intended use is a simple for loop:
+
+        for block in file:
+            for hasher in hashers.values():
+                hasher.update(block)
+    """
+
+    hashers = {}
+
+    for alg in algorithms:
+        try:
+            hasher = hashlib.new(alg)
+        except ValueError:
+            LOGGER.warning(
+                _("Disabling requested hash algorithm %s: hashlib does not support it"),
+                alg,
+            )
+            continue
+
+        hashers[alg] = hasher
+
+    if not hashers:
+        raise ValueError(
+            _(
+                "Unable to continue: hashlib does not support any of the requested algorithms!"
+            )
+        )
+
+    return hashers
+
+
+def _calc_hashes(args):
+    # auto unpacking of sequences illegal in Python3
+    (base_path, rel_path, hashes, algorithms) = args
+    full_path = os.path.join(base_path, rel_path)
+
+    # Create a clone of the default empty hash objects:
+    f_hashers = dict((alg, hashlib.new(alg)) for alg in hashes if alg in algorithms)
+
+    try:
+        f_hashes = _calculate_file_hashes(full_path, f_hashers)
+    except BagValidationError as e:
+        f_hashes = dict((alg, force_unicode(e)) for alg in f_hashers.keys())
+
+    return rel_path, f_hashes, hashes
+
+
+def _calculate_file_hashes(full_path, f_hashers):
+    """
+    Returns a dictionary of (algorithm, hexdigest) values for the provided
+    filename
+    """
+    LOGGER.info(_("Verifying checksum for file %s"), full_path)
+
+    try:
+        with open(full_path, "rb") as f:
+            while True:
+                block = f.read(HASH_BLOCK_SIZE)
+                if not block:
+                    break
+                for i in f_hashers.values():
+                    i.update(block)
+    except (OSError, IOError) as e:
+        raise BagValidationError(
+            _("Could not read %(filename)s: %(error)s")
+            % {"filename": full_path, "error": force_unicode(e)}
+        )
+
+    return dict((alg, h.hexdigest()) for alg, h in f_hashers.items())
+
+
+def _load_tag_file(tag_file_name, encoding="utf-8-sig"):
+    with open_text_file(tag_file_name, "r", encoding=encoding) as tag_file:
+        # Store duplicate tags as list of vals
+        # in order of parsing under the same key.
+        tags = {}
+        for name, value in _parse_tags(tag_file):
+            if name not in tags:
+                tags[name] = value
+                continue
+
+            if not isinstance(tags[name], list):
+                tags[name] = [tags[name], value]
+            else:
+                tags[name].append(value)
+
+        return tags
+
+
+def _parse_tags(tag_file):
+    """Parses a tag file, according to RFC 2822.  This
+       includes line folding, permitting extra-long
+       field values.
+
+       See http://www.faqs.org/rfcs/rfc2822.html for
+       more information.
+    """
+
+    tag_name = None
+    tag_value = None
+
+    # Line folding is handled by yielding values only after we encounter
+    # the start of a new tag, or if we pass the EOF.
+    for num, line in enumerate(tag_file):
+        # Skip over any empty or blank lines.
+        if len(line) == 0 or line.isspace():
+            continue
+        elif line[0].isspace() and tag_value is not None:  # folded line
+            tag_value += line
+        else:
+            # Starting a new tag; yield the last one.
+            if tag_name:
+                yield (tag_name, tag_value.strip())
+
+            if ":" not in line:
+                raise BagValidationError(
+                    _("%(filename)s contains invalid tag: %(line)s")
+                    % {
+                        "line": line.strip(),
+                        "filename": os.path.basename(tag_file.name),
+                    }
+                )
+
+            parts = line.strip().split(":", 1)
+            tag_name = parts[0].strip()
+            tag_value = parts[1]
+
+    # Passed the EOF.  All done after this.
+    if tag_name:
+        yield (tag_name, tag_value.strip())
+
+
+def _make_tag_file(bag_info_path, bag_info):
+    headers = sorted(bag_info.keys())
+    with open_text_file(bag_info_path, "w") as f:
+        for h in headers:
+            values = bag_info[h]
+            if not isinstance(values, list):
+                values = [values]
+            for txt in values:
+                # strip CR, LF and CRLF so they don't mess up the tag file
+                txt = re.sub(r"\n|\r|(\r\n)", "", force_unicode(txt))
+                f.write("%s: %s\n" % (h, txt))
+
+
+def make_manifests(data_dir, processes, algorithms=DEFAULT_CHECKSUMS, encoding="utf-8"):
+    LOGGER.info(
+        _("Using %(process_count)d processes to generate manifests: %(algorithms)s"),
+        {"process_count": processes, "algorithms": ", ".join(algorithms)},
+    )
+
+    manifest_line_generator = partial(generate_manifest_lines, algorithms=algorithms)
+
+    if processes > 1:
+        pool = multiprocessing.Pool(processes=processes)
+        checksums = pool.map(manifest_line_generator, _walk(data_dir))
+        pool.close()
+        pool.join()
+    else:
+        checksums = [manifest_line_generator(i) for i in _walk(data_dir)]
+
+    # At this point we have a list of tuples which start with the algorithm name:
+    manifest_data = {}
+    for batch in checksums:
+        for entry in batch:
+            manifest_data.setdefault(entry[0], []).append(entry[1:])
+
+    # These will be keyed on the algorithm name so we can perform sanity checks
+    # below to catch failures in the hashing process:
+    num_files = defaultdict(lambda: 0)
+    total_bytes = defaultdict(lambda: 0)
+
+    for algorithm, values in manifest_data.items():
+        manifest_filename = "manifest-%s.txt" % algorithm
+
+        with open_text_file(manifest_filename, "w", encoding=encoding) as manifest:
+            for digest, filename, byte_count in values:
+                manifest.write("%s  %s\n" % (digest, _encode_filename(filename)))
+                num_files[algorithm] += 1
+                total_bytes[algorithm] += byte_count
+
+    # We'll use sets of the values for the error checks and eventually return the payload oxum values:
+    byte_value_set = set(total_bytes.values())
+    file_count_set = set(num_files.values())
+
+    # allow a bag with an empty payload
+    if not byte_value_set and not file_count_set:
+        return 0, 0
+
+    if len(file_count_set) != 1:
+        raise RuntimeError(_("Expected the same number of files for each checksum"))
+
+    if len(byte_value_set) != 1:
+        raise RuntimeError(_("Expected the same number of bytes for each checksums"))
+
+    return byte_value_set.pop(), file_count_set.pop()
+
+
+def _make_tagmanifest_file(alg, bag_dir, encoding="utf-8"):
+    tagmanifest_file = join(bag_dir, "tagmanifest-%s.txt" % alg)
+    LOGGER.info(_("Creating %s"), tagmanifest_file)
+
+    checksums = []
+    for f in _find_tag_files(bag_dir):
+        if re.match(r"^tagmanifest-.+\.txt$", f):
+            continue
+        with open(join(bag_dir, f), "rb") as fh:
+            m = hashlib.new(alg)
+            while True:
+                block = fh.read(HASH_BLOCK_SIZE)
+                if not block:
+                    break
+                m.update(block)
+            checksums.append((m.hexdigest(), f))
+
+    with open_text_file(
+        join(bag_dir, tagmanifest_file), mode="w", encoding=encoding
+    ) as tagmanifest:
+        for digest, filename in checksums:
+            tagmanifest.write("%s %s\n" % (digest, filename))
+
+
+def _find_tag_files(bag_dir):
+    for dir in os.listdir(bag_dir):
+        if dir != "data":
+            if os.path.isfile(dir) and not dir.startswith("tagmanifest-"):
+                yield dir
+            for dir_name, _, filenames in os.walk(dir):
+                for filename in filenames:
+                    if filename.startswith("tagmanifest-"):
+                        continue
+                    # remove everything up to the bag_dir directory
+                    p = join(dir_name, filename)
+                    yield os.path.relpath(p, bag_dir)
+
+
+def _walk(data_dir):
+    for dirpath, dirnames, filenames in os.walk(data_dir):
+        # if we don't sort here the order of entries is non-deterministic
+        # which makes it hard to test the fixity of tagmanifest-md5.txt
+        filenames.sort()
+        dirnames.sort()
+        for fn in filenames:
+            path = os.path.join(dirpath, fn)
+            # BagIt spec requires manifest to always use '/' as path separator
+            if os.path.sep != "/":
+                parts = path.split(os.path.sep)
+                path = "/".join(parts)
+            yield path
+
+
+def _can_bag(test_dir):
+    """Scan the provided directory for files which cannot be bagged due to insufficient permissions"""
+    unbaggable = []
+
+    if not os.access(test_dir, os.R_OK):
+        # We cannot continue without permission to read the source directory
+        unbaggable.append(test_dir)
+        return unbaggable
+
+    if not os.access(test_dir, os.W_OK):
+        unbaggable.append(test_dir)
+
+    for dirpath, dirnames, filenames in os.walk(test_dir):
+        for directory in dirnames:
+            full_path = os.path.join(dirpath, directory)
+            if not os.access(full_path, os.W_OK):
+                unbaggable.append(full_path)
+
+    return unbaggable
+
+
+def _can_read(test_dir):
+    """
+    returns ((unreadable_dirs), (unreadable_files))
+    """
+    unreadable_dirs = []
+    unreadable_files = []
+
+    if not os.access(test_dir, os.R_OK):
+        unreadable_dirs.append(test_dir)
+    else:
+        for dirpath, dirnames, filenames in os.walk(test_dir):
+            for dn in dirnames:
+                full_path = os.path.join(dirpath, dn)
+                if not os.access(full_path, os.R_OK):
+                    unreadable_dirs.append(full_path)
+            for fn in filenames:
+                full_path = os.path.join(dirpath, fn)
+                if not os.access(full_path, os.R_OK):
+                    unreadable_files.append(full_path)
+    return (tuple(unreadable_dirs), tuple(unreadable_files))
+
+
+def generate_manifest_lines(filename, algorithms=DEFAULT_CHECKSUMS):
+    LOGGER.info(_("Generating manifest lines for file %s"), filename)
+
+    # For performance we'll read the file only once and pass it block
+    # by block to every requested hash algorithm:
+    hashers = get_hashers(algorithms)
+
+    total_bytes = 0
+
+    with open(filename, "rb") as f:
+        while True:
+            block = f.read(HASH_BLOCK_SIZE)
+
+            if not block:
+                break
+
+            total_bytes += len(block)
+            for hasher in hashers.values():
+                hasher.update(block)
+
+    decoded_filename = _decode_filename(filename)
+
+    # We'll generate a list of results in roughly manifest format but prefixed with the algorithm:
+    results = [
+        (alg, hasher.hexdigest(), decoded_filename, total_bytes)
+        for alg, hasher in hashers.items()
+    ]
+
+    return results
+
+
+def _encode_filename(s):
+    s = s.replace("\r", "%0D")
+    s = s.replace("\n", "%0A")
+    return s
+
+
+def _decode_filename(s):
+    s = re.sub(r"%0D", "\r", s, re.IGNORECASE)
+    s = re.sub(r"%0A", "\n", s, re.IGNORECASE)
+    return s
+
+
+def force_unicode_py2(s):
+    """Reliably return a Unicode string given a possible unicode or byte string"""
+    if isinstance(s, str):
+        return s.decode("utf-8")
+    else:
+        return unicode(s)
+
+
+if sys.version_info > (3, 0):
+    force_unicode = str
+else:
+    force_unicode = force_unicode_py2
+
+# following code is used for command line program
+
+
+class BagArgumentParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        argparse.ArgumentParser.__init__(self, *args, **kwargs)
+        self.set_defaults(bag_info={})
+
+
+class BagHeaderAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        opt = option_string.lstrip("--")
+        opt_caps = "-".join([o.capitalize() for o in opt.split("-")])
+        namespace.bag_info[opt_caps] = values
+
+
+def _make_parser():
+    parser = BagArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="bagit-python version %s\n\n%s\n" % (VERSION, __doc__.strip()),
+    )
+    parser.add_argument(
+        "--processes",
+        type=int,
+        dest="processes",
+        default=1,
+        help=_(
+            "Use multiple processes to calculate checksums faster (default: %(default)s)"
+        ),
+    )
+    parser.add_argument("--log", help=_("The name of the log file (default: stdout)"))
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help=_("Suppress all progress information other than errors"),
+    )
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help=_(
+            "Validate existing bags in the provided directories instead of"
+            " creating new ones"
+        ),
+    )
+    parser.add_argument(
+        "--fast",
+        action="store_true",
+        help=_(
+            "Modify --validate behaviour to only test whether the bag directory"
+            " has the number of files and total size specified in Payload-Oxum"
+            " without performing checksum validation to detect corruption."
+        ),
+    )
+    parser.add_argument(
+        "--completeness-only",
+        action="store_true",
+        help=_(
+            "Modify --validate behaviour to test whether the bag directory"
+            " has the expected payload specified in the checksum manifests"
+            " without performing checksum validation to detect corruption."
+        ),
+    )
+
+    checksum_args = parser.add_argument_group(
+        _("Checksum Algorithms"),
+        _(
+            "Select the manifest algorithms to be used when creating bags"
+            " (default=%s)"
+        )
+        % ", ".join(DEFAULT_CHECKSUMS),
+    )
+
+    for i in CHECKSUM_ALGOS:
+        alg_name = re.sub(r"^([A-Z]+)(\d+)$", r"\1-\2", i.upper())
+        checksum_args.add_argument(
+            "--%s" % i,
+            action="append_const",
+            dest="checksums",
+            const=i,
+            help=_("Generate %s manifest when creating a bag") % alg_name,
+        )
+
+    metadata_args = parser.add_argument_group(_("Optional Bag Metadata"))
+    for header in STANDARD_BAG_INFO_HEADERS:
+        metadata_args.add_argument(
+            "--%s" % header.lower(), type=str, action=BagHeaderAction, default=argparse.SUPPRESS
+        )
+
+    parser.add_argument(
+        "directory",
+        nargs="+",
+        help=_(
+            "Directory which will be converted into a bag in place"
+            " by moving any existing files into the BagIt structure"
+            " and creating the manifests and other metadata."
+        ),
+    )
+
+    return parser
+
+
+def _configure_logging(opts):
+    log_format = "%(asctime)s - %(levelname)s - %(message)s"
+    if opts.quiet:
+        level = logging.ERROR
+    else:
+        level = logging.INFO
+    if opts.log:
+        logging.basicConfig(filename=opts.log, level=level, format=log_format)
+    else:
+        logging.basicConfig(level=level, format=log_format)
+
+
+def main():
+    if "--version" in sys.argv:
+        print(_("bagit-python version %s") % VERSION)
+        sys.exit(0)
+
+    parser = _make_parser()
+    args = parser.parse_args()
+
+    if args.processes < 0:
+        parser.error(_("The number of processes must be 0 or greater"))
+
+    if args.fast and not args.validate:
+        parser.error(_("--fast is only allowed as an option for --validate!"))
+
+    _configure_logging(args)
+
+    rc = 0
+    for bag_dir in args.directory:
+        # validate the bag
+        if args.validate:
+            try:
+                bag = Bag(bag_dir)
+                # validate throws a BagError or BagValidationError
+                bag.validate(
+                    processes=args.processes,
+                    fast=args.fast,
+                    completeness_only=args.completeness_only,
+                )
+                if args.fast:
+                    LOGGER.info(_("%s valid according to Payload-Oxum"), bag_dir)
+                else:
+                    LOGGER.info(_("%s is valid"), bag_dir)
+            except BagError as e:
+                LOGGER.error(
+                    _("%(bag)s is invalid: %(error)s"), {"bag": bag_dir, "error": e}
+                )
+                rc = 1
+
+        # make the bag
+        else:
+            try:
+                make_bag(
+                    bag_dir,
+                    bag_info=args.bag_info,
+                    processes=args.processes,
+                    checksums=args.checksums,
+                )
+            except Exception as exc:
+                LOGGER.error(
+                    _("Failed to create bag in %(bag_directory)s: %(error)s"),
+                    {"bag_directory": bag_dir, "error": exc},
+                    exc_info=True,
+                )
+                rc = 1
+
+    sys.exit(rc)
+
+
+if __name__ == "__main__":
+    main()
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/AUTHORS
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/AUTHORS	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,49 @@
+Behold, mortal, the origins of Beautiful Soup...
+================================================
+
+Leonard Richardson is the primary maintainer.
+
+Aaron DeVore and Isaac Muse have made significant contributions to the
+code base.
+
+Mark Pilgrim provided the encoding detection code that forms the base
+of UnicodeDammit.
+
+Thomas Kluyver and Ezio Melotti finished the work of getting Beautiful
+Soup 4 working under Python 3.
+
+Simon Willison wrote soupselect, which was used to make Beautiful Soup
+support CSS selectors. Isaac Muse wrote SoupSieve, which made it
+possible to _remove_ the CSS selector code from Beautiful Soup.
+
+Sam Ruby helped with a lot of edge cases.
+
+Jonathan Ellis was awarded the prestigious Beau Potage D'Or for his
+work in solving the nestable tags conundrum.
+
+An incomplete list of people have contributed patches to Beautiful
+Soup:
+
+ Istvan Albert, Andrew Lin, Anthony Baxter, Oliver Beattie, Andrew
+Boyko, Tony Chang, Francisco Canas, "Delong", Zephyr Fang, Fuzzy,
+Roman Gaufman, Yoni Gilad, Richie Hindle, Toshihiro Kamiya, Peteris
+Krumins, Kent Johnson, Marek Kapolka, Andreas Kostyrka, Roel Kramer,
+Ben Last, Robert Leftwich, Stefaan Lippens, "liquider", Staffan
+Malmgren, Ksenia Marasanova, JP Moins, Adam Monsen, John Nagle, "Jon",
+Ed Oskiewicz, Martijn Peters, Greg Phillips, Giles Radford, Stefano
+Revera, Arthur Rudolph, Marko Samastur, James Salter, Jouni Seppänen,
+Alexander Schmolck, Tim Shirley, Geoffrey Sneddon, Ville Skyttä,
+"Vikas", Jens Svalgaard, Andy Theyers, Eric Weiser, Glyn Webster, John
+Wiseman, Paul Wright, Danny Yoo
+
+An incomplete list of people who made suggestions or found bugs or
+found ways to break Beautiful Soup:
+
+ Hanno Böck, Matteo Bertini, Chris Curvey, Simon Cusack, Bruce Eckel,
+ Matt Ernst, Michael Foord, Tom Harris, Bill de hOra, Donald Howes,
+ Matt Patterson, Scott Roberts, Steve Strassmann, Mike Williams,
+ warchild at redho dot com, Sami Kuisma, Carlos Rocha, Bob Hutchison,
+ Joren Mc, Michal Migurski, John Kleven, Tim Heaney, Tripp Lilley, Ed
+ Summers, Dennis Sutch, Chris Smith, Aaron Swartz, Stuart
+ Turner, Greg Edwards, Kevin J Kalupson, Nikos Kouremenos, Artur de
+ Sousa Rocha, Yichun Wei, Per Vognsen
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/COPYING.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/COPYING.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,27 @@
+Beautiful Soup is made available under the MIT license:
+
+ Copyright (c) 2004-2017 Leonard Richardson
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+Beautiful Soup incorporates code from the html5lib library, which is
+also made available under the MIT license. Copyright (c) 2006-2013
+James Graham and other contributors
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/LICENSE
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/LICENSE	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,30 @@
+Beautiful Soup is made available under the MIT license:
+
+ Copyright (c) 2004-2019 Leonard Richardson
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+Beautiful Soup incorporates code from the html5lib library, which is
+also made available under the MIT license. Copyright (c) 2006-2013
+James Graham and other contributors
+
+Beautiful Soup depends on the soupsieve library, which is also made
+available under the MIT license. Copyright (c) 2018 Isaac Muse
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,132 @@
+Metadata-Version: 2.1
+Name: beautifulsoup4
+Version: 4.9.3
+Summary: Screen-scraping library
+Home-page: http://www.crummy.com/software/BeautifulSoup/bs4/
+Author: Leonard Richardson
+Author-email: leonardr@segfault.org
+License: MIT
+Download-URL: http://www.crummy.com/software/BeautifulSoup/bs4/download/
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Topic :: Text Processing :: Markup :: XML
+Classifier: Topic :: Text Processing :: Markup :: SGML
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+Requires-Dist: soupsieve (<2.0,>1.2) ; python_version < "3.0"
+Requires-Dist: soupsieve (>1.2) ; python_version >= "3.0"
+Provides-Extra: html5lib
+Requires-Dist: html5lib ; extra == 'html5lib'
+Provides-Extra: lxml
+Requires-Dist: lxml ; extra == 'lxml'
+
+Beautiful Soup is a library that makes it easy to scrape information
+from web pages. It sits atop an HTML or XML parser, providing Pythonic
+idioms for iterating, searching, and modifying the parse tree.
+
+# Quick start
+
+```
+>>> from bs4 import BeautifulSoup
+>>> soup = BeautifulSoup("<p>Some<b>bad<i>HTML")
+>>> print(soup.prettify())
+<html>
+ <body>
+  <p>
+   Some
+   <b>
+    bad
+    <i>
+     HTML
+    </i>
+   </b>
+  </p>
+ </body>
+</html>
+>>> soup.find(text="bad")
+'bad'
+>>> soup.i
+<i>HTML</i>
+#
+>>> soup = BeautifulSoup("<tag1>Some<tag2/>bad<tag3>XML", "xml")
+#
+>>> print(soup.prettify())
+<?xml version="1.0" encoding="utf-8"?>
+<tag1>
+ Some
+ <tag2/>
+ bad
+ <tag3>
+  XML
+ </tag3>
+</tag1>
+```
+
+To go beyond the basics, [comprehensive documentation is available](http://www.crummy.com/software/BeautifulSoup/bs4/doc/).
+
+# Links
+
+* [Homepage](http://www.crummy.com/software/BeautifulSoup/bs4/)
+* [Documentation](http://www.crummy.com/software/BeautifulSoup/bs4/doc/)
+* [Discussion group](http://groups.google.com/group/beautifulsoup/)
+* [Development](https://code.launchpad.net/beautifulsoup/)
+* [Bug tracker](https://bugs.launchpad.net/beautifulsoup/)
+* [Complete changelog](https://bazaar.launchpad.net/~leonardr/beautifulsoup/bs4/view/head:/CHANGELOG)
+
+# Note on Python 2 sunsetting
+
+Since 2012, Beautiful Soup has been developed as a Python 2 library
+which is automatically converted to Python 3 code as necessary. This
+makes it impossible to take advantage of some features of Python
+3.
+
+For this reason, I plan to discontinue Beautiful Soup's Python 2
+support at some point after December 31, 2020: one year after the
+sunset date for Python 2 itself. Beyond that point, new Beautiful Soup
+development will exclusively target Python 3. Of course, older
+releases of Beautiful Soup, which support both versions, will continue
+to be available.
+
+# Supporting the project
+
+If you use Beautiful Soup as part of your professional work, please consider a
+[Tidelift subscription](https://tidelift.com/subscription/pkg/pypi-beautifulsoup4?utm_source=pypi-beautifulsoup4&utm_medium=referral&utm_campaign=readme).
+This will support many of the free software projects your organization
+depends on, not just Beautiful Soup.
+
+If you use Beautiful Soup for personal projects, the best way to say
+thank you is to read
+[Tool Safety](https://www.crummy.com/software/BeautifulSoup/zine/), a zine I
+wrote about what Beautiful Soup has taught me about software
+development.
+
+# Building the documentation
+
+The bs4/doc/ directory contains full documentation in Sphinx
+format. Run `make html` in that directory to create HTML
+documentation.
+
+# Running the unit tests
+
+Beautiful Soup supports unit test discovery from the project root directory:
+
+```
+$ nosetests
+```
+
+```
+$ python -m unittest discover -s bs4
+```
+
+If you checked out the source tree, you should see a script in the
+home directory called test-all-versions. This script will run the unit
+tests under Python 2, then create a temporary Python 3 conversion of
+the source and run the unit tests again under Python 3.
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,44 @@
+beautifulsoup4-4.9.3.dist-info/AUTHORS,sha256=uSIdbrBb1sobdXl7VrlUvuvim2dN9kF3MH4Edn0WKGE,2176
+beautifulsoup4-4.9.3.dist-info/COPYING.txt,sha256=pH6lEjYJhGT-C09Vl0NZC1MwVtngD0nsv4Apn6tH4jE,1315
+beautifulsoup4-4.9.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+beautifulsoup4-4.9.3.dist-info/LICENSE,sha256=ynIn3bnu1syAnhV_Z7Ag543eBjJAAB0RhW-FxJy25CM,1447
+beautifulsoup4-4.9.3.dist-info/METADATA,sha256=iY3LTmChfV6eWiLC4MPfy_FZL9pllucV7IzOVrF117Q,4190
+beautifulsoup4-4.9.3.dist-info/RECORD,,
+beautifulsoup4-4.9.3.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+beautifulsoup4-4.9.3.dist-info/top_level.txt,sha256=H8VT-IuPWLzQqwG9_eChjXDJ1z0H9RRebdSR90Bjnkw,4
+bs4/__init__.py,sha256=Xg4iRoWU7bD9HQo8OCHh6BP9g74T8n37QjQFhT3_GLA,32102
+bs4/__pycache__/__init__.cpython-39.pyc,,
+bs4/__pycache__/dammit.cpython-39.pyc,,
+bs4/__pycache__/diagnose.cpython-39.pyc,,
+bs4/__pycache__/element.cpython-39.pyc,,
+bs4/__pycache__/formatter.cpython-39.pyc,,
+bs4/__pycache__/testing.cpython-39.pyc,,
+bs4/builder/__init__.py,sha256=dJcyrx6CdAuKQhg5KfpKTAEQeDKvIW3PWHo-0aKDaLg,19777
+bs4/builder/__pycache__/__init__.cpython-39.pyc,,
+bs4/builder/__pycache__/_html5lib.cpython-39.pyc,,
+bs4/builder/__pycache__/_htmlparser.cpython-39.pyc,,
+bs4/builder/__pycache__/_lxml.cpython-39.pyc,,
+bs4/builder/_html5lib.py,sha256=hDxlzVrAku_eU7zEt4gZ-sAXzG58GvkLfMz6P4zUqoA,18748
+bs4/builder/_htmlparser.py,sha256=80-Nb3QXS3PrSa-ReEBTh1X8-C2HkLFLLAbC0fSKuoU,18405
+bs4/builder/_lxml.py,sha256=e4w91RZi3NII_QYe2e1-EiN_BxQtgJPSRwQ8Xgz41ZA,12234
+bs4/dammit.py,sha256=k_XPB3kbZsHM01ckf9BxCUB2Eu2dIQ3d3DDt7UEv9RA,34130
+bs4/diagnose.py,sha256=WOzytCTkvqh_fGhqYlMyaYVjtH50w4jbdf1Fd0iundE,7755
+bs4/element.py,sha256=DbavvJfetuG3GWM_mOsNPVk7WuyQtJQ6qti8FFzwZvE,81650
+bs4/formatter.py,sha256=Wayv1d6fUc9BSCa2k9uhvWwm89xCukdtJhyi9Sxvkuc,5654
+bs4/testing.py,sha256=8C72bkPqP_zPzpP-f9i1qtlNuKonHD-VtamNxUKwIBE,45930
+bs4/tests/__init__.py,sha256=bdUBDE750n7qNEfue7-3a1fBaUxJlvZMkvJvZa-lbYs,27
+bs4/tests/__pycache__/__init__.cpython-39.pyc,,
+bs4/tests/__pycache__/test_builder_registry.cpython-39.pyc,,
+bs4/tests/__pycache__/test_docs.cpython-39.pyc,,
+bs4/tests/__pycache__/test_html5lib.cpython-39.pyc,,
+bs4/tests/__pycache__/test_htmlparser.cpython-39.pyc,,
+bs4/tests/__pycache__/test_lxml.cpython-39.pyc,,
+bs4/tests/__pycache__/test_soup.cpython-39.pyc,,
+bs4/tests/__pycache__/test_tree.cpython-39.pyc,,
+bs4/tests/test_builder_registry.py,sha256=pllfRpArh9TYhjjRUiu1wITr9Ryyv4hiaAtRjij-k4E,5582
+bs4/tests/test_docs.py,sha256=FXfz2bGL4Xe0q6duwpmg9hmFiZuU4DVJPNZ0hTb6aH4,1067
+bs4/tests/test_html5lib.py,sha256=eWnLGHek_RO_TMq0Ixpb1RF3BEDrvhenMf2eaEBjjsg,6754
+bs4/tests/test_htmlparser.py,sha256=3294XvFbWVe0AYoTlnLPEDW_a0Om0BKRcsrwlJbxUaI,3941
+bs4/tests/test_lxml.py,sha256=xJr8eDrtHSb_vQw88lYEKyfdM1Hel4-dBaz14vQq78M,4105
+bs4/tests/test_soup.py,sha256=EhE1dhHKyctNu0y2l0ql6FOHg9qliEt8Kh7jfCx1lDw,29303
+bs4/tests/test_tree.py,sha256=UsXGvnlTBKixno0sbnFllZo6pm-7EiSvOY1dOeWcqFg,89437
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/beautifulsoup4-4.9.3.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+bs4
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/INSTALLER
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/INSTALLER	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+pip
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/LICENSE
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/LICENSE	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012-2020 Galaxy Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/METADATA
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/METADATA	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: bioblend
+Version: 0.15.0
+Summary: Galaxy and CloudMan API library
+Home-page: https://bioblend.readthedocs.io/
+Author: Enis Afgan
+Author-email: afgane@gmail.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/galaxyproject/bioblend/issues
+Project-URL: Documentation, https://bioblend.readthedocs.io/
+Project-URL: Source Code, https://github.com/galaxyproject/bioblend
+Platform: Posix; MacOS X; Windows
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.6
+Requires-Dist: boto (>=2.9.7)
+Requires-Dist: pyyaml
+Requires-Dist: requests (>=2.20.0)
+Requires-Dist: requests-toolbelt (!=0.9.0,>=0.5.1)
+Provides-Extra: testing
+Requires-Dist: pytest ; extra == 'testing'
+
+.. image:: https://img.shields.io/pypi/v/bioblend.svg
+    :target: https://pypi.org/project/bioblend/
+    :alt: latest version available on PyPI
+
+.. image:: https://readthedocs.org/projects/bioblend/badge/
+    :alt: Documentation Status
+    :target: https://bioblend.readthedocs.io/
+
+.. image:: https://badges.gitter.im/galaxyproject/bioblend.svg
+   :alt: Join the chat at https://gitter.im/galaxyproject/bioblend
+   :target: https://gitter.im/galaxyproject/bioblend?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+
+
+BioBlend is a Python library for interacting with `Galaxy`_ and  `CloudMan`_
+APIs.
+
+BioBlend is supported and tested on:
+
+- Python 3.6, 3.7, 3.8 and 3.9
+- Galaxy release_17.09 and later.
+
+Full docs are available at https://bioblend.readthedocs.io/ with a quick library
+overview also available in `ABOUT.rst <./ABOUT.rst>`_.
+
+.. References/hyperlinks used above
+.. _CloudMan: https://galaxyproject.org/cloudman/
+.. _Galaxy: https://galaxyproject.org/
+
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/RECORD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/RECORD	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,140 @@
+../../../bin/bioblend-galaxy-tests,sha256=TSiWxkT3hsOMvM5ZYwejcTMKDGNuE2VNJqkfiQK0Gxg,309
+bioblend-0.15.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+bioblend-0.15.0.dist-info/LICENSE,sha256=xk4fon9Gs8PPLX9l7XzA3uSJWOPy1IcB5pPu9D7Pb2Y,1076
+bioblend-0.15.0.dist-info/METADATA,sha256=CMOntIBsd_MW587Keoesxn6g8ag5gz1u9HVzroHZ3TM,2172
+bioblend-0.15.0.dist-info/RECORD,,
+bioblend-0.15.0.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+bioblend-0.15.0.dist-info/entry_points.txt,sha256=vBEh8v5ijoWChGZ1o5ZZKt5xwG5H8ManZg0UWHFhmWE,101
+bioblend-0.15.0.dist-info/top_level.txt,sha256=mA6L22Od7-pDUqgEcHKXiZeAcfhddOuRrsViwGGnc7k,9
+bioblend/__init__.py,sha256=jSCo6ZAXFF-DgOTf4uTaDwakmru8VM8f-vBAauxooKA,2840
+bioblend/__pycache__/__init__.cpython-39.pyc,,
+bioblend/__pycache__/config.cpython-39.pyc,,
+bioblend/__pycache__/galaxyclient.cpython-39.pyc,,
+bioblend/_tests/CloudmanTestBase.py,sha256=dLIJEix9iPNldliTG2n5MuxQdaA45XoAKBHD_gLuaPE,2443
+bioblend/_tests/GalaxyTestBase.py,sha256=XHhgxfUXvhgYEbo3Xm2WDG1fEfVT4n9uZLCYZa9s_r4,1004
+bioblend/_tests/TestCloudmanLaunch.py,sha256=RL0wm6_egDA6S4PFAWYCqPxQHHQtVs0BWA945252HvM,2075
+bioblend/_tests/TestCloudmanMock.py,sha256=Gba2fdqTHonFNq0RsBii-_florX4O_SCMIGZdysmPHw,5904
+bioblend/_tests/TestCloudmanServices.py,sha256=1eTij6but5K3oDCnEJv5bMYqdbo5_CE_hhXEmbkv-Y4,1890
+bioblend/_tests/TestGalaxyDatasetCollections.py,sha256=xFFylfj6L2ZRyUpdYD0Df35S03MA2y_Q_8GR3B4q0Dw,7269
+bioblend/_tests/TestGalaxyDatasets.py,sha256=GpBjZE9fQeoA2K1X_6r6HRPHiuaIlDq20y1bE8JnvlM,2481
+bioblend/_tests/TestGalaxyFolders.py,sha256=NAZIvWco0Krh4WVJ1yV9xN4jocjHlD18JHRPDTCxCVU,2489
+bioblend/_tests/TestGalaxyGroups.py,sha256=ZG49rlpNqhIw7sQnp3wTYDF2odqLIw1EwSXU4gPynps,2615
+bioblend/_tests/TestGalaxyHistories.py,sha256=ZKy-ohq0hqQFw9bSmavSzBsQiOjZGnty_ZO3DN1p_KY,11338
+bioblend/_tests/TestGalaxyInstance.py,sha256=pscdtAeeqETq0H5-BXHC-K2fDA6QHzUt8CV-jVQ-q_g,1320
+bioblend/_tests/TestGalaxyInvocations.py,sha256=Qhho0Tzrx2HBf4cjJQ8dvfQqcRipklMDATRGfMWEdWY,3194
+bioblend/_tests/TestGalaxyJobs.py,sha256=3c8txTuyJ4R5kLZVjWnt0cDG56mRKnuZovExcRhuuUg,1504
+bioblend/_tests/TestGalaxyLibraries.py,sha256=Hl7mXIgfTunLjSl31PZzSpaUAtKij4W2KlOEixU01_0,7569
+bioblend/_tests/TestGalaxyObjects.py,sha256=jZfgKdRPx6BK0hykXELnudMYP31BGvjoiQ0MdnFjamc,30864
+bioblend/_tests/TestGalaxyQuotas.py,sha256=fiKizJcFqU3i9kDwoB_F31lLg2LZZ7b2-zWYs0hRUgs,2228
+bioblend/_tests/TestGalaxyRoles.py,sha256=VTH3fz3_SrOcNiwSMUGGkV4mmBwuZJ6QLRX6TyKBR80,960
+bioblend/_tests/TestGalaxyToolData.py,sha256=xi1pYj7wEgmFpZl1817tHQ3PABTrIn6vlR5xSHwLu-E,685
+bioblend/_tests/TestGalaxyToolInputs.py,sha256=WdkLKWhSDMonO5FUaS3TviSazxevMAjkmuSN9XJOdJo,1344
+bioblend/_tests/TestGalaxyTools.py,sha256=fRZ74tsuZsT9ru3tNjOOGcVcBSP5gIsoH0kBzuYKw3M,6474
+bioblend/_tests/TestGalaxyUsers.py,sha256=P7PFhe_cm19wKkV6jLxg9_zrv2Xku8p9hD7iWHGLKfE,4070
+bioblend/_tests/TestGalaxyWorkflows.py,sha256=QGj0drIPR9lI4fIm3mR6E0MHWSZFwhSkK1nIh1vUPlk,10081
+bioblend/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bioblend/_tests/__pycache__/CloudmanTestBase.cpython-39.pyc,,
+bioblend/_tests/__pycache__/GalaxyTestBase.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestCloudmanLaunch.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestCloudmanMock.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestCloudmanServices.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyDatasetCollections.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyDatasets.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyFolders.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyGroups.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyHistories.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyInstance.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyInvocations.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyJobs.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyLibraries.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyObjects.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyQuotas.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyRoles.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyToolData.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyToolInputs.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyTools.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyUsers.cpython-39.pyc,,
+bioblend/_tests/__pycache__/TestGalaxyWorkflows.cpython-39.pyc,,
+bioblend/_tests/__pycache__/__init__.cpython-39.pyc,,
+bioblend/_tests/__pycache__/pytest_galaxy_test_wrapper.cpython-39.pyc,,
+bioblend/_tests/__pycache__/test_util.cpython-39.pyc,,
+bioblend/_tests/data/1.bed,sha256=gGQiuSZX1DEumKEwOAzcG6BHAsPkUcLD16Ilm5g910Q,4202
+bioblend/_tests/data/Galaxy-History-test.tar.gz,sha256=SN6ZfRpYD3B7duayqA0a55MU_GEIKDxePuI7UnAwuoM,12362265
+bioblend/_tests/data/paste_columns.ga,sha256=sFKaVe9G0C3I6UbSyTDKK6L4bWDZWLv-CirC_04yyFg,2529
+bioblend/_tests/data/paste_columns_collections.ga,sha256=nELpkeDs7yAM5YHKHXxk-vJb8rBSCTOWS90WfgobU_s,2947
+bioblend/_tests/data/test_workflow_pause.ga,sha256=0UOe8m_OUIiXDpJ2CQTFqseOE4GyR7BScDUvNXmGmYA,3659
+bioblend/_tests/data/workflow_with_parameter_input.ga,sha256=xEOSyDCl8GwL8cjIP44jv7VkeRExI7OSgVUfJqpoNxs,3557
+bioblend/_tests/pytest_galaxy_test_wrapper.py,sha256=5E_fn6FdgjUmgCurnP7tLflTi1R6J_lyb6rpZvtwP2w,1259
+bioblend/_tests/test_util.py,sha256=6aQm1YPOkeBIvJYaXSV5V12wqxrpgDZo7r_xwV45SGE,4311
+bioblend/cloudman/__init__.py,sha256=JzNnPB-puahHW8buyKOi1ES_RD9ihxork-oBFW0zSxw,29399
+bioblend/cloudman/__pycache__/__init__.cpython-39.pyc,,
+bioblend/cloudman/__pycache__/launch.cpython-39.pyc,,
+bioblend/cloudman/launch.py,sha256=sQ4OVys5LQ9nSWZVAgHfD8ElfhPlx4vZNzrPOR5MAdE,40215
+bioblend/config.py,sha256=cF5chgJkxoQ3rxb92y1Y5UQ3JMJOQ2eo0w2auVpCpw4,1964
+bioblend/galaxy/__init__.py,sha256=qkjDDxMIvJ8GVvGfPWIqIK6tI-wvM1YjDzq1bAifAvI,4205
+bioblend/galaxy/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/__pycache__/client.cpython-39.pyc,,
+bioblend/galaxy/client.py,sha256=aMlW5BU5h82MgQukDleD2HGX1CVrw_jqsaezMKvbmho,8648
+bioblend/galaxy/config/__init__.py,sha256=87dNF7Za5DbnZN93axcyH8O1IF1Y87_mTe8EaVj9PVU,1498
+bioblend/galaxy/config/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/dataset_collections/__init__.py,sha256=SHdROI_cC52qAdgVMROR0q9UD-vUnz5XRn6dEWi5AbQ,1791
+bioblend/galaxy/dataset_collections/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/datasets/__init__.py,sha256=lFnmRb7UpGGpjSm4HnlV2b6b0_oJrxlmkX2Ak2x5Cgs,7728
+bioblend/galaxy/datasets/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/datatypes/__init__.py,sha256=m-Qca9ELz_7O_J984-X4_4XLrEJjgQyl1_gq3TWnHVc,1838
+bioblend/galaxy/datatypes/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/folders/__init__.py,sha256=RifhqYdQ4B8uumEgL51cthO_2pkgUBLfX9MZiPLKhk8,4278
+bioblend/galaxy/folders/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/forms/__init__.py,sha256=zIIx9Bz32upowiSQzWCjwS-ufkbl1SqpCyJL7DkCCng,1810
+bioblend/galaxy/forms/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/ftpfiles/__init__.py,sha256=XjyiC3odNreqK_4qJV1YKbApoqSjBDH-MdQiJy-6iCY,569
+bioblend/galaxy/ftpfiles/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/genomes/__init__.py,sha256=WpfeKy9qU_hWrkCcef8eR8XbhHPWnLogRi4iHxy3I8E,3034
+bioblend/galaxy/genomes/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/groups/__init__.py,sha256=3kOjjfrYcZqxlH56k840W2VHO2RRvHAjsMyv7Uldp1o,5928
+bioblend/galaxy/groups/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/histories/__init__.py,sha256=GU1QtBSUAzEqBfXcyIcXwZ_68VFS3Kc0hN42lDSPBrs,27579
+bioblend/galaxy/histories/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/invocations/__init__.py,sha256=RZoRiFshGLOB_adLEHsZKgRZqqjqcfN8bN0mRGwVyJA,6682
+bioblend/galaxy/invocations/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/jobs/__init__.py,sha256=x-wDOaauafyzjMsuOLYK0rFPNwXXUSojmg6eNsn5jzM,7615
+bioblend/galaxy/jobs/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/libraries/__init__.py,sha256=tUy3DO2A3CFT_iDkO0zFMkKzSJcbylBHLVfelUTqK0s,26576
+bioblend/galaxy/libraries/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/objects/__init__.py,sha256=UMDJE0GPQa28JpTL_eahYB23YaVg1ywsxhGc3NNS6E0,101
+bioblend/galaxy/objects/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/objects/__pycache__/client.cpython-39.pyc,,
+bioblend/galaxy/objects/__pycache__/galaxy_instance.cpython-39.pyc,,
+bioblend/galaxy/objects/__pycache__/wrappers.cpython-39.pyc,,
+bioblend/galaxy/objects/client.py,sha256=DGzsbZuwjlK9UMOyiMooH-ceG_tRtU4WgWbH5ZZNIGg,14482
+bioblend/galaxy/objects/galaxy_instance.py,sha256=gqDu6m6M9ZstQupy6h1j4reLl-o4d3BDF0t3LsThjxw,3154
+bioblend/galaxy/objects/wrappers.py,sha256=l0ys9H4jzBg4qwmMGKWvgxOb0Cqsrjt8MXzOWK4MoCA,48438
+bioblend/galaxy/quotas/__init__.py,sha256=YW0hzQB-wPzSn0KnSzJnNDqHIMQ_a-3QpTEoGhpZEds,6646
+bioblend/galaxy/quotas/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/roles/__init__.py,sha256=EGyzzD3sOkFarVxSO2NDxO4h7I3DTvn8vuTyH3zQ4ow,2748
+bioblend/galaxy/roles/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/tool_data/__init__.py,sha256=hj9B58j_zkJ_SEeyGbFJpZyLMeSgnHVFS_O-v_AJOAg,2633
+bioblend/galaxy/tool_data/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/tools/__init__.py,sha256=WGPwbJOR_tOPRB75OIUPyC0l1OFANrONOfK_8k59uM0,12283
+bioblend/galaxy/tools/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/tools/__pycache__/inputs.cpython-39.pyc,,
+bioblend/galaxy/tools/inputs.py,sha256=SJJvTxBq3nufLhp3s07q4MTXKhGkP_6YsQ2W7RSglQk,1738
+bioblend/galaxy/toolshed/__init__.py,sha256=sJJcZQEKg-L7hXT1rfq1DNXc75DCJYeIpNYwkiGaZzQ,7689
+bioblend/galaxy/toolshed/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/users/__init__.py,sha256=nWqpzPa5LTtvsB6X9EXR4LOt0Sb6f-GZe-CentI5RHo,6632
+bioblend/galaxy/users/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/visual/__init__.py,sha256=mb0ECjW-jhGwLDDtdgjJLUubFNab0hue8etoPC4F7X8,1770
+bioblend/galaxy/visual/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxy/workflows/__init__.py,sha256=XU4r5tHJUVpU4kMG6HVUfcFgcVmI5YkejUQaflIQ3wM,29092
+bioblend/galaxy/workflows/__pycache__/__init__.cpython-39.pyc,,
+bioblend/galaxyclient.py,sha256=hhPJlCYJ5iKDgqFOyVAU_awFK_4tLwVE8iOGXA4fejs,9487
+bioblend/toolshed/__init__.py,sha256=HPntkbIFsONON-gcyj-eyw1U4baIMda9eWjAun9yDQI,2195
+bioblend/toolshed/__pycache__/__init__.cpython-39.pyc,,
+bioblend/toolshed/categories/__init__.py,sha256=Rvr0mV-toq-01ONqKRu7NuVkLHWUjteYigolUuA17Ko,1382
+bioblend/toolshed/categories/__pycache__/__init__.cpython-39.pyc,,
+bioblend/toolshed/repositories/__init__.py,sha256=v9XGmloZFJSFLTm_SAYv0PSicvKX_LPT0JbWW-pghc0,19036
+bioblend/toolshed/repositories/__pycache__/__init__.cpython-39.pyc,,
+bioblend/toolshed/tools/__init__.py,sha256=OyaXx8FQMFjaPZpMGlDG9XyT_iPTqgKayBz4tg9RRGU,1826
+bioblend/toolshed/tools/__pycache__/__init__.cpython-39.pyc,,
+bioblend/util/__init__.py,sha256=4hOSrFD6gEbW9JUgTACotWXuH6GRFYepBzuHFlcMS_0,1382
+bioblend/util/__pycache__/__init__.cpython-39.pyc,,
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/WHEEL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/WHEEL	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/entry_points.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/entry_points.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,3 @@
+[console_scripts]
+bioblend-galaxy-tests = bioblend._tests.pytest_galaxy_test_wrapper:main [testing]
+
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/top_level.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend-0.15.0.dist-info/top_level.txt	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,1 @@
+bioblend
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/__init__.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,104 @@
+import logging
+import os
+
+from bioblend.config import (
+    BioBlendConfigLocations,
+    Config,
+)
+
+# Current version of the library
+__version__ = '0.15.0'
+
+# default chunk size (in bytes) for reading remote data
+try:
+    import resource
+    CHUNK_SIZE = resource.getpagesize()
+except Exception:
+    CHUNK_SIZE = 4096
+
+
+config = Config()
+
+
+def get_version():
+    """
+    Returns a string with the current version of the library (e.g., "0.2.0")
+    """
+    return __version__
+
+
+def init_logging():
+    """
+    Initialize BioBlend's logging from a configuration file.
+    """
+    for config_file in BioBlendConfigLocations:
+        try:
+            logging.config.fileConfig(os.path.expanduser(config_file))
+        except Exception:
+            pass
+
+
+class NullHandler(logging.Handler):
+    def emit(self, record):
+        pass
+
+
+# By default, do not force any logging by the library. If you want to see the
+# log messages in your scripts, add the following to the top of your script:
+#   import logging
+#   logging.basicConfig(filename="bioblend.log", level=logging.DEBUG)
+default_format_string = "%(asctime)s %(name)s [%(levelname)s]: %(message)s"
+log = logging.getLogger('bioblend')
+log.addHandler(NullHandler())
+init_logging()
+
+# Convenience functions to set logging to a particular file or stream
+# To enable either of these, simply add the following at the top of a
+# bioblend module:
+#   import bioblend
+#   bioblend.set_stream_logger(__name__)
+
+
+def set_file_logger(name, filepath, level=logging.INFO, format_string=None):
+    global log
+    if not format_string:
+        format_string = default_format_string
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    fh = logging.FileHandler(filepath)
+    fh.setLevel(level)
+    formatter = logging.Formatter(format_string)
+    fh.setFormatter(formatter)
+    logger.addHandler(fh)
+    log = logger
+
+
+def set_stream_logger(name, level=logging.DEBUG, format_string=None):
+    global log
+    if not format_string:
+        format_string = default_format_string
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    fh = logging.StreamHandler()
+    fh.setLevel(level)
+    formatter = logging.Formatter(format_string)
+    fh.setFormatter(formatter)
+    logger.addHandler(fh)
+    log = logger
+
+
+class ConnectionError(Exception):
+    """
+    An exception class that is raised when unexpected HTTP responses come back.
+
+    Should make it easier to debug when strange HTTP things happen such as a
+    proxy server getting in the way of the request etc.
+    @see: body attribute to see the content of the http response
+    """
+    def __init__(self, message, body=None, status_code=None):
+        super().__init__(message)
+        self.body = body
+        self.status_code = status_code
+
+    def __str__(self):
+        return "{}: {}".format(self.args[0], self.body)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/__pycache__/config.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/__pycache__/config.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/__pycache__/galaxyclient.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/__pycache__/galaxyclient.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/CloudmanTestBase.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/CloudmanTestBase.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,68 @@
+"""
+Tests the functionality of the Blend CloudMan API. These tests require working
+credentials to supported cloud infrastructure.
+"""
+import os
+
+from bioblend.util import Bunch
+from . import test_util
+from .test_util import unittest
+
+
+class CloudmanTestBase(unittest.TestCase):
+
+    @classmethod
+    @test_util.skip_unless_cloudman()
+    def setUpClass(cls):
+        if os.environ.get('BIOBLEND_CLOUD_TYPE') == 'EC2':
+            cls.access_key = os.environ['BIOBLEND_ACCESS_KEY']
+            cls.secret_key = os.environ['BIOBLEND_SECRET_KEY']
+            cls.cluster_name = 'Blend CloudMan'
+            cls.ami_id = os.environ['BIOBLEND_AMI_ID']
+            cls.instance_type = 'm1.small'
+            cls.password = 'password'
+            cls.cloud_metadata = Bunch(
+                id='1',  # for compatibility w/ DB representation
+                name="Amazon",
+                cloud_type="ec2",
+                bucket_default="cloudman",
+                region_name="us-east-1",
+                region_endpoint="ec2.amazonaws.com",
+                ec2_port="",
+                ec2_conn_path="/",
+                cidr_range="",
+                is_secure=True,
+                s3_host="s3.amazonaws.com",
+                s3_port="",
+                s3_conn_path='/')
+        else:
+            # Assume OpenStack/NeCTAR
+            cls.access_key = os.environ['BIOBLEND_ACCESS_KEY']
+            cls.secret_key = os.environ['BIOBLEND_SECRET_KEY']
+            cls.cloud_metadata = Bunch(
+                id='-1',
+                name="NeCTAR",
+                cloud_type='openstack',
+                bucket_default='cloudman-os',
+                region_name='melbourne',
+                region_endpoint='nova.rc.nectar.org.au',
+                ec2_port=8773,
+                ec2_conn_path='/services/Cloud',
+                cidr_range='115.146.92.0/22',
+                is_secure=True,
+                s3_host='swift.rc.nectar.org.au',
+                s3_port=8888,
+                s3_conn_path='/')
+            cls.cluster_name = 'Blend CloudMan'
+            cls.ami_id = os.environ['BIOBLEND_AMI_ID']
+            cls.instance_type = 'm1.small'
+            cls.password = 'password'
+
+    @classmethod
+    @test_util.skip_unless_cloudman()
+    def tearDownClass(cls):
+        try:
+            # TODO: cloudman's terminate method has a bug. Needs fix
+            cls.cmi.terminate(delete_cluster=True)
+        except Exception:
+            pass
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/GalaxyTestBase.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/GalaxyTestBase.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,27 @@
+import os
+
+import bioblend
+import bioblend.galaxy
+from . import test_util
+from .test_util import unittest
+
+bioblend.set_stream_logger('test', level='INFO')
+
+BIOBLEND_TEST_JOB_TIMEOUT = int(os.environ.get("BIOBLEND_TEST_JOB_TIMEOUT", "60"))
+
+
+@test_util.skip_unless_galaxy()
+class GalaxyTestBase(unittest.TestCase):
+
+    def setUp(self):
+        galaxy_key = os.environ['BIOBLEND_GALAXY_API_KEY']
+        galaxy_url = os.environ['BIOBLEND_GALAXY_URL']
+        self.gi = bioblend.galaxy.GalaxyInstance(url=galaxy_url, key=galaxy_key)
+
+    def _test_dataset(self, history_id, contents="1\t2\t3", **kwds):
+        tool_output = self.gi.tools.paste_content(contents, history_id, **kwds)
+        return tool_output["outputs"][0]["id"]
+
+    def _wait_and_verify_dataset(self, dataset_id, expected_contents, timeout_seconds=BIOBLEND_TEST_JOB_TIMEOUT):
+        dataset_contents = self.gi.datasets.download_dataset(dataset_id, maxwait=timeout_seconds)
+        self.assertEqual(dataset_contents, expected_contents)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestCloudmanLaunch.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestCloudmanLaunch.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,44 @@
+"""
+Tests the functionality of the Blend CloudMan API. These tests require working
+credentials to supported cloud infrastructure.
+"""
+from bioblend.cloudman import CloudManConfig, CloudManInstance
+from . import CloudmanTestBase, test_util
+
+
+@test_util.skip_unless_cloudman()
+class TestCloudmanLaunch(CloudmanTestBase.CloudmanTestBase):
+
+    def setUp(self):
+        super().setUp()
+
+    def test_validate_valid_config(self):
+        """
+        Tests whether a valid config is validated properly.
+        """
+        # cfg = CloudManConfig(self.access_key, self.secret_key, self.cluster_name, self.ami_id, self.instance_type, self.password, cloud_metadata=self.cloud_metadata)
+        cls = TestCloudmanLaunch
+        cfg = CloudManConfig(cls.access_key, cls.secret_key, cls.cluster_name, cls.ami_id, cls.instance_type, cls.password, cloud_metadata=cls.cloud_metadata)
+        result = cfg.validate()
+        self.assertIsNone(result, "Validation did not return null to indicate success!")
+
+    def test_validate_invalid_config(self):
+        """
+        Tests whether an invalid config is validated properly.
+        """
+        cfg = CloudManConfig()
+        result = cfg.validate()
+        self.assertIsNotNone(result, "Validation should have returned a value since the configuration was invalid!")
+
+    def test_launch_and_terminate(self):
+        cls = TestCloudmanLaunch
+        cfg = CloudManConfig(cls.access_key, cls.secret_key, cls.cluster_name, cls.ami_id, cls.instance_type, cls.password, cloud_metadata=cls.cloud_metadata)
+        cmi = CloudManInstance.launch_instance(cfg)
+        status = cmi.get_status()
+        self.assertNotEqual(status['cluster_status'], 'ERROR', "instance.get_status() returned ERROR. Should return a successful status!")
+        try:
+            # TODO: The terminate method is unpredictable! Needs fix.
+            result = cmi.terminate(delete_cluster=True)
+            self.assertEqual(result['cluster_status'], 'SHUTDOWN', "Cluster should be in status SHUTDOWN after call to terminate!")
+        except Exception:
+            pass
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestCloudmanMock.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestCloudmanMock.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,137 @@
+"""
+Tests the functionality of the BioBlend CloudMan API, without actually making
+calls to a remote CloudMan instance/server. These don't actually ensure
+that BioBlend is integrated with CloudMan correctly. They only ensure that
+if you refactor the BioBlend CloudMan API code, that it will maintain its
+current behaviour.
+"""
+from unittest.mock import MagicMock
+
+from bioblend import cloudman
+from .test_util import unittest
+
+
+class TestCloudmanMock(unittest.TestCase):
+
+    def setUp(self):
+        url = "http://127.0.0.1:42284"
+        password = "password"
+        self.cm = cloudman.CloudManInstance(url, password)
+
+#    def test_initialize(self):
+#        self.cm._make_get_request = MagicMock(return_value="{}")
+#
+#        ## Set cluster type
+#        self.cm.initialize(type="Galaxy")
+#
+#        params = {'startup_opt': 'Galaxy'}
+#        self.cm._make_get_request.assert_called_with("initialize_cluster", parameters=params)
+
+    def test_get_status(self):
+        # Set return value of call
+        self.cm._make_get_request = MagicMock(return_value={})
+
+        status = self.cm.get_status()
+        self.assertNotEqual(status, None)
+        self.assertEqual(status, {})
+
+        # Check that the correct URL was called
+        self.cm._make_get_request.assert_called_with("instance_state_json")
+
+    def test_get_nodes(self):
+        # Set return value of call
+        self.cm._make_get_request = MagicMock(return_value={'instances': []})
+
+        nodes = self.cm.get_nodes()
+        self.assertIsNotNone(nodes)
+        self.assertEqual(len(nodes), 0)
+
+        # Check that the correct URL was called
+        self.cm._make_get_request.assert_called_with("instance_feed_json")
+
+    def test_add_nodes(self):
+        self.cm._make_get_request = MagicMock(return_value="{}")
+        num_nodes = 10
+        status = self.cm.add_nodes(num_nodes)
+        self.assertIsNotNone(status)
+
+        # Check that the correct URL was called
+        params = {'number_nodes': 10, 'instance_type': '', 'spot_price': ''}
+        self.cm._make_get_request.assert_called_with("add_instances", parameters=params)
+
+    def test_remove_nodes(self):
+        self.cm._make_get_request = MagicMock(return_value="{}")
+        num_nodes = 10
+        status = self.cm.remove_nodes(num_nodes, force=True)
+        self.assertIsNotNone(status)
+
+        # Check that the correct URL was called
+        params = {'number_nodes': 10, 'force_termination': True}
+        self.cm._make_get_request.assert_called_with("remove_instances", parameters=params)
+
+    def test_remove_node(self):
+        self.cm._make_get_request = MagicMock(return_value="{}")
+        instance_id = "abcdef"
+        self.cm.remove_node(instance_id, force=True)
+
+        # Check that the correct URL was called
+        params = {'instance_id': "abcdef"}
+        self.cm._make_get_request.assert_called_with("remove_instance", parameters=params)
+
+    def test_reboot_node(self):
+        self.cm._make_get_request = MagicMock(return_value="{}")
+        instance_id = "abcdef"
+        self.cm.reboot_node(instance_id)
+
+        # Check that the correct URL was called
+        params = {'instance_id': "abcdef"}
+        self.cm._make_get_request.assert_called_with("reboot_instance", parameters=params)
+
+    def test_autoscaling_enabled_true(self):
+        return_json_string = {"autoscaling": {"use_autoscaling": True, "as_max": "3", "as_min": "1"}}
+        self.cm._make_get_request = MagicMock(return_value=return_json_string)
+        self.assertTrue(self.cm.autoscaling_enabled())
+
+    def test_autoscaling_enabled_false(self):
+        return_json_string = {"autoscaling": {"use_autoscaling": False, "as_max": "3", "as_min": "1"}}
+        self.cm._make_get_request = MagicMock(return_value=return_json_string)
+        self.assertFalse(self.cm.autoscaling_enabled())
+
+    def test_enable_autoscaling(self):
+        return_json_string = {"autoscaling": {"use_autoscaling": False, "as_max": "N/A", "as_min": "N/A"}}
+        self.cm._make_get_request = MagicMock(return_value=return_json_string)
+        self.assertFalse(self.cm.autoscaling_enabled())
+        self.cm.enable_autoscaling(minimum_nodes=0, maximum_nodes=19)
+
+        # Check that the correct URL was called
+        params = {'as_min': 0, 'as_max': 19}
+        self.cm._make_get_request.assert_called_with("toggle_autoscaling", parameters=params)
+
+        return_json_string = {"autoscaling": {"use_autoscaling": True, "as_max": "19", "as_min": "0"}}
+        self.cm.enable_autoscaling(minimum_nodes=0, maximum_nodes=19)
+
+        # Check that the correct URL was called
+        params = {'as_min': 0, 'as_max': 19}
+        self.cm._make_get_request.assert_called_with("toggle_autoscaling", parameters=params)
+
+    def test_disable_autoscaling(self):
+        return_json_string = {"autoscaling": {"use_autoscaling": True, "as_max": "3", "as_min": "1"}}
+        self.cm._make_get_request = MagicMock(return_value=return_json_string)
+        self.cm.disable_autoscaling()
+
+        self.cm._make_get_request.assert_called_with("toggle_autoscaling")
+
+    def test_adjust_autoscaling(self):
+        return_json_string = {"autoscaling": {"use_autoscaling": True, "as_max": "3", "as_min": "1"}}
+        self.cm._make_get_request = MagicMock(return_value=return_json_string)
+        self.cm.adjust_autoscaling(minimum_nodes=3, maximum_nodes=4)
+        params = {'as_min_adj': 3, 'as_max_adj': 4}
+        self.cm._make_get_request.assert_called_with("adjust_autoscaling", parameters=params)
+
+    def test_get_galaxy_state_stopped(self):
+        return_json = {"status": "'Galaxy' is not running", "srvc": "Galaxy"}
+        self.cm._make_get_request = MagicMock(return_value=return_json)
+
+        self.assertEqual(self.cm.get_galaxy_state()['status'], "'Galaxy' is not running")
+        params = {'srvc': "Galaxy"}
+        self.cm._make_get_request.assert_called_with("get_srvc_status", parameters=params)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestCloudmanServices.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestCloudmanServices.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,55 @@
+"""
+Tests the functionality of the Blend CloudMan API. These tests require working
+credentials to supported cloud infrastructure.
+"""
+from bioblend.cloudman import CloudManConfig, CloudManInstance
+from . import CloudmanTestBase, test_util
+
+
+@test_util.skip_unless_cloudman()
+class TestCloudmanServices(CloudmanTestBase.CloudmanTestBase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.cfg = CloudManConfig(cls.access_key, cls.secret_key, cls.cluster_name, cls.ami_id, cls.instance_type, cls.password, cloud_metadata=cls.cloud_metadata)
+        cls.cmi = CloudManInstance.launch_instance(cls.cfg)
+
+    def setUp(self):
+        self.cmi = self.__class__.cmi
+
+    def test_get_status(self):
+        status = self.cmi.get_status()
+        self.assertIsNotNone(status)
+
+    def test_get_nodes(self):
+        nodes = self.cmi.get_nodes()
+        self.assertIsNotNone(nodes)
+
+    def test_add_nodes(self):
+        num_nodes = 1
+        status = self.cmi.add_nodes(num_nodes)
+        self.assertIsNotNone(status)
+
+    def test_reboot_node(self):
+        instance_id = self.cmi.instance_id
+        self.cmi.reboot_node(instance_id)
+
+    def test_remove_node(self):
+        instance_id = self.cmi.instance_id
+        self.cmi.remove_node(instance_id, force=True)
+
+    def test_enable_autoscaling(self):
+        self.assertFalse(self.cmi.autoscaling_enabled())
+        self.cmi.enable_autoscaling(minimum_nodes=0, maximum_nodes=19)
+        self.assertTrue(self.cmi.autoscaling_enabled())
+
+    def test_disable_autoscaling(self):
+        self.cmi.disable_autoscaling()
+        self.assertFalse(self.cmi.autoscaling_enabled())
+
+    def test_adjust_autoscaling(self):
+        self.cmi.adjust_autoscaling(minimum_nodes=3, maximum_nodes=4)
+
+#    def test_get_galaxy_state_stopped(self):
+#        self.assertEqual(self.cmi.get_galaxy_state(), "'Galaxy' is not running")
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyDatasetCollections.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyDatasetCollections.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,135 @@
+from bioblend.galaxy import dataset_collections
+from . import GalaxyTestBase
+
+
+class TestGalaxyDatasetCollections(GalaxyTestBase.GalaxyTestBase):
+
+    def test_create_list_in_history(self):
+        history_id = self.gi.histories.create_history(name="TestDSListCreate")["id"]
+        dataset1_id = self._test_dataset(history_id)
+        dataset2_id = self._test_dataset(history_id)
+        dataset3_id = self._test_dataset(history_id)
+        collection_response = self.gi.histories.create_dataset_collection(
+            history_id=history_id,
+            collection_description=dataset_collections.CollectionDescription(
+                name="MyDatasetList",
+                elements=[
+                    dataset_collections.HistoryDatasetElement(name="sample1", id=dataset1_id),
+                    dataset_collections.HistoryDatasetElement(name="sample2", id=dataset2_id),
+                    dataset_collections.HistoryDatasetElement(name="sample3", id=dataset3_id),
+                ]
+            )
+        )
+        self.assertEqual(collection_response["name"], "MyDatasetList")
+        self.assertEqual(collection_response["collection_type"], "list")
+        elements = collection_response["elements"]
+        self.assertEqual(len(elements), 3)
+        self.assertEqual(elements[0]["element_index"], 0)
+        self.assertEqual(elements[0]["object"]["id"], dataset1_id)
+        self.assertEqual(elements[1]["object"]["id"], dataset2_id)
+        self.assertEqual(elements[2]["object"]["id"], dataset3_id)
+        self.assertEqual(elements[2]["element_identifier"], "sample3")
+
+    def test_create_list_of_paired_datasets_in_history(self):
+        history_id = self.gi.histories.create_history(name="TestDSListCreate")["id"]
+        dataset1_id = self._test_dataset(history_id)
+        dataset2_id = self._test_dataset(history_id)
+        dataset3_id = self._test_dataset(history_id)
+        dataset4_id = self._test_dataset(history_id)
+        collection_response = self.gi.histories.create_dataset_collection(
+            history_id=history_id,
+            collection_description=dataset_collections.CollectionDescription(
+                name="MyListOfPairedDatasets",
+                type="list:paired",
+                elements=[
+                    dataset_collections.CollectionElement(
+                        name="sample1",
+                        type="paired",
+                        elements=[
+                            dataset_collections.HistoryDatasetElement(name="forward", id=dataset1_id),
+                            dataset_collections.HistoryDatasetElement(name="reverse", id=dataset2_id),
+                        ]
+                    ),
+                    dataset_collections.CollectionElement(
+                        name="sample2",
+                        type="paired",
+                        elements=[
+                            dataset_collections.HistoryDatasetElement(name="forward", id=dataset3_id),
+                            dataset_collections.HistoryDatasetElement(name="reverse", id=dataset4_id),
+                        ]
+                    ),
+                ]
+            )
+        )
+        self.assertEqual(collection_response["name"], "MyListOfPairedDatasets")
+        self.assertEqual(collection_response["collection_type"], "list:paired")
+        elements = collection_response["elements"]
+        self.assertEqual(len(elements), 2)
+        self.assertEqual(elements[0]["element_index"], 0)
+        created_pair1 = elements[0]["object"]
+        self.assertEqual(created_pair1["collection_type"], "paired")
+        self.assertEqual(len(created_pair1["elements"]), 2)
+        forward_element1 = created_pair1["elements"][0]
+        self.assertEqual(forward_element1["element_identifier"], "forward")
+        self.assertEqual(forward_element1["element_index"], 0)
+        forward_dataset1 = forward_element1["object"]
+        self.assertEqual(forward_dataset1["id"], dataset1_id)
+
+        self.assertEqual(elements[1]["element_index"], 1)
+        created_pair2 = elements[1]["object"]
+        self.assertEqual(created_pair2["collection_type"], "paired")
+        self.assertEqual(len(created_pair2["elements"]), 2)
+        reverse_element2 = created_pair2["elements"][1]
+        reverse_dataset2 = reverse_element2["object"]
+
+        self.assertEqual(reverse_element2["element_identifier"], "reverse")
+        self.assertEqual(reverse_element2["element_index"], 1)
+        self.assertEqual(reverse_dataset2["id"], dataset4_id)
+
+    def test_collections_in_history_index(self):
+        history_id = self.gi.histories.create_history(name="TestHistoryDSIndex")["id"]
+        history_dataset_collection = self._create_pair_in_history(history_id)
+        contents = self.gi.histories.show_history(history_id, contents=True)
+        self.assertEqual(len(contents), 3)
+        self.assertEqual(contents[2]["id"], history_dataset_collection["id"])
+        self.assertEqual(contents[2]["name"], "MyTestPair")
+        self.assertEqual(contents[2]["collection_type"], "paired")
+
+    def test_show_history_dataset_collection(self):
+        history_id = self.gi.histories.create_history(name="TestHistoryDSIndexShow")["id"]
+        history_dataset_collection = self._create_pair_in_history(history_id)
+        show_response = self.gi.histories.show_dataset_collection(history_id, history_dataset_collection["id"])
+        for key in ["collection_type", "elements", "name", "deleted", "visible"]:
+            self.assertIn(key, show_response)
+        self.assertFalse(show_response["deleted"])
+        self.assertTrue(show_response["visible"])
+
+    def test_delete_history_dataset_collection(self):
+        history_id = self.gi.histories.create_history(name="TestHistoryDSDelete")["id"]
+        history_dataset_collection = self._create_pair_in_history(history_id)
+        self.gi.histories.delete_dataset_collection(history_id, history_dataset_collection["id"])
+        show_response = self.gi.histories.show_dataset_collection(history_id, history_dataset_collection["id"])
+        self.assertTrue(show_response["deleted"])
+
+    def test_update_history_dataset_collection(self):
+        history_id = self.gi.histories.create_history(name="TestHistoryDSDelete")["id"]
+        history_dataset_collection = self._create_pair_in_history(history_id)
+        self.gi.histories.update_dataset_collection(history_id, history_dataset_collection["id"], visible=False)
+        show_response = self.gi.histories.show_dataset_collection(history_id, history_dataset_collection["id"])
+        self.assertFalse(show_response["visible"])
+
+    def _create_pair_in_history(self, history_id):
+        dataset1_id = self._test_dataset(history_id)
+        dataset2_id = self._test_dataset(history_id)
+        collection_response = self.gi.histories.create_dataset_collection(
+            history_id=history_id,
+            collection_description=dataset_collections.CollectionDescription(
+                name="MyTestPair",
+                type="paired",
+                elements=[
+                    dataset_collections.HistoryDatasetElement(name="forward", id=dataset1_id),
+                    dataset_collections.HistoryDatasetElement(name="reverse", id=dataset2_id),
+                ]
+            )
+        )
+        return collection_response
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyDatasets.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyDatasets.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,59 @@
+import shutil
+import tempfile
+
+from . import (
+    GalaxyTestBase,
+    test_util
+)
+
+
+class TestGalaxyDatasets(GalaxyTestBase.GalaxyTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.history_id = self.gi.histories.create_history(name='TestShowDataset')['id']
+        self.dataset_contents = "line 1\nline 2\rline 3\r\nline 4"
+        self.dataset_id = self._test_dataset(self.history_id, contents=self.dataset_contents)
+
+    def tearDown(self):
+        self.gi.histories.delete_history(self.history_id, purge=True)
+
+    @test_util.skip_unless_galaxy('release_19.05')
+    def test_show_nonexistent_dataset(self):
+        with self.assertRaises(Exception):
+            self.gi.datasets.show_dataset('nonexistent_id')
+
+    def test_show_dataset(self):
+        self.gi.datasets.show_dataset(self.dataset_id)
+
+    def test_download_dataset(self):
+        with self.assertRaises(Exception):
+            self.gi.datasets.download_dataset(None)
+        expected_contents = ("\n".join(self.dataset_contents.splitlines()) + "\n").encode()
+        # download_dataset() with file_path=None is already tested in TestGalaxyTools.test_paste_content()
+        # self._wait_and_verify_dataset(self.dataset_id, expected_contents)
+        tempdir = tempfile.mkdtemp(prefix='bioblend_test_')
+        try:
+            downloaded_dataset = self.gi.datasets.download_dataset(
+                self.dataset_id, file_path=tempdir,
+                maxwait=GalaxyTestBase.BIOBLEND_TEST_JOB_TIMEOUT * 2)
+            self.assertTrue(downloaded_dataset.startswith(tempdir))
+            with open(downloaded_dataset, 'rb') as f:
+                self.assertEqual(f.read(), expected_contents)
+        finally:
+            shutil.rmtree(tempdir)
+        with tempfile.NamedTemporaryFile(prefix='bioblend_test_') as f:
+            download_filename = self.gi.datasets.download_dataset(
+                self.dataset_id, file_path=f.name, use_default_filename=False,
+                maxwait=GalaxyTestBase.BIOBLEND_TEST_JOB_TIMEOUT)
+            self.assertEqual(download_filename, f.name)
+            f.flush()
+            self.assertEqual(f.read(), expected_contents)
+
+    @test_util.skip_unless_galaxy('release_19.05')
+    def test_get_datasets(self):
+        datasets = self.gi.datasets.get_datasets()
+        dataset_ids = [dataset['id'] for dataset in datasets]
+        assert self.dataset_id in dataset_ids
+        datasets = self.gi.datasets.get_datasets(limit=0)
+        assert datasets == []
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyFolders.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyFolders.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,58 @@
+from . import GalaxyTestBase
+
+FOO_DATA = 'foo\nbar\n'
+
+
+class TestGalaxyFolders(GalaxyTestBase.GalaxyTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.name = 'automated test folder'
+        self.library = self.gi.libraries.create_library(self.name, description='automated test', synopsis='automated test synopsis')
+        self.folder = self.gi.folders.create_folder(self.library['root_folder_id'], self.name,
+                                                    description="automatically created folder")
+
+    def tearDown(self):
+        self.gi.libraries.delete_library(self.library['id'])
+
+    def test_create_folder(self):
+        self.assertEqual(self.folder['name'], self.name)
+        self.assertEqual(self.folder['description'], 'automatically created folder')
+
+    def test_show_folder(self):
+        f2 = self.gi.folders.show_folder(self.folder['id'])
+        self.assertEqual(f2['id'], self.folder['id'])
+
+    def test_show_folder_contents(self):
+        f2 = self.gi.folders.show_folder(self.folder['id'], contents=True)
+        self.assertIn('folder_contents', f2)
+        self.assertIn('metadata', f2)
+        self.assertEqual(self.name, f2['metadata']['folder_name'])
+
+    def test_delete_folder(self):
+        self.sub_folder = self.gi.folders.create_folder(self.folder['id'], self.name)
+        self.gi.folders.delete_folder(self.sub_folder['id'])
+
+    def test_update_folder(self):
+        self.folder = self.gi.folders.update_folder(self.folder['id'], 'new-name', 'new-description')
+        self.assertEqual(self.folder['name'], 'new-name')
+        self.assertEqual(self.folder['description'], 'new-description')
+
+    def test_get_set_permissions(self):
+        empty_permission = {'add_library_item_role_list': [], 'modify_folder_role_list': [], 'manage_folder_role_list': []}
+        # They should be empty to start with
+        self.assertEqual(
+            self.gi.folders.get_permissions(self.folder['id'], scope='current'),
+            empty_permission
+        )
+        self.assertEqual(
+            self.gi.folders.get_permissions(self.folder['id'], scope='available'),
+            empty_permission
+        )
+        # Then we'll add a role
+        role = self.gi.roles.get_roles()[0]
+        self.gi.folders.set_permissions(self.folder['id'], add_ids=[role['id']])
+        self.assertTrue(
+            role['id'] in
+            self.gi.folders.get_permissions(self.folder['id'], scope='available')['add_library_item_role_list'][0]
+        )
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyGroups.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyGroups.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,63 @@
+"""
+WARNING: only admins can operate on groups!
+"""
+import uuid
+
+from . import GalaxyTestBase
+
+
+class TestGalaxyGroups(GalaxyTestBase.GalaxyTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.name = 'test_%s' % uuid.uuid4().hex
+        self.group = self.gi.groups.create_group(self.name)[0]
+
+    def tearDown(self):
+        # As of 2015/04/13, deleting a group is not possible through the API
+        pass
+
+    def test_create_group(self):
+        self.assertEqual(self.group['name'], self.name)
+        self.assertIsNotNone(self.group['id'])
+
+    def test_get_groups(self):
+        groups = self.gi.groups.get_groups()
+        for group in groups:
+            self.assertIsNotNone(group['id'])
+            self.assertIsNotNone(group['name'])
+
+    def test_show_group(self):
+        group_data = self.gi.groups.show_group(self.group['id'])
+        self.assertEqual(self.group['id'], group_data['id'])
+        self.assertEqual(self.group['name'], group_data['name'])
+
+    def test_get_group_users(self):
+        group_users = self.gi.groups.get_group_users(self.group['id'])
+        self.assertEqual(group_users, [])
+
+    def test_get_group_roles(self):
+        group_roles = self.gi.groups.get_group_roles(self.group['id'])
+        self.assertEqual(group_roles, [])
+
+    def test_update_group(self):
+        new_name = 'test_%s' % uuid.uuid4().hex
+        new_users = [self.gi.users.get_current_user()['id']]
+        self.gi.groups.update_group(self.group['id'], new_name, user_ids=new_users)
+        updated_group = self.gi.groups.show_group(self.group['id'])
+        self.assertEqual(self.group['id'], updated_group['id'])
+        self.assertEqual(updated_group['name'], new_name)
+        updated_group_users = [_['id'] for _ in self.gi.groups.get_group_users(self.group['id'])]
+        self.assertEqual(set(updated_group_users), set(new_users))
+        updated_group_roles = [_['id'] for _ in self.gi.groups.get_group_roles(self.group['id'])]
+        self.assertEqual(set(updated_group_roles), set())
+
+    def test_add_delete_group_user(self):
+        new_user = self.gi.users.get_current_user()['id']
+        ret = self.gi.groups.add_group_user(self.group['id'], new_user)
+        self.assertEqual(ret['id'], new_user)
+        updated_group_users = [_['id'] for _ in self.gi.groups.get_group_users(self.group['id'])]
+        self.assertIn(new_user, updated_group_users)
+        self.gi.groups.delete_group_user(self.group['id'], new_user)
+        updated_group_users = [_['id'] for _ in self.gi.groups.get_group_users(self.group['id'])]
+        self.assertNotIn(new_user, updated_group_users)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyHistories.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyHistories.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,226 @@
+"""
+"""
+import os
+import shutil
+import tarfile
+import tempfile
+
+import bioblend.galaxy
+from . import GalaxyTestBase, test_util
+
+
+class TestGalaxyHistories(GalaxyTestBase.GalaxyTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.default_history_name = "buildbot - automated test"
+        self.history = self.gi.histories.create_history(name=self.default_history_name)
+
+    def test_create_history(self):
+        history_name = "another buildbot - automated test"
+        new_history = self.gi.histories.create_history(name=history_name)
+        self.assertIsNotNone(new_history['id'])
+        self.assertEqual(new_history['name'], history_name)
+        self.assertIsNotNone(new_history['url'])
+
+    def test_update_history(self):
+        new_name = 'buildbot - automated test renamed'
+        new_annotation = 'Annotation for %s' % new_name
+        new_tags = ['tag1', 'tag2']
+        updated_hist = self.gi.histories.update_history(self.history['id'], name=new_name, annotation=new_annotation, tags=new_tags)
+        if 'id' not in updated_hist:
+            updated_hist = self.gi.histories.show_history(self.history['id'])
+        self.assertEqual(self.history['id'], updated_hist['id'])
+        self.assertEqual(updated_hist['name'], new_name)
+        self.assertEqual(updated_hist['annotation'], new_annotation)
+        self.assertEqual(updated_hist['tags'], new_tags)
+
+    def test_publish_history(self):
+        # Verify that searching for published histories does not return the test history
+        published_histories = self.gi.histories.get_histories(published=True)
+        self.assertFalse(any(h['id'] == self.history['id'] for h in published_histories))
+        updated_hist = self.gi.histories.update_history(self.history['id'], published=True)
+        if 'id' not in updated_hist:
+            updated_hist = self.gi.histories.show_history(self.history['id'])
+        self.assertEqual(self.history['id'], updated_hist['id'])
+        self.assertTrue(updated_hist['published'])
+        # Verify that searching for published histories now returns the test history
+        published_histories = self.gi.histories.get_histories(published=True)
+        self.assertTrue(any(h['id'] == self.history['id'] for h in published_histories))
+        # Verify that get_published_histories as an anonymous user also returns the test history
+        anonymous_gi = bioblend.galaxy.GalaxyInstance(url=self.gi.base_url, key=None)
+        published_histories = anonymous_gi.histories.get_published_histories()
+        self.assertTrue(any(h['id'] == self.history['id'] for h in published_histories))
+        history_from_slug = anonymous_gi.histories.get_published_histories(slug=updated_hist['slug'])
+        self.assertTrue(len(history_from_slug) == 1)
+        self.assertEqual(self.history['id'], history_from_slug[0]['id'])
+
+    def test_get_histories(self):
+        # Make sure there's at least one value - the one we created
+        all_histories = self.gi.histories.get_histories()
+        self.assertGreater(len(all_histories), 0)
+
+        # Check whether name is correct, when searched by id
+        new_history = self.gi.histories.get_histories(history_id=self.history['id'])[0]
+        self.assertEqual(new_history['name'], self.default_history_name)
+
+        # Check whether id is present, when searched by name
+        histories = self.gi.histories.get_histories(name=self.default_history_name)
+        self.assertTrue(any(h['id'] == self.history['id'] for h in histories))
+
+        # TODO: check whether deleted history is returned correctly
+        # At the moment, get_histories() returns only not-deleted histories
+        # and get_histories(deleted=True) returns only deleted histories,
+        # so they are not comparable.
+        # In the future, according to https://trello.com/c/MoilsmVv/1673-api-incoherent-and-buggy-indexing-of-deleted-entities ,
+        # get_histories() will return both not-deleted and deleted histories
+        # and we can uncomment the following test.
+        # deleted_history = self.gi.histories.get_histories(deleted=True)
+        # self.assertGreaterEqual(len(all_histories), len(deleted_history))
+
+    def test_show_history(self):
+        history_data = self.gi.histories.show_history(self.history['id'])
+        self.assertEqual(self.history['id'], history_data['id'])
+        self.assertEqual(self.history['name'], history_data['name'])
+        self.assertEqual('new', history_data['state'])
+
+    def test_show_history_with_contents(self):
+        history_id = self.history["id"]
+        contents = self.gi.histories.show_history(history_id, contents=True)
+        # Empty history has no datasets, content length should be 0
+        self.assertEqual(len(contents), 0)
+        self._test_dataset(history_id)
+        contents = self.gi.histories.show_history(history_id, contents=True)
+        # history has 1 dataset, content length should be 1
+        self.assertEqual(len(contents), 1)
+        contents = self.gi.histories.show_history(history_id, contents=True, types=['dataset'])
+        # filtering for dataset, content length should still be 1
+        self.assertEqual(len(contents), 1)
+        contents = self.gi.histories.show_history(history_id, contents=True, types=['dataset_collection'])
+        # filtering for dataset collection but there's no collection in the history
+        self.assertEqual(len(contents), 0)
+        contents = self.gi.histories.show_history(history_id, contents=True, types=['dataset', 'dataset_collection'])
+        self.assertEqual(len(contents), 1)
+
+    def test_create_history_tag(self):
+        new_tag = 'tag1'
+        self.gi.histories.create_history_tag(self.history['id'], new_tag)
+        updated_hist = self.gi.histories.show_history(self.history['id'])
+        self.assertEqual(self.history['id'], updated_hist['id'])
+        self.assertIn(new_tag, updated_hist['tags'])
+
+    def test_show_dataset(self):
+        history_id = self.history["id"]
+        dataset1_id = self._test_dataset(history_id)
+        dataset = self.gi.histories.show_dataset(history_id, dataset1_id)
+        for key in ["name", "hid", "id", "deleted", "history_id", "visible"]:
+            self.assertIn(key, dataset)
+        self.assertEqual(dataset["history_id"], history_id)
+        self.assertEqual(dataset["hid"], 1)
+        self.assertEqual(dataset["id"], dataset1_id)
+        self.assertEqual(dataset["deleted"], False)
+        self.assertEqual(dataset["visible"], True)
+
+    def test_show_dataset_provenance(self):
+        history_id = self.history["id"]
+        dataset1_id = self._test_dataset(history_id)
+        prov = self.gi.histories.show_dataset_provenance(history_id, dataset1_id)
+        for key in ["id", "job_id", "parameters", "stderr", "stdout", "tool_id"]:
+            self.assertIn(key, prov)
+
+    def test_delete_dataset(self):
+        history_id = self.history["id"]
+        dataset1_id = self._test_dataset(history_id)
+        self.gi.histories.delete_dataset(history_id, dataset1_id)
+        dataset = self.gi.histories.show_dataset(history_id, dataset1_id)
+        self.assertTrue(dataset["deleted"])
+        self.assertFalse(dataset['purged'])
+
+    def test_purge_dataset(self):
+        history_id = self.history["id"]
+        dataset1_id = self._test_dataset(history_id)
+        self.gi.histories.delete_dataset(history_id, dataset1_id, purge=True)
+        dataset = self.gi.histories.show_dataset(history_id, dataset1_id)
+        self.assertTrue(dataset["deleted"])
+        self.assertTrue(dataset['purged'])
+
+    def test_update_dataset(self):
+        history_id = self.history["id"]
+        dataset1_id = self._test_dataset(history_id)
+        updated_dataset = self.gi.histories.update_dataset(history_id, dataset1_id, visible=False)
+        if 'id' not in updated_dataset:
+            updated_dataset = self.gi.histories.show_dataset(history_id, dataset1_id)
+        self.assertFalse(updated_dataset["visible"])
+
+    def test_upload_dataset_from_library(self):
+        pass
+
+    # download_dataset() is already tested in TestGalaxyDatasets
+
+    def test_delete_history(self):
+        result = self.gi.histories.delete_history(self.history['id'])
+        self.assertTrue(result['deleted'])
+
+        all_histories = self.gi.histories.get_histories()
+        self.assertTrue(not any(d['id'] == self.history['id'] for d in all_histories))
+
+    def test_undelete_history(self):
+        self.gi.histories.delete_history(self.history['id'])
+        self.gi.histories.undelete_history(self.history['id'])
+        all_histories = self.gi.histories.get_histories()
+        self.assertTrue(any(d['id'] == self.history['id'] for d in all_histories))
+
+    def test_get_status(self):
+        state = self.gi.histories.get_status(self.history['id'])
+        self.assertEqual('new', state['state'])
+
+    def test_get_most_recently_used_history(self):
+        most_recently_used_history = self.gi.histories.get_most_recently_used_history()
+        # if the user has been created via the API, it does not have
+        # a session, therefore no history
+        if most_recently_used_history is not None:
+            self.assertIsNotNone(most_recently_used_history['id'])
+            self.assertIsNotNone(most_recently_used_history['name'])
+            self.assertIsNotNone(most_recently_used_history['state'])
+
+    def test_download_history(self):
+        jeha_id = self.gi.histories.export_history(
+            self.history['id'], wait=True, maxwait=60)
+        self.assertTrue(jeha_id)
+        tempdir = tempfile.mkdtemp(prefix='bioblend_test_')
+        temp_fn = os.path.join(tempdir, 'export.tar.gz')
+        try:
+            with open(temp_fn, 'wb') as fo:
+                self.gi.histories.download_history(self.history['id'], jeha_id,
+                                                   fo)
+            self.assertTrue(tarfile.is_tarfile(temp_fn))
+        finally:
+            shutil.rmtree(tempdir)
+
+    def test_import_history(self):
+        path = test_util.get_abspath(os.path.join('data', 'Galaxy-History-test.tar.gz'))
+        self.gi.histories.import_history(file_path=path)
+
+    def test_copy_dataset(self):
+        history_id = self.history["id"]
+        contents = "1\t2\t3"
+        dataset1_id = self._test_dataset(history_id, contents=contents)
+        self.history_id2 = self.gi.histories.create_history('TestCopyDataset')['id']
+        copied_dataset = self.gi.histories.copy_dataset(self.history_id2, dataset1_id)
+        expected_contents = ("\n".join(contents.splitlines()) + "\n").encode()
+        self._wait_and_verify_dataset(copied_dataset['id'], expected_contents)
+        self.gi.histories.delete_history(self.history_id2, purge=True)
+
+    @test_util.skip_unless_galaxy('release_20.09')
+    def test_update_dataset_datatype(self):
+        history_id = self.history["id"]
+        dataset1_id = self._test_dataset(history_id)
+        self._wait_and_verify_dataset(dataset1_id, b'1\t2\t3\n')
+        original_hda = self.gi.datasets.show_dataset(dataset1_id)
+        assert original_hda['extension'] == 'bed'
+        self.gi.histories.update_dataset(history_id, dataset1_id, datatype='tabular')
+        updated_hda = self.gi.datasets.show_dataset(dataset1_id)
+        assert updated_hda['extension'] == 'tabular'
+
+    def tearDown(self):
+        self.gi.histories.delete_history(self.history['id'], purge=True)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyInstance.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyInstance.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,39 @@
+"""
+Tests on the GalaxyInstance object itself.
+"""
+import time
+
+from bioblend import ConnectionError
+from bioblend.galaxy import GalaxyInstance
+from bioblend.galaxy.client import Client
+from .test_util import unittest
+
+
+class TestGalaxyInstance(unittest.TestCase):
+
+    def setUp(self):
+        # "connect" to a galaxy instance that doesn't exist
+        self.gi = GalaxyInstance("http://localhost:56789", key="whatever")
+
+    def test_set_max_get_retries(self):
+        self.gi.max_get_attempts = 3
+        self.assertEqual(3, Client.max_get_retries())
+
+    def test_set_retry_delay(self):
+        self.gi.get_retry_delay = 5
+        self.assertEqual(5, Client.get_retry_delay())
+
+    def test_get_retry(self):
+        # We set the client to try twice, with a delay of 5 seconds between
+        # attempts. So, we expect the call to take at least 5 seconds before
+        # failing.
+        self.gi.max_get_attempts = 2
+        self.gi.get_retry_delay = 5
+        start = time.time()
+        try:
+            self.gi.libraries.get_libraries()
+            self.fail("Call to show_libraries should have raised a ConnectionError")
+        except ConnectionError:
+            end = time.time()
+        duration = end - start
+        self.assertGreater(duration, self.gi.get_retry_delay, "Didn't seem to retry long enough")
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyInvocations.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyInvocations.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,75 @@
+import os
+import time
+
+from . import GalaxyTestBase, test_util
+
+
+class TestGalaxyInvocations(GalaxyTestBase.GalaxyTestBase):
+    @test_util.skip_unless_galaxy('release_19.09')
+    def test_invocation(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        workflow = self.gi.workflows.import_workflow_from_local_path(path)
+        history_id = self.gi.histories.create_history(name="TestWorkflowState")["id"]
+        dataset1_id = self._test_dataset(history_id)
+        dataset = {'src': 'hda', 'id': dataset1_id}
+
+        invocation = self.gi.workflows.invoke_workflow(
+            workflow['id'],
+            inputs={'Input 1': dataset, 'Input 2': dataset},
+            history_id=history_id,
+            inputs_by='name',
+        )
+
+        invocation_id = invocation["id"]
+        invocations = self.gi.invocations.get_invocations()
+        self.assertEqual(len(invocations), 1)
+        self.assertEqual(invocations[0]["id"], invocation_id)
+        self.gi.invocations.cancel_invocation(invocation_id)
+        invocation = self.gi.invocations.show_invocation(invocation_id)
+        self.assertEqual(invocation['state'], 'cancelled')
+
+        summary = self.gi.invocations.get_invocation_summary(invocation_id)
+        report = self.gi.invocations.get_invocation_report(invocation_id)
+
+        assert summary['states'] == {}
+        assert report['workflows'] == {workflow['id']: {'name': 'paste_columns'}}
+
+    @test_util.skip_unless_galaxy('release_19.09')
+    @test_util.skip_unless_tool("cat1")
+    @test_util.skip_unless_tool("cat")
+    def test_workflow_scheduling(self):
+        path = test_util.get_abspath(os.path.join('data', 'test_workflow_pause.ga'))
+        workflow = self.gi.workflows.import_workflow_from_local_path(path)
+        history_id = self.gi.histories.create_history(name="TestWorkflowState")["id"]
+        dataset1_id = self._test_dataset(history_id)
+
+        invocation = self.gi.workflows.invoke_workflow(
+            workflow["id"],
+            inputs={"0": {"src": "hda", "id": dataset1_id}},
+        )
+        invocation_id = invocation["id"]
+
+        def invocation_steps_by_order_index():
+            invocation = self.gi.invocations.show_invocation(invocation_id)
+            return {s["order_index"]: s for s in invocation["steps"]}
+
+        for _ in range(20):
+            if 2 in invocation_steps_by_order_index():
+                break
+            time.sleep(.5)
+
+        steps = invocation_steps_by_order_index()
+        pause_step = steps[2]
+        self.assertIsNone(
+            self.gi.invocations.show_invocation_step(invocation_id, pause_step["id"])["action"])
+        self.gi.invocations.run_invocation_step_action(invocation_id, pause_step["id"], action=True)
+        self.assertTrue(self.gi.invocations.show_invocation_step(invocation_id, pause_step["id"])["action"])
+        for _ in range(20):
+            invocation = self.gi.invocations.show_invocation(invocation_id)
+            if invocation["state"] == "scheduled":
+                break
+
+            time.sleep(.5)
+
+        invocation = self.gi.invocations.show_invocation(invocation_id)
+        self.assertEqual(invocation["state"], "scheduled")
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyJobs.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyJobs.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,38 @@
+from . import (
+    GalaxyTestBase,
+    test_util
+)
+
+
+class TestGalaxyJobs(GalaxyTestBase.GalaxyTestBase):
+    @test_util.skip_unless_galaxy('release_21.01')
+    @test_util.skip_unless_tool("random_lines1")
+    def test_run_and_rerun_random_lines(self):
+        history_id = self.gi.histories.create_history(name="test_run_random_lines history")["id"]
+        dataset_id = self._test_dataset(history_id, contents="line 1\nline 2\rline 3\r\nline 4")
+        tool_inputs = {
+            'num_lines': '1',
+            'input': {
+                'src': 'hda',
+                'id': dataset_id
+            },
+            'seed_source': {
+                'seed_source_selector': 'set_seed',
+                'seed': 'asdf'
+            }
+        }
+
+        original_output = self.gi.tools.run_tool(
+            history_id=history_id,
+            tool_id="random_lines1",
+            tool_inputs=tool_inputs,
+            input_format='21.01'
+        )
+        original_job_id = original_output['jobs'][0]['id']
+        build_for_rerun = self.gi.jobs._build_for_rerun(original_job_id)
+        self.assertEqual(build_for_rerun['state_inputs']['seed_source']['seed'], 'asdf')
+
+        rerun_output = self.gi.jobs.rerun_job(original_job_id)
+        rerun_output_content = self.gi.datasets.download_dataset(rerun_output['outputs'][0]['id'])
+        original_output_content = self.gi.datasets.download_dataset(original_output['outputs'][0]['id'])
+        self.assertEqual(rerun_output_content, original_output_content)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyLibraries.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyLibraries.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,134 @@
+import os
+import shutil
+import tempfile
+
+from . import GalaxyTestBase, test_util
+
+FOO_DATA = 'foo\nbar\n'
+
+
+class TestGalaxyLibraries(GalaxyTestBase.GalaxyTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.name = 'automated test library'
+        self.library = self.gi.libraries.create_library(self.name, description='automated test', synopsis='automated test synopsis')
+
+    def tearDown(self):
+        self.gi.libraries.delete_library(self.library['id'])
+
+    def test_create_library(self):
+        self.assertEqual(self.library['name'], self.name)
+        self.assertIsNotNone(self.library['id'])
+
+    def test_get_libraries(self):
+        library_data = self.gi.libraries.get_libraries(library_id=self.library['id'])[0]
+        self.assertTrue(library_data['name'] == self.name)
+        deleted_name = 'deleted test library'
+        deleted_library = self.gi.libraries.create_library(deleted_name, description='a deleted library', synopsis='automated test synopsis')
+        self.gi.libraries.delete_library(deleted_library['id'])
+        deleted_library_data = self.gi.libraries.get_libraries(library_id=deleted_library['id'], deleted=True)[0]
+        self.assertTrue(deleted_library_data['name'] == deleted_name)
+        all_non_deleted_libraries = self.gi.libraries.get_libraries(deleted=False)
+        self.assertTrue(any(l['id'] == self.library['id'] for l in all_non_deleted_libraries))
+        self.assertFalse(any(l['id'] == deleted_library['id'] for l in all_non_deleted_libraries))
+        all_deleted_libraries = self.gi.libraries.get_libraries(deleted=True)
+        self.assertFalse(any(l['id'] == self.library['id'] for l in all_deleted_libraries))
+        self.assertTrue(any(l['id'] == deleted_library['id'] for l in all_deleted_libraries))
+        all_libraries = self.gi.libraries.get_libraries(deleted=None)
+        self.assertTrue(any(l['id'] == self.library['id'] for l in all_libraries))
+        self.assertTrue(any(l['id'] == deleted_library['id'] for l in all_libraries))
+
+    def test_show_library(self):
+        library_data = self.gi.libraries.show_library(self.library['id'])
+        self.assertEqual(self.library['id'], library_data['id'])
+        self.assertEqual(self.library['name'], library_data['name'])
+
+    def test_upload_file_from_url(self):
+        self.gi.libraries.upload_file_from_url(self.library['id'], 'https://zenodo.org/record/582600/files/wildtype.fna?download=1')
+
+    def test_upload_file_contents(self):
+        self.gi.libraries.upload_file_contents(self.library['id'], FOO_DATA)
+
+    def test_upload_file_from_local_path(self):
+        with tempfile.NamedTemporaryFile(mode='w', prefix='bioblend_test_') as f:
+            f.write(FOO_DATA)
+            f.flush()
+            self.gi.libraries.upload_file_from_local_path(self.library['id'], f.name)
+
+    def test_upload_file_from_server(self):
+        pass
+
+    def test_upload_from_galaxy_filesystem(self):
+        bnames = ['f%d.txt' % i for i in range(2)]
+        tempdir = tempfile.mkdtemp(prefix='bioblend_test_')
+        try:
+            fnames = [os.path.join(tempdir, _) for _ in bnames]
+            for fn in fnames:
+                with open(fn, 'w') as f:
+                    f.write(FOO_DATA)
+            filesystem_paths = '\n'.join(fnames)
+            ret = self.gi.libraries.upload_from_galaxy_filesystem(self.library['id'], filesystem_paths)
+            for dataset_dict in ret:
+                dataset = self.gi.libraries.wait_for_dataset(self.library['id'], dataset_dict['id'])
+                self.assertEqual(dataset['state'], 'ok')
+            ret = self.gi.libraries.upload_from_galaxy_filesystem(self.library['id'], filesystem_paths, link_data_only='link_to_files')
+            for dataset_dict in ret:
+                dataset = self.gi.libraries.wait_for_dataset(self.library['id'], dataset_dict['id'])
+                self.assertEqual(dataset['state'], 'ok')
+        finally:
+            shutil.rmtree(tempdir)
+
+    def test_copy_from_dataset(self):
+        history = self.gi.histories.create_history()
+        dataset_id = self._test_dataset(history['id'])
+        self.gi.libraries.copy_from_dataset(self.library['id'], dataset_id, message='Copied from dataset')
+
+    def test_update_dataset(self):
+        library_id = self.library["id"]
+        dataset1 = self.gi.libraries.upload_file_contents(library_id, FOO_DATA)
+        updated_dataset = self.gi.libraries.update_library_dataset(dataset1[0]['id'], name='Modified name', misc_info='Modified the name succesfully')
+        self.assertEqual(updated_dataset["name"], 'Modified name')
+        self.assertEqual(updated_dataset["misc_info"], 'Modified the name succesfully')
+
+    def test_library_permissions(self):
+        current_user = self.gi.users.get_current_user()
+        user_id_list_new = [current_user['id']]
+        self.gi.libraries.set_library_permissions(self.library['id'], access_in=user_id_list_new, modify_in=user_id_list_new, add_in=user_id_list_new, manage_in=user_id_list_new)
+        ret = self.gi.libraries.get_library_permissions(self.library['id'])
+        self.assertEqual({_[1] for _ in ret['access_library_role_list']}, set(user_id_list_new))
+        self.assertEqual({_[1] for _ in ret['modify_library_role_list']}, set(user_id_list_new))
+        self.assertEqual({_[1] for _ in ret['add_library_item_role_list']}, set(user_id_list_new))
+        self.assertEqual({_[1] for _ in ret['manage_library_role_list']}, set(user_id_list_new))
+
+    def test_dataset_permissions(self):
+        current_user = self.gi.users.get_current_user()
+        user_id_list_new = [current_user['id']]
+        library_id = self.library["id"]
+        dataset1 = self.gi.libraries.upload_file_contents(library_id, FOO_DATA)
+        ret = self.gi.libraries.set_dataset_permissions(dataset1[0]['id'], access_in=user_id_list_new, modify_in=user_id_list_new, manage_in=user_id_list_new)
+        self.assertEqual({_[1] for _ in ret['access_dataset_roles']}, set(user_id_list_new))
+        self.assertEqual({_[1] for _ in ret['modify_item_roles']}, set(user_id_list_new))
+        self.assertEqual({_[1] for _ in ret['manage_dataset_roles']}, set(user_id_list_new))
+        # test get_dataset_permissions
+        ret_get = self.gi.libraries.get_dataset_permissions(dataset1[0]['id'])
+        self.assertEqual({_[1] for _ in ret_get['access_dataset_roles']}, set(user_id_list_new))
+        self.assertEqual({_[1] for _ in ret_get['modify_item_roles']}, set(user_id_list_new))
+        self.assertEqual({_[1] for _ in ret_get['manage_dataset_roles']}, set(user_id_list_new))
+
+    @test_util.skip_unless_galaxy('release_19.09')
+    def test_upload_file_contents_with_tags(self):
+        datasets = self.gi.libraries.upload_file_contents(self.library['id'], FOO_DATA, tags=["name:foobar", "barfoo"])
+        dataset_show = self.gi.libraries.show_dataset(self.library['id'], datasets[0]['id'])
+        self.assertEqual(dataset_show['tags'], 'name:foobar, barfoo')
+
+    @test_util.skip_unless_galaxy('release_19.09')
+    def test_update_dataset_tags(self):
+        datasets = self.gi.libraries.upload_file_contents(self.library['id'], FOO_DATA)
+        dataset_show = self.gi.libraries.show_dataset(self.library['id'], datasets[0]['id'])
+        self.assertEqual(dataset_show['tags'], "")
+
+        updated_dataset = self.gi.libraries.update_library_dataset(datasets[0]['id'], tags=["name:foobar", "barfoo"])
+        dataset_show = self.gi.libraries.show_dataset(self.library['id'], updated_dataset['id'])
+
+        self.assertEqual(dataset_show['tags'], 'name:foobar, barfoo')
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyObjects.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyObjects.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,839 @@
+# pylint: disable=C0103,E1101
+import json
+import os
+import shutil
+import socket
+import sys
+import tarfile
+import tempfile
+import uuid
+from ssl import SSLError
+from urllib.error import URLError
+from urllib.request import urlopen
+
+import bioblend
+import bioblend.galaxy.objects.galaxy_instance as galaxy_instance
+import bioblend.galaxy.objects.wrappers as wrappers
+from bioblend.galaxy import dataset_collections
+from . import test_util
+from .test_util import unittest
+
+bioblend.set_stream_logger('test', level='INFO')
+socket.setdefaulttimeout(10.0)
+SAMPLE_FN = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+SAMPLE_WF_COLL_FN = test_util.get_abspath(os.path.join('data', 'paste_columns_collections.ga'))
+SAMPLE_WF_PARAMETER_INPUT_FN = test_util.get_abspath(os.path.join('data', 'workflow_with_parameter_input.ga'))
+FOO_DATA = 'foo\nbar\n'
+FOO_DATA_2 = 'foo2\nbar2\n'
+SAMPLE_WF_DICT = {
+    'deleted': False,
+    'id': '9005c5112febe774',
+    'inputs': {
+        '571': {'label': 'Input Dataset', 'value': ''},
+        '572': {'label': 'Input Dataset', 'value': ''},
+    },
+    'model_class': 'StoredWorkflow',
+    'name': 'paste_columns',
+    'owner': 'user_foo',
+    'published': False,
+    'steps': {
+        '571': {
+            'id': 571,
+            'input_steps': {},
+            'tool_id': None,
+            'tool_inputs': {'name': 'Input Dataset'},
+            'tool_version': None,
+            'type': 'data_input',
+        },
+        '572': {
+            'id': 572,
+            'input_steps': {},
+            'tool_id': None,
+            'tool_inputs': {'name': 'Input Dataset'},
+            'tool_version': None,
+            'type': 'data_input',
+        },
+        '573': {
+            'id': 573,
+            'input_steps': {
+                'input1': {'source_step': 571, 'step_output': 'output'},
+                'input2': {'source_step': 572, 'step_output': 'output'},
+            },
+            'tool_id': 'Paste1',
+            'tool_inputs': {
+                'delimiter': '"T"',
+                'input1': 'null',
+                'input2': 'null',
+            },
+            'tool_version': '1.0.0',
+            'type': 'tool',
+        }
+    },
+    'tags': [],
+    'url': '/api/workflows/9005c5112febe774',
+}
+
+
+def is_reachable(url):
+    res = None
+    try:
+        res = urlopen(url, timeout=5)
+    except (SSLError, URLError, socket.timeout):
+        return False
+    if res is not None:
+        res.close()
+    return True
+
+
+def upload_from_fs(lib, bnames, **kwargs):
+    tempdir = tempfile.mkdtemp(prefix='bioblend_test_')
+    try:
+        fnames = [os.path.join(tempdir, _) for _ in bnames]
+        for fn in fnames:
+            with open(fn, 'w') as f:
+                f.write(FOO_DATA)
+        dss = lib.upload_from_galaxy_fs(fnames, **kwargs)
+    finally:
+        shutil.rmtree(tempdir)
+    return dss, fnames
+
+
+class MockWrapper(wrappers.Wrapper):
+    BASE_ATTRS = frozenset(['a', 'b'])
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @property
+    def gi_module(self):
+        return super().gi_module()
+
+
+class TestWrapper(unittest.TestCase):
+
+    def setUp(self):
+        self.d = {'a': 1, 'b': [2, 3], 'c': {'x': 4}}
+        self.assertRaises(TypeError, wrappers.Wrapper, self.d)
+        self.w = MockWrapper(self.d)
+
+    def test_initialize(self):
+        for k in MockWrapper.BASE_ATTRS:
+            self.assertEqual(getattr(self.w, k), self.d[k])
+        self.w.a = 222
+        self.w.b[0] = 222
+        self.assertEqual(self.w.a, 222)
+        self.assertEqual(self.w.b[0], 222)
+        self.assertEqual(self.d['a'], 1)
+        self.assertEqual(self.d['b'][0], 2)
+        self.assertRaises(AttributeError, getattr, self.w, 'foo')
+        self.assertRaises(AttributeError, setattr, self.w, 'foo', 0)
+
+    def test_taint(self):
+        self.assertFalse(self.w.is_modified)
+        self.w.a = 111  # pylint: disable=W0201
+        self.assertTrue(self.w.is_modified)
+
+    def test_serialize(self):
+        w = MockWrapper.from_json(self.w.to_json())
+        self.assertEqual(w.wrapped, self.w.wrapped)
+
+    def test_clone(self):
+        w = self.w.clone()
+        self.assertEqual(w.wrapped, self.w.wrapped)
+        w.b[0] = 111
+        self.assertEqual(self.w.b[0], 2)
+
+    def test_kwargs(self):
+        parent = MockWrapper({'a': 10})
+        w = MockWrapper(self.d, parent=parent)
+        self.assertIs(w.parent, parent)
+        self.assertRaises(AttributeError, setattr, w, 'parent', 0)
+
+
+class TestWorkflow(unittest.TestCase):
+
+    def setUp(self):
+        self.wf = wrappers.Workflow(SAMPLE_WF_DICT)
+
+    def test_initialize(self):
+        self.assertEqual(self.wf.id, '9005c5112febe774')
+        self.assertEqual(self.wf.name, 'paste_columns')
+        self.assertEqual(self.wf.deleted, False)
+        self.assertEqual(self.wf.owner, 'user_foo')
+        self.assertEqual(self.wf.published, False)
+        self.assertEqual(self.wf.tags, [])
+        self.assertEqual(
+            self.wf.input_labels_to_ids, {'Input Dataset': {'571', '572'}})
+        self.assertEqual(self.wf.tool_labels_to_ids, {'Paste1': {'573'}})
+        self.assertEqual(self.wf.data_input_ids, {'571', '572'})
+        self.assertEqual(self.wf.source_ids, {'571', '572'})
+        self.assertEqual(self.wf.sink_ids, {'573'})
+
+    def test_dag(self):
+        inv_dag = {}
+        for h, tails in self.wf.dag.items():
+            for t in tails:
+                inv_dag.setdefault(str(t), set()).add(h)
+        self.assertEqual(self.wf.inv_dag, inv_dag)
+        heads = set(self.wf.dag)
+        self.assertEqual(heads, set.union(*self.wf.inv_dag.values()))
+        tails = set(self.wf.inv_dag)
+        self.assertEqual(tails, set.union(*self.wf.dag.values()))
+        ids = self.wf.sorted_step_ids()
+        self.assertEqual(set(ids), heads | tails)
+        for h, tails in self.wf.dag.items():
+            for t in tails:
+                self.assertLess(ids.index(h), ids.index(t))
+
+    def test_steps(self):
+        steps = SAMPLE_WF_DICT['steps']
+        for sid, s in self.wf.steps.items():
+            self.assertIsInstance(s, wrappers.Step)
+            self.assertEqual(s.id, sid)
+            self.assertIn(sid, steps)
+            self.assertIs(s.parent, self.wf)
+        self.assertEqual(self.wf.data_input_ids, {'571', '572'})
+        self.assertEqual(self.wf.tool_ids, {'573'})
+
+    def test_taint(self):
+        self.assertFalse(self.wf.is_modified)
+        self.wf.steps['571'].tool_id = 'foo'
+        self.assertTrue(self.wf.is_modified)
+
+    def test_input_map(self):
+        class DummyLD:
+            SRC = 'ld'
+
+            def __init__(self, id_):
+                self.id = id_
+
+        label = 'Input Dataset'
+        self.assertEqual(self.wf.input_labels, {label})
+        input_map = self.wf.convert_input_map(
+            {label: [DummyLD('a'), DummyLD('b')]})
+        # {'571': {'id': 'a', 'src': 'ld'}, '572': {'id': 'b', 'src': 'ld'}}
+        # OR
+        # {'571': {'id': 'b', 'src': 'ld'}, '572': {'id': 'a', 'src': 'ld'}}
+        self.assertEqual(set(input_map), {'571', '572'})
+        for d in input_map.values():
+            self.assertEqual(set(d), {'id', 'src'})
+            self.assertEqual(d['src'], 'ld')
+            self.assertIn(d['id'], 'ab')
+
+
+@test_util.skip_unless_galaxy()
+class GalaxyObjectsTestBase(unittest.TestCase):
+
+    def setUp(self):
+        galaxy_key = os.environ['BIOBLEND_GALAXY_API_KEY']
+        galaxy_url = os.environ['BIOBLEND_GALAXY_URL']
+        self.gi = galaxy_instance.GalaxyInstance(galaxy_url, galaxy_key)
+
+
+class TestGalaxyInstance(GalaxyObjectsTestBase):
+
+    def test_library(self):
+        name = 'test_%s' % uuid.uuid4().hex
+        description, synopsis = 'D', 'S'
+        lib = self.gi.libraries.create(
+            name, description=description, synopsis=synopsis)
+        self.assertEqual(lib.name, name)
+        self.assertEqual(lib.description, description)
+        self.assertEqual(lib.synopsis, synopsis)
+        self.assertEqual(len(lib.content_infos), 1)  # root folder
+        self.assertEqual(len(lib.folder_ids), 1)
+        self.assertEqual(len(lib.dataset_ids), 0)
+        self.assertIn(lib.id, [_.id for _ in self.gi.libraries.list()])
+        lib.delete()
+        self.assertFalse(lib.is_mapped)
+
+    def test_workflow_from_str(self):
+        with open(SAMPLE_FN) as f:
+            wf = self.gi.workflows.import_new(f.read())
+        self._check_and_del_workflow(wf)
+
+    def test_workflow_collections_from_str(self):
+        with open(SAMPLE_WF_COLL_FN) as f:
+            wf = self.gi.workflows.import_new(f.read())
+        self._check_and_del_workflow(wf)
+
+    @test_util.skip_unless_galaxy('release_19.01')
+    def test_workflow_parameter_input(self):
+        with open(SAMPLE_WF_PARAMETER_INPUT_FN) as f:
+            self.gi.workflows.import_new(f.read())
+
+    def test_workflow_from_dict(self):
+        with open(SAMPLE_FN) as f:
+            wf = self.gi.workflows.import_new(json.load(f))
+        self._check_and_del_workflow(wf)
+
+    def test_workflow_publish_from_dict(self):
+        with open(SAMPLE_FN) as f:
+            wf = self.gi.workflows.import_new(json.load(f), publish=True)
+        self._check_and_del_workflow(wf, check_is_public=True)
+
+    def test_workflow_missing_tools(self):
+        with open(SAMPLE_FN) as f:
+            wf_dump = json.load(f)
+        wf_info = self.gi.gi.workflows.import_workflow_dict(wf_dump)
+        wf_dict = self.gi.gi.workflows.show_workflow(wf_info['id'])
+        for id_, step in wf_dict['steps'].items():
+            if step['type'] == 'tool':
+                for k in 'tool_inputs', 'tool_version':
+                    wf_dict['steps'][id_][k] = None
+        wf = wrappers.Workflow(wf_dict, gi=self.gi)
+        self.assertFalse(wf.is_runnable)
+        self.assertRaises(RuntimeError, wf.run)
+        wf.delete()
+
+    def test_workflow_export(self):
+        with open(SAMPLE_FN) as f:
+            wf1 = self.gi.workflows.import_new(f.read())
+        wf2 = self.gi.workflows.import_new(wf1.export())
+        self.assertNotEqual(wf1.id, wf2.id)
+        for wf in wf1, wf2:
+            self._check_and_del_workflow(wf)
+
+    def _check_and_del_workflow(self, wf, check_is_public=False):
+        # Galaxy appends additional text to imported workflow names
+        self.assertTrue(wf.name.startswith('paste_columns'))
+        self.assertEqual(type(wf.owner), str)
+        self.assertEqual(len(wf.steps), 3)
+        for step_id, step in wf.steps.items():
+            self.assertIsInstance(step, wrappers.Step)
+            self.assertEqual(step_id, step.id)
+            self.assertIsInstance(step.tool_inputs, dict)
+            if step.type == 'tool':
+                self.assertIsNotNone(step.tool_id)
+                self.assertIsNotNone(step.tool_version)
+                self.assertIsInstance(step.input_steps, dict)
+            elif step.type in ('data_collection_input', 'data_input'):
+                self.assertIsNone(step.tool_id)
+                self.assertIsNone(step.tool_version)
+                self.assertEqual(step.input_steps, {})
+        wf_ids = {_.id for _ in self.gi.workflows.list()}
+        self.assertIn(wf.id, wf_ids)
+        if check_is_public:
+            self.assertTrue(wf.published)
+        wf.delete()
+
+    # not very accurate:
+    #   * we can't publish a wf from the API
+    #   * we can't directly get another user's wf
+    def test_workflow_from_shared(self):
+        all_prevs = {
+            _.id: _ for _ in self.gi.workflows.get_previews(published=True)
+        }
+        pub_only_ids = set(all_prevs).difference(
+            _.id for _ in self.gi.workflows.get_previews())
+        if pub_only_ids:
+            wf_id = pub_only_ids.pop()
+            imported = self.gi.workflows.import_shared(wf_id)
+            self.assertIsInstance(imported, wrappers.Workflow)
+            imported.delete()
+        else:
+            self.skipTest('no published workflows, manually publish a workflow to run this test')
+
+    def test_get_libraries(self):
+        self._test_multi_get('library')
+
+    def test_get_histories(self):
+        self._test_multi_get('history')
+
+    def test_get_workflows(self):
+        self._test_multi_get('workflow')
+
+    def _normalized_functions(self, obj_type):
+        if obj_type == 'library':
+            create = self.gi.libraries.create
+            get_objs = self.gi.libraries.list
+            get_prevs = self.gi.libraries.get_previews
+            del_kwargs = {}
+        elif obj_type == 'history':
+            create = self.gi.histories.create
+            get_objs = self.gi.histories.list
+            get_prevs = self.gi.histories.get_previews
+            del_kwargs = {'purge': True}
+        elif obj_type == 'workflow':
+            def create(name):
+                with open(SAMPLE_FN) as f:
+                    d = json.load(f)
+                d['name'] = name
+                return self.gi.workflows.import_new(d)
+
+            get_objs = self.gi.workflows.list
+            get_prevs = self.gi.workflows.get_previews
+            del_kwargs = {}
+        return create, get_objs, get_prevs, del_kwargs
+
+    def _test_multi_get(self, obj_type):
+        create, get_objs, get_prevs, del_kwargs = self._normalized_functions(
+            obj_type)
+
+        def ids(seq):
+            return {_.id for _ in seq}
+
+        names = ['test_%s' % uuid.uuid4().hex for _ in range(2)]
+        objs = []
+        try:
+            objs = [create(_) for _ in names]
+            self.assertLessEqual(ids(objs), ids(get_objs()))
+            if obj_type != 'workflow':
+                filtered = get_objs(name=names[0])
+                self.assertEqual(len(filtered), 1)
+                self.assertEqual(filtered[0].id, objs[0].id)
+                del_id = objs[-1].id
+                objs.pop().delete(**del_kwargs)
+                self.assertIn(del_id, ids(get_prevs(deleted=True)))
+            else:
+                # Galaxy appends info strings to imported workflow names
+                prev = get_prevs()[0]
+                filtered = get_objs(name=prev.name)
+                self.assertEqual(len(filtered), 1)
+                self.assertEqual(filtered[0].id, prev.id)
+        finally:
+            for o in objs:
+                o.delete(**del_kwargs)
+
+    def test_delete_libraries_by_name(self):
+        self._test_delete_by_name('library')
+
+    def test_delete_histories_by_name(self):
+        self._test_delete_by_name('history')
+
+    def test_delete_workflows_by_name(self):
+        self._test_delete_by_name('workflow')
+
+    def _test_delete_by_name(self, obj_type):
+        create, _, get_prevs, del_kwargs = self._normalized_functions(
+            obj_type)
+        name = 'test_%s' % uuid.uuid4().hex
+        objs = [create(name) for _ in range(2)]  # noqa: F812
+        final_name = objs[0].name
+        prevs = [_ for _ in get_prevs(name=final_name) if not _.deleted]
+        self.assertEqual(len(prevs), len(objs))
+        del_kwargs['name'] = final_name
+        objs[0].gi_module.delete(**del_kwargs)
+        prevs = [_ for _ in get_prevs(name=final_name) if not _.deleted]
+        self.assertEqual(len(prevs), 0)
+
+
+class TestLibrary(GalaxyObjectsTestBase):
+    # just something that can be expected to be always up
+    DS_URL = 'https://tools.ietf.org/rfc/rfc1866.txt'
+
+    def setUp(self):
+        super().setUp()
+        self.lib = self.gi.libraries.create('test_%s' % uuid.uuid4().hex)
+
+    def tearDown(self):
+        self.lib.delete()
+
+    def test_root_folder(self):
+        r = self.lib.root_folder
+        self.assertIsNone(r.parent)
+
+    def test_folder(self):
+        name, desc = 'test_%s' % uuid.uuid4().hex, 'D'
+        folder = self.lib.create_folder(name, description=desc)
+        self.assertEqual(folder.name, name)
+        self.assertEqual(folder.description, desc)
+        self.assertIs(folder.container, self.lib)
+        self.assertEqual(folder.parent.id, self.lib.root_folder.id)
+        self.assertEqual(len(self.lib.content_infos), 2)
+        self.assertEqual(len(self.lib.folder_ids), 2)
+        self.assertIn(folder.id, self.lib.folder_ids)
+        retrieved = self.lib.get_folder(folder.id)
+        self.assertEqual(folder.id, retrieved.id)
+
+    def _check_datasets(self, dss):
+        self.assertEqual(len(dss), len(self.lib.dataset_ids))
+        self.assertEqual({_.id for _ in dss}, set(self.lib.dataset_ids))
+        for ds in dss:
+            self.assertIs(ds.container, self.lib)
+
+    def test_dataset(self):
+        folder = self.lib.create_folder('test_%s' % uuid.uuid4().hex)
+        ds = self.lib.upload_data(FOO_DATA, folder=folder)
+        self.assertEqual(len(self.lib.content_infos), 3)
+        self.assertEqual(len(self.lib.folder_ids), 2)
+        self._check_datasets([ds])
+
+    def test_dataset_from_url(self):
+        if is_reachable(self.DS_URL):
+            ds = self.lib.upload_from_url(self.DS_URL)
+            self._check_datasets([ds])
+        else:
+            self.skipTest('%s not reachable' % self.DS_URL)
+
+    def test_dataset_from_local(self):
+        with tempfile.NamedTemporaryFile(mode='w', prefix='bioblend_test_') as f:
+            f.write(FOO_DATA)
+            f.flush()
+            ds = self.lib.upload_from_local(f.name)
+        self._check_datasets([ds])
+
+    def test_datasets_from_fs(self):
+        bnames = ['f%d.txt' % i for i in range(2)]
+        dss, fnames = upload_from_fs(self.lib, bnames)
+        self._check_datasets(dss)
+        dss, fnames = upload_from_fs(
+            self.lib, bnames, link_data_only='link_to_files')
+        for ds, fn in zip(dss, fnames):
+            self.assertEqual(ds.file_name, fn)
+
+    def test_copy_from_dataset(self):
+        hist = self.gi.histories.create('test_%s' % uuid.uuid4().hex)
+        try:
+            hda = hist.paste_content(FOO_DATA)
+            ds = self.lib.copy_from_dataset(hda)
+        finally:
+            hist.delete(purge=True)
+        self._check_datasets([ds])
+
+    def test_get_dataset(self):
+        ds = self.lib.upload_data(FOO_DATA)
+        retrieved = self.lib.get_dataset(ds.id)
+        self.assertEqual(ds.id, retrieved.id)
+
+    def test_get_datasets(self):
+        bnames = ['f%d.txt' % _ for _ in range(2)]
+        dss, _ = upload_from_fs(self.lib, bnames)
+        retrieved = self.lib.get_datasets()
+        self.assertEqual(len(dss), len(retrieved))
+        self.assertEqual({_.id for _ in dss}, {_.id for _ in retrieved})
+        name = '/%s' % bnames[0]
+        selected = self.lib.get_datasets(name=name)
+        self.assertEqual(len(selected), 1)
+        self.assertEqual(selected[0].name, bnames[0])
+
+
+class TestLDContents(GalaxyObjectsTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.lib = self.gi.libraries.create('test_%s' % uuid.uuid4().hex)
+        self.ds = self.lib.upload_data(FOO_DATA)
+        self.ds.wait()
+
+    def tearDown(self):
+        self.lib.delete()
+
+    def test_dataset_get_stream(self):
+        for idx, c in enumerate(self.ds.get_stream(chunk_size=1)):
+            self.assertEqual(FOO_DATA[idx].encode(), c)
+
+    def test_dataset_peek(self):
+        fetched_data = self.ds.peek(chunk_size=4)
+        self.assertEqual(FOO_DATA[0:4].encode(), fetched_data)
+
+    def test_dataset_download(self):
+        with tempfile.TemporaryFile() as f:
+            self.ds.download(f)
+            f.seek(0)
+            self.assertEqual(FOO_DATA.encode(), f.read())
+
+    def test_dataset_get_contents(self):
+        self.assertEqual(FOO_DATA.encode(), self.ds.get_contents())
+
+    def test_dataset_delete(self):
+        self.ds.delete()
+        # Cannot test this yet because the 'deleted' attribute is not exported
+        # by the API at the moment
+        # self.assertTrue(self.ds.deleted)
+
+    def test_dataset_update(self):
+        new_name = 'test_%s' % uuid.uuid4().hex
+        new_misc_info = 'Annotation for %s' % new_name
+        new_genome_build = 'hg19'
+        updated_ldda = self.ds.update(name=new_name, misc_info=new_misc_info, genome_build=new_genome_build)
+        self.assertEqual(self.ds.id, updated_ldda.id)
+        self.assertEqual(self.ds.name, new_name)
+        self.assertEqual(self.ds.misc_info, new_misc_info)
+        self.assertEqual(self.ds.genome_build, new_genome_build)
+
+
+class TestHistory(GalaxyObjectsTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.hist = self.gi.histories.create('test_%s' % uuid.uuid4().hex)
+
+    def tearDown(self):
+        self.hist.delete(purge=True)
+
+    def test_create_delete(self):
+        name = 'test_%s' % uuid.uuid4().hex
+        hist = self.gi.histories.create(name)
+        self.assertEqual(hist.name, name)
+        hist_id = hist.id
+        self.assertIn(hist_id, [_.id for _ in self.gi.histories.list()])
+        hist.delete(purge=True)
+        self.assertFalse(hist.is_mapped)
+        h = self.gi.histories.get(hist_id)
+        self.assertTrue(h.deleted)
+
+    def _check_dataset(self, hda):
+        self.assertIsInstance(hda, wrappers.HistoryDatasetAssociation)
+        self.assertIs(hda.container, self.hist)
+        self.assertEqual(len(self.hist.dataset_ids), 1)
+        self.assertEqual(self.hist.dataset_ids[0], hda.id)
+
+    def test_import_dataset(self):
+        lib = self.gi.libraries.create('test_%s' % uuid.uuid4().hex)
+        lds = lib.upload_data(FOO_DATA)
+        self.assertEqual(len(self.hist.dataset_ids), 0)
+        hda = self.hist.import_dataset(lds)
+        lib.delete()
+        self._check_dataset(hda)
+
+    def test_upload_file(self):
+        with tempfile.NamedTemporaryFile(mode='w', prefix='bioblend_test_') as f:
+            f.write(FOO_DATA)
+            f.flush()
+            hda = self.hist.upload_file(f.name)
+        self._check_dataset(hda)
+
+    def test_paste_content(self):
+        hda = self.hist.paste_content(FOO_DATA)
+        self._check_dataset(hda)
+
+    def test_get_dataset(self):
+        hda = self.hist.paste_content(FOO_DATA)
+        retrieved = self.hist.get_dataset(hda.id)
+        self.assertEqual(hda.id, retrieved.id)
+
+    def test_get_datasets(self):
+        bnames = ['f%d.txt' % _ for _ in range(2)]
+        lib = self.gi.libraries.create('test_%s' % uuid.uuid4().hex)
+        lds = upload_from_fs(lib, bnames)[0]
+        hdas = [self.hist.import_dataset(_) for _ in lds]
+        lib.delete()
+        retrieved = self.hist.get_datasets()
+        self.assertEqual(len(hdas), len(retrieved))
+        self.assertEqual({_.id for _ in hdas}, {_.id for _ in retrieved})
+        selected = self.hist.get_datasets(name=bnames[0])
+        self.assertEqual(len(selected), 1)
+        self.assertEqual(selected[0].name, bnames[0])
+
+    def test_export_and_download(self):
+        jeha_id = self.hist.export(wait=True, maxwait=60)
+        self.assertTrue(jeha_id)
+        tempdir = tempfile.mkdtemp(prefix='bioblend_test_')
+        temp_fn = os.path.join(tempdir, 'export.tar.gz')
+        try:
+            with open(temp_fn, 'wb') as fo:
+                self.hist.download(jeha_id, fo)
+            self.assertTrue(tarfile.is_tarfile(temp_fn))
+        finally:
+            shutil.rmtree(tempdir)
+
+    def test_update(self):
+        new_name = 'test_%s' % uuid.uuid4().hex
+        new_annotation = 'Annotation for %s' % new_name
+        new_tags = ['tag1', 'tag2']
+        updated_hist = self.hist.update(name=new_name, annotation=new_annotation, tags=new_tags)
+        self.assertEqual(self.hist.id, updated_hist.id)
+        self.assertEqual(self.hist.name, new_name)
+        self.assertEqual(self.hist.annotation, new_annotation)
+        self.assertEqual(self.hist.tags, new_tags)
+        updated_hist = self.hist.update(published=True)
+        self.assertEqual(self.hist.id, updated_hist.id)
+        self.assertTrue(self.hist.published)
+
+    def test_create_dataset_collection(self):
+        self._create_collection_description()
+        hdca = self.hist.create_dataset_collection(self.collection_description)
+        self.assertIsInstance(hdca, wrappers.HistoryDatasetCollectionAssociation)
+        self.assertEqual(hdca.collection_type, 'list')
+        self.assertIs(hdca.container, self.hist)
+        self.assertEqual(len(hdca.elements), 2)
+        self.assertEqual(self.dataset1.id, hdca.elements[0]['object']['id'])
+        self.assertEqual(self.dataset2.id, hdca.elements[1]['object']['id'])
+
+    def test_delete_dataset_collection(self):
+        self._create_collection_description()
+        hdca = self.hist.create_dataset_collection(self.collection_description)
+        hdca.delete()
+        self.assertTrue(hdca.deleted)
+
+    def _create_collection_description(self):
+        self.dataset1 = self.hist.paste_content(FOO_DATA)
+        self.dataset2 = self.hist.paste_content(FOO_DATA_2)
+        self.collection_description = dataset_collections.CollectionDescription(
+            name="MyDatasetList",
+            elements=[
+                dataset_collections.HistoryDatasetElement(name="sample1", id=self.dataset1.id),
+                dataset_collections.HistoryDatasetElement(name="sample2", id=self.dataset2.id),
+            ]
+        )
+
+
+class TestHDAContents(GalaxyObjectsTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.hist = self.gi.histories.create('test_%s' % uuid.uuid4().hex)
+        self.ds = self.hist.paste_content(FOO_DATA)
+        self.ds.wait()
+
+    def tearDown(self):
+        self.hist.delete(purge=True)
+
+    def test_dataset_get_stream(self):
+        for idx, c in enumerate(self.ds.get_stream(chunk_size=1)):
+            self.assertEqual(FOO_DATA[idx].encode(), c)
+
+    def test_dataset_peek(self):
+        fetched_data = self.ds.peek(chunk_size=4)
+        self.assertEqual(FOO_DATA[0:4].encode(), fetched_data)
+
+    def test_dataset_download(self):
+        with tempfile.TemporaryFile() as f:
+            self.ds.download(f)
+            f.seek(0)
+            self.assertEqual(FOO_DATA.encode(), f.read())
+
+    def test_dataset_get_contents(self):
+        self.assertEqual(FOO_DATA.encode(), self.ds.get_contents())
+
+    def test_dataset_update(self):
+        new_name = 'test_%s' % uuid.uuid4().hex
+        new_annotation = 'Annotation for %s' % new_name
+        new_genome_build = 'hg19'
+        updated_hda = self.ds.update(name=new_name, annotation=new_annotation, genome_build=new_genome_build)
+        self.assertEqual(self.ds.id, updated_hda.id)
+        self.assertEqual(self.ds.name, new_name)
+        self.assertEqual(self.ds.annotation, new_annotation)
+        self.assertEqual(self.ds.genome_build, new_genome_build)
+
+    def test_dataset_delete(self):
+        self.ds.delete()
+        self.assertTrue(self.ds.deleted)
+        self.assertFalse(self.ds.purged)
+
+    def test_dataset_purge(self):
+        self.ds.delete(purge=True)
+        self.assertTrue(self.ds.deleted)
+        self.assertTrue(self.ds.purged)
+
+
+class TestRunWorkflow(GalaxyObjectsTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.lib = self.gi.libraries.create('test_%s' % uuid.uuid4().hex)
+        with open(SAMPLE_FN) as f:
+            self.wf = self.gi.workflows.import_new(f.read())
+        self.contents = ['one\ntwo\n', '1\n2\n']
+        self.inputs = [self.lib.upload_data(_) for _ in self.contents]
+
+    def tearDown(self):
+        self.wf.delete()
+        self.lib.delete()
+
+    def _test(self, existing_hist=False, params=False):
+        hist_name = 'test_%s' % uuid.uuid4().hex
+        if existing_hist:
+            hist = self.gi.histories.create(hist_name)
+        else:
+            hist = hist_name
+        if params:
+            params = {'Paste1': {'delimiter': 'U'}}
+            sep = '_'  # 'U' maps to '_' in the paste tool
+        else:
+            params = None
+            sep = '\t'  # default
+        input_map = {'Input 1': self.inputs[0], 'Input 2': self.inputs[1]}
+        sys.stderr.write(os.linesep)
+        outputs, out_hist = self.wf.run(
+            input_map, hist, params=params, wait=True, polling_interval=1)
+        self.assertEqual(len(outputs), 1)
+        out_ds = outputs[0]
+        self.assertIn(out_ds.id, out_hist.dataset_ids)
+        res = out_ds.get_contents()
+        exp_rows = zip(*(_.splitlines() for _ in self.contents))
+        exp_res = ("\n".join(sep.join(t) for t in exp_rows) + "\n").encode()
+        self.assertEqual(res, exp_res)
+        if existing_hist:
+            self.assertEqual(out_hist.id, hist.id)
+        out_hist.delete(purge=True)
+
+    def test_existing_history(self):
+        self._test(existing_hist=True)
+
+    def test_new_history(self):
+        self._test(existing_hist=False)
+
+    def test_params(self):
+        self._test(params=True)
+
+
+class TestRunDatasetCollectionWorkflow(GalaxyObjectsTestBase):
+
+    def setUp(self):
+        super().setUp()
+        with open(SAMPLE_WF_COLL_FN) as f:
+            self.wf = self.gi.workflows.import_new(f.read())
+        self.hist = self.gi.histories.create('test_%s' % uuid.uuid4().hex)
+
+    def tearDown(self):
+        self.wf.delete()
+        self.hist.delete(purge=True)
+
+    def test_run_workflow_with_dataset_collection(self):
+        dataset1 = self.hist.paste_content(FOO_DATA)
+        dataset2 = self.hist.paste_content(FOO_DATA_2)
+        collection_description = dataset_collections.CollectionDescription(
+            name="MyDatasetList",
+            elements=[
+                dataset_collections.HistoryDatasetElement(name="sample1", id=dataset1.id),
+                dataset_collections.HistoryDatasetElement(name="sample2", id=dataset2.id),
+            ]
+        )
+        dataset_collection = self.hist.create_dataset_collection(collection_description)
+        input_map = {"Input Dataset Collection": dataset_collection,
+                     "Input 2": dataset1}
+        outputs, out_hist = self.wf.run(input_map, self.hist, wait=True)
+        self.assertEqual(len(outputs), 1)
+        out_hdca = outputs[0]
+        self.assertIsInstance(out_hdca, wrappers.HistoryDatasetCollectionAssociation)
+        self.assertEqual(out_hdca.collection_type, 'list')
+        self.assertEqual(len(out_hdca.elements), 2)
+        self.assertEqual(out_hist.id, self.hist.id)
+
+
+class TestJob(GalaxyObjectsTestBase):
+
+    def test_get(self):
+        job_prevs = self.gi.jobs.get_previews()
+        if len(job_prevs) > 0:
+            job_prev = job_prevs[0]
+            self.assertIsInstance(job_prev, wrappers.JobPreview)
+            job = self.gi.jobs.get(job_prev.id)
+            self.assertIsInstance(job, wrappers.Job)
+            self.assertEqual(job.id, job_prev.id)
+        for job in self.gi.jobs.list():
+            self.assertIsInstance(job, wrappers.Job)
+
+
+def suite():
+    loader = unittest.TestLoader()
+    s = unittest.TestSuite()
+    s.addTests([loader.loadTestsFromTestCase(c) for c in (
+        TestWrapper,
+        TestWorkflow,
+        TestGalaxyInstance,
+        TestLibrary,
+        TestLDContents,
+        TestHistory,
+        TestHDAContents,
+        TestRunWorkflow,
+    )])
+    return s
+
+
+if __name__ == '__main__':
+    tests = suite()
+    RUNNER = unittest.TextTestRunner(verbosity=2)
+    RUNNER.run(tests)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyQuotas.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyQuotas.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,55 @@
+import uuid
+
+from . import GalaxyTestBase
+
+
+class TestGalaxyQuotas(GalaxyTestBase.GalaxyTestBase):
+
+    def setUp(self):
+        super().setUp()
+        # Quota names must be unique, and they're impossible to delete
+        # without accessing the database.
+        self.quota_name = 'BioBlend-Test-Quota-%s' % uuid.uuid4().hex
+        self.quota = self.gi.quotas.create_quota(
+            self.quota_name, 'testing', '100 GB', '=',
+            default='registered'
+        )
+
+    def tearDown(self):
+        self.gi.quotas.update_quota(self.quota['id'], default='registered')
+        self.gi.quotas.update_quota(self.quota['id'], default='no')
+        self.gi.quotas.delete_quota(self.quota['id'])
+
+    def test_create_quota(self):
+        quota = self.gi.quotas.show_quota(self.quota['id'])
+        self.assertEqual(quota['name'], self.quota_name)
+        self.assertEqual(quota['bytes'], 107374182400)
+        self.assertEqual(quota['operation'], '=')
+        self.assertEqual(quota['description'], 'testing')
+
+    def test_get_quotas(self):
+        quotas = self.gi.quotas.get_quotas()
+        self.assertIn(self.quota['id'], [quota['id'] for quota in quotas])
+
+    def test_update_quota(self):
+        response = self.gi.quotas.update_quota(
+            self.quota['id'], name=self.quota_name + '-new',
+            description='asdf', default='registered', operation='-',
+            amount='.01 TB'
+        )
+        self.assertIn(f"""Quota '{self.quota_name}' has been renamed to '{self.quota_name}-new'""", response)
+
+        quota = self.gi.quotas.show_quota(self.quota['id'])
+        self.assertEqual(quota['name'], self.quota_name + '-new')
+        self.assertEqual(quota['bytes'], 10995116277)
+        self.assertEqual(quota['operation'], '-')
+        self.assertEqual(quota['description'], 'asdf')
+
+    def test_delete_undelete_quota(self):
+        self.gi.quotas.update_quota(
+            self.quota['id'], default='no'
+        )
+        response = self.gi.quotas.delete_quota(self.quota['id'])
+        self.assertEqual(response, 'Deleted 1 quotas: ' + self.quota_name)
+        response = self.gi.quotas.undelete_quota(self.quota['id'])
+        self.assertEqual(response, 'Undeleted 1 quotas: ' + self.quota_name)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyRoles.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyRoles.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,31 @@
+"""
+Tests the functionality of the Blend CloudMan API. These tests require working
+credentials to supported cloud infrastructure.
+"""
+import uuid
+
+from . import GalaxyTestBase
+
+
+class TestGalaxyRoles(GalaxyTestBase.GalaxyTestBase):
+
+    def setUp(self):
+        super().setUp()
+        self.name = 'test_%s' % uuid.uuid4().hex
+        self.description = 'automated test role'
+        self.role = self.gi.roles.create_role(self.name, self.description)
+
+    def tearDown(self):
+        # As of 2017/07/26, deleting a role is not possible through the API
+        pass
+
+    def test_get_roles(self):
+        roles = self.gi.roles.get_roles()
+        for role in roles:
+            self.assertIsNotNone(role['id'])
+            self.assertIsNotNone(role['name'])
+
+    def test_create_role(self):
+        self.assertEqual(self.role['name'], self.name)
+        self.assertEqual(self.role['description'], self.description)
+        self.assertIsNotNone(self.role['id'])
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyToolData.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyToolData.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,20 @@
+"""
+Tests the functionality of the Blend CloudMan API. These tests require working
+credentials to supported cloud infrastructure.
+"""
+from . import GalaxyTestBase
+
+
+class TestGalaxyToolData(GalaxyTestBase.GalaxyTestBase):
+
+    def test_get_data_tables(self):
+        tables = self.gi.tool_data.get_data_tables()
+        for table in tables:
+            self.assertIsNotNone(table['name'])
+
+    def test_show_data_table(self):
+        tables = self.gi.tool_data.get_data_tables()
+        table = self.gi.tool_data.show_data_table(tables[0]['name'])
+        self.assertIsNotNone(table['columns'])
+        self.assertIsNotNone(table['fields'])
+        self.assertIsNotNone(table['name'])
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyToolInputs.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyToolInputs.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,45 @@
+from bioblend.galaxy.tools.inputs import (
+    conditional,
+    dataset,
+    inputs,
+    repeat,
+)
+
+
+def test_conditional():
+    # Build up example inputs for random_lines1
+    as_dict = inputs().set(
+        "num_lines", 5
+    ).set(
+        "input", dataset("encoded1")
+    ).set(
+        "seed_source", conditional().set(
+            "seed_source_selector", "set_seed"
+        ).set(
+            "seed", "asdf"
+        )
+    ).to_dict()
+    assert as_dict["num_lines"] == 5
+    assert as_dict["input"]["src"] == "hda"
+    assert as_dict["input"]["id"] == "encoded1"
+    assert as_dict["seed_source|seed_source_selector"] == "set_seed"
+    assert as_dict["seed_source|seed"] == "asdf"
+
+
+def test_repeat():
+    # Build up inputs for cat1
+    as_dict = inputs().set(
+        "input1", dataset("encoded1")
+    ).set(
+        "queries", repeat().instance(
+            inputs().set_dataset_param("input2", "encoded2")
+        ).instance(
+            inputs().set_dataset_param("input2", "encoded3")
+        )
+    ).to_dict()
+    assert as_dict["input1"]["src"] == "hda"
+    assert as_dict["input1"]["id"] == "encoded1"
+    assert as_dict["queries_0|input2"]["src"] == "hda"
+    assert as_dict["queries_0|input2"]["id"] == "encoded2"
+    assert as_dict["queries_1|input2"]["src"] == "hda"
+    assert as_dict["queries_1|input2"]["id"] == "encoded3"
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyTools.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyTools.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,151 @@
+"""
+"""
+import os
+
+from bioblend.galaxy.tools.inputs import (
+    conditional,
+    dataset,
+    inputs,
+    repeat,
+)
+from . import GalaxyTestBase, test_util
+
+
+class TestGalaxyTools(GalaxyTestBase.GalaxyTestBase):
+
+    def test_get_tools(self):
+        # Test requires target Galaxy is configured with at least one tool.
+        tools = self.gi.tools.get_tools()
+        self.assertGreater(len(tools), 0)
+        self.assertTrue(all(map(self._assert_is_tool_rep, tools)))
+
+    def test_get_tool_panel(self):
+        # Test requires target Galaxy is configured with at least one tool
+        # section.
+        tool_panel = self.gi.tools.get_tool_panel()
+        sections = [s for s in tool_panel if "elems" in s]
+        self.assertGreater(len(sections), 0)
+        self.assertTrue(all(map(self._assert_is_tool_rep, sections[0]["elems"])))
+
+    def _assert_is_tool_rep(self, data):
+        self.assertTrue(data["model_class"].endswith("Tool"))
+        # Special tools like SetMetadataTool may have different model_class
+        # than Tool - but they all seem to end in tool.
+
+        for key in ["name", "id", "version"]:
+            self.assertIn(key, data)
+        return True
+
+    def test_paste_content(self):
+        history = self.gi.histories.create_history(name="test_paste_data history")
+        paste_text = 'line 1\nline 2\rline 3\r\nline 4'
+        tool_output = self.gi.tools.paste_content(paste_text, history["id"])
+        self.assertEqual(len(tool_output["outputs"]), 1)
+        # All lines in the resulting dataset should end with "\n"
+        expected_contents = ("\n".join(paste_text.splitlines()) + "\n").encode()
+        self._wait_and_verify_dataset(tool_output['outputs'][0]['id'], expected_contents)
+        # Same with space_to_tab=True
+        tool_output = self.gi.tools.paste_content(paste_text, history["id"], space_to_tab=True)
+        self.assertEqual(len(tool_output["outputs"]), 1)
+        expected_contents = ("\n".join("\t".join(_.split()) for _ in paste_text.splitlines()) + "\n").encode()
+        self._wait_and_verify_dataset(tool_output['outputs'][0]['id'], expected_contents)
+
+    def test_upload_file(self):
+        history = self.gi.histories.create_history(name="test_upload_file history")
+
+        fn = test_util.get_abspath("test_util.py")
+        file_name = "test1"
+        tool_output = self.gi.tools.upload_file(
+            fn,
+            # First param could be a regular path also of course...
+            history_id=history["id"],
+            file_name=file_name,
+            dbkey="?",
+            file_type="txt",
+        )
+        self._wait_for_and_verify_upload(tool_output, file_name, fn, expected_dbkey="?")
+
+    def test_upload_file_dbkey(self):
+        history = self.gi.histories.create_history(name="test_upload_file history")
+        fn = test_util.get_abspath("test_util.py")
+        file_name = "test1"
+        dbkey = "hg19"
+        tool_output = self.gi.tools.upload_file(
+            fn,
+            history_id=history["id"],
+            file_name=file_name,
+            dbkey=dbkey,
+            file_type="txt",
+        )
+        self._wait_for_and_verify_upload(tool_output, file_name, fn, expected_dbkey=dbkey)
+
+    @test_util.skip_unless_tool("random_lines1")
+    def test_run_random_lines(self):
+        # Run second test case from randomlines.xml
+        history_id = self.gi.histories.create_history(name="test_run_random_lines history")["id"]
+        with open(test_util.get_abspath(os.path.join("data", "1.bed"))) as f:
+            contents = f.read()
+        dataset_id = self._test_dataset(history_id, contents=contents)
+        tool_inputs = inputs().set(
+            "num_lines", "1"
+        ).set(
+            "input", dataset(dataset_id)
+        ).set(
+            "seed_source", conditional().set(
+                "seed_source_selector", "set_seed"
+            ).set(
+                "seed", "asdf"
+            )
+        )
+        tool_output = self.gi.tools.run_tool(
+            history_id=history_id,
+            tool_id="random_lines1",
+            tool_inputs=tool_inputs
+        )
+        self.assertEqual(len(tool_output["outputs"]), 1)
+        # TODO: Wait for results and verify has 1 line and is
+        # chr5  131424298   131424460   CCDS4149.1_cds_0_0_chr5_131424299_f 0   +
+
+    @test_util.skip_unless_tool("cat1")
+    def test_run_cat1(self):
+        history_id = self.gi.histories.create_history(name="test_run_cat1 history")["id"]
+        dataset1_id = self._test_dataset(history_id, contents="1 2 3")
+        dataset2_id = self._test_dataset(history_id, contents="4 5 6")
+        dataset3_id = self._test_dataset(history_id, contents="7 8 9")
+        tool_inputs = inputs().set(
+            "input1", dataset(dataset1_id)
+        ).set(
+            "queries", repeat().instance(
+                inputs().set("input2", dataset(dataset2_id))
+            ).instance(
+                inputs().set("input2", dataset(dataset3_id))
+            )
+        )
+        tool_output = self.gi.tools.run_tool(
+            history_id=history_id,
+            tool_id="cat1",
+            tool_inputs=tool_inputs
+        )
+        self.assertEqual(len(tool_output["outputs"]), 1)
+        # TODO: Wait for results and verify it has 3 lines - 1 2 3, 4 5 6,
+        # and 7 8 9.
+
+    def test_tool_dependency_install(self):
+        installed_dependencies = self.gi.tools.install_dependencies('CONVERTER_fasta_to_bowtie_color_index')
+        self.assertTrue(any(True for d in installed_dependencies if d.get('name') == 'bowtie' and d.get('dependency_type') == 'conda'), "installed_dependencies is %s" % installed_dependencies)
+
+    @test_util.skip_unless_tool('CONVERTER_fasta_to_bowtie_color_index')
+    def test_tool_requirements(self):
+        tool_requirements = self.gi.tools.requirements('CONVERTER_fasta_to_bowtie_color_index')
+        self.assertTrue(
+            any(True for tr in tool_requirements if {'dependency_type', 'version'} <= set(tr.keys()) and tr.get('name') == 'bowtie'),
+            'tool_requirements is %s' % tool_requirements
+        )
+
+    def _wait_for_and_verify_upload(self, tool_output, file_name, fn, expected_dbkey="?"):
+        self.assertEqual(len(tool_output["outputs"]), 1)
+        output = tool_output['outputs'][0]
+        self.assertEqual(output['name'], file_name)
+        expected_contents = open(fn, "rb").read()
+        self._wait_and_verify_dataset(output["id"], expected_contents)
+        self.assertEqual(output["genome_build"], expected_dbkey)
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyUsers.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyUsers.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,83 @@
+"""
+Tests the functionality of the Blend CloudMan API. These tests require working
+credentials to supported cloud infrastructure.
+"""
+from . import GalaxyTestBase
+
+
+class TestGalaxyUsers(GalaxyTestBase.GalaxyTestBase):
+
+    def test_get_users(self):
+        users = self.gi.users.get_users()
+        for user in users:
+            self.assertIsNotNone(user['id'])
+            self.assertIsNotNone(user['email'])
+
+    def test_show_user(self):
+        current_user = self.gi.users.get_current_user()
+        user = self.gi.users.show_user(current_user['id'])
+        self.assertEqual(user['id'], current_user['id'])
+        self.assertEqual(user['username'], current_user['username'])
+        self.assertEqual(user['email'], current_user['email'])
+        # The 2 following tests randomly fail
+#        self.assertEqual(user['nice_total_disk_usage'], current_user['nice_total_disk_usage'])
+#        self.assertEqual(user['total_disk_usage'], current_user['total_disk_usage'])
+
+    def test_create_remote_user(self):
+        # WARNING: only admins can create users!
+        # WARNING: Users cannot be purged through the Galaxy API, so execute
+        # this test only on a disposable Galaxy instance!
+        if not self.gi.config.get_config()['use_remote_user']:
+            self.skipTest('This Galaxy instance is not configured to use remote users')
+        new_user_email = 'newuser@example.com'
+        user = self.gi.users.create_remote_user(new_user_email)
+        self.assertEqual(user['email'], new_user_email)
+        if self.gi.config.get_config()['allow_user_deletion']:
+            deleted_user = self.gi.users.delete_user(user['id'])
+            self.assertEqual(deleted_user['email'], new_user_email)
+            self.assertTrue(deleted_user['deleted'])
+
+    def test_create_local_user(self):
+        # WARNING: only admins can create users!
+        # WARNING: Users cannot be purged through the Galaxy API, so execute
+        # this test only on a disposable Galaxy instance!
+        if self.gi.config.get_config()['use_remote_user']:
+            self.skipTest('This Galaxy instance is not configured to use local users')
+        new_user_email = 'newuser@example.com'
+        user = self.gi.users.create_local_user('newuser', new_user_email, 'secret')
+        self.assertEqual(user['username'], 'newuser')
+        self.assertEqual(user['email'], new_user_email)
+        if self.gi.config.get_config()['allow_user_deletion']:
+            deleted_user = self.gi.users.delete_user(user['id'])
+            self.assertEqual(deleted_user['email'], new_user_email)
+            self.assertTrue(deleted_user['deleted'])
+
+    def test_get_current_user(self):
+        user = self.gi.users.get_current_user()
+        self.assertIsNotNone(user['id'])
+        self.assertIsNotNone(user['username'])
+        self.assertIsNotNone(user['email'])
+        self.assertIsNotNone(user['nice_total_disk_usage'])
+        self.assertIsNotNone(user['total_disk_usage'])
+
+    def test_update_user(self):
+        # WARNING: only admins can create users!
+        # WARNING: Users cannot be purged through the Galaxy API, so execute
+        # this test only on a disposable Galaxy instance!
+        if self.gi.config.get_config()['use_remote_user']:
+            self.skipTest('This Galaxy instance is not configured to use local users')
+        new_user_email = 'newuser2@example.com'
+        user = self.gi.users.create_local_user('newuser2', new_user_email, 'secret')
+        self.assertEqual(user['username'], 'newuser2')
+        self.assertEqual(user['email'], new_user_email)
+
+        updated_user_email = 'updateduser@example.com'
+        updated_username = 'updateduser'
+        user_id = user['id']
+        self.gi.users.update_user(user_id, username=updated_username, email=updated_user_email)
+        user = self.gi.users.show_user(user_id)
+        self.assertEqual(user['username'], updated_username)
+        self.assertEqual(user['email'], updated_user_email)
+
+        if self.gi.config.get_config()['allow_user_deletion']:
+            self.gi.users.delete_user(user['id'])
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyWorkflows.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/TestGalaxyWorkflows.py	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,209 @@
+import json
+import os
+import shutil
+import tempfile
+import time
+
+from . import GalaxyTestBase, test_util
+
+
+class TestGalaxyWorkflows(GalaxyTestBase.GalaxyTestBase):
+
+    @test_util.skip_unless_tool("cat1")
+    @test_util.skip_unless_tool("cat")
+    def test_workflow_scheduling(self):
+        path = test_util.get_abspath(os.path.join('data', 'test_workflow_pause.ga'))
+        workflow = self.gi.workflows.import_workflow_from_local_path(path)
+        workflow_id = workflow["id"]
+        history_id = self.gi.histories.create_history(name="TestWorkflowState")["id"]
+        dataset1_id = self._test_dataset(history_id)
+
+        invocations = self.gi.workflows.get_invocations(workflow_id)
+        self.assertEqual(len(invocations), 0)
+
+        invocation = self.gi.workflows.invoke_workflow(
+            workflow["id"],
+            inputs={"0": {"src": "hda", "id": dataset1_id}},
+        )
+        invocation_id = invocation["id"]
+        invocations = self.gi.workflows.get_invocations(workflow_id)
+        self.assertEqual(len(invocations), 1)
+        self.assertEqual(invocations[0]["id"], invocation_id)
+
+        def invocation_steps_by_order_index():
+            invocation = self.gi.workflows.show_invocation(workflow_id, invocation_id)
+            return {s["order_index"]: s for s in invocation["steps"]}
+
+        for _ in range(20):
+            if 2 in invocation_steps_by_order_index():
+                break
+            time.sleep(.5)
+
+        invocation = self.gi.workflows.show_invocation(workflow_id, invocation_id)
+        self.assertEqual(invocation['state'], "ready")
+
+        steps = invocation_steps_by_order_index()
+        pause_step = steps[2]
+        self.assertIsNone(
+            self.gi.workflows.show_invocation_step(workflow_id, invocation_id, pause_step["id"])["action"])
+        self.gi.workflows.run_invocation_step_action(workflow_id, invocation_id, pause_step["id"], action=True)
+        self.assertTrue(self.gi.workflows.show_invocation_step(workflow_id, invocation_id, pause_step["id"])["action"])
+        for _ in range(20):
+            invocation = self.gi.workflows.show_invocation(workflow_id, invocation_id)
+            if invocation["state"] == "scheduled":
+                break
+
+            time.sleep(.5)
+
+        invocation = self.gi.workflows.show_invocation(workflow_id, invocation_id)
+        self.assertEqual(invocation["state"], "scheduled")
+
+    @test_util.skip_unless_tool("cat1")
+    @test_util.skip_unless_tool("cat")
+    def test_cancelling_workflow_scheduling(self):
+        path = test_util.get_abspath(os.path.join('data', 'test_workflow_pause.ga'))
+        workflow = self.gi.workflows.import_workflow_from_local_path(path)
+        workflow_id = workflow["id"]
+        history_id = self.gi.histories.create_history(name="TestWorkflowState")["id"]
+        dataset1_id = self._test_dataset(history_id)
+
+        invocations = self.gi.workflows.get_invocations(workflow_id)
+        self.assertEqual(len(invocations), 0)
+
+        invocation = self.gi.workflows.invoke_workflow(
+            workflow["id"],
+            inputs={"0": {"src": "hda", "id": dataset1_id}},
+        )
+        invocation_id = invocation["id"]
+        invocations = self.gi.workflows.get_invocations(workflow_id)
+        self.assertEqual(len(invocations), 1)
+        self.assertEqual(invocations[0]["id"], invocation_id)
+
+        invocation = self.gi.workflows.show_invocation(workflow_id, invocation_id)
+        self.assertIn(invocation['state'], ['new', 'ready'])
+
+        self.gi.workflows.cancel_invocation(workflow_id, invocation_id)
+        invocation = self.gi.workflows.show_invocation(workflow_id, invocation_id)
+        self.assertEqual(invocation['state'], 'cancelled')
+
+    def test_import_export_workflow_from_local_path(self):
+        with self.assertRaises(Exception):
+            self.gi.workflows.import_workflow_from_local_path(None)
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        imported_wf = self.gi.workflows.import_workflow_from_local_path(path)
+        self.assertIsInstance(imported_wf, dict)
+        self.assertEqual(imported_wf['name'], 'paste_columns')
+        self.assertTrue(imported_wf['url'].startswith('/api/workflows/'))
+        self.assertFalse(imported_wf['deleted'])
+        self.assertFalse(imported_wf['published'])
+        with self.assertRaises(Exception):
+            self.gi.workflows.export_workflow_to_local_path(None, None, None)
+        export_dir = tempfile.mkdtemp(prefix='bioblend_test_')
+        try:
+            self.gi.workflows.export_workflow_to_local_path(imported_wf['id'], export_dir)
+            dir_contents = os.listdir(export_dir)
+            self.assertEqual(len(dir_contents), 1)
+            export_path = os.path.join(export_dir, dir_contents[0])
+            with open(export_path) as f:
+                exported_wf_dict = json.load(f)
+        finally:
+            shutil.rmtree(export_dir)
+        self.assertIsInstance(exported_wf_dict, dict)
+
+    def test_import_publish_workflow_from_local_path(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        imported_wf = self.gi.workflows.import_workflow_from_local_path(path, publish=True)
+        self.assertIsInstance(imported_wf, dict)
+        self.assertFalse(imported_wf['deleted'])
+        self.assertTrue(imported_wf['published'])
+
+    def test_import_export_workflow_dict(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        with open(path) as f:
+            wf_dict = json.load(f)
+        imported_wf = self.gi.workflows.import_workflow_dict(wf_dict)
+        self.assertIsInstance(imported_wf, dict)
+        self.assertEqual(imported_wf['name'], 'paste_columns')
+        self.assertTrue(imported_wf['url'].startswith('/api/workflows/'))
+        self.assertFalse(imported_wf['deleted'])
+        self.assertFalse(imported_wf['published'])
+        exported_wf_dict = self.gi.workflows.export_workflow_dict(imported_wf['id'])
+        self.assertIsInstance(exported_wf_dict, dict)
+
+    def test_import_publish_workflow_dict(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        with open(path) as f:
+            wf_dict = json.load(f)
+        imported_wf = self.gi.workflows.import_workflow_dict(wf_dict, publish=True)
+        self.assertIsInstance(imported_wf, dict)
+        self.assertFalse(imported_wf['deleted'])
+        self.assertTrue(imported_wf['published'])
+
+    def test_get_workflows(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        wf = self.gi.workflows.import_workflow_from_local_path(path)
+        all_wfs = self.gi.workflows.get_workflows()
+        self.assertGreater(len(all_wfs), 0)
+        wf_data = self.gi.workflows.get_workflows(workflow_id=wf['id'])[0]
+        self.assertEqual(wf['id'], wf_data['id'])
+        self.assertEqual(wf['name'], wf_data['name'])
+        self.assertEqual(wf['url'], wf_data['url'])
+        wf_data_list = self.gi.workflows.get_workflows(name=wf['name'])
+        self.assertTrue(any(_['id'] == wf['id'] for _ in wf_data_list))
+
+    def test_show_workflow(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        wf = self.gi.workflows.import_workflow_from_local_path(path)
+        wf_data = self.gi.workflows.show_workflow(wf['id'])
+        self.assertEqual(wf_data['id'], wf['id'])
+        self.assertEqual(wf_data['name'], wf['name'])
+        self.assertEqual(wf_data['url'], wf['url'])
+        self.assertEqual(len(wf_data['steps']), 3)
+        self.assertIsNotNone(wf_data['inputs'])
+
+    @test_util.skip_unless_galaxy('release_18.05')
+    def test_update_workflow_name(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        wf = self.gi.workflows.import_workflow_from_local_path(path)
+        new_name = 'new name'
+        updated_wf = self.gi.workflows.update_workflow(wf['id'], name=new_name)
+        self.assertEqual(updated_wf['name'], new_name)
+
+    @test_util.skip_unless_galaxy('release_19.09')  # due to Galaxy bug fixed in https://github.com/galaxyproject/galaxy/pull/9014
+    def test_show_workflow_versions(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        wf = self.gi.workflows.import_workflow_from_local_path(path)
+        wf_data = self.gi.workflows.show_workflow(wf['id'])
+        self.assertEqual(wf_data['version'], 0)
+        new_name = 'new name'
+        self.gi.workflows.update_workflow(wf['id'], name=new_name)
+        updated_wf = self.gi.workflows.show_workflow(wf['id'])
+        self.assertEqual(updated_wf['name'], new_name)
+        self.assertEqual(updated_wf['version'], 1)
+        updated_wf = self.gi.workflows.show_workflow(wf['id'], version=0)
+        self.assertEqual(updated_wf['name'], 'paste_columns')
+        self.assertEqual(updated_wf['version'], 0)
+        updated_wf = self.gi.workflows.show_workflow(wf['id'], version=1)
+        self.assertEqual(updated_wf['name'], new_name)
+        self.assertEqual(updated_wf['version'], 1)
+
+    def test_run_workflow(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        wf = self.gi.workflows.import_workflow_from_local_path(path)
+        # Try invalid run of workflow
+        with self.assertRaises(Exception):
+            self.gi.workflows.run_workflow(wf['id'], None)
+
+    def test_invoke_workflow(self):
+        path = test_util.get_abspath(os.path.join('data', 'paste_columns.ga'))
+        wf = self.gi.workflows.import_workflow_from_local_path(path)
+        history_id = self.gi.histories.create_history(name="test_wf_invocation")['id']
+        dataset1_id = self._test_dataset(history_id)
+        dataset = {'src': 'hda', 'id': dataset1_id}
+        invoke_response = self.gi.workflows.invoke_workflow(
+            wf['id'],
+            inputs={'Input 1': dataset, 'Input 2': dataset},
+            history_id=history_id,
+            inputs_by='name',
+        )
+        assert invoke_response['state'] == 'new', invoke_response
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__init__.py
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/CloudmanTestBase.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/CloudmanTestBase.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/GalaxyTestBase.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/GalaxyTestBase.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestCloudmanLaunch.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestCloudmanLaunch.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestCloudmanMock.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestCloudmanMock.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestCloudmanServices.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestCloudmanServices.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyDatasetCollections.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyDatasetCollections.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyDatasets.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyDatasets.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyFolders.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyFolders.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyGroups.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyGroups.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyHistories.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyHistories.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyInstance.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyInstance.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyInvocations.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyInvocations.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyJobs.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyJobs.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyLibraries.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyLibraries.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyObjects.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyObjects.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyQuotas.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyQuotas.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyRoles.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyRoles.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyToolData.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyToolData.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyToolInputs.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyToolInputs.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyTools.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyTools.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyUsers.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyUsers.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyWorkflows.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/TestGalaxyWorkflows.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/__init__.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/__init__.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/pytest_galaxy_test_wrapper.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/pytest_galaxy_test_wrapper.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/test_util.cpython-39.pyc
Binary file env/lib/python3.9/site-packages/bioblend/_tests/__pycache__/test_util.cpython-39.pyc has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/data/1.bed
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/data/1.bed	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,65 @@
+chr1	147962192	147962580	CCDS989.1_cds_0_0_chr1_147962193_r	0	-
+chr1	147984545	147984630	CCDS990.1_cds_0_0_chr1_147984546_f	0	+
+chr1	148078400	148078582	CCDS993.1_cds_0_0_chr1_148078401_r	0	-
+chr1	148185136	148185276	CCDS996.1_cds_0_0_chr1_148185137_f	0	+
+chr10	55251623	55253124	CCDS7248.1_cds_0_0_chr10_55251624_r	0	-
+chr11	116124407	116124501	CCDS8374.1_cds_0_0_chr11_116124408_r	0	-
+chr11	116206508	116206563	CCDS8377.1_cds_0_0_chr11_116206509_f	0	+
+chr11	116211733	116212337	CCDS8378.1_cds_0_0_chr11_116211734_r	0	-
+chr11	1812377	1812407	CCDS7726.1_cds_0_0_chr11_1812378_f	0	+
+chr12	38440094	38440321	CCDS8736.1_cds_0_0_chr12_38440095_r	0	-
+chr13	112381694	112381953	CCDS9526.1_cds_0_0_chr13_112381695_f	0	+
+chr14	98710240	98712285	CCDS9949.1_cds_0_0_chr14_98710241_r	0	-
+chr15	41486872	41487060	CCDS10096.1_cds_0_0_chr15_41486873_r	0	-
+chr15	41673708	41673857	CCDS10097.1_cds_0_0_chr15_41673709_f	0	+
+chr15	41679161	41679250	CCDS10098.1_cds_0_0_chr15_41679162_r	0	-
+chr15	41826029	41826196	CCDS10101.1_cds_0_0_chr15_41826030_f	0	+
+chr16	142908	143003	CCDS10397.1_cds_0_0_chr16_142909_f	0	+
+chr16	179963	180135	CCDS10401.1_cds_0_0_chr16_179964_r	0	-
+chr16	244413	244681	CCDS10402.1_cds_0_0_chr16_244414_f	0	+
+chr16	259268	259383	CCDS10403.1_cds_0_0_chr16_259269_r	0	-
+chr18	23786114	23786321	CCDS11891.1_cds_0_0_chr18_23786115_r	0	-
+chr18	59406881	59407046	CCDS11985.1_cds_0_0_chr18_59406882_f	0	+
+chr18	59455932	59456337	CCDS11986.1_cds_0_0_chr18_59455933_r	0	-
+chr18	59600586	59600754	CCDS11988.1_cds_0_0_chr18_59600587_f	0	+
+chr19	59068595	59069564	CCDS12866.1_cds_0_0_chr19_59068596_f	0	+
+chr19	59236026	59236146	CCDS12872.1_cds_0_0_chr19_59236027_r	0	-
+chr19	59297998	59298008	CCDS12877.1_cds_0_0_chr19_59297999_f	0	+
+chr19	59302168	59302288	CCDS12878.1_cds_0_0_chr19_59302169_r	0	-
+chr2	118288583	118288668	CCDS2120.1_cds_0_0_chr2_118288584_f	0	+
+chr2	118394148	118394202	CCDS2121.1_cds_0_0_chr2_118394149_r	0	-
+chr2	220190202	220190242	CCDS2441.1_cds_0_0_chr2_220190203_f	0	+
+chr2	220229609	220230869	CCDS2443.1_cds_0_0_chr2_220229610_r	0	-
+chr20	33330413	33330423	CCDS13249.1_cds_0_0_chr20_33330414_r	0	-
+chr20	33513606	33513792	CCDS13255.1_cds_0_0_chr20_33513607_f	0	+
+chr20	33579500	33579527	CCDS13256.1_cds_0_0_chr20_33579501_r	0	-
+chr20	33593260	33593348	CCDS13257.1_cds_0_0_chr20_33593261_f	0	+
+chr21	32707032	32707192	CCDS13614.1_cds_0_0_chr21_32707033_f	0	+
+chr21	32869641	32870022	CCDS13615.1_cds_0_0_chr21_32869642_r	0	-
+chr21	33321040	33322012	CCDS13620.1_cds_0_0_chr21_33321041_f	0	+
+chr21	33744994	33745040	CCDS13625.1_cds_0_0_chr21_33744995_r	0	-
+chr22	30120223	30120265	CCDS13897.1_cds_0_0_chr22_30120224_f	0	+
+chr22	30160419	30160661	CCDS13898.1_cds_0_0_chr22_30160420_r	0	-
+chr22	30665273	30665360	CCDS13901.1_cds_0_0_chr22_30665274_f	0	+
+chr22	30939054	30939266	CCDS13903.1_cds_0_0_chr22_30939055_r	0	-
+chr5	131424298	131424460	CCDS4149.1_cds_0_0_chr5_131424299_f	0	+
+chr5	131556601	131556672	CCDS4151.1_cds_0_0_chr5_131556602_r	0	-
+chr5	131621326	131621419	CCDS4152.1_cds_0_0_chr5_131621327_f	0	+
+chr5	131847541	131847666	CCDS4155.1_cds_0_0_chr5_131847542_r	0	-
+chr6	108299600	108299744	CCDS5061.1_cds_0_0_chr6_108299601_r	0	-
+chr6	108594662	108594687	CCDS5063.1_cds_0_0_chr6_108594663_f	0	+
+chr6	108640045	108640151	CCDS5064.1_cds_0_0_chr6_108640046_r	0	-
+chr6	108722976	108723115	CCDS5067.1_cds_0_0_chr6_108722977_f	0	+
+chr7	113660517	113660685	CCDS5760.1_cds_0_0_chr7_113660518_f	0	+
+chr7	116512159	116512389	CCDS5771.1_cds_0_0_chr7_116512160_r	0	-
+chr7	116714099	116714152	CCDS5773.1_cds_0_0_chr7_116714100_f	0	+
+chr7	116945541	116945787	CCDS5774.1_cds_0_0_chr7_116945542_r	0	-
+chr8	118881131	118881317	CCDS6324.1_cds_0_0_chr8_118881132_r	0	-
+chr9	128764156	128764189	CCDS6914.1_cds_0_0_chr9_128764157_f	0	+
+chr9	128787519	128789136	CCDS6915.1_cds_0_0_chr9_128787520_r	0	-
+chr9	128882427	128882523	CCDS6917.1_cds_0_0_chr9_128882428_f	0	+
+chr9	128937229	128937445	CCDS6919.1_cds_0_0_chr9_128937230_r	0	-
+chrX	122745047	122745924	CCDS14606.1_cds_0_0_chrX_122745048_f	0	+
+chrX	152648964	152649196	CCDS14733.1_cds_0_0_chrX_152648965_r	0	-
+chrX	152691446	152691471	CCDS14735.1_cds_0_0_chrX_152691447_f	0	+
+chrX	152694029	152694263	CCDS14736.1_cds_0_0_chrX_152694030_r	0	-
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/data/Galaxy-History-test.tar.gz
Binary file env/lib/python3.9/site-packages/bioblend/_tests/data/Galaxy-History-test.tar.gz has changed
diff -r 000000000000 -r 4f3585e2f14b env/lib/python3.9/site-packages/bioblend/_tests/data/paste_columns.ga
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.9/site-packages/bioblend/_tests/data/paste_columns.ga	Mon Mar 22 18:12:50 2021 +0000
@@ -0,0 +1,87 @@
+{
+    "a_galaxy_workflow": "true",
+    "annotation": "",
+    "format-version": "0.1",
+    "name": "paste_columns",
+    "steps": {
+        "0": {
+            "annotation": "",
+            "id": 0,
+            "input_