quandl 0.2.27 → 0.3.0

data/lib/quandl/command/task/translations.rb

@@ -0,0 +1,37 @@
+module Quandl
+module Command
+class Task
+
+module Translations
+  
+  extend ActiveSupport::Concern
+
+  included do
+    
+  end
+
+  module ClassMethods
+    
+    def t(key)
+      key = key.to_s
+      translation = lang
+      key.split('.').each{|m| translation = translation.respond_to?(m) ? translation.send(m) : nil }
+      translation
+    end
+    
+    def lang
+      @lang ||= Quandl::Lang.send(language).quandl.command.tasks.send(command_name)
+    end
+    
+    def language
+      # stub
+      'en'
+    end
+    
+  end
+  
+end
+
+end
+end
+end

data/lib/quandl/command/task/updatable.rb

@@ -0,0 +1,77 @@
+module Quandl
+module Command
+class Task
+
+module Updatable
+  
+  extend ActiveSupport::Concern
+  
+  VERSION_URL="https://raw.github.com/quandl/quandl_command/master/lib/quandl/command/version.rb"
+  
+  included do
+    before_execute :check_for_update_once_daily
+  end
+  
+  def check_for_update_once_daily
+    check_time = config.last_checked_for_update
+    # check time present?
+    if check_time.present? && check_time.is_a?(Time)
+      # has it been more than one day?  
+      check_for_update if Time.now - 1.day > check_time || check_time > Time.now
+    else
+      check_for_update
+    end
+  end
+  
+  def check_for_update
+    # notify user of impending update check
+    print("# Checking for updates ... ")
+    # lazy load dependencies since this happens infrequently
+    require_check_for_update_dependencies
+    # build request
+    http, request = prepare_update_request
+    # send request
+    response = send_update_request(http, request)
+    # handle output
+    handle_update_response(response)
+  rescue => err
+    error("An unexpected error occured while checking for updates ... #{err}")
+    error err.backtrace.join("\n") if trace?
+  ensure
+    config.last_checked_for_update = Time.now
+  end
+  
+  private
+  
+  def require_check_for_update_dependencies
+    require 'uri'
+    require 'net/http'
+    require 'open-uri'
+  end
+  
+  def prepare_update_request
+    uri = URI.parse( VERSION_URL )
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    [ http, Net::HTTP::Get.new(uri.request_uri) ]
+  end
+  
+  def send_update_request(http, request)
+    # send request
+    response = http.request(request)
+    # fetch version number
+    response.body.split("\n").detect{|r| r =~ /VERSION/ }.split("'").last
+  end
+  
+  def handle_update_response(response)
+    return info(" you are up to date! #{response}") if Quandl::Command::VERSION == response
+    # otherwise they are out of sync
+    info(" A new version of quandl toolbelt has been released. #{response}. Please run 'quandl update'")
+  end
+  
+end
+
+end
+end
+end

data/lib/quandl/command/tasks.rb

@@ -1,23 +1,24 @@
 module Quandl
 module Command
 module Tasks
-  
+
   def self.root
     @root ||= File.expand_path(File.join(File.dirname(__FILE__), '../../../'))
   end
-  
+
   def self.each(&block)
     tasks.each{|t| block.call(t) }
   end
-  
+
   def self.tasks
     @tasks ||= []
   end
-  
+
   # require base task
-  require 'quandl/command/tasks/base'
+  require 'quandl/command/task'
   # require tasks
   Dir.glob(File.join(root, 'lib/quandl/command/tasks/*.rb')){|t| require(t) }
+
 end
 end
 end

data/lib/quandl/command/tasks/delete.rb

@@ -1,12 +1,12 @@
-class Quandl::Command::Tasks::Delete < Quandl::Command::Tasks::Base
+class Quandl::Command::Tasks::Delete < Quandl::Command::Task
   
-  autoload_client_library
+  autoload_quandl_client
   authenticated_users_only!
   
   description "Delete a dataset by its quandl code."
   syntax %Q{quandl delete (SOURCE_CODE/)CODE
 
-    Examples:
+    EXAMPLES:
 
       $ quandl delete TEST
       Are you sure? (y/n)
@@ -20,72 +20,15 @@ class Quandl::Command::Tasks::Delete < Quandl::Command::Tasks::Base
     
       $ cat ids.txt | quandl delete --force-yes}
 
-  options({
-    Integer => {
-      threads:      t('options.threads'),
-    }
-  })
-  
   def execute
