diff --git a/AAI.py b/AAI.py
new file mode 100755
index 0000000..bec794d
--- /dev/null
+++ b/AAI.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+
+import os
+from argparse import ArgumentParser
+from glob import glob
+from numpy import mean, std
+from subprocess import Popen
+from sys import exit
+from time import strftime
+
+def parseArgs():
+	parser = ArgumentParser(description='Computes the average amino acid '
+			'identity (AAI) between two protein sets', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-1', '--set1', required=True, metavar='FILE',
+		help='first input FastA sequence file')
+	req.add_argument('-2', '--set2', required=True, metavar='FILE',
+		help='second input FastA sequence file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--cpus', type=str, metavar='INT',
+		default='1', help='number of CPUs [1]')
+	opt.add_argument('-f', '--fraction', type=float, metavar='FLOAT',
+		default=70.0, help='minimum alignment length percentage [70.0]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-i', '--identity', type=float, metavar='FLOAT',
+		default=30.0, help='minimum percent identity [30.0]')
+	opt.add_argument('-l', '--length', type=int, metavar='INT',
+		default=0, help='minimum alignment character length (sum of all '
+		'aligned segments and all gaps) [0]')
+	opt.add_argument('-o', '--outpath', metavar='PATH',
+		default=None, help='output directory [./AAI--<date>_<time>]')
+	opt.add_argument('-s', '--bitscore', type=float, metavar='FLOAT',
+		default=0.0, help='minimum alignment Bit score [0.0]')
+	opt.add_argument('--refilter', default=False, action='store_true',
+		help='skip blast system commands and re-filter previously generated '
+		'blast output from this script with different cutoff parameters, '
+		'which overwrites loci and stats output')
+	return parser.parse_args()
+
+def main():
+	opts = parseArgs()
+	set1 = os.path.abspath(opts.set1)
+	set2 = os.path.abspath(opts.set2)
+	if opts.outpath is not None:
+		outpath = os.path.abspath(opts.outpath)
+	else:
+		autocreated_dirname = 'AAI--' + strftime('%d%b%Y_%-I:%M%p').upper()
+		outpath = os.path.join(os.getcwd(), autocreated_dirname)
+	if not os.path.exists(outpath):
+		os.mkdir(outpath)
+
+	if not opts.refilter:
+		# Execute bidirectional blast
+		for s1, s2 in [(set1, set2), (set2, set1)]:  #s1 as subj; s2 as query
+			s1b = os.path.basename(s1).rsplit('.')[0]
+			s2b = os.path.basename(s2).rsplit('.')[0]
+			c1 = ['makeblastdb', '-in', s1, '-input_type', 'fasta',
+				'-out', os.path.join(outpath, s1b), '-dbtype', 'prot']
+			c2 = ['blastp', '-db', os.path.join(outpath, s1b), '-max_hsps', '1',
+				'-query', s2, '-max_target_seqs', '1', '-num_threads', opts.cpus,
+				'-out', os.path.join(outpath, 'blast.'+s1b+','+s2b+'.tab'),
+				'-outfmt', '6 qseqid sseqid pident length bitscore qcovhsp']
+			for cmd in [c1, c2]:
+				with open(os.devnull, 'wb') as dump:
+					return_code = Popen(cmd, shell=False, stdout=dump)
+					if return_code.wait() != 0:
+						exit('ERROR: failed sys call\n{}'.format(' '.join(cmd)))
+		junk = []
+		for ext in ['*.[np]hr', '*.[np]in', '*.[np]sq']:
+			junk.extend(list(glob(os.path.join(outpath, ext))))
+		for j in junk:
+			os.remove(j)
+
+	# Parse blast output
+	aai1, d1 = [], {}
+	tot1, filt1 = 0, 0
+	with open(os.path.join(outpath, 'blast.'+s2b+','+s1b+'.tab')) as dat:
+		for line in dat:
+			tot1 += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[4])>=opts.bitscore and float(l[5])>=opts.fraction:
+				d1[(str(l[0]), str(l[1]))] = (l[2], l[3], l[4])
+				filt1 += 1
+				aai1.append(float(l[2]))
+	tot2, filt2 = 0, 0
+	aai2, twoway = [], []
+	with open(os.path.join(outpath, 'blast.'+s1b+','+s2b+'.tab')) as dat, \
+	open(os.path.join(outpath, 'aai.'+s2b+','+s1b+'.loci.tab'), 'w') as loci:
+		for line in dat:
+			tot2 += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[4])>=opts.bitscore and float(l[5])>=opts.fraction:
+				filt2 += 1
+				aai2.append(float(l[2]))
+				if (str(l[1]), str(l[0])) in d1:
+					loci.write(l[0]+'\t'+l[1]+'\n')
+					twoway.extend([float(l[2]),
+									float(d1[str(l[1]), str(l[0])][0])])
+	# Write AAI data
+	with open(os.path.join(outpath, 'aai.'+s2b+','+s1b+'.stats.tab'), 'w') as aai:
+		aai.write('Sample(s)\tFiltered\tAAI\tStandard_Deviation\n')
+		aai.write('{},{}\t{}/{}\t{}%\t{}%\n'.format(s2b, s1b, len(twoway),
+			tot1+tot2, round(mean(twoway), 3), round(std(twoway), 3)))
+		aai.write('{}\t{}/{}\t{}%\t{}%\n'.format(s2b, filt1, tot1,
+			round(mean(aai1), 3), round(std(aai1), 3)))
+		aai.write('{}\t{}/{}\t{}%\t{}%\n'.format(s1b, filt2, tot2,
+			round(mean(aai2), 3), round(std(aai2), 3)))
+
+if __name__ == '__main__':
+	main()
diff --git a/AAIb+.py b/AAIb+.py
new file mode 100755
index 0000000..5fec90f
--- /dev/null
+++ b/AAIb+.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python
+
+__version__ = '1.0.1'
+
+
+import gzip
+import os
+import shutil
+import sys
+import subprocess as sp
+from argparse import ArgumentParser
+from collections import Counter
+from glob import glob
+from multiprocessing import cpu_count
+from tempfile import mkdtemp
+from time import strftime
+
+from Bio import SeqIO
+from Bio.Alphabet import IUPAC, generic_dna
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+from numpy import mean, std
+
+def parseArgs():
+	parser = ArgumentParser(description='Computes the average amino acid '
+			'identity (AAI) between two protein sets', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-1', '--set1', required=True, metavar='FILE',
+		help='first input FastA or GenBank file '
+		'(optionally gunzip compressed)')
+	req.add_argument('-2', '--set2', required=True, metavar='FILE',
+		help='second input FastA or GenBank file '
+		'(optionally gunzip compressed)')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--cpus', type=require_int_nonnegative,
+		metavar='INT', default='0', help='number of CPUs [all]')
+	opt.add_argument('-f', '--fraction', type=float, metavar='FLOAT',
+		default=70.0, help='minimum alignment length percentage [70.0]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-i', '--identity', type=require_float_0_to_100,
+		metavar='FLOAT', default=30.0, help='minimum percent identity [30.0]')
+	opt.add_argument('-l', '--length', type=int, metavar='INT',
+		default=0, help='minimum alignment character length (sum of all '
+		'aligned segments and all gaps) [0]')
+	opt.add_argument('-o', '--outpath', metavar='PATH',
+		default=None, help='output directory [AAI--<date>_<time>]')
+	opt.add_argument('-s', '--bitscore', type=float, metavar='FLOAT',
+		default=0.0, help='minimum alignment Bit score [0.0]')
+	opt.add_argument('--aligner', choices=['blastp', 'diamond'],
+		default='blastp', help='local protein aligner [blastp]')
+	opt.add_argument('--decimal-places', type=require_int_nonnegative,
+		metavar='INT', default=3, help='precision decimal points to round '
+		'AAI values [3]')
+	opt.add_argument('--max-ACGT', type=require_float_0_to_1,
+		metavar='FLOAT', default=0.9, help='input sequence sets above this '
+		'fraction of ACGT will be assumed to be nucleotides and AAI '
+		'skipped [0.9]')
+	opt.add_argument('--min-aln-frac', type=require_float_0_to_1,
+		metavar='FLOAT', default=0, help='minimum two-way alignment fraction '
+		'of each set [0.0]')
+	opt.add_argument('--min-aln-len', type=require_int_nonnegative,
+		metavar='INT', default=0, help='minimum two-way alignment length of '
+		'each set [0]')
+	opt.add_argument('--name1', type=str, metavar='STR', default=None,
+		help='identifier used for set1 output data [basename set1]')
+	opt.add_argument('--name2', type=str, metavar='STR', default=None,
+		help='identifier used for set2 output data [basename set2]')
+	opt.add_argument('--refilter', default=False, action='store_true',
+		help='skip alignment and re-filter previous search data with '
+		'different cutoff parameters; overwrites output [off]')
+	return parser.parse_args()
+
+def require_int_nonnegative(x):
+	try:
+		if int(x) < 0 or '.' in str(x):
+			sys.stderr.write('ERROR: {} must be a non-negative integer\n'.\
+				format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be an integer\n'.format(x))
+		sys.exit(1)
+	return int(x)
+
+def require_float_0_to_100(x):
+	try:
+		x = float(x)
+		if 0 < x > 100:
+			sys.stderr.write('ERROR: {} must be in 0, 100 range\n'.format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be a float\n'.format(x))
+		sys.exit(1)
+	return x
+
+def require_float_0_to_1(x):
+	try:
+		x = float(x)
+		if 0 < x > 1:
+			sys.stderr.write('ERROR: {} must be in 0, 1.0 range\n'.format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be a float\n'.format(x))
+		sys.exit(1)
+	return x
+
+def require_dependency(dep):
+	for path in os.environ.get('PATH', '').split(':'):
+		if os.path.exists(os.path.join(path, dep)) and \
+		not os.path.isdir(os.path.join(path, dep)):
+			return True
+	sys.stderr.write('ERROR: {} unavailable; not in $PATH\n'.format(dep))
+	sys.exit(1)
+
+def decompress_file(infile, outdir):
+	uncompressed_file = os.path.basename(infile).rstrip('.gz')
+	outfile = os.path.join(outdir, uncompressed_file)
+	with gzip.open(infile, 'rb') as ifh, open(outfile, 'wb') as ofh:
+		shutil.copyfileobj(ifh, ofh)
+	return outfile
+
+def genbank_to_faa(infile, outdir):
+	faa_file = os.path.basename(infile).rsplit('.', 1)[0] + '.faa'
+	outfile = os.path.join(outdir, faa_file)
+	records = []
+	for rec in SeqIO.parse(infile, 'genbank'):
+		for feat in rec.features:
+			if feat.type == 'CDS' and 'translation' in feat.qualifiers:
+				if len(feat.qualifiers['translation']) == 1:
+					new_rec = SeqRecord(Seq(feat.qualifiers['translation'][0],
+						IUPAC.protein), id=feat.qualifiers['locus_tag'][0],
+						description=rec.id)
+					records.append(new_rec)
+	with open(outfile, 'w') as ofh:
+		SeqIO.write(records, ofh, 'fasta')
+	return outfile
+
+def get_seqlen(infile):
+	seqlen = 0
+	for rec in SeqIO.parse(infile, 'fasta'):
+		seqlen += len(rec.seq)
+	return seqlen
+
+def verify_file_exists_and_nonempty(infile):
+	if os.path.exists(infile):
+		if os.stat(infile).st_size == 0:
+			sys.stderr.write('ERROR: {} file empty\n'.format(infile))
+			sys.exit(1)
+	else:
+		sys.stderr.write('ERROR: {} file absent\n'.format(infile))
+		sys.exit(1)
+
+def verify_protein_fasta_is_not_nucleotides(infile, max_acgt):
+	c, total_length = Counter(), 0
+	for rec in SeqIO.parse(infile, 'fasta'):
+		c += Counter(rec.seq.upper())
+		total_length += len(rec.seq)
+	observed_acgt_fraction = 1. * (c['A']+c['C']+c['G']+c['T']) / total_length
+	if observed_acgt_fraction > max_acgt:
+		sys.stderr.write('ERROR: {} exceeds {} maximum allowed A, C, G, T '
+			'composition. If {} is truly amino acids and not nucleotides, '
+			'adjust the --max-ACGT value to compute AAI.\n'.format(
+				observed_acgt_fraction, max_acgt, infile))
+		sys.exit(1)
+
+def count_fasta_records(infile):
+	return sum([1 for ln in open(infile).readlines() if ln.startswith('>')])
+
+def main():
+	opts = parseArgs()
+	require_dependency(opts.aligner)
+	if opts.aligner == 'blastp':
+		require_dependency('makeblastdb')
+
+	# I/O handling
+	if opts.cpus < 1:
+		cpus = str(cpu_count())
+	else:
+		cpus = str(opts.cpus)
+	dec_pts = opts.decimal_places
+	psize, aln_frc = (0, 0), (0, 0, (0, 0))
+	set1 = os.path.realpath(os.path.expanduser(opts.set1))
+	set2 = os.path.realpath(os.path.expanduser(opts.set2))
+	if opts.name1 is not None:
+		b1 = opts.name1
+	else:
+		b1 = os.path.basename(opts.set1).rstrip('.gz').rsplit('.', 1)[0]
+	if opts.name2 is not None:
+		b2 = opts.name2
+	else:
+		b2 = os.path.basename(opts.set2).rstrip('.gz').rsplit('.', 1)[0]
+	tmp = mkdtemp()
+	if opts.outpath is not None:
+		outpath = os.path.realpath(os.path.expanduser(opts.outpath))
+	else:
+		autocreated_dirname = 'AAI--' + strftime('%d%b%Y_%-I:%M:%S%p').upper()
+		outpath = os.path.join(os.getcwd(), autocreated_dirname)
+	if not os.path.exists(outpath):
+		os.mkdir(outpath)
+
+	if not opts.refilter:
+		# Automatically handle gunzip compression and GenBank format input
+		if set1.endswith('.gz'):
+			set1 = decompress_file(set1, tmp)
+		if set2.endswith('.gz'):
+			set2 = decompress_file(set2, tmp)
+		if set1.endswith(('.gbff', '.gbf', '.gbk', '.gb')):
+			set1 = genbank_to_faa(set1, tmp)
+		else:
+			verify_protein_fasta_is_not_nucleotides(set1, opts.max_ACGT)
+		if set2.endswith(('.gbff', '.gbf', '.gbk', '.gb')):
+			set2 = genbank_to_faa(set2, tmp)
+		else:
+			verify_protein_fasta_is_not_nucleotides(set2, opts.max_ACGT)
+
+		# Get input sequence lengths of proteomes
+		psize = (get_seqlen(set1), get_seqlen(set2))
+
+		# Execute bidirectional blast of proteins
+		for s1, s2, sb1, sb2 in [(set1, set2, b1, b2), (set2, set1, b2, b1)]:
+			aln = os.path.join(outpath, opts.aligner+'.' +sb1+','+sb2+ '.tab')
+			ref_db = os.path.join(tmp, sb1)
+			if opts.aligner == 'blastp':
+				c1 = ['makeblastdb', '-in', s1, '-out', ref_db, '-dbtype',
+					'prot']
+				c2 = ['blastp', '-db', ref_db, '-query', s2, '-max_hsps', '1',
+					'-max_target_seqs', '1', '-num_threads', cpus,
+					'-out', aln, '-outfmt', '6 qseqid sseqid pident length'
+					' mismatch gapopen qstart qend sstart send evalue'
+					' bitscore qcovhsp gaps']
+			elif opts.aligner == 'diamond':
+				c1 = ['diamond', 'makedb', '--in', s1, '--db', ref_db]
+				c2 = ['diamond', 'blastp', '--db', ref_db, '--query', s2,
+					'--max-hsps', '1', '--max-target-seqs', '1',
+					'--threads', cpus, '--out', aln, '--outfmt'] + \
+					('6 qseqid sseqid pident length mismatch gapopen qstart'
+					' qend sstart send evalue bitscore qcovhsp gaps').split()
+			for cmd in (c1, c2):
+				process = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE)
+				_, err = process.communicate()
+				if process.returncode != 0:
+					sys.stderr.write(err)
+					sys.stderr.write('ERROR: failed system call: {}\n'.\
+						format(' '.join(cmd)))
+					sys.exit(1)
+
+	# Parse alignment output
+	aai, tot, filt = [[] for _ in range(3)], Counter(), [[] for _ in range(3)]
+	# idx0 set1 qry, idx1 set2 qry, idx2 twoway
+	d = {} #filtered aln data
+	# d keys are (qseqid, sseqid), vals are (%ident, gapless_aln_len)
+
+	set1qry_base = os.path.join(outpath, opts.aligner + '.' + b2 + ',' + b1)
+	set2qry_base = os.path.join(outpath, opts.aligner + '.' + b1 + ',' + b2)
+	verify_file_exists_and_nonempty(set1qry_base + '.tab')
+	verify_file_exists_and_nonempty(set2qry_base + '.tab')
+
+	with open(set1qry_base + '.tab') as dat, \
+	open(set1qry_base + '.filt.tab', 'w') as passed:
+		for line in dat:
+			tot[0] += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[11])>=opts.bitscore and float(l[12])>=opts.fraction:
+				aai[0].append(float(l[2]))
+				aln_len = int(l[3]) - int(l[13])
+				d[(str(l[0]), str(l[1]))] = float(l[2]), aln_len
+				filt[0].append(aln_len)
+				passed.write(line)
+	with open(set2qry_base + '.tab') as dat, \
+	open(set2qry_base + '.filt.tab', 'w') as passed, \
+	open(set2qry_base + '.filt.two-way.tab', 'w') as passed2:
+		for line in dat:
+			tot[1] += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[11])>=opts.bitscore and float(l[12])>=opts.fraction:
+				aai[1].append(float(l[2]))
+				aln_len = int(l[3]) - int(l[13])
+				filt[1].append(aln_len)
+				passed.write(line)
+				pair = str(l[1]), str(l[0])
+				if pair in d:
+					aai[2].extend([float(l[2]), float(d[pair][0])])
+					filt[2].append(aln_len)
+					passed2.write(line)
+	if any(len(l) == 0 for l in aai + filt):
+		sys.stderr.write('ERROR: no alignments between sets.\n')
+		sys.exit(1)
+
+	# Calculate overall alignment (absolute and relative) values
+	if not opts.refilter:
+		set1_alnfrc = sum(filt[0]) / 1. / psize[0]
+		set2_alnfrc = sum(filt[1]) / 1. / psize[1]
+		bidirectional_alnfrc = (sum(filt[2]) / 1. / psize[0],
+			sum(filt[2]) / 1. / psize[1])
+		aln_frc = (set1_alnfrc, set2_alnfrc, bidirectional_alnfrc)
+		tot = count_fasta_records(set1), count_fasta_records(set2)
+	else:
+		sys.stderr.write('WARNING: Total protein counts, which are the '
+			'denominators in the second column output reported in the AAI '
+			'stats tab file, were estimated from the blast alignment data '
+			'files rather than from tallied input fragments. These values '
+			'are likely a underestimation.\n'
+			'WARNING: Proteome sizes and alignment fractions are reported as '
+			'0 and 0.0. Turn off --refilter to get usable values.\n')
+
+	# Optionally quit if low (absolute or relative) sequence alignment
+	if opts.min_aln_len > sum(filt[2]):
+		sys.stderr.write('ERROR: {} bi-directional (two-way) gapless '
+			'alignment length is less than {}\n'.format(sum(filt[2]),
+			opts.min_aln_len))
+		sys.exit(1)
+	if any(x < opts.min_aln_frac for x in aln_frc[2]):
+		sys.stderr.write('ERROR: {} and/or {} bi-directional (two-way) '
+			'gapless alignment fraction (relative to each input sequence '
+			'length) is less than {}\n'.format(aln_frc[2][0], aln_frc[2][1],
+			opts.min_aln_frac))
+		sys.exit(1)
+
+	# Write AAI data
+	with open(os.path.join(outpath, 'aai.'+b1+','+b2+'.stats.tab'), 'w') \
+	as ofh:
+		ofh.write('Query_Sample(s)\tFiltered_Proteins\tAAI\tStDev\t'
+			'Gapless_Aln\tInput_Size\tAln_Fraction\n')
+		ofh.write('{}\t{}/{}\t{:.{p}f}%\t{:.{p}f}%\t{}\t{}\t{:.{p}f}\n'.\
+			format(b1, len(filt[0]), tot[0], mean(aai[0]), std(aai[0]),
+			sum(filt[0]), psize[0], aln_frc[0], p=dec_pts))
+		ofh.write('{}\t{}/{}\t{:.{p}f}%\t{:.{p}f}%\t{}\t{}\t{:.{p}f}\n'.\
+			format(b2, len(filt[1]), tot[1], mean(aai[1]), std(aai[1]),
+			sum(filt[1]), psize[1], aln_frc[1], p=dec_pts))
+		ofh.write('{},{}\t{}/{},{}/{}\t{:.{p}f}%\t{:.{p}f}%\t{},{}\t{},{}\t'
+			'{:.{p}f},{:.{p}f}\n'.format(b1, b2, len(aai[2]) / 2, tot[0],
+			len(aai[2]) / 2, tot[1], mean(aai[2]), std(aai[2]),
+			sum(filt[2]), sum(filt[2]), psize[0], psize[1],
+			aln_frc[2][0], aln_frc[2][1], p=dec_pts))
+	shutil.rmtree(tmp)
+
+if __name__ == '__main__':
+	main()
diff --git a/ANI.py b/ANI.py
new file mode 100755
index 0000000..c658dd0
--- /dev/null
+++ b/ANI.py
@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+
+
+import os
+from argparse import ArgumentParser
+from collections import deque
+from itertools import islice
+from numpy import mean, std
+from shutil import rmtree
+from subprocess import Popen
+from sys import exit
+from tempfile import mkdtemp
+from time import strftime
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Computes the average nucleotide '
+	'identity (ANI) between two nucleic acid sequence sets', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-1', '--set1', required=True, metavar='FILE',
+		help='first input FastA sequence file')
+	req.add_argument('-2', '--set2', required=True, metavar='FILE',
+		help='second input FastA sequence file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--cpus', type=str, metavar='INT',
+		default='1', help='number of CPUs [1]')
+	opt.add_argument('-f', '--fraction', type=float, metavar='FLOAT',
+		default=70.0, help='minimum alignment length percentage [70.0]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-i', '--identity', type=float, metavar='FLOAT',
+		default=30.0, help='minimum percent identity [30.0]')
+	opt.add_argument('-j', '--fill', type=str, metavar='CHAR', default='', 
+		help='character to add to end of fragments that are less than the '
+		'window size to force them to be the same length; requires the -k '
+		'switch as well [None]')
+	opt.add_argument('-k', '--keep-small-frags', default=False,
+		action='store_true', help='keep remaining nucleotide sequences less '
+		' than the window size')
+	opt.add_argument('-l', '--length', type=int, metavar='INT',
+		default=0, help='minimum alignment character length (sum of all '
+		'aligned segments and all gaps) [0]')
+	opt.add_argument('-o', '--outpath', metavar='PATH',
+		default=None, help='output directory [./ANI--<date>_<time>]')
+	opt.add_argument('-s', '--step-size', type=int, metavar='INT',
+		default=200, help='nucleotide step size during sequence '
+		'fragmentation prior to BLAST alignments; to turn off steps to '
+		'speed up, set to same length as the fragment size [200]')
+	opt.add_argument('-w', '--fragment-size', type=int, metavar='INT',
+		default=1000, help='fragment lengths to slice nucleotide sequence '
+		'sets into prior to BLAST alignments [1000]')
+	opt.add_argument('--refilter', default=False, action='store_true',
+		help='skip blast system commands and re-filter previously generated '
+		'blast output from this script with different cutoff parameters, '
+		'which overwrites loci and stats output')
+	return parser.parse_args()
+
+def fragment(seq, win, step, fill):
+	iters = iter(seq)
+	q = deque(islice(iters, win), maxlen=win)
+	q.extend(fill for _ in range(win-len(q)))
+	while True:
+		yield q
+		q.append(next(iters))
+		q.extend(next(iters, fill) for _ in range(step-1))
+
+def main():
+	opts = parseArgs()
+	set1 = os.path.abspath(opts.set1)
+	set2 = os.path.abspath(opts.set2)
+	b1   = os.path.basename(set1).rsplit('.')[0]
+	b2   = os.path.basename(set2).rsplit('.')[0]
+	if opts.outpath is not None:
+		outpath = os.path.abspath(opts.outpath)
+	else:
+		autocreated_dirname = 'ANI--' + strftime('%d%b%Y_%-I:%M%p').upper()
+		outpath = os.path.join(os.getcwd(), autocreated_dirname)
+	if not os.path.exists(outpath):
+		os.mkdir(outpath)
+
+	if not opts.refilter:
+		# Fragment input sequences
+		tmp  = mkdtemp()
+		ifh1 = os.path.join(tmp, b1 + '.frags')
+		ifh2 = os.path.join(tmp, b2 + '.frags')
+		for f, s in [(ifh1, set1), (ifh2, set2)]:
+			with open(f, 'w') as ofh:
+				for rec in SeqIO.parse(s, 'fasta'):
+					i = 1
+					for frag in fragment(rec.seq, opts.fragment_size,
+					opts.step_size, opts.fill):
+						frag_seq = ''.join(list(frag))
+						if opts.keep_small_frags or \
+						len(frag_seq) == opts.fragment_size:
+							ofh.write('>{}\n{}\n'.format(
+								str(i) + '__' + rec.id, frag_seq))
+							i += 1
+
+		# Execute bidirectional blast
+		for s1, s2, sb1, sb2 in [(ifh1, ifh2, b1, b2), (ifh2, ifh1, b2, b1)]:
+			c1 = ['makeblastdb', '-in', s1, '-out', s1, '-dbtype', 'nucl']
+			c2 = ['blastn', '-db', s1, '-query', s2, '-dust', 'no',
+				'-max_hsps', '1', '-max_target_seqs', '1',
+				'-num_threads', opts.cpus, '-task', 'blastn',
+				'-outfmt', '6 qseqid sseqid pident length bitscore qcovhsp',
+				'-out', os.path.join(outpath, 'blast.'+sb1+','+sb2+'.tab')]
+			for cmd in [c1, c2]:
+				with open(os.devnull, 'wb') as dump:
+					return_code = Popen(cmd, shell=False, stdout=dump)
+					if return_code.wait() != 0:
+						exit('ERROR: failed sys call\n{}'.format(' '.join(cmd)))
+		rmtree(tmp)
+
+	# Parse blast output
+	ani1, d1 = [0], {}
+	tot1, filt1, len1 = 0, 0, 0 #counts for set1 as query
+	with open(os.path.join(outpath, 'blast.'+b2+','+b1+'.tab')) as dat:
+		for line in dat:
+			tot1 += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[5])>=opts.fraction:
+				d1[(str(l[0]), str(l[1]))] = (l[2], l[3], l[4])
+				filt1 += 1
+				len1  += int(l[3])
+				ani1.append(float(l[2]))
+	tot2, filt2, len2, twowaylen = 0, 0, 0, 0 #counts for set2 as query
+	ani2, twoway = [0], [0]
+	with open(os.path.join(outpath, 'blast.'+b1+','+b2+'.tab')) as dat:
+		for line in dat:
+			tot2 += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[5])>=opts.fraction:
+				filt2 += 1
+				len2  += int(l[3])
+				ani2.append(float(l[2]))
+				if (str(l[1]), str(l[0])) in d1:
+					twowaylen += int(l[3])
+					twoway.extend([float(l[2]),
+									float(d1[str(l[1]), str(l[0])][0])])
+	# Write ANI data
+	with open(os.path.join(outpath, 'ani.'+b1+','+b2+'.stats.tab'), 'w') \
+	as ani:
+		ani.write('Query_Sample(s)\tFiltered\tANI\tStandard_Deviation\t'
+			'Alignment\n')
+		ani.write('{},{}\t{}/{}\t{}%\t{}%\t{}\n'.format(b1, b2, len(twoway),
+			tot1+tot2, round(mean(twoway), 3), round(std(twoway), 3),
+			twowaylen))
+		ani.write('{}\t{}/{}\t{}%\t{}%\t{}\n'.format(b1, filt1, tot1,
+			round(mean(ani1), 3), round(std(ani1), 3), len1))
+		ani.write('{}\t{}/{}\t{}%\t{}%\t{}\n'.format(b2, filt2, tot2,
+			round(mean(ani2), 3), round(std(ani2), 3), len2))
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/ANIb+.py b/ANIb+.py
new file mode 100755
index 0000000..13d3b8d
--- /dev/null
+++ b/ANIb+.py
@@ -0,0 +1,406 @@
+#!/usr/bin/env python
+
+__version__ = '1.1.1b'
+
+
+import gzip
+import os
+import shutil
+import sys
+import subprocess as sp
+from argparse import ArgumentParser
+from collections import deque, Counter
+from itertools import islice
+from glob import glob
+from multiprocessing import cpu_count
+from tempfile import mkdtemp
+from time import strftime
+
+from Bio import SeqIO
+from Bio.SeqUtils import GC
+from numpy import mean, std
+
+def parseArgs():
+	parser = ArgumentParser(description='Computes the average nucleotide '
+		'identity (ANI) between two nucleic acid sequence sets with BLASTn',
+		add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-1', '--set1', required=True, metavar='FILE',
+		help='first input FastA or GenBank file '
+		'(optionally gunzip compressed)')
+	req.add_argument('-2', '--set2', required=True, metavar='FILE',
+		help='second input FastA or GenBank file '
+		'(optionally gunzip compressed)')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--cpus', type=require_int_nonnegative,
+		metavar='INT', default=0, help='number of CPUs [all]')
+	opt.add_argument('-f', '--fraction', type=require_float_0_to_100,
+		metavar='FLOAT', default=70.0, help='minimum fragment alignment '
+		'length percentage [70.0]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-i', '--identity', type=require_float_0_to_100,
+		metavar='FLOAT', default=30.0, help='minimum fragment alignment '
+		'identity [30.0]')
+	opt.add_argument('-l', '--length', type=require_int_nonnegative,
+		metavar='INT', default=0, help='minimum fragment alignment length '
+		'(incl gaps) [0]')
+	opt.add_argument('-o', '--outpath', type=str, metavar='PATH',
+		default=None, help='output directory [ANI--<date>_<time>]')
+	opt.add_argument('-s', '--step-size', type=require_int_positive,
+		metavar='INT', default=200, help='number of bases to shift during '
+		'sequence fragmentation prior to alignments; to turn off steps to '
+		'speed up, set to same length as the fragment size [200]')
+	opt.add_argument('-v', '--version', action='version',
+		version='%(prog)s v{}'.format(__version__))
+	opt.add_argument('-w', '--fragment-size', type=require_int_positive,
+		metavar='INT', default=1000, help='fragment lengths to slice '
+		'nucleotides into prior to alignments [1000]')
+	opt.add_argument('--bed', default=False, action='store_true',
+		help='produce BED files listing coordinates (0-based) used in ANI '
+		'calculation; requires Bedtools [off]')
+	opt.add_argument('--decimal-places', type=require_int_nonnegative,
+		metavar='INT', default=3, help='precision decimal points to round '
+		'ANI values [3]')
+	opt.add_argument('--fill', type=str, metavar='CHAR', default='',
+		help='character to add to end of fragments that are less than the '
+		'window size to force them to be the same length; turns on '
+		'--keep-small-frags [None]')
+	opt.add_argument('--keep-small-frags', default=False,
+		action='store_true', help='include the final fragment (less than the '
+		'window size) of each sequence record during alignment [off]')
+	opt.add_argument('--min-ACGT', type=require_float_0_to_1, metavar='FLOAT',
+		default=.97, help='minimum fraction of ACGT in each input set [0.97]')
+	opt.add_argument('--min-aln-frac', type=require_float_0_to_1,
+		metavar='FLOAT', default=0, help='minimum two-way alignment fraction '
+		'of each set [0.0]')
+	opt.add_argument('--min-aln-len', type=require_int_nonnegative,
+		metavar='INT', default=0, help='minimum two-way alignment length of '
+		'each set [0]')
+	opt.add_argument('--name1', type=str, metavar='STR', default=None,
+		help='identifier used for set1 output data [basename set1]')
+	opt.add_argument('--name2', type=str, metavar='STR', default=None,
+		help='identifier used for set2 output data [basename set2]')
+	opt.add_argument('--refilter', default=False, action='store_true',
+		help='skip BLASTn and re-filter previous alignment data with '
+		'different cutoff parameters; overwrites output [off]')
+	return parser.parse_args()
+
+def require_int_nonnegative(x):
+	try:
+		if int(x) < 0 or '.' in str(x):
+			sys.stderr.write('ERROR: {} must be a non-negative integer\n'.\
+				format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be an integer\n'.format(x))
+		sys.exit(1)
+	return int(x)
+
+def require_int_positive(x):
+	try:
+		if int(x) < 1 or '.' in str(x):
+			sys.stderr.write('ERROR: {} must be a positive integer\n'.\
+				format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be an integer\n'.format(x))
+		sys.exit(1)
+	return int(x)
+
+def require_float_0_to_100(x):
+	try:
+		x = float(x)
+		if 0 < x > 100:
+			sys.stderr.write('ERROR: {} must be in 0, 100 range\n'.format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be a float\n'.format(x))
+		sys.exit(1)
+	return x
+
+def require_float_0_to_1(x):
+	try:
+		x = float(x)
+		if 0 < x > 1:
+			sys.stderr.write('ERROR: {} must be in 0, 1.0 range\n'.format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be a float\n'.format(x))
+		sys.exit(1)
+	return x
+
+def require_dependency(dep):
+	for path in os.environ.get('PATH', '').split(':'):
+		if os.path.exists(os.path.join(path, dep)) and \
+		not os.path.isdir(os.path.join(path, dep)):
+			return True
+	sys.stderr.write('ERROR: {} unavailable; not in $PATH\n'.format(dep))
+	sys.exit(1)
+
+def decompress_file(infile, outdir):
+	uncompressed_file = os.path.basename(infile).rstrip('.gz')
+	outfile = os.path.join(outdir, uncompressed_file)
+	with gzip.open(infile, 'rb') as ifh, open(outfile, 'wb') as ofh:
+		shutil.copyfileobj(ifh, ofh)
+	return outfile
+
+def genbank_to_fasta(infile, outdir):
+	fasta_file = os.path.basename(infile).rsplit('.', 1)[0] + '.fa'
+	outfile = os.path.join(outdir, fasta_file)
+	records = []
+	for rec in SeqIO.parse(infile, 'genbank'):
+		if float(GC(rec.seq)) == 0:
+			sys.stderr.write('ERROR: {} appears to lack nucleotides'.\
+				format(rec.name))
+			sys.exit(1)
+		records.append(rec)
+	with open(outfile, 'w') as ofh:
+		SeqIO.write(records, ofh, 'fasta')
+	return outfile
+
+def get_seqlen_and_filter_ambiguous(infile, min_ACGT):
+	seqlen, c = 0, Counter()
+	for rec in SeqIO.parse(infile, 'fasta'):
+		seqlen += len(rec.seq)
+		c += Counter(list(rec.seq.upper()))
+	ACGT_fraction = float(c['A'] + c['C'] + c['G'] + c['T']) / seqlen
+	if ACGT_fraction < min_ACGT:
+		sys.stderr.write('ERROR: low composition ({:.1f}%) of unambiguous '
+			'nucleotides in {}\n'.format(ACGT_fraction * 100, 
+			os.path.basename(infile)))
+		sys.exit(1)
+	if ACGT_fraction != 1.:
+		sys.stderr.write('WARNING: {:.6f}% ambiguous nucleotides detected in '
+			'{}\n'.format(100 - ACGT_fraction*100, os.path.basename(infile)))
+	return seqlen
+
+def fragment(seq, win, step, fill):
+	iters = iter(seq)
+	q = deque(islice(iters, win), maxlen=win)
+	q.extend(fill for _ in range(win-len(q)))
+	while True:
+		yield q
+		q.append(next(iters))
+		q.extend(next(iters, fill) for _ in range(step-1))
+
+def parse_coords(seq_id, aln_coords, outfile):
+	hdr_name   = seq_id.split('__frg')[0]
+	hdr_coords = [int(s) for s in seq_id.split('__pos')[-1].split('-')]
+	aln_coords = [int(s) for s in aln_coords]
+	if aln_coords[1] < aln_coords[0]:
+		aln_coords[1], aln_coords[0] = aln_coords
+	start = aln_coords[0] + hdr_coords[0]
+	end   = aln_coords[1] + hdr_coords[0]
+	with open(outfile, 'a') as ofh:
+		ofh.write('{}\t{}\t{}\n'.format(hdr_name, start, end))
+
+def count_fasta_records(infile):
+	return sum([1 for ln in open(infile).readlines() if ln.startswith('>')])
+
+def main():
+	opts = parseArgs()
+	require_dependency('blastn')
+	require_dependency('makeblastdb')
+	if opts.bed:
+		require_dependency('bedtools')
+
+	# I/O handling
+	if opts.cpus < 1:
+		cpus = str(cpu_count())
+	else:
+		cpus = str(opts.cpus)
+	dec_pts = opts.decimal_places
+	gsize, aln_frc = (0, 0), (0, 0, (0, 0))
+	set1 = os.path.realpath(os.path.expanduser(opts.set1))
+	set2 = os.path.realpath(os.path.expanduser(opts.set2))
+	if opts.name1 is not None:
+		b1 = opts.name1
+	else:
+		b1 = os.path.basename(opts.set1).rstrip('.gz').rsplit('.', 1)[0]
+	if opts.name2 is not None:
+		b2 = opts.name2
+	else:
+		b2 = os.path.basename(opts.set2).rstrip('.gz').rsplit('.', 1)[0]
+	tmp = mkdtemp()
+	if opts.outpath is not None:
+		outpath = os.path.realpath(os.path.expanduser(opts.outpath))
+	else:
+		autocreated_dirname = 'ANI--' + strftime('%d%b%Y_%-I:%M:%S%p').upper()
+		outpath = os.path.join(os.getcwd(), autocreated_dirname)
+	if not os.path.exists(outpath):
+		os.mkdir(outpath)
+
+	if not opts.refilter:
+		keep_small_frags = opts.keep_small_frags
+		if len(opts.fill) > 0:
+			keep_small_frags = True
+
+		# Automatically handle gunzip compression and GenBank format input
+		if set1.endswith('.gz'):
+			set1 = decompress_file(set1, tmp)
+		if set2.endswith('.gz'):
+			set2 = decompress_file(set2, tmp)
+		if set1.endswith(('.gbff', '.gbf', '.gbk', '.gb')):
+			set1 = genbank_to_fasta(set1, tmp)
+		if set2.endswith(('.gbff', '.gbf', '.gbk', '.gb')):
+			set2 = genbank_to_fasta(set2, tmp)
+		
+		# Get input sequence lengths prior to fragmentation and
+		# quit if either input set lacks primarily A,C,G,T nucleotides
+		gsize = (get_seqlen_and_filter_ambiguous(set1, opts.min_ACGT),
+			get_seqlen_and_filter_ambiguous(set2, opts.min_ACGT))
+
+		# Fragment input sequences
+		if1 = os.path.join(tmp, b1 + '.frags')
+		if2 = os.path.join(tmp, b2 + '.frags')
+		for f, s in [(if1, set1), (if2, set2)]:
+			with open(f, 'w') as ofh:
+				for rec in SeqIO.parse(s, 'fasta'):
+					coord, i = 0, 1
+					for frag in fragment(rec.seq, opts.fragment_size,
+					opts.step_size, opts.fill):
+						frag_seq = ''.join(list(frag))
+						if keep_small_frags or \
+						len(frag_seq) == opts.fragment_size:
+							defln = ('{}__frg{}__pos{}-{}').format(rec.id, i,
+								coord, coord + opts.fragment_size)
+							ofh.write('>{}\n{}\n'.format(defln, frag_seq))
+							i += 1
+							coord += opts.step_size
+
+		# Align fragments
+		for s1, s2, sb1, sb2 in [(if1, if2, b1, b2), (if2, if1, b2, b1)]:
+			aln = os.path.join(outpath, 'blast.' + sb1 + ',' + sb2 + '.tab')
+			c1 = ['makeblastdb', '-in', s1, '-out', s1, '-dbtype', 'nucl']
+			c2 = ['blastn', '-db', s1, '-query', s2, '-dust', 'no',
+				'-max_hsps', '1', '-max_target_seqs', '1',
+				'-num_threads', cpus, '-task', 'blastn',
+				'-outfmt', '6 qseqid sseqid pident length mismatch gapopen'
+				' qstart qend sstart send evalue bitscore qcovhsp gaps',
+				'-out', aln]
+			for cmd in (c1, c2):
+				process = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE)
+				_, err = process.communicate()
+				if process.returncode != 0:
+					sys.stderr.write(err)
+					sys.stderr.write('ERROR: failed system call: {}\n'.\
+						format(' '.join(cmd)))
+					sys.exit(1)
+
+	# Parse blast output
+	ani, tot, filt = [[] for _ in range(3)], Counter(), [[] for _ in range(3)]
+	# idx0 set1 qry, idx1 set2 qry, idx2 twoway
+	d = {} #filtered aln data
+	# d keys are (qseqid, sseqid), vals are (%ident, gapless_aln_len)
+	b = os.path.join(outpath, 'blast.' + b2 + ',' + b1) #set1 as query
+	with open(b + '.tab') as dat, \
+	open(b + '.filt.tab', 'w') as passed:
+		for line in dat:
+			tot[0] += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[12])>=opts.fraction:
+				ani[0].append(float(l[2]))
+				aln_len = int(l[3]) - int(l[13])
+				d[(str(l[0]), str(l[1]))] = float(l[2]), aln_len
+				filt[0].append(aln_len)
+				passed.write(line)
+				if opts.bed:
+					parse_coords(l[0], (l[6], l[7]), os.path.join(tmp,
+						'coords.'+b1+'frags.'+b2+'ref,'+b1+'qry.bed'))
+					parse_coords(l[1], (l[8], l[9]), os.path.join(tmp,
+						'coords.'+b2+'frags.'+b2+'ref,'+b1+'qry.bed'))
+	b = os.path.join(outpath, 'blast.' + b1 + ',' + b2) #set2 as query
+	with open(b + '.tab') as dat, \
+	open(b + '.filt.tab', 'w') as passed, \
+	open(b + '.filt.two-way.tab', 'w') as passed2:
+		for line in dat:
+			tot[1] += 1
+			l = line.split('\t')
+			if float(l[2])>=opts.identity and int(l[3])>=opts.length \
+			and float(l[12])>=opts.fraction:
+				ani[1].append(float(l[2]))
+				aln_len = int(l[3]) - int(l[13])
+				filt[1].append(aln_len)
+				passed.write(line)
+				if opts.bed:
+					parse_coords(l[0], (l[6], l[7]), os.path.join(tmp,
+						'coords.'+b2+'frags.'+b1+'ref,'+b2+'qry.bed'))
+					parse_coords(l[1], (l[8], l[9]), os.path.join(tmp,
+						'coords.'+b1+'frags.'+b1+'ref,'+b2+'qry.bed'))
+				pair = str(l[1]), str(l[0])
+				if pair in d:
+					ani[2].extend([float(l[2]), float(d[pair][0])])
+					filt[2].append(aln_len)
+					passed2.write(line)
+					if opts.bed:
+						parse_coords(l[0], (l[6], l[7]), os.path.join(tmp,
+							'coords.'+b2+'frags.two-way.bed'))
+						parse_coords(l[1], (l[8], l[9]), os.path.join(tmp,
+							'coords.'+b1+'frags.two-way.bed'))
+	if any(len(l) == 0 for l in ani + filt):
+		sys.stderr.write('ERROR: no alignments between sets.\n')
+		sys.exit(1)
+
+	# Calculate overall alignment (absolute and relative) values
+	if not opts.refilter:
+		coverage = 1. * opts.fragment_size / opts.step_size
+		set1_alnfrc = sum(filt[0]) / coverage / gsize[0]
+		set2_alnfrc = sum(filt[1]) / coverage / gsize[1]
+		bidirectional_alnfrc = (sum(filt[2]) / coverage / gsize[0],
+			sum(filt[2]) / coverage / gsize[1])
+		aln_frc = (set1_alnfrc, set2_alnfrc, bidirectional_alnfrc)
+		tot = count_fasta_records(if1), count_fasta_records(if2)
+	else:
+		sys.stderr.write('WARNING: Total fragment counts, which are the '
+			'denominators in the second column output reported in the ANI '
+			'stats tab file, were estimated from the blast alignment data '
+			'files rather than from tallied input fragments. These values '
+			'are likely a underestimation.\n'
+			'WARNING: Genome sizes and alignment fractions are reported as '
+			'0 and 0.0. Turn off --refilter to get usable values.\n')
+
+	# Optionally quit if low (absolute or relative) sequence alignment
+	if opts.min_aln_len > sum(filt[2]):
+		sys.stderr.write('ERROR: {} bi-directional (two-way) gapless '
+			'alignment length is less than {}\n'.format(sum(filt[2]),
+			opts.min_aln_len))
+		sys.exit(1)
+	if any(x < opts.min_aln_frac for x in aln_frc[2]):
+		sys.stderr.write('ERROR: {} and/or {} bi-directional (two-way) '
+			'gapless alignment fraction (relative to each input sequence '
+			'length) is less than {}\n'.format(aln_frc[2][0], aln_frc[2][1],
+			opts.min_aln_frac))
+		sys.exit(1)
+
+	# Write ANI data
+	with open(os.path.join(outpath, 'ani.'+b1+','+b2+'.stats.tab'), 'w') \
+	as ofh:
+		ofh.write('Query_Sample(s)\tFiltered_Frags\tANI\tStDev\t'
+			'Gapless_Aln\tInput_Size\tAln_Fraction\n')
+		ofh.write('{}\t{}/{}\t{:.{p}f}%\t{:.{p}f}%\t{}\t{}\t{:.{p}f}\n'.\
+			format(b1, len(filt[0]), tot[0], mean(ani[0]), std(ani[0]),
+			sum(filt[0]), gsize[0], aln_frc[0], p=dec_pts))
+		ofh.write('{}\t{}/{}\t{:.{p}f}%\t{:.{p}f}%\t{}\t{}\t{:.{p}f}\n'.\
+			format(b2, len(filt[1]), tot[1], mean(ani[1]), std(ani[1]),
+			sum(filt[1]), gsize[1], aln_frc[1], p=dec_pts))
+		ofh.write('{},{}\t{}/{},{}/{}\t{:.{p}f}%\t{:.{p}f}%\t{},{}\t{},{}\t'
+			'{:.{p}f},{:.{p}f}\n'.format(b1, b2, len(ani[2]) / 2, tot[0],
+			len(ani[2]) / 2, tot[1], mean(ani[2]), std(ani[2]),
+			sum(filt[2]), sum(filt[2]), gsize[0], gsize[1],
+			aln_frc[2][0], aln_frc[2][1], p=dec_pts))
+
+	# Optionally produce BED files of coordinates used for ANI calculations
+	if opts.bed:
+		beds = glob(os.path.join(tmp, 'coords.*.bed'))
+		for f in beds:
+			srt = sp.Popen(['bedtools', 'sort', '-i', f], stdout=sp.PIPE)
+			mrg = sp.Popen(['bedtools', 'merge', '-i', 'stdin'],
+				stdin=srt.stdout, stdout=sp.PIPE)
+			with open(os.path.join(outpath, os.path.basename(f)), 'w') as ofh:
+				ret = sp.Popen(['sort', '-V'], stdin=mrg.stdout, stdout=ofh)
+	shutil.rmtree(tmp)
+
+if __name__ == '__main__':
+	main()
diff --git a/HMM.search.summarize.py b/HMM.search.summarize.py
new file mode 100755
index 0000000..a419b33
--- /dev/null
+++ b/HMM.search.summarize.py
@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+
+
+import os
+import string
+import sys
+from argparse import ArgumentParser
+from decimal import Decimal, ROUND_HALF_UP
+from subprocess import check_output, Popen
+from time import strftime
+from Bio import SeqIO
+from Bio.Alphabet import generic_dna
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def parseArgs():
+	parser = ArgumentParser(description='Extracts proteins from a FastA or GenBank proteome. Providing a GenBank file extracts both protein and gene sequence hits, whereas a FastA input only allows for protein extractions.',
+	epilog='Output directory structure: <outpath>/{indiv,log,sum}/<base>.<filenames>.<ext> Individually extracted loci are named <base>.<locus_tag>.<acc_in_db> with fsa extension for proteins and fas extension for genes. These are subsequently merged in the sum dir as <base>_found with faa extension for proteins and ffn extension for genes and summarized with a <base>.loci_abundance.tab file useful for plotting in R.')
+	parser.add_argument('-i', '--infile', required=True, help='input proteome FastA file <.faa> or GenBank file <.gb||.gbk> with translations')
+	parser.add_argument('-m', '--hmm', required=True, help='input HMM database file')
+	parser.add_argument('-b', '--base', required=False, default=None, help='prefix string to append to output files [`basename infile .<ext>`]')
+	parser.add_argument('-o', '--outpath', required=False, default=None, help='output directory  [./base--<date>_<time>]')
+	parser.add_argument('-c', '--cpus', required=False, type=int, default='1', help='number of CPUs [1]')
+	args = parser.parse_args()
+	return args
+
+def genbank2faa(in_queryfile, outpath):
+	if in_queryfile.endswith('.gb'):
+		proteome = os.path.basename(in_queryfile).replace('.gb', '.faa')
+	elif in_queryfile.endswith('.gbk'):
+		proteome = os.path.basename(in_queryfile).replace('.gbk', '.faa')
+	with open(os.path.join(outpath, proteome), 'w') as p:
+		for rec in SeqIO.parse(in_queryfile, 'genbank'):
+			for feat in rec.features:
+				if feat.type == 'CDS':
+					p.write('>{} {}\n{}\n'.format(
+						feat.qualifiers['locus_tag'][0],
+						feat.qualifiers['product'][0],
+						feat.qualifiers['translation'][0]))
+	return os.path.join(outpath, proteome)
+
+def index_genbank_features(gb_record, feature_type, qualifier) :
+	gb_idx = dict()
+	for (i, feat) in enumerate(gb_record.features):
+		if feat.type == feature_type:
+			if qualifier in feat.qualifiers:
+				for s in feat.qualifiers[qualifier]:  #list of loci
+					if s in gb_idx:  #make sure the locus_tag is unique in the record
+						sys.exit('ERROR: malformed GenBank file; found duplicate of {}'.format(s))
+					else:
+						gb_idx[s] = i
+	return gb_idx
+
+def locus_tag2gene_seq(gbk, locus_tag, outfile):
+	r = 0
+	for gb_record in SeqIO.parse(open(gbk, 'r'), 'genbank'):
+		locus_tag_index = index_genbank_features(gb_record, 'CDS', 'locus_tag')
+		if locus_tag in locus_tag_index:
+			gene_seq = str(gb_record.features[locus_tag_index[locus_tag]].extract(gb_record.seq))
+			product = str(gb_record.features[locus_tag_index[locus_tag]].qualifiers['product'][0])
+			record = SeqRecord(Seq(gene_seq, generic_dna), id=locus_tag, description=product, name='')
+			r += 1
+	if r == 1:
+		SeqIO.write(record, outfile, 'fasta')  #gene seq
+	elif r > 1:
+		sys.exit('ERROR: malformed GenkBank file; found >1 occurance of {}'.format(locus_tag))
+	else:
+		sys.exit('ERROR: malformed GenkBank file; absent locus? {}'.format(locus_tag))
+
+def main():
+	opts = parseArgs()
+	cpus = opts.cpus
+	in_queryfile = str(os.path.abspath(opts.infile))  # Example: proteome.faa
+	hmm = os.path.abspath(opts.hmm)                   # Example: prot-markers.hmm
+	if opts.base:
+		base = opts.base
+	else:
+		base = os.path.basename(os.path.abspath(opts.infile)).rsplit('.')[0]
+	if opts.outpath is not None:
+		outpath = os.path.abspath(opts.outpath)
+		if not os.path.exists(outpath):
+			os.mkdir(outpath)
+	else:
+		autocreated_dirname = base + '--' + strftime('%d%b%Y_%-I:%M%p').upper()
+		outpath = os.path.join(os.getcwd(), autocreated_dirname)
+		os.mkdir(outpath)
+
+	# Setup dir structure
+	for d in ['log', 'indiv', 'sum']:
+		try:
+			os.mkdir(os.path.join(outpath, d))
+		except OSError as err:  #OSError: [Errno 17] File exists
+			print 'WARNING: non-empty output directory {}/{} might result in overwritten files'.format(outpath, d)
+
+	# Check input sequence file format
+	if in_queryfile.endswith(('.gb', '.gbk')):
+		gene = True
+		proteome = genbank2faa(in_queryfile, os.path.join(outpath, 'sum'))
+	elif in_queryfile.endswith(('.faa', '.fa', '.fasta', '.FastA', '.fas', '.fsa')):
+		gene = False
+		proteome = in_queryfile
+	else:
+		sys.exit('ERROR: unsupported {} file extension'.format(in_queryfile.split('.')[-1:]))
+
+	# Verify HMMsearch is v3.0+
+	hmm_ver = check_output('hmmsearch -h | head -n 4', shell=True).rstrip('\n')
+	if '# HMMER 3.' not in hmm_ver:
+		sys.exit('ERROR: HMMER v3.0+ required')
+
+	# Run HMMsearch with proteome input against a HMM database
+	search_results = os.path.join(outpath, 'log', base + '.targethits.txt')
+	cmd_search = 'hmmsearch --tblout {} --cut_tc --notextw --cpu {} {} {}'.format(search_results, cpus, hmm, proteome)
+	with open(os.path.join(outpath, 'log', base + '.targethits.log'), 'w') as f:
+		return_code = Popen(cmd_search.split(), stdout=f, shell=False)
+		if return_code.wait() != 0:
+			sys.exit('ERROR: failed system call\n{}\n'.format(cmd_search))
+
+	# Count number of HMM profiles queried
+	cmd_getloci = "hmmstat {} | grep -Ev '(^#|^$)' | awk '{{print $2}}' | tr '\\n' '\\t'".format(hmm)
+	query_names = check_output(cmd_getloci, shell=True)
+	query_names_list = query_names.rstrip('\t').split('\t')
+
+	# Parse HMM search results
+	input_records = SeqIO.index(proteome, 'fasta')
+	query_names_found = {}  #key=query_name;val=(target_name,accession,description_of_target)
+	with open(search_results, 'r') as results:
+		for line in results:
+			if not line.startswith("#"):
+				data = line.split()
+				if data[2] not in query_names_found:
+					query_names_found[data[2]] = (data[0],data[3],data[18])
+				else:
+					old_val = query_names_found.pop(data[2])
+					query_names_found[data[2]] = [old_val, (data[0],data[3],data[18])]
+				SeqIO.write(input_records[data[0]], '{}.fsa'.format(
+					os.path.join(outpath, 'indiv', base + '.' + data[0].split()[0] + '.' + data[3].split()[0])),
+					'fasta') #protein seq
+				if gene:
+					locus_tag2gene_seq(in_queryfile, input_records[data[0]].id,
+						os.path.join(outpath, 'indiv', base + '.' + data[0].split()[0] + '.' + data[3].split()[0] + '.fas'))
+		input_records.close()
+
+	# Create merged/summary extracted sequence file(s)
+	if gene:
+		os.remove(os.path.join(outpath, 'sum', base + '.faa'))  #rm tmp proteome from gbk input
+		os.system('ls {} | xargs cat > {}'.format(os.path.join(outpath, 'indiv', '*.fas'), os.path.join(outpath, 'sum', base + '.found.ffn')))  #genes
+	os.system('ls {} | xargs cat > {}'.format(os.path.join(outpath, 'indiv', '*.fsa'), os.path.join(outpath, 'sum', base + '.found.faa')))  #proteins
+
+	# Generate input for R
+	counts = []
+	for qn in query_names_list:
+		if qn in query_names_found:
+			if type(query_names_found.get(qn)) is tuple:
+				counts.append('1')
+				hit = query_names_found.get(qn)
+			elif type(query_names_found.get(qn)) is list:
+				counts.append(str(len(query_names_found.get(qn))))
+				hits = query_names_found.get(qn)
+		else:
+			counts.append('0')
+	with open(os.path.join(outpath, 'sum', '{}.loci_abundance.tab'.format(base)), 'w') as outabund:
+		outabund.write('#Sample\t{}\n'.format('\t'.join(query_names_list)))
+		outabund.write('{}\t{}\n'.format(base, '\t'.join(counts)))
+
+	# Count number of HMM profiles queried
+	cmd_stat = "hmmstat {} | grep -Ev '(^#|^$)' | wc -l".format(hmm)
+	num_profiles = check_output(cmd_stat, shell=True).rstrip('\n')
+
+	# Report absent loci, single hits, and multiples
+	num_absent  = counts.count('0')
+	num_single  = counts.count('1')
+	num_gt_once = len(counts) - num_absent - num_single
+	with open(os.path.join(outpath, 'sum', '{}.stats.tab'.format(base)), 'w') as outsum:
+		outsum.write('{:>7}% or {}/{} loci not found\n'.format(
+			str(Decimal(num_absent/float(num_profiles)*100).quantize(Decimal('.01'), rounding=ROUND_HALF_UP)),
+			str(num_absent), num_profiles))
+		outsum.write('{:>7}% or {}/{} loci found once\n'.format(
+			str(Decimal(num_single/float(num_profiles)*100).quantize(Decimal('.01'), rounding=ROUND_HALF_UP)),
+			str(num_single), num_profiles))
+		outsum.write('{:>7}% or {}/{} loci found more than once'.format(
+			str(Decimal(num_gt_once/float(num_profiles)*100).quantize(Decimal('.01'), rounding=ROUND_HALF_UP)),
+			str(num_gt_once), num_profiles))
+
+if __name__ == '__main__':
+	main()
diff --git a/NCBI.asm-biosample.rename.py b/NCBI.asm-biosample.rename.py
new file mode 100755
index 0000000..23b3f45
--- /dev/null
+++ b/NCBI.asm-biosample.rename.py
@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+
+
+import csv
+import json
+import os
+import re
+import shutil
+import sys
+from argparse import ArgumentParser
+from glob import glob
+
+def parseArgs():
+        parser = ArgumentParser(description='Renames assembly files',
+                add_help=False)
+        req = parser.add_argument_group('Required')
+        req.add_argument('-i', '--indir', required=True, metavar='FILE',
+                help='input path containing files to rename')
+        req.add_argument('-j', '--json', required=True, metavar='FILE',
+                help='input JSON database file of BioSample metadata')
+        req.add_argument('-k', '--keys', required=True, metavar='FILE',
+                help='TSV file; first column are BioSample Accessions'
+                ' and second column are corresponding strings (e.g.,'
+                ' Assembly Accessions) in input filenames to match')
+        opt = parser.add_argument_group('Optional')
+        opt.add_argument('-h', '--help', action='help',
+                help='show this help message and exit')
+        opt.add_argument('-o', '--outdir', metavar='FILE', default=None,
+                help='path for renamed files [cwd]')
+        rno = parser.add_argument_group('Renaming Options')
+        rno.add_argument('--empty', metavar='STR', type=str, default='missing',
+                help='character or string for empty values [missing]')
+        rno.add_argument('--metadata', choices=['geo_loc_name', 'isolate', 'SRA',
+                'strain'], nargs='+', default=['geo_loc_name'],
+                help='biosample field(s) from JSON input to add to corresponding'
+                ' filenames [geo_loc_name]')
+        rno.add_argument('--save-method', choices=['copy', 'move', 'symlink'],
+                default='symlink',
+                help='method for saving renamed files [symlink]')
+        rno.add_argument('--substring-rename-method', default='append-suffix',
+                choices=['append-prefix', 'append-suffix', 'replace'],
+                help='filename renaming strategy [append-suffix]')
+        fso = parser.add_argument_group('File Matching Options')
+        fso.add_argument('--extension', metavar='STR', type=str,
+                default=['.gbff.gz'], nargs='+',
+                help='extension(s) of files to rename [.gbff.gz]')
+        fso.add_argument('--no-recursive', action='store_true', default=False,
+                help='turn off recursive search for files within indir [off]')
+        qry = parser.add_argument_group('Word Query (2nd col --keys <TSV>) Options')
+        qry.add_argument('--query-absent', default='fail',
+                choices=['fail', 'skip'],
+                help='when word not found in any files [fail]')
+        # qry.add_argument('--query-type', default='filenames',
+        #       choices=['filenames', 'content'],
+        #       help='where to search for query words [filenames]')
+        qry.add_argument('--substring-match-location', default='anywhere',
+                choices=['anywhere', 'full', 'prefix', 'suffix'],
+                help='where TSV values exist in each filename [anywhere]')
+        return parser.parse_args()
+
+def get_metadata(queries, data, field, search_type):
+        '''finds each query string from a list of queries in a data dictionary
+        with specified search field and search type'''
+        all_found_records = {}
+        if search_type == 'anywhere':
+                for qry in queries:
+                        found = {k:v for k, v in data.items() if qry in v[field]}
+                        if len(found) == 0:
+                                sys.stderr.write('ERROR: {} {} absent\n'.format(qry, field))
+                                sys.exit(1)
+                        all_found_records.update(found)
+        elif search_type == 'full':
+                for qry in queries:
+                        found = {k: v for k, v in data.items() if v[field] == qry}
+                        if len(found) == 0:
+                                sys.stderr.write('ERROR: {} {} absent\n'.format(qry, field))
+                                sys.exit(1)
+                        all_found_records.update(found)
+        elif search_type == 'prefix':
+                for qry in queries:
+                        found = {k:v for k, v in data.items() if v[field].startswith(qry)}
+                        if len(found) == 0:
+                                sys.stderr.write('ERROR: {} {} absent\n'.format(qry, field))
+                                sys.exit(1)
+                        all_found_records.update(found)
+        elif search_type == 'suffix':
+                for qry in queries:
+                        found = {k:v for k, v in data.items() if v[field].endswith(qry)}
+                        if len(found) == 0:
+                                sys.stderr.write('ERROR: {} {} absent\n'.format(qry, field))
+                                sys.exit(1)
+                        all_found_records.update(found)
+        elif search_type == 'key':
+                for qry in queries:
+                        found = data.get(qry, None)
+                        if found is None:
+                                sys.stderr.write('ERROR: {} BioSample absent\n'.format(qry))
+                                sys.exit(1)
+                        all_found_records.update({qry: found})
+        sys.stderr.write('INFO: {} entries remain after {} filter\n'.format(
+                len(all_found_records), field))
+        return all_found_records
+
+def find_files(query, extensions, files, search_type, query_absent):
+        '''finds files within a list of files with the filename containing a query
+         string with specified file extensions and search type'''
+        found_files = []
+        for file in files:
+                f = os.path.basename(file)
+                if search_type == 'anywhere':
+                        if query in f:
+                                found_files.append(file)
+                elif search_type == 'full':
+                        for ext in extensions:
+                                b = f.rstrip(ext)
+                                if query == b:
+                                        found_files.append(file)
+                elif search_type == 'prefix':
+                        if f.startswith(query):
+                                found_files.append(file)
+                elif search_type == 'suffix':
+                        for ext in extensions:
+                                if f.endswith(query + ext):
+                                        found_files.append(file)
+        if len(found_files) == 0 and query_absent == 'fail':
+                sys.stderr.write('ERROR: no filenames contain {} {}\n'.format(query,
+                        search_type))
+                sys.exit(1)
+        return found_files
+
+def main():
+        opt = parseArgs()
+        recursive = not opt.no_recursive
+        if sys.version_info < (3, 5):
+                sys.stderr.write('WARNING: Python 3.5+ is required to do the'
+                        'recursive file searching with the stdlib simply in glob\n')
+                recursive = False
+        indir = os.path.realpath(os.path.expanduser(opt.indir))
+        extensions = opt.extension
+        match_location = opt.substring_match_location
+        if opt.outdir is None:
+                outdir = os.getcwd()
+        else:
+                outdir = os.path.realpath(os.path.expanduser(opt.outdir))
+                if not os.path.exists(outdir):
+                        os.makedirs(outdir)
+
+        # Identify files with matching extensions
+        files = []
+        for ext in extensions:
+                if not opt.no_recursive:
+                        found = glob(os.path.join(indir, '**', '*' + ext), recursive=True)
+                else:
+                        found = glob(os.path.join(indir, '*' + ext))
+                if len(found) > 0:
+                        files.extend(found)
+        if len(files) == 0:
+                sys.stderr.write('ERROR: no files in {} with {} extension\n'.format(
+                        indir, ','.join(extensions)))
+                sys.exit(1)
+
+        # Load TSV input keys
+        rename_keys = {}
+        with open(os.path.realpath(os.path.expanduser(opt.keys))) as ifh:
+                reader = csv.DictReader(ifh, fieldnames=['BioSample', 'Query_Word'],
+                        delimiter='\t')
+                biosample_regex = re.compile('^SAM(D|N|E([AG]?))[0-9]+$')
+                for row in reader:
+                        if not bool(re.match(biosample_regex, row['BioSample'])):
+                                sys.stderr.write('ERROR: first column must be a BioSample'
+                                        ' accession and {} doesn\'t appear to be one. EBI'
+                                        ' explains, "BioSample accessions always begin with SAM.'
+                                        ' The next letter is either E or N or D depending if the'
+                                        ' sample information was originally submitted to EBI or'
+                                        ' NCBI or DDBJ respectively. After that, there may be an'
+                                        ' A or a G to denote an Assay sample or a Group of'
+                                        ' samples. Finally there is a numeric component that may'
+                                        ' or may not be zero-padded."\n'.format(row['BioSample']))
+                                sys.exit(1)
+                        rename_keys[str(row['BioSample'])] = row['Query_Word']
+        sys.stderr.write('INFO: input renaming keys has {} entries\n'.format(
+                len(rename_keys)))
+
+        # Load JSON input with biosample accessions as keys
+        with open(os.path.realpath(os.path.expanduser(opt.json))) as ifh:
+                json_d = json.load(ifh)
+        cnt_biosamples = len(json_d)
+        sys.stderr.write('INFO: input has {} biosample entries\n'.format(
+                cnt_biosamples))
+
+        # Compare rename biosample key input with JSON input
+        absent_biosamples = [s for s in rename_keys.keys() if not s in json_d]
+        cnt_absent = len(absent_biosamples)
+        if cnt_absent == len(rename_keys):
+                sys.stderr.write('ERROR: all keys provided are absent in JSON'
+                        ' database\n')
+                sys.exit(1)
+        elif cnt_absent > 0:
+                sys.stderr.write('WARNING: {} keys provided are absent in JSON'
+                        ' database and will not be renamed:\n  {}\n'.format(cnt_absent,
+                        ' '.join(sorted(absent_biosamples))))
+                for key in absent_biosamples:
+                        del rename_keys[key]
+
+        # Rename files
+        cnt_renamed = 0
+        for biosample, qry_word in rename_keys.items():
+                bs_data = json_d[biosample]
+                new_name = ''
+                for wanted_field in opt.metadata:
+                        if wanted_field in bs_data:
+                            if bs_data[wanted_field] is not None:
+                                # new_name += '_' + bs_data[wanted_field].split(':')[0]
+                                new_name += '_' + bs_data[wanted_field]
+                            else:
+                                new_name += '_' + opt.empty
+                        else:
+                                new_name += '_' + opt.empty
+                found_files = find_files(qry_word, extensions, files, match_location,
+                        opt.query_absent)
+                for f in found_files:
+                        b = os.path.basename(f)
+                        if opt.substring_rename_method == 'append-prefix':
+                                filename = os.path.join(outdir, new_name + b)
+                        elif opt.substring_rename_method == 'append-suffix':
+                                idx = [i for i, s in enumerate(extensions) if b.endswith(s)]
+                                for idx, ext in enumerate(extensions):
+                                        if b.endswith(ext):
+                                                filename = (b.rstrip(extensions[idx]) + new_name
+                                                + extensions[idx])
+                                                break
+                        elif opt.substring_rename_method == 'replace':
+                                filename = b.replace(qry_word, new_name)
+                        dest = os.path.join(outdir, filename)
+                        if opt.save_method == 'copy':
+                                shutil.copyfile(f, dest)
+                        elif opt.save_method == 'move':
+                                shutil.move(f, dest)
+                        elif opt.save_method == 'symlink':
+                                try:
+                                        os.symlink(os.path.relpath(f, os.path.dirname(dest)), dest)
+                                except FileExistsError:
+                                        pass
+                        cnt_renamed += 1
+        sys.stderr.write('INFO: {} files renamed\n'.format(cnt_renamed))
+
+if __name__ == '__main__':
+        main()
diff --git a/NCBI.asm.fetch.py b/NCBI.asm.fetch.py
new file mode 100755
index 0000000..4a63c2b
--- /dev/null
+++ b/NCBI.asm.fetch.py
@@ -0,0 +1,244 @@
+#!/usr/bin/env python
+
+
+import multiprocessing as mp
+import os
+import subprocess as sp
+import sqlite3
+import sys
+from argparse import ArgumentParser
+from shutil import rmtree
+from tempfile import mkdtemp
+
+def parseArgs():
+	parser = ArgumentParser(description='Fetches assembly files from NCBI\'s '
+		'web server with rsync or wget. Unless a query is provided to find a '
+		'subset, all database entries will be fetched.', add_help=False,
+		epilog='NOTE: files are named exactly as listed on NCBI')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--input', required=True, metavar='FILE',
+		help='input SQLite3 database file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--file-conflicts', choices=['force', 'keep',
+		'update'], default='update',
+		help='how file conflicts are handled; force always overwrites local, '
+		'keep always retains local, and update only overwrites local when '
+		'NCBI has the same file with a newer timestamp [update]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-m', '--format', choices=['fna', 'gbff', 'gff'],
+		default='gbff', help='assembly file format to fetch [gbff]')
+	opt.add_argument('-o', '--outpath', metavar='PATH',
+		help='output path where retrieved files are stored [cwd]')
+	opt.add_argument('-p', '--protocol', choices=['rsync', 'wget'],
+		default='rsync', help='download protocol [rsync]')
+	opt.add_argument('-q', '--quiet', action='store_true', default=False,
+		help='hide messages when entries are updated or added [off]')
+	opt.add_argument('-t', '--table', metavar='STR', default='asm_summary',
+		 type=str, help='SQL table name to fetch entries [asm_summary]')
+	opt.add_argument('-s', '--query-search', metavar='STR', default=None,
+		help='term to search within the database\'s query-feature [None]')
+	opt.add_argument('-u', '--query-feature', choices=['assembly_accession',
+		'bioproject', 'biosample', 'wgs_master', 'refseq_category', 'taxid',
+		'species_taxid', 'organism_name', 'infraspecific_name', 'isolate',
+		'version_status', 'assembly_level', 'release_type', 'genome_rep',
+		'seq_rel_date', 'asm_name', 'submitter', 'gbrs_paired_asm',
+		'paired_asm_comp', 'ftp_path', 'excluded_from_refseq',
+		'relation_to_type_material'], metavar='STR', 
+		default='assembly_accession',
+		help='feature (column) in database to query (e.g., bioproject, '
+		'biosample, taxid, organism_name, asm_name) [assembly_accession]')
+	opt.add_argument('-y', '--query-type', choices=['exact', 'substring'],
+		default='exact', help='fetch all assemblies where query term is '
+		'found within the entry or matches the full entry [exact]')
+	opt.add_argument('--connections', metavar='INT', default=1, type=int,
+		help='number of concurrent download connections [1]')
+	opt.add_argument('--connect-timeout', metavar='INT', default=3, type=int,
+		help='seconds to wait for a connection to NCBI before quitting [3]')
+	opt.add_argument('--info', metavar='FILE', default=None,
+		help='output tab-delimited list of sample metadata fetched [None]')
+	opt.add_argument('--list', metavar='FILE', default=None,
+		help='output list of URLs (line-by-line); useful if you want to do '
+		'your own rsync --files-from or wget --input-file [None]')
+	opt.add_argument('--no-download', action='store_true', default=False,
+		help='skips downloading assembly files [off]')
+	return parser.parse_args()
+
+def sql_open(sql_out):
+	try:
+		con = sqlite3.connect(sql_out)
+		cur = con.cursor()
+		return con, cur
+	except:
+		raise
+
+def sql_close(con, cur):
+	cur.close()
+	con.close()
+
+def make_list_of_webfiles(sql_data, file_format):
+	if len(sql_data) == 0:
+		sys.stderr.write('ERROR: no entries match the query\n')
+		sys.exit(1)
+	get = []
+	for row in sql_data:
+		if not row[19].startswith(('ftp:', 'https:')):
+			sys.stderr.write('ERROR: expect FTP or HTTPS path but instead found '
+				'{}\n'.format(row[19]))
+			sys.exit(1)
+		b = os.path.basename(row[19])
+		get.append('{}/{}_genomic.{}.gz'.format(row[19], b, file_format))
+	return get
+
+def generate_metadata(sql_data, file_format):
+	''' returns a list, where each item is a tab-delimited string. The first
+	column is the full filepath to fetch the file from NCBI's FTP server,
+	the remaining columns are identical to NCBI's assembly summary format
+	which hold 22 columns, e.g., Assembly Accn, BioSample, Organism, etc. '''
+	nfo = []
+	for row in sql_data:
+		b = os.path.basename(row[19])
+		# need a char for empty cells to read while-loop array with IFS tab
+		metadata = [str(s) if str(s).strip() else '.' for s in row]
+		nfo.append('{}/{}_genomic.{}.gz\t{}'.format(
+			row[19], b, file_format, '\t'.join(metadata)))
+	return nfo
+
+def write_file_list(outfile, url_list, bool_quiet):
+	with open(outfile, 'w') as o:
+		for ln in url_list:
+			o.write('{}\n'.format(''.join(ln)))
+	if not bool_quiet:
+		sys.stderr.write('INFO: saved file list for {} assemblies\n'.\
+			format(len(url_list)))
+
+def fetch_asm(sys_cmd_string):
+	sys_cmd_list = sys_cmd_string.split()
+	with open(os.devnull, 'wb') as dump:
+		process = sp.Popen(sys_cmd_list, stdout=dump, stderr=sp.PIPE)
+		_, err = process.communicate()
+		sys.stderr.write(err)
+		if process.returncode == 0:
+			return True
+		else:	
+			sys.stderr.write('ERROR: failed system call: {}\n'.\
+				format(sys_cmd_string))
+			return False
+
+def main():
+	opt = parseArgs()
+
+	# I/O handling
+	ifh = os.path.abspath(os.path.expanduser(opt.input))
+	if opt.outpath is not None:
+		out = os.path.abspath(os.path.expanduser(opt.outpath))
+	else:
+		out = os.getcwd()
+	if os.path.exists(out) and opt.file_conflicts == 'update' \
+	and not opt.quiet:
+		sys.stderr.write('WARNING: conflicting files will be overwritten if '
+			'a newer assembly file is found...\n')
+	elif not os.path.exists(out):
+		os.mkdir(out)
+	cpu_processes = opt.connections
+
+	# Gather paths of assembly files
+	tbl = opt.table
+	con, cur = sql_open(ifh)
+	reload(sys)
+	sys.setdefaultencoding('UTF-8')
+	if opt.query_search is None:
+		cur.execute('SELECT * FROM {}'.format(tbl))
+		dat = cur.fetchall()
+		get = make_list_of_webfiles(dat, opt.format)
+	else:
+		if opt.query_type == 'exact':
+			cur.execute('SELECT * FROM {} WHERE ({} = \'{}\' '
+				'AND version_status = "latest")'.format(
+				tbl, opt.query_feature, opt.query_search))
+		elif opt.query_type == 'substring':
+			cur.execute('SELECT * FROM {} WHERE ({} LIKE \'%{}%\' '
+				'AND version_status = "latest")'.format(
+				tbl, opt.query_feature, opt.query_search))
+		dat = cur.fetchall()
+		get = make_list_of_webfiles(dat, opt.format)
+	sql_close(con, cur)
+
+	# Optionally save assembly metadata to an output file
+	if opt.info is not None:
+		with open(os.path.abspath(os.path.expanduser(opt.info)), 'w') as o:
+			for ln in generate_metadata(dat, opt.format):
+				o.write('{}\n'.format(''.join(ln)))
+		if not opt.quiet:
+			sys.stderr.write('INFO: saved metadata for {} assemblies\n'.\
+				format(len(get)))
+
+	# Optionally save assembly URLs to an output file
+	if opt.list is not None:
+		write_file_list(os.path.abspath(os.path.expanduser(opt.list)), get,
+			opt.quiet)
+	
+	# Optionally skip downloading assembly files from NCBI
+	if opt.no_download:
+		sys.exit(0)
+
+	# Make generic download command before adding url to fetch
+	## rsync <options> fetch-url output-dir
+	## wget -P <output-dir> <options> fetch-url
+	if opt.protocol == 'rsync':
+		cmd = 'rsync --copy-links --times --human-readable '
+	elif opt.protocol == 'wget':
+		cmd = 'wget --directory-prefix={} '.format(out)
+	if opt.connect_timeout:
+		if opt.protocol == 'rsync':
+			cmd += '--contimeout {} '.format(opt.connect_timeout)
+		elif opt.protocol == 'wget':
+			cmd += '--connect-timeout={} '.format(opt.connect_timeout)
+	conflicts = {'rsync': 
+					{'force':  '--ignore-times ',
+					 'keep':   '--ignore-existing ',
+					 'update': '--update '},
+				 'wget':
+					{'force':  '',
+					 'keep':   '--no-clobber ',
+					 'update': '--timestamping '}}
+	cmd += conflicts[opt.protocol][opt.file_conflicts]
+	if opt.quiet:
+		cmd += '--quiet '
+	else:
+		sys.stderr.write('INFO: fetching {} assemblies into {}...\n'.format(
+			len(get), out))
+
+	# Now add file (and outdir) to each generic fetch command and download
+	if opt.protocol == 'rsync':
+		cmds = [cmd + x.replace('ftp:', 'rsync:') + ' ' + out for x in get]
+	elif opt.protocol == 'wget':
+		cmds = [cmd + x.replace('ftp:', 'https:') for x in get]
+	
+	# Fetch the first assembly file
+	first_try = cmds.pop(0)
+	if not fetch_asm(first_try):
+		sys.stderr.write('ERROR: retrieval issue with {}. Consider an '
+			'alternative connection protocol.\n'.format(opt.protocol))
+		sys.exit(1)
+
+	# Connection and download successful, so now multiprocess the rest
+	pool = mp.Pool(processes=cpu_processes)
+	try:	
+		for output in pool.imap_unordered(fetch_asm, cmds):
+			if not output:
+				sys.stderr.write('ERROR: retrieval issue with {}. Consider '
+					'an alternative connection protocol.\n'.format(
+						opt.protocol))
+				pool.terminate()
+				pool.join()
+				sys.exit(1)
+		pool.close()
+		pool.join()
+	except KeyboardInterrupt:
+		pool.terminate()
+		pool.join()
+		sys.exit(1)
+
+if __name__ == '__main__':
+	main()
diff --git a/NCBI.asm.summary.py b/NCBI.asm.summary.py
new file mode 100755
index 0000000..60c7e4a
--- /dev/null
+++ b/NCBI.asm.summary.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from csv import reader
+from shutil import rmtree
+from tempfile import mkdtemp
+import sqlite3
+
+def parseArgs():
+	parser = ArgumentParser(description='Creates (or updates) a SQLite3 '
+		'database of genome assembly information from NCBI\'s FTP site '
+		'(or a given summary file)', add_help=False,
+		epilog='The output database file is especially useful for retrieving '
+		'genome assembly files with the aid of NCBI.asm.fetch.py')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-o', '--output', required=True, metavar='FILE',
+		help='output SQLite3 database file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--compress', action='store_true', default=False,
+		help='compress SQLite3 output database; especially useful when the '
+		'infile database entries overwrite fetched or provided summary data '
+		'or contains many different additional entries [off]')
+	opt.add_argument('-d', '--db', choices=['genbank', 'refseq'],
+		default='refseq', help='database to summarize from NCBI [refseq]')
+	opt.add_argument('-f', '--force', action='store_true', default=False,
+		help='when input SQL entry has a conflicting assembly_accession '
+		'entry with the summary data fetched or provided, overwrite/replace '
+		'entry in the summary data with the infile database entry [off]')
+	opt.add_argument('-g', '--group', choices=['all', 'archaea', 'bacteria',
+		'fungi', 'invertebrate', 'metagenomes', 'other', 'plant', 'protozoa',
+		'vertebrate_mammalian', 'vertebrate_other', 'viral'],
+		metavar='{archaea, bacteria, viral}',
+		default='bacteria', help='group of assembly data to fetch [bacteria]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-i', '--infile', metavar='FILE',
+		help='input SQLite3 database file which is appended to the summary '
+		'data output; table name must be \'<--db>_asm_summary\'; see '
+		'--force for handling entry conflicts')
+	opt.add_argument('-q', '--quiet', action='store_true', default=False,
+		help='hide messages when entries are updated or added [off]')
+	opt.add_argument('-r', '--rows', metavar='INT', type=int, default=200000,
+		help='number of data summary rows to simultaneously add to SQLite '
+		'database at once; useful for speed optimization; default takes 5 '
+		'sec for refseq whereas naive insertion of 1 takes 7 min [200000]')
+	opt.add_argument('-s', '--summary-data', metavar='FILE',
+		help='tab-delimited local file of assembly summary data (23-column '
+		'format as NCBI has specified in ftp://ftp.ncbi.nlm.nih.gov/genomes/'
+		'ASSEMBLY_REPORTS/README_assembly_summary.txt) rather than directly '
+		'fetching from NCBI\'s FTP site; especially useful if FTP is '
+		'blocked or creating custom database')
+	opt.add_argument('-u', '--url', metavar='STR', type=str, default=None,
+		help='web address to file of assembly summary data (23-column); '
+		'for bypassing NCBI access (e.g., EMBL-EBI) without locally storing '
+		'the file')
+	return parser.parse_args()
+
+def sql_open(sql_out):
+	try:
+		con = sqlite3.connect(sql_out)
+		cur = con.cursor()
+		return con, cur
+	except Error as e:
+		sys.stderr.write('ERROR: {}\n'.format(e))
+		sys.exit(1)
+
+def sql_compress(cur):
+	cur.execute('VACUUM')
+
+def sql_close(con, cur):
+	cur.close()
+	con.close()
+
+def sql_create_table(cur, tbl):
+	# NOTE: the 23rd column 'asm_not_live_date' was added some time between
+	#  years 2019 and 2021; before that only the first 22 columns existed
+	cur.execute('''
+		CREATE TABLE IF NOT EXISTS {} (
+		assembly_accession TEXT UNIQUE NOT NULL,
+		bioproject TEXT,
+		biosample TEXT,
+		wgs_master TEXT,
+		refseq_category TEXT,
+		taxid INT,
+		species_taxid INT,
+		organism_name TEXT,
+		infraspecific_name TEXT,
+		isolate TEXT,
+		version_status TEXT,
+		assembly_level TEXT,
+		release_type TEXT,
+		genome_rep TEXT,
+		seq_rel_date TEXT,
+		asm_name TEXT,
+		submitter TEXT,
+		gbrs_paired_asm TEXT,
+		paired_asm_comp TEXT,
+		ftp_path TEXT NOT NULL,
+		excluded_from_refseq TEXT,
+		relation_to_type_material TEXT,
+		asm_not_live_date TEXT
+	)'''.format(tbl))
+
+def sql_data_entry(con, cur, tbl, dat, bulk=False, overwrite=False):
+	if bulk and not overwrite:
+		cur.executemany('INSERT INTO {} VALUES({})'.format(
+			tbl, ('?,' * 23)[:-1]), dat)
+	elif bulk and overwrite:
+		cur.executemany('REPLACE INTO {} VALUES({})'.format(
+			tbl, ('?,' * 23)[:-1]), dat)
+	elif not bulk and overwrite:
+		cur.execute('REPLACE INTO {} VALUES({})'.format(
+			tbl, ('?,' * 23)[:-1]), dat)
+	else:
+		cur.execute('INSERT INTO {} VALUES({})'.format(
+			tbl, ('?,' * 23)[:-1]), dat)
+	con.commit()
+
+def sql_query(cur, tbl, query, quiet):
+	cur.execute('SELECT * FROM {} WHERE assembly_accession=?'.format(
+		tbl), (query,))
+	fnd = cur.fetchall()
+	if len(fnd) >= 1:
+		if not quiet:
+			sys.stderr.write('INFO: {} already found in db\n'.format(query))
+		if len(fnd) == 1:
+			return fnd[0]
+		elif len(fnd) > 1:
+			if not quiet:
+				sys.stderr.write('WARNING: expect 1 but found {} entries for '
+					'{}. Using first value {}...\n'.format(
+						len(fnd), query, fnd[0]))
+			return fnd[0]
+	else:
+		return False
+
+def chunk_data(data, rows_per_chunk=5000):
+	chunk = []
+	for i, row in enumerate(data):
+		if i % rows_per_chunk == 0 and i > 0:
+			yield chunk
+			del chunk[:]
+		chunk.append([str(s).decode('UTF-8') for s in row])
+	yield chunk
+
+def main():
+	opt = parseArgs()
+	ofh = os.path.abspath(os.path.expanduser(opt.output))
+	if opt.infile:
+		ifh = os.path.abspath(os.path.expanduser(opt.infile))
+		if ifh == ofh:
+			sys.stderr.write('ERROR: in and out files cannot be the same\n')
+			sys.exit(1)
+
+	# Prepare or fetch summary file of assembly data
+	if opt.summary_data:
+		summary_file = os.path.abspath(os.path.expanduser(opt.summary_data))
+		with open(summary_file) as f:
+			ln = next(f)
+			num_col = len(ln.split('\t'))
+		if num_col != 23:
+			sys.stderr.write('ERROR: expect 23 data columns from input '
+				'summary file; contains {} columns\n'.format(num_col))
+			sys.exit(1)
+	else:
+		tmp = mkdtemp()
+		tfh = os.path.join(tmp, 'asm-summary.tab')
+		if opt.url is not None:
+			url = opt.url
+		elif opt.group == 'all':
+			url = ('ftp://ftp.ncbi.nlm.nih.gov/genomes/ASSEMBLY_REPORTS/'
+				'assembly_summary_{}.txt'.format(opt.db))
+		else:
+			url = ('ftp://ftp.ncbi.nlm.nih.gov/genomes/{}/{}/'
+				'assembly_summary.txt'.format(opt.db, opt.group))
+		os.system('curl --max-time 300 --silent --fail --show-error '
+			'{} -o {}'.format(url, tfh))
+		if os.path.exists(tfh) and os.path.getsize(tfh) > 0:
+			summary_file = tfh
+		else:
+			sys.stderr.write('ERROR: unable to fetch assembly summary file '
+				'from NCBI\'s FTP site\n')
+			rmtree(tmp)
+			sys.exit(1)
+
+	# Output sqlite3 db from fetched or provided assembly data
+	tbl = 'asm_summary'
+	con, cur = sql_open(ofh)
+	sql_create_table(cur, tbl)
+	with open(summary_file) as f:
+		r = reader((row for row in f if not row.startswith('#')),
+			delimiter='\t')
+		for chunk in chunk_data(r, rows_per_chunk=opt.rows):
+			sql_data_entry(con, cur, tbl, chunk, bulk=True)
+
+	# Handle comparisons of input to output sqlite3 dbs
+	if opt.infile:
+		sql_close(con, cur)
+		con, cur = sql_open(ifh)
+		cur.execute('SELECT * FROM {}'.format(tbl))
+		input_data = cur.fetchall()
+		sql_close(con, cur)
+		con, cur = sql_open(ofh)
+		reload(sys)
+		sys.setdefaultencoding('UTF-8')
+		if opt.force:
+			for chunk in chunk_data(input_data, rows_per_chunk=opt.rows):
+				sql_data_entry(con, cur, tbl, chunk, bulk=True, overwrite=True)
+		else:
+			for entry in input_data:
+				a = sql_query(cur, tbl, str(entry[0]), opt.quiet)
+				if not a:
+					sql_data_entry(con, cur, tbl,
+						[str(s).decode('UTF-8') for s in entry])
+
+	# Finish and cleanup
+	if opt.compress:
+		sql_compress(cur)
+	sql_close(con, cur)
+	if not opt.summary_data:
+		rmtree(tmp)
+
+if __name__ == '__main__':
+	main()
diff --git a/NCBI.biosample.parse.py b/NCBI.biosample.parse.py
new file mode 100755
index 0000000..44426d9
--- /dev/null
+++ b/NCBI.biosample.parse.py
@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+
+
+import csv
+import json
+import os
+import sys
+from argparse import ArgumentParser
+
+def parseArgs():
+	parser = ArgumentParser(description='Parses data from a JSON database of'
+		' BioSample information from NCBI.biosample.summary.py output',
+		add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input JSON database file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-e', '--empty', metavar='STR', type=str, default='',
+		help='character or string to denote empty value [None]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-j', '--out-json', metavar='FILE', default=None,
+		help='JSON output file [None]')
+	opt.add_argument('-o', '--output', metavar='FILE', default=None,
+		help='output tab-delimited file [stdout]')
+	opt.add_argument('--max-records', metavar='INT', type=int, default=None,
+		help='maximum number of records to output [None]')
+	opt.add_argument('--min-records', metavar='INT', type=int, default=1,
+		help='minimum number of records to output [1]')
+	qry = parser.add_argument_group('Query Fields to Output')
+	qry.add_argument('--find-biosample', metavar='STR', type=str, nargs='*',
+		default=None, help='biosample identifier(s) [all]')
+	qry.add_argument('--find-organism', metavar='STR', type=str, nargs='*',
+		default=None, help='organism name prefix(es) [all]')
+	qry.add_argument('--find-taxid', metavar='INT', type=int, nargs='*',
+		default=None, help='taxonomic identifier(s) assigned by NCBI [all]')
+	qry.add_argument('--find-taxname', metavar='STR', type=str, nargs='*',
+		default=None, help='taxonomic name prefix(es) [all]')
+	xtr = parser.add_argument_group('Additional Fields to Output')
+	xtr.add_argument('--collected-by', action='store_true', default=False,
+		help='name of persons or institute who collected the sample')
+	xtr.add_argument('--collection-date', action='store_true', default=False,
+		help='collection date')
+	xtr.add_argument('--description', action='store_true', default=False,
+		help='sample\'s description')
+	xtr.add_argument('--geo', action='store_true', default=False,
+		help='geographic origin')
+	xtr.add_argument('--host', action='store_true', default=False,
+		help='organism from which the sample was obtained')
+	xtr.add_argument('--isolate', action='store_true', default=False,
+		help='isolate number')
+	xtr.add_argument('--sample-type', action='store_true', default=False,
+		help='sample type')
+	xtr.add_argument('--sra', action='store_true', default=False,
+		help='Sequence Read Archive (SRA) accession')
+	xtr.add_argument('--strain', action='store_true', default=False,
+		help='strain number')
+	return parser.parse_args()
+
+def find_entries(queries, data, field, search_type):
+	all_found_records = {}
+	if search_type == 'full':
+		for qry in queries:
+			try:
+				found = {k: v for k, v in data.items() if v[field] == qry}
+			except KeyError:
+				sys.stderr.write('ERROR: {} absent in db\n'.format(field))
+				sys.exit(1)
+			if len(found) == 0:
+				sys.stderr.write('ERROR: {} {} absent\n'.format(qry, field))
+				sys.exit(1)
+			all_found_records.update(found)
+	elif search_type == 'prefix':
+		for qry in queries:
+			try:
+				found = {k: v for k, v in data.items() if v[field].startswith(qry)}
+			except KeyError:
+				sys.stderr.write('ERROR: {} absent in db\n'.format(field))
+				sys.exit(1)
+			if len(found) == 0:
+				sys.stderr.write('ERROR: {} {} absent\n'.format(qry, field))
+				sys.exit(1)
+			all_found_records.update(found)
+	elif search_type == 'key':
+		for qry in queries:
+			found = data.get(qry, None)
+			if found is None:
+				sys.stderr.write('ERROR: {} BioSample absent\n'.format(qry))
+				sys.exit(1)
+			all_found_records.update({qry: found})
+	sys.stderr.write('INFO: {} entries remain after {} filter\n'.format(
+		len(all_found_records), field))
+	return all_found_records
+
+def main():
+	opt = parseArgs()
+	
+	# Load JSON input
+	with open(os.path.abspath(os.path.expanduser(opt.infile))) as ifh:
+		json_d = json.load(ifh)
+	cnt_biosamples = len(json_d)
+	sys.stderr.write('INFO: input has {} biosample entries\n'.format(
+		cnt_biosamples))
+	if cnt_biosamples < 1:
+		sys.stderr.write('ERROR: at least one biosample entry required\n'.\
+			format(cnt_biosamples))
+		sys.exit(1)
+
+	# Record filtering
+	find_l = [(opt.find_biosample, 'BioSample', 'key'),
+		(opt.find_organism, 'Organism', 'prefix'),
+		(opt.find_taxid, 'TaxID', 'full'),
+		(opt.find_taxname, 'Taxonomy_Name', 'prefix')]
+	for queries, field, search_type in find_l:
+		if queries is not None:
+			json_d = find_entries(queries, json_d, field, search_type)
+
+	# Save additional fields specified
+	want = ['Organism', 'Taxonomy_Name']
+	if opt.collected_by:
+		want.append('collected_by')
+	if opt.collection_date:
+		want.append('collection_date')
+	if opt.description:
+		want.append('description')
+	if opt.geo:
+		want.append('geo_loc_name')
+	if opt.host:
+		want.append('host')
+	if opt.isolate:
+		want.append('isolate')
+	if opt.sample_type:
+		want.append('sample_type')
+	if opt.sra:
+		want.append('SRA')
+	if opt.strain:
+		want.append('strain')
+	d = {}
+	for biosample, val in json_d.items():
+		d[biosample] = {k: v for k, v in val.items() if k in want}
+
+	# Quit if too few or too many records found
+	num_records = len(d)
+	if num_records < opt.min_records:
+		sys.stderr.write('ERROR: {} records matching query less than {}'
+			' --min-records specified\n'.format(num_records,
+			opt.min_records))
+		sys.exit(1)
+	if opt.max_records is not None:
+		if opt.max_records < num_records:
+			sys.stderr.write('ERROR: {} records matching query greater than'
+				' {} --max-records specified\n'.format(num_records,
+				opt.max_records))
+			sys.exit(1)
+
+	# Optionally write data as JSON
+	if opt.out_json is not None:
+		out_json = os.path.realpath(os.path.expanduser(opt.out_json))
+		with open(out_json, 'w') as o:
+			json.dump(d, o)
+
+	# Output TSV data
+	if opt.output is not None:
+		ofh = open(os.path.realpath(os.path.expanduser(opt.output)), 'w')
+	else:
+		ofh = sys.stdout
+	w = csv.DictWriter(ofh, fieldnames=['BioSample'] + want,
+		delimiter='\t', extrasaction='ignore')
+	w.writeheader()
+	for k in sorted(d):
+		data = {field: d[k].get(field, opt.empty) for field in want}
+		w.writerow({'BioSample': k, **data})
+
+if __name__ == '__main__':
+	main()
diff --git a/NCBI.biosample.summary.py b/NCBI.biosample.summary.py
new file mode 100755
index 0000000..b0afc48
--- /dev/null
+++ b/NCBI.biosample.summary.py
@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+
+
+import gzip
+import json
+import os
+import shutil
+import sys
+import xml.etree.ElementTree as ET
+from argparse import ArgumentParser
+from tempfile import mkdtemp
+
+def parseArgs():
+	parser = ArgumentParser(description='Creates a JSON database of '
+		'BioSample information from NCBI\'s FTP site or from a BioSample '
+		'XML file', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-o', '--output', required=True, metavar='FILE',
+		help='output JSON database file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-s', '--biosample-data', metavar='FILE',
+		help='XML local file of biosample data (Schema v2.0 '
+		'format as NCBI has specified in https://www.ncbi.nlm.nih.gov/'
+		'biosample/docs/submission/validation-service/) rather than directly '
+		'fetching from NCBI\'s FTP site; especially useful if FTP is '
+		'blocked or creating custom database')
+	opt.add_argument('-u', '--url', metavar='STR', type=str, default=None,
+		help='web address to a file of biosample data; useful for bypassing '
+		'NCBI access (e.g., EMBL-EBI)')
+	return parser.parse_args()
+
+def decompress_file(infile, outdir):
+	uncompressed_file = os.path.basename(infile).rstrip('.gz')
+	outfile = os.path.join(outdir, uncompressed_file)
+	with gzip.open(infile, 'rb') as ifh, open(outfile, 'wb') as ofh:
+		shutil.copyfileobj(ifh, ofh)
+	return outfile
+
+def main():
+	opt = parseArgs()
+	tmp = mkdtemp()
+
+	# Prepare or fetch summary file of biosample data
+	if opt.biosample_data:
+		summary_file = os.path.realpath(os.path.expanduser(
+			opt.biosample_data))
+		if summary_file.endswith('.gz'):
+			summary_file = decompress_file(summary_file, tmp)
+		# TO-DO: verify XML file given conforms to NCBI BioSample (use their
+		#        tester?)
+	else:
+		tfh = os.path.join(tmp, 'biosample_set.xml.gz')
+		if opt.url is not None:
+			url = opt.url
+		else:
+			url = 'ftp://ftp.ncbi.nlm.nih.gov/biosample/biosample_set.xml.gz'
+		os.system('curl --max-time 300 --silent --fail --show-error '
+			'{} -o {}'.format(url, tfh))
+		if os.path.exists(tfh) and os.path.getsize(tfh) > 0:
+			if tfh.endswith('.gz'):
+				summary_file = decompress_file(tfh, tmp)
+			else:
+				summary_file = tfh
+		else:
+			sys.stderr.write('ERROR: unable to fetch biosample data file '
+				'from NCBI\'s FTP site\n')
+			shutil.rmtree(tmp)
+			sys.exit(1)
+
+	# Read in XML data
+	# NOTE: primary tags from:
+	# 	xml_data = ET.iterparse(f, events=('start', 'end'))
+	# 	tags = []
+	# 	for _, elem in xml_data:
+	# 		tags.append(elem.tag)
+	# 	tags = list(set(tags))
+	group_data = {}
+	empty_values = ('null', '', None, 'missing', 'not determined')
+	xml_data = ET.iterparse(summary_file, events=('start', 'end'))
+	if not opt.biosample_data:
+		shutil.rmtree(tmp)
+	for event, elem in xml_data:
+		# All biosample data are within a single 'BioSampleSet' tag
+		if event == 'end' and elem.tag == 'BioSample':
+			# d = dict.fromkeys(tags)
+			d = {}
+			# Extract primary info from 'Id' tags within the 'Ids' tag
+			# adds at most 3 key-value pairs to the sample dict
+			#    * selects all child elements
+			#    . select the current node
+			#   // selects all subelements
+			biosample_accn = elem.findtext(
+				'.//Id[@db="BioSample"][@is_primary="1"]')
+			if biosample_accn is None:
+				break
+			for el in elem.iterfind('.//Id'):
+				id_attrs = el.attrib
+				if 'db_label' in id_attrs and \
+				id_attrs['db_label'] == 'Sample name':
+					d['Sample_Name'] = el.text
+				elif 'SRA' == id_attrs['db']:
+					d['SRA'] = el.text
+
+			# Extract info within the 'Description' tag
+			d['Description'] = elem.findtext(
+				'.//Description/Comment/Paragraph')
+			d['Title'] = elem.findtext('.//Description/Title')
+			d['Organism'] = elem.findtext('.//OrganismName')
+			organism = elem.find('.//Organism')
+			d['Taxonomy_Name'] = organism.get('taxonomy_name')
+			d['TaxID'] = int(organism.get('taxonomy_id'))
+
+			# Extract info within the 'Owner' tag
+			first = elem.findtext('.//Owner/Contacts/Contact/Name/First')
+			middle = elem.findtext('.//Owner/Contacts/Contact/Name/Middle','')
+			last = elem.findtext('.//Owner/Contacts/Contact/Name/Last')
+			if any((first, middle, last)):
+				d['Owner'] = ('{}, {} {}'.format(last, first, middle)).strip()
+			contact = elem.find('.//Owner/Contacts/Contact')
+			if contact is not None:
+				if 'email' in contact.attrib:
+					d['Contact'] = contact.attrib['email']
+
+			# Extract info from the 'Model' tag
+			d['Model'] = elem.findtext('.//Models/Model')
+
+			# Extract info from the 'Package' tag
+			d['Package'] = elem.findtext('.//Package')
+
+			# Extract info from the 'Attributes' tag
+			for el in elem.iterfind('.//Attribute'):
+				attribute_attrs = el.attrib
+				if 'harmonized_name' in attribute_attrs:
+					# 415 unique harmonized_name keys exist according to
+					# https://www.ncbi.nlm.nih.gov/biosample/docs/attributes/
+					# which is why JSON is used as database rather than sqlite
+					if el.text not in empty_values:
+						d[attribute_attrs['harmonized_name']] = el.text
+				elif 'Alias' == attribute_attrs['attribute_name']:
+					d['Alias'] = el.text
+				elif 'INSDC center name' == attribute_attrs['attribute_name']:
+					d['Center'] = el.text
+				# NOTE: non-harmonized data below might be problematic; skip
+				# elif 'attribute_name' in attribute_attrs:
+				# 	d[attribute_attrs['attribute_name']] = el.text
+
+			# Extract info from the 'Links/Link' tags
+			for el in elem.iterfind('.//Links/Link'):
+				link_attrs = el.attrib
+				if link_attrs['type'] == 'entrez' and \
+				link_attrs['target'] == 'bioproject':
+					d['BioProject'] = int(el.text)
+				elif link_attrs['type'] == 'entrez' and \
+				link_attrs['target'] == 'pubmed':
+					d['PubMed'] = int(el.text)
+				elif link_attrs['type'] == 'url':
+					d['URL'] = el.text
+
+			# Extract info from the 'Status' tags (uses self-closing tags)
+			for el in elem.iterfind('.//Status'):
+				status_attrs = el.attrib
+				d['Status'] = status_attrs['status']
+				d['Status_date'] = status_attrs['when'].split('T')[0]
+			d = {k: v for k, v in d.items() if v not in empty_values}
+			group_data.update({biosample_accn: d})
+
+	# Output data as JSON
+	with open(os.path.realpath(os.path.expanduser(opt.output)), 'w') as o:
+		json.dump(group_data, o)
+
+if __name__ == '__main__':
+	main()
diff --git a/QualAssessCleanSeqs.bash b/QualAssessCleanSeqs.bash
new file mode 100755
index 0000000..98689dc
--- /dev/null
+++ b/QualAssessCleanSeqs.bash
@@ -0,0 +1,199 @@
+#!/bin/bash
+#  Dependencies:  awk, bc, cut, GNU sed, grep, gunzip, mkdir, readlink, paste, printf, wc
+
+usage() { 
+	echo "
+	USAGE: $0 Input_R1.paired.fq Input_R2.paired.fq Input.single.fq Outdir
+
+	The trimmed reads must be in Illumina 1.8+ FastQ
+	format, and filenames must be formatted:
+	<name>.fastq.gz or <name>.fastq, where
+	<name> is the name of the sample.
+	"
+	}
+
+#Help and usage information
+if [[ "$1" == "" || "$1" == "--help" || "$1" == "-h" ]]; then
+	usage
+	exit 1
+elif [[ "$1" == "-v" || "$1" == "--version" ]]; then
+	echo 'v1.1'
+	exit 0
+fi
+
+#Require 4 arguments
+if [ $# -ne 4 ]; then
+	usage
+	exit 1
+fi
+
+#Make outdir if absent
+if [ ! -d "$4" ]; then
+	mkdir -p "$4"
+	echo "created output directory path:  $4"
+fi
+
+#File input sequence information
+#  file regex from Illumina 1.8+ (gunzip extracted):
+#  ([0-9A-Za-z]{1,19})_S([0-9A-Za-z]{1,3})_L([0-9]{3})_R[12]_([0-9]{3}).fastq
+SAMPLE=$(basename $1 | cut -d . -f 1 | cut -d _ -f 1)
+
+#Filename handling
+if [[ $1 == *.gz && $2 == *.gz && $3 == *.gz ]]; then  #all files are gunzipped
+	SAMPLEL=$(basename $1 .gz)
+	SAMPLER=$(basename $2 .gz)
+	SAMPLES=$(basename $3 .gz)
+	echo "extracting the gunzipped file $1..."
+	gunzip -c "$1" > "$4"/"$SAMPLEL"
+	echo "$1 was extracted..."
+	SEQ1="$4"/"$SAMPLEL"
+	echo "extracting the gunzipped file $2..."
+	gunzip -c "$2" > "$4"/"$SAMPLER"
+	echo "$2 was extracted..."
+	SEQ2="$4"/"$SAMPLER"
+	echo "extracting the gunzipped file $3..."
+	gunzip -c "$3" > "$4"/"$SAMPLES"
+	echo "$3 was extracted..."
+	SEQ3="$4"/"$SAMPLES"
+elif [[ $1 == *q && $2 == *q && $3 == *q ]]; then  #all files are fq format
+	echo "all three files are in FastQ format..."
+	SEQ1="$1"
+	SEQ2="$2"
+	SEQ3="$3"
+else  #for now skip possibily of some but not all gunzipped
+	usage
+	exit 1
+fi
+wait
+
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo " $SEQ1, $SEQ2,"
+echo " and $SEQ3 sequences were read in..."
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Count total nucleotides
+TN1=$(awk 'BEGIN {SUM=0;} {if(NR%4==2) {SUM+=length($0);}} END {print SUM;}' $SEQ1)
+TN2=$(awk 'BEGIN {SUM=0;} {if(NR%4==2) {SUM+=length($0);}} END {print SUM;}' $SEQ2)
+TN3=$(awk 'BEGIN {SUM=0;} {if(NR%4==2) {SUM+=length($0);}} END {print SUM;}' $SEQ3)
+BP_TOT="$(($TN1 + $TN2 + $TN3))"
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo " counted the total nucleotides..."
+echo "        Total:  $BP_TOT"
+echo "        R1:     $TN1"
+echo "        R2:     $TN2"
+echo "        single: $TN3"
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+OPSYS=$(uname -s)
+
+###Count nucleotides >=Q20 and >=Q30 for Illumina 1.8+
+if [[ "$OPSYS" == Linux ]]; then  #should be linux where sed default is GNU sed
+	Q301=$(sed -n '4~4'p $SEQ1 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q302=$(sed -n '4~4'p $SEQ2 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q303=$(sed -n '4~4'p $SEQ3 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q20to301=$(sed -n '4~4'p $SEQ1 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m)
+	Q20to302=$(sed -n '4~4'p $SEQ2 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m) 
+	Q20to303=$(sed -n '4~4'p $SEQ3 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m) 
+	Q201=$(($Q20to301 + $Q301))
+	Q202=$(($Q20to302 + $Q302)) 
+	Q203=$(($Q20to303 + $Q303)) 
+elif [[ "$OPSYS" == Darwin ]]; then  #use gsed instead of sed in Mac OS X here
+	Q301=$(gsed -n '4~4'p $SEQ1 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q302=$(gsed -n '4~4'p $SEQ2 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q303=$(gsed -n '4~4'p $SEQ3 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q20to301=$(gsed -n '4~4'p $SEQ1 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m)
+	Q20to302=$(gsed -n '4~4'p $SEQ2 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m) 
+	Q20to303=$(gsed -n '4~4'p $SEQ3 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m) 
+	Q201=$(($Q20to301 + $Q301))
+	Q202=$(($Q20to302 + $Q302)) 
+	Q203=$(($Q20to303 + $Q303)) 
+else
+	echo 'ERROR: Your operating system does not appear to be supported.' >&2
+	exit 1
+fi
+wait
+Q20_TOT="$(($Q201 + $Q202 + $Q203))" 
+Q30_TOT="$(($Q301 + $Q302 + $Q303))" 
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' counted the Q20+ and Q30+ nucleotides...'
+echo "        ${Q201} nucleotides are >=Q20 in $SEQ1" 
+echo "        ${Q301} nucleotides are >=Q30 in $SEQ1" 
+echo "        ${Q202} nucleotides are >=Q20 in $SEQ2" 
+echo "        ${Q302} nucleotides are >=Q30 in $SEQ2" 
+echo "        ${Q203} nucleotides are >=Q20 in $SEQ3" 
+echo "        ${Q303} nucleotides are >=Q30 in $SEQ3" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Calculate percentages of >=Q20 and >=Q30
+PQ201="$(echo "scale=2;($Q201/$TN1)*100" | bc)"
+PQ202="$(echo "scale=2;($Q202/$TN2)*100" | bc)"
+PQ203="$(echo "scale=2;($Q203/$TN3)*100" | bc)"
+PQ301="$(echo "scale=2;($Q301/$TN1)*100" | bc)"
+PQ302="$(echo "scale=2;($Q302/$TN2)*100" | bc)"
+PQ303="$(echo "scale=2;($Q303/$TN3)*100" | bc)"
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' calculated the percentages of Q20 and Q30...'
+echo "        ${PQ201}% nucleotides are >=Q20 in $SEQ1" 
+echo "        ${PQ301}% nucleotides are >=Q30 in $SEQ1" 
+echo "        ${PQ202}% nucleotides are >=Q20 in $SEQ2" 
+echo "        ${PQ302}% nucleotides are >=Q30 in $SEQ2" 
+echo "        ${PQ203}% nucleotides are >=Q20 in $SEQ3" 
+echo "        ${PQ303}% nucleotides are >=Q30 in $SEQ3" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Count number of reads
+NUMLN_L=$(wc -l $SEQ1| awk '{print $1}')
+NUMLN_R=$(wc -l $SEQ2 | awk '{print $1}')
+NUMLN_single=$(wc -l $SEQ3 | awk '{print $1}')
+wait
+NUM_L="$(($NUMLN_L / 4))"
+NUM_R="$(($NUMLN_R / 4))"
+NUM_single="$(($NUMLN_single / 4))"
+READ_TOT="$(($NUM_L + NUM_R + NUM_single))"
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' counted the number of reads...'
+echo "        There are $NUM_L reads in $SAMPLEL" 
+echo "        There are $NUM_R reads in $SAMPLER" 
+echo "        There are $NUM_single reads in $SAMPLES" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Create results output file
+printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
+Sample_Name Q20_Total_[bp] Q30_Total_[bp] Q20_R1_[bp] Q20_R2_[bp] Q20_single_[bp] Q20_R1_[%] Q20_R2_[%] Q20_single_[%] Q30_R1_[bp] Q30_R2_[bp] Q30_single_[bp] Q30_R1_[%] Q30_R2_[%] Q30_single_[%] Total_Sequenced_[bp] Total_Sequenced_[reads] NUMR1_[bp] NUMR2_[bp] NUMsingle_[bp] \
+"$SAMPLE" "$Q20_TOT" "$Q30_TOT" "$Q201" "$Q202" "$Q203" "$PQ201%" "$PQ202%" "$PQ203%" "$Q301" "$Q302" "$Q303" "$PQ301%" "$PQ302%" "$PQ303%" "$BP_TOT" "$READ_TOT" "$NUM_L" "$NUM_R" "$NUM_single" \
+> "$4"/QualAssessTrimSeqs_"$SAMPLE"_results.tab ;
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' created results output file...'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+if [[ "$OPSYS" == Linux ]]; then
+	R1FILEPATH=$(readlink -m $1)
+	R2FILEPATH=$(readlink -m $2)
+	singleFILEPATH=$(readlink -m $3)
+elif [[ "$OPSYS" == Darwin ]]; then
+	R1FILEPATH=$(echo `pwd`/`ls "$1"`)
+	R2FILEPATH=$(echo `pwd`/`ls "$2"`)
+	singleFILEPATH=$(echo `pwd`/`ls "$3"`)
+fi
+
+[[ $1 == *.gz ]] && rm -f "$3"/"$SAMPLEL" 
+[[ $2 == *.gz ]] && rm -f "$3"/"$SAMPLER"
+[[ $3 == *.gz ]] && rm -f "$3"/"$SAMPLES"
+
+#Create log file
+printf "`date`\n$USER\n%s\n%s\n\n" \
+"$R1FILEPATH" "$R2FILEPATH" "$singleFILEPATH" \
+> "$4"/QualAssessTrimSeqs_"$SAMPLE"_results.log ;
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' created log output file...'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo " Quality assessment of $SAMPLE trimmed sequences completed" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
diff --git a/QualAssessRawSeqs.bash b/QualAssessRawSeqs.bash
new file mode 100755
index 0000000..425a9e1
--- /dev/null
+++ b/QualAssessRawSeqs.bash
@@ -0,0 +1,186 @@
+#!/bin/bash
+#  Dependencies:  awk, bc, cut, GNU sed, grep, gunzip, mkdir, readlink, paste, printf, wc
+
+usage() { 
+	echo "
+	USAGE: $0 Input_R1.fastq Input_R2.fastq Outdir
+
+	The raw reads must be in Illumina 1.8+ FastQ
+	format, and filenames must be formatted:
+	<name>.fastq.gz or <name>.fastq, where
+	<name> is the name of the sample.
+	"
+	}
+
+#Help and usage information
+if [[ "$1" == "" || "$1" == "--help" || "$1" == "-h" ]]; then
+	usage
+	exit 1
+elif [[ "$1" == "-v" || "$1" == "--version" ]]; then
+	echo '1.1'
+	exit 0
+fi
+
+#Require 3 arguments
+if [ $# -ne 3 ]; then
+	usage
+	exit 1
+fi
+
+#Make outdir if absent
+if [ ! -d "$3" ]; then
+	mkdir -p "$3"
+	echo "created output directory path:  $3"
+fi
+
+#File input sequence information
+#  file regex from Illumina 1.8+ (gunzip extracted):
+#  ([0-9A-Za-z]{1,19})_S([0-9A-Za-z]{1,3})_L([0-9]{3})_R[12]_([0-9]{3}).fastq
+SAMPLE=$(basename $1 | cut -d . -f 1 | cut -d _ -f 1)
+
+#Filename handling
+if [[ $1 == *.gz && $2 == *.gz ]]; then  #both files are gunzipped
+	SAMPLEL=$(basename $1 .gz)
+	SAMPLER=$(basename $2 .gz)
+	echo "extracting the gunzipped file $1..."
+	gunzip -c "$1" > "$3"/"$SAMPLEL"
+	echo "$1 was extracted..."
+	SEQ1="$3"/"$SAMPLEL"
+	echo "extracting the gunzipped file $2..."
+	gunzip -c "$2" > "$3"/"$SAMPLER"
+	echo "$2 was extracted..."
+	SEQ2="$3"/"$SAMPLER"
+elif [[ $1 == *q && $2 == *q ]]; then  #both files are fastq format
+	echo "both are FastQ format..."
+	SEQ1="$1"
+	SEQ2="$2"
+elif [[ $1 == *.gz && $2 == *q ]]; then
+	SAMPLEL=$(basename $1 .gz)
+	echo "extracting the gunzipped file $1..."
+	gunzip -c "$1" > "$3"/"$SAMPLEL"
+	echo "$1 was extracted..."
+	SEQ1="$3"/"$SAMPLEL"
+	SEQ2="$2"  #$2 is still in fastq format
+elif [[ $1 == *q && $2 == *.gz ]]; then
+	SAMPLER=$(basename $2 .gz)
+	SEQ1="$1"  #$1 is still in fastq format
+	echo "extracting the gunzipped file $2..."
+	gunzip -c "$2" > "$3"/"$SAMPLER"
+	echo "$2 was extracted..."
+	SEQ2="$3"/"$SAMPLER"
+else
+	usage
+	exit 1
+fi
+wait
+
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo " $SEQ1 and $SEQ2 sequences were read in..."
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Count total nucleotides
+TN1=$(awk 'BEGIN {SUM=0;} {if(NR%4==2) {SUM+=length($0);}} END {print SUM;}' $SEQ1)
+TN2=$(awk 'BEGIN {SUM=0;} {if(NR%4==2) {SUM+=length($0);}} END {print SUM;}' $SEQ2)
+BP_TOT="$(($TN1 + $TN2))"
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo " counted the total nucleotides..."
+echo "        Total: $BP_TOT"
+echo "        R1:    $TN1"
+echo "        R2:    $TN2"
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+OPSYS=$(uname -s)
+
+#Count nucleotides >=Q20 and >=Q30 for Illumina 1.8+
+if [[ "$OPSYS" == Linux ]]; then  #should be linux where sed default is GNU sed
+	Q30L=$(sed -n '4~4'p $SEQ1 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q30R=$(sed -n '4~4'p $SEQ2 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q20to30L=$(sed -n '4~4'p $SEQ1 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m)
+	Q20to30R=$(sed -n '4~4'p $SEQ2 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m) 
+	Q20L="$(($Q20to30L + $Q30L))"
+	Q20R="$(($Q20to30R + $Q30R))"
+elif [[ "$OPSYS" == Darwin ]]; then  #use gsed instead of sed in Mac OS X here
+	Q30L=$(gsed -n '4~4'p $SEQ1 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q30R=$(gsed -n '4~4'p $SEQ2 | grep -o '[\?@A-J]' | paste -s -d"\0" - | wc -m)
+	Q20to30L=$(gsed -n '4~4'p $SEQ1 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m)
+	Q20to30R=$(gsed -n '4~4'p $SEQ2 | grep -o '[5-9:\;\<=\>]' | paste -s -d"\0" - | wc -m) 
+	Q20L="$(($Q20to30L + $Q30L))"
+	Q20R="$(($Q20to30R + $Q30R))"
+else
+	echo 'ERROR: Your operating system does not appear to be supported.' >&2
+	exit 1
+fi
+wait
+Q20_TOT="$(($Q20L + $Q20R))" 
+Q30_TOT="$(($Q30L + $Q30R))" 
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' counted the Q20+ and Q30+ nucleotides...'
+echo "        ${Q20L} nucleotides are >=Q20 in $SEQ1" 
+echo "        ${Q30L} nucleotides are >=Q30 in $SEQ1" 
+echo "        ${Q20R} nucleotides are >=Q20 in $SEQ2" 
+echo "        ${Q30R} nucleotides are >=Q30 in $SEQ2" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Calculate percentages of >=Q20 and >=Q30
+PQ20L="$(echo "scale=2;($Q20L/$TN1)*100" | bc)"
+PQ20R="$(echo "scale=2;($Q20R/$TN2)*100" | bc)"
+PQ30L="$(echo "scale=2;($Q30L/$TN1)*100" | bc)"
+PQ30R="$(echo "scale=2;($Q30R/$TN2)*100" | bc)"
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' calculated the percentages of Q20+ and Q30+...'
+echo "        ${PQ20L}% nucleotides are >=Q20 in $SEQ1" 
+echo "        ${PQ30L}% nucleotides are >=Q30 in $SEQ1" 
+echo "        ${PQ20R}% nucleotides are >=Q20 in $SEQ2" 
+echo "        ${PQ30R}% nucleotides are >=Q30 in $SEQ2" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Count number of reads
+NUMLN_L=$(wc -l $SEQ1| awk '{print $1}')
+NUMLN_R=$(wc -l $SEQ2 | awk '{print $1}')
+wait
+NUM_L="$(($NUMLN_L / 4))"
+NUM_R="$(($NUMLN_R / 4))"
+READ_TOT="$(($NUM_L + NUM_R))"
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' counted the number of reads...'
+echo "        There are $NUM_L reads in $SEQ1" 
+echo "        There are $NUM_R reads in $SEQ2" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+#Create results output file
+printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
+Sample_Name Q20_Total_[bp] Q30_Total_[bp] Q20_R1_[bp] Q20_R2_[bp] Q20_R1_[%] Q20_R2_[%] Q30_R1_[bp] Q30_R2_[bp] Q30_R1_[%] Q30_R2_[%] Total_Sequenced_[bp] Total_Sequenced_[reads] NUMR1_[bp] NUMR2_[bp] \
+"$SAMPLE" "$Q20_TOT" "$Q30_TOT" "$Q20L" "$Q20R" "$PQ20L%" "$PQ20R%" "$Q30L" "$Q30R" "$PQ30L%" "$PQ30R%" "$BP_TOT" "$READ_TOT" "$NUM_L" "$NUM_R" \
+> "$3"/QualAssessRawSeqs_"$SAMPLE"_results.tab ;
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' created results output file...'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+if [[ "$OPSYS" == Linux ]]; then
+	R1FILEPATH=$(readlink -m $1)
+	R2FILEPATH=$(readlink -m $2)
+elif [[ "$OPSYS" == Darwin ]]; then
+	R1FILEPATH=$(echo `pwd`/`ls "$1"`)
+	R2FILEPATH=$(echo `pwd`/`ls "$2"`)
+fi
+
+[[ $1 == *.gz ]] && rm -f "$3"/"$SAMPLEL" 
+[[ $2 == *.gz ]] && rm -f "$3"/"$SAMPLER"
+
+#Create log file
+printf "`date`\n$USER\n%s\n%s\n\n" \
+"$R1FILEPATH" "$R2FILEPATH" \
+> "$3"/QualAssessRawSeqs_"$SAMPLE"_results.log ;
+wait
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo ' created log output file...'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo " Quality assessment of $SAMPLE raw sequences completed" 
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..a63580a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,62 @@
+# Misc Genomics Scripts
+
+### Requirements
+ - python 2.7 with biopython and the full scipy stack
+
+***
+# FastA manipulation and statistics
+- **calc.ATCG.content.bash**: a unix way to quickly get A,T,C,G,N,- content from a FastA file; handles linewraps and multiple records
+
+- **filter.contigs.py**: cleans up a _de novo_ assembly from SPAdes, Velvet, or IDBA (requires biopython). IDBA includes space-delimited data in their contig headers, and because SeqIO parses on whitespace, these will need to be removed or replaced (e.g., `sed -i 's/ /|/g' assembly.fna`). SPAdes and Velvet lack whitespace in their contig deflines, so those output files can be directly fed into this filtering script.
+
+    **Example batch usage**:
+    If there are many SPAdes assembly output directories beginning with 3009 that need filtering, first cd into the parent dir containing all of the 3009\* dirs and execute: `for F in 3009*/contigs.fasta; do B=$(dirname $F | awk -F \/ '{print $1}'); filter.contigs.py -i $F -g -m -c 5 -l 250 -o "$B".fna; done` This took me 1 min for 340 assemblies.
+
+- **find.dupes.bash**: given a FastA file, identifies repetitive regions, and outputs a BED file; flexible opts for defining repetitive sites; depends on BEDTools and MUMmer (nucmer)
+
+
+***
+# Fetching data from NCBI
+
+- **biosample2FastQ.py**: download FastQ read files from NCBI for a given BioSample (or SRR) accession
+
+- **genbankacc2gbk.py** A GenBank file is fetched from NCBI given an accession number. When more than one accession is provided (e.g., for taxa with >1 chromosome or harboring plasmids) all records are merged into a single output file. The `--min-length` option ensures unusually small sequence sizes don't make their way into downstream analyses. Biopython is used to avoid a dependency on efetch.
+
+***
+# GenBank file manipulations
+
+- **extract.nucl.from.GBK.py**: Specify a search term such as a gene name or locus_tag and extract its nucleotide sequence. An ERROR message is printed if the query returns more than one or no hit.
+- **gbk2proteome.molec.weights.py**: prints molecular weights of all proteins from coding sequences to stdout and provides the corresponding locus_tag and product for each as well. Handles unknown residues in proteins ('X') by estimating each as 128.16 Daltons and appends an '~' in front of the calculated molecular weight to indicate approximation.
+- **locus_tag2faa.py**: given a locus tag, an amino acid FastA is printed to stdout
+
+***
+# Cleaning up disk space
+
+- BLAST searching requires index files that can be easily and quickly re-generated, so remove all leftover binary files within $HOME: `find $HOME -type f -regextype posix-extended -regex '.*\.(nhr|nih|nin|nog|nsd|nsi|nsq|psi|psq)' -print | xargs rm -v`
+- SPAdes keeps a lot of intermediate files, so delete these but keep essential log and FastA files to repeat the assembly if necessary: `prune.SPAdes.assembly.dirs.bash $HOME`
+
+***
+#### Example Installation of *'bpy2'* environment
+ 1 - get anaconda
+
+     cd ~/Downloads/
+     wget https://repo.continuum.io/archive/Anaconda2-4.4.0-Linux-x86_64.sh
+     chmod u+x Anaconda2-4.4.0-Linux-x86_64.sh
+     bash Anaconda2-4.4.0-Linux-x86_64.sh
+ 2 - make it available
+
+     echo 'export PATH="$LAB_HOME/.anaconda2/bin:$PATH"' >> ~/.bashrc
+     source ~/.bashrc
+ 3 - create an environment called 'bpy2' with Python 2.7.12
+
+     conda create -n bpy2 python=2.7.12
+ 4 - hop into the bpy2 env
+
+     source activate bpy2
+ 5 - install modules within the bpy2 environment
+
+     conda config --add channels bioconda
+     conda install biopython=1.68 dendropy=4.2.0 matplotlib=2.0.0 numpy=1.12.1 pandas=0.19.2 readline=6.2 reportlab=3.4.0 ruffus=2.6.3 scipy=0.19.0 seaborn=0.7.1 scikit-learn=0.18.1 sqlite=3.13.0
+ 6 - get out of the environment
+
+     source deactivate
diff --git a/SolexaQA.and.SPAdes.sh b/SolexaQA.and.SPAdes.sh
new file mode 100755
index 0000000..1984592
--- /dev/null
+++ b/SolexaQA.and.SPAdes.sh
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+
+[[ "$1" == "" || "$1" == "--help" || "$1" == "-h" ]] && {echo 'Proj dir required as input'; exit 1;}
+
+# Setup Proj where RawFQs already exist
+mkdir -p "$1"/{TrimFQs,Asm}
+cd "$1"/RawFQs
+
+# Qual Trim
+for i in *_L001_R1_001.fastq; do
+	b=$(basename $i _R1_001.fastq);
+	SolexaQA++ dynamictrim $b_L001_R1_001.fastq $b_L001_R2_001.fastq -d ../TrimFQs --sanger -h 20;
+	SolexaQA++ lengthsort ../TrimFQs/$b_L001_R1_001.fastq.trimmed ../TrimFQs/$b_L001_R2_001.fastq.trimmed -d ../TrimFQs -l 50;
+done
+
+# Merge PDF summaries of trimming
+cd ../TrimFQs
+gs -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -dPDFSETTINGS=/prepress -q -sOutputFile=Summary_Q20_Trim.pdf *.fastq_trimmed.segments_hist.pdf
+gs -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -dPDFSETTINGS=/prepress -q -sOutputFile=Summary_Q20_Trim.Sort.pdf *.fastq.trimmed.summary.txt.pdf
+rm *.fastq_trimmed.segments_hist.pdf *.fastq.trimmed.summary.txt.pdf 
+
+# Rename file extensions because my QA script && SPAdes mandate FQ or FASTQ extension
+rename "s/\.fastq\.trimmed\.paired/\.trimmed\.paired\.fq/" *.fastq.trimmed.paired
+rename "s/\.fastq\.trimmed\.single/\.trimmed\.single\.fq/" *.fastq.trimmed.single
+
+# Assemble
+for i in *.trimmed.single.fq; do
+	b=$(basename $i _L001_R1_001.trimmed.single.fq);
+	spades.py -k 41,79,85,97 --careful --phred-offset 33 --pe1-1 "$b"_L001_R1_001.trimmed.paired.fq --pe1-2 "$b"_L001_R2_001.trimmed.paired.fq --pe1-s "$b"_L001_R1_001.trimmed.single.fq -o ../Asm/$b -t 30;
+done
diff --git a/TETRA.py b/TETRA.py
new file mode 100755
index 0000000..69d523e
--- /dev/null
+++ b/TETRA.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+
+
+import collections
+import itertools
+import os
+import sys
+from argparse import ArgumentParser
+from math import sqrt
+
+from Bio import SeqIO
+from regex import findall
+from scipy.stats.mstats import pearsonr
+
+def parseArgs():
+	parser = ArgumentParser(description='Given a pair of FastA nucleotide '
+		'files, calculates observed and expected tetranucleotide frequencies, '
+		'computes Z-scores for each tetranucleotide, and reports the Pearson '
+		'correlation coefficient', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-1', '--set1', required=True, metavar='FILE',
+		help='first input FastA sequence file')
+	req.add_argument('-2', '--set2', required=True, metavar='FILE',
+		help='second input FastA sequence file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-l', '--min-length', type=int, metavar='INT',
+		default=1000, help='minimum sequence length (base pairs) to use '
+		'in kmer frequency calculations [1000]')
+	return parser.parse_args()
+
+def nuc_cln(seq):
+	if not len(set(seq) - set(['A', 'C', 'G', 'T'])):
+		return True
+	sys.stderr.write('WARNING: {} kmer sequence contains illegal '
+					'characters; skipping it...\n'.format(seq))
+	return False
+
+def gen_kmers(k):
+	for kmer in itertools.product(('A', 'C', 'G', 'T'), repeat=k):
+		yield ''.join(kmer)  # faster than appending to string
+
+def calc_zscores(di, tri, tet):
+	# for each kmer, calc expected frequencies
+	# according to the maximal order (k-1, k-2, ...) Markov model
+	kmers_exp = {}
+	for mer in [kmer for kmer in tet if nuc_cln(kmer)]:
+		kmers_exp[mer] = 1. * tri[mer[:3]] * tri[mer[1:]] / di[mer[1:3]]
+
+	# for each kmer, calc the stdev and Z-score
+	kmers_std = {}
+	kmers_z  = {}
+	for mer, exp in kmers_exp.items():
+		two = di[mer[1:3]]
+		kmers_std[mer] = sqrt(exp * (two-tri[mer[:3]]) * (two-tri[mer[1:]]) / (two*two))
+		try:
+			kmers_z[mer] = (tet[mer]-exp) / kmers_std[mer]
+		except ZeroDivisionError: # if an individual kmer's stdev=0
+			kmers_z[mer] = 1 / (two*two)
+	return kmers_z
+
+def cnt_kmers(infile, minlen):
+	di, tri, tet  = [collections.Counter() for _ in range(4 - 1)]
+	for rec in SeqIO.parse(infile, 'fasta'):
+		if len(rec.seq) < minlen:
+			sys.stderr.write('INFO: skipping {} due to small size...\n'.format(rec.id))
+			continue
+		for seq in [str(rec.seq).upper(),
+					str(rec.seq.reverse_complement()).upper()]:
+			# NOTE: mono tallies unnecessary
+			# for n in ('A', 'C', 'G', 'T'):
+			# 	mono[n] += seq.count(n)
+			# NOTE: count func doesnt tally overlaps so cant use for kmers
+			# Prefer regex.findall overlapping func for speed (written in C); this
+			# method avoids the check with nuc_cln(), so its quicker for shortmers
+			for k, c in [(2, di), (3, tri)]:
+				for kmer in list(gen_kmers(k)):
+					c[kmer] += len(findall(kmer, seq, overlapped=True))
+			# slice across the contig instead of iterating over each gen_kmers
+			for i in range(len(seq) - 4 + 1):
+				tet[seq[i:i + 4]] += 1
+	return calc_zscores(di, tri, tet)
+
+def main():
+	opts = parseArgs()
+	minlen = opts.min_length
+
+	t1 = cnt_kmers(os.path.abspath(os.path.expanduser(opts.set1)), minlen)
+	t2 = cnt_kmers(os.path.abspath(os.path.expanduser(opts.set2)), minlen)
+
+	tetmers = sorted(list(gen_kmers(4)))
+	zscores = [[t1.get(t,0) for t in tetmers], [t2.get(t,0) for t in tetmers]]
+	r_val, p_val = pearsonr(zscores[0], zscores[1])
+	print '{}\t{}\t{}'.format(r_val, opts.set1, opts.set2)
+
+if __name__ == '__main__':
+	main()
diff --git a/VFDB2ProkkaDB.py b/VFDB2ProkkaDB.py
new file mode 100755
index 0000000..dc7ee20
--- /dev/null
+++ b/VFDB2ProkkaDB.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+
+import os
+from argparse import ArgumentParser
+from shutil import copyfile
+from string import replace
+from Bio import SeqIO
+from Bio.Alphabet import generic_protein
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def parseArgs():
+	parser = ArgumentParser(add_help=False, description='Converts VFDB '
+		'protein FastA file into a Prokka-friendly FastA format '
+		'to create a custom annotation database which can then be provided '
+		'to Prokka as `--proteins <outfile>`. If the database has been '
+		'parsed for a particular genus, naming the output file as the '
+		'genus.faa and specifying the Prokka genus database path (-d) enables '
+		'the `--usegenus` option in Prokka.')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, help='input multi-FastA'
+		' protein file from http://www.mgc.ac.cn/VFs/download.htm '
+		'doi:10.1093/nar/gkv1239', metavar='FILE')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-d', '--setup-db', action=None, metavar='PATH',
+		help='copy output file to specified database location, e.g., '
+		'$HOME/.linuxbrew/opt/prokka/db/genus '
+		'and format the database so that Prokka can now use it; requires '
+		'prokka to be exported in $PATH')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='output file [./<infile>.faa]')
+	return parser.parse_args()
+
+def main():
+	args = parseArgs()
+	infile  = args.infile
+	cfg_db  = args.setup_db
+	if args.outfile:
+		outfile = args.outfile
+	else:
+		outfile = os.path.join(os.getcwd(), os.path.basename(infile) + '.faa')
+	if not os.path.exists(os.path.dirname(outfile)):
+		os.mkdir(os.path.dirname(outfile))
+
+	mfasta = SeqIO.parse(infile, 'fasta')
+	revised_recs = []
+	for rec in mfasta:
+		rd = rec.description
+		s  = rd.split(' ')
+		accession   = s[0]
+		gene_name   = s[1].lstrip('(').rstrip(')')
+		description = replace(' '.join(s[2:]), '] [', ' from ')
+		prot_seq    = str(rec.seq)
+		defline     = '~~~{}~~~{}'.format(gene_name, description)
+		revised_rec = SeqRecord(Seq(prot_seq, generic_protein), id=accession,
+			description=defline)
+		revised_recs.append(revised_rec)
+	SeqIO.write(revised_recs, outfile, 'fasta')
+
+	if cfg_db is not None:
+		db = os.path.join(cfg_db, os.path.basename(outfile).split('.')[:-2][0])
+		copyfile(outfile, db)
+		os.system('prokka --setupdb')
+
+if __name__ == '__main__':
+	main()
diff --git a/backbone2bed.py b/backbone2bed.py
new file mode 100755
index 0000000..d1a2e6c
--- /dev/null
+++ b/backbone2bed.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+
+import argparse
+import os
+import sys
+
+def parseArgs():
+	parser = argparse.ArgumentParser(description='extracts alignment '
+		'coordinates in a Mauve or Parsnp backbone file and saves as '
+		'a BED format', add_help=False, epilog='NOTE: unaligned sites '
+		'can be identified with bedtools complement')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', metavar='FILE',
+		required=True, help='input backbone file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--col', type=int, default=1, metavar='INT',
+		help='start column for coordinate extraction [1]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='output BED file [stdout]')
+	return parser.parse_args()
+
+def main():
+	args   = parseArgs()
+	infile = os.path.abspath(os.path.expanduser(args.infile))
+	col    = args.col
+	if args.outfile is None:
+		out = sys.stdout
+	else:
+		out = open(os.path.abspath(os.path.expanduser(args.outfile)), 'w')
+
+	with open(infile) as ifh:
+		hdr = next(ifh).rstrip('\n').split('\t')
+		chrom = hdr[1-col].rstrip('_start').lstrip('>')
+		for ln in ifh:
+			l = ln.rstrip('\n').split('\t')
+			out.write('{}\t{}\t{}\n'.format(
+				chrom, int(l[1-col].lstrip('-')), int(l[col].lstrip('-'))))
+
+if __name__ == '__main__':
+	main()
diff --git a/bam2fasta.py b/bam2fasta.py
new file mode 100755
index 0000000..2151750
--- /dev/null
+++ b/bam2fasta.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+
+
+import argparse
+import os
+import sys
+
+import pysam
+from Bio import SeqIO, Seq, SeqRecord
+
+def parseArgs():
+	parser = argparse.ArgumentParser(description='extracts read sequences '
+		'aligned to a reference from a BAM, CRAM, or SAM file and outputs '
+		'the reads in FastA format', add_help=False, epilog='alternative to '
+		'Picard\'s SamToFastq and HudsonAlpha\'s bam2fastq')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', metavar='FILE',
+		required=True, help='input BAM or SAM file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='output FastA file [stdout]')
+	return parser.parse_args()
+
+def bam_to_seqrec(infile):
+	''' converts SAM or BAM file to Biopython.SeqRecord object '''
+	if infile.endswith('.bam')
+		alns = pysam.AlignmentFile(infile, 'rb')
+	elif infile.endswith('.sam')
+		alns = pysam.AlignmentFile(infile, 'r')
+	elif infile.endswith('.cram')
+		alns = pysam.AlignmentFile(infile, 'rc')
+	else:
+		sys.stderr.write('ERROR: unable to detect whether input file is a BAM '
+			'or SAM format based on filename suffix\n')
+		sys.exit(1)
+	for read in alns:
+		seq = Seq.Seq(read.seq)
+		if read.is_unmapped:
+			continue
+		if read.is_reverse: #read aligned to the negative strand of reference
+			seq = seq.reverse_complement()
+		rec = SeqRecord.SeqRecord(seq, read.qname, '', '')
+		yield rec
+
+def main(infile):
+	args   = parseArgs()
+	infile = os.path.abspath(os.path.expanduser(args.infile))
+	if args.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(args.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+
+	SeqIO.write(bam_to_seqrec(infile), ofh, 'fasta')
+
+if __name__ == '__main__':
+	main()
diff --git a/bbh.clust.extract.py b/bbh.clust.extract.py
new file mode 100755
index 0000000..468bbb0
--- /dev/null
+++ b/bbh.clust.extract.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+
+
+import os
+from argparse import ArgumentParser
+from glob import glob
+from time import strftime
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Extracts core orthologous sequences from clustered bidirectional best hits (BBH)', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', metavar='FILE', required=True, help='tab-delimited input listing clustered sequence identifiers')
+	req.add_argument('-d', '--indir', metavar='DIR', required=True, help='directory of FastA files containing sequence files used to generate the infile')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-b', '--by-sample', action='store_true', default=False, help='output sequence files according to sample name rather than by orthologous cluster group')
+	opt.add_argument('-c', '--core', metavar='FLOAT', type=float, default=1, help='fraction of samples a sequence must be in (per cluster) to be considered core [1.0]')
+	opt.add_argument('-e', '--ext', metavar='STR', type=str, default='.fa', help='file extension to append to each extracted FastA file [.fa]')
+	opt.add_argument('-h', '--help', action='help', help='show this help message and exit')
+	opt.add_argument('-l', '--paralogs', action='store_true', default=False, help='output clusters with paralogs as well')
+	opt.add_argument('-o', '--outpath', metavar='PATH', default=None, help='output directory [./BBH.clust.extracts--<date>_<time>]')
+	opt.add_argument('-p', '--pref', metavar='STR', type=str, default='', help='prefix to discard before extracting sequence names from input FastA files [None]')
+	opt.add_argument('-s', '--suff', metavar='STR', type=str, default='.faa', help='suffix to discard when extracting sequence names from input FastA files [.faa]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+
+	# Grab sample ID names from files within input dir
+	sample_ids = []
+	sample_files = sorted(glob(os.path.join(opt.indir, opt.pref+'*'+opt.suff)))
+	for s in sample_files:
+		sample_ids.append(os.path.basename(s).lstrip(opt.pref).rstrip(opt.suff))
+	if opt.outpath is not None:
+		outpath = os.path.abspath(opt.outpath)
+	else:
+		autocreated_dirname = 'BBH.clust.extracts--' + strftime('%d%b%Y_%-I:%M%p').upper()
+		outpath = os.path.join(os.getcwd(), autocreated_dirname)
+
+	if opt.by_sample:
+		for p in [os.path.join(outpath, s) for s in sample_ids]:
+			if not os.path.exists(p):
+				os.makedirs(p)
+
+		# Get core sequence identifiers
+		clust, ortho, par = 0, 0, 0
+		core_ids = []
+		with open(opt.infile) as f:
+			for line in f:
+				clust += 1
+				l = line.rstrip('\n').split('\t')
+				if len([s for s in l if s != ''])/float(len(l)) >= opt.core:
+					if any(',' in s for s in l):
+						par += 1
+						if opt.paralogs:
+							core_ids.append(l)
+					else:
+						ortho += 1
+						core_ids.append(l)
+		trs_ids = sorted([sorted([row[i] for row in core_ids]) for i in range(len(core_ids[1]))])
+
+		# Extract core sequences
+		for sid, sample_file, sample in zip(sample_ids, sample_files, trs_ids):
+			mfa_idx = SeqIO.index(sample_file, 'fasta')
+			for locus in sample:
+				if ',' in locus:
+					tags = locus.split(',')
+					for t in tags:
+						with open(os.path.join(outpath, sid, t+opt.ext), 'w') as o:
+							o.write(mfa_idx.get_raw(t))
+				else:
+					with open(os.path.join(outpath, sid, locus+opt.ext), 'w') as o:
+						o.write(mfa_idx.get_raw(locus))
+
+	else:
+		# Read in all FastA files
+		mfasta_idx = {}
+		for faa in sample_files:
+			faa_idx = SeqIO.index(faa, 'fasta')
+			mfasta_idx.update(faa_idx)
+
+		# Get sequences
+		clust, ortho, par = 0, 0, 0
+		with open(opt.infile) as f:
+			for line in f:
+				clust += 1
+				l = line.rstrip('\n').split('\t')
+				if len([s for s in l if s != ''])/float(len(l)) >= opt.core:
+					if any(',' in s for s in l):
+						par += 1
+						if opt.paralogs:
+							p = os.path.join(outpath, 'para-clust_' + str(par))
+							if not os.path.exists(p):
+								os.makedirs(p)
+							for tag in l:
+								if ',' in tag:
+									tags = tag.split(',')
+									for t in tags:
+										SeqIO.write(mfasta_idx[t],
+											os.path.join(p, t + opt.ext), 'fasta')
+								else:
+									SeqIO.write(mfasta_idx[tag],
+										os.path.join(p, tag + opt.ext), 'fasta')
+					else:
+						ortho += 1
+						p = os.path.join(outpath, 'ortho-clust_' + str(ortho))
+						if not os.path.exists(p):
+							os.makedirs(p)
+						for tag in l:
+							SeqIO.write(mfasta_idx[tag],
+								os.path.join(p, tag + opt.ext), 'fasta')
+
+	# Summarize counts
+	print '{} total clusters'.format(clust)
+	print '{} clusters of core homologs have at least one paralog'.format(par)
+	print '{} ({}% of input clusters) core orthologs found per sample'.format(
+			ortho, round(float(ortho)/clust*100, 3))
+
+if __name__ == '__main__':
+	main()
diff --git a/bbh.cluster.py b/bbh.cluster.py
new file mode 100755
index 0000000..861651b
--- /dev/null
+++ b/bbh.cluster.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+
+
+import os
+import shutil
+import subprocess as sp
+import sys
+from argparse import ArgumentParser
+from cmath import sqrt
+from decimal import Decimal, ROUND_HALF_UP
+from glob import glob
+from multiprocessing import cpu_count
+from tempfile import mkdtemp
+from time import strftime
+
+def parseArgs():
+	parser = ArgumentParser(description='Lists and quantifies homologous'
+		' sequence clusters from bidirectional best hits (BBH).',
+		epilog='Note: Output is saved as bbh.clust.{tab,stats.txt}, so if'
+		' iteratively testing parameters on the same dataset (e.g., inflation'
+		' effects), rename it after each or it will be overwritten.')
+	subparsers = parser.add_subparsers(title='subcommands',
+		metavar='<input type>',
+		description='One of the two is mandatory to specify input type.'
+		' Executing either subcommand along with --help lists their optional'
+		' and mandatory parameters.')
+	a = subparsers.add_parser('DIR', help='Input directory containing pairs'
+		' of BBH alignment files to cluster. Sample names are extracted from'
+		' filenames and are used as query prefixes to locate sequences, i.e.,'
+		' sequence identifiers must begin with the sample name.')
+	a.add_argument('-c', '--data-column', metavar='INT', type=int, default=12,
+		help='column number of data values to use for clustering; Default, bit'
+		' score [12]')
+	a.add_argument('-i', '--indir', metavar='PATH', required=True,
+		help='input directory containing BBH files to cluster')
+	a.add_argument('-k', '--keep', default=False, action='store_true',
+		help='keep temporary files in outpath')
+	a.add_argument('-p', '--pref', metavar='STR', type=str, default='bbh.',
+		help='prefix of pairwise BBH filenames [bbh.]')
+	a.add_argument('-s', '--suff', metavar='STR', type=str,
+		default='.filt.tab', help='suffix of pairwise BBH filenames'
+		' [.filt.tab]')
+	a.add_argument('-d', '--delim', metavar='STR', type=str, default=',',
+		help='delimiter between sample names in pairwise BBH filenames [,]')
+	a.add_argument('-I', '--inflation', metavar='FLOAT', type=float,
+		default=1.5, help='main inflation value for Markov clustering [1.5]')
+	a.add_argument('-o', '--outpath', metavar='PATH', default=None,
+		help='output directory [./BBH.clust--<date>_<time>]')
+	a.add_argument('-t', '--threads', metavar='INT', type=int, default=0,
+		help='number of threads [all]')
+	a.add_argument('-x', '--xoptmcl', metavar='\'STR\'', type=str,
+		default=None, help='extra commands to pass to mcl (e.g,.'
+		' \'-scheme 7\' or\n\'-pct 95\') [none]')
+	b = subparsers.add_parser('ABC', help='ABC format file summarizing'
+		' all-vs-all BBHs')
+	b.add_argument('-a', '--abc', metavar='FILE', required=True,
+		help='input ABC format file summarizing all-vs-all BBHs to cluster')
+	b.add_argument('-k', '--keep', default=False, action='store_true',
+		help='keep temporary files in outpath')
+	b.add_argument('-n', '--names', metavar='STR,STR,STR[...]', required=True,
+		help='comma-delimited sample names present in ABC input file as well'
+		' as prefixes to each sequence identifier (nodes and edges)')
+	b.add_argument('-I', '--inflation', metavar='FLOAT', type=float,
+		default=1.5, help='main inflation value for Markov clustering [1.5]')
+	b.add_argument('-o', '--outpath', metavar='PATH', default=None,
+		help='output directory [./BBH.clust--<date>_<time>]')
+	b.add_argument('-t', '--threads', metavar='INT', type=int, default=0,
+		help='number of threads [all]')
+	b.add_argument('-x', '--xoptmcl', metavar='\'STR\'', type=str,
+		default=None, help='extra commands to pass to mcl (e.g,.'
+		' \'-scheme 7\' or\n\'-pct 95\') [none]')
+	return parser.parse_args()
+
+def require_dependency(dep):
+	for path in os.environ.get('PATH', '').split(':'):
+		if os.path.exists(os.path.join(path, dep)) and \
+		not os.path.isdir(os.path.join(path, dep)):
+			return True
+	sys.stderr.write('ERROR: {} unavailable; not in $PATH\n'.format(dep))
+	sys.exit(1)
+
+def calc_sample_nr_from_pairwise_cnt(pairwise_file_count):
+	# NOTE: equation is x^2 - x - n*2 = 0, where n is bbh file combos
+	a, b, c = 1, -1, pairwise_file_count * -2
+	discriminant = (b ** 2) - (4 * a * c)
+	solution1 = (-b - abs(sqrt(discriminant))) / (2 * a)
+	solution2 = (-b + abs(sqrt(discriminant))) / (2 * a)
+	soln1 = int(Decimal(solution1).quantize(Decimal('1'),
+		rounding=ROUND_HALF_UP))
+	soln2 = int(Decimal(solution2).quantize(Decimal('1'),
+		rounding=ROUND_HALF_UP))
+	return [x for x in (soln1, soln2) if x > 0]
+
+def main():
+	opt = parseArgs()
+	require_dependency('mcxload')
+	require_dependency('mcl')
+
+	# I/O handling
+	tmp = mkdtemp()
+	if opt.outpath is not None:
+		outpath = os.path.realpath(os.path.expanduser(opt.outpath))
+	else:
+		autogen_dir = 'BBH.clust--' + strftime('%d%b%Y_%-I:%M%p').upper()
+		outpath = os.path.join(os.getcwd(), autogen_dir)
+	if not os.path.exists(outpath):
+		os.mkdir(outpath)
+
+	# Number of CPUs to use
+	if opts.threads < 1:
+		cpus = str(cpu_count())
+	else:
+		cpus = str(opts.threads)
+
+	# Parse sample names and ABC file handling
+	if opt.indir:
+		pref = opt.pref.strip('\'').strip('"')
+		suff = opt.suff.strip('\'').strip('"')
+		delim = opt.delim.strip('\'').strip('"')
+		indir = os.path.join(os.path.abspath(opt.indir))
+
+		pair_files = glob(indir, pref + '*' + suff)
+		if len(pair_files) < 3:
+			sys.stderr.write('ERROR: too few (< 3) files found\n'.format(
+				pair_files))
+
+		# Estimate sample number(s) from quantity of bbh file quantity
+		estimated_sample_cnts = calc_sample_nr_from_pairwise_cnt(
+			len(pair_files))
+
+		# Parse filenames to get unique sample names and generate ABC file
+		sample_names = set()
+		with open(os.path.join(tmp, 'bbh.groupsummary.abc'), 'w') as o:
+			for pair_file in pair_files:
+				b = os.path.basename(pair_file)
+				s1, s2 = b.lstrip(pref).rstrip(suff).split(delim)
+				sample_names.update([s1, s2])
+				with open(pair_file) as pf:
+					for line in pf:
+						l = line.split('\t')
+						o.write(l[0]+'\t'+l[1]+'\t'+l[opt.data_column-1]+'\n')
+		if not any(x == len(sample_names) for x in estimated_sample_cnts):
+			sys.stderr.write('ERROR: the observed sample name quantity ({})'
+				' is unequal to the expected sample quantity from {} parsed'
+				' bbh filenames\n'.format(len(sample_names),
+					' or '.join(str(x) for x in estimated_sample_cnts),
+					indir))
+			sys.exit(1)
+	elif opt.abc:
+		with open(os.path.realpath(os.path.expanduser(opt.abc))) as f:
+			if next(f).count('\t') != 3:
+				sys.stderr.write('ERROR: expected 3-column tab-delim input\n')
+				sys.exit()
+		abc_file = os.path.realpath(os.path.expanduser(opt.abc))
+		sample_names = opt.names.strip('\'').strip('"').split(',')
+
+	# Execute clustering
+	graph_file = os.path.join(tmp, 'graph.mci')
+	seqids_file = os.path.join(tmp, 'seqids.tab')
+	mcl_file = os.path.join(tmp, 'clust.mcl')
+	cmd_graph = ['mcxload', '--stream-mirror', '-re', 'max', '-abc', abc_file,
+				'-o', graph_file, '--write-binary', '-write-tab', seqids_file]
+	cmd_clust = ['mcl', graph_file, '-I', str(opt.inflation), '-V', 'all',
+				'-use-tab', seqids_file, '-o', mcl_file, '-te', cpus]
+	if opt.xoptmcl:
+		cmd_clust.extend(opt.xoptmcl.strip('\'').strip('"').split(' '))
+	for cmd in [cmd_graph, cmd_clust]:
+		with open(os.devnull, 'wb') as dump:
+			return_code = sp.Popen(cmd, shell=False, stdout=dump, stderr=dump)
+			if return_code.wait() != 0:
+				sys.stderr.write('ERROR: failed system call\n{}\n'.format(
+					' '.join(cmd)))
+				sys.exit()
+
+	# Parse mcl output
+	with open(mcl_file) as mcl_data, \
+	open(os.path.join(outpath, 'bbh.clust.tab'), 'w') as o: 
+		i = 0
+		for line in mcl_data:
+			l = line.rstrip('\n').split('\t')
+			match = ''
+			for n in sample_names:
+				match = match+','.join([m for m in l if m.startswith(n)])+'\t'
+			o.write(match[:-1]+'\n' if match.endswith('\t') else match+'\n')
+			i += 1
+	with open(seqids_file) as f:
+		seqs = sum(1 for l in f)
+	with open(os.path.join(outpath, 'bbh.clust.stats.txt'), 'w') as stats:
+		stats.write('Queried {} samples\nQueried {} total sequences\n' \
+			'Clustered {} sequence groups\n'.format(len(sample_names), seqs,
+				i))
+
+	# Optionally keep intermediate files
+	if opt.keep:
+		if opt.indir:
+			shutil.copy(os.path.join(tmp, 'bbh.groupsummary.abc'),
+				os.path.join(outpath, 'bbh.groupsummary.abc'))
+		for f in ['clust.mcl', 'graph.mci', 'seqids.tab']:
+			shutil.copy(os.path.join(tmp, f), os.path.join(outpath, f))
+	shutil.rmtree(tmp)
+
+if __name__ == '__main__':
+	main()
diff --git a/bbh.pair.py b/bbh.pair.py
new file mode 100755
index 0000000..15fc80d
--- /dev/null
+++ b/bbh.pair.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+
+
+import os
+from argparse import ArgumentParser
+from glob import glob
+from subprocess import Popen
+from sys import exit
+from time import strftime
+
+def parseArgs():
+	parser = ArgumentParser(description='Lists and quantifies bidirectional best hits (BBH) of nucleotide or protein sets. Alignment filters are properly applied in both directions. Requires NCBI BLAST 2.2.29+ or newer', add_help=False,
+	epilog='Output is saved as <outpath>/blast.<set1-ext>,<set2-ext>.tab, <outpath>/blast.<set2-ext>,<set1-ext>.tab, and <outpath>/bbh.<set1-ext>,<set2-ext>.{discard,filt,stats}.tab. If iteratively testing parameters on the same dataset (e.g., percent identity effects) with the --refilter option, rename bbh.*.tab files after each iteration or files will be overwritten.')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-1', '--set1', metavar='FILE', required=True, help='first input FastA sequence file')
+	req.add_argument('-2', '--set2', metavar='FILE', required=True, help='second input FastA sequence file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-b', '--bitscore', metavar='FLOAT', type=float, default=0, help='minimum alignment Bit score [0]')
+	opt.add_argument('-c', '--cpus', metavar='INT', type=str, default='1', help='number of CPUs [1]')
+	opt.add_argument('-e', '--ext', metavar='\'STR\'', type=str, default=None, help='file extension to strip from each set for generating paired output filenames; optionally flanked by single quotes [\'.<ext>\']')
+	opt.add_argument('-f', '--fraction', metavar='FLOAT', type=float, default=30, help='minimum alignment length percentage [30]')
+	opt.add_argument('-h', '--help', action='help', help='show this help message and exit')
+	opt.add_argument('-i', '--identity', metavar='FLOAT', type=float, default=80, help='minimum percent identity [80]')
+	opt.add_argument('-l', '--length', metavar='INT', type=int, default=0, help='minimum alignment character length (sum of all aligned segments and all gaps) [0]')
+	opt.add_argument('-m', '--moleculetype', default='prot', choices=['nucl', 'prot'], help='input molecule type [prot]')
+	opt.add_argument('-o', '--outpath', metavar='PATH', default=None, help='output directory [./BBH.pair--<date>_<time>]')
+	opt.add_argument('--refilter', default=False, action='store_true', help='skip blast system commands and re-filter previously generated blast output from this script with different cutoff parameters')
+	return parser.parse_args()
+
+def main():
+	opts = parseArgs()
+	set1 = os.path.abspath(opts.set1)
+	set2 = os.path.abspath(opts.set2)
+	if opts.outpath is not None:
+		outpath = os.path.abspath(opts.outpath)
+		if not os.path.exists(outpath):
+			os.mkdir(outpath)
+	else:
+		autocreated_dirname = 'BBH.pair--'+strftime('%d%b%Y_%-I:%M%p').upper()
+		outpath = os.path.join(os.getcwd(), autocreated_dirname)
+		os.mkdir(outpath)
+	if opts.ext is not None:
+		b1 = os.path.basename(set1).rstrip(opts.ext.lstrip('\'').rstrip('\''))
+		b2 = os.path.basename(set2).rstrip(opts.ext.lstrip('\'').rstrip('\''))
+	else:
+		b1 = '.'.join(os.path.basename(set1).split('.')[:-1])
+		b2 = '.'.join(os.path.basename(set2).split('.')[:-1])
+
+	if not opts.refilter:
+		# Execute bidirectional blast
+		mol_type = opts.moleculetype 
+		if mol_type == 'nucl':
+			blast = 'blastn'
+		elif mol_type == 'prot':
+			blast = 'blastp'
+		for s1, s2 in [(set1, set2), (set2, set1)]:  #s1 as subj; s2 as query
+			s1b = os.path.basename(s1).rsplit('.')[0]
+			s2b = os.path.basename(s2).rsplit('.')[0]
+			cmd_makedb= ['makeblastdb', '-in', s1, '-input_type', 'fasta',
+						'-out', os.path.join(outpath, s1b), '-dbtype', mol_type]
+			cmd_blast = [blast, '-db', os.path.join(outpath, s1b), '-max_hsps', '1',
+						'-query', s2, '-max_target_seqs', '1', '-num_threads', opts.cpus,
+						'-out', os.path.join(outpath, 'blast.'+s1b+','+s2b+'.tab'),
+						'-outfmt', '6 qseqid sseqid pident length bitscore qcovs']
+			for cmd in [cmd_makedb, cmd_blast]:
+				with open(os.devnull, 'wb') as dump:
+					return_code = Popen(cmd, shell=False, stdout=dump)
+					if return_code.wait() != 0:
+						exit('ERROR: failed system call\n{}\nBLAST 2.2.29+ or newer required'.format(' '.join(cmd)))
+		junk = []
+		for ext in ['*.[np]hr', '*.[np]in', '*.[np]sq']:
+			junk.extend(list(glob(os.path.join(outpath, ext))))
+		for j in junk:
+			os.remove(j)
+
+	# Parse the blast output
+	d = {}
+	hit_s2 = 0
+	with open(os.path.join(outpath, 'blast.'+b2+','+b1+'.tab')) as dat, \
+	open(os.path.join(outpath, 'bbh.'+b2+','+b1+'.discard.tab'), 'w') as discfh:
+		for line in dat:
+			hit_s2 += 1
+			l = line.split('\t')
+			if float(l[2]) >= opts.identity and int(l[3]) >= opts.length and float(l[4]) >= opts.bitscore and float(l[5]) >= opts.fraction:
+				d[(str(l[1]), str(l[0]))] = (float(l[2]), int(l[3]), float(l[4]), float(l[5]))
+			else:
+				discfh.write(line)
+	filt_s2 = len(d)
+	filt_s1 = hit_s1 = bbh = 0
+	with open(os.path.join(outpath, 'blast.'+b1+','+b2+'.tab')) as dat, \
+	open(os.path.join(outpath, 'bbh.'+b1+','+b2+'.discard.tab'), 'w') as discfh, \
+	open(os.path.join(outpath, 'bbh.'+b1+','+b2+'.filt.tab'), 'w') as bbhfh:
+		for line in dat:
+			hit_s1 += 1
+			l = line.split('\t')
+			if float(l[2]) >= opts.identity and int(l[3]) >= opts.length and float(l[4]) >= opts.bitscore and float(l[5]) >= opts.fraction:
+				filt_s1 += 1
+				if (str(l[0]), str(l[1])) in d:
+					bbhfh.write(line)
+					bbh += 1
+			else:
+				discfh.write(line)
+
+	# Report results
+	pbbh = round(float(bbh)/((hit_s1+hit_s2)/2)*100, 3)
+	with open(os.path.join(outpath, 'bbh.'+b1+','+b2+'.stats.tab'), 'w') as stats:
+		stats.write('{},{}\tBBHs:\t{}\t({}%)\n'.format(b1, b2, bbh, pbbh))
+		stats.write('{}\ttotal hits as subject:\t{}\n'.format(b1, hit_s1))
+		stats.write('{}\tdiscarded hits as subject:\t{}\t({}%)\n'.format(b1,
+			(hit_s2-filt_s2), round((hit_s2-filt_s2)/float(hit_s2)*100, 3) ))
+		stats.write('{}\ttotal hits as subject:\t{}\n'.format(b2, hit_s2))
+		stats.write('{}\tdiscarded hits as subject:\t{}\t({}%)\n'.format(b2,
+			(hit_s1-filt_s1), round((hit_s1-filt_s1)/float(hit_s1)*100, 3) ))
+	print '{} BBHs ({}% passed filters)'.format(bbh, pbbh)
+
+if __name__ == '__main__':
+	main()
diff --git a/biosample2FastQ.py b/biosample2FastQ.py
new file mode 100755
index 0000000..0319dc0
--- /dev/null
+++ b/biosample2FastQ.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+
+
+import multiprocessing as mp
+import os
+import sys
+from argparse import ArgumentParser
+from shutil import rmtree
+from tempfile import mkdtemp
+
+def parseArgs():
+	parser = ArgumentParser(description='Downloads FastQ (Phred 33) reads'
+		' given a BioSample accession (SAMN########) or SRA Run accession'
+		' (SRR#######). Depends on Entrez Direct scripts'
+		' http://www.ncbi.nlm.nih.gov/books/NBK179288/ and SRA toolkit'
+		' http://www.ncbi.nlm.nih.gov/books/NBK158899/', add_help=False,
+		epilog='NOTE: EDirect ver 7.50+ uses the API key value from the'
+		' NCBI_API_KEY environment variable')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-a', '--acc', required=True, metavar='STR',
+		help='accession that points to FastQ reads to download')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outdir', metavar='DIR',
+		default=None, help='output directory [./]')
+	# opt.add_argument('--api-key', metavar='STR',
+	# 	default=None, help='API key (64 characters) from NCBI; re-assigns NCBI_API_KEY'
+	# 	' environment variable [None]')
+	return parser.parse_args()
+
+def check_dependency(dep):
+	''' returns a tuple where first item is boolean and second item is the
+	dependency path; symbolic links are not expanded to their real path '''
+	found = False, None
+	for path in os.environ['PATH'].split(os.pathsep):
+		dependency_path = os.path.join(path, dep)
+		if all([os.path.exists(dependency_path),
+		os.path.isfile(dependency_path),
+		os.access(dependency_path, os.X_OK)]):
+			return True, dependency_path
+	return found
+
+def main():
+	opt = parseArgs()
+	acc = opt.acc
+	tmp = mkdtemp()
+	tfh = os.path.join(tmp, acc)
+	if opt.outdir is not None:
+		outdir = os.path.realpath(opt.outdir)
+	else:
+		outdir = os.getcwd()
+
+	if not all([check_dependency('esearch')[0],
+	check_dependency('efetch')[0]]):
+		sys.stderr.write('ERROR: Entrez Direct scripts not found in $PATH.'
+			' Install edirect.\n')
+		sys.exit(1)
+	os.system('esearch -db sra -query {} | efetch -format docsum | '
+			  'grep \'<Runs>\' > {}'.format(acc, tfh))
+
+	download = []
+	with open(tfh, 'r') as run_info:
+		for ln in run_info:
+			if '<Run acc="' in ln:
+				SRR = ln.split('<Run acc="')[1].split('"')[0]
+				download.append(SRR)
+	rmtree(tmp)
+
+	if len(download) > 1:
+		print('downloading {} ...'.format(', '.join(download)))
+	elif len(download) == 1:
+		print('downloading {} ...'.format(download[0]))
+	else:
+		sys.exit('No matches for {}.'.format(acc))
+	
+	if check_dependency('fasterq-dump')[0]:
+		threads_avail = mp.cpu_count()
+		# https://github.com/ncbi/sra-tools/issues/242#issuecomment-549525056
+		if threads_avail < 6:
+			threads = threads_avail
+		else:
+			threads = 6
+		for SRR in download:
+			os.system('fasterq-dump {} -O {} --force --split-files'
+					  ' --print-read-nr --threads {} --temp {} 1> {}'.format(
+						SRR, outdir, threads, tmp, os.devnull))
+			print('  downloaded {}'.format(SRR))
+	elif check_dependency('fastq-dump')[0]:
+		for SRR in download:
+			os.system('fastq-dump -O {} --dumpbase --split-files --readids'
+					  ' -Q 33 -defline-qual \'+\' '
+					  ' --defline-seq \'@$ac_$sn[_$rn]/$ri\' {} 1> {}'.format(
+						outdir, SRR, os.devnull))
+			print('  downloaded {}'.format(SRR))
+	else:
+		sys.stderr.write('ERROR: fastq-dump or fasterq-dump is required but'
+			'both are absent in $PATH. Install sratoolkit.\n')
+		sys.exit(1)
+
+if __name__ == '__main__':
+	main()
diff --git a/calc.ATCG.content.bash b/calc.ATCG.content.bash
new file mode 100755
index 0000000..191baac
--- /dev/null
+++ b/calc.ATCG.content.bash
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+
+function usage { 
+	echo "
+	Usage: `basename $0` input.fasta
+
+	Given a FastA file (with or without linewraps),
+	reports nucleotide frequency including gaps and Ns,
+	GC content, and cumulative length.
+	"
+	}
+
+# check for infile
+[[ "$1" == "" || "$1" == "--help" || "$1" == "-h" ]] && { usage; exit 1;}
+if test -f "$1" -a -r "$1"; then
+	GENOME=$1  # input FastA file
+else
+	usage; exit 1;
+fi
+
+# Calculate full ATCG content
+grep -v '^>' "$GENOME" | tr -d [:space:] > /tmp/sequence.txt
+TOT_NUM_A=$(grep -io 'A' /tmp/sequence.txt | wc -l)
+TOT_NUM_T=$(grep -io 'T' /tmp/sequence.txt | wc -l)
+TOT_NUM_C=$(grep -io 'C' /tmp/sequence.txt | wc -l)
+TOT_NUM_G=$(grep -io 'G' /tmp/sequence.txt | wc -l)
+TOT_NUM_N=$(grep -io 'N' /tmp/sequence.txt | wc -l)
+TOT_NUM_GAP=$(grep -o '-' /tmp/sequence.txt | wc -l)
+rm /tmp/sequence.txt
+
+GC=$(($TOT_NUM_G + $TOT_NUM_C))
+TOT_LEN=$(($GC + $TOT_NUM_A + $TOT_NUM_T + $TOT_NUM_N + $TOT_NUM_GAP))
+GC_PERC=$(echo "scale=1; ($GC / $TOT_LEN) * 100" | bc)
+
+echo "A: $TOT_NUM_A
+T: $TOT_NUM_T
+C: $TOT_NUM_C
+G: $TOT_NUM_G
+N: $TOT_NUM_N
+gaps: $TOT_NUM_GAP
+GC content: $GC_PERC%
+Total length: $TOT_LEN
+"
diff --git a/calc.pairwise.similarities.py b/calc.pairwise.similarities.py
new file mode 100755
index 0000000..e16a457
--- /dev/null
+++ b/calc.pairwise.similarities.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+
+
+from argparse import ArgumentParser
+from itertools import combinations
+from glob import glob
+from re import search, DOTALL
+from shutil import rmtree
+from tempfile import mkdtemp
+import os
+
+def parseArgs():
+	parser = ArgumentParser(description='Computes pairwise percent '
+		'nucleotide similarities by performing local or global alignments. '
+		'Requires the blastn binary from the BLAST+ suite, the '
+		'needle binary from The European Molecular Biology '
+		'Open Software Suite (EMBOSS) or the ggsearch36 binary from '
+		'the FASTA package suite.', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--inpath', required=True, metavar='PATH',
+		help='path containing input files')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-a', '--aligner', choices=['blastn', 'ggsearch36',
+		'needle'], default='blastn', help='binary name to use for local or '
+		'global alignment [blastn]')
+	opt.add_argument('-c', '--cpus', type=int, metavar='INT',
+		default=1, help='number of CPUs to use [1]')
+	opt.add_argument('-e', '--ext', type=str, metavar='STR', default='fasta',
+		help='file extension to find all nucleotide FastA files within the '
+		'specified inpath [fasta]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', metavar='FILE',
+		default='Pairwise.Similarities.tab',
+		help='output file [./Pairwise.Similarities.tab]')
+	opt.add_argument('-p', '--pref', type=str, metavar='STR', default='',
+		help='file prefix to find all nucleotide FastA files within the '
+		'specified inpath [*]')
+	return parser.parse_args()
+
+def main():
+	opts = parseArgs()
+	aligner = opts.aligner
+	inpath  = os.path.abspath(opts.inpath)
+	ext     = opts.ext
+	pref    = opts.pref
+	tmp     = mkdtemp()
+	outfile = os.path.abspath(opts.outfile)
+
+	# Get sorted unique list of tuples
+	files = glob(os.path.join(inpath, '{}*.{}'.format(pref, ext)))
+	uniq = set()
+	for i in combinations(files, 2):
+		if i[0] != i[1]:
+			uniq.add(i)
+	sort_uniq_filepairs = sorted(uniq, key=lambda tupl:tupl[0])
+
+	with open(outfile, 'w') as ofh:
+		for i, j in sort_uniq_filepairs:
+			b1 = os.path.basename(i).rstrip('.' + ext)
+			b2 = os.path.basename(j).rstrip('.' + ext)
+			tmpfile = os.path.join(tmp, b1 + ',' + b2 + '.similarity')
+			
+			# Run global alignments
+			if aligner == 'needle':
+				os.system('needle -asequence {} -snucleotide1 -bsequence '
+				'{} -snucleotide2 -gapopen 10.0 -gapextend 0.5 -outfile '
+				'{} -aformat3 markx2 -awidth3 60 -auto -error'.format(
+					i, j, tmpfile))
+			elif aligner == 'ggsearch36':
+				os.system('ggsearch36 -T {} -b 1 -f 10 -g 0.5 -n -m 0 -O {} -w 80 '
+					'{} {} > {}'.format(opts.cpus, tmpfile, i, j, os.devnull))
+			elif aligner == 'blastn':
+				tmp_b1 = os.path.join(tmp, b1)
+				os.system('makeblastdb -dbtype nucl -in {} -out {} '
+					'> {}'.format(i, tmp_b1, os.devnull))
+				os.system('blastn -num_threads {} -task blastn -outfmt \"6 ppos\" '
+					'-db {} -query {} -out {} > {}'.format(opts.cpus, tmp_b1, j,
+					tmpfile, os.devnull))
+
+			# Parse percent similarity values
+			dat = open(tmpfile).readlines()
+			if aligner == 'needle':  #(Version: EMBOSS:6.6.0.0)
+				f = search(r'#\s+Similarity:\s+\d+\/\d+\s+\(\d+.\d+\%\)\n',
+					''.join(dat))
+				similarity = f.group(0).split('(')[-1].rstrip('%)\n')
+			elif aligner == 'ggsearch36':  #GGSEARCH 36.3.7 Oct, 2014preload9
+				f = search(r'global\/global.+similar.+\n',
+					''.join(dat), flags=DOTALL)
+				similarity = f.group(0).split('% identity (')[-1].split(
+					'% similar)')[0]
+			elif aligner == 'blastn':  #v2.2.31+
+				similarity = dat[0].rstrip('\n')
+			ofh.write('{}\t{}\t{}\n'.format(b1, b2, similarity))
+	rmtree(tmp)
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/calc.percent.core.genome.SNPs.bash b/calc.percent.core.genome.SNPs.bash
new file mode 100755
index 0000000..d256754
--- /dev/null
+++ b/calc.percent.core.genome.SNPs.bash
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+
+function usage { 
+	echo "
+	Usage: `basename $0` -c input_coreSNPs.fasta -r input_ref.fasta
+	
+	Given a SNPs FastA file and the corresponding reference 
+	FastA file, reports the number of SNP sites per sample, the
+	total sites in the reference file, and fraction of reference
+	sites that are SNPs.
+	"
+	}
+
+nopts=$#
+for ((i=1 ; i <= nopts ; i++)); do
+	case $1 in
+		-c | --core)  # FastA format
+			CORESNPS=$2
+			echo "    core SNP file: $2"
+			shift 2
+			;;
+		-r | --ref)  # FastA format
+			REF=$2
+			echo "    ref genome file: $2"
+			shift 2
+			;;
+		-h | --help)
+			usage
+			exit 1
+			;;
+	esac
+done
+
+[[ -z $CORESNPS || -z $REF ]] && { usage; exit 1; }
+
+REF_GENOME=$(grep -v '^>' $REF | tr -d [:space:] | wc -c)
+echo "    found $REF_GENOME sites in the reference file"
+
+TOT_SITES=$(grep -v '^>' $CORESNPS | tr -d [:space:] | wc -c)
+TOT_SMPL=$(grep -c '^>' $CORESNPS)
+SITES_PER_SMPL=$((TOT_SITES / TOT_SMPL))
+echo "    found $SITES_PER_SMPL sites in each sample in $CORESNPS"
+
+CORE_PER_REF=$(echo "scale=4;($SITES_PER_SMPL/$REF_GENOME)*100" | bc)
+echo -e "\n    ${CORE_PER_REF}% of the reference file was identified as core sites\n"
diff --git a/calc.percent.reads.mapped.bash b/calc.percent.reads.mapped.bash
new file mode 100755
index 0000000..b6a595c
--- /dev/null
+++ b/calc.percent.reads.mapped.bash
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+
+function usage { 
+	echo "
+	Usage: `basename $0` -b input_bam_dir [-o ./stats.mapping.tab]
+
+	Given a directory of BAM files, reports mapping statistics
+	to a specified tab-delimited output file. Requires bamtools.
+	"
+	}
+
+nopts=$#
+for ((i=1 ; i <= nopts ; i++)); do
+	case $1 in
+		-b | --bams)  # dir of BAM files
+			BAMDIR=$2
+			echo "    calculating mapping statistics on BAMs in: $2"
+			shift 2
+			;;
+		-o | --out)  # output file (optionally with filepath)
+			OUT=$2
+			echo "    output file saved as: $2"
+			shift 2
+			;;
+		-h | --help)
+			usage
+			exit 1
+			;;
+	esac
+done
+
+# depend checks
+[[ -z $BAMDIR ]] && { usage; exit 1; }
+command -v bamtools >/dev/null 2>&1 || { echo 'ERROR: bamtools not found' >&2; exit 1; }
+
+# default output filename
+[[ -z $OUT ]] && OUT='stats.mapping.tab'
+
+# Create output path and output summary file
+DIR=$(dirname "$OUT")
+if [ ! -d "$DIR" ]; then
+	mkdir -p "$DIR"
+	echo '    Created output dir...'
+else
+	echo "WARNING: Output dir $DIR already exists. Competing files will be overwritten."
+fi
+echo -e "Sample\tReads_Mapped[%]" > "$OUT" # overwrite to avoid appending data to different projects (if script exec >1 with same outfile)
+
+for bam in "$BAMDIR"/*.bam; do
+	b=$(basename "$bam")
+	bamtools stats -in "$bam" > "$DIR"/tmpstatsfull."$b".tmp
+	
+	grep 'Mapped reads' tmpstatsfull."$b".tmp |\
+	 awk 'BEGIN {FS="\t"}; {print $2}' |\
+	 sed 's/[()]//g' > "$DIR"/tmpstatsperc."$b".tmp
+	rm "$DIR"/tmpstatsfull."$b".tmp
+
+	if [ -s tmpstatsperc."$b".tmp ]; then # percent was extracted
+		p=$(cat "$DIR"/tmpstatsperc."$b".tmp)
+		echo -e "$b\t$p" >> "$OUT"
+	else # no percent avail
+		echo -e "$b\tError" >> "$OUT"
+	fi
+	rm "$DIR"/tmpstatsperc."$b".tmp
+done
+
diff --git a/compare.two.FastQ.files.py b/compare.two.FastQ.files.py
new file mode 100755
index 0000000..42c3cfb
--- /dev/null
+++ b/compare.two.FastQ.files.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+
+
+import gzip
+import os
+import shutil
+import sys
+from argparse import ArgumentParser
+from tempfile import mkdtemp
+
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+import numpy as np
+from Bio import SeqIO
+from Bio.SeqIO.QualityIO import FastqGeneralIterator
+
+
+def parse_args():
+    parser = ArgumentParser(
+        description='Compares two FastQ files and reports differences between'
+        ' the two. Initially developed to audit mutated FastQ files and'
+        ' report the number of shared and unshared sequence headers as well'
+        ' as the SNP frequency of artificially mutated sequences.',
+        epilog='NOTE: order between the two files is expected to be sorted '
+        'based on the header names with no missing sequences between the two',
+        add_help=False,
+    )
+    req = parser.add_argument_group('Required')
+    req.add_argument(
+        '-a',
+        '--after',
+        required=True,
+        metavar='FILE',
+        help='modified or processed FastQ sequence file'
+        ' , optionally gunzip compressed',
+    )
+    req.add_argument(
+        '-b',
+        '--before',
+        required=True,
+        metavar='FILE',
+        help='initial FastQ sequence file , optionally gunzip compressed',
+    )
+    opt = parser.add_argument_group('Optional')
+    opt.add_argument(
+        '-o',
+        '--outdir',
+        metavar='PATH',
+        type=str,
+        default=None,
+        help='outpath to save two files (after and before) with differing'
+        ' sequence records [None]',
+    )
+    opt.add_argument(
+        '-h', '--help', action='help', help='show this help message and exit'
+    )
+    return parser.parse_args()
+
+
+def decompress_file(infile, outdir):
+    # Create a new output file name
+    uncompressed_file = os.path.basename(infile).rstrip('.gz')
+    outfile = os.path.join(outdir, uncompressed_file)
+
+    # Decompress the gunzipped file
+    with gzip.open(infile, 'rb') as ifh, open(outfile, 'wb') as ofh:
+        shutil.copyfileobj(ifh, ofh)
+
+    # Send the full path of the decompressed file back
+    return outfile
+
+
+def compare_two_fastq_files(after, before, outdir):
+    comparisons_counted_snps = []
+    sequence_records_with_different_sequences_after = []
+    sequence_records_with_different_sequences_before = []
+    for (
+        title_after,
+        sequence_after,
+        quality_after,
+        title_before,
+        sequence_before,
+        quality_before,
+    ) in zip(FastqGeneralIterator(after), FastqGeneralIterator(before)):
+        # Verify these two records have the same sequence header
+        if str(title_after) != str(title_before):
+            sys.stderr.write(
+                'INFO: skipping {} in {} and {} in {} due to different'
+                ' sequence headers.'.format(
+                    title_after,
+                    os.path.basename(after),
+                    title_before,
+                    os.path.basename(before),
+                )
+            )
+            continue
+
+        # Verify these two records have the same sequence length
+        if len(sequence_after) != len(sequence_before):
+            sys.stderr.write(
+                'INFO: skipping {} in {} and {} in {} due to different'
+                ' sequence lengths.'.format(
+                    title_after,
+                    os.path.basename(after),
+                    title_before,
+                    os.path.basename(before),
+                )
+            )
+            continue
+
+        # Compare the sequence composition between the two for SNPs
+        cnt_SNPs = 0
+        for nucleotide_after, nucleotide_before in zip(
+            sequence_after, sequence_before
+        ):
+            if nucleotide_after != nucleotide_before:
+                cnt_SNPs += 1
+        comparisons_counted_snps.append(cnt_SNPs)
+
+        if outdir is not None:
+            # Construct new FastQ sequence record objects
+            fastq_record_string = '@{}\n{}\n+\n{}\n'.format(
+                title_after, sequence_after, quality_after
+            )
+            new_rec = SeqIO.read(StringIO(fastq_record_string), 'fastq')
+            sequence_records_with_different_sequences_after.append(new_rec)
+            fastq_record_string = '@{}\n{}\n+\n{}\n'.format(
+                title_before, sequence_before, quality_before
+            )
+            new_rec = SeqIO.read(StringIO(fastq_record_string), 'fastq')
+            sequence_records_with_different_sequences_before.append(new_rec)
+
+    # Optionally, write only mutated output
+    if outdir is not None:
+        out_after = os.path.join(outdir, 'different_sequences.after.fastq')
+        out_before = os.path.join(outdir, 'different_sequences.before.fastq')
+        SeqIO.write(
+            sequence_records_with_different_sequences_after,
+            out_after,
+            'fastq',
+        )
+        SeqIO.write(
+            sequence_records_with_different_sequences_before,
+            out_before,
+            'fastq',
+        )
+        print(
+            'INFO: saved all {} sequence records with different'
+            ' sequences'.format(
+                len(sequence_records_with_different_sequences_after)
+            )
+        )
+
+    return comparisons_counted_snps
+
+
+def calculate_stats(list_of_integers):
+    stats = {}
+    stats['q1'] = int(
+        np.percentile(list_of_integers, 25, interpolation='midpoint')
+    )
+    stats['median'] = int(np.median(list_of_integers))
+    stats['q3'] = int(
+        np.percentile(list_of_integers, 75, interpolation='midpoint')
+    )
+    stats['mean'] = int(np.mean(list_of_integers))
+    stats['stdev'] = int(np.std(list_of_integers))
+    stats['total_sequence_records'] = len(list_of_integers)
+    stats['total_SNPs'] = int(np.sum(list_of_integers))
+    stats['most_SNPs_in_a_record'] = int(np.amax(list_of_integers))
+    stats['fewest_SNPs_in_a_record'] = int(np.amin(list_of_integers))
+    return stats
+
+
+def main():
+    opt = parse_args()
+
+    # I/O handling
+    after = os.path.realpath(os.path.expanduser(opt.after))
+    before = os.path.realpath(os.path.expanduser(opt.before))
+    if opt.outdir is None:
+        outdir = None
+    else:
+        outdir = os.path.realpath(os.path.expanduser(opt.outdir))
+
+    # Auto-handle gunzip compressed input
+    tmp = mkdtemp()
+    if after.endswith('.gz'):
+        after = decompress_file(after, tmp)
+    if before.endswith('.gz'):
+        before = decompress_file(before, tmp)
+
+    # Compare the two sequence files
+    comparisons_counted_snps = compare_two_fastq_files(after, before, outdir)
+
+    # Cleanup
+    shutil.rmtree(tmp)
+
+    # Report statistics on SNPs observed between the two sequence sets
+    stats = calculate_stats(comparisons_counted_snps)
+    for k, v in stats.items():
+        print('{} = {}'.format(k.replace('_', ' '), v))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/concatenate.multi-fasta.py b/concatenate.multi-fasta.py
new file mode 100755
index 0000000..87a095a
--- /dev/null
+++ b/concatenate.multi-fasta.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+
+import re
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(add_help=False,
+		description='Combines all sequence records in a multi-FastA file '
+		'into a single sequence record FastA file.')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input multi-FastA file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-c', '--character', type=str, default='N',
+		metavar='STR', help='character to use for insertions between '
+		'sequence records [N]')
+	opt.add_argument('-d', '--defline', type=str, default=None,
+		metavar='STR', help='output sequence record name; if including '
+		'whitespace flank with apostrophes [basename infile]')
+	opt.add_argument('-o', '--outfile', metavar='FILE', default=None,
+		help='output FastA file [stdout]')
+	opt.add_argument('-r', '--remove', metavar='\'STR\'', type=str,
+		default=None,
+		help='prior to combining the individual sequences records together, '
+		'remove sites containing at least one specified character(s) '
+		'such as gaps or ambiguities; comma-separate for more than one '
+		'character and flank with apostrophes if necessary to santize special '
+		'characters such as \'N,n,X,x,-\' [none]')
+	opt.add_argument('-s', '--gap-size', type=int, default=1000, metavar='INT',
+		help='number of characters to insert between sequence records [1000]')
+	return parser.parse_args()
+
+def make_linewrapped_fasta(text, defline, width=80):
+	''' given a text string, a newline is added every width chars;
+	faster than textwrap fill for FastA '''
+	# import textwrap
+	# wrapper = textwrap.TextWrapper()
+	# wrapper.break_long_words = True
+	# wrapper.width = width
+	# wrapper.replace_whitespace = False
+	# wrapper.expand_tabs = False
+	# wrapper.break_on_hyphens = False
+	# return '>{}\n{}\n'.format(defline, wrapper.fill(seq))	
+	split_text = [text[i:i + width] for i in range(0, len(text), width)]
+	return '>{}\n{}\n'.format(defline, '\n'.join(split_text))
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(os.path.expanduser(opt.infile))
+	seqs = []
+	for rec in SeqIO.parse(ifh, 'fasta'):
+		seqs.append(str(rec.seq))
+
+	# Optional site filtering
+	if opt.remove is not None:
+		regex = re.compile(r'{}'.format(
+			opt.remove.strip('\'').replace(',', '|')))
+		seqs = [re.sub(regex, '', s) for s in seqs]
+
+	# Stitch sequences with character filler
+	seq = (opt.character * opt.gap_size).join(seqs)
+	if opt.defline is not None:
+		defline = opt.defline.strip('\'')
+	else:
+		if '.' in os.path.basename(ifh):
+			defline = '.'.join(os.path.basename(ifh).split('.')[:-1])
+		else:
+			defline = os.path.basename(ifh)
+	out_fasta = make_linewrapped_fasta(seq, defline)
+
+	# Write output file
+	if opt.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opt.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	ofh.write(out_fasta)
+
+if __name__ == '__main__':
+	main()
diff --git a/estimate.genome.size.py b/estimate.genome.size.py
new file mode 100755
index 0000000..a4173d2
--- /dev/null
+++ b/estimate.genome.size.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from numpy import mean, std
+from shutil import rmtree
+from tempfile import mkdtemp
+
+def parseArgs():
+	parser = ArgumentParser(description='Estimates genome size and the '
+			'percentage of the genome with duplication. Requires BBTools.',
+			add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-1', '--R1', required=True, metavar='FILE',
+		help='input R1 FastQ reads file')
+	req.add_argument('-2', '--R2', required=True, metavar='FILE',
+		help='input R2 FastQ reads file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-k', '--kmers', type=str, metavar='CSVs',
+		default='21,33,55,77,99,127',
+		help='comma-separated list of kmers to use [21,33,55,77,99,127]')
+	opt.add_argument('-w', '--warn-std', metavar='FLOAT', type=float,
+		default=5.0, help='print warning to stderr when the standard '
+		'deviation exceeds a specified percentage [5.0]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	R1  = os.path.abspath(opt.R1)
+	R2  = os.path.abspath(opt.R2)
+	tmp = mkdtemp()
+
+	kmers = opt.kmers.replace(' ', '').split(',')
+	if len(kmers) < 3:
+		sys.exit('ERROR: at least 3 kmers required to estimate genome size')
+
+	dupes, sizes = [], []
+	for k in kmers:
+		peaks = os.path.join(tmp, k + '_peaks.txt')
+		os.system('kmercountexact.sh ploidy=1 k={} peaks={} '
+			'in1={} in2={} 2> {}'.format(k, peaks, R1, R2, os.devnull))
+		i = 0
+		with open(peaks) as dat:
+			for ln in dat:
+				if ln.startswith('#genome_size'):
+					sizes.append(float(ln.split()[1]))
+					i += 1
+				elif ln.startswith('#percent_repeat'):
+					dupes.append(float(ln.split()[1]))
+					i += 1
+		if i != 2:
+			sys.exit('ERROR: unable to parse genome_size and percent_repeat '
+				'from:  {}'.format(peaks))
+	rmtree(tmp)
+	avg_size = mean(sizes)/float(1000000)
+	avg_dupe = mean(dupes)
+	std_size = std(sizes)/float(1000000)
+	std_dupe = std(dupes)
+	print '{:.2f} Mbp mean estimated genome size'.format(avg_size)
+	print '{:.3f} Mbp stdev estimated genome size'.format(std_size)
+	print '{:.3}% mean estimated duplication in the genome'.format(avg_dupe)
+	print '{:.3}% stdev estimated duplication in the genome'.format(std_dupe)
+	if std_size/avg_size*100 > opt.warn_std:
+		sys.stderr.write('WARNING: percentage error exceeded {}'.format(
+			opt.warn_std))
+
+if __name__ == '__main__':
+	main()
diff --git a/examples/adapters_Nextera_NEB_TruSeq_NuGEN_ThruPLEX.fas.gz b/examples/adapters_Nextera_NEB_TruSeq_NuGEN_ThruPLEX.fas.gz
new file mode 100644
index 0000000..7d61a90
Binary files /dev/null and b/examples/adapters_Nextera_NEB_TruSeq_NuGEN_ThruPLEX.fas.gz differ
diff --git a/examples/bact.singlecopy.essentials.hmm.gz b/examples/bact.singlecopy.essentials.hmm.gz
new file mode 100644
index 0000000..c23eee3
Binary files /dev/null and b/examples/bact.singlecopy.essentials.hmm.gz differ
diff --git a/examples/doubles.txt b/examples/doubles.txt
new file mode 100644
index 0000000..9b54212
--- /dev/null
+++ b/examples/doubles.txt
@@ -0,0 +1,36 @@
+CP008834 CP008835
+CP008758 CP008759
+CP009127 CP009128
+CP008911 CP008912
+CP008893 CP008894
+CP008763 CP008764
+CP008909 CP008910
+CP008784 CP008783
+CP008891 CP008892
+CP008754 CP008755
+NC_018527 NC_018529
+NC_006350 NC_006351
+CP009164 CP009165
+CP009150 CP009151
+CP009162 CP009163
+CP009234 CP009235
+CP009271 CP009272
+CP009270 CP009269
+CP009152 CP009153
+CP009156 CP009157
+CP009160 CP009161
+CP009535 CP009536
+CP004042 CP004043
+CP004023 CP004024
+CP004368 CP004369
+NC_009074 NC_009075
+CP004003 CP004004
+CP004377 CP004378
+CP004001 CP004002
+CP003976 CP003977
+LK936442 LK936443
+NZ_CM000774 NZ_CM000775
+NZ_CM000832 NZ_CM000833
+CP000124 CP000125
+CM001156 CM001157
+CP006469 CP006470
\ No newline at end of file
diff --git a/extract.nfo.from.GBK.py b/extract.nfo.from.GBK.py
new file mode 100755
index 0000000..55746fc
--- /dev/null
+++ b/extract.nfo.from.GBK.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+
+# Example: <script>.py -i input.gbk -s VFDB_setA_pro -f CDS -q inference -r product
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Parses a GenBank file for data '
+		'given a search term and specified fields to query. An additional '
+		'parsed field is also reported in tab-delimited format.', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input GenBank file')
+	req.add_argument('-s', '--query-search', required=True, metavar='STR',
+		type=str, help='search term to look for within the query feature '
+		'and query qualifier')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-f', '--query-feature', default='CDS', metavar='STR',
+		help='genbank feature type to search in, e.g., CDS, gene, rRNA, '
+		'source, tRNA, misc_feature')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default='parsed.tab', metavar='FILE',
+		help='output tab-delimited file containing <locus_tag>\\t'
+		'<query-qualifier>\\t<report-qualifier>  [./parsed.tab]')
+	opt.add_argument('-q', '--query-qualifier', default='inference',
+		metavar='STR', help='qualifier term within each genbank feature to '
+		'search in, e.g., locus_tag, inference, codon_start, product, '
+		'transl_table, translation')
+	opt.add_argument('-r', '--report-qualifier', default='product',
+		metavar='STR', help='additional qualifier term to parse data from '
+		'and report when queries are found')
+	return parser.parse_args()
+
+def main():
+	opts = parseArgs()
+	gbk          = opts.infile
+	query_feat   = opts.query_feature
+	query_qualif = opts.query_qualifier
+	query_str    = opts.query_search
+	rep_qualif   = opts.report_qualifier
+	outfile      = opts.outfile
+
+	l = []
+	for rec in SeqIO.parse(open(gbk, 'r'), 'genbank'):
+		for feature in rec.features:
+			if query_feat == feature.type and \
+			query_qualif in feature.qualifiers:
+				list_to_search_against = feature.qualifiers[query_qualif]
+				found = [s for s in list_to_search_against if query_str in s]
+				if len(found) > 0:
+					hit = ' '.join(found)
+					l.append('{}\t{}\t{}'.format(
+						feature.qualifiers['locus_tag'][0], hit,
+						''.join(feature.qualifiers[rep_qualif][0])))
+
+	with open(opts.outfile, 'w') as ofh:
+		for i in l:
+			ofh.write('{}\n'.format(i))
+
+if __name__ == '__main__':
+	main()
diff --git a/extract.nucl.from.GBK.py b/extract.nucl.from.GBK.py
new file mode 100755
index 0000000..de64086
--- /dev/null
+++ b/extract.nucl.from.GBK.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+
+import gzip
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+from Bio.Alphabet import generic_dna
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def parseArgs():
+	parser = ArgumentParser(description='Extracts a nucleotide sequence from '
+		'a GenBank file', epilog='NOTE: if >1 record is found, a warning is '
+		'printed to stderr, and all matches are sent as output', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input GenBank file, optionally gunzip compressed')
+	req.add_argument('-f', '--find', required=True, metavar='STR',
+		help='string to find')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-t', '--type', default='locus_tag', metavar='STR',
+		help='genbank feature type to search in, e.g., CDS, gene, rRNA, '
+		'source, misc_feature [locus_tag]')
+	opt.add_argument('-o', '--outfile', required=False, default=None,
+		help='FastA output [stdout]')
+	return parser.parse_args()
+
+def index_genbank(rec, feature_type, qualifier) :
+	gb_idx = {}
+	for (i, feat) in enumerate(rec.features):
+		if feat.type == feature_type:
+			if qualifier in feat.qualifiers:
+				for s in feat.qualifiers[qualifier]:
+					if s in gb_idx:
+						sys.stderr.write('ERROR: >1 {} in input\n'.format(s))
+						sys.exit(1)
+					else:
+						gb_idx[s] = i
+	return gb_idx
+
+def locus_tag2gene_seq(gbk, ft_type, query, outfile):
+	if gbk.endswith('.gz'):
+		gbk = gzip.open(gbk)
+	records = []
+	for rec in SeqIO.parse(gbk, 'genbank'):
+		gbk_idx = index_genbank(rec, 'CDS', ft_type)
+		if query in gbk_idx:
+			gene_seq = str(rec.features[gbk_idx[query]].extract(rec.seq))
+			product = str(rec.features[gbk_idx[query]].qualifiers['product'][0])
+			record = SeqRecord(Seq(gene_seq, generic_dna), id=query,
+				description=product, name='')
+			records.append(record)
+
+	if len(records) == 0:
+		sys.stderr.write('ERROR: {} absent in {}\n'.format(query, gbk))
+		sys.exit(1)
+	elif len(records) > 1:
+		sys.stderr.write('WARNING: found >1 {} in {}\n'.format(query, gbk))
+	
+	if outfile:
+		outfile = os.path.abspath(os.path.expanduser(outfile))
+		SeqIO.write(records, outfile, 'fasta')
+	else:
+		SeqIO.write(records, sys.stdout, 'fasta')
+
+def main():
+	opts = parseArgs()
+	locus_tag2gene_seq(opts.infile, str(opts.type), str(opts.find), opts.outfile)
+
+if __name__ == '__main__':
+	main()
diff --git a/extract.positions.multifasta.py b/extract.positions.multifasta.py
new file mode 100755
index 0000000..610180e
--- /dev/null
+++ b/extract.positions.multifasta.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+
+
+import gzip
+import os
+import re
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+from Bio.Alphabet import generic_alphabet
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def parseArgs():
+	parser = ArgumentParser(description='Extracts sites from each record in a'
+	' multi-record FastA file', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input multi-record FastA file, optionally gunzip compressed')
+	req.add_argument('-s', '--sites', required=True, nargs='+', type=str,
+		metavar='INT|RANGE', help='position(s) to extract; range requires a'
+		' colon or hyphen; order given is the concatenated output order')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None,
+		help='FastA output [stdout]')
+	opt.add_argument('--unequal-lengths', action='store_true', default=False,
+		help='allow unequal record lengths [off]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(os.path.expanduser(opt.infile))
+	positions = opt.sites
+
+	# Quick checks of positions
+	inv_pattern = re.compile('[^0-9:-]')
+	if any([inv_pattern.search(x) for x in positions]):
+		sys.stderr.write('ERROR: sites must only contain [0-9:-]\n')
+		sys.exit(1)
+	if any([x.startswith('0') for x in positions]):
+		sys.stderr.write('ERROR: 0 position prefix found; site extraction is'
+			' 1-based\n')
+		sys.exit(1)
+
+	# Extract all specified sites one file at a time
+	if ifh.endswith('.gz'):
+		ifh = gzip.open(ifh)
+	records = []
+	rec_length = len(next(SeqIO.parse(ifh, 'fasta')))
+	for rec in SeqIO.parse(ifh, 'fasta'):
+		if rec_length != len(rec):
+			sys.stderr.write('WARNING: unequal record lengths\n')
+			if not opt.unequal_lengths:
+				sys.exit(1)
+		rec_length = len(rec)
+		seq = ''
+		for pos in positions:
+			if not any((x in (':', '-')) for x in pos):
+				pos = int(pos) - 1
+				if pos >= rec_length:
+					sys.stderr.write('ERROR: {} value larger than {} record'
+						' ({} sites).\n'.format(pos, rec.id, rec_length))
+					sys.exit(1)
+				seq += str(rec.seq[pos])
+			elif ':' in pos:
+				start, stop = [int(x) for x in pos.split(':')]
+				if any(v > rec_length for v in (start, stop)):
+					sys.stderr.write('ERROR: {} range larger than {} record'
+						' ({} sites).\n'.format(pos, rec.id, rec_length))
+					sys.exit(1)
+				if start > stop:
+					sys.stderr.write('ERROR: {} range must have second value'
+						' exceed first.\n'.format(pos))
+					sys.exit(1)
+				seq += str(rec.seq[start-1:stop])
+			elif '-' in pos:
+				start, stop = [int(x) for x in pos.split('-')]
+				if any(v > rec_length for v in (start, stop)):
+					sys.stderr.write('ERROR: {} range larger than {} record'
+						' ({} sites).\n'.format(pos, rec.id, rec_length))
+					sys.exit(1)
+				if start >= stop:
+					sys.stderr.write('ERROR: {} range must have second value'
+						' exceed first.\n'.format(pos))
+					sys.exit(1)
+				seq += str(rec.seq[start-1:stop])
+			else:
+				sys.stderr.write('ERROR: {} not detected a single position or'
+					' a range of positions\n'.format(pos))
+				sys.exit(1)
+		defline = str(rec.description) + ' Sites(' + ' '.join(positions) + ')'
+		record = SeqRecord(Seq(seq, generic_alphabet), id=defline,
+			description='')
+		records.append(record)
+
+	# Output specified positions with FastA format
+	if opt.outfile is not None:
+		outfile = os.path.abspath(os.path.expanduser(opt.outfile))
+		SeqIO.write(records, outfile, 'fasta')
+	else:
+		try:
+			SeqIO.write(records, sys.stdout, 'fasta')
+		except Exception, errno:
+			if errno == 32: #IOError for py2, BrokenPipeError for py3
+				pass
+
+if __name__ == '__main__':
+	main()
diff --git a/extract.record.from.genbank.py b/extract.record.from.genbank.py
new file mode 100755
index 0000000..e2446e6
--- /dev/null
+++ b/extract.record.from.genbank.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+
+import gzip
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(
+		description='extract record(s) from a GenBank file that contain one '
+		'or more query and output in FastA format', add_help=False,
+		epilog='NOTE: GenBank Feature Table Definition is described at '
+		'http://www.insdc.org/files/feature_table.html')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input GenBank file, optionally gunzip compressed')
+	req.add_argument('-q', '--query', nargs='+', metavar='STR',
+		help='string(s) to search each defline')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-f', '--query-feature', default='CDS', metavar='STR',
+		help='GenBank feature type to search in, e.g., CDS, gene, rRNA, '
+		'source, tRNA, misc_feature [default: CDS]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='FastA output [default: stdout]')
+	opt.add_argument('-u', '--query-qualifier', default='product',
+		metavar='STR', help='qualifier term within each genbank feature to '
+		'search in, e.g., gene, inference, locus_tag, old_locus_tag, '
+		'product, translation [default: product]')
+	opt.add_argument('--search-type', default='any_q_in_rec',
+		choices=['all_q_in_rec', 'any_q_in_rec', 'any_q_is_rec'],
+		help='type of query match [default: any_q_in_rec]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	infile = os.path.abspath(os.path.expanduser(opt.infile))
+	inbase = os.path.splitext(os.path.basename(infile))[0]
+	qry = opt.query
+	query_feat, query_qualif = opt.query_feature, opt.query_qualifier
+
+	if infile.endswith('.gz'):
+		infile = gzip.open(infile)
+
+	query_match = []
+	for rec in SeqIO.parse(infile, 'genbank'):
+		for feat in rec.features:
+			if query_feat == feat.type and query_qualif in feat.qualifiers:
+				qual_vals = feat.qualifiers[query_qualif]
+				if opt.search_type == 'all_q_in_rec':
+					found = [v for v in qual_vals if all(t in v for t in qry)]
+				if opt.search_type == 'any_q_in_rec':
+					found = [v for v in qual_vals if any(t in v for t in qry)]
+				elif opt.search_type == 'any_q_is_rec':
+					found = [v for v in qual_vals if any(t == v for t in qry)]
+				if len(found) > 0:
+					hit = ' '.join(found)
+					locus_tag = feat.qualifiers['locus_tag'][0]
+					query_match.append('>{} {} {} {}\n{}'.format(
+						inbase, locus_tag, rec.name, hit,
+						feat.extract(rec.seq)))
+
+	if len(query_match) == 0:
+		sys.stderr.write('ERROR: {} absent in {}\n'.format(qry, infile))
+		sys.exit(1)
+	elif len(query_match) > 1:
+		sys.stderr.write('WARNING: found >1 {} in {}\n'.format(qry, infile))
+
+	if opt.outfile:
+		outfile = os.path.abspath(os.path.expanduser(opt.outfile))
+		with open(opt.outfile, 'w') as ofh:
+			for rec in query_match:
+				ofh.write('{}\n'.format(rec))
+	else:
+		for rec in query_match:
+			print rec
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/extract.record.from.multifasta.py b/extract.record.from.multifasta.py
new file mode 100755
index 0000000..b9ac6b6
--- /dev/null
+++ b/extract.record.from.multifasta.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+
+import gzip
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(
+		description='extract record(s) from a multi-record FastA file that '
+		'have a query string match to defline(s)', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input multi-FastA file, optionally gunzip compressed')
+	req.add_argument('-q', '--query', required=True, type=str, metavar='STR',
+		help='string to search deflines')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='FastA output [stdout]')
+	opt.add_argument('-y', '--search-type', default='contains',
+		choices=['contains', 'full_exact'], help='type of query match '
+		'[default: contains]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	infile = os.path.abspath(os.path.expanduser(opt.infile))
+	query  = opt.query
+
+	if infile.endswith('.gz'):
+		infile = gzip.open(infile)
+	mfasta = SeqIO.parse(infile, 'fasta')
+	query_match = []
+	for record in mfasta:
+		if opt.search_type == 'contains':
+			if query in str(record.description):
+				query_match.append(record)
+		elif opt.search_type == 'full_exact':
+			if query == str(record.description):
+				query_match.append(record)
+
+	if len(query_match) == 0:
+		sys.stderr.write('ERROR: {} absent from deflines\n'.format(query))
+		sys.exit(1)
+
+	if opt.outfile:
+		outfile = os.path.abspath(os.path.expanduser(opt.outfile))
+		SeqIO.write(query_match, outfile, 'fasta')
+	else:
+		SeqIO.write(query_match, sys.stdout, 'fasta')
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/fasta2bed.py b/fasta2bed.py
new file mode 100644
index 0000000..a41f826
--- /dev/null
+++ b/fasta2bed.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Converts a FastA file into a BED '
+		'file, which is a tab-delimited list of sequence record names and '
+		'their boundaries')
+	parser.add_argument('-i', '--infile', required=True,
+		help='input FastA Format file')
+	parser.add_argument('-o', '--outfile', required=False, default=None,
+		help='output BED Format file [stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(os.path.expanduser(opt.infile))
+
+	if opt.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opt.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	with open(ifh) as infasta:
+		for rec in SeqIO.parse(infasta, 'fasta'):
+			ofh.write('{}\t0\t{}\n'.format(rec.id, len(rec)))
+
+if __name__ == '__main__':
+	main()
diff --git a/fasta2genbank.py b/fasta2genbank.py
new file mode 100755
index 0000000..e03c34e
--- /dev/null
+++ b/fasta2genbank.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+
+
+import os
+import re
+import sys
+from argparse import ArgumentParser
+from itertools import groupby
+from shutil import rmtree
+from tempfile import mkdtemp
+from Bio import SeqIO, Alphabet
+from Bio.SeqFeature import SeqFeature, FeatureLocation
+
+def parseArgs():
+	parser = ArgumentParser(description='Creates a GenBank file from a '
+	'FastA file', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--input', required=True, metavar='FILE',
+		help='input FastA file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--output', metavar='FILE', default=None,
+		help='output GenBank file [stdout]')
+	opt.add_argument('--label-ambiguous', action='store_true',
+		default=False, help='label positions where N occurs as \'ambiguous\' '
+		'[off]')
+	opt.add_argument('--label-unambiguous', action='store_true',
+		default=False, help='label positions where ATCG occur [off]')
+	return parser.parse_args()
+
+def collapse_integers_to_ranges(sites):
+	''' converts list of integers into list of pairs of begin,end sites '''
+	ranges = []
+	for _, g in groupby(enumerate(sites), key=lambda e: e[0]-e[1]):
+		group = [val[1] for val in g]
+		if len(group) > 1:
+			ranges.append(group[::len(group) - 1])
+		elif len(group) == 1:
+			ranges.append([group[0], group[0]])
+	return ranges
+
+def label_sites_to_gbkrec(rec, sites, label):
+	ranges = collapse_integers_to_ranges(sites)
+	for begin_end in ranges:
+		sf = SeqFeature(FeatureLocation(begin_end[0], begin_end[1]+1),
+			type=label, id=label, qualifiers={label:'yes',
+			'note':'{} nucleotide region'.format(label)})
+		rec.features.append(sf)
+	return rec
+
+def label_ambiguous_gbkrecs(gbkrecs):
+	records = []
+	for rec in gbkrecs:
+		# Find ambiguous N nucleotides
+		i, split_len = 0, 0
+		sites = []
+		seq = rec.seq.upper()
+		while i >= 0:
+			i = seq.find('N')
+			if i >= 0:
+				sites.append(i + split_len)
+				split_len += i+1
+				seq = seq[i+1:]
+		records.append(label_sites_to_gbkrec(rec, sites, 'ambiguous'))
+	return records
+
+def label_unambiguous_gbkrecs(gbkrecs):
+	records = []
+	for rec in gbkrecs:
+		# Find unambiguous ATCG nucleotides
+		seq = str(rec.seq.upper())
+		sites = [m.start() for m in re.finditer(
+			'|'.join(map(re.escape, 'ATCG')), seq)]
+		records.append(label_sites_to_gbkrec(rec, sites, 'unambiguous'))
+	return records
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(os.path.expanduser(opt.input))
+	if opt.output is not None:
+		ofh = os.path.abspath(os.path.expanduser(opt.output))
+	else:
+		ofh = sys.stdout
+
+	if not opt.label_ambiguous and not opt.label_unambiguous:
+		SeqIO.convert(ifh, 'fasta', ofh, 'genbank',
+			alphabet=Alphabet.generic_dna)
+		sys.exit(0)
+
+	tmp = mkdtemp()
+	temp_gbk = os.path.join(tmp, 'gb')
+	SeqIO.convert(ifh, 'fasta', temp_gbk, 'genbank',
+		alphabet=Alphabet.generic_dna)
+	with open(temp_gbk) as tfh:
+		gbkrecs = list(SeqIO.parse(tfh, 'genbank'))
+	if opt.label_ambiguous:
+		gbkrecs = label_ambiguous_gbkrecs(gbkrecs)
+	if opt.label_unambiguous:
+		gbkrecs = label_unambiguous_gbkrecs(gbkrecs)
+
+	SeqIO.write(gbkrecs, ofh, 'genbank')
+	sys.stderr.write('INFO: {} sequence records written\n'.format(
+		len(gbkrecs)))
+	rmtree(tmp)
+
+if __name__ == '__main__':
+	main()
diff --git a/fetch.ncbi.taxon.GBKs.py b/fetch.ncbi.taxon.GBKs.py
new file mode 100755
index 0000000..9d4ccb6
--- /dev/null
+++ b/fetch.ncbi.taxon.GBKs.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from shutil import rmtree
+from subprocess import check_output
+from tempfile import mkdtemp
+
+def parseArgs():
+	parser = ArgumentParser(description='Fetches GenBank files for all '
+		'genomes within a specified taxon. Requires NCBI\'s E-utilities.',
+		epilog='Note that although the proper assembly status term to '
+		'describe completed genomes is \'Complete genome\', the single word '
+		'\'Complete\' is used here. When more than one status is desired, '
+		'the --status opt needs to be specified each time. For example, -s '
+		'Complete -s Contig.', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--tax-id', required=True, metavar='INT',
+		help='Taxonomy ID from NCBI. '
+		'See https://www.ncbi.nlm.nih.gov/taxonomy')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-d', '--db', choices=['GenBank', 'RefSeq'],
+		default='GenBank', help='NCBI sequence database to query [GenBank]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outpath', metavar='PATH',
+		default=None, help='output directory where GenBank files will be '
+		'downloaded to [./]')
+	opt.add_argument('-s', '--status', action='append',
+		metavar='{Chromosome, Contig, Complete, Scaffold}',
+		choices=['Chromosome', 'Contig', 'Complete', 'Scaffold'],
+		default=[], help='assembly status(es) of files to fetch '
+		'[Chromosome, Complete, Contig, Scaffold]')
+	return parser.parse_args()
+
+def main():
+	opt   = parseArgs()
+	tmp   = mkdtemp()
+	taxid = 'txid' + str(opt.tax_id)
+	if not opt.status:  #Default is empty list to indicate fetch all
+		status_want = ['Chromosome', 'Contig', 'Complete', 'Scaffold']
+	else:
+		status_want = opt.status
+	if opt.outpath is not None:
+		out = os.path.abspath(opt.outpath)
+	else:
+		out = os.getcwd()
+	if not os.path.exists(out):
+		os.mkdir(out)
+
+	t = check_output('esearch -db taxonomy -query "{}[ORGN:exp]" | '
+		'efetch -format docsum | xtract -pattern DocumentSummary -element '
+		'ScientificName'.format(taxid), shell=True).rstrip('\n')
+	print 'Fetching GenBank files for {} ...'.format(t)
+	tmp_file = os.path.join(tmp, 'urls')
+	os.system('esearch -db assembly -query "{}[ORGN:exp]" | '
+		'efetch -format docsum | xtract -pattern DocumentSummary -element '
+		'AssemblyStatus FtpPath_{} 1> {}'.format(taxid, opt.db, tmp_file))
+	i = 0
+	with open(tmp_file) as urls:
+		for ln in urls:
+			try:
+				status, part_url = ln.rstrip('\n').split('\t')
+				if any([x in status for x in status_want]):
+					s = part_url.split('/')[-1]
+					gbk_url = os.path.join(part_url, s + '_genomic.gbff.gz')
+					gz_temp = os.path.join(tmp, s + '.gbk.gz')
+					gbk_out = os.path.join(out, s + '.gbk')
+					os.system('wget -q -O {} {}'.format(gz_temp, gbk_url))
+					if os.path.getsize(gz_temp) > 0:
+						os.system('gunzip -c {} > {}'.format(gz_temp, gbk_out))
+						i += 1
+					else:
+						sys.exit('ERROR: unable to download {}'.format(s))	
+			except ValueError:
+				pass
+	rmtree(tmp)
+	print 'Downloaded {} GenBank files'.format(i)
+
+if __name__ == '__main__':
+	main()
diff --git a/filter.blast.py b/filter.blast.py
new file mode 100755
index 0000000..391ce13
--- /dev/null
+++ b/filter.blast.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+
+def parseArgs():
+	parser = ArgumentParser(description='Filters BLAST output format 6 '
+		'(tab-delimited) for best hit based on bitscore. '
+		'Handles additional data columns following bitscore.',
+		add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input file in NCBI\'s BLAST -outfmt 6 format')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-c', '--column', type=int, metavar='{1,2}',
+		choices=[1, 2], default=1, help='report best hit per query label '
+		'(1st column; \'1\') or target (2nd column; \'2\') [1]')
+	opt.add_argument('-o', '--outfile', metavar='FILE',
+		default=None, help='output file [stdout]')
+	opt.add_argument('-s', '--bitscore', type=float, metavar='FLOAT',
+		default=0.0, help='minimum alignment Bit score [0.0]')
+	return parser.parse_args()
+
+def main():
+	opts = parseArgs()
+	infile = os.path.abspath(os.path.expanduser(opts.infile))
+	
+	# Identify unique query labels and will not assume sorted file
+	with open(infile, 'r') as ifh:
+		query_labels = set()
+		for ln in ifh:
+			query_labels.add(ln.split('\t')[opts.column-1])
+	num_cols = len(ln.split('\t'))
+
+	# Filter best hits
+	best = {k: ['0']*num_cols for k in query_labels}
+	with open(infile, 'r') as ifh:
+		for ln in ifh:
+			data = ln.rstrip('\n').split('\t')
+			if float(data[11]) >= opts.bitscore and \
+			float(data[11]) > float(best[data[opts.column-1]][11]):
+				best[data[opts.column-1]] = data
+
+	# Write output
+	if opts.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opts.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	for val in sorted(best.values()):
+		if val != ['0']*num_cols:
+			ofh.write('\t'.join(val) + '\n')
+
+if __name__ == '__main__':
+	main()
diff --git a/filter.contigs.py b/filter.contigs.py
new file mode 100755
index 0000000..4eff349
--- /dev/null
+++ b/filter.contigs.py
@@ -0,0 +1,405 @@
+#!/usr/bin/env python
+
+
+import argparse
+import gzip
+import os
+import re
+import sys
+
+from Bio import SeqIO
+from Bio import SeqRecord
+from Bio.SeqUtils import GC
+
+
+def parseArgs():
+	parser = argparse.ArgumentParser(description='filters contigs (or '
+		'scaffolds) based on length, coverage, GC skew, and compositional '
+		'complexity', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', metavar='FILE',
+		required=True, help='input FastA file from IDBA, SKESA, SPAdes, '
+		'Unicycler, or Velvet, optionally gunzip compressed')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-b', '--baseheader', default=None, metavar='STR',
+		help='contig header prefix (with _<CNTR> suffix) '
+		'[basename infile .ext]')
+	opt.add_argument('-c', '--cov', type=str, default='5', metavar='INT|FLOAT',
+		help='minimum coverage; set to 0 to skip; an integer of at least 1 '
+		'applies a raw absolute coverage value filter whereas a float value '
+		'filters sequences that meet a minimum percentage relative to the '
+		'length-normalized median coverage of sequences that first pass all '
+		'other filters [5]')
+	opt.add_argument('-d', '--discarded', metavar='FILE', default=None,
+		help='output FastA file of discarded sequences which includes '
+		'failed filters in the deflines [None]')
+	opt.add_argument('-g', '--gcskew', default=True, action='store_false',
+		help='keep >88 and <12%% GC contigs')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-l', '--len', type=int, default=500, metavar='INT',
+		help='minimum contig length (in bp) [500]')
+	opt.add_argument('-m', '--complex', default=True, action='store_false',
+		help='keep low-complexity contigs with only 1 or 2 nucleotides '
+		'represented')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='output filtered FastA file [stdout]')
+	opt.add_argument('--deflines', choices={'rename', 'rename_retain',
+		'retain'}, default='rename_retain', help='rename: fully rename '
+		'with -b prefix and _<CNTR> suffix; retain: keep exactly as input; '
+		'rename_retain: includes rename style prefix but also adds '
+		'OrigDefln=<input defline> suffix [rename_retain]')
+	opt.add_argument('--no-sort', default=False, action='store_true',
+		help='skip sorting contigs by descending length')
+	opt.add_argument('--quiet-removal', default=False, action='store_true',
+		help='skip explanations for each record removal')
+	opt.add_argument('--quiet-coverage', default=False, action='store_true',
+		help='skip reporting coverage statistics (min, Q25, mean, median, '
+		'Q75, max)')
+	opt.add_argument('--quiet-stats', default=False, action='store_true',
+		help='skip final reporting of input, discard, and output tallies '
+		'(contigs count, sequence lengths)')
+	opt.add_argument('--silent', default=False, action='store_true',
+		help='no screen output')
+	return parser.parse_args()
+
+# SPAdes v3.12.0 and Velvet v1.2.10 are the identical
+# SKESA v2.2 appends _Circ after cov if suggested circular contig
+# IDBA (requires replacing spaces into underscores
+#       due to Biopython SeqIO's parsing)
+# Unicycler v0.4.7 appends x to relative cov val
+ASSEM_REGEXS = {
+	'idba'   : 'read_count_([0-9]+)',
+	'skesa'  : 'Contig_[0-9]{1,}_[0-9]{1,}.[0-9]{1,}',
+	'unicyc' : 'depth=[0-9]{1,}(\.[0-9]{1,})?',
+	'velvet' : 'cov_([0-9]{1,}.[0-9]{1,})'
+	}
+
+def string_is_int_or_float(s):
+	try:
+		float(s)
+	except ValueError:
+		return False
+	return True
+
+def string_is_float(s):
+	try:
+		return float(s) and '.' in s
+	except ValueError:
+		return False
+
+def require_minimum_arg_value(arg_value, arg_name, min_value):
+	if arg_value < min_value:
+		sys.stderr.write('ERROR: minimum {} must be at least {}\n'.\
+			format(arg_name, arg_value))
+		sys.exit(1)
+
+def detect_assembly_format(record, quiet):
+	'''
+	given a Bio.SeqRecord.SeqRecord object, returns the assembler software
+	name used to generate the input FastA file based on the coverage defline
+	'''
+	for k, v in ASSEM_REGEXS.items():
+		cov_regex = re.compile(v)
+		cov_match = cov_regex.search(record.description)
+		if cov_match:
+			if not quiet:
+				sys.stderr.write('INFO: detected {} defline format\n\n'.\
+					format(k))
+			return k, cov_regex
+	else:
+		sys.stderr.write('ERROR: unable to parse coverage from first defline\n'
+			'Expect raw output file from SKESA, SPAdes, or Velvet assemblers '
+			'or an IDBA file with undescores instead of spaces in the deflines. '
+			'Coverage cannot be filtered for other formats, so to apply '
+			'other filters and skip coverage filtering, set coverage to 0.\n')
+		sys.exit(1)
+
+def extract_coverage_value_from_defline(record, assembly_fmt, cov_regex):
+	'''
+	given a Bio.SeqRecord.SeqRecord object and the assembler name,
+	extracts and returns the coverage value found in its defline
+	'''
+	cov_val = 0
+	cov_match = cov_regex.search(record.description)
+	if cov_match:
+		if assembly_fmt == 'idba':
+			cov_val = int((cov_match.group(0)).lstrip('read_count_'))
+		elif assembly_fmt == 'skesa':
+			cov_val = float((cov_match.group(0)).split('_')[-1])
+		elif assembly_fmt == 'unicyc':
+			cov_val = float((cov_match.group(0)).lstrip('depth='))
+		elif assembly_fmt == 'velvet':
+			cov_val = float((cov_match.group(0)).lstrip('cov_'))
+	return cov_val
+
+def filter_record_length(record, min_len, quiet):
+	'''
+	evaluates a Bio.SeqRecord.SeqRecord object for sequence length
+	'''
+	seq_len = len(record.seq)
+	if seq_len >= min_len:
+		return seq_len
+	else:
+		if not quiet:
+			sys.stderr.write('INFO: {} too short\n'.format(record.id))
+		return False
+
+def filter_record_coverage(record, min_cov, assembly_fmt, cov_regex,
+	quiet):
+	'''
+	evaluates a Bio.SeqRecord.SeqRecord object for read coverage depth
+	'''
+	cov = extract_coverage_value_from_defline(record, assembly_fmt, cov_regex)
+	if cov >= min_cov:
+		return '{:.2f}'.format(cov)
+	else:
+		if not quiet:
+			sys.stderr.write('INFO: {} low coverage\n'.format(record.id))
+		return False
+
+def filter_record_gc(record, bool_gc, quiet):
+	'''
+	evaluates a Bio.SeqRecord.SeqRecord object for GC composition; note
+	that biopython represents GC content as a percentage of the total
+	sequence length and not just of ATCG
+	'''
+	if bool_gc:
+		gc_content = float(GC(record.seq))
+		if 12 <= gc_content <= 88:
+			return '{:.2f}'.format(gc_content)
+		else:
+			if not quiet:
+				sys.stderr.write('INFO: {} skewed GC\n'.format(record.id))
+			return False
+	else:
+		return 'skipped filter'
+
+def filter_record_complexity(record, bool_complex, quiet):
+	'''
+	evaluates a Bio.SeqRecord.SeqRecord object for at least 3 unique
+	unambiguous nucleotides present
+	'''
+	if bool_complex:
+		i = 0
+		for nucleotide in ('A', 'T', 'C', 'G'):
+			if nucleotide in record.seq:
+				i += 1
+		if i > 2:
+			return i
+		else:
+			if not quiet:
+				sys.stderr.write('INFO: {} low compositional complexity\n'.\
+					format(record.id))
+			return False
+	else:
+		return 'skipped filter'
+
+def calc_median(srt_floats_list):
+	'''
+	takes a sorted list of floats and returns a tuple of median value and a
+	list of the index(es) of the median value(s)
+	''' 
+	idxs = []
+	len_list = len(srt_floats_list)
+	if len_list % 2 == 0:
+		idxs.append(int(len_list / 2) - 1)
+		idxs.append(int(len_list / 2))
+		median = (srt_floats_list[idxs[0]] + srt_floats_list[idxs[1]]) / 2.
+	else:
+		idxs.append(int(len_list / 2))
+		median = srt_floats_list[idxs[0]]
+	return median, idxs
+
+def calc_normalized_median_cov(records, assembly_fmt, cov_regex,
+	coverage_filter_type, quiet):
+	''' 
+	calculates the length-normalized median coverage value
+	for a list of SeqIO records
+	'''
+	seqcoverages = []
+	for rec in records:
+		seq_len = len(rec.seq)
+		cov = extract_coverage_value_from_defline(rec, assembly_fmt,
+			cov_regex)
+		seqcoverages.extend(seq_len * [cov])
+	srt_covs = sorted(seqcoverages)
+	Q50, median_idxs = calc_median(srt_covs)
+	if not quiet:
+		d = {'abs': 'in', 'rel': 'ex'}
+		Q25, _ = calc_median(srt_covs[:median_idxs[0]])
+		Q75, _ = calc_median(srt_covs[median_idxs[-1] + 1:])
+		sys.stderr.write('\nINFO: coverage quartiles of filtered contigs\n'
+			'    ({}cluding cov filt)\n'
+			'    25th={:.2f}\n'
+			'    50th={:.2f}\n'
+			'    75th={:.2f}\n'.format(d[coverage_filter_type],
+				Q25, Q50, Q75))
+	return Q50
+
+def rename_record_defline(record, baseheader, i, rename_type):
+	'''
+	renames sequence record object according to specified type
+	'''
+	if rename_type == 'rename_retain':
+		return SeqRecord.SeqRecord(id='{}_{} OrigDefln={}'.format(
+			baseheader, i, record.description),
+			seq=record.seq, description='')
+	elif rename_type == 'rename':
+		return SeqRecord.SeqRecord(id='{}_{}'.format(baseheader, i),
+			seq=record.seq, description='')
+	elif rename_type == 'retain':
+		return SeqRecord.SeqRecord(id=record.description,
+			seq=record.seq, description='')
+	elif rename_type == 'discarded':
+		return SeqRecord.SeqRecord(id='{}_{} {} OrigDefln={}'.format(
+			baseheader, i, record.description, record.id),
+			seq=record.seq, description='')
+
+def write_records(records, baseheader, defline_rename, outfile,
+	bool_nosortbylen):
+	if not bool_nosortbylen:
+		records = sorted(records, key=lambda x: x[1], reverse=True)
+	out_recs = []
+	i = 1
+	for r, _ in records:
+		out_recs.append(rename_record_defline(r, baseheader, i, defline_rename))
+		i += 1
+	SeqIO.write(out_recs, outfile, 'fasta')
+
+def main():
+	args = parseArgs()
+	if not string_is_int_or_float(args.cov):
+		sys.stderr.write('ERROR: --cov {} must be a float or integer\n'.\
+			format(args.cov))
+		sys.exit(1)
+	min_cov, min_len = float(args.cov), args.len
+	require_minimum_arg_value(min_cov, 'coverage', 0)
+	require_minimum_arg_value(min_len, 'length', 1)
+	infile, outfile = args.infile, args.outfile
+	defline_rename = args.deflines
+	bool_gc, bool_complex = args.gcskew, args.complex, 
+	bool_nosortbylen = args.no_sort
+	silent, quiet_coverage = args.silent, args.quiet_coverage
+	quiet_removal, quiet_stats = args.quiet_removal, args.quiet_stats
+	if silent:
+		quiet_removal = quiet_coverage = quiet_stats = True
+
+	# Output handling
+	if args.baseheader is None:
+		baseheader = os.path.splitext(os.path.basename(
+			infile.strip('.gz')))[0]
+	else:
+		baseheader = args.baseheader
+	if outfile is None:
+		out = sys.stdout
+	else:
+		out = os.path.abspath(os.path.expanduser(outfile))
+
+	# Auto-detections
+	if string_is_float(args.cov):
+		coverage_filter_type = 'rel'
+		min_cov = 0
+	else:
+		coverage_filter_type = 'abs'
+	if infile.endswith('.gz'):
+		infile = gzip.open(infile)
+
+	# Enable skiping coverage filter
+	if float(args.cov) > 0:
+		first_record = next(SeqIO.parse(infile, 'fasta'))
+		assembly_fmt, cov_regex = detect_assembly_format(first_record, silent)
+	else:
+		assembly_fmt, cov_regex = 'post-processed', re.compile('xX0Xx')
+		quiet_coverage = True
+
+	# Filter each sequence record
+	records, discarded = [], [] #items are tuples of seqrec obj and seqlen int
+	cnts_input_reclengths = []
+	for record in SeqIO.parse(infile, 'fasta'):
+		cnts_input_reclengths.append(len(record.seq))
+		d = {}
+		d['length'] = filter_record_length(record, min_len, quiet_removal)
+		d['coverage'] = filter_record_coverage(record, min_cov, assembly_fmt,
+			cov_regex, quiet_removal)
+		d['gc_content'] = filter_record_gc(record, bool_gc, quiet_removal)
+		d['complexity'] = filter_record_complexity(record, bool_complex,
+			quiet_removal)
+		if all(d.values()):
+			records.append((record, d['length']))
+		else:
+			record.description = ''
+			for k, v in d.items():
+				if not v:
+					record.description += 'Failed={}'.format(k)
+			discarded.append((record, len(record.seq)))
+
+	# Calculate statistics for read depth of contig coverage
+	if len(records) == 0:
+		sys.stderr.write('\n\nERROR: no contigs passed filters\n'
+			'To diagnose, check which filter(s) responsible for this in '
+			'the stderr info. Coverage is most suspect, especially if input '
+			'has relative depths such as Unicycler, which can be quickly '
+			'confirmed if the number of \'low coverage\' in stderr equals '
+			'the number of input records.\n')
+		sys.exit(1)
+	unfilt_records = [r[0] for r in records]
+	median_cov = calc_normalized_median_cov(unfilt_records, assembly_fmt,
+		cov_regex, coverage_filter_type, quiet_coverage)
+	unfilt_coverages = [extract_coverage_value_from_defline(
+		r, assembly_fmt, cov_regex) for r in unfilt_records]
+	if not quiet_coverage:
+		min_val, max_val = min(unfilt_coverages), max(unfilt_coverages)
+		avg_cov = sum(unfilt_coverages) / float(len(unfilt_coverages))
+		d = {'abs': 'in', 'rel': 'ex'}
+		sys.stderr.write('\nINFO: coverage of filtered contigs\n'
+		'    ({}cluding cov filt)\n'
+		'    minimum={:.2f}\n'
+		'    average={:.2f}\n'
+		'    maximum={:.2f}\n\n'.format(d[coverage_filter_type],
+			min_val, avg_cov, max_val))
+
+	# Relative coverage filtering of filtered recs only
+	if coverage_filter_type == 'rel' and len(records) > 0:
+		min_cov = median_cov * float(args.cov)
+		records = []
+		for rec in unfilt_records:
+			cov_val = filter_record_coverage(rec, min_cov, 
+				assembly_fmt, cov_regex, quiet_removal)
+			if cov_val:
+				records.append((rec, len(rec.seq)))
+			else:
+				rec.description = 'Failed=coverage'
+				discarded.append((rec, len(rec.seq)))
+		if not silent:
+			sys.stderr.write('\nINFO: {} minimum coverage applied from '
+				'{} input relative coverage value * '
+				'{:.2f} calculated median coverage\n\n'.format(
+					min_cov, args.cov, median_cov))
+
+	# Optionally report tallies
+	if not quiet_stats:
+		sys.stderr.write('INFO: {} contigs input\n'.format(
+			len(cnts_input_reclengths)))
+		sys.stderr.write('INFO: {} bp input\n'.format(
+			sum(cnts_input_reclengths)))
+		sys.stderr.write('INFO: {} contigs discarded\n'.format(
+			len(discarded)))
+		sys.stderr.write('INFO: {} bp discarded\n'.format(
+			sum(n for _, n in discarded)))
+		sys.stderr.write('INFO: {} contigs output\n'.format(
+			len(records)))
+		sys.stderr.write('INFO: {} bp output\n\n'.format(
+			sum(n for _, n in records)))
+
+	# Output records
+	if len(records) > 0:
+		write_records(records, baseheader, defline_rename, out,
+			bool_nosortbylen)
+	if args.discarded is not None and len(discarded) > 0:
+		outfile = os.path.abspath(os.path.expanduser(args.discarded))
+		write_records(discarded, baseheader, 'discarded', outfile,
+			bool_nosortbylen)
+
+if __name__ == '__main__':
+	main()
diff --git a/find.dupes.bash b/find.dupes.bash
new file mode 100755
index 0000000..5ada37b
--- /dev/null
+++ b/find.dupes.bash
@@ -0,0 +1,132 @@
+#!/bin/bash
+
+set -e
+function usage { 
+	echo "
+	Given a FastA file, identifies repetitive regions, and outputs a BED file
+
+	usage: `basename $0` -r reference.fasta -o maskedRegions.bed [-l <int>] [-i <float>] [-t <dir>]
+		
+		-r [default: ./reference.fasta]   FastA formatted input file
+		-o [default: ./maskedRegions.bed] BED formatted output file
+		-i [default: 99]                  Minimum percent identity required between two
+		                                  repeat regions
+		-l [default: 249]                 Minimum repeat length to find (in bp)
+		-t [default: ./tmp/]              Temporary directory where intermediate files
+		                                  are written to and removed
+		
+	Paths can be absolute or relative.
+	"
+	}
+
+# Defaults
+PERC_ID=99
+LEN=249
+OUTFILE="$PWD/maskedRegions.bed"
+REF="$PWD/reference.fasta"
+TMP="$PWD/tmp"
+
+nopts=$#
+for ((i=1 ; i <= nopts ; i++)); do
+	case "$1" in
+		-i | --percid)
+			PERC_ID="$2"
+			echo "    min percent identity required: $2"
+			shift 2
+			;;
+		-l | --len)
+			LEN="$2"
+			echo "    min length: $2"
+			shift 2
+			;;
+		-o | --out)
+			OUTFILE="$2"
+			echo "    output file: $2"
+			shift 2
+			;;
+		-r | --ref)
+			REF=`readlink -f $2`
+			echo "    reference genome: $2"
+			shift 2
+			;;
+		-t | --temp)
+			TMP="$2"
+			echo "    temporary directory: $2"
+			shift 2
+			;;
+		-h | --help)
+			usage
+			exit 1
+			;;
+		\?)
+			echo "    ERROR: $2 is not a valid argument"
+			usage
+			exit 1
+			;;
+	esac
+done
+
+# Input file requirements and dependency check
+[[ ! -e "$REF" || ! -s "$REF" ]] && { echo "ERROR: $REF cannot be read"; exit 1; }
+command -v nucmer >/dev/null 2>&1 || { echo 'ERROR: nucmer not found' >&2; exit 1; }
+command -v show-coords >/dev/null 2>&1 || { echo 'ERROR: show-coords not found' >&2; exit 1; }
+command -v bedtools >/dev/null 2>&1 || { echo 'ERROR: bedtools not found' >&2; exit 1; }
+command -v sortBed >/dev/null 2>&1 || { echo 'ERROR: sortBed not found' >&2; exit 1; }
+
+# Create tmp dir (if absent)
+if [ ! -d "$TMP" ]; then
+	mkdir -p "$TMP"
+else
+	echo "WARNING: Temporary directory $TMP already exists."
+	echo 'Files present in the specified tmp dir might disrupt analysis.'
+fi
+
+# Primary system commands
+cd "$TMP"  #cannot specific outpath in nucmer, so change into tmp dir
+nucmer --nosimplify --maxmatch -p DUPES "$REF" "$REF" 2> /dev/null
+show-coords -I "$PERC_ID" -L "$LEN" -r -l -o -T DUPES.delta > filtered.coords
+
+# Parse nucmer output into BED format
+[[ -a DUPES.bed ]] && rm DUPES.bed
+while IFS=$'\t' read -r -a line; do
+	if [ ${line[0]} -gt ${line[1]} ]; then
+		l0=${line[0]}
+		l1=${line[1]}
+		line[0]=$l1
+		line[1]=$l0
+	fi
+	if [ ${line[2]} -gt ${line[3]} ]; then
+		l2=${line[2]}
+		l3=${line[3]}
+		line[2]=$l3
+		line[3]=$l2
+	fi
+	echo -e "${line[9]}\t${line[0]}\t${line[1]}" >> DUPES.bed
+	echo -e "${line[9]}\t${line[2]}\t${line[3]}" >> DUPES.bed
+done < <(grep '^[1-9]' filtered.coords)
+
+# Sort and remove duplicate lines
+sort -t$'\t' -V -k 1,3 DUPES.bed | sortBed > DUPES_sorted.bed
+awk '{if(++dup[$0]==1) {print $0}}' DUPES_sorted.bed > DUPES_sorted_deduped.bed
+
+# Remove full-length chromosome matches; handles >1 contig
+while read -r -a deflines; do
+	CHROM_ID=${deflines[1]}
+	END_POS=${deflines[3]}
+	# awk -v chrom="${CHROM_ID}" -v end="${END_POS}" '!/chrom\t1\tend/' DUPES_sorted_deduped.bed > tmp.bed
+	# mv tmp.bed DUPES_sorted_deduped.bed
+	TAB=$'\t'
+	sed -i "/${CHROM_ID}${TAB}1${TAB}${END_POS}/d" DUPES_sorted_deduped.bed
+done < <(grep '^>' DUPES.delta)
+
+# Merge common overlapping regions
+bedtools merge -i DUPES_sorted_deduped.bed > maskedRegions.unsorted.bed
+sort -t$'\t' -V -k 1,3 maskedRegions.unsorted.bed > maskedRegions.bed
+
+REGIONS=$(wc -l maskedRegions.bed | awk '{print $1}')
+SITES=$(awk -F'\t' 'BEGIN{SUM=0}; {SUM+=$3-$2}; END{print SUM}' maskedRegions.bed)
+echo "found $REGIONS regions and $SITES total sites to mask"
+
+# Cleanup
+mv -v maskedRegions.bed "$OUTFILE"
+rm -r "$TMP"
diff --git a/gatkspandx.vcf2fasta.py b/gatkspandx.vcf2fasta.py
new file mode 100755
index 0000000..2f42c72
--- /dev/null
+++ b/gatkspandx.vcf2fasta.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+
+import sys
+from argparse import ArgumentParser
+from collections import Counter
+
+
+def parseArgs():
+	parser = ArgumentParser(description='Parses a VCF file processed by GATK '
+			'within SPANDx and prints a FastA to standard out. This is '
+			'particularly useful when manipulating the out.vcf file. '
+			'Multiallelic SNPs are handled, heterozygous SNPs are filtered, '
+			'FILTER tags are ignored, and unmapped loci are reported as gaps. '
+			'Sample names and their binary data must begin on the 10th '
+			'column. ',
+			add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--input', required=True, metavar='FILE',
+		help='input VCF file from Parsnp')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	return parser.parse_args()
+
+# Main
+opts = parseArgs()
+
+# Get sample IDs
+with open(opts.input, 'r') as ifh:
+	for ln in ifh:
+		if any(ln.startswith('#CHROM') for x in ln):
+			samples_d = {k:[] for k in ln.rstrip('\n').split('\t')[9:]}
+			samples_l = ln.rstrip('\n').split('\t')[9:]
+			break
+
+# Parse the VCF file
+ifh = open(opts.input, 'r')
+for ln in ifh:
+	if not ln.startswith('#'):
+		data = ln.rstrip('\n').split('\t')
+		ref = data[3]
+		if ',' in data[4]:
+			alt = data[4].split(',')
+		else:
+			alt = [data[4]]
+
+		# filter genotype
+		gt = 0
+		for x in data[9:]:
+			y, z = x.split(':')[0].split('/')
+			if y != z:
+				gt += 1
+
+		if gt == 0:
+			binary_data = [x.split(':')[0].split('/')[0] for x in data[9:]]
+			for i, datum in enumerate(binary_data):
+				if datum == '0':
+					nuc = ref
+				elif datum == '1':
+					nuc = alt[0]
+				elif datum == '2':
+					nuc = alt[1]
+				elif datum == '3':
+					nuc = alt[2]
+				elif datum == '.':
+					nuc = '-'
+				else:
+					sys.stderr.write('ERROR: ALT value >3\n')
+				sample_id = samples_l[i]
+				samples_d[sample_id].append(nuc)
+ifh.close()
+
+# Write FastA to Std Out
+snp_len = len(samples_d[sample_id])
+for sample in samples_l:
+	snps = ''.join(samples_d[sample])
+	if len(snps) != snp_len:
+		sys.stderr.write('ERROR: unequal sequence records printed\n')
+	else:
+		print '>{}'.format(sample)
+		print snps
diff --git a/gbk2proteome.molec.weights.py b/gbk2proteome.molec.weights.py
new file mode 100755
index 0000000..7bc5fb9
--- /dev/null
+++ b/gbk2proteome.molec.weights.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+# Given a genbank file, prints to stdout a tab-delimited summary
+# of the proteome including the molecular weight in Daltons, where
+# '~<value>' indicates the MW is estimated due to ambiguous amino acid(s)
+
+# Usage: python script.py <input.gbk>
+
+import os
+import string
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO, SeqUtils
+from decimal import Decimal, ROUND_UP
+
+def parseArgs():
+	parser = ArgumentParser(description='Calculates the molecular weight of proteins in a GenBank file')
+	parser.add_argument('-i', '--infile', required=True, help='input GenBank file with translations')
+	args = parser.parse_args()
+	return args
+
+def calc_molec_weight(protein_seq):
+	return Decimal(SeqUtils.molecular_weight(protein_seq, seq_type='protein')
+		).quantize(Decimal('.001'), rounding=ROUND_UP)
+
+def main():
+	opts = parseArgs()
+	infile = opts.infile
+	gb = SeqIO.parse(infile, 'genbank')
+
+	print 'Locus_Tag\tProduct\tProtein_MolecWt_[Da]\tProtein_Seq'  #Header
+	for rec in gb:
+		for s in rec.features:
+			if (s.type == 'CDS' and 'translation') in s.qualifiers:
+				locus   = s.qualifiers['locus_tag'][0]
+				product = s.qualifiers['product'][0]
+				protein = s.qualifiers['translation'][0]
+				if 'X' in protein:
+					num_X = protein.count('X')
+					estimated_mw = Decimal(num_X) * Decimal('128.16')  #UNK=(C5)(H6)(N1)(O3)=128.16
+					peptide_mw   = calc_molec_weight(protein.replace('X', ''))
+					protein_mw   = '~' + str(peptide_mw + estimated_mw)
+				else:
+					protein_mw   = calc_molec_weight(protein)
+				print '{}\t{}\t{}\t{}'.format(locus,product,protein_mw,protein)
+
+if __name__ == '__main__':
+	main()
diff --git a/genbank2faa.py b/genbank2faa.py
new file mode 100755
index 0000000..67208ef
--- /dev/null
+++ b/genbank2faa.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Creates a Fasta Amino Acid (FAA) '
+		'formatted file of protein sequences from a GenBank flat file format',
+		add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input GenBank file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None,
+		help='output Fasta Amino Acid (.faa) format file [stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(os.path.expanduser(opt.infile))
+	if opt.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opt.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	with open(ifh) as i:
+		for rec in SeqIO.parse(i, 'genbank') :
+			for feat in rec.features:
+				if feat.type == 'CDS' and \
+				'translation' in feat.qualifiers:
+					if len(feat.qualifiers['translation']) == 1:
+						ofh.write('>{} {}\n{}\n'.format(
+							feat.qualifiers['locus_tag'][0],
+							rec.name,
+							feat.qualifiers['translation'][0]))
+
+if __name__ == '__main__':
+	main()
diff --git a/genbank2fasta.py b/genbank2fasta.py
new file mode 100755
index 0000000..5cb2d41
--- /dev/null
+++ b/genbank2fasta.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+
+import gzip
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+from Bio.SeqUtils import GC
+
+def parseArgs():
+	parser = ArgumentParser(description='Creates a FastA file from a '
+	'GenBank file', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--input', required=True, metavar='FILE',
+		help='input GenBank file (optionally gunzip compressed)')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--output', metavar='FILE',
+		help='output FastA file [basename.fa]')
+	return parser.parse_args()
+
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.realpath(os.path.expanduser(opt.input))
+	if opt.output:
+		ofh = os.path.realpath(os.path.expanduser(opt.output))
+	else:
+		ofh = os.path.basename(ifh).rstrip('.gz').rsplit('.', 1)[0] + '.fa'
+
+	records = []
+	if ifh.endswith('.gz'):
+		ifh = gzip.open(ifh)	
+	for rec in SeqIO.parse(ifh, 'genbank'):
+		# halt if nucleotides are absent rather than printing default 'N'
+		if float(GC(rec.seq)) == 0:
+			sys.stderr.write('ERROR: {} appears to lack nucleotides\n'.\
+				format(ifh))
+			sys.exit(1)
+		records.append(rec)
+	with open(ofh, 'w') as o:
+		SeqIO.write(records, o, 'fasta')
+
+
+if __name__ == '__main__':
+	main()
diff --git a/genbank2ffn.py b/genbank2ffn.py
new file mode 100755
index 0000000..0e8a763
--- /dev/null
+++ b/genbank2ffn.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Converts a GenBank file containing '
+		'nucleotide sequences into a FastA Format of genes (FFN) file')
+	parser.add_argument('-i', '--infile', required=True,
+		help='input GenBank Format file <.gbff||.gbk>')
+	parser.add_argument('-o', '--outfile', required=False, default=None,
+		help='output FastA Format of gene sequences (.ffn) file [stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	o = []
+	with open(os.path.abspath(os.path.expanduser(opt.infile))) as ifh:
+		for rec in SeqIO.parse(ifh, 'genbank'):
+			for feat in rec.features:
+				if feat.type == 'gene':
+					seq = str(feat.location.extract(rec.seq))
+					tag = feat.qualifiers['locus_tag'][0]
+					o.append('>{}\n{}\n'.format(tag, seq))
+
+	if opt.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opt.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	for rec in o:
+		ofh.write(rec)
+
+if __name__ == '__main__':
+	main()
diff --git a/genbank2gff.py b/genbank2gff.py
new file mode 100755
index 0000000..05f3467
--- /dev/null
+++ b/genbank2gff.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+
+import gzip
+import os
+import sys
+from argparse import ArgumentParser
+from BCBio import GFF  #pip install bcbio-gff
+from Bio import SeqIO
+from Bio.SeqUtils import GC
+
+def parseArgs():
+	parser = ArgumentParser(description='Converts a GenBank file containing '
+		'nucleotide sequences into a General Feature Format (GFF) file')
+	parser.add_argument('-i', '--infile', required=True,
+		help='input GenBank Format file <.gff||.gff3>')
+	parser.add_argument('-o', '--outfile', required=False, default=None,
+		help='output General Feature Format (.gff or .gff3) file [stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.realpath(os.path.expanduser(opt.infile))
+	if opt.outfile is not None:
+		ofh = os.path.realpath(os.path.expanduser(opt.outfile))
+	else:
+		ofh = sys.stdout
+
+	records = []
+	if ifh.endswith('.gz'):
+		ifh = gzip.open(ifh)
+	for rec in SeqIO.parse(ifh, 'genbank'):
+		# halt if nucleotides are absent rather than printing default 'N'
+		if float(GC(rec.seq)) == 0:
+			sys.stderr.write('ERROR: {} appears to lack nucleotides\n'.\
+				format(ifh))
+			sys.exit(1)
+		records.append(rec)
+	with open(ofh, 'w') as o:
+		GFF.write(records, o, include_fasta=True)
+
+if __name__ == '__main__':
+	main()
diff --git a/genbankacc2gbk.py b/genbankacc2gbk.py
new file mode 100755
index 0000000..88a1dbc
--- /dev/null
+++ b/genbankacc2gbk.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+
+import os
+import re
+import sys
+import time
+from argparse import ArgumentParser
+from Bio import Entrez
+
+def parseArgs():
+	parser = ArgumentParser(description='Given accession(s), retrieve and '
+		'save a GenBank file.', add_help=False, epilog='If more than one '
+		'accession is provided, all will be merged into a single output file')
+	req = parser.add_argument_group('Required')
+	req.add_argument('acc', metavar='accession', nargs='+',
+		help='accession number(s) to retrieve')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-l', '--min-length', type=int, metavar='INT',
+		default=7500, help='minimum record length (base pairs) to save '
+		'without error warnings [7500]')
+	opt.add_argument('-o', '--outfile', type=str, metavar='FILE',
+		default=None, help='output GenBank filename [<acc>.gbk] ')
+	return parser.parse_args()
+
+def multi_gbk(acc_list, minlen, gbk):
+	fetched = Entrez.efetch(db='nucleotide', id=acc_list,
+		rettype='gbwithparts', retmode='text').read().rstrip('\n')
+	print('\tfound {} GenBank records'.format(
+		str(len(fetched.split('//\n\n')))))
+	if len(fetched) < minlen:
+		sys.exit('ERROR: suspiciously short GenBank record')
+	contigs = []
+	for record in fetched.split('\n\n'):
+		if acc_list[0] not in record:
+			sys.exit('ERROR: improperly retrieved accession {}'.format(
+				acc_list[0]))
+		del acc_list[0]
+		contig = record.rstrip('\n').split('\n')
+		i = contig.index('ORIGIN      ')
+		contig.insert(i, 'CONTIG')  #enables biopython to SeqIO parse as 'gb'
+		contigs.extend(contig)
+	with open(gbk, 'w') as of:
+		of.write('\n'.join(s for s in contigs))
+
+def get_gbk(accession, minlen, gbk):
+	fetched = Entrez.efetch(db='nucleotide', id=accession,
+		rettype='gbwithparts', retmode='text').read()
+	if accession not in fetched:
+		sys.exit('ERROR: unable to retrieve accession number {}'.format(
+			accession))
+	if 'WGS         ' in fetched: #entry is the master record for a whole 
+	# genome shotgun sequencing (WGS) project and lacks sequence data
+		wgs_acc_list = []
+		for line in fetched.split('\n'): #handles >1 WGS entry such as NZ_AWGN00000000.1
+			if line.startswith('WGS         '):
+				if '-' in line: #single range specified such as NZ_MDJV00000000.1
+					wgs_accs = line.lstrip('WGS         ').split('-')
+					wgs_acc_pref_first = re.sub('\d', '', wgs_accs[0])
+					wgs_acc_pref_last  = re.sub('\d', '', wgs_accs[1])
+					if wgs_acc_pref_first != wgs_acc_pref_last:
+						sys.exit('ERROR: unable to parse WGS info')
+					wgs_acc_suff_first = int(re.sub('\D', '', wgs_accs[0]))
+					wgs_acc_suff_last  = int(re.sub('\D', '', wgs_accs[1]))
+					acc_suffs = range(wgs_acc_suff_first, wgs_acc_suff_last + 1, 1)
+					wgs_acc_list.extend( [wgs_acc_pref_first + 
+						str('{num:08d}'.format(num=s)) for s in acc_suffs] )
+				else: #just one accession specified such as NZ_JPNX00000000.2
+					wgs_acc_list.append(line.split()[1])
+		print('\t{} accession is an incomplete chromosome.\n'
+		'\tRetrieving {} individual contigs...'.format(
+			accession, str(len(wgs_acc_list))))
+		time.sleep(3)  #be nice to NCBI before doing a second efetch request
+		multi_gbk(wgs_acc_list, minlen, gbk)
+	elif len(fetched) < minlen:
+		sys.exit('{}\nERROR: suspiciously short record for {}'.format(
+			fetched, accession))
+	else:
+		with open(gbk, 'w') as of:
+			of.write(fetched)
+		print('\tfound {}'.format(accession))
+
+def main():
+	opts = parseArgs()
+	acc    = opts.acc
+	minlen = opts.min_length
+	Entrez.email = 'yourname@univ.edu'
+
+	# just in case an accession was passed as a comma-separated string, split
+	if any(',' in a for a in acc):
+		split_accessions = []
+		for accessions_string in acc:
+			for accession in accessions_string.split(','):
+				split_accessions.append(accession)
+		acc = split_accessions
+
+	# handle outfile naming
+	if opts.outfile is not None:
+		out = os.path.realpath(opts.outfile)
+	elif len(acc) == 1:
+		out = os.path.join(os.getcwd(), '{}.gbk'.format(acc[0]))
+	elif len(acc) > 1:
+		out = os.path.join(os.getcwd(), '{}.gbk'.format(','.join(acc)))
+	
+	# fetch genbank record(s) and save as single file
+	if len(acc) == 1:
+		get_gbk(acc[0], minlen, out)
+	elif len(acc) > 1:
+		multi_gbk(acc, minlen, out)
+
+if __name__ == '__main__':
+	main()
diff --git a/join.multi-fasta.py b/join.multi-fasta.py
new file mode 100755
index 0000000..3e3bab9
--- /dev/null
+++ b/join.multi-fasta.py
@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from itertools import chain
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(add_help=False,
+		description='Reads more than one multi-FastA file and joins '
+		'sequences together (in the order given) based on a shared '
+		'identifier in each sequence record. Works on amino and nucleic '
+		'acids, with and without gaps. All sample identifiers in the first '
+		'file given must be present in all other files, and those '
+		'absent in the first file will be ignored. For example: '
+		'>s1_00012 CCC >s2_00475 C-C and '
+		'>s1_00037 GGGG >s2_00029 GAAG >s3_00029 GTTG '
+		'become >s1 CCCGGGG >s2 C-CGAAG',
+		epilog='NOTE: Prokka generates FAA files with locus_tags being first '
+		'in each defline, which is extracted from each SeqRecord object '
+		'property as a name (--seq-property name). Sample identifiers can '
+		'then be extracted from each locus_tag by taking the prefix when '
+		'split from an underscore (--seq-delim \'_\'). Defaults are setup to '
+		'handle this.')
+	req = parser.add_argument_group('Required')
+	req.add_argument('mfa', metavar='FILE', nargs='+',
+		help='input multi-FastA file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-d', '--discard', metavar='\'STR\'', type=str, default='',
+		help='remove sites containing at least one specified character(s) '
+		'such as gaps or ambiguities; comma-separate for more than one '
+		'character and flank with apostrophes if necessary to santize special '
+		'characters such as \'N,n,X,x,-\' [none]')
+	opt.add_argument('-n', '--min-alleles', metavar='INT', type=int, default=1,
+		help='minimum number of allele variants (after optional --discard '
+		'filtering option) required per site to report in output; '
+		'e.g., 2 removes monomorphic sites and 3 removes '
+		'invariant and biallelic sites [1]')
+	opt.add_argument('-o', '--outfile', metavar='FILE', default=None,
+		help='joined output multi-FastA file [stdout]')
+	opt.add_argument('-x', '--max-alleles', metavar='INT', type=int, default=1000,
+		help='maximum number of allele variants (after optional --discard '
+		'filtering option) required per site to report in output; '
+		'e.g., 2 removes all multiallelic sites [None]')
+	opt.add_argument('--seq-delim', metavar='\'STR\'', type=str,
+		default='\'_\'',
+		help='extracted identifiers (from --seq-property) are split on this '
+		'delimiter, and only the first item from this is used as a sample '
+		'identifier for joining sequences. Flank with apostrophes if '
+		'necessary to santize special characters. More than one character to '
+		'singly match and split off is permitted. Set to \'\' if each '
+		'identifier is not a locus_tag. [\'_\']')
+	opt.add_argument('--seq-property',
+		choices=['description', 'id', 'name'], default='name',
+		help='SeqRecord object property to first extract identifiers from '
+		'[name]')
+	opt.add_argument('--sort-files', action='store_true',
+		default=False,
+		help='toggle on alphanumeric sorting of input sample files to '
+		're-orient sequence order in the output [off]')
+	return parser.parse_args()
+
+def mfa_to_dic(seq_delim, seq_property, infile, keys_only=False):
+	if len(seq_delim) > 0:
+		if seq_property == 'name':
+			d = SeqIO.to_dict(SeqIO.parse(infile, 'fasta'),
+				key_function=lambda rec: \
+				rec.name.split(seq_delim)[0])
+		elif seq_property == 'id':
+			d = SeqIO.to_dict(SeqIO.parse(infile, 'fasta'),
+				key_function=lambda rec: \
+				rec.id.split(seq_delim)[0])
+		elif seq_property == 'description':
+			d = SeqIO.to_dict(SeqIO.parse(infile, 'fasta'),
+				key_function=lambda rec: \
+				rec.description.split(seq_delim)[0])
+	else:
+		if seq_property == 'name':
+			d = SeqIO.to_dict(SeqIO.parse(infile, 'fasta'),
+				key_function=lambda rec: rec.name)
+		elif seq_property == 'id':
+			d = SeqIO.to_dict(SeqIO.parse(infile, 'fasta'),
+				key_function=lambda rec: rec.id)
+		elif seq_property == 'description':
+			d = SeqIO.to_dict(SeqIO.parse(infile, 'fasta'),
+				key_function=lambda rec: rec.description)
+	if keys_only:
+		d = sorted(list(d.keys()))
+	return d
+
+def main():
+	opt = parseArgs()
+
+	# Input file handling
+	ifs = [os.path.abspath(os.path.expanduser(f)) for f in opt.mfa]
+	if opt.sort_files:
+		ifs.sort()
+
+	# Get sample IDs from first file's deflines
+	qp = opt.seq_property
+	qd = opt.seq_delim.lstrip('\'').rstrip('\'')
+	ids = mfa_to_dic(qd, qp, ifs[0], keys_only = True)
+
+	# Capture all sequences for each sample ID from each input file
+	d = {}
+	for idx_file, file in enumerate(ifs):
+		fa = mfa_to_dic(qd, qp, file)
+		for sample in ids:
+			d['{}_{}'.format(idx_file, sample)] = str(fa[sample].seq)
+
+	# Prepare output
+	o = []
+	for sample in ids:
+		seq = ''
+		for i in range(len(ifs)):
+			seq += d['{}_{}'.format(i, sample)]
+		o.extend(['>' + str(sample), str(seq)])
+	cnt_init = cnt_keep = len(o[1])
+
+
+	# Optional site filtering
+	if len(opt.discard) > 0 or opt.min_alleles != 1 or opt.max_alleles != 1000:
+		unwanted = opt.discard.lstrip('\'').rstrip('\'').split(',')
+		keep = []
+
+		# Transpose sequences
+		for site in zip(*(o[1::2])):
+			alleles = set(site)
+			filt_alleles = filter(lambda a: a not in unwanted, alleles)
+
+			# Filter allelle contents
+			if len(alleles) == len(filt_alleles):
+				# Filter allelle quantities
+				if len(alleles) >= opt.min_alleles and \
+				len(alleles) <= opt.max_alleles:
+					keep.append(''.join(site))
+		cnt_keep = len(keep)
+
+		# Interleave deflines with sequences
+		o = list(chain.from_iterable(zip(o[0::2], zip(*keep))))
+
+	# Report tallies
+	for i, s in ((len(ids), 'sequence records found'),
+		(cnt_init, 'initial sites per sequence'),
+		(cnt_init - cnt_keep, 'sites discarded per sequence'),
+		(cnt_keep, 'final sites per sequence')):
+		sys.stderr.write('  {} {}\n'.format(i, s))
+
+	# Write single output file
+	if opt.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opt.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	for ln in o:
+		ofh.write('{}\n'.format(''.join(ln)))
+
+if __name__ == '__main__':
+	main()
diff --git a/locus_tag2faa.py b/locus_tag2faa.py
new file mode 100755
index 0000000..adb12b4
--- /dev/null
+++ b/locus_tag2faa.py
@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+
+# Usage: python script.py <input.gbk> <locus_tag>
+
+from Bio import SeqIO
+import sys
+
+infile = SeqIO.parse(sys.argv[1], 'genbank')
+want = str(sys.argv[2])
+
+for record in infile:
+	for s in record.features:
+		if 'locus_tag' and 'translation' and 'protein_id' and 'product' in s.qualifiers:
+			locus_record = s.qualifiers['locus_tag'][0]
+			if locus_record == want:
+				print '>' + s.qualifiers['locus_tag'][0] + '|' + s.qualifiers['protein_id'][0] + '|' + s.qualifiers['product'][0] + '\n' + s.qualifiers['translation'][0]
diff --git a/locus_tag2ffn.py b/locus_tag2ffn.py
new file mode 100755
index 0000000..e156464
--- /dev/null
+++ b/locus_tag2ffn.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from BCBio import GFF  #pip install bcbio-gff
+from BCBio.GFF import GFFParser
+from Bio import SeqIO
+from Bio.Alphabet import generic_dna
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def parseArgs():
+	parser = ArgumentParser(description='Extracts gene sequences from a '
+		'General Feature Format (GFF) file given a locus_tag or '
+		'comma-separated list of locus_tags. BED file of extraction(s) is '
+		'printed to stdout.',
+		epilog='a BED format of extracted gene(s) is printed to standard out')
+	parser.add_argument('-i', '--infile', required=True,
+		help='input General Feature Format file <.gff||.gff3>')
+	parser.add_argument('-l', '--locus_tag', required=True, default=None,
+		help='locus tag(s) to extract; comma-separate if >1')
+	parser.add_argument('-o', '--outfile', required=False, default=None,
+		help='[<locus_tag(s)>.ffn]')
+	return parser.parse_args()
+
+def extract_seq(beg, end, sns, seq, locus_name):
+	''' returns a SeqRecord obj given a nucleotide sequence and record
+	info to extract specific sites including: begin, stop, and strand sense '''
+	extraction = seq[int(beg):int(end)]
+	if sns < 0:
+		return SeqRecord(Seq(extraction, generic_dna).reverse_complement(),
+						id=locus_name, description='')
+	else:
+		return SeqRecord(Seq(extraction, generic_dna),
+						id=locus_name, description='')
+
+def locus_tag2rec_nfo(want, infile):
+	''' returns a tuple containing record info 
+	given a GFF file and locus_tag to locate '''
+	parser = GFFParser()
+	with open(infile, 'r') as gff:
+		rec_nfo = (None, ) * 5
+		for rec in parser.parse(gff, limit_info = dict(
+			gff_type = ['gene', 'CDS', 'locus_tag', 'product'])):
+			for feat in rec.features:
+				if feat.type == 'gene' and 'locus_tag' in feat.qualifiers:
+					locus_tag = feat.qualifiers.get('locus_tag', None)
+					if want in locus_tag:
+						rec_nfo = (feat.location.start.position,
+							feat.location.end.position, feat.strand,
+							rec.id, rec.seq.tostring())
+	return rec_nfo
+
+def main():
+	opt = parseArgs()
+	ifh = opt.infile
+	if ',' in opt.locus_tag:
+		loc_wnt = opt.locus_tag.split(',')
+	else:
+		loc_wnt = opt.locus_tag
+
+	if opt.outfile is not None:
+		ofh = os.path.abspath(os.path.expanduser(opt.outfile))
+	else:
+		ofh = opt.locus_tag + '.ffn'
+
+	# Extract one or more locus tags
+	if isinstance(loc_wnt, list):
+		seq_rec = []
+		for loc in loc_wnt:
+			rec_nfo = locus_tag2rec_nfo(loc, ifh)
+			if all(rec_nfo):
+				(beg, end, sns, ctg_id, ctg_seq) = rec_nfo
+				if sns < 0:
+					sym = '-'
+				else:
+					sym = '+'
+				print '{}\t{}\t{}\t{}\t0\t{}'.format(ctg_id, beg, end, loc, sym)
+				sr = extract_seq(beg, end, sns, ctg_seq, loc)
+				seq_rec.append(sr)
+			else:
+				sys.exit('ERROR: absent {}'.format(loc))
+	else:
+		rec_nfo = locus_tag2rec_nfo(loc_wnt, ifh)
+		if all(rec_nfo):
+			(beg, end, sns, ctg_id, ctg_seq) = rec_nfo
+			if sns < 0:
+				sym = '-'
+			else:
+				sym = '+'
+			print '{}\t{}\t{}\t{}\t0\t{}'.format(ctg_id, beg, end, loc_wnt, sym)
+			seq_rec = extract_seq(beg, end, sns, ctg_seq, loc_wnt)
+		else:
+			sys.exit('ERROR: absent {}'.format(loc_wnt))
+
+	# Write one or more extracted genes to FastA
+	SeqIO.write(seq_rec, ofh, 'fasta')
+
+if __name__ == '__main__':
+	main()
diff --git a/mutate.nucleotide.sequence.records.py b/mutate.nucleotide.sequence.records.py
new file mode 100755
index 0000000..ff1f4e8
--- /dev/null
+++ b/mutate.nucleotide.sequence.records.py
@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+
+
+import gzip
+import os
+import shutil
+import sys
+from argparse import ArgumentParser
+from tempfile import mkdtemp
+
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+import numpy as np
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+from Bio.SeqIO.QualityIO import FastqGeneralIterator
+
+
+def parse_args():
+    parser = ArgumentParser(
+        description='Introduce SNPs into sequence records',
+        epilog='NOTE: More mutations than the length of a sequence is'
+        ' supported. Each mutation position is chosen at random, and it is'
+        ' possible 2 mutations would occur at the same site.',
+        add_help=False,
+    )
+    req = parser.add_argument_group('Required')
+    req.add_argument(
+        '-i',
+        '--infile',
+        required=True,
+        metavar='FILE',
+        help='input sequence file '
+        '(FastA or FastQ, optionally gunzip compressed)',
+    )
+    opt = parser.add_argument_group('Input Options')
+    opt.add_argument(
+        '-k',
+        '--keep-lowercase',
+        action='store_true',
+        default=False,
+        help='keep mutated nucleotides lowercase [off]',
+    )
+    opt.add_argument(
+        '-m',
+        '--mutations-per-record',
+        metavar='INT',
+        type=require_int_nonnegative,
+        default=1,
+        help='number of mutation events to introduce for each sequence record'
+        ' [%(default)s]',
+    )
+    opt.add_argument(
+        '-o',
+        '--outfile',
+        metavar='FILE',
+        type=str,
+        default=None,
+        help='output file [stdout]',
+    )
+    opt.add_argument(
+        '-h',
+        '--help',
+        action='help',
+        help='show this help message and exit'
+    )
+    return parser.parse_args()
+
+
+def require_int_nonnegative(x):
+    try:
+        if int(x) < 0 or '.' in str(x):
+            sys.stderr.write(
+                'ERROR: {} must be a non-negative integer\n'.format(x)
+            )
+            sys.exit(1)
+    except ValueError:
+        sys.stderr.write('ERROR: {} must be an integer\n'.format(x))
+        sys.exit(1)
+    return int(x)
+
+
+def decompress_file(infile, outdir):
+    # Create a new output file name
+    uncompressed_file = os.path.basename(infile).rstrip('.gz')
+    outfile = os.path.join(outdir, uncompressed_file)
+
+    # Decompress the gunzipped file
+    with gzip.open(infile, 'rb') as ifh, open(outfile, 'wb') as ofh:
+        shutil.copyfileobj(ifh, ofh)
+
+    # Send the full path of the decompressed file back
+    return outfile
+
+
+def mutate_nucleotide_site(input_nucleotide, bool_keep_lowercase):
+    nucleotides = ['a', 't', 'c', 'g']
+
+    # Remove the input nucleotide from the list to guarantee we create a SNP
+    # NOTE: even an 'N' or other non-ATCG nucleotide will be mutated
+    if input_nucleotide.lower() in nucleotides:
+        nucleotides.remove(input_nucleotide.lower())
+
+    # Randomly choose a new (different) nucleotide
+    random_value = np.random.randint(low=0, high=len(nucleotides))
+    new_nucleotide = nucleotides[random_value]
+
+    # Choose upper or lowercase for the mutation character
+    if not bool_keep_lowercase:
+        new_nucleotide = new_nucleotide.upper()
+
+    return new_nucleotide
+
+
+def mutate_nucleotide_string(input_string, position, bool_keep_lowercase):
+    # Extract the individual nucleotide to be mutated
+    old_nucleotide = input_string[position]
+
+    # Randomly choose a different nucleotide
+    new_nucleotide = mutate_nucleotide_site(
+        old_nucleotide, bool_keep_lowercase
+    )
+
+    # Form the new full length nucleotide string
+    mutated_nucleotide_string = (
+        input_string[:position] + new_nucleotide + input_string[position+1:]
+    )
+
+    return mutated_nucleotide_string
+
+
+def mutate_fastq(infile, mutations_per_record, bool_keep_lowercase, outfile):
+    new_sequence_records = []
+    for title, sequence, quality in FastqGeneralIterator(infile):
+        seq = str(sequence)
+
+        # Determine random positions within the nucleotide string to mutate
+        random_positions = list(
+            np.random.randint(
+                low=0, high=len(sequence), size=mutations_per_record
+            )
+        )
+
+        # Mutate the sequence; handles 1 or more mutations per record
+        for pos in random_positions:
+            seq = mutate_nucleotide_string(seq, pos, bool_keep_lowercase)
+
+        # Verify we truly have mutated the sequence
+        if seq == sequence:
+            sys.stderr.write('ERROR: {} sequence not mutated\n'.format(seq))
+            sys.exit(1)
+
+        # Construct a new FastQ sequence record object
+        fastq_record_string = '@{}\n{}\n+\n{}\n'.format(title, seq, quality)
+        new_rec = SeqIO.read(StringIO(fastq_record_string), 'fastq')
+        new_sequence_records.append(new_rec)
+
+    # Write the mutated output and report some general info
+    SeqIO.write(new_sequence_records, outfile, 'fastq')
+    print(
+        'INFO: mutated all {} sequence records'.format(
+            len(new_sequence_records)
+        )
+    )
+
+
+def mutate_fasta(infile, mutations_per_record, bool_keep_lowercase, outfile):
+    new_sequence_records = []
+    for record in SeqIO.parse(infile, 'fasta'):
+        seq = str(record.seq)
+
+        # Determine random positions within the nucleotide string to mutate
+        random_positions = list(
+            np.random.randint(low=0, high=len(seq), size=mutations_per_record)
+        )
+
+        # Mutate the sequence; handles 1 or more mutations per record
+        for pos in random_positions:
+            seq = mutate_nucleotide_string(seq, pos, bool_keep_lowercase)
+
+        # Verify we truly have mutated the sequence
+        if seq == record.seq:
+            sys.stderr.write('ERROR: {} sequence not mutated\n'.format(seq))
+            sys.exit(1)
+
+        # Construct a new FastA sequence record object
+        new_rec = SeqRecord(
+            id=record.description, seq=Seq(seq), description='', name=''
+        )
+        new_sequence_records.append(new_rec)
+
+    # Write the mutated output and report some general info
+    SeqIO.write(new_sequence_records, outfile, 'fasta')
+    print(
+        'INFO: mutated all {} sequence records'.format(
+            len(new_sequence_records)
+        )
+    )
+
+
+def main():
+    opt = parse_args()
+
+    # I/O handling
+    mutations_per_record = opt.mutations_per_record
+    infile = os.path.realpath(os.path.expanduser(opt.infile))
+    if opt.outfile is None:
+        outfile = sys.stdout
+    else:
+        outfile = os.path.realpath(os.path.expanduser(opt.outfile))
+    bool_keep_lowercase = opt.keep_lowercase
+
+    # Auto-handle gunzip compressed input
+    tmp = mkdtemp()
+    if infile.endswith('.gz'):
+        infile = decompress_file(infile, tmp)
+
+    # Iteratate across each sequence record and mutate
+    if infile.lower().endswith(('.fastq', '.fq', '.fsq')):
+        mutate_fastq(
+            infile, mutations_per_record, bool_keep_lowercase, outfile
+        )
+    elif infile.lower().endswith(('.fasta', '.fa', '.fsa', '.fas')):
+        mutate_fasta(
+            infile, mutations_per_record, bool_keep_lowercase, outfile
+        )
+    else:
+        sys.stderr.write(
+            'ERROR: unable to detect file extension as FastA or FastQ'
+            ' format\n'
+        )
+        sys.exit(1)
+
+    # Cleanup
+    shutil.rmtree(tmp)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/parsnp.vcf2fasta.py b/parsnp.vcf2fasta.py
new file mode 100755
index 0000000..a322076
--- /dev/null
+++ b/parsnp.vcf2fasta.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+
+
+import sys
+from argparse import ArgumentParser
+
+
+def parseArgs():
+	parser = ArgumentParser(description='Parses a Parsnp VCF file and '
+			'prints all SNPs to standard out. This is particularly useful '
+			'when manipulating the file and harvesttools has an error. '
+			'Multiallelic SNPs must be removed and FILTER tags are ignored. '
+			'Sample names and their binary data must begin on the 10th '
+			'column. For SNP extraction from default Parsnp, '
+			'`harvesttools -i parsnp.ggr -S SNPs.fa` is recommended.',
+			add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--input', required=True, metavar='FILE',
+		help='input VCF file from Parsnp')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	return parser.parse_args()
+
+# Main
+opts = parseArgs()
+
+# Get sample IDs
+with open(opts.input, 'r') as ifh:
+	for ln in ifh:
+		if any(ln.startswith('#CHROM') for x in ln):
+			samples_d = {k:[] for k in ln.rstrip('\n').split('\t')[9:]}
+			samples_l = ln.rstrip('\n').split('\t')[9:]
+			break
+
+# Parse the VCF file
+ifh = open(opts.input, 'r')
+for ln in ifh:
+	if not ln.startswith('#'):
+		data = ln.rstrip('\n').split('\t')
+		ref = data[3]
+		if ',' in data[4]:
+			alt = data[4].split(',')
+		else:
+			alt = [data[4]]
+		binary_data = data[9:]
+		for i, datum in enumerate(binary_data):
+			if datum == '0':
+				nuc = ref
+			elif datum == '1':
+				nuc = alt[0]
+			elif datum == '2':
+				nuc = alt[1]
+			elif datum == '3':
+				nuc = alt[2]
+			else:
+				sys.stderr.write('ERROR: ALT value >3\n')
+			sample_id = samples_l[i]
+			samples_d[sample_id].append(nuc)
+ifh.close()
+
+# Write FastA to Std Out
+snp_len = len(samples_d[sample_id])
+for sample in samples_l:
+	snps = ''.join(samples_d[sample])
+	if len(snps) != snp_len:
+		sys.stderr.write('ERROR: unequal sequence records printed\n')
+	else:
+		print('>{}'.format(sample))
+		print(snps)
diff --git a/plot.map-to-ref.py b/plot.map-to-ref.py
new file mode 100755
index 0000000..173f3e0
--- /dev/null
+++ b/plot.map-to-ref.py
@@ -0,0 +1,538 @@
+#!/usr/bin/env python
+
+
+import argparse
+import csv
+import gzip
+import os
+import re
+import shutil
+import subprocess as sp
+import sys
+from multiprocessing import cpu_count
+from tempfile import mkdtemp
+
+from Bio import SeqIO
+from Bio import SeqRecord
+from Bio.SeqUtils import GC
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+# import vcf
+
+
+def parseArgs():
+	parser = argparse.ArgumentParser(description='creates a scatter'
+		' histogram plot of reads mapped to a reference', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', type=str, metavar='FILE', nargs='+',
+		help='input FastQ file(s) optionally gunzip compressed; two inputs'
+		' uses paired-end mapping')
+	req.add_argument('-r', '--reference', metavar='FILE', required=True,
+		type=str,
+		help='FastA reference for reads to map to, optionally gunzip'
+		' compressed')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-c', '--cpus', type=require_int_nonnegative,
+		metavar='INT', default='0', help='number of CPUs [all]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-m', '--map-options', type=str,
+		default='\'--no-unal --no-mixed --no-discordant -X 1000\'',
+		metavar='\'STR\'',
+		help='options passed to bowtie2 aligner; surround with single quotes'
+		' [\'--no-unal --no-mixed --no-discordant -X 1000\']')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='output plot filename [map-to-ref.pdf]')
+	opt.add_argument('-x', '--xlsx', default=None, metavar='FILE',
+		help='output XLSX filename [None]')
+	return parser.parse_args()
+
+def require_nargs_range(x, val_min, val_max):
+	if val_min > len(x) > val_max:
+		sys.stderr.write('ERROR: {} must not be lower than {} or higher than'
+			' {}'.format(x, val_min, val_max))
+		sys.exit(1)
+	return str(x)
+
+def require_int_nonnegative(x):
+	try:
+		if int(x) < 0 or '.' in str(x):
+			sys.stderr.write('ERROR: {} must be a non-negative integer\n'.\
+				format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be an integer\n'.format(x))
+		sys.exit(1)
+	return int(x)
+
+def require_dependency(dep):
+	for path in os.environ.get('PATH', '').split(':'):
+		if os.path.exists(os.path.join(path, dep)) and \
+		not os.path.isdir(os.path.join(path, dep)):
+			return True
+	sys.stderr.write('ERROR: {} unavailable; not in $PATH\n'.format(dep))
+	sys.exit(1)
+
+def verify_file_exists_and_nonempty(infile):
+	if os.path.exists(infile):
+		if os.stat(infile).st_size == 0:
+			sys.stderr.write('ERROR: {} file empty\n'.format(infile))
+			sys.exit(1)
+	else:
+		sys.stderr.write('ERROR: {} file absent\n'.format(infile))
+		sys.exit(1)
+
+def system_call(cmd):
+	process = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE)
+	_, err = process.communicate()
+	if process.returncode != 0:
+		sys.stderr.write(err)
+		sys.stderr.write('ERROR: failed system call: {}\n'.\
+			format(' '.join(cmd)))
+		sys.exit(1)
+
+def cleanup_and_evaluate_mfasta(infile, outfile):
+	'''
+	avoid funky input defline headaches with alignment software by renaming
+	and report contig lengths
+	'''
+	records, sequence_lengths = [], []
+	i = 1
+	for rec in SeqIO.parse(infile, 'fasta'):
+		if float(GC(rec.seq)) == 0:
+			sys.stderr.write('ERROR: {} appears to lack nucleotides\n'.\
+				format(infile))
+			sys.exit(1)
+		sequence_lengths.append(len(rec.seq))
+		# records.append(SeqRecord.SeqRecord(id='ctg_{}'.format(i),
+		# 	seq=rec.seq, description=''))
+		records.append(SeqRecord.SeqRecord(
+			id=str(i), #plain integers for easy sorting VCF by chrom name
+			seq=rec.seq, description=''))
+		i += 1
+	SeqIO.write(records, outfile, 'fasta')
+	return sequence_lengths
+
+def read_vcf_with_pyvcf(infile):
+	'''
+	takes VCF file as input, returns list of tuples containing:
+	chrom, pos, depth, percent identity
+	'''
+	# strict allows you to parse files with spaces in the sample names
+	vcf_reader = vcf.Reader(filename=infile, strict_whitespace=True)
+	mapped_sites = [] #list of tuples where each tuple contains:
+					# (chrom, pos, depth, %identity)
+	for rec in vcf_reader:
+		chrom, pos, alleles = rec.CHROM, rec.POS, rec.INFO['AD']
+		total_depth = sum(alleles)
+		if total_depth > 0:
+			ref_depth = float(alleles[0])
+			percent_identity = (ref_depth / total_depth) * 100
+			print('{}\t{}\t{}\t{}'.format(chrom, pos, total_depth, percent_identity))
+			mapped_sites.append(chrom, pos, total_depth, percent_identity)
+	return mapped_sites
+
+def read_vcf(infile, check_dupes=True):
+	'''
+	takes VCF file as input, returns pandas dataframe
+	'''
+	# load in VCF file
+	skip_rows = 0
+	with open(infile) as ifh:
+		for ln in ifh:
+			if ln.startswith('##'):
+				skip_rows += 1
+			else:
+				break
+	df = pd.read_csv(infile, sep='\t', skiprows=skip_rows, header=0,
+		dtype={'#CHROM': int, 'POS': int, 'ID': str, 'REF': str, 'ALT': str,
+		'QUAL': str, 'FILTER': str, 'INFO': str, 'FORMAT': str},).\
+		rename(columns={'#CHROM': 'CHROM'})
+	if len(df) < 1:
+		sys.stderr.write('ERROR: no alignment data present in VCF.'
+			' Verify reads align to the input reference. Files are'
+			' within {}\n'.format(os.path.dirname(infile)))
+		sys.exit(1)
+	# remove unused columns
+	df.drop(columns=['ID', 'REF', 'ALT', 'QUAL', 'FILTER', 'FORMAT'])
+
+	if check_dupes:
+		dupes = df[df.duplicated(subset=['CHROM','POS'], keep=False)]
+		if len(dupes) > 0:
+			sys.stderr.write('ERROR: duplicate positions found, '
+				'perhaps due to SNPs and InDels. Only one position '
+				'permitted, so either skip InDels or merge prior to trying '
+				'to fill unmapped sites.\n')
+			dupes = dupes[['CHROM', 'POS']]
+			sys.stderr.write( dupes.to_string(index=False) + '\n')
+			sys.exit(1)
+	return df
+
+def calc_stats_from_frequency_distribution_table(freqs, vals):
+	values, freqs = np.array(vals), np.array(freqs)
+	arg_sorted = np.argsort(values)
+	values = values[arg_sorted]
+	freqs = freqs[arg_sorted]
+	count = freqs.sum()
+	fx = values * freqs
+	mean = fx.sum() / count
+	variance = ((freqs * values**2).sum() / count) - mean**2
+	variance = count / (count - 1) * variance
+	std = np.sqrt(variance)
+	minimum, maximum = np.min(values), np.max(values)
+	cumcount = np.cumsum(freqs)
+	Q1 = values[np.searchsorted(cumcount, 0.25*count)]
+	Q2 = values[np.searchsorted(cumcount, 0.50*count)]
+	Q3 = values[np.searchsorted(cumcount, 0.75*count)]
+	idx = ['count', 'mean', 'std', 'min', '25%', '50%', '75%', 'max']
+	df = pd.Series([count, mean, std, minimum, Q1, Q2, Q3, maximum], index=idx)
+	return df
+
+def convert_vcf_to_stats(vcf_df):
+	'''
+	calculates depth and percent identity from vcf dataframe
+	'''
+	# make Allelic Depths "AD" its own column
+	sample_df = vcf_df.loc[:, vcf_df.columns.str.endswith('sample.sorted.sam')]
+	# sample_df = df.filter(regex='sample.sorted.sam$', axis=1)
+	if len(sample_df.columns) != 1:
+		sys.stderr.write('ERROR: VCF file requires the mapped sample name to'
+		' end with sample.sorted.sam\n')
+		sys.exit(1)
+	pl_ad = sample_df.iloc[:, 0].str.split(pat=':', expand=True)
+	if len(pl_ad.columns) != 2:
+		sys.stderr.write('ERROR: expected sample column in VCF to be split'
+			' by : into two columns in pandas. The sample column should have'
+			' ended with sample.sorted.sam (filename), and contained the PL'
+			' and AD tags but only the AD second is used.\n')
+		sys.exit(1)
+	pl_ad.columns = ['PL', 'AD'] #AD,"Allelic depths (high-quality bases)"
+	# calculate read depth per site
+	allele_depths = pl_ad['AD'].str.split(pat=',', expand=True).\
+		fillna(0).astype(int)
+	total_depth_per_site = allele_depths.sum(axis=1)
+	# calculate percent identity mapped to each reference site 
+	ref_depths = allele_depths.iloc[:, 0].astype(float)
+	percent_identity = (ref_depths / total_depth_per_site) * 100
+	# form a new VCF df with just chrom and pos
+	df = vcf_df[['CHROM','POS']]
+	# add each data Series into dataframe
+	df = pd.concat([df, total_depth_per_site.rename('depth'),
+		percent_identity.rename('percent_identity')], axis=1)
+	df = df[df.depth != 0]
+	# calculate statistics
+	alignment = {'length': len(df)}
+	depth = {'mean': float(df.depth.mean()), 'std': float(df.depth.std())}
+	s = calc_stats_from_frequency_distribution_table(
+		df['depth'], df['percent_identity'])
+	ani = {'mean': s['mean'], 'std': s['std'],
+		'Q1': s['25%'], 'Q2': s['50%'], 'Q3': s['75%']}
+	df['percent_identity'] = df['percent_identity'].round(0).astype(int)
+	# print(df.dtypes)
+	return df, alignment, depth, ani
+
+def add_unmapped_sites_to_vcf(vcf_df, ref_seq_lengths, xlsx=None):
+	'''
+	identify positions in the input reference file that had no reads align
+	and add those sites into the pandas dataframe with 0 data
+	'''
+	# dfs, chrom_names = [], []
+	# for i, ref_seq_length in enumerate(ref_seq_lengths, start=1):
+	# 	chrom_id = 'ctg_' + str(i) #cleanup_and_evaluate_mfasta() made names
+	# 	mapped_positions_in_chrom = vcf_df.loc[vcf_df['CHROM'] == chrom_id]
+	# 	if len(mapped_positions_in_chrom) == 0:
+	# 		sys.stderr.write('INFO: no reads mapped to {}\n'.format(chrom_id))
+	# 		continue
+	# 	dfs.append(
+	# 		mapped_positions_in_chrom.\
+	# 		reindex(np.arange(1, ref_seq_length + 1)).\
+	# 		fillna(0)).sort_values('POS')
+	# 	chrom_names.append(chrom_id)
+	# df = pd.concat(dfs, keys=chrom_names)
+	# # require vcf dataframe to have a row for each reference site
+	# total_ref_seq_length = sum(ref_seq_lengths)
+	# positions_in_vcf = len(df)
+	# if total_ref_seq_length != positions_in_vcf:
+	# 	sys.stderr.write('ERROR: number of VCF rows unequal to FastA'
+	# 		' reference input sequence lengths\n')
+	# 	sys.exit(1)
+	# return df
+
+	# df = vcf_df.set_index(['CHROM', 'POS']).\
+	# reindex((c, n) for c, v in enumerate(ref_seq_lengths, start=1) for n in np.arange(1, v+1)).reset_index()
+
+	rotated_df = vcf_df.set_index(['CHROM', 'POS'])
+	frames = []
+	for chrom_name, chrom_length in enumerate(ref_seq_lengths, start=1):
+		positions = np.arange(start=1, stop=chrom_length + 1)
+		idx = pd.MultiIndex.from_product(([chrom_name], positions),
+			names=['CHROM', 'POS'])
+		# chrom_df = rotated_df.iloc[
+		# 	rotated_df.index.get_level_values('CHROM') == chrom_name]
+		# dupe_positions = chrom_df[chrom_df.duplicated(['POS'], keep=False)]
+		# if len(dupe_positions) > 0:
+		# 	sys.stderr.write('ERROR: duplicate positions in {} chrom found, '
+		# 		'perhaps due to SNPs and InDels. Only one position '
+		# 		'permitted, so either skip InDels or merge prior to trying '
+		# 		'to fill unmapped sites.\n'.format(chrome_name))
+		# 	sys.stderr.write( dupe_positions + '\n')
+		# 	sys.exit(1)
+		frame = rotated_df.reindex(idx, fill_value=0).\
+			sort_values(by=['CHROM', 'POS']).reset_index()
+		frames.append(frame)
+	df = pd.concat(frames).sort_values(by=['CHROM', 'POS']).reset_index()
+	positions_in_vcf = len(df)
+	if positions_in_vcf != sum(ref_seq_lengths):
+		sys.stderr.write('ERROR: number of VCF rows unequal to FastA'
+			' reference input sequence lengths\n')
+		sys.exit(1)
+	if xlsx is not None:
+		df.to_excel(os.path.realpath(os.path.expanduser(xlsx)))
+	df = df[['depth', 'percent_identity']].to_numpy()
+	return df
+
+def filter_vcf(chrom_name=None, chrom_positions=None):
+	return None
+
+def window_average(array, window_size):
+	a = np.nanmean(np.pad(array.astype(float),
+		(0, 0 if array.size % window_size == 0 
+			else window_size - array.size % window_size),
+		mode='constant', constant_values=np.NaN).\
+		reshape(-1, window_size), axis=1)
+	return a
+
+def scatter_hist(x, y, y2, chrom_lengths, ax, ax_histx, ax_histy):
+	# no labels
+	# x = 'Depth [bp of Reads / bp of Reference]'
+	# y = 'Aligned Nucleotide Identity (ANI)'
+	ax_histx.tick_params(axis='x', which='both', labelbottom=False)
+	ax_histy.tick_params(axis='y', left=True, right=True, 
+		which='both', labelright=True, labelrotation=90)
+
+	# the scatter plot:
+	ax.scatter(x, y2, marker='.', c='k', alpha=0.25)
+	if chrom_lengths is not None:
+		for length in chrom_lengths:
+			ax.vlines(length, ymin=0, ymax=max(y), alpha=0.4)
+	# ax.vlines([1200, 5000, 7500, 12500, 15000, 16000, 17000],
+	# 	ymin=0, ymax=max(y), alpha=0.4)
+
+	# # now determine nice limits by hand:
+	# binwidth = 0.1
+	# xy_max = max(np.max(np.abs(x)), np.max(np.abs(y2)))
+	# lim = (int(xy_max/binwidth) + 1) * binwidth
+
+	# bins = np.arange(1, lim + binwidth, binwidth)
+	# print('bins'+str(bins))
+	# bins=2000
+	# ax_histx.hist(y, bins=bins)
+
+	# ax_histx.bar(x, y, color='blue', align='center') # A bar chart
+	# ax_histx.xlabel('Bins')
+	# ax_histx.ylabel('Frequency')
+
+	window_size = int(len(x) / 300)
+	x = window_average(x, window_size)
+	y = window_average(y, window_size)
+	y2 = window_average(y2, window_size)
+
+	ax_histx.bar(x, y, edgecolor='k')
+	# ax_histx.bar(x, y, width=.01, edgecolor='k')
+
+	# H, xedges, yedges = np.histogram2d(x, y, bins=100)
+	# H = H.T  # Let each row list bins with common y range.
+	# X, Y = np.meshgrid(xedges, yedges)
+	# ax_histx.pcolormesh(X, Y, H)
+
+	# window_size=200
+	# x = window_average(x, window_size)
+	# print(len(x))
+
+	# ax_histy.bar(x, y2, edgecolor='k', orientation='horizontal')
+	ax_histy.hist(y2, bins=x, orientation='horizontal')
+
+	# COLORS https://matplotlib.org/api/_as_gen/matplotlib.pyplot.colors.html
+
+def plot_scatterplot_and_histogram(x, y, y2, chrom_lengths, ani, 
+	alignment, depth, num_bins, title, subtitle, outfile):
+	# definitions for the axes
+	left, width = 0.1, 0.65
+	bottom, height = 0.1, 0.55
+	spacing = 0.015
+
+	rect_scatter = [left, bottom, width, height]
+	rect_histx = [left, bottom + height + spacing, width, 0.3]
+	rect_histy = [left + width + spacing, bottom, 0.2, height]
+	rect_text = [left + width + spacing, bottom + height + spacing, 0.2, 0.3]
+
+	# start with a square Figure
+	fig = plt.figure(figsize=(10.5, 8))
+	ax = fig.add_axes(rect_scatter)
+	plt.xlabel('Reference Genome [bp]', axes=ax)
+	plt.ylabel('Nucleotide Identity [%]', axes=ax)
+	ax_histx = fig.add_axes(rect_histx, sharex=ax)
+	plt.xlabel('', axes=ax)
+	plt.ylabel('Reads Mapped (Depth of Coverage)', axes=ax)
+	ax_histy = fig.add_axes(rect_histy)
+	plt.xlabel('BB', axes=ax)
+	plt.ylabel('Identity', axes=ax)
+	text_area = fig.add_axes(rect_text, frameon=False)
+	text_area.axis('off')
+
+	# plt.ylabel('Depth', axes=ax_histx)
+	# plt.xlabel('Quantity', axes=ax_histy)
+	# plt.ylabel('Nucleotide Identity [%]', axes=ax_histy)
+
+	textblock = '\n'.join((
+		'ANI = {:.2f}%'.format(ani['mean']),
+		r'$\sigma$ = {:.2f}%'.format(ani['std']),
+		'Q1 = {:.2f}%'.format(ani['Q1']),
+		'median = {:.2f}%'.format(ani['Q2']),
+		'Q3 = {:.2f}%'.format(ani['Q3']),
+		'Alignment = {:,} bp ({:.2f}%)'.format(alignment['length'], alignment['fraction']),
+		r'Mean Depth = {:.2f}x $\pm$ {:.2f}x'.format(depth['mean'], depth['std'])
+		))
+	legend = dict(boxstyle='round', facecolor='grey', alpha=0.5)
+	# fig.text(0.996, 0.98, textblock, transform=text_area.transAxes, fontsize=8,
+	# 	fontdict={'family':'monospace'}, verticalalignment='top', bbox=legend,
+	# 	multialignment='left')
+	text_area.annotate(textblock, xy=(1, 1), xycoords='axes fraction',
+		fontsize=8, 
+		backgroundcolor='#DCDCDC', color='k', ha='right', va='top')
+
+	# use the previously defined function
+	scatter_hist(x, y, y2, chrom_lengths, ax, ax_histx, ax_histy)
+
+	# if title is not None:
+	# 	fig.suptitle(title, fontsize=10)
+	# if subtitle is not None:
+	# 	ax.set_title(subtitle, fontsize=8)
+	if outfile.endswith('.png'):
+		img_fmt = 'png'
+	elif outfile.endswith('.svg'):
+		img_fmt = 'svg'
+	elif outfile.endswith('.eps'):
+		img_fmt = 'eps'
+	else:
+		img_fmt = 'pdf'
+	plt.savefig(outfile, pad_inches=0.5, dpi=300, format=img_fmt)
+
+def main():
+	opt = parseArgs()
+	require_dependency('bowtie2-build')
+	require_dependency('bowtie2')
+
+	# I/O Handling
+	require_nargs_range(opt.infile, 1, 2)	
+	fastq_input = []
+	for file in opt.infile:
+		fastq_input.append(os.path.realpath(os.path.expanduser(file)))
+	if len(fastq_input) == 2:
+		mode = 'paired'
+	elif len(fastq_input) == 1:
+		mode = 'single'
+	else:
+		sys.stderr.write('ERROR: only 1 or 2 input files supported\n')
+		sys.exit(1)
+	if opt.outfile is not None:
+		outfile = os.path.realpath(os.path.expanduser(opt.outfile))
+		outdir = os.path.dirname(outfile)
+		if not os.path.exists(outdir):
+			os.mkdir(outdir)
+	else:
+		outfile = 'map-to-ref.pdf'
+	input_ref = os.path.realpath(os.path.expanduser(opt.reference))
+	tmp = mkdtemp()
+	temp_ref = os.path.join(tmp, 'ref')
+	# shutil.copy(input_ref, temp_ref)
+	ref_seq_lengths = cleanup_and_evaluate_mfasta(input_ref, temp_ref)
+	sys.stderr.write('INFO: reference has {} contigs and {} total length\n'.\
+		format(len(ref_seq_lengths), sum(ref_seq_lengths)))
+	if opt.cpus < 1:
+		cpus = str(cpu_count())
+	else:
+		cpus = str(opt.cpus)
+
+	# Map input reads to reference
+	map_file = os.path.join(tmp, 'sample.sam')
+	cmd = ['bowtie2-build', '--quiet', '--threads', cpus, temp_ref, temp_ref]
+	system_call(cmd)
+	for x in ['1', '2', '3', '4', 'rev.1', 'rev.2']:
+		verify_file_exists_and_nonempty(temp_ref + '.' + x + '.bt2')
+		# NOTE: if ref >4 Gbp the large 64 bits .bt2l extensions will fail
+	cmd = ['bowtie2'] + opt.map_options.strip('\'').strip('\"').split() + \
+		['-x', temp_ref, '-S', map_file]
+	if mode == 'paired':
+		cmd.extend(['-1', fastq_input[0], '-2', fastq_input[1]])
+	elif mode == 'single':
+		cmd.extend(['-U', fastq_input[0]])
+	system_call(cmd)
+	verify_file_exists_and_nonempty(map_file)
+
+	# Sort the mapped file by chromosome position
+	sort_file = os.path.join(tmp, 'sample.sorted.sam')
+	cmd = ['samtools', 'sort', '--threads', cpus, '--output-fmt', 'SAM',
+		'--reference', temp_ref, '-o', sort_file, map_file]
+	system_call(cmd)
+	verify_file_exists_and_nonempty(sort_file)
+	# c = ['samtools', 'index', sort_file] #NOTE: cant index SAM, only BAM
+
+	# Convert SAM to BED coordinates 0 to len(ref)
+		# HOW TO get % nucl ident per site????
+
+	# Convert mapped file to VCF
+	# cmd1 = ['bcftools', 'view', '--threads', cpus, '-O', 'v', '-o', out_vcf, sort_file]
+	# mpileup_file = os.path.join(tmp, 'sample.mpileup')
+	# cmd2 = ['samtools', 'mpileup', '-aa', '--output-BP', '--output-MQ,' '--fasta-ref', temp_ref, '-o', mpileup_file, sort_file]
+	# c1 = ['samtools', 'faidx', temp_ref]
+	# system_call(c1)
+	# verify_file_exists_and_nonempty(temp_ref + '.fai')
+	vcf_file = os.path.join(tmp, 'sample.vcf')
+	cmd = ['bcftools', 'mpileup', '--annotate', 'FORMAT/AD,INFO/AD',
+		'--skip-indels', '--max-depth', '500', '--threads', cpus,
+		'--fasta-ref', temp_ref, '-o', vcf_file,sort_file]
+	system_call(cmd)
+	verify_file_exists_and_nonempty(vcf_file)
+#cd ~/test_plot.map-to-ref/2020_ND/3001927717_BacND2019/ANI-from-BAM
+#bcftools mpileup --max-depth 500 -a "FORMAT/AD,INFO/AD" --fasta-ref ../../AmesAncestor/pXO2ISelemStretchWithcapABCDE.fasta -o vcf_file output.sam.sorted
+
+	# Convert VCF file to Pandas DataFrame, then to Numpy N-dimensional array
+	df_mapped_with_stats, alignment, depth, ani = convert_vcf_to_stats(
+		read_vcf(vcf_file))
+	shutil.rmtree(tmp)
+	# convert df to class 'numpy.ndarray'
+	arr_mapped_and_unmapped = add_unmapped_sites_to_vcf(
+		df_mapped_with_stats, ref_seq_lengths, xlsx=opt.xlsx)
+	# df_filt	= df[(df['depth'] >= opt.min_depth) &
+	# 	(df['percent_identity'] > opt.min_identity)]
+	# df_filt['Depth*Ident'] = df_filt['depth'] * df_filt['percent_identity']
+	# cnt_identity = df_filt['Depth*Ident'].sum()
+	# cnt_total_depth = df_filt['depth'].sum()
+	# ani = 100. * cnt_identity / cnt_total_depth
+	# percent_aligned = 100. * len(df_filt) / ref_length
+	alignment['fraction'] = 100. * alignment['length'] / sum(ref_seq_lengths)
+
+	# # df_filt = df_filt.round({'percent_identity': 0})  #problematic 0.5 val round
+	# cnt_identity = np.around(df_filt['percent_identity'], 0).sum()
+	# cnt_total_aln = len(df_filt)
+	# ani = 100. * cnt_identity / cnt_total_aln
+	# # df_filt = np.around(df)
+
+	# Bin the coordinates as a list
+	#### collapse df into (index_position, depth, identity)
+	depths = arr_mapped_and_unmapped[:, 0] #dtype is int64
+	per_id = arr_mapped_and_unmapped[:, 1] #dtype is int64
+
+	# Plot Coords+Depth then Coords+%Ident
+	coordinates = np.arange(1, sum(ref_seq_lengths) + 1)
+	if len(ref_seq_lengths) > 1:
+		chrom_lengths = np.add.accumulate(np.array(ref_seq_lengths))
+	else:
+		chrom_lengths = None
+	plot_scatterplot_and_histogram(coordinates, depths, per_id, 
+		chrom_lengths, ani, alignment, depth, 200, 'title', 'subtitle', outfile)
+
+if __name__ == '__main__':
+	main()
diff --git a/plot.read-lengths.py b/plot.read-lengths.py
new file mode 100755
index 0000000..733304d
--- /dev/null
+++ b/plot.read-lengths.py
@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+
+
+import csv
+import gzip
+import multiprocessing as mp
+import os
+import shutil
+import sys
+from argparse import ArgumentParser
+from glob import glob
+from multiprocessing import cpu_count
+from tempfile import mkdtemp
+from io import StringIO
+
+import numpy as np
+import seaborn as sns
+from matplotlib import pyplot as plt
+from Bio import SeqIO
+from Bio.SeqIO.QualityIO import FastqGeneralIterator
+
+def parseArgs():
+	parser = ArgumentParser(description='Creates a sequence length '
+		'distribution plot with a statistical summary', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--indir', required=True, metavar='DIR',
+		help='input path containing read files')
+	opt = parser.add_argument_group('Input Options')
+	opt.add_argument('-e', '--extension', metavar='STR', type=str, nargs='+',
+		default=['fastq', 'fastq.gz', 'fast5'],
+		help='file extension(s) to assess [fastq, fastq.gz, fast5]')
+	opt.add_argument('-p', '--prefix', type=str, metavar='STR', default='',
+		help='filename prefix required in each sequence file [*]')
+	fig = parser.add_argument_group('Figure Options')
+	fig.add_argument('-o', '--outfile', metavar='FILE', type=str,
+		default='read-lengths.pdf', help='output file [read-lengths.pdf]')
+	fig.add_argument('--subtitle', metavar='\"STR\"', type=str,
+		default=None, help='figure subtitle; surround with quotes [None]')
+	fig.add_argument('--title', metavar='\"STR\"', type=str,
+		default=None, help='figure title; surround with quotes [None]')
+	fig.add_argument('--bins', type=int, metavar='INT', default=100,
+		help='number of length groups for plotting [100]')
+	fig.add_argument('--min-length', type=int, metavar='INT', default=1,
+		help='minimum read length [1]')
+	fig.add_argument('--max-length', type=int, metavar='INT', default=9999999,
+		help='maximum read length [9999999]')
+	mis = parser.add_argument_group('Misc Options')
+	mis.add_argument('-c', '--cpus', type=require_int_nonnegative,
+		metavar='INT', default='0', help='number of CPUs [all]')
+	mis.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	mis.add_argument('-l', '--lengths-outfile', metavar='FILE', type=str,
+		default=None, help='output file listing lengths [None]')
+	return parser.parse_args()
+
+def require_int_nonnegative(x):
+	try:
+		if int(x) < 0 or '.' in str(x):
+			sys.stderr.write('ERROR: {} must be a non-negative integer\n'.\
+				format(x))
+			sys.exit(1)
+	except ValueError:
+		sys.stderr.write('ERROR: {} must be an integer\n'.format(x))
+		sys.exit(1)
+	return int(x)
+
+def require_minimum_arg_value(arg_value, arg_name, min_value):
+	if arg_value < min_value:
+		sys.stderr.write('ERROR: minimum {} must be at least {}\n'.\
+			format(arg_name, arg_value))
+		sys.exit(1)
+
+def calc_sequence_lengths(args):
+	infile, tempdir, min_length, max_length = args
+	# Auto-handle gunzip compressed input
+	if infile.endswith('.gz'):
+		tmp_outfile = os.path.join(tempdir,
+			os.path.basename(infile).rstrip('.gz'))
+		with gzip.open(infile) as ifh, open(tmp_outfile, 'w') as ofh:
+			shutil.copyfileobj(ifh, ofh)
+		infile = tmp_outfile
+	outfile = os.path.join(tempdir, os.path.basename(infile) + '.len')
+
+	# Count lengths within the sequence file
+	i = 0
+	if infile.endswith('.fastq'):
+		with open(infile) as ifh, open(outfile, 'w') as ofh:
+			for _, seq_string, _ in FastqGeneralIterator(ifh):
+				sequence_length = len(seq_string)
+				if min_length < sequence_length < max_length:
+					i += 1
+					ofh.write(str(sequence_length) + os.linesep)
+	elif infile.endswith('.fast5'):
+		import h5py
+		# http://docs.h5py.org/en/stable/quick.html
+		try:
+			fast5_file = h5py.File(infile, 'r')
+			names = []
+			fast5_file.visit(names.append)
+		except (IOError, RuntimeError) as e:
+			sys.stderr.write('ERROR: {} appears corrupt\n{}\n'.\
+				format(infile, e))
+			sys.exit(1)
+		keys = {
+			'2D template':
+			'Analyses/Basecall_1D_%03d/BaseCalled_template/Fastq',
+			'2D complement':
+			'Analyses/Basecall_2D_%03d/BaseCalled_complement/Fastq',
+			'2D twodirections':
+			'Analyses/Basecall_2D_%03d/BaseCalled_2D/Fastq',
+			'1D template':
+			'Analyses/Basecall_1D_000/BaseCalled_template/Fastq',
+			'1D complement':
+			'Analyses/Basecall_1D_%03d/BaseCalled_complement/Fastq'
+		}
+		with open(outfile, 'w') as ofh:
+			# single read per Fast5
+			for k, v in keys.iteritems():
+				try:
+					_ = fast5_file[v][()]
+					# now that first read extraction works, do all of them
+					for name in names:
+						fastq = fast5_file[v][()]
+						record = SeqIO.read(StringIO(fastq), 'fastq')
+						sequence_length = len(rec.seq)
+						if min_length < sequence_length < max_length:
+							i += 1
+							ofh.write(str(sequence_length) + os.linesep)
+					sys.stderr.write('INFO: detected {} format for {}\n'.\
+						format(k, infile))
+					break
+				except KeyError:
+					pass
+			# multi-Fast5 format has a different layout
+			if i == 0:
+				names = [str(s) for s in fast5_file.keys()]
+				for k, v in keys.iteritems():
+					try:
+						_ = fast5_file[names[0]][v]
+						# now that first read extraction works, do all of them
+						# NOTE: find out how to get an iter instead of lookups
+						for name in names:
+							record = fast5_file[name][v].value
+							record_chunks = record.rstrip('\n').split('\n')
+							if len(record_chunks) == 4:
+								seq_id, seq, sep, qual = record_chunks
+								sequence_length = len(seq)
+								if min_length < sequence_length < max_length:
+									i += 1
+									ofh.write(str(sequence_length) +
+										os.linesep)
+							else:
+								sys.stderr.write('ERROR: unable to parse'
+									' FastQ from {} in {}\n'.\
+									format(name, infile))
+						sys.stderr.write('INFO: detected {} format for {}\n'.\
+							format(k, infile))
+						break
+					except KeyError:
+						pass
+		fast5_file.close()
+	elif infile.endswith('.fasta') or infile.endswith('.fa'):
+		with open(infile) as ifh, open(outfile, 'w') as ofh:
+			for rec in SeqIO.parse(ifh, 'fasta'):
+				sequence_length = len(rec.seq)
+				if min_length < sequence_length < max_length:
+					i += 1
+					ofh.write(str(sequence_length) + os.linesep)
+	if i < 1:
+		sys.stderr.write('INFO: no sequences between {} and {:,.0f}'
+			' found in {}\n'.format(min_length, max_length, infile))
+
+def merge_count_files(count_files, merged_file):
+	sequence_lengths = []
+	for file in count_files:
+		with open(file) as ifh:
+			counts = ifh.read().splitlines()
+		if len(counts) > 0:
+			sequence_lengths.extend(counts)
+		else:
+			sys.stderr.write('INFO: no sequence lengths found in {}\n'.\
+				format(file))
+
+	sequence_lengths.sort(key=int, reverse=True)
+	with open(merged_file, 'w') as ofh:
+		for val in sequence_lengths:
+			ofh.write(val + os.linesep)
+
+	return sequence_lengths
+
+def calculate_stats(merged_lengths):
+	stats = {}
+	stats['q1'] = int(np.percentile(merged_lengths, 25,
+		interpolation='midpoint'))
+	stats['median'] = int(np.median(merged_lengths))
+	stats['q3'] = int(np.percentile(merged_lengths, 75,
+		interpolation='midpoint'))
+	stats['mean'] = int(np.mean(merged_lengths))
+	stats['stdev'] = int(np.std(merged_lengths))
+	stats['gt3kbp'] = int(np.sum(merged_lengths > 3000))
+	stats['gt10kbp'] = int(np.sum(merged_lengths > 10000))
+	stats['gt20kbp'] = int(np.sum(merged_lengths > 20000))
+	stats['total_count'] = len(merged_lengths)
+	stats['total_length'] = int(np.sum(merged_lengths))
+	stats['largest'] = int(np.amax(merged_lengths))
+	total_length = stats['total_length']
+	limit = .5 * stats['total_length']
+	for length in merged_lengths:
+		total_length -= length
+		if total_length <= limit:
+			stats['n50'] = length
+			break
+	else:
+		stats['n50'] = 0
+	return stats
+
+def plot_histogram(lengths, num_bins, stats, outfile, title, subtitle):
+	sns.set_style('whitegrid')
+	fig, ax = plt.subplots()
+	ax.hist(lengths, bins=num_bins)
+
+	# Place stats in upper right of axes coords
+	textblock = '\n'.join((
+		'Total Length = {:,.0f} bp'.format(stats['total_length']),
+		'N50 = {:,.0f} bp'.format(stats['n50']),
+		r'$\mu = {:,.0f}$ bp'.format(stats['mean']),
+		r'$\sigma = {:,.0f}$ bp'.format(stats['stdev']),
+		'Q1 = {:,.0f} bp'.format(stats['q1']),
+		r'median = {:,.0f} bp'.format(stats['median']),
+		'Q3 = {:,.0f} bp'.format(stats['q3']),
+		'largest = {:,.0f} bp'.format(stats['largest']),
+		'',
+		'Total Reads = {:,.0f}'.format(stats['total_count']),
+		'>3 kbp = {:,.0f} ({:.0f}%)'.format(stats['gt3kbp'],
+			100. * stats['gt3kbp'] / stats['total_count']),
+		'>10 kbp = {:,.0f} ({:.0f}%)'.format(stats['gt10kbp'],
+			100. * stats['gt10kbp'] / stats['total_count']),
+		'>20 kbp = {:,.0f} ({:.0f}%)'.format(stats['gt20kbp'],
+			100. * stats['gt20kbp'] / stats['total_count'])
+		))
+	legend = dict(boxstyle='round', facecolor='grey', alpha=0.5)
+	ax.text(0.6, 0.98, textblock, transform=ax.transAxes, fontsize=8,
+		fontdict={'family':'monospace'}, verticalalignment='top', bbox=legend,
+		multialignment='right')
+
+	# Add labels
+	plt.xlabel('Read Length [bp]', axes=ax)
+	plt.ylabel('Quantity [#]', axes=ax)
+	if title is not None:
+		fig.suptitle(title, fontsize=10)
+	if subtitle is not None:
+		ax.set_title(subtitle, fontsize=8)
+
+	# Save the plot
+	plt.savefig(outfile, pad_inches=0.5, dpi=300)
+
+def main():
+	opt = parseArgs()
+	min_length, max_length = opt.min_length, opt.max_length
+	require_minimum_arg_value(min_length, 'length', 1)
+	if min_length > max_length:
+		sys.stderr.write('ERROR: --min-length cannot exceed --max-length\n')
+		sys.exit(1)
+	bins = opt.bins
+	require_minimum_arg_value(bins, 'bins', 2)
+	indir = os.path.realpath(os.path.expanduser(opt.indir))
+	outfile = os.path.realpath(os.path.expanduser(opt.outfile))
+	extensions, prefix = opt.extension, opt.prefix
+	if opt.cpus < 1:
+		cpus = cpu_count()
+	else:
+		cpus = opt.cpus
+
+	# Locate sequence files
+	sequence_files = []
+	for ext in extensions:
+		sequence_files.extend(glob(os.path.join(indir, '{}*.{}'.\
+			format(prefix, ext))))
+	if len(sequence_files) < 1:
+		sys.stderr.write('ERROR: no sequence files found\n')
+		sys.exit(1)
+	else:
+		sys.stderr.write('INFO: found {} sequence files...\n'.\
+			format(len(sequence_files)))
+
+	# Calculate lengths of each sequence within all sequence files
+	tmp = mkdtemp()
+	pool = mp.Pool(processes=cpus)
+	args = [(file, tmp, min_length, max_length) for file in sequence_files]
+	pool.map_async(calc_sequence_lengths, args).get(timeout=99999)
+
+	# Summarize all length files
+	length_files = glob(os.path.join(tmp, '*.len'))
+	if len(length_files) < 1:
+		sys.stderr.write('ERROR: no read length count files found\n')
+		shutil.rmtree(tmp)
+		sys.exit(1)
+	merged_file = os.path.join(tmp, 'merged_file.txt')
+	merged_lengths = merge_count_files(length_files, merged_file)
+	if len(merged_lengths) < 3:
+		sys.stderr.write('INFO: not enough sequence lengths to plot'
+			' and calculate length statistics\n')
+		shutil.rmtree(tmp)
+		sys.exit(0)
+	merged_lengths = np.array(merged_lengths, dtype=int)
+	stats = calculate_stats(merged_lengths)
+	plot_histogram(merged_lengths, bins, stats, outfile, opt.title,
+		opt.subtitle)
+
+	# Cleanup
+	if opt.lengths_outfile is not None:
+		shutil.copy(merged_file,
+			os.path.realpath(os.path.expanduser(opt.lengths_outfile)))
+	shutil.rmtree(tmp)
+
+if __name__ == '__main__':
+	main()
diff --git a/prune.SPAdes.assembly.dirs.bash b/prune.SPAdes.assembly.dirs.bash
new file mode 100755
index 0000000..3bc0ebf
--- /dev/null
+++ b/prune.SPAdes.assembly.dirs.bash
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+
+if [[ "$1" == "" || "$1" == "--help" || "$1" == "-h" ]]; then
+  echo "
+  Usage: `basename $0` input_dir
+
+  Given a path containing SPAdes assemblies, recursively
+  searches within the input dir to remove most dirs and files
+  SPAdes creates but maintains essential contigs, graph, and
+  log files."
+  exit 1
+fi
+
+mapfile -t asm_dirs < <(find -L "$1" -type d \
+ -regextype posix-extended -regex '\/.*\/K[1-9][0-9]{1,2}' -print |\
+ xargs dirname | uniq)
+
+for directory in "${asm_dirs[@]}"; do 
+  rm -f "$directory"/{assembly_graph.fastg,before_rr.fasta}
+  rm -f "$directory"/{contigs.paths,dataset.info,input_dataset.yaml}
+  rm -f "$directory"/scaffolds.{fasta,paths}
+  pigz -9f "$directory"/{params.txt,spades.log}
+done
+
+find -L "$1" -type d -regextype posix-extended \
+ -regex '\/.*\/(K[1-9][0-9]{1,2}|misc|tmp)' -print | xargs rm -rv
diff --git a/rotate.contigs.py b/rotate.contigs.py
new file mode 100755
index 0000000..13e031a
--- /dev/null
+++ b/rotate.contigs.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+
+
+import argparse
+import gzip
+import os
+import sys
+
+from Bio import SeqIO
+from Bio.Seq import Seq, Alphabet
+
+def parseArgs():
+	parser = argparse.ArgumentParser(description='rotates contigs (or '
+		'scaffolds) individually', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', metavar='FILE', required=True,
+		help='input FastA file, optionally gunzip compressed')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='output rotated FastA file [stdout]')
+	opt.add_argument('-r', '--rotate', type=int, default=50000, metavar='INT',
+		help='rotation size (in bp); negative values turn counterclockwise '
+		'from 3\' to 5\' [50,000]')
+	opt.add_argument('--force', default=False, action='store_true',
+		help='force rotations for all sequence records')
+	opt.add_argument('--skip-failures', default=False, action='store_true',
+		help='skip records that are not longer than the rotation size; '
+		'output all records that can be rotated')
+	return parser.parse_args()
+
+def main():
+	args = parseArgs()
+	infile = os.path.abspath(os.path.expanduser(args.infile))
+	if infile.endswith('.gz'):
+		infile = gzip.open(infile)
+	rotation_size = args.rotate
+
+	# Identify rotation direction and make sure it's not zero bp
+	if rotation_size > 0:
+		sys.stderr.write('INFO: rotating each sequence record {} bp '
+			'clockwise...\n\n'.format(rotation_size))
+	elif rotation_size < 0:
+		sys.stderr.write('INFO: rotating each sequence record {} bp '
+			'counterclockwise...\n\n'.format(abs(rotation_size)))
+	else:
+		sys.stderr.write('ERROR: the number of base pairs to rotate each '
+			'contig must be an integer greater than or less than 0.\n')
+		sys.exit(1)
+
+	# Verify input sequences exceed rotation size
+	records_lengths = []
+	for record in SeqIO.parse(infile, 'fasta'):
+		records_lengths.append(len(record.seq))
+	if any(x <= abs(rotation_size) for x in records_lengths):
+		if args.force or args.skip_failures:
+			sys.stderr.write('INFO: at least one input record is not longer '
+				'than {} bp rotation size.\n\n'.format(abs(rotation_size)))
+		else:
+			sys.stderr.write('ERROR: at least one input record is not longer '
+				'than {} bp. To forcibly rotate anyways, re-run with --force '
+				'or specify a smaller rotation size.\n\n'.format(
+					abs(rotation_size)))
+			sys.exit(1)
+
+	# Rotate each sequence
+	rotated_records = []
+	for record in SeqIO.parse(infile, 'fasta'):
+		init_seq, seq_length = str(record.seq), len(record.seq)
+		if seq_length > abs(rotation_size):
+			rotd_seq = init_seq[rotation_size:] + init_seq[:rotation_size]
+			record.seq = Seq(rotd_seq, Alphabet.generic_dna)
+			rotated_records.append(record)
+			sys.stderr.write('INFO: {} sequence ({} bp) was rotated {} bp.\n'.\
+				format(record.id, seq_length, abs(rotation_size)))
+		else:
+			if args.force:
+				spin_size = rotation_size % len(record.seq)
+				rotated_seq = init_seq[spin_size:] + init_seq[:spin_size]
+				record.seq = Seq(rotated_seq, Alphabet.generic_dna)
+				rotated_records.append(record)
+				sys.stderr.write('INFO: {} sequence ({} bp) is not longer '
+					'than the specified {} bp rotation size. It was rotated '
+					'{} bp.\n'.format(record.id, seq_length,
+						abs(rotation_size), spin_size))
+			elif args.skip_failures:
+				continue
+			else:
+				sys.stderr.write('INFO: {} sequence ({} bp) is not longer '
+					'than the specified {} bp rotation size. To forcibly '
+					'rotate anyways, re-run with --force or specify a '
+					'smaller rotation size.\n'.format(record.id,
+						abs(rotation_size)))
+				sys.exit(1)
+
+	# Output records
+	if args.outfile is None:
+		ofh = sys.stdout
+	else:
+		ofh = os.path.abspath(os.path.expanduser(outfile))
+	SeqIO.write(rotated_records, ofh, 'fasta')
+
+if __name__ == '__main__':
+	main()
diff --git a/slice.fasta.py b/slice.fasta.py
new file mode 100755
index 0000000..c114df4
--- /dev/null
+++ b/slice.fasta.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Slices out a single sequence from a '
+	'FastA file', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		type=str, help='input FastA sequence file')
+	req.add_argument('-d', '--defline', required=True, metavar='STR',
+		type=str, help='header/defline name for target sequence record to '
+		'slice out sequences from')
+	req.add_argument('-b', '--begin', required=True, metavar='INT', type=int,
+		help='initial position to extract from the specified sequence record')
+	req.add_argument('-e', '--end', required=True, metavar='INT', type=int,
+		help='final position to extract from the specified sequence record')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-m', '--defline-query-method', required=False,
+		type=str, default='substr', choices=['full', 'substr'],
+		help='search method for header/defline name [substr]')
+	opt.add_argument('-o', '--outfile', required=False, metavar='FILE',
+		default=None, help='FastA-formatted sliced output [stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(opt.infile)
+	get = (opt.defline, opt.begin-1, opt.end)
+
+	# Find seq record
+	mfa = SeqIO.parse(ifh, 'fasta')
+	fnd = []
+	if opt.defline_query_method == 'full':
+		for rec in mfa:
+			if str(get[0]) == rec.description:
+				fnd.append(rec)
+	elif opt.defline_query_method == 'substr':		
+		for rec in mfa:
+			if str(get[0]) in rec.description:
+				fnd.append(rec)
+	else:
+		sys.stderr.write('ERROR: unsupported {} search method; argparse '
+			'should have prevented this\n'.format(opt.defline_query_method))
+		sys.exit(1)
+
+	# Halt if anything but one seq record match found
+	if len(fnd) > 1:
+		sys.stderr.write('ERROR: >1 defline match to {}\n'.format(get[0]))
+		sys.exit(1)
+	elif len(fnd) == 0:
+		sys.stderr.write('ERROR: {} absent from deflines\n'.format(get[0]))
+		sys.exit(1)
+
+	# Slice seq record
+	out = fnd[0][get[1]:get[2]]
+
+	# Output
+	if opt.outfile is not None:
+		ofh = os.path.abspath(os.path.expanduser(opt.outfile))
+		SeqIO.write(out, ofh, 'fasta')
+	else:
+		SeqIO.write(out, sys.stdout, 'fasta')
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/slice.genbank.py b/slice.genbank.py
new file mode 100644
index 0000000..d9bc019
--- /dev/null
+++ b/slice.genbank.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+
+
+import gzip
+import os
+import re
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(
+		description='extract record(s) from a GenBank file that contain one '
+		'or more query and output in FastA format', add_help=False,
+		epilog='NOTE: GenBank Feature Table Definition is described at '
+		'http://www.insdc.org/files/feature_table.html')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input GenBank file, optionally gunzip compressed')
+	req.add_argument('-q', '--query', required=True, metavar='STR',
+		help='string to search each locus (record) name')
+	req.add_argument('-r', '--range', required=True, metavar='INT:INT|INT-INT',
+		help='range to extract within the locus')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', default=None, metavar='FILE',
+		help='FastA output [default: stdout]')
+	opt.add_argument('--search-type', default='contains',
+		choices=['contains', 'full_exact'],
+		help='type of query match [default: contains]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	infile = os.path.abspath(os.path.expanduser(opt.infile))
+	if infile.endswith('.gz'):
+		infile = gzip.open(infile)
+	qry = opt.query
+	positions = opt.range
+
+	# Quick checks of positions
+	inv_pattern = re.compile('[^0-9:-]')
+	if any([inv_pattern.search(x) for x in positions]):
+		sys.stderr.write('ERROR: sites must only contain [0-9:-]\n')
+		sys.exit(1)
+	if positions.startswith('0'):
+		sys.stderr.write('ERROR: 0 position prefix found; site extraction is'
+			' 1-based\n')
+		sys.exit(1)
+	if ':' in positions:
+		start, stop = [int(x) for x in positions.split(':')]
+	elif '-' in positions:
+		start, stop = [int(x) for x in positions.split('-')]
+	if start >= stop:
+		sys.stderr.write('ERROR: {} range must have second value'
+			' exceed first.\n'.format(positions))
+		sys.exit(1)
+
+	# Find the contig (locus or record) of interest
+	query_match = []
+	for rec in SeqIO.parse(infile, 'genbank'):
+		if opt.search_type == 'contains':
+			if qry in rec.name:
+				query_match.append(rec)
+		elif opt.search_type == 'full_exact':
+			if qry == rec.name:
+				query_match.append(rec)
+	if len(query_match) == 0:
+		sys.stderr.write('ERROR: {} absent in {}\n'.format(qry, infile))
+		sys.exit(1)
+	elif len(query_match) > 1:
+		sys.stderr.write('ERROR: found >1 {} in {}\n'.format(qry, infile))
+		sys.exit(1)
+
+	# Slice GenBank record
+	rec = query_match[0]
+	if any(v > len(rec.seq) for v in (start, stop)):
+		sys.stderr.write('ERROR: {} range larger than {} record'
+			' ({} sites).\n'.format(positions, rec.name, len(rec.seq)))
+		sys.exit(1)
+	sliced_rec = rec[start-1:stop]
+
+	# Warn about partial feature(s)
+	feats = [feat for feat in rec.features if feat.type == 'CDS']
+	desired = set(range(start-1, stop))
+	for f in feats:
+		span = set(range(f.location.start.position, f.location.end.position))
+		intersection = span & desired
+		min_intersection = min(intersection)
+		if len(intersection) < len(desired):
+			# NOTE: more complex comparison needed to handle multi-gene range  
+			sys.stderr.write('INFO: partial incomplete sequence match to\n\n')
+			sys.stderr.write('{}\n\n'.format(f))
+
+	# Output genbank format
+	if opt.outfile:
+		outfile = os.path.abspath(os.path.expanduser(opt.outfile))
+		SeqIO.write(sliced_rec, outfile, 'genbank')
+	else:
+		SeqIO.write(sliced_rec, sys.stdout, 'genbank')
+
+if __name__ == '__main__':
+	main()
diff --git a/slice.mfasta.py b/slice.mfasta.py
new file mode 100644
index 0000000..99fb1ee
--- /dev/null
+++ b/slice.mfasta.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(description='Extracts sequence site(s) from a'
+	' multi-record FastA file', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		type=str, help='input FastA sequence file')
+	req.add_argument('-s', '--sites', nargs='+', metavar='INT|INT:INT',
+		help='position(s) to extract from each sequence record;'
+		' colon or hyphen separate for ranges')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', required=False, metavar='FILE',
+		default=None, help='FastA-formatted output [stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.realpath(os.path.expanduser(opt.infile))
+	sites = []
+	for site in opt.sites:
+		if ':' in site:
+			sites.append(':'.join([int(n) + 1 for n in site.split(':')]))
+		elif '-' in site:
+			sites.append(':'.join([int(n) + 1 for n in site.split(':')]))
+		else:
+			sites.append(int(site) + 1)
+
+	# Find sites in each seq record
+	out = []
+	for rec in SeqIO.parse(ifh, 'fasta'):
+		seq = ''
+		for site in sites:
+			seq += str(rec[site].seq)
+
+	# Output
+	if opt.outfile is not None:
+		ofh = os.path.abspath(os.path.expanduser(opt.outfile))
+		SeqIO.write(out, ofh, 'fasta')
+	else:
+		SeqIO.write(out, sys.stdout, 'fasta')
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/slice.record.from.fasta.py b/slice.record.from.fasta.py
new file mode 100755
index 0000000..ece31a3
--- /dev/null
+++ b/slice.record.from.fasta.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+
+def parseArgs():
+	parser = ArgumentParser(add_help=False,
+		description='Finds FastA file sequence record(s) that contain a given '
+		'string and extracts the specified range of sites.',
+		epilog='NOTE: BLAST outputs 1-based closed intervals for positions, '
+		'and the begin and end options here will fetch the same.')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', metavar='FILE',
+		required=True, help='input FastA file')
+	req.add_argument('-b', '--begin', metavar='INT', type=int,
+		required=True, help='start site to extract')
+	req.add_argument('-c', '--contains', metavar='STR', type=str,
+		required=True, help='defline contains')
+	req.add_argument('-e', '--end', metavar='INT', type=int,
+		required=True, help='stop site to extract')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-a', '--all', action='store_false', default=True,
+		help='enable all sequence records to be parsed if the -c STR occurs '
+		'in >1 defline; default quits after the first record is parsed [off]')
+	opt.add_argument('-o', '--outfile', metavar='FILE', default=None,
+		help='output FastA file [stdout]')
+	opt.add_argument('-p', '--prefix', metavar='STR', type=str, default='',
+		help='prefix to add to output defline(s) before the input defline and '
+		'extracted sites [None]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	fas = os.path.abspath(os.path.expanduser(opt.infile))
+	if opt.begin < 1 or opt.end < 1:
+		sys.stderr.write('\tERROR: begin and end positions are 1-based\n')
+		sys.exit(1)
+
+	o = []
+	with open(fas) as ifh:
+		for rec in SeqIO.parse(ifh, 'fasta'):
+			if opt.contains in rec.id:
+				if opt.begin < opt.end:
+					o.append('>{}{} {}:{}'.format(
+						opt.prefix, rec.id,opt.begin, opt.end))
+					o.append(rec.seq[opt.begin-1:opt.end])
+				elif opt.begin > opt.end:
+					o.append('>{}{} {}:{}(rc)'.format(
+						opt.prefix, rec.id, opt.end, opt.begin))
+					o.append(rec.seq[opt.end-1:opt.begin].reverse_complement())
+				elif opt.begin == opt.end:
+					o.append('>{}{} {}:{}'.format(
+						opt.prefix, rec.id, opt.begin, opt.end))
+					o.append(rec.seq[opt.begin-1])
+				if opt.all:
+					break
+
+	if len(o) == 0:
+		sys.stderr.write('\t{} absent in deflines\n'.format(opt.contains))
+	if opt.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opt.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	for ln in o:
+		ofh.write('{}\n'.format(''.join(ln)))
+
+if __name__ == '__main__':
+	main()
diff --git a/split.multifasta.non-ambiguous-segments.py b/split.multifasta.non-ambiguous-segments.py
new file mode 100755
index 0000000..2a8cc13
--- /dev/null
+++ b/split.multifasta.non-ambiguous-segments.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+
+
+import os
+import sys
+from argparse import ArgumentParser
+
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def parseArgs():
+    parser = ArgumentParser(add_help=False,
+        description='splits multi-FastA file into individual FastA files of'
+        ' non-ambiguous segments of specified minimum length',
+        epilog='useful to get individual FastA files for each segment aligned'
+        ' to a reference and have a `samtools consensus` file to split up')
+    req = parser.add_argument_group('Required')
+    req.add_argument('-i', '--infile', required=True, metavar='FILE',
+        help='input multi-FastA file')
+    opt = parser.add_argument_group('Optional')
+    opt.add_argument('-e', '--ext', metavar='STR', type=str, default='.fasta',
+        help='extension name for each output FastA file [\'.fasta\']')
+    opt.add_argument('-h', '--help', action='help',
+        help='show this help message and exit')
+    opt.add_argument('-m', '--min-length', metavar='INT', type=int, default=31,
+        help='minimum length of non-ambiguous sequences to output [31]')
+    opt.add_argument('-o', '--outdir', metavar='PATH',
+        help='output directory path [dir of outfiles]')
+    return parser.parse_args()
+
+def save_segment_fasta(non_ambiguous_segment, min_length, rec_id, coordinate_start, coordinate_stop, ext, infile, outdir):
+    basename_input_filename = os.path.basename(infile)
+    if len(non_ambiguous_segment) >= min_length:
+        out_rec = SeqRecord(
+            Seq(non_ambiguous_segment), 
+            id=rec_id + ':' + str(coordinate_start) + '-' + str(coordinate_stop),
+            description=basename_input_filename
+            )
+        SeqIO.write(
+            out_rec, os.path.join(
+                outdir,
+                rec_id  + ':' + str(coordinate_start) + '-' + str(coordinate_stop) + ext
+                ),
+           'fasta'
+           )
+
+def main():
+    opt = parseArgs()
+
+    # I/O handling
+    infile = os.path.abspath(os.path.expanduser(opt.infile))
+    if opt.outdir is None:
+        outdir = os.path.dirname(infile)
+    else:
+        outdir = os.path.abspath(os.path.expanduser(opt.outdir))
+    if not os.path.exists(outdir):
+        os.makedirs(outdir)
+
+    # Define non-ambiguous characters we want
+    non_ambiguous_nucleotides = ['A', 'T', 'C', 'G']
+
+    # Iterate over each individual sequence record
+    for rec in SeqIO.parse(infile, 'fasta'):
+
+        # Individual sequence handling
+        coordinate_start, coordinate_stop = 1, 1
+        non_ambiguous_segment = ''
+        record_sequence  = str(rec.seq).upper()
+
+        # Iterate over each site or position within a record or contig
+        for site in record_sequence:
+            len_record_sequence = len(record_sequence)
+            print(site, 'rec len:', str(len_record_sequence), str(coordinate_start), str(coordinate_stop))
+
+            if site in non_ambiguous_nucleotides:
+                print('site passed', str(coordinate_start), str(coordinate_stop))
+
+                # When the last site is non-ambiguous and exceeds length to store, save it
+                if coordinate_stop == len_record_sequence:
+                    print('final segment saved', str(coordinate_start), str(coordinate_stop))
+                    save_segment_fasta(
+                        non_ambiguous_segment,
+                        opt.min_length,
+                        rec.id,
+                        coordinate_start,
+                        coordinate_stop,
+                        opt.ext,
+                        opt.infile,
+                        outdir
+                        )
+                non_ambiguous_segment += site
+                coordinate_stop += 1
+
+            # Handles the next site when non-ambiguous
+            else:
+
+                # Only when the previous several non-ambiguous sites meet or exceed length, save it
+                print('segment saved', str(coordinate_start), str(coordinate_stop))
+                save_segment_fasta(
+                    non_ambiguous_segment,
+                    opt.min_length,
+                    rec.id,
+                    coordinate_start,
+                    coordinate_stop,
+                    opt.ext,
+                    opt.infile,
+                    outdir
+                    )
+
+                # Regardless of storing the segment or not, move onto the next site
+                non_ambiguous_segment = ''
+                coordinate_stop += 1
+                coordinate_start = coordinate_stop
+
+if __name__ == '__main__':
+    main()
diff --git a/split.multifasta.py b/split.multifasta.py
new file mode 100755
index 0000000..328b881
--- /dev/null
+++ b/split.multifasta.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def parseArgs():
+    parser = ArgumentParser(add_help=False,
+        description='splits multi-FastA file into individual FastA files',
+        epilog='NOTE: for each split file, the output defline will be the '
+        'filename excluding the extension')
+    req = parser.add_argument_group('Required')
+    req.add_argument('-i', '--infile', required=True, metavar='FILE',
+        help='input multi-FastA file')
+    opt = parser.add_argument_group('Optional')
+    opt.add_argument('-e', '--ext', metavar='STR', type=str, default='.fasta',
+        help='extension name for each output file [\'.fasta\']')
+    opt.add_argument('-g', '--nogaps', action='store_true', default=False,
+        help='toggle on removal of \'-\' gaps [off]')
+    opt.add_argument('-h', '--help', action='help',
+        help='show this help message and exit')
+    opt.add_argument('-o', '--outdir', metavar='PATH',
+        help='output directory path [dir of input file]')
+    opt.add_argument('-p', '--prefix', metavar='STR', type=str, default=None,
+        help='prefix name for each output file [defline from input file; '
+        'first string on whitespace]')
+    opt.add_argument('-s', '--suffix', metavar='STR', type=str, default=None,
+        help='suffix name for each output file [\'_<int++>\']')
+    return parser.parse_args()
+
+def main():
+    opt = parseArgs()
+
+    # I/O handling
+    infile = os.path.abspath(os.path.expanduser(opt.infile))
+    if opt.outdir is None:
+        outdir = os.path.dirname(infile)
+    else:
+        outdir = os.path.abspath(os.path.expanduser(opt.outdir))
+    if not os.path.exists(outdir):
+        os.makedirs(outdir)
+    mfasta = SeqIO.parse(infile, 'fasta')
+
+    i = 1
+    for rec in mfasta:
+        # Sequence handling
+        seq  = str(rec.seq).upper()
+        if opt.nogaps:
+            seq = seq.replace('-', '')
+
+        # Defline and filename handling
+        if opt.prefix is not None:
+            pref = opt.prefix
+        else:
+            pref = (rec.id).split()[0]
+        if opt.suffix is not None:
+            suff = opt.suffix
+        else:
+            suff = '_{}'.format(i)
+            i += 1
+
+        # Output each record as separate file
+        new_rec = SeqRecord(Seq(seq), id=pref + suff,
+            description='')
+        SeqIO.write(new_rec, os.path.join(outdir, pref + suff + opt.ext),
+            'fasta')
+
+if __name__ == '__main__':
+    main()
diff --git a/stats.multifasta.py b/stats.multifasta.py
new file mode 100755
index 0000000..45cc60b
--- /dev/null
+++ b/stats.multifasta.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+
+
+import os
+import sys
+from argparse import ArgumentParser
+from Bio import SeqIO
+from Bio.SeqUtils import GC
+
+def parseArgs():
+	parser = ArgumentParser(add_help=False,
+		description='reports statistics of multi-FastA file per sequence '
+		'record in tab-delimited format: Name, Length, %GC, %CT, # Gaps, # Ns')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input multi-FastA file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-f', '--filename', action='store_true', default=False,
+		help='add input filename in front of first data column [off]')
+	opt.add_argument('-g', '--nogaps', action='store_true', default=False,
+		help='prior to statistics calculations, remove \'-\' gaps [off]')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-n', '--noambiguous', action='store_true', default=False,
+		help='prior to statistics calculations, remove N,n [off]')
+	opt.add_argument('-o', '--outfile', metavar='FILE',
+		help='tab-delimited output file [stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+
+	# I/O handling
+	infile = os.path.abspath(os.path.expanduser(opt.infile))
+	mfasta = SeqIO.parse(infile, 'fasta')
+
+	o = []
+	for rec in mfasta:
+		# Sequence and defline handling
+		seq  = str(rec.seq).upper()
+		if opt.nogaps:
+			seq = seq.replace('-', '')
+		if opt.noambiguous:
+			seq = seq.replace('N', '')
+		defln = rec.description
+		if opt.filename:
+			defln = '{}\t{}'.format(infile, defln)
+
+		# Statistics
+		seqlen = len(seq)
+		ct = 100.0 * (seq.count('C') + seq.count('G')) / seqlen
+		gc = GC(seq)
+		gaps = seq.count('-')
+		ambig = seq.count('N')
+		o.append('{}\t{}\t{:.4f}\t{:.4f}\t{}\t{}'.format(
+			defln, seqlen, gc, ct, gaps, ambig))
+
+	# Write single output file
+	if opt.outfile is not None:
+		ofh = open(os.path.abspath(os.path.expanduser(opt.outfile)), 'w')
+	else:
+		ofh = sys.stdout
+	for ln in o:
+		ofh.write('{}\n'.format(''.join(ln)))
+
+if __name__ == '__main__':
+	main()
diff --git a/summarize.Pilon.assembly.corrections.2.py b/summarize.Pilon.assembly.corrections.2.py
new file mode 100755
index 0000000..ada1cc5
--- /dev/null
+++ b/summarize.Pilon.assembly.corrections.2.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+
+
+import sys
+from Bio import SeqIO
+
+
+def usage():
+	sys.exit('Quantifies assembly errors that are corrected with Illumina '
+		'reads by Pilon. DOI: 10.1371/journal.pone.0112963.\n\n'
+		'Usage: {} <pilon>.changes <pilon.fasta>.gbk 1>indel.tab 2>sub.tab\n'
+		'where the GenBank file has identical LOCUS ID tags as the '
+		'FastA given to Pilon. Note: `sed -i \'s/_pilon//g\' <pilon.fasta>` '
+		'is likely required prior to Prokka annotation.'.format(sys.argv[0]))
+
+if len(sys.argv) != 3:
+	usage()
+elif any(h == sys.argv[1] for h in ['-h', '-help', '--help']):
+	usage()
+
+idx = {}
+for rec in SeqIO.parse(open(sys.argv[2]), 'genbank'):
+	contig_idx = set()
+	for (i, feat) in enumerate(rec.features):
+		if feat.type == 'CDS':
+			loc = str(feat.location)
+			if loc.endswith('(-)') or loc.endswith('(+)'):
+				b,e = loc.lstrip('[').rstrip('](-)').rstrip('](+)').split(':')
+				contig_idx.update(range(int(b), int(e) + 1))
+			else:
+				sys.exit('ERROR')
+	idx[rec.id] = contig_idx
+
+with open(sys.argv[1]) as ifh:
+	# So many empties!
+	k = ['ins_CDS', 'ins_noCDS', 'ins2_CDS', 'ins2_noCDS',
+	'del_CDS', 'del_noCDS', 'del2_CDS', 'del2_noCDS']
+	d = dict.fromkeys(k, '')
+	nucs = ['A', 'T', 'C', 'G']
+	e = {'CDS': dict((n, dict((n, 0) for n in nucs)) for n in nucs),
+	'noCDS': dict((n, dict((n, 0) for n in nucs)) for n in nucs)}
+	for ln in ifh:
+		# Verify FastA headers given to Pilon corresponds to GenBank provided
+		chrom = str(ln.split()[0].split(':')[0])
+		pos   = int(ln.split()[0].split(':')[1].split('-')[0])
+		if chrom not in idx:
+			sys.exit('ERROR: {} not in GenBank entry as a LOCUS identifier.'
+				' The FastA deflines given to Pilon must match with GenBank'
+				' LOCUS ID entries.'.format(chrom))
+
+		# Count and classify each error type
+		l = ln.split()[2:4]
+		if '.' == l[0]:  # insertion
+			if len(l[1]) == 1:
+				if pos in idx[chrom]:
+					d['ins_CDS'] += l[1]
+				else:
+					d['ins_noCDS'] += l[1]
+			else:
+				if pos in idx[chrom]:
+					d['ins2_CDS'] += l[1]
+				else:
+					d['ins2_noCDS'] += l[1]
+		elif '.' == l[1]:  # deletion
+			if len(l[0]) == 1:
+				if pos in idx[chrom]:
+					d['del_CDS'] += l[0]
+				else:
+					d['del_noCDS'] += l[0]
+			else:
+				if pos in idx[chrom]:
+					d['del2_CDS'] += l[0]
+				else:
+					d['del2_noCDS'] += l[0]
+		else:  # substitution
+			if pos in idx[chrom]:
+				cds = 'CDS'
+			else:
+				cds = 'noCDS'
+			x = ''  #e.g., 'TG' is T->G
+			for y in (l[0], l[1]):
+				for z in nucs:
+					if y == z:
+						x += z
+			e[cds][x[0]][x[1]] += 1
+
+# Report nucleotide frequency data for indels to stdout
+head_indel = ('.\tCDS\tCDS\tCDS\tCDS\tnon-CDS\tnon-CDS\tnon-CDS\tnon-CDS\n'
+'Nucleotide\tInsertion (1 bp)\tDeletion (1 bp)\t'
+'Insertion (> 1 bp)\tDeletion (>1 bp)\tInsertion (1 bp)\t'
+'Deletion (1 bp)\tInsertion (> 1 bp)\tDeletion (>1 bp)\n')
+data_indel = ''
+for j in ['A', 'T', 'C', 'G']:
+	data_indel += j
+	for k in ('CDS', 'noCDS'):
+		for l in ('_', '2_'):
+			for m in ('ins', 'del'):
+				data_indel += '\t' + str((d[m + l + k]).count(j))
+	data_indel += '\n'
+print head_indel + data_indel
+
+# Report nucleotide frequency data for substitutions to stderr
+head_subst = ('Nucleotide (From)\tNucleotide (To)\tSubstitution in '
+'Coding Sequence\tSubstitution in Non-Coding Sequence\n')
+data_subst = ''
+for s in nucs:
+	for t in nucs:
+		if s != t:
+			c = str(e['CDS'][s][t]) + '\t' + str(e['noCDS'][s][t])
+			data_subst += s + '\t' + t + '\t' + c + '\n'
+sys.stderr.write(head_subst + data_subst)
diff --git a/summarize.Pilon.assembly.corrections.py b/summarize.Pilon.assembly.corrections.py
new file mode 100755
index 0000000..5d77b56
--- /dev/null
+++ b/summarize.Pilon.assembly.corrections.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+
+
+import sys
+from Bio import SeqIO
+
+def usage():
+	sys.exit('Quantifies assembly errors that are corrected with Illumina '
+		'reads by Pilon. DOI: 10.1371/journal.pone.0112963.\n\n'
+		'Usage: {} <pilon>.changes <pilon.fasta>.gbk\n'
+		'where the GenBank file has identical LOCUS ID tags as the '
+		'FastA given to Pilon. Note: `sed -i \'s/_pilon//g\' <pilon.fasta>` '
+		'is likely required prior to Prokka annotation.'.format(sys.argv[0]))
+
+if len(sys.argv) != 3:
+	usage()
+elif any(h == sys.argv[1] for h in ['-h', '-help', '--help']):
+	usage()
+
+idx = {}
+for rec in SeqIO.parse(open(sys.argv[2]), 'genbank'):
+	contig_idx = set()
+	for (i, feat) in enumerate(rec.features):
+		if feat.type == 'CDS':
+			loc = str(feat.location)
+			if loc.endswith('(-)') or loc.endswith('(+)'):
+				b,e = loc.lstrip('[').rstrip('](-)').rstrip('](+)').split(':')
+				contig_idx.update(range(int(b), int(e) + 1))
+			else:
+				sys.exit('ERROR')
+	idx[rec.id] = contig_idx
+
+with open(sys.argv[1]) as ifh:
+	# So many empties!
+	i, cnt_sub, cnt_sub_cds = 0, 0, 0
+	cnt_ins, cnt_ins2, cnt_del, cnt_del2 = 0, 0, 0, 0
+	cnt_ins_cds, cnt_del_cds, cnt_ins2_cds, cnt_del2_cds = 0, 0, 0, 0
+	sub_from, sub_to, ins, ins2, deL, del2 = '', '', '', '', '', ''
+	for ln in ifh:
+		# Verify FastA headers given to Pilon corresponds to GenBank provided
+		chrom = str(ln.split()[0].split(':')[0])
+		pos   = int(ln.split()[0].split(':')[1].split('-')[0])
+		if chrom not in idx:
+			sys.exit('ERROR: {} not in GenBank entry as a LOCUS identifier.'
+				' The FastA deflines given to Pilon must match with GenBank'
+				' LOCUS ID entries.'.format(chrom))
+
+		# Count and classify each error type
+		l = ln.split()[2:4]
+		if '.' == l[0]:  # insertion
+			if len(l[1]) == 1:
+				cnt_ins += 1
+				ins     += l[1]
+				if pos in idx[chrom]:
+					cnt_ins_cds += 1
+			else:
+				cnt_ins2 += 1
+				ins2     += l[1]
+				if pos in idx[chrom]:
+					cnt_ins2_cds += 1
+		elif '.' == l[1]:  # deletion
+			if len(l[0]) == 1:
+				cnt_del += 1
+				deL     += l[0]
+				if pos in idx[chrom]:
+					cnt_del_cds += 1
+			else:
+				cnt_del2 += 1
+				del2     += l[0]
+				if pos in idx[chrom]:
+					cnt_del2_cds += 1
+		else:  # substitution
+			cnt_sub  += 1
+			sub_from += l[0]
+			sub_to   += l[1]
+			if pos in idx[chrom]:
+				cnt_sub_cds += 1
+		i += 1
+
+# Report error counts
+for s, t in [('substitu', cnt_sub),
+(' 1 bp inser', cnt_ins), ('>1 bp inser', cnt_ins2),
+(' 1 bp dele', cnt_del), ('>1 bp dele', cnt_del2)]:
+	print 'Total {}tions: {}'.format(s, t)
+
+# Report errors being within or outside of coding sequences
+for s, t, u in [('sub', cnt_sub, cnt_sub_cds),
+('1 bp ins', cnt_ins, cnt_ins_cds), ('>1 bp ins', cnt_ins2, cnt_ins2_cds),
+('1 bp del', cnt_del, cnt_del_cds), ('>1 bp del', cnt_del2, cnt_del2_cds)]:
+	for m, n in [(t - u, 'non-'), (u, '')]:
+		print '   {} in {}coding sequences: {}'.format(s, n, m)
+
+# Report nucleotide frequency data
+for s, t, u in [('sub', 'from', sub_from), ('sub', 'to', sub_to),
+('1 bp', 'ins', ins), ('>1 bp', 'ins', ins2),
+('1 bp', 'del', deL), ('>1 bp', 'del', del2)]:
+	for n in ['A', 'T', 'C', 'G']:
+		print '      {} {} {}: {}'.format(s, t, n, u.count(n))
diff --git a/summarize.circlator.tigs.py b/summarize.circlator.tigs.py
new file mode 100755
index 0000000..ed9f7ad
--- /dev/null
+++ b/summarize.circlator.tigs.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+
+import os
+from argparse import ArgumentParser
+from Bio import SeqIO
+from Bio.SeqUtils import GC
+
+def parseArgs():
+	parser = ArgumentParser(description='Summarizes circlator '
+		'output according to each sequence\'s length, GC content, and '
+		'optionally its circularized status when the logfile is provided.',
+		add_help=False, epilog='Circlator DOI: 10.1186/s13059-015-0849-0')
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', metavar='FILE',
+		required=True, help='input FastA file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-l', '--circlator-log', metavar='FILE',
+		help='corresponding tab-delimited \'04.merge.circularise.log\' file '
+		'from Circlator; required for reporting circularized status')
+	opt.add_argument('-o', '--outfile', required=False, metavar='FILE',
+		default=None, help='summary output [stdout]')
+	opt.add_argument('-s', '--separate', required=False, action='store_true',
+		default=False, help='switch to copy each sequence record (contig or '
+		'unitig) into its own separate file in the cwd [OFF]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(os.path.expanduser(opt.infile))
+	log = os.path.abspath(os.path.expanduser(opt.circlator_log))
+
+	d = {}
+	if log is not None:
+		with open(log) as cl:
+			for ln in cl:
+				l = ln.rstrip('\n').split('\t')
+				d[l[1]] = l[5]
+
+	with open(ifh) as input_fasta:
+		for rec in SeqIO.parse(input_fasta, 'fasta'):
+			seq_id = str(rec.id)
+			if opt.separate:
+				# Create individual files for each seq rec (contig or unitig)
+				SeqIO.write(rec, seq_id + '.fa', 'fasta')
+
+			# Gather summary data
+			if log is not None:
+				if seq_id in d:
+					v = d[seq_id]
+					if v == '1':
+						status = 'circularized'
+					else:
+						status = 'not_circularized'
+				else:
+					status = 'unitig_not_in_logfile'
+			else:
+				status = ''
+			seq_len = str(len(rec.seq))
+			GC_content = float(GC(rec.seq))
+			data = '{}\t{}\t{:.2f}\t{}'.format(seq_id, seq_len, GC_content,
+				status)
+
+			# Output
+			if opt.outfile is not None:
+				ofh = os.path.abspath(os.path.expanduser(opt.outfile))
+				with open(ofh, 'wa') as o:
+					o.write(data + '\n')
+			else:
+				print(data)
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/summarize.phaster.json.py b/summarize.phaster.json.py
new file mode 100755
index 0000000..216d903
--- /dev/null
+++ b/summarize.phaster.json.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+
+import json
+import os
+import sys
+from argparse import ArgumentParser
+
+
+def parseArgs():
+	parser = ArgumentParser(description='Extracts summary data from a '
+		'JavaScript Object Notation (JSON) file returned by PHASTER\'s '
+		'(PHAge Search Tool Enhanced Release) application programming '
+		'interface (API)', add_help=False)
+	req = parser.add_argument_group('Required')
+	req.add_argument('-i', '--infile', required=True, metavar='FILE',
+		help='input JSON file')
+	opt = parser.add_argument_group('Optional')
+	opt.add_argument('-h', '--help', action='help',
+		help='show this help message and exit')
+	opt.add_argument('-o', '--outfile', required=False, metavar='FILE',
+		default=None, help='[stdout]')
+	return parser.parse_args()
+
+def main():
+	opt = parseArgs()
+	ifh = os.path.abspath(os.path.expanduser(opt.infile))
+
+	with open(ifh) as json_file:
+		json_data = json.load(json_file)
+		if opt.outfile is not None:
+			ofh = os.path.abspath(os.path.expanduser(opt.outfile))
+			with open(ofh, 'w') as o:
+				o.write(json_data[u'summary'])
+		else:
+			print(json_data[u'summary'])
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file