alphavantagerb 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45b9bfaa0883fbcebabc5b26972fd66f736df2c4
-  data.tar.gz: 9407ed9a0c3761d8ba70bf79a19678bc7b614ac8
+  metadata.gz: 743749f1cf99b12c71e4c5550074305f1c7b04a5
+  data.tar.gz: 5640ecf935bc22da9f2dc6577e138e1f3846a43c
 SHA512:
-  metadata.gz: d07776377781826d1778768bad668cf5125f3e8856b52828c27b0d3a45bfe18907023739cd0d4884af890ce9727f528c4775e02f502fac9970980e48dcdb0bf3
-  data.tar.gz: 60945c1de9ffc3d0c08dff5b65b87cf3cba61615f32d61107e17f3ffcf9db5afa8570f6abb978cc61069bcc31385ff4e46cc354418728ea0a455f768b31bda9f
+  metadata.gz: f46bf5a084371e19873eb21cc8ece703da94469fa079b933db4cc79f6d8b194adf0d280bb75c29f196ab7ce92c111a88b887af2156aa58faefce6e4906735bc0
+  data.tar.gz: 7bd15d518d533a731935bfaeca3b30a986e087a35be39562b97e7cf0d0f357b4ff84a3fd29e0133c5f5e422095b9577fcec7be2ab9d8442b5d3b79637aa0540d

data/AlphavantageRB.gemspec

@@ -4,7 +4,7 @@ require "rake"
 
 Gem::Specification.new do |s|
   s.name        = "alphavantagerb"
-  s.version	    = "1.2.0"
+  s.version	    = "1.3.0"
   s.authors     = ["Stefano Martin"]
   s.email       = ["stefano.martin87@gmail.com"]
   s.homepage    = "https://github.com/StefanoMartin/AlphaVantageRB"

data/README.md

@@ -10,6 +10,16 @@ To install AlphavantageRB: `gem install alphavantagerb`
 
 To use it in your application: `require "alphavantagerb"`
 
+## How to test
+
+To test the Gem create a config.yml file inside the folder /spec with inside a line
+``` ruby
+key: [YOUR KEY]
+```
+
+Then run "rspec spec/test_all.rb".
+Since AlphaVantage does not permit more than 5 request for minutes, many of your tests will fail. I advice either having a premium account or, like me, trying each file of test from the folder "spec/lib/1.0.0".
+
 ## Classes
 
 AlphavantateRB has the following classes:
@@ -18,12 +28,12 @@ AlphavantateRB has the following classes:
   Vantage
 * [Alphavantage::Stock](#Stock): to create a stock class
 * [Alphavantage::Timeseries](#Timeseries): to retrieve historical data of a stock
-* [Alphavantage::Batch](#Batch): to retrieve multiple stock data at once
 * [Alphavantage::Indicator](#Indicator): to use some technical indicator of a stock
 * [Alphavantage::Crypto](#Crypto): to create a crypto currency class
 * [Alphavantage::Crypto_Timeseries](#Crypto_Timeseries): to retrieve historical
   data of a crypto currency
 * [Alphavantage::Exchange](#Exchange): to retrieve how a currency is exchanged currently on the market
+* [Alphavantage::Exchange_Timeseries](#Exchange_Timeseries): to retrieve historical data of how a currency is exchanged currently on the market
 * [Alphavantage::Sector](#Sector): to retrieve the status of the historical sector performances calculated from S&P500 incumbents
 * [Alphavantage::Error](#Error): to manage AlphavantageRB errors
 
@@ -42,7 +52,32 @@ If you want to see the request that the client will do to Alpha Vantage you can
 setup verbose equal to true.
 
 ``` ruby
-client.verbose = true # You can setup this during the initialization too
+  client.verbose = true # You can setup this during the initialization too
+```
+
+You can use the method search to find some stocks by name.
+``` ruby
+  stocks_found = client.search keywords: "MSFT"
+  stocks_found.output # Return the hash retrieved
+```
+
+This will return an array where each elements has the following structure:
+``` ruby
+  stocks_found.stocks[0].symbol
+  stocks_found.stocks[0].name
+  stocks_found.stocks[0].type
+  stocks_found.stocks[0].region
+  stocks_found.stocks[0].marketopen
+  stocks_found.stocks[0].marketclose
+  stocks_found.stocks[0].timezone
+  stocks_found.stocks[0].currency
+  stocks_found.stocks[0].matchscore
+```
+
+Furthermore you can retrieve its respective AlphaVantage::Stock instance by using:
+
+``` ruby
+  stocks_found.stocks[0].stock
 ```
 
 <a name="Stock"></a>
@@ -67,7 +102,7 @@ Note that the initialization owns different entry:
 You can setup the datatype of future retrieving by doing:
 
 ``` ruby
-stock.datatype = "csv"
+  stock.datatype = "csv"
 ```
 
 <a name="Timeseries"></a>
@@ -96,7 +131,7 @@ Note that the initialization owns different entries:
 
 You can retrieve all the output from Alpha Vantage by doing.
 ``` ruby
-  timeseries.hash
+  timeseries.output
 ```
 
 Specific information about the timeseries can be retrieved using the following methods:
@@ -131,44 +166,6 @@ You can order the data in ascending or descending order.
   timeseries.open("asc")
 ```
 
-<a name="Batch"></a>
-## Alphavantage::Batch
-
-Alphavantage::Batch is used to retrieve the last updated values of multiple stocks.
-To create a new Batch class you can use a Client class or you can create it directly.
-These two creation commands are equivalent:
-
-``` ruby
-batch = client.batch symbols: ["MSFT", "FB", "AAPL"]
-batch = Alphavantage::Batch.new symbols: ["MSFT", "FB", "AAPL"], key: "YOURKEY"
-```
-
-Note that the initialization owns different entries:
-* symbols: it is an array of string that denote the stocks you want to retrieve.
-* key: authentication key.  This value cannot be setup if you are initializing a batch from a client
-* verbose: used to see the request to Alpha Vantage (default false). This value cannot be setup if you are initializing a batch from a client
-* datatype: it can be "json" or "csv" (default "json")
-* file: path where a csv file should be saved (default "nil")
-
-You can retrieve all the output from Alpha Vantage by doing.
-``` ruby
-  batch.hash
-```
-
-The array of the stocks is found by using:
-``` ruby
-  batch.stock_quotes
-```
-
-Specific information about the batch can be retrieved using the following methods:
-
-``` ruby
-  batch.information # Retrieve information about the batch
-  batch.symbols # Symbols used by the batch
-  batch.notes # Generic notes of the batch
-  batch.time_zone # Time zone of the batch
-```
-
 <a name="Indicator"></a>
 ## Alphavantage::Indicator
 
@@ -201,7 +198,7 @@ The MA parameters accept as an entry one of these attributes: "0", "1", "2", "3"
 Each indicator has several methods that can use in relation of the type. Some are used for each indicator.
 ``` ruby
 indicator = stock.indicator(function: "SMA", interval: "weekly", time_period: "60", series_type: "close")
-indicator.hash # Retrieve the output from Alpha vantage
+indicator.output # Retrieve the output from Alpha vantage
 indicator.symbol
 indicator.interval
 indicator.indicator
@@ -680,7 +677,7 @@ Note that the initialization owns different entries:
 
 You can retrieve all the output from Alpha Vantage by doing.
 ``` ruby
-  crypto_timeseries.hash
+  crypto_timeseries.output
 ```
 
 Specific information about the timeseries can be retrieved using the following methods:
@@ -740,24 +737,82 @@ Note that the initialization owns different entry:
 * verbose: used to see the request to Alpha Vantage (default false). This value cannot be setup if you are initializing a timeseries from a stock
 * datatype: it can be "json" or "csv" (default "json")  
 
-You can retrieve all the output from Alpha Vantage by doing.
+You can retrieve the actual situation of the exchange from Alpha Vantage by doing.
 ``` ruby
-  exchange.hash
+  ex_now = exchange.now
 ```
 
 Other information can be retrieved using the following methods:
 
 ``` ruby
-  exchange.from_currency_code # Code of the from currency
-  exchange.from_currency_name # Name of the from currency
-  exchange.to_currency_code  # Code of the to currency
-  exchange.to_currency_name # Name of the to currency
-  exchange.exchange_rate # Exchange rate between the two currencies
-  exchange.information # Retrieve information about the timeseries
-  exchange.symbol # Symbol used by the timeseries
+  ex_now.from_currency_code # Code of the from currency
+  ex_now.from_currency_name # Name of the from currency
+  ex_now.to_currency_code  # Code of the to currency
+  ex_now.to_currency_name # Name of the to currency
+  ex_now.exchange_rate # Exchange rate between the two currencies
+  ex_now.information # Retrieve information about the timeseries
+  ex_now.symbol # Symbol used by the timeseries
   exchange.last_refreshed # A timestamp that show when last time the data were refreshed
-  exchange.output_size # Size of the output
-  exchange.time_zone # Time zone of the timeseries
+  ex_now.output_size # Size of the output
+  ex_now.time_zone # Time zone of the timeseries
+```
+
+<a name="Exchange_Timeseries"></a>
+## Alphavantage::Exchange_Timeseries
+
+Alphavantage::Exchange_Timeseries is used to retrieve historical data of an exchange currency.
+To create a new Exchange_Timeseries class you can use an Exchange class or you can create it directly.
+These two creation commands are equivalent:
+
+``` ruby
+exchange_timeseries = exchange.timeseries type: "daily"
+exchange_timeseries = Alphavantage::Exchange_Timeseries.new from: "USD", to: "DKK", key: "YOURKEY", type: "daily"
+```
+
+Note that the initialization owns different entries:
+* symbol: it is a string that denote the stock you want to retrieve. This value cannot be setup if you are initializing a timeseries from a stock
+* key: authentication key.  This value cannot be setup if you are initializing a timeseries from a stock
+* verbose: used to see the request to Alpha Vantage (default false). This value cannot be setup if you are initializing a timeseries from a stock
+* type: it can be "intraday", "daily", "weekly", "monthly" (default "daily")
+* adjusted: a boolean value, it returns adjusted values (default false)
+* interval: it can be "1min", "5min", "15min", "30min", or "60min". It is used
+  only if type is "intraday" (default nil)
+* outputsize: it can be "compact", or "full" (default "compact")
+* datatype: it can be "json" or "csv" (default "json")
+* file: path where a csv file should be saved (default "nil")
+
+You can retrieve all the output from Alpha Vantage by doing.
+``` ruby
+  exchange_timeseries.output
+```
+
+Specific information about the timeseries can be retrieved using the following methods:
+
+``` ruby
+  exchange_timeseries.information # Retrieve information about the timeseries
+  exchange_timeseries.from_symbol # Code of the from symbol
+  exchange_timeseries.to_symbol # Code of the to symbol
+  exchange_timeseries.last_refreshed # A timestamp that show when last time the data were refreshed
+  exchange_timeseries.output_size # Size of the output
+  exchange_timeseries.time_zone # Time zone of the timeseries
+```
+
+Specific data can be retrieved using the following methods.
+These methods will return an array of couples where the first entry is a timestampand the second one is the value of the stock at the timestamp.
+These timeseries return always the corrispective timeseries in relation of the USD market.
+
+``` ruby
+  exchange_timeseries.open
+  exchange_timeseries.close
+  exchange_timeseries.high
+  exchange_timeseries.low
+```
+
+You can order the data in ascending or descending order.
+
+``` ruby
+  exchange_timeseries.open("desc") # Default
+  exchange_timeseries.open("asc")
 ```
 
 <a name="Sector"></a>
@@ -777,7 +832,7 @@ Note that the initialization owns different entries:
 
 You can retrieve all the output from Alpha Vantage by doing.
 ``` ruby
-  sector.hash
+  sector.output
 ```
 
 Specific information about the timeseries can be retrieved using the following methods:

data/lib/Client.rb

@@ -51,16 +51,31 @@ module Alphavantage
       return "CSV saved in #{file}"
     end
 
-    def batch(symbols:, datatype: "json", file: nil)
-      Alphavantage::Batch.new symbols: symbols, key: self, datatype: datatype, file: file
+    def search(keywords:, datatype: "json", file: nil)
+      check_datatype(datatype, file)
+      url = "function=SYMBOL_SEARCH&keywords=#{keywords}"
+      return download(url, file) if datatype == "csv"
+      output = OpenStruct.new
+      output.output = request(url)
+      bestMatches = output.output.dig("bestMatches") || {}
+      output.stocks = bestMatches.map do |bm|
+        val = OpenStruct.new
+        bm.each do |key, valz|
+          key_sym = recreate_metadata_key(key)
+          val[key_sym] = valz
+        end
+        val.stock = Alphavantage::Stock.new(symbol: bm["1. symbol"], key: self)
+        val
+      end
+      return output
     end
 
     def stock(symbol:, datatype: "json")
       Alphavantage::Stock.new symbol: symbol, key: self, datatype: datatype
     end
 
-    def exchange(from:, to:)
-      Alphavantage::Exchange.new from: from, to: to, key: self
+    def exchange(from:, to:, datatype: "json")
+      Alphavantage::Exchange.new from: from, to: to, key: self, datatype: datatype
     end
 
     def crypto(symbol:, market:, datatype: "json")

data/lib/Crypto_Timeseries.rb

@@ -7,17 +7,13 @@ module Alphavantage
       check_argument([true, false], verbose, "verbose")
       @client = return_client(key, verbose)
       check_argument(["json", "csv"], datatype, "datatype")
-      if datatype == "csv" && file.nil?
-        raise Alphavantage::Error.new message: "No file specified where to save the CSV data"
-      elsif datatype != "csv" && !file.nil?
-        raise Alphavantage::Error.new message: "Hash error: No file necessary"
-      end
+      check_datatype(datatype, file)
 
-      @selected_time_series = which_series(type)
+      @selected_time_series = which_series(type, "DIGITAL_CURRENCY")
       url = "function=#{@selected_time_series}&symbol=#{symbol}&market=#{market}"
       return @client.download(url, file) if datatype == "csv"
-      @hash = @client.request(url)
-      metadata = @hash.dig("Meta Data") || {}
+      @output = @client.request(url)
+      metadata = @output.dig("Meta Data") || {}
       metadata.each do |key, val|
         key_sym = key.downcase.gsub(/[0-9.]/, "").lstrip.gsub(" ", "_").to_sym
         define_singleton_method(key_sym) do
@@ -29,10 +25,10 @@ module Alphavantage
       @market_cap_usd = [];
 
       begin
-        time_series = @hash.find{|key, val| key.include?("Time Series")}[1]
+        time_series = @output.find{|key, val| key.include?("Time Series")}[1]
       rescue Exception => e
         raise Alphavantage::Error.new message: "No Time Series found: #{e.message}",
-          data: @hash
+          data: @output
       end
 
       series = {}
@@ -55,13 +51,6 @@ module Alphavantage
       end
     end
 
-    attr_reader :hash
-
-    def which_series(type)
-      check_argument(["intraday", "daily", "weekly", "monthly"], type, "type")
-      series = "DIGITAL_CURRENCY_"
-      series += type.upcase
-      return series
-    end
+    attr_reader :output
   end
 end

data/lib/Exchange.rb

@@ -2,22 +2,34 @@ module Alphavantage
   class Exchange
     include HelperFunctions
 
-    def initialize from:, to:, key:, verbose: false
+    def initialize from:, to:, key:, verbose: false,
+      datatype: "json"
       check_argument([true, false], verbose, "verbose")
       @client = return_client(key, verbose)
       @from = from
       @to = to
-      @hash = @client.request("function=CURRENCY_EXCHANGE_RATE&from_currency=#{@from}&to_currency=#{@to}")
-      hash = @hash["Realtime Currency Exchange Rate"]
-      hash.each do |key, val|
-        key_sym = recreate_metadata_key(key)
-        define_singleton_method(key_sym) do
-          return val
-        end
-      end
+      check_argument(["json", "csv"], datatype, "datatype")
+      @datatype = datatype
     end
 
-    attr_reader :hash
+    attr_accessor :from, :to
+    attr_reader :datatype
 
+    def datatype=(datatype)
+      check_argument(["json", "csv"], datatype, "datatype")
+      @datatype = datatype
+    end
+
+    def now(datatype: @datatype, file: nil)
+      url = "function=CURRENCY_EXCHANGE_RATE&from_currency=#{@from}&to_currency=#{@to}"
+      check_datatype(datatype, file)
+      return @client.download(url, file) if datatype == "csv"
+      return open_struct(url, "Realtime Currency Exchange Rate")
+    end
+
+    def timeseries from: @from, to: @to, type: "intraday", file: nil, datatype: @datatype, interval: nil, outputsize: "compact"
+      Alphavantage::Exchange_Timeseries.new from: from, to: to, type: type, datatype: datatype, file: file, key: @client, interval: interval,
+        outputsize: outputsize
+    end
   end
 end

data/lib/Exchange_Timeseries.rb

@@ -0,0 +1,63 @@
+module Alphavantage
+  class Exchange_Timeseries
+    include HelperFunctions
+
+    def initialize type: "intraday", from:, to:, datatype: "json", file: nil,
+      key:, verbose: false, outputsize: "compact", interval: nil
+      check_argument([true, false], verbose, "verbose")
+      @client = return_client(key, verbose)
+      if type == "intraday"
+        interval ||= "1min"
+        check_argument(["1min", "5min", "15min", "30min", "60min"], interval, "interval")
+        interval = "&interval=#{interval}"
+      else
+        check_argument([nil], interval, "interval")
+        interval = ""
+      end
+      check_argument(["compact", "full"], outputsize, "outputsize")
+      check_argument(["json", "csv"], datatype, "datatype")
+      check_datatype(datatype, file)
+
+      @selected_time_series = which_series(type, "FX")
+      url = "function=#{@selected_time_series}&from_symbol=#{from}&to_symbol=#{to}#{interval}&outputsize=#{outputsize}"
+      return @client.download(url, file) if datatype == "csv"
+      @output = @client.request(url)
+      metadata = @output.dig("Meta Data") || {}
+      metadata.each do |key, val|
+        key_sym = key.downcase.gsub(/[0-9.]/, "").lstrip.gsub(" ", "_").to_sym
+        define_singleton_method(key_sym) do
+          return val
+        end
+      end
+      @open = []; @high = []; @low = []; @close = [];
+
+      begin
+        time_series = @output.find{|key, val| key.include?("Time Series")}[1]
+      rescue Exception => e
+        raise Alphavantage::Error.new message: "No Time Series found: #{e.message}",
+          data: @output
+      end
+
+      series = {}
+      convert_key = {}
+      time_series.values[0].keys.each do |key|
+        key_sym = recreate_metadata_key(key)
+        series[key_sym] = []
+        convert_key[key] = key_sym
+      end
+      time_series.each do |time, ts_hash|
+        ts_hash.each do |key, value|
+          series[convert_key[key]] << [time, value]
+        end
+      end
+      series.keys.each do |key_sym|
+        define_singleton_method(key_sym) do |*args|
+          args ||= []
+          return return_series(series[key_sym], args[0])
+        end
+      end
+    end
+
+    attr_reader :output
+  end
+end