-    # download using arguments when present
-    return delete_each_argument if args.first.present?
-    # otherwise delete using stdin
-    delete_each_stdin
-  end
-  
-  def delete_each_argument
-    # delete each arg
-    args.each{|code| delete_with_pool(code) }
-    # wait for all deletes to finish
-    pool.shutdown
-  end
-  
-  def delete_each_stdin
-    return error("Cannot delete datasets from STDIN unless --force-yes is set!") unless force_yes?
-    # treat each line from stdin as a code
-    $stdin.each_line{|code| delete_with_pool(code) }
-    # wait for deletes to finish
-    pool.shutdown
-  end
-  
-  def delete_with_pool(code)
-    # sanitize
-    code = code.to_s.strip.rstrip
-    # if --force-yes send the deletes async
-    if force_yes?
-      pool.process{ delete( code ) }
-    # otherwise send each delete sync and wait for confirmation
-    else
-      delete( code )
+    each_line_in_background( args_or_stdin ) do |code|
+      # find
+      dataset = Quandl::Client::Dataset.find( code )
+      # destroy
+      dataset.destroy if dataset.respond_to?(:destroy) && dataset.exists?
+      # present
+      present dataset
     end
   end
   
-  def delete(code)
-    return error("You must provide a code!") if code.blank?
-    # find by code
-    dataset = Quandl::Client::Dataset.find(code)
-    # fail fast if dataset does not exist
-    return error(table(Quandl::Client::HTTP_STATUS_CODES[404], code)) if dataset.nil?
-    return report(dataset) unless dataset.exists?
-    # confirm deletion
-    return error("You must confirm deletion!") unless confirmed?(dataset)
-    # delete if exists
-    dataset.destroy if dataset.exists?
-    # output status
-    report(dataset)
-  end
-  
-  def report(dataset)
-    # message
-    m = table dataset.elapsed_request_time_ms, dataset.full_code
-    # report
-    dataset.status == 200 ? info(table("Deleted", m)) : error(table(dataset.human_status, m))
-  end
-  
-  def confirmed?(dataset)
-    return true if force_yes?
-    info summarize dataset.attributes.slice('source_code', 'code', 'name', 'from_date', 'to_date', 'column_names', 'created_at')
-    ask_yes_or_no
-  end
-  
 end

data/lib/quandl/command/tasks/download.rb

@@ -1,5 +1,5 @@
-class Quandl::Command::Tasks::Download < Quandl::Command::Tasks::Base
-  autoload_client_library
+class Quandl::Command::Tasks::Download < Quandl::Command::Task
+  autoload_quandl_client
   
   syntax "quandl download (SOURCE_CODE/)CODE"
   description "Download a dataset using its quandl code."
@@ -23,89 +23,22 @@ class Quandl::Command::Tasks::Download < Quandl::Command::Tasks::Base
     }
   })
   
+  delegate :trim_start, :trim_end, :order, :collapse, :transform, to: :options
+  
   validates :trim_start, :trim_end, allow_nil: true, format: { with: Quandl::Pattern.dataset_date, message: t('validations.trim_start') }
   validates :order, allow_nil: true, inclusion: { in: ['asc', 'desc'], message: t('validations.order') }
   validates :collapse, allow_nil: true, inclusion: { in: Quandl::Operation::Collapse.valid_collapses.collect(&:to_s), message: t('validations.collapse') }
   validates :transform, allow_nil: true, inclusion: { in: Quandl::Operation::Transform.valid_transformations.collect(&:to_s), message: t('validations.transform') }
   
   def execute
-    # download using arguments when present
-    return download_each_argument if args.first.present?
-    # otherwise download using stdin
-    download_each_stdin
-  end
-  
-  def download_each_argument
-    args.each do |code|
-      pool.process{ download(code) }
-    end
-    pool.shutdown
-  end
-  
-  def download_each_stdin
-    $stdin.each_line do |code|
-      pool.process{ download(code.strip.rstrip) }
-    end
-    pool.shutdown
-  end
-  
-  def download(code)
-    timer = Time.now
-    # find dataset
-    dataset = Quandl::Client::Dataset.find( code )
-    # fail fast
-    return error(table(Quandl::Client::HTTP_STATUS_CODES[404], code)) if dataset.nil?
-    # set data operations
-    dataset.data.assign_attributes(data_params) unless dataset.blank?
-    # send request & check for errors.
-    if !dataset.exists? && !dataset.valid?
-      # raise detailed error
-      return error( table( dataset.human_status, code, dataset.elapsed_request_time_ms ) )
-    end
-    # generate qdf
-    elapsed = timer.elapsed_ms
-    qdf = dataset.to_qdf
-    # write to STDOUT
-    mutex.synchronize{
-      debug("# #{dataset.try(:full_url)} downloaded in #{elapsed}")
-      info(qdf)
-    }
-    true
-  end
-  
-  def trim_start
-    options.trim_start
-  end
-  
-  def trim_end
-    options.trim_end
-  end
-  
-  def order
-    options.order
-  end
-  
-  def collapse
-    options.collapse
-  end
-  
-  def transform
-    options.transform
-  end
-  
-  def data_params
-    params = {}
-    self.class.options.each do |class_type, opts|
-      opts.each do |name, desc|
-        if options.is_a?(OpenStruct)
-          params[name] = self.options.send(name)
-        else
-          params[name] = self.options[name] if self.options[name].present?
-        end
-        
-      end
+    each_line_in_background( args_or_stdin ) do |code|
+      # find dataset
+      dataset = Quandl::Client::Dataset.find( code )
+      # apply filters
+      dataset.data.assign_attributes(declared_params) if dataset.try(:exists?)
+      # present
+      present dataset, output_format: :qdf
     end
