cotcube-bardata 0.1.5 → 0.1.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6685b99ba2fcbd933356ebefad21f83c3ec641101b8772419c030b3d197f0de
-  data.tar.gz: 825d415ff9c9f3a5ffe072ff1cec47e8238ce63399c9c7519e7a496392aef4f8
+  metadata.gz: 42d2c651e2e0cc53cbd35ea0ea824e82828930bee04d1bce9a52edf9b70c54f1
+  data.tar.gz: 388c35d25810c30a73136e66e0e204473dd2646f2ea776c23a476b8cb769afb7
 SHA512:
-  metadata.gz: dff1e21c1076d0d566a088a0e8af2955abaf4d9d3c26ddfa33685f4b8fa660744dfbd3210ede01badf71bd85398cb064d292f0ec6998f7784d3db4f06bac2b88
-  data.tar.gz: ed811a9909dc7c08b08030c07b8c4ee811c13e1313a7481d8747f4ca4107b0597f5abde1e2eb8f78ac907e15f37aa494398144df565e354b00042b41bc00265e
+  metadata.gz: 705ded304d33270f8133a5e297a807a56288b7a710ac12f6aa2896f4971c2302f6e5a3a9b229c8c513489abb32bbe3079e0f60bdf094756935f19a6d84d7d276
+  data.tar.gz: e36f72ffc6dbf098a86b647932f8d881016477ebb74223b8db12f75f3e9c58f4962eef7da5992838c72538d1e18545f647b4df104554e70727ba45694b55de59

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 0.1.9.2 (February 07, 2021)
+  - minor changes
+  - daily#continuous_table: introducing debuglevel
+
+## 0.1.9.1 (January 29, 2021)
+  - provide: added new interval 'synth', mixing available dailies with synthetic days based on quarters
+  - minor change / cleanup
+  - setting gemspec to use rake 13 and changing version spec to overcome warnings
+
+## 0.1.8 (January 27, 2021)
+  - in helpers, #extended_range_for_date: fixed comparison signs
+  - range_matrix: applied cops, noted appearance of Cotcube::Helpers.simple_series_stats
+  - cached: Fixing wrong comparison sign
+  - daily: slimmed down results for #continuous_overview
+
+## 0.1.7 (January 14, 2021)
+  - added :range parameter to :provide, hence to :provide_cached, :provide_daily
+  - added forgotten module_functions
+
+## 0.1.6 (January 07, 2021)
+  - prefering datetime instead date (in helpers and daily)
+  - changed keyword :set to :filter in cached, provide and trading_hours
+
 ## 0.1.5 (January 02, 2021)
   - applied some still missing cops
 

data/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.9.2

data/cotcube-bardata.gemspec

@@ -34,7 +34,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'parallel',           '~> 1'
   spec.add_dependency 'yaml',               '~> 0.1'
 
-  spec.add_development_dependency 'rake',  '>= 12'
+  # using ~> in favor of >= to overcome warning
+  spec.add_development_dependency 'rake',  '~> 13'
   spec.add_development_dependency 'rspec', '~>3.6'
-  spec.add_development_dependency 'yard', '~>0.9'
+  spec.add_development_dependency 'yard',  '~>0.9'
 end

data/lib/cotcube-bardata.rb

@@ -52,6 +52,8 @@ module Cotcube
                     :continuous_actual_ml,
                     # based on continuous, create list of when which contract was most liquid
                     :continuous_overview,
+                    # provider estimation of current ML usability
+                    :continuous_table,
                     # provide the list of quarters, possibly as hours or days.
                     :provide_quarters,
                     # some statistics to estimate daily volatility of specific contract
@@ -60,6 +62,9 @@ module Cotcube
                     :trading_hours,
                     # receive id / symbol information on an uncertain set of parameters
                     :get_id_set,
+                    :select_specific_date,
+                    :extended_select_for_range,
+                    :provide_cached,
                     :compare,
                     :holidays,
                     :symbols # reads and provides the symbols file

data/lib/cotcube-bardata/cached.rb

@@ -6,12 +6,29 @@ module Cotcube
     # send pre-created days based on quarters
     def provide_cached(contract:, # rubocop:disable Metrics/ParameterLists
                        symbol: nil, id: nil,
+                       range: nil,
                        config: init,
+                       debug: false,
                        timezone: Time.find_zone('America/Chicago'),
                        filter: :full, # most probably either :full or :rth
                        force_update: false, # force reloading via provide_quarters
                        force_recent: false) #
 
