#!/usr/bin/env python

"""

Snoop thru a fasta file looking for microsatellite repeats of given periods

Output format: length_of_repeat left_flank_length right_flank_length repeat_motif hamming_distance read_name read_sequence read_quality

:Author: Bob Harris (rsharris@bx.psu.edu)

"""

from sys import argv,stdin,stderr,exit

from string import maketrans

from md5 import new as md5_new

from pyfracluster import dense_intervals

def usage(s=None):

else: exit ("%s\n%s" % (s,message))

detailedDescription = """In broad terms, the process works as follows:

the user."""

def main():

inputF.close()

# correlation_sequence--

# Compute the correlation sequence for a given period. This is a sequence

# of + and - indicating whether the base at a given position matches the one

# P positions earlier (where P is the period). The first P positions are

# blank. Positions with single character runs longer than the period are

# considered as non-matches, unless the period is 1.

def correlation_sequence(sequence,period,start=None,end=None):

return "".join(corr)

# longest_suitable_run--

# Find longest run with a good enough rate (of positives).

#

# We score a "+" as 1-r and anything else as -r. This is based on the fol-

# lowing derivation (p is the number of "+"s, n is the number of non-"+"s):

# p/(p+n) >= r

# ==> p >= rp + rn

# ==> (1-r)p - rn >= 0

#

# We adapt an algorithm from "Programming Pearls", pg. 81 (2000 printing).

#

# $$$ we use the denominator as the threshold, but we really should use the

# $$$ .. numerator, comparing it to minLength*rate

#

# $$$ this needs to account for $$$ this situation:

# $$$ sequence: ACGACGACGACGTTATTATTATTA

# $$$ matches: +++++++++---+++++++++

# $$$ this is currently considered to be one interval (if rate <= 6/7), but it

# $$$ ought to be two; we can't just post-process, though, because some other

# $$$ interval might be longer than the longest half of this; maybe what we

# $$$ need to do is consider matches at distances -P and -2P, or if we match

# $$$ -P but that itself was a mismatch, we should carry the mismatch forward

def longest_suitable_run(seq,minLength,rate):

return [(start,end)]

# all_suitable_runs--

# Find all non-overlapping runs with a good enough rate (of positives), and

# which meet our length threshold.

# $$$ this needs to post-process the intervals, splitting them to account for

# $$$ this situation:

# $$$ sequence: ACGACGACGACGTTATTATTATTA

# $$$ matches: +++++++++---+++++++++

# $$$ this is currently reported as one interval (if rate <= 6/7), but it

# $$$ ought to be two

def all_suitable_runs(seq,minCorrLength,rate):

return [(start,end) for (start,end) in dense_intervals(seq,rate,"+","-",blockers=None,minLength=minCorrLength)]

# find_repeat_element--

# Find the most plausible repeat element for a run, and nudge the ends of

# the run if needed. Note that we will not consider kmers that represent

# shorter repeats. For example, we won't report ACTACT as a 6-mer since we

# consider this to have a shorter period than 6.

def find_repeat_element(period,seq,start,end,allowPartials=False):

return (kmer,bestD,bestStart,bestEnd)

# plausible_intervals--

# Yield all plausible intervals intersecting with a run. We generate all

# starts within P bp of the run's start. For each of these, we either (a) try

# all ends within P bp of run's end, or (b) trim the new interval to a whole

# multiple of the period, and report this short interval and the longer

# interval with one more period appended. Case (a) allows partial motifs,

# while case (b) only allows whole motifs.

def plausible_intervals(start,end,period,seqLen,allowPartials=False):

if (candEnd <= seqLen): yield (candStart,candEnd)

# hamming_distance--

# Determine the hamming distance between the run and a simple repeat.

# $$$ improve this by allowing gaps, and stopping when we reach a threshold

kmerToDiffs = {} # (this is used for memo-ization)

def hamming_distance(seq,start,end,kmer):

return d

# fasta_sequences--

# Read the fasta sequences from a file. Note that we convert to upper case,

# and convert any letter other than ACGT to N.

nonDnaMap = maketrans("BDEFHIJKLMOPQRSUVWXYZ","NNNNNNNNNNNNNNNNNNNNN")

def fasta_sequences(f):

yield (seqName,"".join(seqNucs).upper().translate(nonDnaMap))

# fastq_sequences--

# Read the fastq sequences from a file. Note that we convert to upper case,

# and convert any letter other than ACGT to N.

def fastq_sequences(f):

"incomplete read at end of file"

# sequence_name--

# Extract the sequence name from a fasta header.

# $$$ this may need to be improved $$$

def sequence_name(s):

s = s[1:].strip()

if (s == ""): return ""

else: return s.split()[0]

# nucleotide_runs--

# Yield (start,end) for all runs of valid nucleotides in a sequence.

def nucleotide_runs(s):

if (start != None): yield (start,len(s))

# contains_repeat--

# Determine whether a short sequence contains a repeated element, such as a

# 6-mer containing a repeated 2-mer (ACACAC) or 3-mer (ACTACT). The repeat

# must cover the entire sequence, without mismatches.

def contains_repeat(kmer):

return hasRepeat

# hash108--

# Return a 108-bit hash "value" of a string

def hash108(s):

m = md5_new()

m.update(s)

return m.hexdigest()[:27]

# float_or_fraction--

# Convert a string to a number, allowing fractions

def float_or_fraction(s):

return float(s)

# int_with_unit--

# Parse a string as an integer, allowing unit suffixes

def int_with_unit(s):

except ValueError: return int(math.ceil(float(s) * multiplier))

if __name__ == "__main__": main()