-    params
   end
   
 end

data/lib/quandl/command/tasks/info.rb

@@ -1,5 +1,5 @@
-class Quandl::Command::Tasks::Info < Quandl::Command::Tasks::Base
-  autoload_client_library
+class Quandl::Command::Tasks::Info < Quandl::Command::Task
+  autoload_quandl_client
   
   description "Display information about the Quandl Toolbelt."
   

data/lib/quandl/command/tasks/list.rb

@@ -1,42 +1,30 @@
-class Quandl::Command::Tasks::List < Quandl::Command::Tasks::Base
-  autoload_client_library
+require 'quandl/command/tasks/search'
+
+class Quandl::Command::Tasks::List < Quandl::Command::Tasks::Search
+  autoload_quandl_client
   
   description "List datasets matching conditions."
   options({
     String => {
-      match:        "Only return datasets matching: [match]",
-      source_code:  "Return datasets matching: [SOURCE_CODE]"
+      query:        "Only return datasets matching: [query]",
+      code:         "Return datasets where code matches [code]",
     },
     Integer => {
-      limit:        "How datasets to return per page.",
+      limit:        "Limit the number of datasets returned by the search. Defaults to unlimited.",
       page:         "Return datasets starting from: [page]",
     }
   })
   
-  
   authenticated_users_only!
   
   def execute
-    # find dataset
-    debug "search_params: #{search_params}"
-    dataset = Quandl::Client::Dataset.where( search_params ).fetch
-    codes = dataset.collect(&:full_code)
-    # fail on errors
-    info codes.join("\n")
-  end
-  
-  def search_params
-    search_params = {}
-    search_params[:query] = options.match if options.match.present?
-    search_params[:source_code] = options.source_code.to_s.upcase if options.source_code.present?
-    search_params[:per_page] = options.limit if options.limit.present?
-    search_params[:page] = page
-    search_params[:self_search] = search_params[:source_code].present? ? false : true
-    search_params
+    Quandl::Client::Dataset.owner('myself').where( declared_params ).each_in_page do |dataset|
+      present(dataset)
+    end
   end
   
-  def page
-    options.page.to_i || 1
+  def query
+    'myself'
   end
   
 end

data/lib/quandl/command/tasks/login.rb

@@ -1,5 +1,5 @@
-class Quandl::Command::Tasks::Login < Quandl::Command::Tasks::Base
-  autoload_client_library
+class Quandl::Command::Tasks::Login < Quandl::Command::Task
+  autoload_quandl_client
     
   description "Login to quandl with username and email."
   
@@ -7,7 +7,7 @@ class Quandl::Command::Tasks::Login < Quandl::Command::Tasks::Base
   
   def execute
     authenticate!
-    reload_session!
+    clear_session!
     if current_user.present?
       info "You have successfully authenticated!"
       info current_user.info
@@ -41,7 +41,7 @@ class Quandl::Command::Tasks::Login < Quandl::Command::Tasks::Base
   end
   
   def write_auth_token(token)
-    QConfig.configuration.token = token
+    config.token = token
   end
   
 end

data/lib/quandl/command/tasks/replace.rb

@@ -0,0 +1,58 @@
+class Quandl::Command::Tasks::Replace < Quandl::Command::Task
+  autoload_quandl_client
+  
+  description "Upload datasets and replace data instead of merging."
+  syntax %{quandl replace file.qdf
+
+  EXAMPLES:
+  
+    $ quandl replace file.qcsv
+    OK | 98ms | http://quandl.com/USERNAME/CODE_1
+    OK | 72ms | http://quandl.com/USERNAME/CODE_2
+
+    $ ruby code.rb | quandl replace
+    OK | 98ms | http://quandl.com/USERNAME/CODE_1
+    OK | 72ms | http://quandl.com/USERNAME/CODE_2
+
+  Quandl CSV Format:
+  
+    code:         YOUR_QUANDL_CODE
+    name:         Dataset Title
+    description:  Dataset description.
+    private:      false
+    -
+    Date, First, Second, Third
+    2013-11-22,1252.0,454.95,448.2
+    2013-11-21,452.25,457.75,449.1
+  }
+  
+  authenticated_users_only!
+  
+  def execute
+    # datasets from file_path if given
+    interface = file_path.present? ? File.open(file_path, "r") : $stdin
+    # for each dataset streamed from interface
+    Quandl::Format::Dataset.each_line(interface) do |dataset, error|
+      # present error if given
+      next present( error ) unless error.nil?
+      # process in background using thread key
+      background_job( lock: dataset.client.full_code ) do
+        # replace
+        replace( dataset )
+      end
+    end
+  end
+  
+  def replace(dataset)
+    dataset.client.delete_data
+    # upload unless errors were raised
+    dataset.upload if dataset.valid?
+    # output report to $stdout or $stderr
+    present(dataset.client)
+  end
+  
+  def file_path
+    args.first
+  end
+  
+end