+      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 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
+
       headers = %i[contract datetime open high low close volume]
       sym      = get_id_set(symbol: symbol, id: id, contract: contract)
       contract = contract[-3..]
@@ -33,18 +50,40 @@ module Cotcube
         if base.last[:high].zero?
           # contract exists but is closed (has the CLOSED marker)
           base.pop
-          return base
-        elsif File.mtime(file) < File.mtime(quarters_file)
-          return base
+          # rubocop:disable Metrics/BlockNesting
+          result = if range.nil?
+                     base
+                   else
+                     base.select do |x|
+                       (range.begin.nil? ? true : x[:datetime] >= range.begin) and
+                         (range.end.nil? ? true : x[:datetime] <= range.end)
+                     end
+                   end
+          return result
+        elsif File.mtime(file) + 1.day > File.mtime(quarters_file)
+          puts "CACHE #{File.mtime(file)}\t#{file}" if debug
+          puts "QUART #{File.mtime(quarters_file)}\t#{quarters_file}" if debug
+          result = if range.nil?
+                     base
+                   else
+                     base.select do |x|
+                       (range.begin.nil? ? true : x[:datetime] >= range.begin) and
+                         (range.end.nil? ? true : x[:datetime] <= range.end)
+                     end
+                   end
+          # rubocop:enable Metrics/BlockNesting
+          return result
         else
-          puts "File #{file} exists, but is neither closed nor current. Running update.".colorize(:light_green)
+          # write a (positive warning, that the cache needs to be updated, as cached value is older
+          #   than one day but not closed
+          puts "File #{file} exists, but is neither closed nor current. Running update...".colorize(:light_green)
         end
       end
       begin
         data = provide_quarters(contract: contract, id: sym[:id], keep_marker: true)
       rescue StandardError
         puts "Cannot provide quarters for requested contract #{sym[:symbol]}:#{contract},"\
-             "returning '[ ]'".colorize(:light_red)
+            "returning '[ ]'".colorize(:light_red)
         return []
       end
 
@@ -52,13 +91,13 @@ module Cotcube
       contract_is_marked = data.last[:high].zero?
       data.pop if contract_is_marked
       unless (filter == :full) || (data.size < 3)
-        requested_set = trading_hours(symbol: sym[:symbol], set: filter)
+        requested_set = trading_hours(symbol: sym[:symbol], filter: filter)
         data = data.select_within(ranges: requested_set, attr: :datetime) { |x| x.to_datetime.to_sssm }
       end
 
       base = Cotcube::Helpers.reduce(bars: data, to: :days)
 
-      # remove last day of result if not marked
+      # remove last day of result unless marked
       base.pop unless contract_is_marked || force_recent
 
       base.map do |x|
@@ -73,7 +112,14 @@ module Cotcube
           csv << marker
         end
       end
-      base
+      if range.nil?
+        base
+      else
+        base.select do |x|
+          (range.begin.nil? ? true : x[:date] >= range.begin) and
+            (range.end.nil? ? true : x[:date] <= range.end)
+        end
+      end
     end
   end
 end

data/lib/cotcube-bardata/daily.rb

@@ -4,14 +4,30 @@ module Cotcube
   # Missing top level documentation comment
   module Bardata
     # just reads bardata/daily/<id>/<contract>.csv
-    def provide_daily(contract:,
+    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
       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 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
 
       sym = get_id_set(symbol: symbol, id: id, contract: contract)
       contract = contract[2..4] if contract.to_s.size == 5
@@ -28,12 +44,19 @@ module Cotcube
           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]).to_date
+        row[:datetime] = timezone.parse(row[:date])
         row[:type]     = :daily
         row
       end
       data.pop if data.last[:high].zero?
-      data
+      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
@@ -109,6 +132,13 @@ module Cotcube
       end
       data.reject! { |x| x[selector].empty? }
       result = data.group_by { |x| x[selector].first[:contract] }
+      result.each_key do |key|
+        result[key].map! do |x|
+          x[:volume].select! { |z| z[:contract] == key }
+          x[:oi].select!     { |z| z[:contract] == key }
+          x
+        end
+      end
       if human
         result.each do |k, v|
           next unless filter.nil? || v.first[selector].first[:contract][2..4] =~ (/#{filter}/)
@@ -119,15 +149,112 @@ module Cotcube
              }\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
+               x[:volume].select do
+                 x[:contract] == k
+               end
+             end.size
              }"
           # rubocop:enable Layout/ClosingParenthesisIndentation
         end
       end
       result
     end
