solvebio 1.5.2 → 1.6.1

data/lib/resource/annotation.rb

@@ -0,0 +1,23 @@
+# Solvebio API Resource for Samples
+require_relative 'apiresource'
+require_relative 'solveobject'
+require_relative '../errors'
+
+#  Annotations are genomic samples that have been annotated.
+#   See https://www.solvebio.com/docs/api/?ruby#annotations
+class SolveBio::Annotation < SolveBio::APIResource
+    include SolveBio::CreateableAPIResource
+    include SolveBio::DeletableAPIResource
+    include SolveBio::DownloadableAPIResource
+    include SolveBio::ListableAPIResource
+end
+
+if __FILE__ == $0
+    unless SolveBio::API_HOST == 'https://api.solvebio.com'
+        SolveBio::SolveObject::CONVERSION = {
+            'Annotation' => SolveBio::Annotation,
+        } unless defined? SolveBio::SolveObject::CONVERSION
+        response = SolveBio::Annotation.all()
+        puts response
+    end
+end

data/lib/resource/apiresource.rb

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+require 'uri'
+require 'json'
+require 'rest_client'
+require_relative 'solveobject'
+require_relative '../main'
+require_relative '../client'
+require_relative '../util'
+require_relative '../errors'
+
+class SolveBio::APIResource < SolveBio::SolveObject
+
+    def self.retrieve(cls, id, params={})
+        instance = cls.new(id, params)
+        instance.refresh()
+        instance
+    end
+
+    def self.class_to_api_name(cls)
+        cls_name = cls.to_s.sub('SolveBio::', '')
+        SolveBio::camelcase_to_underscore(SolveBio::pluralize(cls_name))
+    end
+
+    def refresh
+        refresh_from request('get', instance_url)
+        self
+    end
+
+    def self.class_url(cls)
+        cls_name = cls.to_s.sub('SolveBio::', '')
+        "/v1/#{class_to_api_name(cls_name)}"
+    end
+
+
+    # Get instance URL by ID or full name (if available)
+    def instance_url
+        id = self['id']
+        base = SolveBio::APIResource.class_url(self.class)
+
+        if id
+            return "#{base}/#{id}"
+        else
+            msg = 'Could not determine which URL to request: %s instance ' +
+                'has invalid ID: %s' % [self.class, id]
+            raise Exception, msg
+        end
+    end
+end
+
+module SolveBio::CreateableAPIResource
+
+    def self.included base
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def create(params={})
+            url = SolveBio::APIResource.class_url(self)
+            response = SolveBio::Client.client
+                .request('post', url, {:payload => params} )
+            to_solve_object(response)
+        end
+    end
+end
+
+
+module SolveBio::DeletableAPIResource
+
+    def delete(params={})
+        begin
+            self.refresh_from(SolveBio::Client.client
+                                 .request('delete', instance_url,
+                                          {:payload => params}))
+        rescue SolveBio::Error => response
+            response.to_solve_object(cls)
+        end
+    end
+end
+
+module SolveBio::DownloadableAPIResource
+
+    #
+    # Download the file to the specified path (or a temp. dir).
+    #
+    def download(path=nil)
+        download_url = instance_url + '/download'
+        response = SolveBio::Client.client.get(download_url, :raw => true)
+
+        if response.code != 302
+            # Some kind of error. We expect a redirect
+            raise SolveError('Could not download file: response code' %
+                             response.status_code)
+        end
+
+        download_url = response.headers[:location]
+        filename = download_url.split('%3B%20filename%3D')[1]
+
+        path = Dir.tmpdir unless path
+        filename = File.join(path, filename)
+        response = nil
+
+        response = SolveBio::Client.client.get(download_url, :raw => true,
+                                               :default_headers => false)
+
+        File.open(filename, 'wb') do |fh|
+            fh.write(response.body)
+        end
+
+        self['filename'] = filename
+        self['code'] = response.code
+        self
+    end
+end
+
+module SolveBio::HelpableAPIResource
+
+    attr_reader :have_launchy
+
+    @@have_launchy = false
+    begin
+        @@have_launchy = require 'launchy'
+    rescue LoadError
+    end
+
+    def self.included base
+        base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+        def help
+            open_help(self['full_name'])
+        end
+    end
+
+    def open_help(path)
+        url = URI::join('https://www.solvebio.com/', path)
+        if @@have_launchy
+            Launchy.open(url)
+        else
+            puts('The SolveBio Ruby client needs the "launchy" gem to ' +
+                 "open help url: #{url.to_s}")
+        end
+    end
+end
+
+module SolveBio::ListableAPIResource
+
+    def self.included base
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def all(params={})
+            url = SolveBio::APIResource.class_url(self)
+            response = SolveBio::Client.client
+                .request('get', url, {:params => params})
+            return response.to_solvebio(self)
+        end
+    end
+
+    # How many items are in this list?
+    def size
+        self[:total]
+    end
+    alias :total :size
+
+end
+
+module SolveBio::SearchableAPIResource
+
+    def self.included base
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def search(query='', params={})
+            params['q'] = query
+            url = SolveBio::APIResource.class_url(self)
+            response = SolveBio::Client.client
+                .request('get', url, {:params => params})
+            response.to_solvebio
+        end
+    end
+end
+
+module SolveBio::SingletonAPIResource
+
+    def self.class_to_api_name(cls)
+        cls_name = cls.to_s.sub('SolveBio::', '')
+        SolveBio::camelcase_to_underscore(cls_name)
+    end
+
+    def self.retrieve(cls)
+        super(SingletonAPIResource, cls).retrieve(nil)
+    end
+
+    def self.class_url(cls)
+        "/v1/#{class_to_api_name(cls)}"
+    end
+
+    def instance_url
+        class_url
+    end
+end
+
+module SolveBio::UpdateableAPIResource
+
+    def self.included base
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def save
+            refresh_from(request('patch', instance_url(),
+                                 {:params => serialize(self)}))
+            return self
+        end
+
+        def serialize(obj)
+            params = {}
+            if obj.unsaved_values
+                obj.unsaved_values.each do |k|
+                    next if k == 'id'
+                    params[k] = getattr(obj, k) or ''
+                end
+            end
+            params
+        end
+    end
+end
+
+# Demo code
+if __FILE__ == $0
+    include SolveBio::HelpableAPIResource
+    if @@have_launchy
+        open_help('docs')
+        sleep 1
+    else
+        puts "Don't have launchy"
+    end
+end

data/lib/resource/dataset.rb

@@ -0,0 +1,91 @@
+require_relative 'apiresource'
+require_relative '../query'
+
+class SolveBio::Dataset < SolveBio::APIResource
+
+    include SolveBio::CreateableAPIResource
+    include SolveBio::ListableAPIResource
+    include SolveBio::UpdateableAPIResource
+    include SolveBio::HelpableAPIResource
+
+    ALLOW_FULL_NAME_ID = true
+
+    # FIXME: base off of DepositoryVersion::FULL_NAME_REGEX
+    # Sample matches:
+    #  'Clinvar/2.0.0-1/Variants'
+    #  'omim/0.0.1-1/omim'
+    FULL_NAME_REGEX = %r{^([\w\-\.]+/){2}[\w\-\.]+$}
+
+    # Dataset lookup by full string name
+    def self.retrieve(id, params={})
+        if id.kind_of?(String)
+            _id = id.strip
+            id = nil
+            if _id =~ FULL_NAME_REGEX
+                params['full_name'] = _id
+            else
+                raise Exception, 'Unrecognized full name.'
+            end
+        end
+
+        return SolveBio::APIResource.
+            retrieve(SolveBio::Dataset, id, params)
+    end
+
+    def depository_version
+        return SolveBio::DepositoryVersion.
+            retrieve(self['depository_version'])
+    end
+
+    def depository
+        return SolveBio::Depository.retrieve(self['depository'])
+    end
+
+    def fields(name=nil, params={})
+        unless self['fields_url']
+            raise Exception,
+            'Please use Dataset.retrieve({ID}) before doing looking ' +
+                'up fields'
+        end
+
+        if name
+            # construct the field's full_name if a field name is provided
+            return DatasetField.retrieve("#{self['full_name']}/#{name}")
+        end
+
+        result = SolveBio::Client.
+                   client.request('get', self['fields_url'])
+        result.to_solvebio(self.class)
+    end
+
+    def query(params={})
+        paging = false
+        if params.member?(:paging)
+            paging = params[:paging]
+            params.delete(:paging)
+        end
+        q = paging ? SolveBio::PagingQuery.new(self['id'], params) :
+            SolveBio::Query.new(self['id'], params)
+
+        if params[:filters]
+            return q.filter(params[:filters])
+        end
+        return q
+    end
+
+    private
+    def data_url
+        unless self['data_url']
+            unless self['id']
+                raise Exception,
+                'No Dataset ID was provided. ' +
+                    'Please instantiate the Dataset ' +
+                    'object with an ID or full_name.'
+            end
+            # automatically construct the data_url from the ID
+            return instance_url() + '/data'
+        end
+        return self['data_url']
+    end
+
+end

data/lib/resource/datasetfield.rb

@@ -0,0 +1,37 @@
+require_relative 'apiresource'
+
+class SolveBio::DatasetField < SolveBio::APIResource
+
+    include SolveBio::CreateableAPIResource
+    include SolveBio::ListableAPIResource
+    include SolveBio::UpdateableAPIResource
+
+    ALLOW_FULL_NAME_ID = true
+    FULL_NAME_REGEX = %r{^([\w\-\.]+/){3}[\w\-\.]+$}
+
+    # Supports lookup by ID or full name
+    def self.retrieve(id, params={})
+        if id.kind_of?(String)
+            _id = id.strip
+            id = nil
+            if FULL_NAME_REGEX =~ _id
+                params['full_name'] = _id
+            else
+                raise Exception, 'Unrecognized full name.'
+            end
+        end
+
+        SolveBio::APIResource.
+            retrieve(SolveBio::DatasetField, id, params)
+    end
+
+    def facets(params={})
+        response = SolveBio::Client.client
+                     .request 'get', self[:facets_url], {:params => params}
+        response.to_solvebio(SolveBio::SolveObject)
+    end
+
+    def help
+        facets
+    end
+end

data/lib/resource/depository.rb

@@ -0,0 +1,50 @@
+require_relative 'apiresource'
+
+#  A depository (or data repository) is like a source code
+#  repository, but for datasets. Depositories have one or more
+#  versions, which in turn contain one or more datasets. Typically,
+#  depositories contain a series of datasets that are compatible with
+#  each other (i.e. they come from the same data source or project).
+class SolveBio::Depository < SolveBio::APIResource
+
+    include SolveBio::CreateableAPIResource
+    include SolveBio::ListableAPIResource
+    include SolveBio::SearchableAPIResource
+    include SolveBio::UpdateableAPIResource
+    include SolveBio::HelpableAPIResource
+
+    ALLOW_FULL_NAME_ID = true
+    FULL_NAME_REGEX = %r{^[\w\-\.]+$}
+
+    # lookup by ID or full name
+    def self.retrieve(id, params={})
+        if id.kind_of?(String)
+            _id = id.strip
+            id = nil
+            if _id =~ FULL_NAME_REGEX
+                params['full_name'] = _id
+            else
+                raise Exception, 'Unrecognized full name: "%s"' % _id
+            end
+        end
+
+        return SolveBio::APIResource.
+            retrieve(SolveBio::Depository, id, params)
+    end
+
+    def versions_url
+        return SolveBio::APIResource.
+            retrieve(SolveBio::Depository, self['id'])['versions_url']
+    end
+
+    def versions(name=nil, params={})
+        # construct the depo version full name
+        return SolveBio::DepositoryVersion.
+            retrieve("#{self['full_name']}/#{name}") if name
+
+        response = SolveBio::Client.client
+            .request('get', versions_url, {:params => params})
+        return response.to_solvebio
+    end
+
+end

data/lib/resource/depositoryversion.rb

@@ -0,0 +1,69 @@
+require_relative 'apiresource'
+
+class SolveBio::DepositoryVersion < SolveBio::APIResource
+
+
+    include SolveBio::CreateableAPIResource
+    include SolveBio::ListableAPIResource
+    include SolveBio::UpdateableAPIResource
+    include SolveBio::HelpableAPIResource
+
+    ALLOW_FULL_NAME_ID = true
+
+    # FIXME: base off of Depository::FULL_NAME_REGEX
+    # Sample matches:
+    #  'Clinvar/2.0.0-1'
+    FULL_NAME_REGEX = %r{^[\w\.]+/[\w\-\.]+$}
+
+    # Supports lookup by full name
+    def self.retrieve(id, params={})
+        if id.kind_of?(String)
+            _id = id.strip
+            id = nil
+            if _id =~ FULL_NAME_REGEX
+                params['full_name'] = _id
+            else
+                raise Exception, 'Unrecognized full name.'
+            end
+        end
+
+        return SolveBio::APIResource.
+            retrieve(SolveBio::DepositoryVersion, id, params)
+    end
+
+    def datasets_url(name=nil)
+        name ||= self['name']
+        "#{self['full_name']}/#{name}"
+    end
+
+    def datasets(name=nil, params={})
+        if name
+            # construct the dataset full name
+            return SolveBio::Dataset.retrieve(datasets_url(name))
+        end
+
+        response = SolveBio::Client.client
+            request('get', datasets_url, {:params => params})
+        return response.to_solvebio
+    end
+
+    # Set the released flag and optional release date and save
+    def release(released_at=nil)
+        if released_at
+            @released_at = released_at
+        end
+        @released = true
+        save()
+    end
+
+    # Unset the released flag and save
+    def unrelease
+        @released = false
+        save()
+    end
+
+    def <=>(other)
+        self[:full_name] <=> other[:full_name]
+    end
+
+end