solvebio 1.5.0

data/lib/apiresource.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+require_relative 'solveobject'
+require_relative 'client'
+
+class SolveBio::APIResource < SolveBio::SolveObject
+
+    def self.retrieve(cls, id, params={})
+        instance = cls.new(id, params)
+        instance.refresh()
+        return instance
+    end
+
+    def refresh
+        refresh_from request('get', instance_url)
+        return self
+    end
+
+    def self.class_url(cls)
+        # cls_name = cls.class_name()
+        cls_name = cls.to_s.sub('SolveBio::', '')
+        # pluralize
+        if cls_name.end_with?('y')
+            cls_name = cls_name[0..-2] + 'ie'
+        end
+        cls_name = camelcase_to_underscore(cls_name)
+        return "/v1/#{cls_name}s"
+    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::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)
+            return response.to_solvebio
+        end
+    end
+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)
+            return response.to_solvebio
+        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, params)
+            return to_solve_object(response)
+        end
+    end
+end
+
+module SolveBio::UpdateableAPIResource
+
+    def self.included base
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def save
+            refresh_from(request('patch', instance_url(),
+                                 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
+            return params
+        end
+    end
+end
+
+class SolveBio::DeletableAPIResource
+    def self.included base
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+        def delete(params={})
+            refresh_from(request('delete', instance_url(), params))
+            return self
+        end
+    end
+end

data/lib/cli/auth.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'readline'
+require 'io/console'
+
+require_relative  '../errors'
+require_relative  '../credentials'
+require_relative  '../client'
+
+module SolveBio::Auth
+
+    def ask_for_credentials(email=nil)
+        while true
+            email ||= Readline.readline('Email address: ', true)
+            print 'Password (typing will be hidden): '
+            password = STDIN.noecho(&:gets).chomp
+            puts
+            # FIXME: validate email address?
+            if email and password
+                return email, password
+            else
+                # FIXME: could say which one is needed.
+                print 'Email and password are both required.'
+                return nil, nil
+            end
+        end
+    end
+
+    def send_install_report
+        require 'socket';
+        data = {
+            :hostname              => Socket.gethostname(),
+            :ruby_version          => SolveBio::RUBY_VERSION,
+            :ruby_implementation   => SolveBio::RUBY_IMPLEMENTATION,
+            # :platform              => platform(),
+            :architecture          => SolveBio::ARCHITECTURE,
+            # :processor             => processor(),
+        }
+        SolveBio::Client.client.request('post',
+                                        '/v1/reports/install',
+                                        data) rescue nil
+    end
+
+
+    include SolveBio::Credentials
+
+    module_function
+
+    #
+    # Prompt user for login information (email/password).
+    # Email and password are used to get the user's auth_token key.
+    #
+    def login(email=nil, password=nil)
+        delete_credentials
+
+        email, password = ask_for_credentials email unless
+            email and password
+        data = {
+            :email    => email,
+            :password => password
+        }
+
+        # FIXME: begin/rescue is a direct translation of the Python
+        # code.  Not sure if it's valid here, or what the equivalent
+        # is.
+        begin
+            response = SolveBio::Client.
+                client.request('post', '/v1/auth/token', data)
+        rescue SolveBio::Error => e
+            puts "Login failed: #{e.to_s}"
+            return false
+        else
+            save_credentials(email.downcase, response['token'])
+            # reset the default client's auth token
+            SolveBio::Client.client.api_key = response['token']
+            send_install_report
+            puts 'You are now logged-in.'
+            return true
+        end
+    end
+
+    def logout
+        if get_credentials()
+            delete_credentials()
+            SolveBio::Client.client.api_key = nil
+            puts 'You have been logged out.'
+            return true
+        else
+            puts 'You are not logged-in.'
+            return false
+        end
+    end
+
+    def whoami
+        creds = get_credentials()
+        if creds
+            puts creds[0]
+            return creds[0]
+        else
+            puts 'You are not logged-in.'
+            return nil
+        end
+    end
+
+end # SolveBio::Auth
+
+# Demo code
+if __FILE__ == $0
+    include SolveBio::Auth
+    case ARGV[0]
+    when 'password'
+        email, password = ask_for_credentials
+        puts email, password
+    when 'login'
+        login
+    when 'logout'
+        logout
+    when 'whoami'
+        whoami
+    end
+end

data/lib/cli/help.rb

@@ -0,0 +1,13 @@
+module SolveBio
+    # Shell help
+    def help
+        puts <<-HELP
+Constants SAMPLE_DEPO, SAMPLE_DEPO_VERSION, and SAMPLE_DATASET are
+available for and example depository, depository_versions or dataset.
+
+By setting environment variable SOLVEBIO_IRBRC, you can add your own
+custom irb profile.
+HELP
+    end
+    module_function :help
+end

data/lib/cli/irb.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# Open the SolveBio shell, an IRB wrapper
+require 'irb'
+require_relative 'help'
+
+module IRB
+
+    # Stuff to add IRB commands goes here
+    # module ExtendCommand
+    #     class SolveHelp
+    #         def self.execute(conf, *opts)
+    #             SolveBio::help
+    #         end
+    #     end
+
+    # end
+
+    module_function
+
+    # ExtendCommandBundle.def_extend_command 'solvehelp', :SolveHelp
+
+    def shell
+
+        # Set to run the standard trepan IRB profile
+        irbrc = File.
+            expand_path(File.join(File.dirname(__FILE__), 'irbrc.rb'))
+
+        # Start out with our custom profile
+        old_irbrc = ENV['IRBRC']
+        ENV['IRBRC'] = irbrc
+        IRB.setup(nil)
+
+        # If the user has an IRB profile or SolveBio IRB profile, run
+        # that now.
+        ENV['IRBRC'] = ENV['SOLVEBIO_IRBRC'] || old_irbrc
+        if ENV['IRBRC']
+            @CONF[:RC_NAME_GENERATOR]=nil
+            IRB.run_config
+        end
+
+        @CONF[:AUTO_INDENT] = true
+        workspace = IRB::WorkSpace.new
+        irb = IRB::Irb.new(workspace)
+
+        @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+        @CONF[:MAIN_CONTEXT] = irb.context
+
+        catch(:IRB_EXIT) do
+            irb.eval_input
+        end
+    end
+end
+
+# Demo it.
+if __FILE__ == $0
+    IRB::shell
+end

data/lib/cli/irbrc.rb

@@ -0,0 +1,53 @@
+# -*- ruby -*-
+# irbrc profile for SolveBio
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+IRB.conf[:PROMPT][:SIMPLE] = {
+  :PROMPT_C => '[SolveBio] In ?: ',  # Prompt when continuing a statement
+  :PROMPT_I => '[SolveBio] In  : ',  # Normal prompt
+  :PROMPT_N => '[SolveBio] In +: ',  # Prompt when indenting code
+  :PROMPT_S => '[SolveBio] In %l: ', # Prompt when continuing a string
+  :RETURN   => "[SolveBio] Out : %s\n"
+ }
+
+require_relative '../solvebio'
+include SolveBio::Auth
+
+# Set some demo names that can be used.
+SAMPLE_DEPO         = 'ClinVar'
+SAMPLE_DEPO_VERSION = "#{SAMPLE_DEPO}/2.0.0-1"
+SAMPLE_DATASET      = "#{SAMPLE_DEPO_VERSION}/Variants"
+
+have_completion = nil
+begin
+    require 'bond' and require 'bond/completion'
+    have_completion = 'bond'
+    rescue LoadError
+      begin
+          have_completion = require 'irb/completion'
+      rescue LoadError
+          have_completion = false
+      end
+    end
+'irb/completion'
+'bond' 'bond/completion'
+
+puts <<-INTRO
+You are in a SolveBio Interactive Ruby (irb) session...
+Type SolveBio::help for help on SolveBio.
+INTRO
+
+unless have_completion
+    if have_completion != 'bond'
+        puts "You might get better completion using the 'bond' gem"
+    end
+end
+
+# Report whether we are logged in.
+include SolveBio::Credentials
+creds = get_credentials()
+if creds
+    puts "You are logged in as #{creds[0]}"
+else
+    puts 'You are not logged in yet. Login using "login [email [, password]]"'
+
+end

data/lib/cli/options.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+# SolveBio Ruby command-line option processing
+
+require 'optparse'
+require_relative '../client'
+
+module SolveBio::CLIOptions
+
+    PROGRAM = 'solvebio.rb'
+
+    def show_version
+        "#{PROGRAM}, version #{SolveBio::VERSION}"
+    end
+
+    # Main parser for the SolveBio command line client
+    def setup_options(options, stdout=$stdout, stderr=$stderr)
+
+        OptionParser.new do |opts|
+            opts.banner = "Usage: solvebio.rb [options] <command> [<args>]"
+            opts.on_tail('-v', '--version',
+                         'print the version') do
+                options[:version] = true
+                stdout.puts "#{PROGRAM}, version #{SolveBio::VERSION}"
+                exit 0
+            end
+
+            opts.on('--api-host NAME', String,
+                    'Override the default SolveBio API host') do
+                |api_host|
+                options[:api_host] = api_host
+            end
+
+            opts.on('--api-key STRING', String,
+                    'Manually provide a SolveBio API key') do
+                |api_key|
+                options[:api_key] = api_key
+            end
+
+            opts.on('-h', '--help', 'Display this screen') do
+                puts opts
+                puts <<-EOH
+
+SolveBio Commands:
+    login [email]       Login and save credentials. Use email if provided.
+    logout              Logout and delete saved credentials
+    whoami              Show your SolveBio email address
+    shell               Open the SolveBio Python shell
+    test                Make sure the SolveBio API is working correctly
+EOH
+                exit
+            end
+        end
+    end
+
+end
+
+def process_options(argv)
+    options = {}
+    args  = setup_options(options)
+    rest  = args.parse argv
+
+    SolveBio::Client.client.api_host =  options[:api_host] if
+        options[:api_host]
+    SolveBio::Client.client.api_key =  options[:api_key] if
+        options[:api_key]
+    return options, rest, args
+end
+
+if __FILE__ == $0
+    include SolveBio::CLIOptions
+    options, rest, parser  = process_options(ARGV)
+    p options, rest, parser
+end