eodhd.rb 0.16.0 → 0.18.0

data/lib/Eodhd/Fundamentals/Highlights.rb

@@ -0,0 +1,63 @@
+# Eodhd/Fundamentals/Highlights.rb
+# Eodhd::Fundamentals::Highlights
+
+class Eodhd
+  class Fundamentals
+    class Highlights
+      attr_reader\
+        :market_capitalization,
+        :ebitda,
+        :pe_ratio,
+        :peg_ratio,
+        :wall_street_target_price,
+        :book_value,
+        :dividend_share,
+        :dividend_yield,
+        :earnings_share,
+        :eps_estimate_current_year,
+        :eps_estimate_next_year,
+        :eps_estimate_next_quarter,
+        :eps_estimate_current_quarter,
+        :most_recent_quarter,
+        :profit_margin,
+        :operating_margin_ttm,
+        :return_on_assets_ttm,
+        :return_on_equity_ttm,
+        :revenue_ttm,
+        :revenue_per_share_ttm,
+        :quarterly_revenue_growth_yoy,
+        :gross_profit_ttm,
+        :diluted_eps_ttm,
+        :quarterly_earnings_growth_yoy
+
+      private
+
+      def initialize(data)
+        @market_capitalization = data['MarketCapitalization']
+        @ebitda = data['EBITDA']
+        @pe_ratio = data['PERatio']
+        @peg_ratio = data['PEGRatio']
+        @wall_street_target_price = data['WallStreetTargetPrice']
+        @book_value = data['BookValue']
+        @dividend_share = data['DividendShare']
+        @dividend_yield = data['DividendYield']
+        @earnings_share = data['EarningsShare']
+        @eps_estimate_current_year = data['EPSEstimateCurrentYear']
+        @eps_estimate_next_year = data['EPSEstimateNextYear']
+        @eps_estimate_next_quarter = data['EPSEstimateNextQuarter']
+        @eps_estimate_current_quarter = data['EPSEstimateCurrentQuarter']
+        @most_recent_quarter = data['MostRecentQuarter']
+        @profit_margin = data['ProfitMargin']
+        @operating_margin_ttm = data['OperatingMarginTTM']
+        @return_on_assets_ttm = data['ReturnOnAssetsTTM']
+        @return_on_equity_ttm = data['ReturnOnEquityTTM']
+        @revenue_ttm = data['RevenueTTM']
+        @revenue_per_share_ttm = data['RevenuePerShareTTM']
+        @quarterly_revenue_growth_yoy = data['QuarterlyRevenueGrowthYOY']
+        @gross_profit_ttm = data['GrossProfitTTM']
+        @diluted_eps_ttm = data['DilutedEpsTTM']
+        @quarterly_earnings_growth_yoy = data['QuarterlyEarningsGrowthYOY']
+      end
+    end
+  end
+end

data/lib/Eodhd/Fundamentals/Holders.rb

@@ -0,0 +1,19 @@
+# Eodhd/Fundamentals/Holders.rb
+# Eodhd::Fundamentals::Holders
+
+class Eodhd
+  class Fundamentals
+    class Holders
+      attr_reader\
+        :institutions,
+        :funds
+
+      private
+
+      def initialize(data)
+        @institutions = data['Institutions']
+        @funds = data['Funds']
+      end
+    end
+  end
+end

data/lib/Eodhd/Fundamentals/SharesStats.rb

@@ -0,0 +1,33 @@
+# Eodhd/Fundamentals/SharesStats.rb
+# Eodhd::Fundamentals::SharesStats
+
+class Eodhd
+  class Fundamentals
+    class SharesStats
+      attr_reader\
+        :shares_outstanding,
+        :shares_float,
+        :percent_insiders,
+        :percent_institutions,
+        :shares_short,
+        :shares_short_prior_month,
+        :short_ratio,
+        :short_percent_outstanding,
+        :short_percent_float
+
+      private
+
+      def initialize(data)
+        @shares_outstanding = data['SharesOutstanding']
+        @shares_float = data['SharesFloat']
+        @percent_insiders = data['PercentInsiders']
+        @percent_institutions = data['PercentInstitutions']
+        @shares_short = data['SharesShort']
+        @shares_short_prior_month = data['SharesShortPriorMonth']
+        @short_ratio = data['ShortRatio']
+        @short_percent_outstanding = data['ShortPercentOutstanding']
+        @short_percent_float = data['ShortPercentFloat']
+      end
+    end
+  end
+end

