#!/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 (additional columns)

If --r option turned on, output format will have additional columns behind:

read_name read_chr pre_s pre_e tr_s tr_e suf_s suf_e tr_len tr_ref_seq

pre_s where the read start

pre_e the last position before microsatellite

tr_s where microsatellite start

tr_e where microsatellite end

suf_s first base after microsatellite

tr_ref_seq reference sequence corresponding to microsatellite

* output positions are 0 based

:Author: Chen Sun (cxs1031@cse.psu.edu); Bob Harris (rsharris@bx.psu.edu)

modifing log:

09/27/2013

replace function dense_intervals with function non_negative_intervals, which do not need to import such file.

10/18/2013

modify function find_repeat_element to get a quick speed, under the condition that hamming_distance = 0, which means do not allowed any mutation/indel

02/25/2014

add function that can deal with mapped reads

with additional output

02/28/2014

modify the 0-based end point, as in 0-base area, it is half-open [ )

so the 0-based site, should always be added by 1

03/05/2014

deal with multi-fasta

"""

from sys import argv,stdin,stderr,exit

from string import maketrans

from md5 import new as md5_new

import re

#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()

# non_negative_intervals

# find intervals with exactly + and no -

# from string like this : +++++++++---+++++++++

def non_negative_intervals(seq, minLength=None):

yield (start, ix+1)

###################################################################

# modified by Chen Sun on 7/11/2014

# We do not want other modules, so parse these functions inside

#

###################################################################

# parse a string of the form {positives}/{positives_and_neutrals}

def parse_spec(s):

return (positives,neutrals)

# convert a string to a number, allowing fractions

def float_or_fraction(s):

return float(s)

# dense_intervals--

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

# which meet our length threshold.

#

# The algorithm used is adapted from Zhang, Berman, Miller, "Post-processing

# long pairwise alignments", Bioinformatics Vol. 15 no. 12 1999.

#

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

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

def dense_intervals(seq,rate,positives,neutrals,blockers="",minLength=None):

yield (left,right)

###################################################################

# modified by Chen Sun on 7/11/2014

#

###################################################################

# 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, hammingThreshold):

return [(start,end) for (start,end) in non_negative_intervals(seq, 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(hammingThreshold, period,seq,start,end,allowPartials=False):

return (kmer,bestD,bestStart,bestEnd)

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