quandl 0.2.22

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

@@ -0,0 +1,46 @@
+class Quandl::Command::Tasks::Info < Quandl::Command::Tasks::Base
+  
+  description "Display information about the Quandl Toolbelt."
+  
+  def execute
+    info title "Quandl Toolbelt"
+    info current_user.info
+    info toolbelt_info
+    
+    debug title "Package Versions"
+    debug package_info
+  end
+  
+  def title(name)
+    name = name.to_s
+    "\n#{name}\n" + ( name.length.times.collect{'='}.join )
+  end
+  
+  def user_info
+    [
+      "username:   #{current_user.username}",
+      "email:      #{current_user.email}",
+     ].join("\n")
+  end
+  
+  def toolbelt_info
+    [
+      "host:       #{quandl_url}",
+      "token:      #{auth_token}",
+      "version:    #{Quandl::Command::VERSION}",
+     ].join("\n")
+  end
+  
+  def package_info
+    quandl_package_versions.sort_by{|p| p[:package].to_s }.collect{|p| "#{ p[:package] } ( #{ p[:version] } )" }.join("\n")
+  end
+  
+  def quandl_package_versions
+    Quandl.constants.collect do |c|
+      package = "Quandl::#{c}".constantize
+      version = "Quandl::#{c}::VERSION".constantize rescue nil
+      { package: package, version: version } unless version.nil?
+    end.compact
+  end
+  
+end

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