data/lib/Eodhd/Fundamentals/SplitsDividends.rb

@@ -0,0 +1,31 @@
+# Eodhd/Fundamentals/SplitsDividends.rb
+# Eodhd::Fundamentals::SplitsDividends
+
+class Eodhd
+  class Fundamentals
+    class SplitsDividends
+      attr_reader\
+        :forward_annual_dividend_rate,
+        :forward_annual_dividend_yield,
+        :payout_ratio,
+        :dividend_date,
+        :ex_dividend_date,
+        :last_split_factor,
+        :last_split_date,
+        :number_dividends_by_year
+
+      private
+
+      def initialize(data)
+        @forward_annual_dividend_rate = data['ForwardAnnualDividendRate']
+        @forward_annual_dividend_yield = data['ForwardAnnualDividendYield']
+        @payout_ratio = data['PayoutRatio']
+        @dividend_date = data['DividendDate']
+        @ex_dividend_date = data['ExDividendDate']
+        @last_split_factor = data['LastSplitFactor']
+        @last_split_date = data['LastSplitDate']
+        @number_dividends_by_year = data['NumberDividendsByYear']
+      end
+    end
+  end
+end

data/lib/Eodhd/Fundamentals/Technicals.rb

@@ -0,0 +1,33 @@
+# Eodhd/Fundamentals/Technicals.rb
+# Eodhd::Fundamentals::Technicals
+
+class Eodhd
+  class Fundamentals
+    class Technicals
+      attr_reader\
+        :beta,
+        :fifty_two_week_high,
+        :fifty_two_week_low,
+        :fifty_day_ma,
+        :two_hundred_day_ma,
+        :shares_short,
+        :shares_short_prior_month,
+        :short_ratio,
+        :short_percent
+
+      private
+
+      def initialize(data)
+        @beta = data['Beta']
+        @fifty_two_week_high = data['52WeekHigh']
+        @fifty_two_week_low = data['52WeekLow']
+        @fifty_day_ma = data['50DayMA']
+        @two_hundred_day_ma = data['200DayMA']
+        @shares_short = data['SharesShort']
+        @shares_short_prior_month = data['SharesShortPriorMonth']
+        @short_ratio = data['ShortRatio']
+        @short_percent = data['ShortPercent']
+      end
+    end
+  end
+end

data/lib/Eodhd/Fundamentals/Valuation.rb

@@ -0,0 +1,29 @@
+# Eodhd/Fundamentals/Valuation.rb
+# Eodhd::Fundamentals::Valuation
+
+class Eodhd
+  class Fundamentals
+    class Valuation
+      attr_reader\
+        :trailing_pe,
+        :forward_pe,
+        :price_sales_ttm,
+        :price_book_mrq,
+        :enterprise_value,
+        :enterprise_value_revenue,
+        :enterprise_value_ebitda
+
+      private
+
+      def initialize(data)
+        @trailing_pe = data['TrailingPE']
+        @forward_pe = data['ForwardPE']
+        @price_sales_ttm = data['PriceSalesTTM']
+        @price_book_mrq = data['PriceBookMRQ']
+        @enterprise_value = data['EnterpriseValue']
+        @enterprise_value_revenue = data['EnterpriseValueRevenue']
+        @enterprise_value_ebitda = data['EnterpriseValueEbitda']
+      end
+    end
+  end
+end

data/lib/Eodhd/Fundamentals.rb

