quandl 0.4.4 → 1.0.0.rc1

data/lib/quandl.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/object/blank'
+require 'rest-client'
+require 'json'
+require 'csv'
+require 'net/http'
+require 'pathname'
+
+require_relative 'quandl/version'
+
+require_relative 'quandl/util'
+require_relative 'quandl/connection'
+
+require_relative 'quandl/api_config'
+require_relative 'quandl/operations/base'
+require_relative 'quandl/operations/list'
+require_relative 'quandl/operations/get'
+
+require_relative 'quandl/model/base'
+require_relative 'quandl/model/list'
+require_relative 'quandl/model/data'
+require_relative 'quandl/model/database'
+require_relative 'quandl/model/dataset'
+
+require_relative 'quandl/errors/quandl_error'

data/lib/quandl/api_config.rb

@@ -0,0 +1,33 @@
+module Quandl
+  class ApiConfig
+    API_KEY_THREAD_KEY = 'quandl_api_key'
+    API_BASE_THREAD_KEY = 'quandl_api_base'
+    API_VERSION_THREAD_KEY = 'quandl_api_version_key'
+
+    class << self
+      def api_key=(api_key)
+        Thread.current[API_KEY_THREAD_KEY] = api_key
+      end
+
+      def api_key
+        Thread.current[API_KEY_THREAD_KEY]
+      end
+
+      def api_base=(api_base)
+        Thread.current[API_BASE_THREAD_KEY] = api_base
+      end
+
+      def api_base
+        Thread.current[API_BASE_THREAD_KEY] || 'https://www.quandl.com/api/v3'
+      end
+
+      def api_version=(api_version)
+        Thread.current[API_VERSION_THREAD_KEY] = api_version
+      end
+
+      def api_version
+        Thread.current[API_VERSION_THREAD_KEY]
+      end
+    end
+  end
+end

data/lib/quandl/connection.rb

@@ -0,0 +1,75 @@
+module Quandl
+  class Connection
+    def self.request(http_verb, url, options = {}, &block)
+      params = options.delete(:params) || {}
+      headers = options.delete(:headers) || {}
+      accept_value = 'application/json'
+      accept_value += ", application/vnd.quandl+json;version=#{ApiConfig.api_version}" if ApiConfig.api_version
+      headers = { accept: accept_value }.merge(headers)
+      headers = { x_api_token: ApiConfig.api_key }.merge(headers) if ApiConfig.api_key
+
+      request_url = ApiConfig.api_base + '/' + url
+      request_url = request_url + '?' + params.to_query if params.present?
+
+      request_opts = { url: request_url, headers: headers, method: http_verb }
+      response = execute_request(request_opts, &block)
+
+      return response if block_given?
+
+      response_data = Quandl::Util.convert_to_dates(parse(response))
+      [response, response_data]
+    end
+
+    def self.execute_request(opts, &block)
+      RestClient::Request.execute(opts, &block)
+    rescue RestClient::ExceptionWithResponse => e
+      handle_api_error(e.response) if e.response
+      raise e
+    end
+
+    def self.parse(response)
+      ActiveSupport::HashWithIndifferentAccess.new(JSON.parse(response))
+    rescue JSON::ParserError
+      raise general_error(response.code, response.body)
+    end
+
+    def self.general_error(rcode, rbody)
+      QuandlError.new("Invalid response object from API: #{rbody.inspect} " \
+                   "(HTTP response code was #{rcode})", rcode, rbody)
+    end
+
+    def self.handle_api_error(resp)
+      error_body = parse(resp.body)
+      code = error_body['quandl_error']['code']
+      message = error_body['quandl_error']['message']
+      code_letter = code.match(/QE([a-zA-Z])x/).captures.first
+
+      case code_letter
+      when 'L'
+        fail LimitExceededError.new(message, resp.code, resp.body, error_body,
+                                    resp.headers, code)
+      when 'M'
+        fail InternalServerError.new(message, resp.code, resp.body, error_body,
+                                     resp.headers, code)
+      when 'A'
+        fail AuthenticationError.new(message, resp.code, resp.body, error_body,
+                                     resp.headers, code)
+      when 'P'
+        fail ForbiddenError.new(message, resp.code, resp.body, error_body,
+                                resp.headers, code)
+      when 'S'
+        fail InvalidRequestError.new(message, resp.code, resp.body, error_body,
+                                     resp.headers, code)
+      when 'C'
+        fail NotFoundError.new(message, resp.code, resp.body, error_body,
+                               resp.headers, code)
+      when 'X'
+        fail ServiceUnavailableError.new(message, resp.code, resp.body,
+                                         error_body, resp.headers, code)
+      else
+        fail QuandlError.new(message, resp.code, resp.body, error_body,
+                             resp.headers, code)
+      end
+    end
+  end
+end

