qu-mfeindex 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 078d0efd0389e0fb00ddb3434b227f57a329960e
+  data.tar.gz: 3e899029902dd46daec7ec7ba7341c7ea04f19a0
+SHA512:
+  metadata.gz: 0196c1634bdfc2455fce27addf74687745bdb9106894d1ed84780800cabf64fc89832cf9c28f97f24e4c6be88a027a4605263bb7545c2737772bd0fbbe051ba5
+  data.tar.gz: 84950a7f7cc5003a464d8dcc53a3a712a56748960af70abd70b35956a00a9dd84430698002b80aac5804f9d837e40dddbf3a54d8a4bc0c5d949606c6560130bf

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qu-mfeindex.gemspec
+gemspec
+gem 'qu/utils'
+gem 'qu/cmdwrapper'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Wubin Qu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Qu::Mfeindex
+
+DNA sequence indexer originally developed for MFEprimer-2.0
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'qu-mfeindex'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install qu-mfeindex
+
+## Usage
+
+`mfeindex fasta_file [kvalue]`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mfeindex

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+
+require 'qu/mfeindex'
+
+def split_db(big_db)
+  big_db_dir = Qu::Mfeindex::get_big_db_dir(big_db)
+  Dir.mkdir(big_db_dir) unless File.directory?(big_db_dir)
+
+  sum_size = 0
+  small_file_list = []
+  Dir.foreach(big_db_dir).each do |small_file|
+    prefix = File.basename(big_db)
+    next small_file unless small_file =~ /^#{prefix}\.\d$/
+    small_file_list << File.join(big_db_dir, small_file)
+    sum_size += File.size(File.join(big_db_dir, small_file))
+  end
+
+  if sum_size >= File.size(big_db)
+    $stdout.print "#{big_db} has been splited, do you want to resplit it? [y/N]:"
+    choice = $stdin.gets.chomp.downcase
+    choice = 'n' if choice.empty?
+    while !['y', 'n'].include?(choice)
+      $stdout.print "The choice should be 'y' or 'n':"
+      choice = $stdin.gets.chomp.downcase
+    end
+
+    if choice == 'n'
+      return small_file_list
+    end
+  end
+
+  small_file_list = []
+
+  small_file_index = 0
+  small_file_name = File.join(big_db_dir, File.basename(big_db) + '.' + small_file_index.to_s)
+  fh = File.open(small_file_name, 'w')
+  small_file_list << small_file_name
+  File.open(big_db).each do |line|
+    if line.start_with?('>')
+      if fh.size >= Qu::Mfeindex::BIG_DB_SPLIT_CUTOFF
+        fh.close
+        small_file_index += 1
+        small_file_name = File.join(big_db_dir, File.basename(big_db) + '.' + small_file_index.to_s)
+        fh = File.open(small_file_name, 'w')
+        small_file_list << small_file_name
+      end
+    end
+    fh.write(line)
+  end
+  fh.close
+
+  return small_file_list
+end
+
+
+def index_db(fasta_file, kvalue)
+  if Qu::Mfeindex::db_indexed?(fasta_file)
+    $stdout.print "#{fasta_file} has already been indexed, do you want to reindex? [y/N]:"
+    choice = $stdin.gets.chomp.downcase
+    choice = 'n' if choice.empty?
+    while !['y', 'n'].include?(choice)
+      $stdout.print "The choice should be 'y' or 'n':"
+      choice = $stdin.gets.chomp.downcase
+    end
+  else
+    choice = 'y'
+  end
+
+  if choice == 'y'
+    Qu::Mfeindex::MFEprimerIndex(fasta_file, kvalue, reindex=true)
+  else
+    Qu::Mfeindex::MFEprimerIndex(fasta_file, kvalue, reindex=false)
+  end
+end
+
+
+usage = "Index database for MFEprimer-2.0
+
+Usage:
+
+  #{File.basename($0)} fasta_file [kvalue]
+
+  
+  Options:
+  
+  kvalue: Default is 9 [Integer].
+
+Contact: Wubin Qu <quwubin@gmail.com>
+"
+
+case ARGV.size
+when 2
+  fasta_file = ARGV[0]
+  kvalue = ARGV[1].to_i
+when 1
+  fasta_file = ARGV[0]
+  kvalue = 9
+else
+  $stderr.puts usage
+  exit
+end
+
+unless File.exists?(fasta_file)
+  $stdout.puts "Error: #{fasta_file} is not exitst.\n"
+  $stderr.puts usage
+  exit
+end
+
+if File.size(fasta_file) > Qu::Mfeindex::BIG_DB_SPLIT_CUTOFF
+  $stdout.print "#{fasta_file} is too large, do you want to split it first? [Y/n]:"
+  choice = $stdin.gets.chomp.downcase
+  choice = 'y' if choice.empty?
+  while !['y', 'n'].include?(choice)
+    $stdout.print "The choice should be 'y' or 'n':"
+    choice = $stdin.gets.chomp.downcase
+  end
+else
+  choice = 'n'
+end
+
+if choice == 'y'
+  small_file_list = split_db(fasta_file)
+  small_file_list.each do |small_file|
+    index_db(small_file, kvalue)
+  end
+else
+  index_db(fasta_file, kvalue)
+end