@@ -0,0 +1,85 @@
+# Eodhd/Fundamentals.rb
+# Eodhd::Fundamentals
+
+require_relative './Fundamentals/AnalystRatings'
+require_relative './Fundamentals/Earnings'
+require_relative './Fundamentals/ESGScores'
+require_relative './Fundamentals/Financials'
+require_relative './Fundamentals/General'
+require_relative './Fundamentals/Highlights'
+require_relative './Fundamentals/Holders'
+require_relative './Fundamentals/SharesStats'
+require_relative './Fundamentals/SplitsDividends'
+require_relative './Fundamentals/Technicals'
+require_relative './Fundamentals/Valuation'
+
+class Eodhd
+  class Fundamentals
+    class << self
+      def all(client: nil, api_token: nil, exchange_code:, symbol:, filter: nil)
+        load(client: client, api_token: api_token, exchange_code: exchange_code, symbol: symbol, filter: filter)
+      end
+
+      private
+
+      def load(client: nil, api_token: nil, exchange_code:, symbol:, filter:)
+        client ||= Client.new(api_token: api_token)
+        response = client.fundamentals(exchange_code: exchange_code, symbol: symbol, filter: filter)
+        self.new(
+          exchange_code: exchange_code,
+          symbol: symbol,
+          general: response['General'],
+          highlights: response['Highlights'],
+          valuation: response['Valuation'],
+          shares_stats: response['SharesStats'],
+          technicals: response['Technicals'],
+          splits_dividends: response['SplitsDividends'],
+          analyst_ratings: response['AnalystRatings'],
+          holders: response['Holders'],
+          insider_transactions: response['InsiderTransactions'],
+          esg_scores: response['ESGScores'],
+          outstanding_shares: response['outstandingShares'],
+          earnings: response['Earnings'],
+          financials: response['Financials']
+        )
+      end
+    end # class << self
+
+    attr_reader\
+      :exchange_code,
+      :symbol,
+      :general,
+      :highlights,
+      :valuation,
+      :shares_stats,
+      :technicals,
+      :splits_dividends,
+      :analyst_ratings,
+      :holders,
+      :insider_transactions,
+      :esg_scores,
+      :outstanding_shares,
+      :earnings,
+      :financials
+
+    private
+
+    def initialize(exchange_code:, symbol:, general:, highlights:, valuation:, shares_stats:, technicals:, splits_dividends:, analyst_ratings:, holders:, insider_transactions:, esg_scores:, outstanding_shares:, earnings:, financials:)
+      @exchange_code = exchange_code
+      @symbol = symbol
+      @general = General.new(general) if general
+      @highlights = Highlights.new(highlights) if highlights
+      @valuation = Valuation.new(valuation) if valuation
+      @shares_stats = SharesStats.new(shares_stats) if shares_stats
+      @technicals = Technicals.new(technicals) if technicals
+      @splits_dividends = SplitsDividends.new(splits_dividends) if splits_dividends
+      @analyst_ratings = AnalystRatings.new(analyst_ratings) if analyst_ratings
+      @holders = Holders.new(holders) if holders
+      @insider_transactions = insider_transactions
+      @esg_scores = ESGScores.new(esg_scores) if esg_scores
+      @outstanding_shares = outstanding_shares
+      @earnings = Earnings.new(earnings) if earnings
+      @financials = Financials.new(financials) if financials
+    end
+  end
+end

data/lib/Eodhd/Intraday.rb

