This script will parse an input FASTA file and output coordinates of found matches of the supplied pattern

#!/usr/bin/env python
# python 2.7

from Bio import SeqIO
import re
import sys


# pattern = "TAACCACTCA"
pattern = sys.argv[1]

# file_path = "/local/data/iGenomes/Homo_sapiens/UCSC/hg19/Sequence/WholeGenomeFasta/genome.fa"
file_path = sys.argv[2]

def search_fasta(pattern, file_path):
    for record in SeqIO.parse(open(file_path, "rU"), "fasta"):
        chrom = record.id
        for match in re.finditer(pattern, str(record.seq)):
            start_pos = match.start() + 1
            end_pos = match.end() + 1
            print chrom, '\t', start_pos, '\t', end_pos

search_fasta(pattern, file_path)

Assuming you save the script as find_seq.py, usage:

$ ./find_seq.py TAACCACTCA /local/data/iGenomes/Homo_sapiens/UCSC/hg19/Sequence/WholeGenomeFasta/genome.fa > test_loc.txt

output:

$ head test_loc.txt
chrM    23  33
chrM    14789   14799
chr1    745938  745948
chr1    4134336     4134346
chr1    7907657     7907667
chr1    8671647     8671657
chr1    11256382    11256392
chr1    20426818    20426828
chr1    22886084    22886094
chr1    28288492    28288502

Edit: adjusted the coordinate parsing

Here's a demo Python script you can modify for your use, which suggests the rough principle:

#!/usr/bin/env python

import sys
import re

bed = """chr1\t0\t10\tABCDEFGHIJ
chr1\t5\t15\tFGHIJABCDO
chr1\t10\t20\tABCDOPABCD"""

string_to_match = sys.argv[1]
pattern = re.compile(string_to_match)

for line in bed.split("\n"):
    (chr, start, stop, id) = line.split("\t")
    for match in pattern.finditer(id):
        sys.stdout.write("\t".join([chr, str(int(start) + match.start()), str(int(start) + match.end()), string_to_match]) + "\n")

Some sample runs:

$ ./test.py HIJABC
chr1    7   13  HIJABC
$ ./test.py HIJAB
chr1    7   12  HIJAB
$ ./test.py BCDEF
chr1    1   6   BCDEF
$ ./test.py ABCD
chr1    0   4   ABCD
chr1    10  14  ABCD
chr1    16  20  ABCD

One would prepare a BED file from the genome's FASTA (with spanning windows), and then modify the Python script to read that BED file on a line-by-line basis.

If a lot of these searches are done, this is also easily parallelizable, splitting work by chromosome or some other unit of work that matches the environment.

So as to avoid "double-hits", It might be worth piping the result to uniq, or testing the length of the input string_to_match to ensure that it is at least half as long as the interleaving spanning elements.

There are perhaps libraries that do a better job of dealing with these and similar edge cases. Still, hopefully this is a useful starting point.

here are my 2 cents for a one-liner perl solution to look for a particular motif in a genome (change the $seqMotif variable to look for your motif of interest; note that it accepts a regex pattern) that prints the positions where the motif happens to appear:

time perl -ne 'BEGIN {
$seqMotif = TAACCACTCA;
$seqPattern = qr/$seqMotif/;
$windowSize = length($seqMotif) - 1;
}
if (/^>(\S+)/) {
 $chr = $1; $start = 0; $preSeq = ""
} else {
 chomp; $seqLength = length; $seq = $preSeq.$_;
 if ( $seq =~ $seqPattern ) {
  $pos = $start + $-[0];
  $pos -= $windowSize if $preSeq;
  print "$chr\t$pos\n";
 }
 $start += $seqLength; $preSeq = substr $seq, -$windowSize;
}' human_hg19.fa > positions.txt

what this code does is to compile the motif pattern at the beginning, and then look for it directly from a fasta file, adding the final characters of the previous line to the current one in order to find the motif in case it's splitted in 2 lines. this particular motif was found 2512 times in the human genome and took 45 seconds on my personal computer, for benchmarking purposes. no reference index needed, no fasta file preprocessing, no dependencies, just good old pattern matching on perl.

I had this issue recently of creating a bed file from a list of primers and a reference. Here's a simple solution using seqkit.

Assuming your primers.fasta are in a fasta file:

>primer_1_F
ATGC
>primer_2_F
ATGY

seqkit locate -f primers.fasta reference.fasta

If you primers have degenerate bases add the -d flag.

To allow mismatches use the -m flag to specify number of mismatches.

To output bed format use --bed or for gtf --gtf.