def main():
# set up CLI
description = __doc__
parser = argparse.ArgumentParser(description=description)
parser.add_argument("-i", "--infile", dest="infile",
metavar="FILE", help="Read raw table from INFILE")
parser.add_argument(
"-o",
"--outfile",
dest="outfile",
metavar="OUTFILE",
help="Write collapsed table to OUTFILE")
parser.add_argument("-d", "--delim", dest="delim", default="\t",
help="Input table delimiter", metavar="DELIM")
parser.add_argument("-D", "--delimOut", dest="delimOut", default="\t",
help="Output table delimiter", metavar="DELIM")
parser.add_argument(
'-F',
'--countFirst',
action='store_true',
default=False,
help="Don't skip the first line, it's NOT a header")
parser.add_argument(
"-R",
"--readColumn",
dest="readCol",
type=int,
default=0,
help="Index (starting at 0) of column with read name, 0 is default",
metavar="READCOL")
parser.add_argument(
"-H",
"--hitColumn",
dest="hitCol",
type=int,
default=2,
help="Index (starting at 0) of column with hit name (for counting), "
"2 is default, if less than zero, all (non-read) columns will "
"be used as multiple hits",
metavar="HITCOL")
parser.add_argument(
'-s',
'--hitSep',
default=None,
help="Use this string to split multiple values in single hit cell. "
"Default is 'None' to leave hits as is, use 'eval' to parse "
"as python repr strings")
add_weight_arguments(parser, multiple=False)
parser.add_argument("-T", "--total", default=False, action="store_true",
help="Report 'Total' in the first row")
# cutoff options
add_count_arguments(parser, {'cutoff': 0})
# log level and help
add_universal_arguments(parser)
arguments = parser.parse_args()
setup_logging(arguments)
# make sure we have something to do
if (arguments.infile is None):
logging.info("Reading table from: STDIN")
else:
logging.info("Reading table from: " + arguments.infile)
if (arguments.outfile is None):
logging.info("Writing counts to: STDOUT")
else:
logging.info("Writing counts to: " + arguments.outfile)
# process arguments
takeFirst = (arguments.allMethod == 'first')
splitHits = (arguments.hitSep is not None and arguments.hitSep != 'None')
uncluster = (arguments.weights is not None)
if arguments.hitSep == 'eval':
parser.error("Sorry, parsing with eval is not yet supported!")
# inform the curious user
logging.info("Delimiter: '" + arguments.delim)
logging.info("Read names in col: '" + str(arguments.readCol))
logging.info("Hit names in col: '" + str(arguments.hitCol))
if splitHits:
logging.info("Splitting hits with: %s" % (arguments.hitSep))
logging.warn(
"Splitting hits has not been tested yet! Let me know how it goes.")
if takeFirst:
logging.info("Taking first hit for each read.")
else:
if arguments.allMethod == 'portion':
logging.info("Dividing count among all hits for each read.")
else:
logging.info("Adding 1 to every hit for each read")
if uncluster:
logging.info(
"Getting read cluster sizes from: %s" %
(arguments.weights))
if arguments.countFirst:
logging.info("First line is data")
else:
logging.info("Skipping first line")
# Do the counting!
counts = {}
countHitsForRead = getAllMethod(arguments.allMethod)
clusteredReadCounts = {}
if uncluster:
clusteredReadCounts = parseMapFile(
arguments.clusterFile, valueType=int)
currentRead = ''
readCount = 1
hits = []
if arguments.infile is None:
infile = sys.stdin
else:
infile = open(arguments.infile)
# loop over lines
if not arguments.countFirst:
# skip first line
try:
next(infile)
except StopIteration:
raise Exception("No lines in %s" % str(infile))
for line in infile:
line = line.rstrip('\r\n')
rowcells = line.split(arguments.delim)
# get read
read = rowcells[arguments.readCol]
# if it's a new read, process previous read
if currentRead == '':
currentRead = read
elif read != currentRead and currentRead != '':
readCount += 1
logging.info("Checking hits for %s" % currentRead)
# was it part of a cluster?
multiplier = 1
if uncluster:
multiplier = clusteredReadCounts[currentRead]
# where does the count for this read go
countHitsForRead(hits, counts, multiplier=multiplier)
hits = []
currentRead = read
# get hit from this line
if arguments.hitCol >= 0:
hit = rowcells[arguments.hitCol]
if splitHits:
hits.extend(hit.split(arguments.hitSep))
else:
hits.append(hit)
else:
rowcells.pop(arguments.readCol)
hits.extend(rowcells)
# check last read!
logging.info("Checking hits for %s" % currentRead)
# was it part of a cluster?
multiplier = 1
if uncluster:
multiplier = clusteredReadCounts[currentRead]
# where does the count for this read go
countHitsForRead(hits, counts, multiplier=multiplier)
# apply cutoff
if arguments.cutoff > 0:
applyFractionalCutoff(counts, threshold=arguments.cutoff * readCount)
# print output
if arguments.outfile is None:
outhandle = sys.stdout
else:
outhandle = open(arguments.outfile, 'w')
if arguments.total:
outhandle.write("Total%s%d\n" % (arguments.delimOut, readCount))
if arguments.allMethod == 'portion':
outFmtString = "%s%s%f\n"
else:
outFmtString = "%s%s%d\n"
delimRE = re.compile(arguments.delimOut)
for hit in sorted(counts.keys()):
count = counts[hit]
hit = delimRE.sub('_', hit)
outhandle.write(outFmtString % (hit, arguments.delimOut, count))
def main():
"""" Set up the CLI """
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("input_files", nargs="+",
default=[],
metavar="INFILE",
help="List of hit tables to process")
parser.add_argument("-o", "--outfile", dest="outfile",
metavar="OUTFILE",
help="Write count table to OUTFILE")
parser.add_argument("-r", "--rank", dest="ranks", default=None,
metavar="RANK", action="append",
help=""" Rank(s) to collect counts on. Use flag
multiple
times to specify multiple ranks. If multiple values
given, one table produced for each with rank name
appended to file name. Defaults to all major ranks
between phylum and species. Corresponds to rank names
in nodes.dmp. To see list run:
'cut -f5 nodes.dmp | uniq | sort | uniq'
in ncbi tax dir. Will also accept 'organism' to mean
no rank (ie, just the organism name).""")
parser.add_argument(
"-s",
"--collapseToDomain",
default=False,
action="store_true",
help="Collapse all taxa below given rank down to "
"superkingdom/domain. EG: in the genus output, anything "
"assigned to Cyanobactia, will be lumped in with all "
"other bacteria")
parser.add_argument(
"--proportional",
dest="proportional",
default=False,
action="store_true",
help="""When using tophit or toporg, redistribute proportionally
instead of winner take all""")
parser.add_argument(
"-R",
"--printRank",
dest="printRanks",
action="append",
help="Include indeicated rank(s) in lineage of printed taxa. "
"Will be ignored if beyond the rank of the taxa "
"(IE We can't include species if the taxon being counted "
"is genus)")
# option for deconvoluting clusters or assemblies
add_weight_arguments(parser, multiple=True)
# cutoff options
add_count_arguments(parser)
# format, tax dir, and more
add_taxon_arguments(
parser,
choices={
'countMethod': (
'LCA',
'all',
'first',
'most',
'tophit',
'toporg',
'consensus')})
# log level and help
add_universal_arguments(parser)
arguments = parser.parse_args()
setup_logging(arguments)
if arguments.proportional and \
arguments.countMethod not in ['tophit', 'toporg']:
parser.error("--proportinal only has meaning "
"if using tophit or toporg")
if len(arguments.input_files) == 0:
parser.error("Must supply at least one m8 file to parse")
# Handle the case where Galaxy tries to set None as a string
arguments.ranks = checkNoneOption(arguments.ranks)
arguments.printRanks = checkNoneOption(arguments.printRanks)
logging.info("Printing out ranks: %r", arguments.ranks)
# Set defaults and check for some conflicts
if arguments.ranks is None and arguments.taxdir is None:
# using hit names only
arguments.ranks = [ORG_RANK]
if arguments.printRanks is not None:
parser.error("Display ranks are not used without taxonomic info")
else:
if arguments.taxdir is None:
parser.error("Cannot select ranks without a taxonomy")
if arguments.ranks is None:
# set a default
arguments.ranks = [
'phylum',
'class',
'order',
'family',
'genus',
'species']
try:
# Make sure the rank lists make sense
arguments.ranks = cleanRanks(arguments.ranks)
if arguments.printRanks is not None:
arguments.printRanks = cleanRanks(arguments.printRanks)
except Exception as e:
parser.error(str(e))
# load weights file
sequenceWeights = loadSequenceWeights(arguments.weights)
# only print to stdout if there is a single rank
if len(arguments.ranks) > 1 and arguments.outfile is None:
parser.error("STDOUT only works if a single rank is chosen!")
# Because rank is used in parsing hits, we can only do multiple ranks for
# certain kinds of count methods
if len(arguments.ranks) > 1:
rank = None
if arguments.countMethod in ['consensus', 'most']:
parser.error(
"Using multiple ranks does not work with the 'consensus' "
"or 'most' counting methods. LCA should give the same "
"results as consensus. If you really want to do this, "
"use a bash loop:'for rank in phylum order genus; do "
"COMMAND -r ${rank}; done'")
else:
rank = arguments.ranks[0]
# load necessary maps
(taxonomy, hitStringMap) = readMaps(arguments)
# parse input files
fileCounts = {}
totals = {}
fileLabels = {}
sortedLabels = []
# Allow for file names to be preceded with TAG=
for filename in arguments.input_files:
bits = filename.split("=", 1)
if len(bits) > 1:
(filetag, filename) = bits
else:
filetag = filename
fileLabels[filename] = filetag
# keep order so that column order matches arguments
sortedLabels.append(filetag)
fileCounts[filetag] = {}
totals[filetag] = 0
params = FilterParams.create_from_arguments(arguments)
if arguments.countMethod == 'tophit' or arguments.countMethod == 'toporg':
# Process all files at once and use overall abundance to pick best hits
from edl import redistribute
multifile = redistribute.multipleFileWrapper(fileLabels.keys())
if arguments.countMethod == 'tophit':
# don't give any taxonomy, just map to accessions for
# redistribution
readHits = redistribute.pickBestHitByAbundance(
multifile,
filterParams=params,
returnLines=False,
winnerTakeAll=not arguments.proportional,
parseStyle=arguments.parseStyle,
sequenceWeights=sequenceWeights)
# define method to turn Hits into orgnaisms
hitTranslator = getHitTranslator(parseStyle=arguments.parseStyle,
taxonomy=taxonomy,
hitStringMap=hitStringMap)
translateHit = lambda hit: hitTranslator.translateHit(hit=hit)[0]
else:
# translate to organism before finding most abundant
readHits = redistribute.pickBestHitByAbundance(
multifile,
filterParams=params,
returnLines=False,
returnTranslations=True,
winnerTakeAll=not arguments.proportional,
taxonomy=taxonomy,
hitStringMap=hitStringMap,
parseStyle=ACCS)
# Organisms will be returned, make translator trivial:
translateHit = passThrough
# use read->file mapping and hit translator to get file based counts
# from returned (read,Hit) pairs
increment = 1
for (read_name, hit) in readHits:
file_name, read_name = read_name.split("/", 1)
file_tag = fileLabels[unquote_plus(file_name)]
taxon = translateHit(hit)
taxcount = fileCounts[file_tag].setdefault(taxon, 0)
if sequenceWeights is not None:
increment = sequenceWeights.get(read_name, 1)
fileCounts[file_tag][taxon] = taxcount + increment
totals[file_tag] += increment
logging.debug(str(totals))
else:
# Original way, just process each file separately
for (filename, filetag) in fileLabels.items():
infile = open(filename, 'rU')
hitIter = parseM8FileIter(infile,
hitStringMap,
params,
arguments.parseStyle,
arguments.countMethod,
taxonomy=taxonomy,
rank=rank)
(total, counts, hitMap) = \
countIterHits(hitIter,
allMethod=arguments.allMethod,
weights=sequenceWeights)
fileCounts[filetag] = counts
totals[filetag] = total
logging.info(
"parsed %d hits (%d unique) for %d reads from %s",
total, len(counts), len(hitMap), filename)
infile.close()
printCountTablesByRank(fileCounts, totals, sortedLabels, arguments)
def main():
description = __doc__
parser = argparse.ArgumentParser(description=description)
parser.add_argument("input_files", nargs="+",
default=[],
metavar="INFILE",
help="List of hit tables to process")
parser.add_argument("-o", "--outfile", dest="output_file",
metavar="OUTFILE", help="Write count table to OUTFILE")
parser.add_argument("-l", "--level", dest="levels", default=None,
metavar="LEVEL", action="append",
help=""" Level(s) to collect counts on. Use flag
multiple times to specify multiple levels. If multiple
values given, one table produced for each with rank
name appended to file name. Levels can be an integer
(1-3) for KEGG or SEED levels, any one of 'gene',
'role', 'family',
'ko', or 'ortholog' (which are all synonyms), or
anything not synonymous with 'gene' to
get CAZy groups. Defaults to ortholog/role and
levels 1, 2, and 3 for KEGG and SEED
and gene and group for CAZy and COG.""")
# option for deconvoluting clusters or assemblies
add_weight_arguments(parser, multiple=True)
# cutoff options
add_count_arguments(parser)
# format, ortholog heirarchy, and more
kegg.add_path_arguments(
parser,
defaults={'countMethod': 'tophit'},
choices={'countMethod':
('tophit',
'first',
'most',
'all',
'consensus')},
helps={'countMethod':
("How to deal with counts from multiple hits. ('first': "
"just use the first hit, 'most': "
"can return multiple hits, 'all': return every hit, "
"consensus: return None unless all the same). Do not "
"use most or consensus with more than one level at a time. "
"Default is 'tophit': This breaks any ties by choosing "
"the most abundant hit based on other unambiguous "
"assignments.")})
# log level and help
add_universal_arguments(parser)
arguments = parser.parse_args()
setup_logging(arguments)
if len(arguments.input_files) == 0:
parser.error("Must supply at least one m8 file to parse")
# Set defaults and check for some conflicts
if arguments.levels is None and arguments.heirarchyFile is None:
# using hit names only
arguments.levels = [None]
else:
if arguments.heirarchyFile is None \
and arguments.heirarchyType != 'cazy':
logging.warning("Type: %s", arguments.heirarchyType)
parser.error("Cannot select levels without a heirarchy (ko) file")
if arguments.levels is None:
# set a default
if arguments.heirarchyType is 'kegg':
arguments.levels = ['ko', '1', '2', 'pathway']
if arguments.heirarchyType is 'seed':
arguments.levels = ['role', '1', '2', 'subsystem']
else:
arguments.levels = ['gene', 'group']
try:
# Make sure the rank lists make sense
arguments.levels = cleanLevels(arguments.levels)
except Exception as e:
parser.error(str(e))
# load weights file
sequenceWeights = loadSequenceWeights(arguments.weights)
# only print to stdout if there is a single level
if len(arguments.levels) > 1 and arguments.output_file is None:
parser.error("STDOUT only works if a single level is chosen!")
cutoff = arguments.cutoff
# map reads to hits
if arguments.mapFile is not None:
if arguments.mapStyle == 'auto':
with open(arguments.mapFile) as f:
firstLine = next(f)
while len(firstLine) == 0 or firstLine[0] == '#':
firstLine = next(f)
if koMapRE.search(firstLine):
arguments.mapStyle = 'kegg'
elif seedMapRE.search(firstLine):
arguments.mapStyle = 'seed'
elif tabMapRE.search(firstLine):
arguments.mapStyle = 'tab'
# elif cogMapRE.search(firstLine):
# arguments.mapStyle='cog'
else:
raise Exception(
"Cannot figure out map type from first line:\n%s" %
(firstLine))
logging.info("Map file seems to be: %s", arguments.mapStyle)
if arguments.mapStyle == 'kegg':
valueMap = kegg.parseLinkFile(arguments.mapFile)
elif arguments.mapStyle == 'seed':
valueMap = kegg.parseSeedMap(arguments.mapFile)
# elif arguments.mapStyle=='cog':
# valueMap=kegg.parseCogMap(arguments.mapFile)
else:
if arguments.parseStyle == GIS:
keyType = int
else:
keyType = None
valueMap = parseMapFile(
arguments.mapFile,
valueType=None,
valueDelim=arguments.tab_map_delim,
keyType=keyType)
if len(valueMap) > 0:
logging.info("Read %d items into map. EG: %s",
len(valueMap), next(iter(valueMap.items())))
else:
logging.warn("Read 0 items into value map!")
else:
valueMap = None
# parse input files
fileCounts = {}
totals = {}
fileLabels = {}
sortedLabels = []
# Allow for file names to be preceded with TAG=
for filename in arguments.input_files:
bits = filename.split("=", 1)
if len(bits) > 1:
(filetag, filename) = bits
else:
filetag = filename
fileLabels[filename] = filetag
# keep order so that column order matches arguments
sortedLabels.append(filetag)
fileCounts[filetag] = {}
totals[filetag] = 0
params = FilterParams.create_from_arguments(arguments)
# TODO: incorporate weights into tophit algorithm!
if arguments.countMethod == 'tophit':
# Process all files at once and use overall abundance to pick best hits
from edl import redistribute
multifile = redistribute.multipleFileWrapper(fileLabels.items())
# don't give any hit translation, just use hit ids for redistribution
readHits = redistribute.pickBestHitByAbundance(
multifile,
filterParams=params,
returnLines=False,
winnerTakeAll=True,
parseStyle=arguments.parseStyle,
sequenceWeights=sequenceWeights)
# define method to turn Hits into Genes (kos, families)
hitTranslator = getHitTranslator(parseStyle=arguments.parseStyle,
hitStringMap=valueMap)
# translateHit = lambda hit: hitTranslator.translateHit(hit)[0]
# use read->file mapping and hit translator to get file based counts
# from returned (read,Hit) pairs
increment = 1
for (read_name, hit) in readHits:
file_tag, read_name = read_name.split("/", 1)
file_tag = unquote_plus(file_tag)
gene = hitTranslator.translateHit(hit)[0]
if gene is None:
gene = "None"
logging.debug(
"READ: %s\t%s\t%s\t%s",
file_tag, read_name, hit.hit, gene)
genecount = fileCounts[file_tag].setdefault(gene, 0)
if sequenceWeights is not None:
increment = sequenceWeights.get(read_name, 1)
fileCounts[file_tag][gene] = genecount + increment
totals[file_tag] += increment
logging.debug(str(totals))
else:
# Original way, just process each file separately
for (filename, filetag) in fileLabels.items():
infile = open(filename, 'rU')
hitIter = parseM8FileIter(infile,
valueMap,
params,
arguments.parseStyle,
arguments.countMethod,
ignoreEmptyHits=arguments.mappedHitsOnly)
(total, counts, hitMap) = \
countIterHits(hitIter,
allMethod=arguments.allMethod,
weights=sequenceWeights)
fileCounts[filetag] = counts
totals[filetag] = total
logging.info(
"parsed %d hits (%d unique) for %d reads from %s",
total, len(counts), len(hitMap), filename)
infile.close()
logging.debug(repr(fileCounts))
printCountTablesByLevel(fileCounts, totals, sortedLabels, arguments)
def main():
description = __doc__
parser = argparse.ArgumentParser(description=description)
parser.add_argument("input_files",
nargs="+",
default=[],
metavar="INFILE",
help="List of hit tables to process")
parser.add_argument("-o",
"--outfile",
dest="output_file",
metavar="OUTFILE",
help="Write count table to OUTFILE")
parser.add_argument("-l",
"--level",
dest="levels",
default=None,
metavar="LEVEL",
action="append",
help=""" Level(s) to collect counts on. Use flag
multiple times to specify multiple levels. If multiple
values given, one table produced for each with rank
name appended to file name. Levels can be an integer
(1-3) for KEGG or SEED levels, any one of 'gene',
'role', 'family',
'ko', or 'ortholog' (which are all synonyms), or
anything not synonymous with 'gene' to
get CAZy groups. Defaults to ortholog/role and
levels 1, 2, and 3 for KEGG and SEED
and gene and group for CAZy and COG.""")
# option for deconvoluting clusters or assemblies
add_weight_arguments(parser, multiple=True)
# cutoff options
add_count_arguments(parser)
# format, ortholog heirarchy, and more
kegg.add_path_arguments(
parser,
defaults={'countMethod': 'tophit'},
choices={
'countMethod': ('tophit', 'first', 'most', 'all', 'consensus')
},
helps={
'countMethod':
("How to deal with counts from multiple hits. ('first': "
"just use the first hit, 'most': "
"can return multiple hits, 'all': return every hit, "
"consensus: return None unless all the same). Do not "
"use most or consensus with more than one level at a time. "
"Default is 'tophit': This breaks any ties by choosing "
"the most abundant hit based on other unambiguous "
"assignments.")
})
# log level and help
add_universal_arguments(parser)
arguments = parser.parse_args()
setup_logging(arguments)
if len(arguments.input_files) == 0:
parser.error("Must supply at least one m8 file to parse")
# Set defaults and check for some conflicts
if arguments.levels is None and arguments.heirarchyFile is None:
# using hit names only
arguments.levels = [None]
else:
if arguments.heirarchyFile is None \
and arguments.heirarchyType != 'cazy':
logging.warning("Type: %s", arguments.heirarchyType)
parser.error("Cannot select levels without a heirarchy (ko) file")
if arguments.levels is None:
# set a default
if arguments.heirarchyType is 'kegg':
arguments.levels = ['ko', '1', '2', 'pathway']
if arguments.heirarchyType is 'seed':
arguments.levels = ['role', '1', '2', 'subsystem']
else:
arguments.levels = ['gene', 'group']
try:
# Make sure the rank lists make sense
arguments.levels = cleanLevels(arguments.levels)
except Exception as e:
parser.error(str(e))
# load weights file
sequenceWeights = loadSequenceWeights(arguments.weights)
# only print to stdout if there is a single level
if len(arguments.levels) > 1 and arguments.output_file is None:
parser.error("STDOUT only works if a single level is chosen!")
cutoff = arguments.cutoff
# map reads to hits
if arguments.mapFile is not None:
if arguments.mapStyle == 'auto':
with open(arguments.mapFile) as f:
firstLine = next(f)
while len(firstLine) == 0 or firstLine[0] == '#':
firstLine = next(f)
if koMapRE.search(firstLine):
arguments.mapStyle = 'kegg'
elif seedMapRE.search(firstLine):
arguments.mapStyle = 'seed'
elif tabMapRE.search(firstLine):
arguments.mapStyle = 'tab'
# elif cogMapRE.search(firstLine):
# arguments.mapStyle='cog'
else:
raise Exception(
"Cannot figure out map type from first line:\n%s" %
(firstLine))
logging.info("Map file seems to be: %s", arguments.mapStyle)
if arguments.mapStyle == 'kegg':
valueMap = kegg.parseLinkFile(arguments.mapFile)
elif arguments.mapStyle == 'seed':
valueMap = kegg.parseSeedMap(arguments.mapFile)
# elif arguments.mapStyle=='cog':
# valueMap=kegg.parseCogMap(arguments.mapFile)
else:
if arguments.parseStyle == GIS:
keyType = int
else:
keyType = None
valueMap = parseMapFile(arguments.mapFile,
valueType=None,
valueDelim=arguments.tab_map_delim,
keyType=keyType)
if len(valueMap) > 0:
logging.info("Read %d items into map. EG: %s", len(valueMap),
next(iter(valueMap.items())))
else:
logging.warn("Read 0 items into value map!")
else:
valueMap = None
# parse input files
fileCounts = {}
totals = {}
fileLabels = {}
sortedLabels = []
# Allow for file names to be preceded with TAG=
for filename in arguments.input_files:
bits = filename.split("=", 1)
if len(bits) > 1:
(filetag, filename) = bits
else:
filetag = filename
fileLabels[filename] = filetag
# keep order so that column order matches arguments
sortedLabels.append(filetag)
fileCounts[filetag] = {}
totals[filetag] = 0
# TODO: incorporate weights into tophit algorithm!
if arguments.countMethod == 'tophit':
# Process all files at once and use overall abundance to pick best hits
from edl import redistribute
params = FilterParams.create_from_arguments(arguments)
multifile = redistribute.multipleFileWrapper(fileLabels.items())
# don't give any hit translation, just use hit ids for redistribution
readHits = redistribute.pickBestHitByAbundance(
multifile,
filterParams=params,
returnLines=False,
winnerTakeAll=True,
parseStyle=arguments.parseStyle,
sequenceWeights=sequenceWeights)
# define method to turn Hits into Genes (kos, families)
hitTranslator = getHitTranslator(parseStyle=arguments.parseStyle,
hitStringMap=valueMap)
# translateHit = lambda hit: hitTranslator.translateHit(hit)[0]
# use read->file mapping and hit translator to get file based counts
# from returned (read,Hit) pairs
increment = 1
for (read_name, hit) in readHits:
file_tag, read_name = read_name.split("/", 1)
file_tag = unquote_plus(file_tag)
gene = hitTranslator.translateHit(hit)[0]
if gene is None:
gene = "None"
logging.debug("READ: %s\t%s\t%s\t%s", file_tag, read_name, hit.hit,
gene)
genecount = fileCounts[file_tag].setdefault(gene, 0)
if sequenceWeights is not None:
increment = sequenceWeights.get(read_name, 1)
fileCounts[file_tag][gene] = genecount + increment
totals[file_tag] += increment
logging.debug(str(totals))
else:
# Original way, just process each file separately
for (filename, filetag) in fileLabels.items():
infile = open(filename, 'rU')
hitIter = parseM8FileIter(infile,
valueMap,
arguments.hitTableFormat,
arguments.filter_top_pct,
arguments.parseStyle,
arguments.countMethod,
ignoreEmptyHits=arguments.mappedHitsOnly)
(total, counts, hitMap) = \
countIterHits(hitIter,
allMethod=arguments.allMethod,
weights=sequenceWeights)
fileCounts[filetag] = counts
totals[filetag] = total
logging.info("parsed %d hits (%d unique) for %d reads from %s",
total, len(counts), len(hitMap), filename)
infile.close()
logging.debug(repr(fileCounts))
printCountTablesByLevel(fileCounts, totals, sortedLabels, arguments)
def main():
"""" Set up the CLI """
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("input_files",
nargs="+",
default=[],
metavar="INFILE",
help="List of hit tables to process")
parser.add_argument("-o",
"--outfile",
dest="outfile",
metavar="OUTFILE",
help="Write count table to OUTFILE")
parser.add_argument("-r",
"--rank",
dest="ranks",
default=None,
metavar="RANK",
action="append",
help=""" Rank(s) to collect counts on. Use flag
multiple
times to specify multiple ranks. If multiple values
given, one table produced for each with rank name
appended to file name. Defaults to all major ranks
between phylum and species. Corresponds to rank names
in nodes.dmp. To see list run:
'cut -f5 nodes.dmp | uniq | sort | uniq'
in ncbi tax dir. Will also accept 'organism' to mean
no rank (ie, just the organism name).""")
parser.add_argument(
"-s",
"--collapseToDomain",
default=False,
action="store_true",
help="Collapse all taxa below given rank down to "
"superkingdom/domain. EG: in the genus output, anything "
"assigned to Cyanobactia, will be lumped in with all "
"other bacteria")
parser.add_argument(
"-R",
"--printRank",
dest="printRanks",
action="append",
help="Include indeicated rank(s) in lineage of printed taxa. "
"Will be ignored if beyond the rank of the taxa "
"(IE We can't include species if the taxon being counted "
"is genus)")
# option for deconvoluting clusters or assemblies
add_weight_arguments(parser, multiple=True)
# cutoff options
add_count_arguments(parser)
# format, tax dir, and more
add_taxon_arguments(parser,
choices={
'countMethod': ('LCA', 'all', 'first', 'most',
'tophit', 'toporg', 'consensus')
})
# log level and help
add_universal_arguments(parser)
arguments = parser.parse_args()
setup_logging(arguments)
if len(arguments.input_files) == 0:
parser.error("Must supply at least one m8 file to parse")
# Handle the case where Galaxy tries to set None as a string
arguments.ranks = checkNoneOption(arguments.ranks)
arguments.printRanks = checkNoneOption(arguments.printRanks)
logging.info("Printing out ranks: %r", arguments.ranks)
# Set defaults and check for some conflicts
if arguments.ranks is None and arguments.taxdir is None:
# using hit names only
arguments.ranks = [ORG_RANK]
if arguments.printRanks is not None:
parser.error("Display ranks are not used without taxonomic info")
else:
if arguments.taxdir is None:
parser.error("Cannot select ranks without a taxonomy")
if arguments.ranks is None:
# set a default
arguments.ranks = [
'phylum', 'class', 'order', 'family', 'genus', 'species'
]
try:
# Make sure the rank lists make sense
arguments.ranks = cleanRanks(arguments.ranks)
if arguments.printRanks is not None:
arguments.printRanks = cleanRanks(arguments.printRanks)
except Exception as e:
parser.error(str(e))
# load weights file
sequenceWeights = loadSequenceWeights(arguments.weights)
# only print to stdout if there is a single rank
if len(arguments.ranks) > 1 and arguments.outfile is None:
parser.error("STDOUT only works if a single rank is chosen!")
# Because rank is used in parsing hits, we can only do multiple ranks for
# certain kinds of count methods
if len(arguments.ranks) > 1:
rank = None
if arguments.countMethod in ['consensus', 'most']:
parser.error(
"Using multiple ranks does not work with the 'consensus' "
"or 'most' counting methods. LCA should give the same "
"results as consensus. If you really want to do this, "
"use a bash loop:'for rank in phylum order genus; do "
"COMMAND -r ${rank}; done'")
else:
rank = arguments.ranks[0]
# load necessary maps
(taxonomy, hitStringMap) = readMaps(arguments)
# parse input files
fileCounts = {}
totals = {}
fileLabels = {}
sortedLabels = []
# Allow for file names to be preceded with TAG=
for filename in arguments.input_files:
bits = filename.split("=", 1)
if len(bits) > 1:
(filetag, filename) = bits
else:
filetag = filename
fileLabels[filename] = filetag
# keep order so that column order matches arguments
sortedLabels.append(filetag)
fileCounts[filetag] = {}
totals[filetag] = 0
if arguments.countMethod == 'tophit' or arguments.countMethod == 'toporg':
# Process all files at once and use overall abundance to pick best hits
from edl import redistribute
params = FilterParams.create_from_arguments(arguments)
multifile = redistribute.multipleFileWrapper(fileLabels.keys())
if arguments.countMethod == 'tophit':
# don't give any taxonomy, just map to accessions for
# redistribution
readHits = redistribute.pickBestHitByAbundance(
multifile,
filterParams=params,
returnLines=False,
winnerTakeAll=True,
parseStyle=arguments.parseStyle,
sequenceWeights=sequenceWeights)
# define method to turn Hits into orgnaisms
hitTranslator = getHitTranslator(parseStyle=arguments.parseStyle,
taxonomy=taxonomy,
hitStringMap=hitStringMap)
translateHit = lambda hit: hitTranslator.translateHit(hit=hit)[0]
else:
# translate to organism before finding most abundant
readHits = redistribute.pickBestHitByAbundance(
multifile,
filterParams=params,
returnLines=False,
returnTranslations=True,
winnerTakeAll=True,
taxonomy=taxonomy,
hitStringMap=hitStringMap,
parseStyle=ACCS)
# Organisms will be returned, make translator trivial:
translateHit = passThrough
# use read->file mapping and hit translator to get file based counts
# from returned (read,Hit) pairs
increment = 1
for (read_name, hit) in readHits:
file_name, read_name = read_name.split("/", 1)
file_tag = fileLabels[unquote_plus(file_name)]
taxon = translateHit(hit)
taxcount = fileCounts[file_tag].setdefault(taxon, 0)
if sequenceWeights is not None:
increment = sequenceWeights.get(read_name, 1)
fileCounts[file_tag][taxon] = taxcount + increment
totals[file_tag] += increment
logging.debug(str(totals))
else:
# Original way, just process each file separately
for (filename, filetag) in fileLabels.items():
infile = open(filename, 'rU')
hitIter = parseM8FileIter(infile,
hitStringMap,
arguments.hitTableFormat,
arguments.filter_top_pct,
arguments.parseStyle,
arguments.countMethod,
taxonomy=taxonomy,
rank=rank)
(total, counts, hitMap) = \
countIterHits(hitIter,
allMethod=arguments.allMethod,
weights=sequenceWeights)
fileCounts[filetag] = counts
totals[filetag] = total
logging.info("parsed %d hits (%d unique) for %d reads from %s",
total, len(counts), len(hitMap), filename)
infile.close()
printCountTablesByRank(fileCounts, totals, sortedLabels, arguments)
def main():
# set up CLI
description = __doc__
parser = argparse.ArgumentParser(description=description)
parser.add_argument("-i", "--infile", dest="infile",
metavar="FILE", help="Read raw table from INFILE")
parser.add_argument(
"-o",
"--outfile",
dest="outfile",
metavar="OUTFILE",
help="Write collapsed table to OUTFILE")
parser.add_argument("-d", "--delim", dest="delim", default="\t",
help="Input table delimiter", metavar="DELIM")
parser.add_argument("-D", "--delimOut", dest="delimOut", default="\t",
help="Output table delimiter", metavar="DELIM")
parser.add_argument(
'-F',
'--countFirst',
action='store_true',
default=False,
help="Don't skip the first line, it's NOT a header")
parser.add_argument(
"-R",
"--readColumn",
dest="readCol",
type=int,
default=0,
help="Index (starting at 0) of column with read name, 0 is default",
metavar="READCOL")
parser.add_argument(
"-H",
"--hitColumn",
dest="hitCol",
type=int,
default=2,
help="Index (starting at 0) of column with hit name (for counting), "
"2 is default, if less than zero, all (non-read) columns will "
"be used as multiple hits",
metavar="HITCOL")
parser.add_argument(
'-s',
'--hitSep',
default=None,
help="Use this string to split multiple values in single hit cell. "
"Default is 'None' to leave hits as is, use 'eval' to parse "
"as python repr strings")
add_weight_arguments(parser, multiple=False)
parser.add_argument("-T", "--total", default=False, action="store_true",
help="Report 'Total' in the first row")
# cutoff options
add_count_arguments(parser, {'cutoff': 0})
# log level and help
add_universal_arguments(parser)
arguments = parser.parse_args()
setup_logging(arguments)
# make sure we have something to do
if (arguments.infile is None):
logging.info("Reading table from: STDIN")
else:
logging.info("Reading table from: " + arguments.infile)
if (arguments.outfile is None):
logging.info("Writing counts to: STDOUT")
else:
logging.info("Writing counts to: " + arguments.outfile)
# process arguments
takeFirst = (arguments.allMethod == 'first')
splitHits = (arguments.hitSep is not None and arguments.hitSep != 'None')
uncluster = (arguments.weights is not None)
if arguments.hitSep == 'eval':
parser.error("Sorry, parsing with eval is not yet supported!")
# inform the curious user
logging.info("Delimiter: '" + arguments.delim)
logging.info("Read names in col: '" + str(arguments.readCol))
logging.info("Hit names in col: '" + str(arguments.hitCol))
if splitHits:
logging.info("Splitting hits with: %s" % (arguments.hitSep))
logging.warn(
"Splitting hits has not been tested yet! Let me know how it goes.")
if takeFirst:
logging.info("Taking first hit for each read.")
else:
if arguments.allMethod == 'portion':
logging.info("Dividing count among all hits for each read.")
else:
logging.info("Adding 1 to every hit for each read")
if uncluster:
logging.info(
"Getting read cluster sizes from: %s" %
(arguments.weights))
if arguments.countFirst:
logging.info("First line is data")
else:
logging.info("Skipping first line")
# Do the counting!
counts = {}
countHitsForRead = getAllMethod(arguments.allMethod)
clusteredReadCounts = {}
if uncluster:
clusteredReadCounts = parseMapFile(
arguments.clusterFile, valueType=int)
currentRead = ''
readCount = 1
hits = []
if arguments.infile is None:
infile = sys.stdin
else:
infile = open(arguments.infile)
# loop over lines
if not arguments.countFirst:
# skip first line
try:
next(infile)
except StopIteration:
raise Exception("No lines in %s" % str(infile))
for line in infile:
line = line.rstrip('\r\n')
rowcells = line.split(arguments.delim)
# get read
read = rowcells[arguments.readCol]
# if it's a new read, process previous read
if currentRead == '':
currentRead = read
elif read != currentRead and currentRead != '':
readCount += 1
logging.info("Checking hits for %s" % currentRead)
# was it part of a cluster?
multiplier = 1
if uncluster:
multiplier = clusteredReadCounts[currentRead]
# where does the count for this read go
countHitsForRead(hits, counts, multiplier=multiplier)
hits = []
currentRead = read
# get hit from this line
if arguments.hitCol >= 0:
hit = rowcells[arguments.hitCol]
if splitHits:
hits.extend(hit.split(arguments.hitSep))
else:
hits.append(hit)
else:
rowcells.pop(arguments.readCol)
hits.extend(rowcells)
# check last read!
logging.info("Checking hits for %s" % currentRead)
# was it part of a cluster?
multiplier = 1
if uncluster:
multiplier = clusteredReadCounts[currentRead]
# where does the count for this read go
countHitsForRead(hits, counts, multiplier=multiplier)
# apply cutoff
if arguments.cutoff > 0:
applyFractionalCutoff(counts, threshold=arguments.cutoff * readCount)
# print output
if arguments.outfile is None:
outhandle = sys.stdout
else:
outhandle = open(arguments.outfile, 'w')
if arguments.total:
outhandle.write("Total%s%d\n" % (arguments.delimOut, readCount))
if arguments.allMethod == 'portion':
outFmtString = "%s%s%f\n"
else:
outFmtString = "%s%s%d\n"
delimRE = re.compile(arguments.delimOut)
for hit in sorted(counts.keys()):
count = counts[hit]
hit = delimRE.sub('_', hit)
outhandle.write(outFmtString % (hit, arguments.delimOut, count))