data/lib/quandl/errors/quandl_error.rb

@@ -0,0 +1,56 @@
+# based off of stripe gem: https://github.com/stripe/stripe-ruby
+module Quandl
+  class QuandlError < StandardError
+    attr_reader :quandl_message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :http_headers
+    attr_reader :request_id
+    attr_reader :json_body
+    attr_reader :quandl_error_code
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(quandl_message = nil, http_status = nil, http_body = nil, json_body = nil,
+                   http_headers = nil, quandl_error_code = nil)
+      @quandl_message = quandl_message
+      @http_status = http_status
+      @http_body = http_body
+      @http_headers = http_headers || {}
+      @json_body = json_body
+      @quandl_error_code = quandl_error_code
+      @message = build_message
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def build_message
+      status_string = @http_status.nil? ? '' : "(Status #{@http_status}) "
+      quandl_error_string = @quandl_error_code.nil? ? '' : "(Quandl Error #{@quandl_error_code}) "
+      "#{status_string}#{quandl_error_string}#{@quandl_message}"
+    end
+
+    def to_s
+      build_message
+    end
+  end
+
+  class AuthenticationError < QuandlError
+  end
+
+  class InvalidRequestError < QuandlError
+  end
+
+  class LimitExceededError < QuandlError
+  end
+
+  class NotFoundError < QuandlError
+  end
+
+  class ServiceUnavailableError < QuandlError
+  end
+
+  class InternalServerError < QuandlError
+  end
+
+  class ForbiddenError < QuandlError
+  end
+end

data/lib/quandl/model/base.rb

@@ -0,0 +1,31 @@
+module Quandl
+  class ModelBase
+    def initialize(data, _options = {})
+      @raw_data = ActiveSupport::HashWithIndifferentAccess.new(Hash[data.map { |k, v| [Quandl::Util.methodize(k), v] }])
+    end
+
+    def data_fields
+      @raw_data.keys.map(&:to_s)
+    end
+
+    def column_names
+      @raw_data.keys.map(&:to_s).map(&:titleize)
+    end
+
+    def to_a
+      @raw_data.values
+    end
+
+    def inspect
+      @raw_data.to_s
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      return @raw_data[method_name.to_s] if @raw_data.key?(method_name.to_s)
+      return @raw_data.method(method_name.to_s).call(*args, &block) if @raw_data.respond_to?(method_name.to_s)
+      super
+    end
+  end
+end

data/lib/quandl/model/data.rb

@@ -0,0 +1,32 @@
+module Quandl
+  class Data < ModelBase
+    include Quandl::Operations::List
+
+    def self.create_list_from_response(_response, data)
+      values = data['dataset_data'].delete('data')
+      metadata = data['dataset_data']
+      Quandl::List.new(self, values, metadata)
+    end
+
+    def self.list_path
+      'datasets/:database_code/:dataset_code/data'
+    end
+
+    def initialize(data, options = {})
+      converted_column_names = options[:meta]['column_names'].map { |cn| Quandl::Util.methodize(cn) }
+      @raw_data = Quandl::Util.convert_to_dates(Hash[converted_column_names.zip(data)])
+      @meta = options[:meta]
+    end
+
+    def column_names
+      @meta['column_names']
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      return @meta[method_name.to_s] if @meta.key?(method_name.to_s)
+      super
+    end
+  end
+end

data/lib/quandl/model/database.rb

@@ -0,0 +1,62 @@
+module Quandl
+  class Database < ModelBase
+    include Quandl::Operations::Get
+    include Quandl::Operations::List
+
+    def datasets(options = {})
+      Quandl::Dataset.all({ params: { database_code: database_code, query: nil, page: 1 } }.deep_merge(options))
+    end
+
+    def bulk_download_url(options = {})
+      options.assert_valid_keys(:download_type, :path_only)
+
+      url = self.class.default_path + '/data'
+      url = Quandl::ApiConfig.api_base + '/' + url unless options[:path_only]
+      url = Quandl::Util.constructed_path(url, id: database_code)
+
+      params = {}
+      params['download_type'] = options[:download_type] if options[:download_type]
+      params['auth_token'] = Quandl::ApiConfig.api_key if Quandl::ApiConfig.api_key
+
+      url += '?' + params.to_query if params.any?
+      url
+    end
+
+    def bulk_download_to_file(file_or_folder_path, options = {})
+      fail(QuandlError, 'You must specific a file handle or folder to write to.') if file_or_folder_path.blank?
+
+      # Retrieve the location of the bulk download url
+      url = bulk_download_url({ path_only: true }.merge(options))
+      download_url = Quandl::Connection.request(:get, url) do |response, _request, _result, &_block|
+        if response.code == 302
+          response.headers[:location]
+        else
+          Quandl::Connection.handle_api_error(response) if response
+          fail(QuandlError, 'Unexpected result when fetching bulk download URI.')
+        end
+      end
+      uri = URI.parse(download_url)
+
+      # Check that we can write to the directory
+      file = file_or_folder_path
+      unless file_or_folder_path.is_a?(File)
+        file_or_folder_path = Pathname.new(file_or_folder_path.to_s).join(File.basename(uri.path))
+        file = File.open(file_or_folder_path, 'wb')
+      end
+
+      # Download the file
+      begin
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+        http.request_get(uri.request_uri) do |resp|
+          resp.read_body do |segment|
+            file.write(segment)
+          end
+        end
+      ensure
+        file.close
+      end
+      file.path
+    end
+  end
+end