data/lib/qu/mfeindex.rb

@@ -0,0 +1,166 @@
+require 'qu/utils'
+require 'qu/cmdwrapper'
+
+require_relative "mfeindex/data"
+require_relative "mfeindex/version"
+require 'json'
+
+module Qu
+  module Mfeindex
+    # Your code goes here...
+
+    module_function
+
+    def get_big_db_dir(db)
+      db + BIG_DB
+    end
+
+    def check_db(db_list)
+      new_db_list = []
+
+      db_list.each do |db|
+        big_db_dir = get_big_db_dir(db)
+        if db_indexed?(db)
+          new_db_list << db 
+          next
+        elsif File.directory?(big_db_dir)
+          Dir.foreach(big_db_dir).each do |small_file|
+            prefix = File.basename(db)
+            next small_file unless small_file =~ /^#{prefix}\.\d$/
+            new_db_list << File.join(big_db_dir, small_file)
+          end
+        elsif !File.exists?(db)
+          $stderr.puts "Error: #{db} is not exists."  
+          exit
+        elsif File.size(db) > BIG_DB_SPLIT_CUTOFF
+          $stderr.puts "Warning: #{db} is too large, please use mfepindex to index the db first."
+          exit
+        else
+          new_db_list << db
+          next
+        end
+      end
+      new_db_list
+    end
+
+    def db_indexed?(db)
+      File.exist?(db + DB_SQLITE3) and File.exist?(db + DB_JSON) and File.exist?(db + DB_2BIT)
+    end
+
+    def MFEprimerIndex(fasta_file, k = 9, reindex = false)
+      return if !reindex and db_indexed?(fasta_file)
+
+      unless File.exists?(fasta_file)
+        $stderr.puts "Error: #{fasta_file} is not exists." 
+        exit
+      end
+      info_json = {}
+
+      uni_fasta = fasta_file + '.unifasta'
+
+      File.open(uni_fasta, 'w') do |fh|
+        Bio::FlatFile.new(Bio::FastaFormat, File.open(fasta_file)).each_with_index do |record, index|
+          info_json[index] = {'id' => record.entry_name, 'desc' => record.desc, 'size' => record.naseq.size}
+          fh.write ">#{index}\n#{record.naseq}\n"
+        end
+      end
+
+      File.open(fasta_file + DB_JSON, 'w') do |fh|
+        fh.write(JSON.dump(info_json))
+      end
+
+      Qu::Cmdwrapper::faToTwoBit(uni_fasta, fasta_file + DB_2BIT)
+
+      cmd = File.join(__dir__, 'pymfeindex')
+      $stderr.puts "Begin index database: #{fasta_file}"
+      `#{cmd} -f #{uni_fasta} -k #{k} -o #{fasta_file + DB_SQLITE3}`
+      begin
+        File.delete(uni_fasta)
+      rescue
+        if File.exists?(uni_fasta)
+          $stderr.puts "You can delete the file #{uni_fasta} by hand."
+        end
+      end
+      $stderr.puts "Done index database: #{fasta_file}"
+    end
+
+    def int2dna(int, k=9, base_number=4)
+      seqint = int.to_s(base_number)
+      dna = ""
+      (0...seqint.length).each do |index|
+       dna += D2I[seqint[index].to_i]    
+     end 
+     return 'A' * (k - seqint.length) + dna   
+    end
+
+    def dna2int(dna, base_number=4)
+      plus_int = 0
+      dna = dna.upcase
+      # This is plus strand position
+      dna.each_char.with_index do |base, index|
+        plus_int += D2I[base] * base_number ** (dna.length - 1 - index)
+      end
+      return plus_int
+    end
+
+    def split_pos(data)
+      # Split position data from SQLite3 database which generated by mfeindex
+      pos_hash = {}
+      data.split(';').each do |hit_record|
+        hit_id, hit_pos = hit_record.split(':')
+        pos_hash[hit_id.to_i] = hit_pos.split(',').collect {|pos| pos.to_i}
+      end
+
+      return pos_hash
+    end
+
+    def detect_kvalue(db_file)
+      db = SQLite3::Database.new(db_file)
+
+      begin
+        mer_num = db.execute("select count(*) from pos")[0][0]
+        kvalue = Math.log(mer_num, 4).to_i
+      rescue Exception => e
+        kvalue = 9
+      end
+      
+      return kvalue
+    end
+
+    def get_kvalue(db_list)
+      kmer_list = []
+      db_list.each do |db|
+        if db_indexed?(db)
+          kmer_list << detect_kvalue(db + DB_SQLITE3)
+        end
+      end
+      kmer_list.uniq!
+
+      kvalue = 9
+      
+      if kmer_list.size > 1
+        $stderr.puts "Different index kmer value among #{@opts.db}."
+        exit
+      elsif kmer_list.size == 1
+        kvalue = kmer_list[0]
+      else
+        kvalue = 9
+      end
+      kvalue
+    end
+    
+
+    def query_sqlite3(db_file, mer_id_list)
+      pos = {}
+      db = SQLite3::Database.new(db_file)
+      db.execute("select mer_id, plus, minus from pos where mer_id in (#{mer_id_list.join(', ')})") do |row|
+        mer_id, plus, minus = row
+        pos[mer_id] ||= {}
+        pos[mer_id][:plus] = split_pos(plus) unless plus.empty?
+        pos[mer_id][:minus] = split_pos(minus) unless minus.empty?
+      end
+
+      return pos
+    end
+  end
+end