+
+    def continuous_table(symbol: nil, id: nil,
+                         selector: :volume,
+                         filter: nil,
+                         date: Date.today,
+                         debuglevel: 1,
+                         debug: false)
+      if debug.is_a?(Integer)
+        debuglevel = debug
+        debug = debuglevel > 0 ? true : false
+      end
+      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)
+      if %w[R6 BJ GE].include? sym[:symbol]
+        puts "Rejecting to process symbol '#{sym[:symbol]}'."
+        return
+      end
+      id  = sym[:id]
+      dfm = lambda do |x, y = date.year|
+        k = Date.strptime("#{y} #{x.negative? ? x + 366 : x}", '%Y %j')
+        k -= 1 while [0, 6].include?(k.wday)
+        k.strftime('%a, %Y-%m-%d')
+      rescue StandardError
+        puts "#{sym[:symbol]}\t#{x}\t#{y}"
+      end
+
+      ytoday = date.yday
+      data = continuous_overview(id: id, selector: selector, filter: filter, human: false, config: init)
+        .reject { |k, _| k[-2..].to_i == date.year % 2000 }
+             .group_by { |k, _| k[2] }
+      output_sent = []
+      early_year=nil
+      data.keys.sort.each do |month|
+        puts "Processing #{sym[:symbol]}#{month}" if debuglevel > 1
+        v0 = data[month]
+        ydays = v0.map { |_, v1| Date.parse(v1.last[:date]).yday }
+        fdays = v0.map { |_, v1| Date.parse(v1.first[:date]).yday }.sort
+        # if the last ml day nears the end of the year, we must fix
+        ydays.map! { |x| x > 350 ? x - 366 : x } if ydays.min < 50
+        fday  = fdays[fdays.size / 2]
+        yavg  = ydays.reduce(:+) / ydays.size
+        # a contract is proposed to use after fday - 1, but before ydays.min (green)
+        # it is warned to user after fday - 1 but before yavg - 1            (red)
+        # it is warned red >= yavg - 1 and <= yavg + 1
+        color = if (ytoday >= yavg - 1) && (ytoday <= yavg + 1)
+                  :light_red
+                elsif (ytoday > ydays.min) && (ytoday < yavg - 1)
+                  :light_yellow
+                elsif (ytoday >= (fday > yavg ? 0 : fday - 5)) && (ytoday <= ydays.min)
+                  :light_green
+                else
+                  :white
+                end
+        # rubocop:disable Layout/ClosingParenthesisIndentation
+        output = "#{sym[:symbol]
+             }#{month
+             }\t#{format '%12s', sym[:type]
+             }\t#{ytoday
+              }/#{fday
+             }\t#{format '%5d', ydays.min
+             }: #{dfm.call(ydays.min)
+             }\t#{format '%5d', yavg
+             }: #{dfm.call(yavg)
+             }\t#{format '%5d', ydays.max
+             }: #{dfm.call(ydays.max)}".colorize(color)
+        if debug || (color != :white)
+          puts output
+          output_sent << "#{sym[:symbol]}#{month}" unless color == :white
+        end
+        early_year  ||= output
+        next unless (debug and debuglevel >= 2)
+
+        v0.each do |contract, v1|
+          puts "\t#{contract
+               }\t#{v1.first[:date]
+               }\t#{Date.parse(v1.last[:date]).strftime('%a')
+               }, #{v1.last[:date]
+               } (#{Date.parse(v1.last[:date]).yday}"
+               # rubocop:enable Layout/ClosingParenthesisIndentation
+        end
+      end
+      case output_sent.size
+      when 0
+        puts "WARNING: No output was sent for symbol '#{sym[:symbol]}'.".colorize(:light_yellow)
+        puts "         Assuming late-year-processing.".light_yellow
+        puts early_year.light_green
+      when 1
+        # all ok
+        true
+      else
+        puts "---- #{output_sent} for #{sym[:symbol]} ---------------"
+
+      end
+      output_sent
+    end
   end
 end

data/lib/cotcube-bardata/helpers.rb

@@ -36,11 +36,11 @@ module Cotcube
             ' 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 += 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 }
+        result = base.select { |x| x[:datetime] >= starting and x[:datetime] <= ending }
       end
       result
     end
@@ -83,8 +83,8 @@ module Cotcube
       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] }
