cotcube-bardata 0.1.2 → 0.1.7

data/lib/cotcube-bardata/constants.rb

@@ -2,16 +2,16 @@
 
 module Cotcube
   module Bardata
-
     SYMBOL_EXAMPLES = [
-      { id: "13874U", symbol: "ET", ticksize: 0.25, power: 1.25, months: "HMUZ", bcf: 1.0, reports: "LF", name: "S&P 500 MICRO" },
-      { id: "209747", symbol: "NM", ticksize: 0.25, power: 0.5,  monhts: "HMUZ", bcf: 1.0, reports: "LF", name: "NASDAQ 100 MICRO" }
+      { id: '13874U', symbol: 'ET', ticksize: 0.25, power: 1.25, months: 'HMUZ', bcf: 1.0, reports: 'LF',
+        name: 'S&P 500 MICRO' },
+      { id: '209747', symbol: 'NM', ticksize: 0.25, power: 0.5,  months: 'HMUZ', bcf: 1.0, reports: 'LF',
+        name: 'NASDAQ 100 MICRO' }
     ].freeze
 
-    MONTH_COLOURS  = { 'F' => :cyan,  'G' => :green,   'H' => :light_green,
-                       'J' => :blue,  'K' => :yellow,  'M' => :light_yellow,
-                       'N' => :cyan,  'Q' => :magenta, 'U' => :light_magenta,
-                       'V' => :blue,  'X' => :red,     'Z' => :light_red }.freeze
-
+    MONTH_COLOURS = { 'F' => :cyan, 'G' => :green, 'H' => :light_green,
+                      'J' => :blue,  'K' => :yellow,  'M' => :light_yellow,
+                      'N' => :cyan,  'Q' => :magenta, 'U' => :light_magenta,
+                      'V' => :blue,  'X' => :red,     'Z' => :light_red }.freeze
   end
 end

data/lib/cotcube-bardata/daily.rb

@@ -1,92 +1,154 @@
 # frozen_string_literal: true
 
 module Cotcube
+  # Missing top level documentation comment
   module Bardata
-
     # just reads bardata/daily/<id>/<contract>.csv
-    def provide_daily(symbol: nil, id: nil, contract:, timezone: Time.find_zone('America/Chicago'), config: init)
+    def provide_daily(contract:, # rubocop:disable Metrics/ParameterLists
+                      symbol: nil, id: nil,
+                      range: nil,
+                      timezone: Time.find_zone('America/Chicago'),
+                      config: init)
       contract = contract.to_s.upcase
-      raise ArgumentError, "Contract '#{contract}' is bogus, should be like 'M21' or 'ESM21'" unless contract.is_a? String and [3,5].include? contract.size
-      if contract.to_s.size == 5
-        symbol   = contract[0..1]
-        contract = contract[2..4] 
+      unless contract.is_a?(String) && [3, 5].include?(contract.size)
+        raise ArgumentError, "Contract '#{contract}' is bogus, should be like 'M21' or 'ESM21'"
+      end
+      unless range.nil? ||
+             (range.is_a?(Range) &&
+             [Date, DateTime, ActiveSupport::TimeWithZone].map do |cl|
+               (range.begin.nil? || range.begin.is_a?(cl)) &&
+               (range.end.nil?   || range.end.is_a?(cl))
+             end.reduce(:|))
+
+        raise ArgumentError, 'Range, if given, must be either (Integer..Integer) or (Timelike..Timelike)'
       end
-      unless symbol.nil?
-        symbol_id = symbols.select{|s| s[:symbol] == symbol.to_s.upcase}.first[:id]
-        raise ArgumentError, "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}" if symbol_id.nil?
-        raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if not id.nil? and symbol_id != id
-        id = symbol_id
+
+      unless range.nil?
+        range_begin = range.begin.nil? ? nil : timezone.parse(range.begin.to_s)
+        range_end   = range.end.nil? ? nil : timezone.parse(range.end.to_s)
+        range = (range_begin..range_end)
       end
-      raise ArgumentError, "Could not guess :id or :symbol from 'contract: #{contract}', please clarify." if id.nil?
+
+      sym = get_id_set(symbol: symbol, id: id, contract: contract)
+      contract = contract[2..4] if contract.to_s.size == 5
+      id = sym[:id]
       id_path   = "#{config[:data_path]}/daily/#{id}"
       data_file = "#{id_path}/#{contract}.csv"
