WingenderTFClass 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a5b5fa62fdeb9e8e624a9e63964f0886d135ddcb
+  data.tar.gz: 11372a9c59c0c627664e01faaab77fc3a212ca3e
+SHA512:
+  metadata.gz: e6c05b7b6670ec5b00a78524c00ebd4c0780552ae8c5539ad0f33925bd696e5987a5a4f84ceba4e09ea63f0de2ea907aa7d1f7fcdbde19310c8f3a70e7556694
+  data.tar.gz: 0c2168abdd84f9cc32818c60f1dd8dcc03ba062b10921ed018c142bc585492c670ead58b547ebcdc88f77c3a76348e8d2b8101d45538e6176cea012d48060911

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in WingenderTFClass.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# WingenderTFClass
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/WingenderTFClass`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'WingenderTFClass'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install WingenderTFClass
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/WingenderTFClass.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/WingenderTFClass.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'WingenderTFClass/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "WingenderTFClass"
+  spec.version       = WingenderTFClass::VERSION
+  spec.authors       = ["prijutme4ty"]
+  spec.email         = ["prijutme4ty@gmail.com"]
+
+  spec.summary       = %q{Gem to acquire TFClass protein class/family/subfamily/etc for a transcription factor by its UniprotID.}
+  spec.description   = %q{This gem allows to retrieve information for a transcription factor from Wingender's TFClass ontology.}
+  spec.homepage      = "https://github.com/VorontsovIE/WingenderTFClass"
+
+  # # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "WingenderTFClass"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/WingenderTFClass.rb

@@ -0,0 +1,6 @@
+require_relative "WingenderTFClass/version"
+require_relative "WingenderTFClass/motif_family_recognizer"
+
+module WingenderTFClass
+  # Your code goes here...
+end

data/lib/WingenderTFClass/motif_family_recognizer.rb

@@ -0,0 +1,96 @@
+require_relative 'obo/tf_classification'
+require_relative 'uniprot_info'
+
+module WingenderTFClass
+  module FilePaths
+    TFOntologyHuman = File.absolute_path('source_data/TFOntologies/TFClass_human.obo', __dir__)
+    TFOntologyMouse = File.absolute_path('source_data/TFOntologies/TFClass_mouse.obo', __dir__)
+
+    UniprotHuman = File.absolute_path('source_data/uniprot_infos/human.tsv', __dir__)
+    UniprotMouse = File.absolute_path('source_data/uniprot_infos/mouse.tsv', __dir__)
+  end
+
+
+  module ProteinFamilyRecognizers
+    def self.by_uniprot_id(deepness:, tf_classification_filename:, uniprot_infos_filename:)
+      tf_classification = OBO::TFClassification.from_file(tf_classification_filename)
+      ByUniprotID.new(
+        ByUniprotAC.new(tf_classification, deepness),
+        UniprotInfo.uniprot_ac_list_by_id_from_file(uniprot_infos_filename)
+      )
+    end
+    HumanAtLevel = Hash.new{|h, deepness|
+      h[deepness] = self.by_uniprot_id(
+        deepness: deepness,
+        tf_classification_filename: FilePaths::TFOntologyHuman,
+        uniprot_infos_filename: FilePaths::UniprotHuman,
+      )
+    }
+
+    MouseAtLevel = Hash.new{|h, deepness|
+      h[deepness] = self.by_uniprot_id(
+        deepness: deepness,
+        tf_classification_filename: FilePaths::TFOntologyMouse,
+        uniprot_infos_filename: FilePaths::UniprotMouse,
+      )
+    }
+    
+    class ByUniprotAC
+      def initialize(tf_classification, deepness)
+        @deepness = deepness
+        @tf_classification = tf_classification
+      end
+
+      def subtree_groups
+        @subtree_groups ||= @tf_classification.tf_groups(@deepness)
+      end
+
+      private def subtree_root_by_uniprot_ac
+        @subtree_root_by_uniprot_id ||= begin
+          result = Hash.new{|h,k| h[k] = [] }
+
+          subtree_groups.each{|group_root, group_leafs|
+            group_leafs.flat_map(&:uniprot_ACs).uniq.each{|uniprot_ac|
+              result[uniprot_ac] << group_root
+            }
+          }
+          result
+        end
+      end
+
+      # In most cases Uniprot refers the only leaf, but in some cases it refers several leafs in different subtrees.
+      # So we return an array of subfamilies
+      def subfamilies_by_uniprot_ac(uniprot_ac)
+        subtree_root_by_uniprot_ac[uniprot_ac]
+      end
+
+      def subfamilies_by_multiple_uniprot_acs(uniprot_acs)
+        uniprot_acs.flat_map{|uniprot_ac|
+          subfamilies_by_uniprot_ac(uniprot_ac)
+        }.uniq
+      end
+    end
+
+    #########################
+
+    class ByUniprotID
+      def initialize(motif_family_recognizer_by_uniprot_ac, uniprot_acs_by_id)
+        @motif_family_recognizer_by_uniprot_ac = motif_family_recognizer_by_uniprot_ac
+        @uniprot_acs_by_id = uniprot_acs_by_id
+      end
+
+      # In most cases Uniprot refers the only leaf, but in some cases it refers several leafs in different subtrees.
+      # So we return an array of subfamilies
+      def subfamilies_by_uniprot_id(uniprot_id)
+        uniprot_acs = @uniprot_acs_by_id[uniprot_id]
+        @motif_family_recognizer_by_uniprot_ac.subfamilies_by_multiple_uniprot_acs( uniprot_acs )
+      end
+
+      def subfamilies_by_multiple_uniprot_ids(uniprot_ids)
+        uniprot_ids.flat_map{|uniprot_id|
+          subfamilies_by_uniprot_id(uniprot_id)
+        }.uniq
+      end
+    end
+  end
+end

data/lib/WingenderTFClass/obo/term.rb

@@ -0,0 +1,110 @@
+module WingenderTFClass
+  module OBO
+    Term = Struct.new(:ontology_tree, :id, :name, :subset, :definition, :parent_id, :uniprot_ACs, :other) do
+      def self.from_line_array(ontology_tree, arr)
+        id, name, subset, definition, parent_id = nil, nil, nil, nil, nil
+        other = []
+        uniprot_ACs = []
+
+        arr.select{|line|
+          line.match(/^\w+:/)
+        }.each{|line|
+          case line
+          when /^id:/
+            id = line[/^id: (?<data>.+)$/, :data]
+          when /^name:/
+            name = line[/^name: (?<data>.+)$/, :data]
+          when /^subset:/
+            subset = line[/^subset: (?<data>.+)$/, :data]
+          when /^def:/
+            definition = line[/^def: (?<data>.+)$/, :data]
+          when /^is_a:/
+            parent_id = line[/^is_a: (?<data>.+?) ! .+$/, :data]
+          when /^xref: UNIPROT:/
+            uniprot_ACs << line[/^xref: UNIPROT:(?<data>\w+)\b/, :data]
+          else
+            other << line
+          end
+        }
+
+        self.new(ontology_tree, id, name, subset, definition, parent_id || '', uniprot_ACs, other)
+      end
+
+      def parent
+        ontology_tree.term(parent_id)
+      end
+
+      def <=>(other)
+        if self.id.split('.').first == '0' && other.id.split('.').first == '0' # unclassified vs unclassified
+          id <=> other.id
+        elsif !self.id.split('.').first == '0' && !other.id.split('.').first == '0' # classified vs classified
+          id <=> other.id
+        elsif self.id.split('.').first == '0' # classified vs unclassified
+          1
+        else
+          -1
+        end
+      end
+
+      def children
+        ontology_tree.children(id)
+      end
+
+      def leaf?
+        ontology_tree.leaf?(id)
+      end
+
+      # It can be different from number of ancestors
+      def deepness
+        id.split('.').size
+      end
+
+      def descendant_leafs
+        leaf? ? [self] : children.flat_map(&:descendant_leafs)
+      end
+
+      def descendants
+        children + children.flat_map(&:descendants)
+      end
+
+      def subtree_nodes
+        [self] + children.flat_map(&:subtree_nodes)
+      end
+
+      def ancestors
+        result = []
+        term = self
+        while term.parent
+          term = term.parent
+          result.unshift(term)
+        end
+        result
+      end
+
+      def level_name
+        case deepness
+        when 0
+          'all TFs'
+        when 1
+          'superclass'
+        when 2
+          'class'
+        when 3
+          'family'
+        when 4
+          'subfamily'
+        when 5
+          'genus'
+        when 6
+          'species'
+        end
+      end
+
+      def to_s
+        "#{name}{#{id}}"
+      end
+
+      def inspect; to_s; end
+    end
+  end
+end

data/lib/WingenderTFClass/obo/tf_classification.rb

@@ -0,0 +1,69 @@
+require_relative 'term'
+module WingenderTFClass
+  module OBO
+    class TFClassification
+      # terms by ids
+      def initialize()
+        @terms_by_id = {}
+        @children_by_id = Hash.new{|h,k| h[k] = [] }
+        @terms_by_name = Hash.new{|h,k| h[k] = [] }
+        # @terms_by_id.each{|term_id, term|
+        #   @children_by_id[term.parent_id] << term  if term.parent_id
+        # }
+        self << Term.new(self, '', '', 'Root', '', nil, [], [])
+      end
+
+      def <<(term)
+        raise "Duplicate id #{term.id}"  if @terms_by_id[term.id]
+        @terms_by_id[term.id] = term
+        @terms_by_name[term.name] << term
+        @children_by_id[term.parent_id] << term  if term.parent_id
+      end
+
+      def self.from_file(filename)
+        tf_ontology = self.new
+        terms = File.readlines(filename)
+          .map(&:chomp)
+          .slice_before{|line|
+            line.start_with?('[Term]')
+          }.drop(1)
+          .map{|enumerator|
+             Term.from_line_array(tf_ontology, enumerator.to_a)
+          }
+        terms.each{|term|
+          tf_ontology << term
+        }
+        tf_ontology
+      end
+
+      def term_by_name(name)
+        @terms_by_name[name]
+      end
+
+      def term(term_id)
+        @terms_by_id[term_id]
+      end
+
+      def children(term_id)
+        @children_by_id[term_id]
+      end
+
+      def root
+        term('')
+      end
+
+      def leaf?(term_id)
+        raise "Term #{term_id} does not exist"  unless @terms_by_id[term_id]
+        @children_by_id[term_id].empty?
+      end
+
+      def tf_groups(slice_deepness)
+        @terms_by_id.each_value.select{|term|
+          term.deepness >= slice_deepness && (!term.parent || term.parent.deepness < slice_deepness)
+        }.map{|term|
+          [term, term.subtree_nodes]
+        }.to_h
+      end
+    end
+  end
+end

data/lib/WingenderTFClass/rake/WingenderClassification.rake

@@ -0,0 +1,64 @@
+require 'rake'
+require 'rake/clean'
+
+task default: 'WingenderTFClass'
+desc 'Download Wingender TFClass ontology'
+task 'WingenderTFClass' => ['WingenderTFClass:download_tfclass', 'WingenderTFClass:download_uniprot_id_ac_mapping']
+
+desc 'Download Wingender ontology files'
+task 'WingenderTFClass:download_tfclass' => ['WingenderTFClass:download_tfclass:human', 'WingenderTFClass:download_tfclass:mouse']
+task 'WingenderTFClass:download_tfclass:human' => 'source_data/TFOntologies/TFClass_human.obo'
+task 'WingenderTFClass:download_tfclass:mouse' => 'source_data/TFOntologies/TFClass_mouse.obo'
+
+directory 'source_data'
+directory 'source_data/uniprot_infos/'
+directory 'source_data/TFOntologies/'
+
+file 'source_data/TFClass_ontologies_temp.zip' => 'source_data' do
+  sh 'wget', 'http://tfclass.bioinf.med.uni-goettingen.de/suplementary/TFClass_ontologies.zip', '-O', 'source_data/TFClass_ontologies_temp.zip'
+end
+
+file 'source_data/TFOntologies/TFClass_human.obo' => ['source_data/TFOntologies/', 'source_data/TFClass_ontologies_temp.zip'] do
+  sh 'unzip', 'source_data/TFClass_ontologies_temp.zip', 'TFClass_human.obo', '-d', 'source_data/TFOntologies/'
+end
+
+file 'source_data/TFOntologies/TFClass_mouse.obo' => ['source_data/TFOntologies/', 'source_data/TFClass_ontologies_temp.zip'] do
+  sh 'unzip', 'source_data/TFClass_ontologies_temp.zip', 'TFClass_mouse.obo', '-d', 'source_data/TFOntologies/'
+end
+
+
+
+desc 'Download Uniprot ID-AC mapping'
+task 'WingenderTFClass:download_uniprot_id_ac_mapping'
+
+{'human' => 'Homo sapiens', 'mouse' => 'Mus musculus'}.each do |organism, organism_official_name|
+  task 'WingenderTFClass:download_uniprot_id_ac_mapping' => "source_data/uniprot_infos/#{organism}.tsv"
+  file "source_data/uniprot_infos/#{organism}.tsv" => "source_data/uniprot_infos/#{organism}.tsv.gz" do
+    sh 'gzip', '--decompress', "source_data/uniprot_infos/#{organism}.tsv.gz"
+  end
+
+  file "source_data/uniprot_infos/#{organism}.tsv.gz" => 'source_data/uniprot_infos/' do
+    query = 'organism:"%{organism}"' % {organism: organism_official_name}
+    columns = ['id', 'entry name' ] # id - is uniprot_ac; entry_name is uniprot_id. Orwell DB
+
+    options = {
+      sort: 'score',
+      desc: '',
+      compress: 'yes',
+      query: query,
+      fil: '',
+      format: 'tab',
+      force: 'yes',
+      columns: columns.join(','),
+    }
+    options_str = options.map{|k,v| "#{k}=#{v}" }.join('&')
+
+    sh 'wget', "http://www.uniprot.org/uniprot/?#{options_str}", '-O', "source_data/uniprot_infos/#{organism}.tsv.gz"
+  end
+end
+
+CLEAN << 'source_data/uniprot_ID_to_AC.tsv.gz'
+CLEAN << 'source_data/TFClass_ontologies_temp.zip'
+
+CLOBBER << 'source_data/uniprot_ID_to_AC.tsv'
+CLOBBER << 'source_data/TFOntologies/*'