@@ -0,0 +1,40 @@
+class Quandl::Command::Tasks::List < Quandl::Command::Tasks::Base
+  
+  description "List datasets matching conditions."
+  options({
+    String => {
+      match:        "Only return datasets matching: [match]",
+      source_code:  "Return datasets matching: [SOURCE_CODE]"
+    },
+    Integer => {
+      limit:        "How datasets to return per page.",
+      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
+  end
+  
+  def page
+    options.page.to_i || 1
+  end
+  
+end

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

@@ -0,0 +1,46 @@
+class Quandl::Command::Tasks::Login < Quandl::Command::Tasks::Base
+  
+  description "Login to quandl with username and email."
+  
+  options String => { method: 'Login method? ( password | token )' }
+  
+  def execute
+    authenticate!
+    reload_session!
+    if current_user.present?
+      info "You have successfully authenticated!"
+      info current_user.info
+    else
+      error "Failed to authenticate!"
+    end
+  end
+  
+  def authenticate!
+    return execute_password_login if options.method == 'password'
+    execute_token_login
+  end
+  
+  def execute_token_login
+    info("Obtain your Auth Token from this page: http://www.quandl.com/users/info")
+    token = ask("Auth Token:  "){ |q| q.echo = "*" }
+    write_auth_token(token)
+  end
+  
+  def execute_password_login
+    # request login and password
+    login = ask("Username or Email: ")
+    password = ask("Password:  "){ |q| q.echo = "*" }
+    # attempt to login
+    user = Quandl::Client::User.login( login: login, password: password )
+    # fail on errors
+    return error( user.human_status ) unless user.auth_token.present?
+    # output qdf
+    write_auth_token(user.auth_token)
+    info "You've successfully authorized #{login}!"
+  end
+  
+  def write_auth_token(token)
+    QConfig.configuration.token = token
+  end
+  
+end

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

@@ -0,0 +1,205 @@
+class Quandl::Command::Tasks::Update < Quandl::Command::Tasks::Base
+  
+  # curl -s https://s3.amazonaws.com/quandl-command/install.sh | bash
+  
+  description "Update Quandl Toolbelt to the latest version."
+  syntax %Q{quandl update [revision]
+
+    Examples:
+
+      $ quandl update
+      Updating from 0.2.18 ...
+      You are up to date! ( 0.3.1 )
+
+      $ quandl update beta1
+      Updating from 0.3.1 ...
+      You are up to date! ( 0.3.1-beta1 )}
+      
+  PACKAGE_URL = 'http://s3.amazonaws.com/quandl-command/'
+  
+  class << self
+    def package_url(revision=nil)
+      # are we on windows?
+      platform = Quandl::Utility::Config.windows? ? 'windows' : nil
+      # build filename
+      filename = ['quandl-command', platform, revision, 'tar.gz'].compact.join(".")
+      # append s3 url
+      File.join(PACKAGE_URL, filename)
+    end
+  end
+  
+  def execute
+    # load libraries needed by this action
+    require_dependencies
+    return unless assert_update_requirements!
+    info "Updating from #{Quandl::Command::VERSION} ... "
+    # wipe update/ and backup/ folders
+    prepare_for_update
+    download_tarball
+    # ensure package was downloaded
+    return error("'#{package_url}' not found") unless File.exists?(tarball_path)
+    # install
+    extract_tarball
+    copy_windows_specific_files if Quandl::Utility::Config.windows?
+    install_update
+    configure_update
+    ensure_correct_permissions
+    # success
+    version = %x{quandl -v}.to_s.strip.rstrip
+    info "You are up to date! ( #{version} )"
+    
+  rescue => err
+    # log error
+    error(err)
+    debug(err.backtrace.join("\n"))
+    # report failure and rollback
+    info("----\nAn error has occured! Rolling back to previous version ... ")
+    info("If the problem persists reinstall with: #{installer_url}")
+    rollback_update
+  end
+  
+  def installer_url
+    return File.join(PACKAGE_URL, "Quandl Setup.exe") if Quandl::Utility::Config.windows?
+    return File.join(PACKAGE_URL, "quandl-toolbelt.pkg") if Quandl::Utility::Config.macosx?
+  end
+  
+  def package_path
+    @package_path ||= File.join(update_path, "quandl-command")
+  end
+  
+  def tarball_path
+    @tarball_path ||= File.join(update_path, "update.tar.gz")
+  end
+  
+  def package_url
+    @package_url ||= self.class.package_url(args.first)
+  end
+  
+  def update_path
+    @update_path ||= File.join( root_path, 'update' )
+  end
+  
+  def backup_path
+    @backup_path ||= File.join( root_path, 'backup' )
+  end
+  
+  def root_path
+    Quandl::Command::Tasks.root
+  end
+  
+  
+  private
+  
+  def require_dependencies
+    require 'quandl/utility/config'
+    require 'zlib'
+    require 'archive/tar/minitar'
+  end
+  
+  def assert_update_requirements!
+    return fatal("update is destructive and disabled in development!") if Dir.exists?(File.join(root_path, ".git"))
+    true
+  end
+  
+  def prepare_for_update
+    [backup_path, update_path].each do |path|
+      # remove previous directory if present
+      rm_rf(path) if Dir.exists?(path)
+      # create new directory
+      mkdir_p(path) unless Dir.exists?(path)
+    end
+  end
+  
+  def download_tarball
+    debug "Downloading '#{package_url}' to '#{tarball_path}'"
+    # download new package
+    uri = URI( package_url )
+    # open connection to storage host
+    Net::HTTP.start( uri.host, uri.port ) do |http|
+      # download file
+      resp = http.get( uri.path )
+      # write tar file if it was found
+      open( tarball_path, "wb"){|f| f.write(resp.body) } unless resp.code == '404'
+    end
+  end
+  
+  def extract_tarball
+    debug "Archive::Tar::Minitar.unpack( '#{tarball_path}', '#{update_path}' )"
+    # extract into update_path
+    Archive::Tar::Minitar.unpack( Zlib::GzipReader.open(tarball_path), update_path )
+  end
+  
+  def copy_windows_specific_files
+    files = ['bin/quandl.bat']
+    files.each do |file|
+      source_path = File.join(root_path, file)
+      cp source_path, File.join(package_path, file) if File.exists?(source_path)
+    end
+  end
+  
+  def install_update
+    debug "Installing '#{update_path}' to '#{root_path}'"
+    # install each folder into the live directory
+    Dir.glob(File.join(package_path, "/*")) do |update_dir|
+      # current folder
+      folder_name = File.basename(update_dir)
+      # get live dir
+      live_dir = File.join(root_path, folder_name )
+      # move live to backup (skip this step if it doesn't exist since it might be a new folder)
+      mv live_dir, File.join(backup_path, folder_name) if File.exists?(live_dir)
+      # move update to live
+      mv update_dir, live_dir
+    end
+  end
+  
+  def configure_update
+    if Dir.exists?("#{root_path}/ruby")
+      bin_file = File.read("#{root_path}/bin/quandl")
+      bin_file.gsub!("#!/usr/bin/env ruby", "#!/#{root_path}/ruby/bin/ruby")
+      File.write("#{root_path}/bin/quandl", bin_file)
+    end 
+  end
+  
+  def rollback_update
+    Dir.glob(File.join(backup_path, "/*")) do |backup_dir|
+      # current folder
+      folder_name = File.basename(backup_dir)
+      # get live dir
+      live_dir = File.join(root_path, folder_name )
+      # move live to update
+      mv live_dir, File.join(package_path, folder_name)
+      # move backup to live
+      mv backup_dir, live_dir
+    end
+  end
+  
+  def ensure_correct_permissions
+    chmod("+x", File.join(root_path, 'bin/quandl'))
+  end
+  
+  def chmod(*args)
+    debug("FileUtils.chmod #{args.to_a.join(' ')}")
+    FileUtils.chmod(*args)
+  end
+
+  def cp(old_path, new_path)
+    debug("FileUtils.cp #{old_path} #{new_path}")
+    FileUtils.cp( old_path, new_path )
+  end
+  
+  def mv(old_path, new_path)
+    debug("FileUtils.mv #{old_path} #{new_path}")
+    FileUtils.mv( old_path, new_path )
+  end
+  
+  def rm_rf(*args)
+    debug( "FileUtils.rm_rf #{args.to_a.join(" ")}")
+    FileUtils.rm_rf(*args)
+  end
+  
+  def mkdir_p(*args)
+    debug( "FileUtils.mkdir_p #{args.to_a.join(" ")}")
+    FileUtils.mkdir_p(*args)
+  end
+  
+end

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

@@ -0,0 +1,69 @@
+class Quandl::Command::Tasks::Upload < Quandl::Command::Tasks::Base
+
+  description "Upload a dataset using its quandl code."
+  syntax %{quandl upload file.qdf
+
+  Examples:
+  
+    $ quandl upload file.qcsv
+    OK | 98ms | http://quandl.com/USERNAME/CODE_1
+    OK | 72ms | http://quandl.com/USERNAME/CODE_2
+
+    $ ruby code.rb | quandl upload
+    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
+  }
+  options({
+    Integer => {
+      threads:         "How many workers to use during download.",
+    }
+  })
+  
+  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|
+      pool.process{ upload( dataset ) }
+    end
+    pool.shutdown
+  end
+  
+  def upload(dataset)
+    # display debug info when verbose
+    debug dataset.attributes.to_s
+    # upload
+    dataset.upload if dataset.valid?
+    # output report to $stdout or $stderr
+    report(dataset)
+  end
+  
+  def report(dataset)
+    if [200,201].include?( dataset.client.status )
+      info table dataset.client.human_status,
+        dataset.client.elapsed_request_time_ms,
+        dataset.client.full_url
+    else
+      error(dataset.human_errors)
+    end
+    debug "---"
+  end
+  
+  def file_path
+    args.first
+  end
+  
+end

data/lib/quandl/command/version.rb

@@ -0,0 +1,5 @@
+module Quandl
+module Command
+  VERSION = '0.2.22'
+end
+end

data/lib/quandl/utility.rb

@@ -0,0 +1,2 @@
+module Quandl::Utility
+end

data/lib/quandl/utility/config.rb

@@ -0,0 +1,43 @@
+require 'rbconfig'
+
+module Quandl::Utility
+module Config
+class << self
+  
+  def windows?
+    host_os == :windows
+  end
+  
+  def macosx?
+    host_os == :macosx
+  end
+  
+  def linux?
+    host_os == :linux
+  end
+  
+  def unix?
+    host_os == :unix
+  end
+  
+  def host_os
+    @os ||= (
+    host_os = RbConfig::CONFIG['host_os']
+    case host_os
+    when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+      :windows
+    when /darwin|mac os/
+      :macosx
+    when /linux/
+      :linux
+    when /solaris|bsd/
+      :unix
+    else
+      raise Error::WebDriverError, "unknown os: #{host_os.inspect}"
+    end
+    )
+  end
+  
+end
+end
+end