-      raise RuntimeError, "No data found for requested :id (#{id_path} does not exist)" unless Dir.exist?(id_path)
-      raise RuntimeError, "No data found for requested contract #{symbol}:#{contract} in #{id_path}." unless File.exist?(data_file)
-      data = CSV.read(data_file, headers: %i[contract date open high low close volume oi] ).map do |row|
+      raise "No data found for requested :id (#{id_path} does not exist)" unless Dir.exist?(id_path)
+
+      raise "No data found for requested contract #{symbol}:#{contract} in #{id_path}." unless File.exist?(data_file)
+
+      data = CSV.read(data_file, headers: %i[contract date open high low close volume oi]).map do |row|
         row = row.to_h
-        row.each do |k, _| 
-          row[k] = row[k].to_f if [:open, :high, :low, :close].include? k
-          row[k] = row[k].to_i if [:volume, :oi].include? k
+        row.each do |k, _|
+          row[k] = row[k].to_f if %i[open high low close].include? k
+          row[k] = row[k].to_i if %i[volume oi].include? k
         end
         row[:datetime] = timezone.parse(row[:date])
+        row[:type]     = :daily
         row
       end
-      data
+      data.pop if data.last[:high].zero?
+      if range.nil?
+        data
+      else
+        data.select do |x|
+          (range.begin.nil? ? true : x[:datetime] >= range.begin) and
+            (range.end.nil? ? true : x[:datetime] <= range.end)
+        end
+      end
     end
-   
-    # reads all files in  bardata/daily/<id> and aggregates by date (what is a pre-stage of a continuous based on daily bars)
+
+    # reads all files in  bardata/daily/<id> and aggregates by date
+    # (what is a pre-stage of a continuous based on daily bars)
     def continuous(symbol: nil, id: nil, config: init, date: nil)
-      unless symbol.nil?
-        symbol_id = symbols.select{|s| s[:symbol] == symbol.to_s.upcase}.first[:id]
-        raise ArgumentError, "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}" if symbol_id.nil?
-        raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if not id.nil? and symbol_id != id
-        id = symbol_id
-      end
-      raise ArgumentError, "Could not guess :id or :symbol, please clarify." if id.nil?
-      id_path    = "#{config[:data_path]}/daily/#{id}"
-      available_contracts = Dir[id_path + '/*.csv'].map{|x| x.split('/').last.split('.').first}.sort_by{|x| x[-7]}.sort_by{|x| x[-6..-5]}
-      data = [] 
-      available_contracts.each do |c| 
-        provide_daily(id: id, config: config, contract: c).each do |x| 
+      sym = get_id_set(symbol: symbol, id: id)
+      id  = sym[:id]
+      id_path = "#{config[:data_path]}/daily/#{id}"
+      available_contracts = Dir["#{id_path}/*.csv"].map { |x| x.split('/').last.split('.').first }
+      available_contracts.sort_by! { |x| x[-7] }.sort_by! { |x| x[-6..-5] }
+      data = []
+      available_contracts.each do |c|
+        provide_daily(id: id, config: config, contract: c).each do |x|
           data << x
         end
       end
-      result = [] 
-      data.sort_by{|x| x[:date]}.group_by{|x| x[:date]}.map{|k,v| 
-        v.map{|x| x.delete(:date)}
+      result = []
+      data.sort_by { |x| x[:date] }.group_by { |x| x[:date] }.map do |k, v|
+        v.map { |x| x.delete(:date) }
         result << {
           date: k,
-          volume: v.map{|x| x[:volume]}.reduce(:+),
-          oi:     v.map{|x| x[:oi    ]}.reduce(:+)
+          volume: v.map { |x| x[:volume] }.reduce(:+),
+          oi: v.map { |x| x[:oi] }.reduce(:+)
         }
         result.last[:contracts] = v
-      } 
-      date.nil? ? result : result.select{|x| x[:date] == date}.first
+      end
+      date.nil? ? result : result.select { |x| x[:date] == date }.first
     end
 
-    # based on .continuous, this methods sorts the prepared dailies continuous for each date on either :volume (default) or :oi
+    def continuous_ml(symbol: nil, id: nil, base: nil)
+      (base.nil? ? Cotcube::Bardata.continuous(symbol: symbol, id: id) : base).map do |x|
+        x[:ml] = x[:contracts].max_by { |z| z[:volume] }[:contract]
+        { date: x[:date], ml: x[:ml] }
+      end
+    end
+
+    # the method above delivers the most_liquid as it is found at the end of the day. D
+    # during trading, the work is done with data
+    # that is already one day old. This is is fixed here:
+    def continuous_actual_ml(symbol: nil, id: nil)
+      continuous =    Cotcube::Bardata.continuous    symbol: symbol, id: id
+      continuous_ml = Cotcube::Bardata.continuous_ml base: continuous
+      continuous_hash = continuous.to_h { |x| [x[:date], x[:contracts]] }
+      actual_ml = continuous_ml.pairwise { |a, b| { date: b[:date], ml: a[:ml] } }
+      actual_ml.map do |x|
+        r = continuous_hash[x[:date]].select { |z| x[:ml] == z[:contract] }.first
+        r = continuous_hash[x[:date]].min_by { |z| -z[:volume] } if r.nil?
+        r
+      end
+    end
+
+    # based on .continuous, this methods sorts the prepared dailies continuous for each date
+    # on either :volume (default) or :oi
     # with this job done, it can provide the period for which a past contract was the most liquid
     #
-    def continuous_overview(symbol: nil, id: nil, config: init, selector: :volume, human: false, filter: nil)
-      raise ArgumentError, "Selector must be either :volume or :oi" unless selector.is_a? Symbol and [:volume, :oi].include? selector
-      
-      unless symbol.nil?
-        symbol_id = symbols.select{|s| s[:symbol] == symbol.to_s.upcase}.first[:id]
-        raise ArgumentError, "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}" if symbol_id.nil?
-        raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if not id.nil? and symbol_id != id
-        id = symbol_id
-      end
-      raise ArgumentError, "Could not guess :id or :symbol, please clarify." if id.nil?
-      data = continuous(id: id, config: config).map{|x| 
+    def continuous_overview(symbol: nil, id: nil, # rubocop:disable Metrics/ParameterLists
+                            config: init,
+                            selector: :volume,
+                            human: false,
+                            filter: nil)
+      raise ArgumentError, 'Selector must be either :volume or :oi' unless selector.is_a?(Symbol) &&
+                                                                           %i[volume oi].include?(selector)
+
+      sym = get_id_set(symbol: symbol, id: id)
+      id  = sym[:id]
+      # noinspection RubyNilAnalysis
+      data = continuous(id: id, config: config).map do |x|
         {
-          date:   x[:date],
-          volume: x[:contracts].sort_by{|x| - x[:volume]}[0..4].compact.select{|x| not x[:volume].zero?},
-          oi:     x[:contracts].sort_by{|x| - x[:oi]}[0..4].compact.select{|x| not x[:oi].zero?}
+          date: x[:date],
+          volume: x[:contracts].sort_by { |z| - z[:volume] }[0..4].compact.reject { |z| z[:volume].zero? },
+          oi: x[:contracts].sort_by { |z| - z[:oi] }[0..4].compact.reject { |z| z[:oi].zero? }
         }
-      }.select{|x| not x[selector].empty? }
-      result = data.group_by{|x| x[selector].first[:contract]}
+      end
+      data.reject! { |x| x[selector].empty? }
+      result = data.group_by { |x| x[selector].first[:contract] }
       if human
-        result.each {|k,v| puts "#{k}\t#{v.first[:date]}\t#{v.last[:date]}" if filter.nil? or v.first[selector].first[:contract][2..4]=~ /#{filter}/ }
+        result.each do |k, v|
+          next unless filter.nil? || v.first[selector].first[:contract][2..4] =~ (/#{filter}/)
+
+          # rubocop:disable Layout/ClosingParenthesisIndentation
+          puts "#{k
+             }\t#{v.first[:date]
+             }\t#{v.last[:date]
+             }\t#{format('%4d', (Date.parse(v.last[:date]) - Date.parse(v.first[:date])))
+             }\t#{result[k].map do |x|
+               x[:volume].select do
+                 x[:contract] == k
+               end
+             end.size
+             }"
+          # rubocop:enable Layout/ClosingParenthesisIndentation
+        end
       end
       result
     end

data/lib/cotcube-bardata/eods.rb

@@ -1,79 +1,122 @@
 # frozen_string_literal: true
 
 module Cotcube
+  # Missing top level documentation
   module Bardata