@@ -0,0 +1,76 @@
+# Eodhd/Intraday.rb
+# Eodhd::Intraday
+
+class Eodhd
+  class Intraday
+    class << self
+      def all(client: nil, api_token: nil, exchange_code: 'US', symbol:, interval:, from: nil, to: nil)
+        load(
+          client: client,
+          api_token: api_token,
+          exchange_code: exchange_code,
+          symbol: symbol,
+          interval: interval,
+          from: from,
+          to: to
+        )
+      end
+
+      private
+
+      def load(client: nil, api_token: nil, exchange_code: 'US', symbol:, interval:, from:, to:)
+        client ||= Client.new(api_token: api_token)
+        client.intraday(
+          exchange_code: exchange_code,
+          symbol: symbol,
+          interval: interval,
+          from: from,
+          to: to
+        ).collect do |intraday_data|
+          self.new(
+            exchange_code: exchange_code,
+            symbol: symbol,
+            interval: interval,
+            timestamp: intraday_data['timestamp'],
+            gmtoffset: intraday_data['gmtoffset'],
+            datetime: intraday_data['datetime'],
+            open: intraday_data['open'],
+            high: intraday_data['high'],
+            low: intraday_data['low'],
+            close: intraday_data['close'],
+            volume: intraday_data['volume']
+          )
+        end
+      end
+    end # class << self
+
+    attr_reader\
+      :exchange_code,
+      :symbol,
+      :interval,
+      :timestamp,
+      :gmtoffset,
+      :datetime,
+      :open,
+      :high,
+      :low,
+      :close,
+      :volume
+
+    private
+
+    def initialize(exchange_code:, symbol:, interval:, timestamp:, gmtoffset:, datetime:, open:, high:, low:, close:, volume:)
+      @exchange_code = exchange_code
+      @symbol = symbol
+      @interval = interval
+      @timestamp = timestamp
+      @gmtoffset = gmtoffset
+      @datetime = datetime
+      @open = open
+      @high = high
+      @low = low
+      @close = close
+      @volume = volume
+    end
+  end
+end

data/lib/Eodhd/VERSION.rb

@@ -1,3 +1,3 @@
 class Eodhd
-  VERSION = '0.16.0'
+  VERSION = '0.18.0'
 end

data/lib/Eodhd/Validations.rb

@@ -3,11 +3,12 @@
 
 class Eodhd
   module Validations
-    def validate_arguments(exchange_code: nil, exchange_id: nil, symbol: nil, period: nil, from: nil, to: nil, date: nil)
+    def validate_arguments(exchange_code: nil, exchange_id: nil, symbol: nil, period: nil, interval: nil, from: nil, to: nil, date: nil)
       exchange_code ||= exchange_id
       validate_exchange_code(exchange_code)
       validate_symbol(symbol)
       validate_period(period)
+      validate_interval(interval)
       validate_date(from, 'from')
       validate_date(to, 'to')
       validate_date_range(from, to)
@@ -38,6 +39,14 @@ class Eodhd
       end
     end
 
+    def validate_interval(interval)
+      return unless interval
+      valid_intervals = %w[1m 5m 15m 30m 1h 4h 1d 1w 1mo]
+      unless valid_intervals.include?(interval)
+        raise ArgumentError, "Invalid interval: #{interval}. Must be one of: #{valid_intervals.join(', ')}"
+      end
+    end
+
     def validate_date(date, param_name = 'date')
       return unless date
       case date

data/lib/{Eodhd.rb → eodhd.rb}

@@ -6,45 +6,41 @@ require_relative './Eodhd/EodBulkLastDay'
 require_relative './Eodhd/EodData'
 require_relative './Eodhd/Exchange'
 require_relative './Eodhd/ExchangeSymbol'
+require_relative './Eodhd/Intraday'
+require_relative './Eodhd/Fundamentals'
 require_relative './Eodhd/WebSocketClient'
 
 class Eodhd
-  def initialize(api_token:, consumer: nil)
-    @api_token = api_token
-    @consumer = consumer
-  end
-
   def exchanges
     Eodhd::Exchange.all(api_token: @api_token)
   end
 
   def exchange_symbols(exchange: nil, exchange_code: nil)
-    exchange_code ||= exchange.code
+    exchange_code ||= exchange&.code
     Eodhd::ExchangeSymbol.all(api_token: @api_token, exchange_code: exchange_code)
   end
 
   def eod_data(exchange: nil, exchange_code: nil, exchange_symbol: nil, symbol: nil, period: nil, from: nil, to: nil)
-    exchange_code ||= exchange.code
-    symbol ||= exchange_symbol.code
+    exchange_code ||= exchange&.code
+    symbol ||= exchange_symbol&.code
     Eodhd::EodData.all(api_token: @api_token, exchange_code: exchange_code, symbol: symbol, period: period, from: from, to: to)
   end
 
   def eod_bulk_last_day(exchange: nil, exchange_code: nil, date:)