data/lib/qu/mfeindex/data.rb

@@ -0,0 +1,24 @@
+module Qu
+  module Mfeindex
+    DB_JSON = '.uni'
+    DB_SQLITE3 = '.sqlite3.db'
+    DB_2BIT = '.2bit'
+    BIG_DB = '_BIG_MFE_DB'
+    BIG_DB_SPLIT_CUTOFF = 1024**3
+
+    D2I = {
+      'A' => 0, 
+      'T' => 3, 
+      'C' => 2, 
+      'G' => 1,
+      '-' => 4,  # For bubble, added by Zheyan Liu
+      0 => 'A',
+      1 => 'G',
+      2 => 'C',
+      3 => 'T',
+      4 => '-',  # For bubble, added by Zheyan Liu 
+    }
+        
+    ANTISENSE_CHARS = %w{A G C T -}
+  end
+end

data/lib/qu/mfeindex/version.rb

@@ -0,0 +1,5 @@
+module Qu
+  module Mfeindex
+    VERSION = "1.0.0"
+  end
+end

data/lib/qu/pymfeindex

@@ -0,0 +1,283 @@
+#!/usr/bin/env python
+from __future__ import division
+
+import os
+import sys
+import datetime
+from time import time
+from optparse import OptionParser
+import sqlite3
+
+import platform
+import subprocess
+import re
+
+
+D2n_dic = dict(A=0, T=3, C=2, G=1, a=0, t=3, c=2, g=1)
+n2D_dic = {0:'A', 3:'T', 2:'C', 1:'G', 0:'a', 3:'t', 2:'c', 1:'g'}
+
+def print_usage():
+    print '''
+%s: Index DB for MFEprimer-2.0
+
+Usage:
+
+    %s -f human.genomic -k 9 -o index_db_name
+
+Author: Wubin Qu <quwubin@gmail.com>
+Last updated: 2012-9-28
+    ''' % (os.path.basename(sys.argv[0]), os.path.basename(sys.argv[0]))
+
+def optget():
+    '''parse options'''
+    parser = OptionParser()
+    parser.add_option("-f", "--file", dest = "filename", help = "DNA file in fasta to be indexed")
+    parser.add_option("-k", "--k", dest = "k", type='int', help = "K mer , default is 9", default = 9)
+    parser.add_option("-o", "--out", dest = "out", help = "Index db file name")
+
+    (options, args) = parser.parse_args()
+
+    if not options.filename:
+        print_usage()
+        exit()
+
+    if not options.out:
+        options.out = options.filename + '.sqlite3.db'
+
+    return options
+
+def parse_fasta_format(fh):
+    '''
+    A Fasta-format Parser return Iterator
+    '''
+    # Remove the comment and blank lines before the first record
+    while True:
+        line = fh.readline()
+        if not line: return # Blank line
+
+        line = line.strip()
+
+        if line.startswith('>'):
+            break
+
+    while True:
+        if not line.startswith('>'):
+            raise ValueError("Records in Fasta files should start with '>' character")
+
+        id, sep, desc = line[1:].partition(' ')
+
+        seq_lines = []
+        line = fh.readline()
+        while True:
+            if not line: break
+
+            line = line.strip()
+
+            if line.startswith('>'):
+                break
+
+            if not line:
+                line = fh.readline()
+                continue
+
+            seq_lines.append(line.replace(' ', '').replace("\r", ''))
+            line = fh.readline()
+
+        yield (id, desc, ''.join(seq_lines))
+
+        if not line: return
+
+    assert False, 'Should not reach this line'
+
+def get_free_memory_percent():
+    if platform.system() == 'Darwin':
+        # Get process info
+        vm = subprocess.Popen(['vm_stat'], stdout=subprocess.PIPE).communicate()[0]
+        installed_memory = float(subprocess.Popen(['sysctl', '-n', 'hw.memsize'], stdout=subprocess.PIPE).communicate()[0])
+
+        # Process vm_stat
+        vmLines = vm.split('\n')
+        sep = re.compile(':[\s]+')
+        vmStats = {}
+        for row in range(1,len(vmLines)-2):
+            rowText = vmLines[row].strip()
+            rowElements = sep.split(rowText)
+            vmStats[(rowElements[0])] = int(rowElements[1].strip('\.')) * 4096
+
+        total_comsumed = vmStats["Pages wired down"] + vmStats["Pages active"] + vmStats["Pages inactive"]
+
+        return (installed_memory - total_comsumed) / installed_memory * 100
+
+    elif platform.system() == 'Linux':
+        items = subprocess.Popen(['free', '-m'], stdout=subprocess.PIPE).communicate()[0].splitlines()[1].strip().split()
+        free = float(items[3]) + float(items[5]) + float(items[6])
+        total = float(items[1])
+
+        return free / total * 100
+    else:
+        print "Sorry, currently only support Mac OS and Linux."
+        return 0
+
+
+def insert_db(conn, mer_count, plus, minus):
+    for mer_id in xrange(mer_count):
+        conn.execute("insert into pos (mer_id, plus, minus) values (?, ?, ?)", \
+                [mer_id, plus[mer_id], minus[mer_id]])
+
+    conn.commit()
+
+def update_db(conn, mer_count, plus, minus):
+    for mer_id in xrange(mer_count):
+        (plus_data, minus_data) = conn.execute("select plus, minus from pos where mer_id=?", [mer_id]).fetchone()
+        if plus_data:
+            if plus[mer_id]:
+                plus_data += ';%s' % plus[mer_id]
+            else:
+                pass
+        else:
+            plus_data = plus[mer_id]
+
+        if minus_data:
+            if minus[mer_id]:
+                minus_data += ';%s' % minus[mer_id]
+            else:
+                pass
+        else:
+            minus_data = minus[mer_id]
+
+        conn.execute("update pos set plus=?, minus=? where mer_id=?", \
+                [plus_data, minus_data, mer_id])
+
+    conn.commit()
+
+def baseN(num, b):
+    '''convert non-negative decimal integer n to
+    equivalent in another base b (2-36)'''
+    return ((num == 0) and  '0' ) or ( baseN(num // b, b).lstrip('0') + "0123456789abcdefghijklmnopqrstuvwxyz"[num % b])
+
+def int2DNA(num, k):
+    seq = baseN(num, 4)
+    return 'A' * (k-len(seq)) + (''.join([n2D_dic[int(base)] for base in seq]))
+
+def DNA2int_2(seq):
+    '''convert a sub-sequence/seq to a non-negative integer'''
+    plus_mer = 0
+    minus_mer = 0
+    length = len(seq) - 1
+    for i, letter in enumerate(seq):
+        plus_mer += D2n_dic[letter] * 4 ** (length - i)
+        minus_mer += (3 - D2n_dic[letter]) * 4 ** i
+
+    return plus_mer, minus_mer
+
+def DNA2int(seq):
+    '''convert a sub-sequence/seq to a non-negative integer'''
+    plus_mer = 0
+    length = len(seq) - 1
+    for i, letter in enumerate(seq):
+        plus_mer += D2n_dic[letter] * 4 ** (length - i)
+
+    return plus_mer
+
+def index(filename, k, dbname):
+    ''''''
+    start = time()
+
+    mer_count = 4**k
+
+    conn = sqlite3.connect(dbname)
+    cur = conn.cursor()
+    cur.executescript('''
+    drop table if exists pos;
+    create table pos(
+    mer_id integer primary key,
+    plus text,
+    minus text
+    );''')
+
+    plus = ['']*mer_count
+    minus = ['']*mer_count
+
+    is_empty = False
+    is_db_new = True
+
+    for record_id, record_desc, fasta_seq in parse_fasta_format(open(filename)):
+        is_empty = False
+        print record_id
+
+        #print 'Time used: ', time() - start
+
+        #plus_mer_list = [''] * mer_count
+        #minus_mer_list = [''] * mer_count
+        plus_mer_list = {}
+        minus_mer_list = {}
+
+        for i in xrange(len(fasta_seq)-k + 1):
+            #start = time()
+            kmer = fasta_seq[i:(i+k)]
+            #print kmer, i
+
+            try:
+                plus_mer_id, minus_mer_id = DNA2int_2(kmer)
+            except:
+                # Skip the unrecognized base, such as 'N'
+                continue
+
+            if plus_mer_list.has_key(plus_mer_id):
+                plus_mer_list[plus_mer_id] += ',%i' % (i+k-1)
+            else:
+                plus_mer_list[plus_mer_id] = str(i+k-1)
+
+            if minus_mer_list.has_key(minus_mer_id):
+                minus_mer_list[minus_mer_id] += ',%i' % (i)
+            else:
+                minus_mer_list[minus_mer_id] = str(i)
+
+
+        #print 'Index time used: ', time() - start
+        #start = time()
+        for mer_id, pos in plus_mer_list.items():
+            if plus[mer_id]:
+                plus[mer_id] += ';%s:%s' % (record_id, pos)
+            else:
+                plus[mer_id] = '%s:%s' % (record_id, pos)
+
+        for mer_id, pos in minus_mer_list.items():
+            if minus[mer_id]:
+                minus[mer_id] += ';%s:%s' % (record_id, pos)
+            else:
+                minus[mer_id] = '%s:%s' % (record_id, pos)
+
+        #print 'Merge time used: ', time() - start
+
+        memory_percent = get_free_memory_percent()
+        if memory_percent < 30:
+            if is_db_new:
+                insert_db(conn, mer_count, plus, minus)
+                is_db_new = False
+            else:
+                update_db(conn, mer_count, plus, minus)
+
+            # Empty the container
+            plus = ['']*mer_count
+            minus = ['']*mer_count
+            is_empty = True
+
+            print 'Empty plus and minus due to the memory problem.'
+
+    if not is_empty:
+        if is_db_new:
+            insert_db(conn, mer_count, plus, minus)
+        else:
+            update_db(conn, mer_count, plus, minus)
+
+    print "Time used: %s" % str(datetime.timedelta(seconds=(time() - start)))
+    print 'Done.'
+
+def main():
+    '''main'''
+    options = optget()
+    index(options.filename, options.k, options.out)
+
+if __name__ == "__main__":
+    main()

data/qu-mfeindex.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qu/mfeindex/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "qu-mfeindex"
+  spec.version       = Qu::Mfeindex::VERSION
+  spec.authors       = ["Wubin Qu"]
+  spec.email         = ["quwubin@gmail.com"]
+  spec.description   = %q{DNA sequence indexer originally developed for MFEprimer-2.0}
+  spec.summary       = %q{A DNA sequence idnexer}
+  spec.homepage      = "https://github.com/quwubin/qu-mfeindex"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'qu-utils', '~> 1.0'
+  spec.add_runtime_dependency 'qu-cmdwrapper', '~> 1.0'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: qu-mfeindex
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Wubin Qu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: qu-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: qu-cmdwrapper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DNA sequence indexer originally developed for MFEprimer-2.0
+email:
+- quwubin@gmail.com
+executables:
+- mfeindex
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/mfeindex
+- lib/qu/mfeindex.rb
+- lib/qu/mfeindex/data.rb
+- lib/qu/mfeindex/version.rb
+- lib/qu/pymfeindex
+- qu-mfeindex.gemspec
+homepage: https://github.com/quwubin/qu-mfeindex
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: A DNA sequence idnexer
+test_files: []