-
     def most_liquid_for(symbol: nil, id: nil, date: last_trade_date, config: init)
-      unless symbol.nil?
-        symbol_id = symbols.select{|s| s[:symbol] == symbol.to_s.upcase}.first[:id]
-        raise ArgumentError, "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}" if symbol_id.nil?
-        raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if not id.nil? and symbol_id != id
-        id = symbol_id
-      end
-      raise ArgumentError, "Need :id or :symbol." if id.nil?
+      id = get_id_set(symbol: symbol, id: id, config: config)[:id]
       provide_eods(id: id, dates: date, contracts_only: true).first
     end
 
-
-
-    def provide_eods(symbol: nil, 
-                     id: nil, 
-                     contract: nil, 
-                     config: init, 
-                     dates: last_trade_date,   # should accept either a date or datelike or date string OR a range of 2 datelike
-                                               # if omitted returns the eods of last trading date
-                     threshold: 0.1,           # set threshold to 0 to disable filtering at all. otherwise only contracts with partial of >= threshold are returned
-                     filter: :volume_part,     # filter can be set to volume_part and oi_part. determines, which property is used for filtering.
-                     contracts_only: true      # set to false to return the complete row instead of just the contracts matching filter and threshold
-                    )
-      raise ArgumentError, "Contract '#{contract}' is bogus, should be like 'M21' or 'ESM21'" unless contract.nil? or (contract.is_a? String and [3,5].include? contract.size)
-      if contract.to_s.size == 5
-        symbol   = contract[0..1]
-        contract = contract[2..4] 
+    # the following method seems to be garbage. It is not used anywhere. It seems it's purpose
+    # was to retrieve a list of quarters that have not been fetched recently (--> :age)
+    def provide_most_liquids_by_eod(symbol: nil, id: nil, # rubocop:disable Metrics/ParameterLists
+                                    config: init,
+                                    date: last_trade_date,
+                                    filter: :volume_part,
+                                    age: 1.hour)
+      sym  = get_id_set(symbol: symbol, id: id) if symbol || id
+      # noinspection RubyScope
+      eods = provide_eods(id: sym.nil? ? nil : sym[:id], config: config, dates: date, filter: filter)
+      result = []
+      eods.map do |eod|
+        symbol   = eod[0..1]
+        contract = eod[2..4]
+        sym      = symbols.select { |s| s[:symbol] == symbol.to_s.upcase }.first
+        quarter  = "#{config[:data_path]}/quarters/#{sym[:id]}/#{contract}.csv"
+        if File.exist?(quarter)
+          # puts "#{quarter}: #{ Time.now } - #{File.mtime(quarter)} > #{age} : #{Time.now - File.mtime(quarter) > age}"
+          result << eod if Time.now - File.mtime(quarter) > age
+        else
+          result << eod
+        end
       end
-      unless symbol.nil?
-        symbol_id = symbols.select{|s| s[:symbol] == symbol.to_s.upcase}.first[:id]
-        raise ArgumentError, "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}" if symbol_id.nil?
-        raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if not id.nil? and symbol_id != id
-        id = symbol_id
+      result
+    end
+
+    # provide a list of all eods for id/symbol or all symbols (default) for an
+    #   array of dates (default: [last_trade_date])
+    #
+    # filter by :threshold*100% share on entire volume(default) or oi
+    #
+    # return full data or just the contract name (default)
+    def provide_eods(symbol: nil, # rubocop:disable Metrics/ParameterLists
+                     id: nil,
+                     contract: nil,
+                     config: init,
+                     # should accept either a date or date_alike or date string OR a range of 2 dates alike
+                     # if omitted returns the eods of last trading date
+                     dates: last_trade_date,
+                     # set threshold to 0 to disable filtering at all.
+                     # otherwise only contracts with partial of >= threshold are returned
+                     threshold: 0.05,
+                     # filter can be set to volume_part and oi_part.
+                     # determines, which property is used for filtering.
+                     filter: :volume_part,
+                     # set to false to return the complete row instead
+                     # of just the contracts matching filter and threshold
+                     contracts_only: true,
+                     quiet: false)
+      unless contract.nil? || (contract.is_a?(String) && [3, 5].include?(contract.size))
+        raise ArgumentError, "Contract '#{contract}' is bogus, should be like 'M21' or 'ESM21'"
       end