-    exchange_code ||= exchange.code
+    exchange_code ||= exchange&.code
     Eodhd::EodBulkLastDay.all(api_token: @api_token, exchange_code: exchange_code, date: date)
   end
 
-  def web_socket(asset_class:, symbols:)
-    Eodhd::WebSocketClient.new(
-      api_token: @api_token,
-      asset_class: asset_class,
-      symbols: symbols,
-      consumer: @consumer,
-    )
+  def intraday(exchange: nil, exchange_code: nil, exchange_symbol: nil, symbol: nil, interval:, from: nil, to: nil)
+    exchange_code ||= exchange&.code
+    symbol ||= exchange_symbol&.code
+    Eodhd::Intraday.all(api_token: @api_token, exchange_code: exchange_code, symbol: symbol, interval: interval, from: from, to: to)
   end
 
-  def stream(asset_class:, symbols:)
-    web_socket(asset_class: asset_class, symbols: symbols).run
+  def fundamentals(exchange: nil, exchange_code: nil, exchange_symbol: nil, symbol: nil, filter: nil)
+    exchange_code ||= exchange&.code
+    symbol ||= exchange_symbol&.code
+    Eodhd::Fundamentals.all(api_token: @api_token, exchange_code: exchange_code, symbol: symbol, filter: filter)
   end
 
   def us_trade_stream(symbols)
@@ -63,4 +59,19 @@ class Eodhd
   def crypto_stream(symbols)
     stream(asset_class: 'crypto', symbols: symbols)
   end
+
+  private
+
+  def initialize(api_token:, consumer: nil)
+    @api_token = api_token
+    @consumer = consumer
+  end
+
+  def web_socket(asset_class:, symbols:)
+    Eodhd::WebSocketClient.new(api_token: @api_token, asset_class: asset_class, symbols: symbols, consumer: @consumer)
+  end
+
+  def stream(asset_class:, symbols:)
+    web_socket(asset_class: asset_class, symbols: symbols).run
+  end
 end

data/test/{client_test.rb → Eodhd/Client_test.rb}

@@ -1,12 +1,13 @@
-require_relative "helper"
+# Eodhd/Client_test.rb
+
+require_relative '../helper'
 
 describe Eodhd::Client do
   let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
-
   let(:client){Eodhd::Client.new(api_token: api_token)}
 
   describe "#exchanges_list" do
-    it "exchanges_list returns parsed JSON array" do
+    it "returns parsed JSON array" do
       VCR.use_cassette("client_exchanges_list") do
         result = client.exchanges_list
         _(result).must_be_kind_of(Array)
@@ -22,7 +23,7 @@ describe Eodhd::Client do
   end
 
   describe "#exchange_symbol_list" do
-    it "exchange_symbol_list returns parsed JSON array" do
+    it "returns parsed JSON array" do
       VCR.use_cassette("client_exchange_symbol_list") do
         result = client.exchange_symbol_list(exchange_code: 'AU')
         _(result).must_be_kind_of(Array)
@@ -38,7 +39,7 @@ describe Eodhd::Client do
   end
 
   describe "#eod_data" do
-    it "eod_data returns parsed JSON array" do
+    it "returns parsed JSON array" do
       VCR.use_cassette('client_eod_data') do
         result = client.eod_data(exchange_id: 'AU', symbol: 'BHP', period: 'd')
         _(result).must_be_kind_of(Array)
@@ -54,7 +55,7 @@ describe Eodhd::Client do
   end
 
   describe "#eod_bulk_last_day" do
-    it "eod_bulk_last_day returns parsed JSON array" do
+    it "returns parsed JSON array" do
       VCR.use_cassette("client_eod_bulk_last_day") do
         result = client.eod_bulk_last_day(exchange_id: 'AU', date: "2024-09-30")
         _(result).must_be_kind_of(Array)
@@ -68,4 +69,43 @@ describe Eodhd::Client do
       end
     end
   end
+
+  describe "#intraday" do
+    it "returns parsed JSON array" do
+      VCR.use_cassette('client_intraday') do
+        result = client.intraday(exchange_code: 'US', symbol: 'AAPL', interval: '5m')
+        _(result).must_be_kind_of(Array)
+        _(result.first.keys).must_equal(%w{timestamp gmtoffset datetime open high low close volume})
+      end
+    end
+
+    it "raises Eodhd::Error on failure" do
+      VCR.use_cassette('client_intraday_401_error') do
+        _{client.intraday(exchange_code: 'US', symbol: 'AAPL', interval: '5m')}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+
+  describe "#fundamentals" do
+    it "returns parsed JSON hash" do
+      VCR.use_cassette('client_fundamentals') do
+        result = client.fundamentals(exchange_code: 'US', symbol: 'AAPL')
+        _(result).must_be_kind_of(Hash)
+        _(result['General']).wont_be_nil
+      end
+    end
+
+    it "supports filter parameter" do
+      VCR.use_cassette('client_fundamentals_filtered') do
+        result = client.fundamentals(exchange_code: 'US', symbol: 'AAPL', filter: 'General')
+        _(result).must_be_kind_of(Hash)
+      end
+    end
+
+    it "raises Eodhd::Error on failure" do
+      VCR.use_cassette('client_fundamentals_401_error') do
+        _{client.fundamentals(exchange_code: 'US', symbol: 'AAPL')}.must_raise(Eodhd::Error)
+      end
+    end
+  end
 end

data/test/Eodhd/Fundamentals_test.rb

@@ -0,0 +1,78 @@
+# Eodhd/Fundamentals_test.rb
+
+require_relative '../helper'
+
+describe Eodhd::Fundamentals do
+  let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
+  let(:fd){Eodhd::Fundamentals.all(api_token: api_token, exchange_code: 'US', symbol: 'AAPL')}
+
+  describe ".all" do
+    it "returns an Eodhd::Fundamentals object" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd).must_be_kind_of(Eodhd::Fundamentals)
+      end
+    end
+
+    it "stores exchange_code and symbol" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.exchange_code).must_equal('US')
+        _(fd.symbol).must_equal('AAPL')
+      end
+    end
+
+    it "returns General as an Eodhd::Fundamentals::General" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.general).must_be_kind_of(Eodhd::Fundamentals::General)
+        _(fd.general.code).must_equal('AAPL')
+        _(fd.general.name).wont_be_nil
+      end
+    end
+
+    it "returns Highlights as an Eodhd::Fundamentals::Highlights" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.highlights).must_be_kind_of(Eodhd::Fundamentals::Highlights)
+        _(fd.highlights.market_capitalization).wont_be_nil
+      end
+    end
+
+    it "returns Valuation as an Eodhd::Fundamentals::Valuation" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.valuation).must_be_kind_of(Eodhd::Fundamentals::Valuation)
+      end
+    end
+
+    it "returns Financials as an Eodhd::Fundamentals::Financials" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.financials).must_be_kind_of(Eodhd::Fundamentals::Financials)
+      end
+    end
+
+    it "returns Financials with income_statement, balance_sheet, and cash_flow" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.financials.income_statement).must_be_kind_of(Eodhd::Fundamentals::Financials::Statement)
+        _(fd.financials.balance_sheet).must_be_kind_of(Eodhd::Fundamentals::Financials::Statement)
+        _(fd.financials.cash_flow).must_be_kind_of(Eodhd::Fundamentals::Financials::Statement)
+      end
+    end
+
+    it "returns quarterly and yearly data as hashes on financial statements" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.financials.income_statement.quarterly).must_be_kind_of(Hash)
+        _(fd.financials.income_statement.yearly).must_be_kind_of(Hash)
+      end
+    end
+
+    it "returns Earnings as an Eodhd::Fundamentals::Earnings" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.earnings).must_be_kind_of(Eodhd::Fundamentals::Earnings)
+      end
+    end
+
+    it "returns SharesStats as an Eodhd::Fundamentals::SharesStats" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.shares_stats).must_be_kind_of(Eodhd::Fundamentals::SharesStats)
+        _(fd.shares_stats.shares_outstanding).wont_be_nil
+      end
+    end
+  end
+end