solvebio 1.6.1 → 1.7.0

data/lib/filter.rb

@@ -1,312 +0,0 @@
-# -*- coding: utf-8 -*-
-require_relative 'main'
-
-# SolveBio::Filter objects.
-#
-# Makes it easier to create filters cumulatively using ``&`` (and),
-# ``|`` (or) and ``~`` (not) operations.
-#
-# == Example
-#
-#     require 'solvebio'
-
-#     f =  SolveBio::Filter.new                       #=> <Filter []>
-
-#     f &= SolveBio::Filter.new :price => 'Free'      #=> <Filter [[:price, "Free"]]>
-
-#     f |= SolveBio::Filter.new :style => 'Mexican'   #=> <Filter [{:or=>[[:price, "Free"], [:style, "Mexican"]]}]>
-#
-# The final result is a filter that can be used in a query which match es
-# "price = 'Free' or style = 'Mexican'".
-#
-# By default, each key/value pairs are AND'ed together. However, you can change that
-# to OR by passing in +:or+ as the last argument.
-#
-#     * `<field>='value` matches if the field is term filter (exact term)
-#     * `<field>__in=[<item1>, ...]` matches any of the terms <item1> and so on
-#     * `<field>__range=[<start>, <end>]` matches anything from <start> to <end>
-#     * `<field>__between=[<start>, <end>]` matches anything between <start> to <end> not include either <start> or <end>
-#
-# String terms are not analyzed and are always assumed to be exact matches.
-#
-# Numeric columns can be selected by range using:
-#
-#     * `<field>__gt`: greater than
-#     * `<field>__gte`: greater than or equal to
-#     * `<field>__lt`: less than
-#     * `<field>__lte`: less than or equal to
-#
-# Field action examples:
-#
-#     dataset.query(:gene__in  => ['BRCA', 'GATA3'],
-#                   :chr       => '3',
-#                   :start__gt => 10000,
-#                   :end__lte  => 20000)
-
-class SolveBio::Filter
-
-    attr_accessor :filters
-
-    # Creates a new Filter, the first argument is expected to be Hash or an Array.
-    def initialize(filters={}, conn=:and)
-        if filters.kind_of?(Hash)
-            @filters = SolveBio::Filter.
-                normalize(filters.keys.sort.map{|key| [key,  filters[key]]})
-        elsif filters.kind_of?(Array)
-            @filters = SolveBio::Filter.normalize(filters)
-        elsif filters.kind_of?(SolveBio::Filter)
-            @filters = SolveBio::Filter.deep_copy(filters.filters)
-            return self
-        else
-            raise TypeError, "Invalid filter type #{filters.class}"
-        end
-        @filters = [{conn => @filters}] if filters.size > 1
-        self
-    end
-
-    def inspect
-        return "<SolveBio::Filter #{@filters.inspect}>"
-    end
-
-    def empty?
-        @filters.empty?
-    end
-
-    # Deep copy
-    def clone
-        SolveBio::Filter.deep_copy(self)
-    end
-
-    # OR and AND will create a new Filter, with the filters from both Filter
-    #   objects combined with the connector `conn`.
-    # FIXME: should we allow a default conn parameter?
-    def combine(other, conn=:and)
-
-        return other.clone if self.empty?
-
-        if other.empty?
-            return self.clone
-        elsif self.filters[0].member?(conn)
-            f = self.clone
-            f.filters[0][conn] += other.filters
-        elsif other.filters[0].member?(conn)
-            f = other.clone
-            f.filters[0][conn] += self.filters
-        else
-            f = initialize(self.clone.filters + other.filters, conn)
-        end
-
-        return f
-    end
-
-    def |(other)
-        return self.combine(other, :or)
-    end
-
-    def &(other)
-        return self.combine(other, :and)
-    end
-
-    def ~()
-        f = self.clone
-
-        # not of null filter is null fiter
-        return f if f.empty?
-
-        # length of self_filters should never be more than 1
-        filters = f.filters.first
-        if filters.kind_of?(Hash) and
-            filters.member?(:not)
-            # The filters are already a single dictionary
-            # containing a 'not'. Swap out the 'not'
-            f.filters = [filters[:not]]
-        else
-            # 'not' blocks can contain only dicts or a single tuple filter
-            # so we get the first element from the filter list
-            f.filters = [{:not => filters}]
-        end
-
-        return f
-    end
-
-    # Checks and normalizes filter array tuples
-    def self.normalize(ary)
-        ary.map do |tuple|
-            unless tuple.kind_of?(Array)
-                raise(TypeError,
-                      "Invalid filter element #{tuple.class}; want Array")
-            end
-            unless tuple.size == 2
-                raise(TypeError,
-                      "filter element size must be 2; is #{tuple.size}")
-            end
-            key, value = tuple
-            if key.to_s =~ /.+__(.+)$/
-                op = $1
-                unless %w(gt gte lt lte in range between).member?(op)
-                    raise(TypeError,
-                          "Invalid field operation #{op} in #{key}")
-                end
-                case op
-                when 'gt', 'gte', 'lt', 'lte'
-                    begin
-                        value = Float(value)
-                    rescue
-                        raise(TypeError,
-                              "Invalid field value #{value} for #{key}; " +
-                              "should be a number")
-                    end
-                    tuple = [key, value]
-                when 'range', 'between'
-                    if value.kind_of?(Range)
-                        value = [value.min, value.max]
-                    end
-                    unless value.kind_of?(Array)
-                        raise(TypeError,
-                              "Invalid field value #{value} for #{key}; " +
-                              "should be an array")
-                    end
-                    unless value.size == 2
-                        raise(TypeError,
-                              "Invalid field value #{value} for #{key}; " +
-                              "array should have exactly two values")
-                    end
-                    if value.first > value.last
-                        raise(IndexError,
-                              "Invalid field value #{value} for #{key}; " +
-                              "start value not greater than end value")
-                    end
-
-                    # FIXME: Should we check that value contains only numbers?
-                    tuple = [key, value]
-                when 'in'
-                    unless value.kind_of?(Array)
-                        raise(TypeError,
-                              "Invalid field value #{value} for #{key}; " +
-                              "should be an array")
-                    end
-
-                end
-            end
-            tuple
-        end
-    end
-
-    def self.deep_copy(obj)
-        Marshal.load(Marshal.dump(obj))
-    end
-
-    # Takes an Array of filter items and returns an Array that can be
-    # passed off (when converted to JSON) to a SolveBio client filter
-    # parameter. As such, the output format is highly dependent on
-    # the SolveBio API format.
-    #
-    # The filter items can be either a SolveBio::Filter, or Hash of
-    # the right form, or an Array of the right form.
-    def self.process_filters(filters)
-        rv = []
-        filters.each do |f|
-            if f.kind_of?(SolveBio::Filter)
-                if f.filters
-                    rv << process_filters(f.filters)
-                    next
-                end
-            elsif f.kind_of?(Hash)
-                key = f.keys[0]
-                val = f[key]
-
-                if val.kind_of?(Hash)
-                    filter_filters = process_filters(val)
-                    if filter_filters.size == 1
-                        filter_filters = filter_filters[0]
-                    end
-                    rv << {key => filter_filters}
-                else
-                    rv << {key => process_filters(val)}
-                end
-            elsif f.kind_of?(Array)
-                rv << f
-            else
-                raise TypeError, "Invalid filter class #{f.class}"
-            end
-        end
-        return rv
-    end
-
-
-end
-
-# Helper class that generates Range Filters from UCSC-style ranges.
-class SolveBio::RangeFilter < SolveBio::Filter
-    SUPPORTED_BUILDS = ['hg18', 'hg19', 'hg38']
-
-    #    Handles UCSC-style range queries (hg19:chr1:100-200)
-    def self.from_string(string, overlap=false)
-        begin
-            build, chromosome, pos = string.split(':')
-        rescue ValueError
-            raise ValueError,
-                'Please use UCSC-style format: "hg19:chr2:1000-2000"'
-        end
-
-        if pos.member?('-')
-            start, last = pos.replace(',', '').split('-')
-        else
-            start = last = pos.replace(',', '')
-        end
-
-        return self.new(build, chromosome, start, last, overlap=overlap)
-    end
-
-    #  Shortcut to do range queries on supported datasets.
-    def initialize(build, chromosome, start, last, overlap=false)
-        if !SUPPORTED_BUILDS.member?(build.downcase)
-            msg = "Build #{build} not supported for range filters. " +
-                "Supported builds are: #{SUPPORTED_BUILDS.join(', ')}"
-            raise Exception, msg
-        end
-
-        f = SolveBio::Filter.new({"#{build}_start__range" => [start, last]})
-
-        if overlap
-            f |=  SolveBio::Filter.
-                new({"#{build}_end__range" => [start, last]})
-        else
-            f &= SolveBio::Filter.
-                new({"#{build}_end__range" => [start, last]})
-        end
-
-        f &= SolveBio::Filter.
-            new({"#{build}_chromosome" => chromosome.sub('chr', '')})
-        @filters = f.filters
-    end
-
-    def inspect
-        return "<RangeFilter #{@filters}>"
-    end
-end
-
-
-# Demo/test code
-if __FILE__ == $0
-    filters =
-        SolveBio::Filter.new(:omim_id => 144650) |
-        SolveBio::Filter.new(:omim_id => 144600) |
-        SolveBio::Filter.new(:omim_id => 145300)
-    puts filters.inspect
-    puts SolveBio::Filter.process_filters([[:omim_id, nil]]).inspect
-    f = SolveBio::Filter.new
-    puts "%s, empty?: %s" % [f.inspect, f.empty?]
-    f_not = ~f
-    puts "%s, empty?: %s" % [f_not.inspect, f_not.empty?]
-    f2 = SolveBio::Filter.new({:style => 'Mexican', :price => 'Free'})
-    puts "%s, empty? %s" % [f2.inspect, f2.empty?]
-    f2_not = ~f2
-    puts "%s, empty? %s" % [f2_not.inspect, f2_not.empty?]
-    # FIXME: using a hash means we can't repeat chr1. Is this intended?
-    f2_or = SolveBio::Filter.new({:chr1 => '3', :chr2 => '4'}, :or)
-    puts "%s, empty %s" % [f2_or.inspect, f2_or.empty?]
-    f2_or = SolveBio::Filter.new({:chr1 => '3'}) | SolveBio::Filter.new({:chr2 => '4'})
-    puts "%s, empty %s" % [f2_or.inspect, f2_or.empty?]
-    puts((f2_or & f2).inspect)
-end

data/lib/locale.rb

@@ -1,47 +0,0 @@
-require_relative 'main'
-module SolveBio::Locale
-
-    # Used only if r18n-core is not around
-    @thousands_sep  = ','
-    @locale = ENV['LANG'] || ENV['LC_NUMERIC'] || 'en_US.UTF-8'
-    def thousands_sep
-        @thousands_sep
-    end
-    def thousands_sep=(value)
-        @thousands_sep = value
-    end
-
-    begin
-        old_verbose = $VERBOSE
-        $VERBOSE = false
-        require 'r18n-core'
-        R18n.set(@locale)
-        $VERBOSE = old_verbose
-        have_r18n = true
-    rescue LoadError
-        have_r18n = false
-    end
-    if have_r18n
-        def pretty_int(num)
-            R18n::l(num)
-        end
-    else
-        def pretty_int(num)
-            num.to_s.reverse.scan(/\d{1,3}/).join(@thousands_sep).reverse
-        end
-    end
-
-    module_function :pretty_int
-
-end
-
-class Fixnum
-    include SolveBio::Locale
-    def pretty_int
-        SolveBio::Locale.pretty_int(self)
-    end
-end
-
-if __FILE__ == $0
-    puts 10000.pretty_int
-end

data/lib/main.rb

@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-# SolveBio Ruby Client
-# ~~~~~~~~~~~~~~~~~~~
-#
-# This is the Ruby client & library for the SolveBio API.
-#
-# Have questions or comments? email us at: contact@solvebio.com
-
-require 'logger'
-require 'fileutils'
-
-module SolveBio
-
-    VERSION      = '1.6.1'
-    @api_key     = ENV['SOLVEBIO_API_KEY']
-    logfile      =
-        if ENV['SOLVEBIO_LOGFILE']
-            ENV['SOLVEBIO_LOGFILE']
-        else
-            dir = File::expand_path '~/.solvebio'
-            FileUtils.mkdir_p(dir) unless File.exist? dir
-            File::expand_path File.join(dir, 'solvebio.log')
-        end
-    @logger      = Logger.new(logfile)
-    API_HOST     = ENV['SOLVEBIO_API_HOST'] || 'https://api.solvebio.com'
-
-    # Config info in reports and requests. Encapsulate more?
-    RUBY_VERSION         = RbConfig::CONFIG['RUBY_PROGRAM_VERSION']
-    RUBY_IMPLEMENTATION  = RbConfig::CONFIG['RUBY_SO_NAME']
-    #PLATFORM            = ???
-    #PROCESSOR           = ???
-    ARCHITECTURE         = RbConfig::CONFIG['arch']
-
-    def logger
-        @logger
-    end
-    def api_key
-        @api_key
-    end
-    def api_key=(value)
-        @api_key = value
-    end
-
-    module_function :logger, :api_key, :api_key=
-
-end

data/lib/query.rb

@@ -1,414 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'pp'
-require_relative 'client'
-require_relative 'filter'
-require_relative 'locale'
-require_relative 'tabulate'
-
-# A Query API request wrapper that generates a request from Filter
-# objects, and can iterate through streaming result sets.
-class SolveBio::PagingQuery
-
-    include Enumerable
-
-    MAXIMUM_LIMIT ||= 100
-
-    attr_accessor :filters
-    attr_reader   :dataset_id
-
-    def initialize(dataset_id, params={})
-        @dataset_id = dataset_id
-
-        begin
-            @limit = Integer(dataset_id)
-        rescue
-            raise TypeError, "'dataset_id' parameter must an Integer"
-        end
-
-        @data_url = "/v1/datasets/#{dataset_id}/data"
-
-        @total = @results = @response = nil
-        reset_range_window
-
-        # results per request
-        @limit = MAXIMUM_LIMIT
-        begin
-            @limit = Integer(params[:limit])
-        rescue
-            raise TypeError, "'limit' parameter must an Integer >= 0"
-        end if params.member?(:limit)
-
-        @result_class = params[:result_class] || Hash
-        @debug = params[:debug] || false
-        @fields = params[:fields]
-        @filters = []
-
-        # parameter error checking
-        if @limit < 0
-            raise RangeError, "'limit' parameter must be >= 0"
-        end
-        self
-    end
-
-    def total
-        warmup('Query total')
-        @total = @response["total"]
-    end
-
-    def clone(filters=[])
-        result =
-            initialize(@dataset_id,
-                       {
-                           :limit => @limit,
-                           :total => total,  # This causes an HTTP request
-                           :result_class => @result_class,
-                           :debug => @debug,
-                           :fields => @fields
-                       })
-
-        result.filters += @filters unless @filters.empty?
-        result.filters += filters unless filters.empty?
-
-        return result
-    end
-
-    # Returns this Query instance with the query args combined with
-    # existing set with AND.
-    #
-    # kwargs are simply passed to a new SolveBio::Filter object and
-    # combined to any other filters with AND.
-    #
-    # By default, everything is combined using AND. If you provide
-    # multiple filters in a single filter call, those are ANDed
-    # together. If you provide multiple filters in multiple filter
-    # calls, those are ANDed together.
-    #
-    # If you want something different, use the F class which supports
-    # ``&`` (and), ``|`` (or) and ``~`` (not) operators. Then call
-    # filter once with the resulting Filter instance.
-    def filter(params={}, conn=:and)
-        if filters.kind_of?(SolveBio::Filter)
-            return Marshal.load(Marshal.dump(params.filters))
-        else
-            return clone(SolveBio::Filter.new(params, conn).filters)
-        end
-    end
-
-    # Shortcut to do range queries on supported datasets.
-    def range(chromosome, start, last, strand=nil, overlap=true)
-        # TODO: ensure dataset supports range queries?
-        return self.
-            clone([self.new(chromosome, start, last, strand, overlap)])
-    end
-
-    def size
-        warmup('PagingQuery size')
-        return @total
-    end
-    alias_method :length, :size
-
-    def empty?
-        warmup('empty?')
-        return @total == 0
-    end
-
-    # Convert SolveBio::QueryPaging object to a String type
-    def to_s
-        if total == 0 or @limit == 0
-            return 'query returned 0 results'
-        end
-
-        sorted_items = SolveBio::Tabulate.
-            tabulate(self[0].to_a.sort_by{|x| x[0]})
-        msg =
-            "\n%s\n\n... %s more results." %
-            [sorted_items, ['Fields', 'Data'], ['right', 'left'],
-             (@total - 1).pretty_int]
-        return msg
-    end
-
-    def to_pp
-        if total == 0 or @limit == 0
-            return 'query returned 0 results'
-        end
-        msg = "\n#{self[0].pretty_inspect}\n" +
-            "\n... #{(@total-1).pretty_int} more results."
-        return msg
-    end
-
-    # Convert SolveBio::QueryPaging object to a Hash type
-    def to_h
-        self[0]
-    end
-
-    def inspect
-        return '<%s: @dataset_id=%s, @total=%s, @limit=%s, @debug=%s>' %
-            [self.class, @dataset_id, @total ? @total : '?',
-             @limit, @debug]
-    end
-
-    # warmup result set...
-    def warmup(what)
-        unless @response
-            SolveBio::logger.debug("warmup #{what}")
-            execute
-        end
-    end
-
-
-    # FIXME: consider creating instance variables from
-    # a response object and then using attr_reader to make that
-    # visible. This is instead of:
-    # # One hacky way to define attributes (methods) on an object.
-    # # Replaces Python's __getattr__
-    # def method_missing(meth, *args, &block)
-    #     if @response.nil?
-    #         logger.debug('warmup ([]): %s' % key)
-    #         execute
-    #     end
-
-    #     if @response.member?(meth)
-    #         return @response[meth]
-    #     end
-
-    #     msg = "'%s' object has no attribute '%s'" % [self.class, meth]
-    #     raise NoMethodError, msg
-    # end
-
-    # Retrieve an item or range from the set of results
-    def [](key)
-        # warmup result set...
-        warmup("[#{key}]")
-
-        unless [Range, Fixnum].member?(key.class)
-            raise TypeError, "Expecting index value to be a Range or Fixnum; is #{key.class}"
-        end
-        if @limit < 0
-            raise IndexError, 'Indexing not supporting when limit < 0.'
-        end
-        if key.kind_of?(Range)
-            if key.begin < 0 or key.end < 0
-                raise IndexError, 'Negative indexing is not supported'
-            end
-            if key.begin > key.end
-                raise IndexError, 'Backwards indexing is not supported'
-            end
-        elsif key < 0
-            raise IndexError, 'Negative indexing is not supported'
-        end
-
-        # FIXME: is it right that we can assume that the results are in
-        # @results. Do I need another index check?
-
-        result =
-            if key.kind_of?(Range)
-                @results[(0...key.end - key.begin)]
-            else
-                @request_range = self.to_range(key)
-                @results[0]
-            end
-        # reset request range
-        @request_range = (0..Float::INFINITY)
-        return result
-    end
-
-    # "each" must be defined in an Enumerator. Allows the Query object
-    # to be an iterable. Iterates through the internal cache using a
-    # cursor.
-    def each(*pass)
-        return self unless block_given?
-        i = 0
-
-        @delta = @request_range.end - @request_range.begin
-        while i < total and i < @delta
-            i_offset = i + @request_range.begin
-            if @window_range.include?(i_offset)
-                result_start = i_offset - @window_range.begin
-                SolveBio::logger.debug('  PagingQuery window range: [%s...%s]' %
-                                       [result_start, result_start + 1])
-            else
-                SolveBio::logger.debug('executing query. offset/limit: %6d/%d' %
-                                       [i_offset, @limit])
-                execute({:offset => i_offset, :limit => @limit})
-                result_start = i % @limit
-            end
-            yield @results[result_start]
-            @delta = @request_range.end - @request_range.begin
-            i += 1
-        end
-        return self
-    end
-
-    # range operations
-    def to_range(range_or_idx)
-        return range_or_idx.kind_of?(Range) ? range_or_idx :
-            (range_or_idx..range_or_idx + 1)
-    end
-
-    def reset_request_range
-        @request_range = (0..Float::INFINITY)
-    end
-
-    def reset_range_window
-        @window = []
-        @window_range = (0..Float::INFINITY)
-        reset_request_range
-    end
-
-    def build_query
-        q = {
-            :limit => @limit,
-            :debug => @debug
-        }
-
-        if @filters
-            filters = SolveBio::Filter.process_filters(@filters)
-            if filters.size > 1
-                q[:filters] = [{:and => filters}]
-            else
-                q[:filters] = filters
-            end
-        end
-
-        if @fields
-            q[:fields] = @fields
-        end
-
-        return q
-    end
-
-    # Executes a query and returns the request parameters and response.
-    def execute(params={})
-        _params = build_query()
-        _params.merge!(params)
-        SolveBio::logger.debug("querying dataset: #{_params}")
-
-        @response = SolveBio::Client.client.post(@data_url, _params)
-        @total    = @response['total']
-        SolveBio::logger.
-            debug("query response took: #{@response['took']} ms, " +
-                  "total: #{@total}")
-
-        # update window
-        offset = _params[:offset] || 0
-        @results = @response['results']
-        @window = @results
-        @window_range = (offset ... offset + @results.size)
-
-        return _params, @response
-    end
-end
-
-class SolveBio::Query < SolveBio::PagingQuery
-    def initialize(dataset_id, params={})
-        super
-        return self
-    end
-
-    def total
-        warmup('Query total')
-        @total
-    end
-
-    def size
-        warmup('Query size')
-        [@total, @results.size].min
-    end
-    alias_method :length, :size
-
-    # "each" must be defined in an Enumerator. Allows the Query object
-    # to be an iterable. Iterates through the internal cache using a
-    # cursor.
-    def each(*pass)
-        return self unless block_given?
-        i = 0
-        while i < size and i < @limit
-            i_offset = i + @request_range.begin
-            if @window_range.include?(i_offset)
-                result_start = i_offset - @window_range.begin
-                SolveBio::logger.debug('  Query window range: [%s...%s]' %
-                                       [result_start, result_start + 1])
-            else
-                SolveBio::logger.debug('executing query. offset/limit: %6d/%d' %
-                                       [i_offset, @limit])
-                execute({:offset => i_offset, :limit => @limit})
-                result_start = i % @limit
-            end
-            yield @results[result_start]
-            i += 1
-        end
-        return self
-    end
-
-    def [](key)
-        # Note: super does other parameter checks.
-        if key.kind_of?(Fixnum) and key >= @window_range.end
-            raise IndexError, "Invalid index #{key} >= #{@window_range.end}"
-        end
-        super[key]
-        # FIXME: Dunno why the above isn't enough.
-        @results[key]
-    end
-end
-
-
-# BatchQuery accepts a list of Query objects and executes them
-# in a single request to /v1/batch_query.
-class SolveBio::BatchQuery
-    # Expects a list of Query objects.
-    def initialize(queries)
-        unless queries.kind_of?(Array)
-            queries = [queries]
-        end
-
-        @queries = queries
-    end
-
-    def build_query
-        query = {:queries => []}
-
-        @queries.each do |i|
-            q = i.build_query
-            q.merge!(:dataset => i.dataset_id)
-            query[:queries] << q
-        end
-
-        return query
-    end
-
-    def execute(params={})
-        _params = build_query()
-        _params.merge!(params)
-        response = SolveBio::Client.client.post('/v1/batch_query', _params)
-        return response
-    end
-end
-
-# Demo/test code
-if __FILE__ == $0
-    if SolveBio::api_key
-        test_dataset_name = 'ClinVar/2.0.0-1/Variants'
-        require_relative 'solvebio'
-        require_relative 'errors'
-        dataset = SolveBio::Dataset.retrieve(test_dataset_name)
-
-        # # A filter
-        # limit = 5
-        # results = dataset.query({:paging=>false, :limit => limit}).
-        #         filter({:alternate_alleles => nil})
-        # puts results.size
-
-        limit = 2
-        # results = dataset.query({:limit => limit, :paging =>false})
-        # puts results.size
-        # results.each_with_index { |val, i|
-        #     puts "#{i}: #{val}"
-        # }
-        # puts "#{limit-1}: #{results[limit-1]}"
-        results = dataset.query({:limit => limit, :paging=>true})
-        # puts results.size
-        puts results.to_s
-    else
-        puts 'Set SolveBio::api_key to run demo'
-    end
-end