+
+      symbol = contract[0..1] if contract.to_s.size == 5
+      sym = get_id_set(symbol: symbol, id: id, config: config) if symbol || id
       # if no id can be clarified from given arguments, return all matching contracts from all available symbols
       # raise ArgumentError, "Could not guess :id or :symbol from 'contract: #{contract}', please clarify." if id.nil?
-      raise ArgumentError, ":filter must be in [:volume_part, :oi_part]" unless [:volume_part, :oi_part].include? filter
+      raise ArgumentError, ':filter must be in [:volume_part, :oi_part]' unless %i[volume_part oi_part].include? filter
 
-      ids = id.nil? ? symbols.map{|x| x[:id]} : [ id ] 
-      dates = [ dates ] unless dates.is_a? Array or dates.nil?
+      # noinspection RubyScope
+      ids = sym.nil? ? symbols.map { |x| x[:id] } : [sym[:id]]
+      dates = [dates] unless dates.is_a?(Array) || dates.nil?
 
-      id_path_get  = lambda {|_id| "#{config[:data_path]}/eods/#{_id}" } 
+      id_path_get = ->(local_id) { "#{config[:data_path]}/eods/#{local_id}" }
 
-      process_date_for_id = lambda do |d,i| 
-        sym        = symbols.select{|s| s[:id] == i}.first
-        symbol     = sym[:symbol]
+      process_date_for_id = lambda do |d, i|
+        # l_sym        = symbols.select { |s| s[:id] == i }.first
+        # l_symbol     = l_sym[:symbol]
         id_path    = id_path_get.call(i)
         data_file  = "#{id_path}/#{d}.csv"
-        raise RuntimeError, "No data found for requested :id (#{id_path} does not exist)" unless Dir.exist?(id_path)
-        raise RuntimeError, "No data found for requested contract #{symbol}:#{contract} in #{id_path}." unless File.exist?(data_file)
-        data = CSV.read(data_file, headers: %i[contract date open high low close volume oi] ).map do |row|
+        raise "No data found for requested :id (#{id_path} does not exist)" unless Dir.exist?(id_path)
+
+        unless File.exist?(data_file)
+          unless quiet
+            puts 'WARNING: No data found for requested id/symbol'\
+            " #{id}/#{symbol} in #{id_path} for #{d}.".colorize(:light_yellow)
+          end
+          return []
+        end
+        data = CSV.read(data_file, headers: %i[contract date open high low close volume oi]).map do |row|
           row = row.to_h
-          row.each do |k, _| 
-            row[k] = row[k].to_f if [:open, :high, :low, :close].include? k
-            row[k] = row[k].to_i if [:volume, :oi].include? k
+          row.each do |k, _|
+            row[k] = row[k].to_f if %i[open high low close].include? k
+            row[k] = row[k].to_i if %i[volume oi].include? k
           end
           row
         end
-        all_volume = data.map{|x| x[:volume] }.reduce(:+)
-        all_oi     = data.map{|x| x[:oi]     }.reduce(:+)
-        data.map{|x| x[:volume_part] = (x[:volume] / all_volume.to_f).round(4); x[:oi_part] = (x[:oi] / all_oi.to_f).round(4) }
-        data.select{|x| x[filter] >= threshold}.sort_by{|x| -x[filter]}.tap{|x| x.map!{|y| y[:contract]} if contracts_only}
+        all_volume = data.map { |x| x[:volume] }.reduce(:+)
+        all_oi     = data.map { |x| x[:oi]     }.reduce(:+)
+        data.map do |x|
+          x[:volume_part] = (x[:volume] / all_volume.to_f).round(4)
+          x[:oi_part]     = (x[:oi] / all_oi.to_f).round(4)
+        end
+        data.select { |x| x[filter] >= threshold }.sort_by { |x| -x[filter] }.tap do |x|
+          if contracts_only
+            x.map! do |y|
+              y[:contract]
+            end
+          end
+        end
       end
       if dates
-        dates.map do |date| 
-          ids.map{|id| process_date_for_id.call(date, id) }
+        dates.map do |date|
+          ids.map { |local_id| process_date_for_id.call(date, local_id) }
         end.flatten
       else
-        raise ArgumentError, "Sorry, support for unlimited dates is not implemented yet. Please send array of dates or single date"
+        raise ArgumentError,
+              'Sorry, support for unlimited dates is not implemented yet. Please send array of dates or single date'
       end
     end
-
   end
 end