-      full.select! {  |x| rth_dates.include? 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

data/lib/cotcube-bardata/provide.rb

@@ -10,7 +10,7 @@ module Cotcube
                 config: init,
                 # supported types are :quarters, :hours, :days, :rth, :dailies, :weeks, :months
                 interval: :days,
-                # supported filters are :raw, :_24x7_, :full and :rth (and custom named, if provided as file)
+                # supported filters are :full and :rth (and custom named, if provided as file)
                 filter: :full,
                 # TODO: for future compatibility and suggestion: planning to include a function to update
                 #       with live data from broker
@@ -22,7 +22,7 @@ module Cotcube
       when :quarters, :hours, :quarter, :hour
         base = provide_quarters(contract: contract, symbol: symbol, id: id, config: config)
         base = extended_select_for_range(range: range, base: base) if range
-        requested_set = trading_hours(symbol: sym[:symbol], set: filter)
+        requested_set = trading_hours(symbol: sym[:symbol], filter: filter)
 
         base = base.select_within(ranges: requested_set, attr: :datetime) { |x| x.to_datetime.to_sssm }
         return base if %i[quarters quarter].include? interval
@@ -33,16 +33,22 @@ module Cotcube
 
       when :days, :weeks, :months
         base = provide_cached contract: contract, symbol: symbol, id: id, config: config, filter: filter,
-                              force_recent: force_recent
-        base = extended_select_for_range(range: range, base: base) if range
+                              range: range, force_recent: force_recent
         return base if %i[day days].include? interval
 
         # TODO: Missing implementation to reduce cached days to weeks or months
         raise 'Missing implementation to reduce cached days to weeks or months'
       when :dailies, :daily
-        base = provide_daily contract: contract, symbol: symbol, id: id, config: config
-        base = extended_select_for_range(range: range, base: base) if range
-        base
+        provide_daily contract: contract, symbol: symbol, id: id, config: config, range: range
+      when :synth, :synthetic, :synthetic_days
+        days = provide_cached contract: contract, symbol: symbol, id: id, config: config, filter: filter,
+                              range: range, force_recent: force_recent
+        dailies = provide_daily contract: contract, symbol: symbol, id: id, config: config, range: range
+        if days.last[:datetime] > dailies.last[:datetime]
+          dailies[..-2] + days.select { |d| d[:datetime] > dailies[-2][:datetime] }
+        else
+          dailies
+        end
       else
         raise ArgumentError, "Unsupported or unknown interval '#{interval}' in Bardata.provide"
       end

data/lib/cotcube-bardata/range_matrix.rb

@@ -12,7 +12,7 @@ module Cotcube
     #   2. avg:
     #   3. lower: like median, but not at 1/2 but 1/4
     #   4. median:
-    #   5. upper: like median, bot not at 1/2 but 3/4
+    #   5. upper: like median, but not at 1/2 but 3/4
     #   6. max:
     # and columns:
     #   1.a) all days os the series
@@ -20,6 +20,8 @@ module Cotcube
     #   1.c) the last 200 days
     #   2.a-c) same with days reduced to weeks (c: 52 weeks)
     #   3.a-c) same with days reduced to months (c: 12 months)
+    #
+    # NOTE: there is now a new method Cotcube::Helpers.simple_series_stats, that should be used in favor.
     def range_matrix(symbol: nil, id: nil, print: false, dim: 0.05)
       # rubocop:disable Style/MultilineBlockChain
       sym = get_id_set(symbol: symbol, id: id)
@@ -38,36 +40,43 @@ module Cotcube
         target[period][:all_size]   =  source[period].size
         target[period][:all_avg]    = (source[period].map { |x| x[:range] }.reduce(:+) / source[period].size).round
         target[period][:all_lower]  =  source[period].sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (source[period].size * 1 / 4).round ]
-        target[period][:all_median] =  source[period].sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (source[period].size * 2 / 4).round ]
-        target[period][:all_upper]  =  source[period].sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (source[period].size * 3 / 4).round ]
+          x[:range]
+        end.map { |x| x[:range] }[ (source[period].size * 1 / 4).round ]
+
+        target[period][:all_median] = source[period].sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (source[period].size * 2 / 4).round ]
+
+        target[period][:all_upper] = source[period].sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (source[period].size * 3 / 4).round ]
+
         target[period][:all_max] = source[period].map { |x| x[:range] }.max
         target[period][:all_records] = source[period].sort_by do |x|
-                                         -x[:range]
-                                       end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
+          -x[:range]
+        end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
 
         tenth = (source[period].size * dim).round
         custom = source[period].sort_by { |x| x[:range] }[tenth..source[period].size - tenth]
