solvebio 1.6.1 → 1.7.0

data/lib/resource/annotation.rb

@@ -1,23 +0,0 @@
-# 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

@@ -1,241 +0,0 @@
-# -*- 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

@@ -1,91 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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