data/lib/cotcube-bardata/helpers.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Cotcube
+  # Missing top level documentation comment
+  module Bardata
+    # small helper to select a specific full trading day from quarters (or reduced)
+    #   this special handling is needed, as full trading days start '5pm CT yesterday'
+    def select_specific_date(date:, base:)
+      base.select do |d|
+        d[:day] == date.day and date.year == d[:datetime].year and (
+        if date.day > 1
+          date.month == d[:datetime].month
+        else
+          ((date.month == d[:datetime].month     and d[:datetime].day == 1) or
+           (date.month == d[:datetime].month + 1 and d[:datetime].day > 25))
+        end
+      )
+      end
+    end
+
+    # diminishes a given base of bars to fit into a given range (DO NOT CONFUSE with trading_hours)
+    # note that the last bar is simply required to _start_ within the given range, not to end withing
+    def extended_select_for_range(base:,
+                                  range: ('1900-01-01'...'2100-01-01'),
+                                  timezone: Time.find_zone('America/Chicago'),
+                                  quiet: false)
+
+      starting = range.begin
+      starting = timezone.parse(starting) if starting.is_a? String
+      ending   = range.end
+      ending   = timezone.parse(ending) if ending.is_a? String
+      puts "#{starting}\t#{ending}" unless quiet
+      if starting.hour.zero? && starting.min.zero? && ending.hour.zero? && ending.min.zero?
+        unless quiet
+          puts 'WARNING: When sending midnight, full trading day'\
+            ' is assumed (starting 5 pm CT yesterday, ending 4 pm CT today)'.colorize(:light_yellow)
+        end
+        result = select_specific_date(date: starting, base: base)
+        result += base.select { |d| d[:datetime] > starting and d[:datetime] < ending.to_date }
+        result += select_specific_date(date: ending, base: base)
+        result.uniq!
+      else
+        result = base.select { |x| x[:datetime] >= starting and x[:datetime] < ending }
+      end
+      result
+    end
+
+    def get_id_set(symbol: nil, id: nil, contract: nil, config: init)
+      if contract.is_a?(String) && (contract.length == 5)
+        c_symbol = contract[0..1]
+        if (not symbol.nil?) && (symbol != c_symbol)
+          raise ArgumentError,
+                "Mismatch between given symbol #{symbol} and contract #{contract}"
+        end
+
+        symbol = c_symbol
+      end
+
+      unless symbol.nil?
+        sym = symbols.select { |s| s[:symbol] == symbol.to_s.upcase }.first
+        if sym.nil? || sym[:id].nil?
+          raise ArgumentError,
+                "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}"
+        end
+        raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if (not id.nil?) && (sym[:id] != id)
+
+        return sym
+      end
+      unless id.nil?
+        sym = symbols.select { |s| s[:id] == id.to_s }.first
+        if sym.nil? || sym[:id].nil?
+          raise ArgumentError,
+                "Could not find match in #{config[:symbols_file]} for given id #{id}"
+        end
+        return sym
+      end
+      raise ArgumentError, 'Need :id, :symbol or valid :contract '
+    end
+
+    def compare(contract:, format: '%5.2f')
+      format = "%#{format}" unless format[0] == '%'
+      daily = provide(contract: contract, interval: :daily)
+      full  = provide(contract: contract, interval: :days, filter: :full)
+      rth   = provide(contract: contract, interval: :days, filter: :rth)
+      rth_dates = rth.map { |x| x[:datetime] }
+      daily.select! { |x| rth_dates.include? x[:datetime].to_datetime }
+      full.select! {  |x| rth_dates.include? x[:datetime].to_datetime }
+
+      printer = lambda { |z|
+           # rubocop:disable Layout/ClosingParenthesisIndentation
+           "#{z[:datetime].strftime('%m-%d') # rubocop:disable Layout/IndentationWidth
+         }\t#{format format, z[:open]
+         }\t#{format format, z[:high]
+         }\t#{format format, z[:low]
+         }\t#{format format, z[:close]
+         }\t#{format '%7d', z[:volume]}"
+        # rubocop:enable Layout/ClosingParenthesisIndentation
+      }
+      daily.each_with_index do |_x, i|
+        puts "DAILY #{printer.call daily[i]}"
+        puts "FULL  #{printer.call full[i]}"
+        puts "RTH   #{printer.call rth[i]}"
+        puts ' '
+      end
+    end
+  end
+end