data/lib/quandl/model/dataset.rb

@@ -0,0 +1,24 @@
+module Quandl
+  class Dataset < ModelBase
+    include Quandl::Operations::Get
+    include Quandl::Operations::List
+
+    # rubocop:disable Style/AccessorMethodName
+    def self.get_path
+      default_path + '/metadata'
+    end
+    # rubocop:enable Style/AccessorMethodName
+
+    def database
+      Quandl::Database.get(database_code)
+    end
+
+    def data(options = {})
+      Quandl::Data.all({ params: { database_code: database_code, dataset_code: dataset_code } }.deep_merge(options))
+    end
+
+    def column_names
+      @raw_data['column_names']
+    end
+  end
+end

data/lib/quandl/model/list.rb

@@ -0,0 +1,45 @@
+module Quandl
+  class List
+    attr_reader :meta
+    attr_reader :values
+
+    def initialize(klass, values, meta)
+      @klass = klass
+      @values = values.map { |v| klass.new(v, meta: meta) }
+      @meta = meta
+    end
+
+    def more_results?
+      fail(QuandlError, "#{@klass} does not support pagination yet") if !@meta.key?('total_pages') && !@meta.key?('current_page')
+      @meta['total_pages'] > @meta['current_page']
+    end
+
+    def to_a
+      @values.map(&:to_a)
+    end
+
+    def to_csv
+      fail(QuandlError, 'No values to export') if @values.empty?
+
+      CSV.generate do |csv|
+        csv << @values.first.column_names
+        @values.each do |row|
+          csv << row.to_a
+        end
+      end
+    end
+
+    def inspect
+      { meta: @meta, values: @values }.to_s
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      return @meta[method_name.to_s] if @meta.key?(method_name.to_s)
+      return @meta[*args] if method_name.to_s == '[]' && @meta.key?(args[0].to_s)
+      return @values.method(method_name).call(*args, &block) if @values.respond_to?(method_name)
+      super
+    end
+  end
+end

data/lib/quandl/operations/base.rb

@@ -0,0 +1,17 @@
+module Quandl
+  module Operations
+    module Base
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def default_path
+          "#{lookup_key}/:id"
+        end
+
+        def lookup_key
+          name.demodulize.pluralize.underscore
+        end
+      end
+    end
+  end
+end

data/lib/quandl/operations/get.rb

@@ -0,0 +1,21 @@
+module Quandl
+  module Operations
+    module Get
+      extend ActiveSupport::Concern
+      include Quandl::Operations::Base
+
+      class_methods do
+        def get(id, options = {})
+          _response, response_data = Quandl::Connection.request(:get, Quandl::Util.constructed_path(get_path, { id: id }.merge(options[:params] || {})), options)
+          new(response_data[lookup_key.singularize])
+        end
+
+        # rubocop:disable Style/AccessorMethodName
+        def get_path
+          default_path
+        end
+        # rubocop:enable Style/AccessorMethodName
+      end
+    end
+  end
+end

data/lib/quandl/operations/list.rb

@@ -0,0 +1,23 @@
+module Quandl
+  module Operations
+    module List
+      extend ActiveSupport::Concern
+      include Quandl::Operations::Base
+
+      class_methods do
+        def all(options = {})
+          response, response_data = Quandl::Connection.request(:get, Quandl::Util.constructed_path(list_path, options[:params]), options)
+          create_list_from_response(response, response_data)
+        end
+
+        def create_list_from_response(_response, data)
+          Quandl::List.new(self, data[lookup_key], data['meta'])
+        end
+
+        def list_path
+          default_path
+        end
+      end
+    end
+  end
+end