+
         target[period][:dim_size]   =  custom.size
         target[period][:dim_avg]    = (custom.map { |x| x[:range] }.reduce(:+) / custom.size).round
         target[period][:dim_lower]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
-        target[period][:dim_median] =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
-        target[period][:dim_upper]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
-        target[period][:dim_max]    =  custom.map { |x| x[:range] }.max
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
+
+        target[period][:dim_median] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
+
+        target[period][:dim_upper] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
+
+        target[period][:dim_max] = custom.map { |x| x[:range] }.max
         target[period][:dim_records] = custom.sort_by do |x|
-                                         -x[:range]
-                                       end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
+          -x[:range]
+        end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
 
         range = case period
                 when :months
@@ -83,18 +92,18 @@ module Cotcube
         target[period][:rec_size]   =  custom.size
         target[period][:rec_avg]    = (custom.map { |x| x[:range] }.reduce(:+) / custom.size).round
         target[period][:rec_lower]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
-        target[period][:rec_median] =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
-        target[period][:rec_upper]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
-        target[period][:rec_max]    =  custom.map { |x| x[:range] }.max
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
+        target[period][:rec_median] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
+        target[period][:rec_upper] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
+        target[period][:rec_max] = custom.map { |x| x[:range] }.max
         target[period][:rec_records] = custom.sort_by do |x|
-                                         -x[:range]
-                                       end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
+          -x[:range]
+        end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
       end
 
       if print

data/lib/cotcube-bardata/trading_hours.rb

@@ -7,11 +7,13 @@ module Cotcube
     #    (as sunday is wday:0)
     # according files are located in config[:data_path]/trading_hours and picked either
     # by the symbol itself or by the assigned type
-    # commonly there are two sets for each symbol: :full and :rth, exceptions are e.g. meats
-    def trading_hours(symbol: nil, id: nil,         # rubocop:disable Metrics/ParameterLists
-                      set: :full, force_set: false,
+    # commonly there are two filter for each symbol: :full and :rth, exceptions are e.g. meats
+    def trading_hours(symbol: nil, id: nil, # rubocop:disable Metrics/ParameterLists
+                      filter: ,
+                      force_filter: false,  # with force_filter one would avoid falling back
+                                            # to the contract_type based range set
                       config: init, debug: false)
-      return (0...24 * 7 * 3600) if set.to_s =~ /24x7/
+      return (0...24 * 7 * 3600) if filter.to_s =~ /24x7/
 
       prepare = lambda do |f|
         CSV.read(f, converters: :numeric)
@@ -22,23 +24,23 @@ module Cotcube
 
       sym = get_id_set(symbol: symbol, id: id)
 
-      file = "#{config[:data_path]}/trading_hours/#{sym[:symbol]}_#{set}.csv"
-      puts "Trying to use #{file} for #{symbol} + #{set}" if debug
+      file = "#{config[:data_path]}/trading_hours/#{sym[:symbol]}_#{filter}.csv"
+      puts "Trying to use #{file} for #{symbol} + #{filter}" if debug
       return prepare.call(file) if File.exist? file
 
       file = "#{config[:data_path]}/trading_hours/#{sym[:symbol]}_full.csv"
       puts "Failed. Trying to use #{file} now" if debug
-      return prepare.call(file) if File.exist?(file) && (not force_set)
+      return prepare.call(file) if File.exist?(file) && (not force_filter)
 
-      file = "#{config[:data_path]}/trading_hours/#{sym[:type]}_#{set}.csv"
+      file = "#{config[:data_path]}/trading_hours/#{sym[:type]}_#{filter}.csv"
       puts "Failed. Trying to use #{file} now." if debug
       return prepare.call(file) if File.exist? file
 
       file = "#{config[:data_path]}/trading_hours/#{sym[:type]}_full.csv"
       puts "Failed. Trying to use #{file} now." if debug
-      return prepare.call(file) if File.exist?(file) && (not force_set)
+      return prepare.call(file) if File.exist?(file) && (not force_filter)
 
-      puts "Finally failed to find range set for #{symbol} + #{set}, returning 24x7"..colorize(:light_yellow)
+      puts "Finally failed to find range filter for #{symbol} + #{filter}, returning 24x7".colorize(:light_yellow)
       (0...24 * 7 * 3600)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-bardata
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.9.2
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-02 00:00:00.000000000 Z
+date: 2021-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -112,16 +112,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '12'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '12'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement