cotcube-level 0.3.4.1 → 0.3.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71bc6b4ca29ab4ff089b95568a0d592d4bc2b3d8c1824ea9158d661792f1c5b7
-  data.tar.gz: 670d5a69457411fc7539542a1bd0ad1712ef9111f7b5a876b3c7bdd5d6de90c0
+  metadata.gz: 4bbf4fc1b2edf64ffee60a29ffe7d72a71a4c0f8fb99b889026dce9dbca7399f
+  data.tar.gz: 59469c2431a20e9e1f07a99e0af61a4fed59ca276a02d654a2f2bd28a8543c04
 SHA512:
-  metadata.gz: 3221bf00e3532ae51f62d98f191332273a2241ae34f0eff99e9840f28f41e339a816d23d100150aca70719855c6a1d0507f6509f2598cad75c880f86089286b3
-  data.tar.gz: 652072c05872418b438ca7ac937e3e5735a5967804c0d0e8f75b4e5381553b55e8b64ecf769cb820745650717077eae1ac7b0b844325725a1c0c78b6b2fbbf85
+  metadata.gz: 78a4cb1a3bc80de5086befc5e927cafc86c38ef62410c4fc9d61e716e929f3847ad4a6ac870d30b94168e10dd72d22267aba8d4d4ae2f52a5e7170454a6864f5
+  data.tar.gz: 79ed8087a1936cef86257e24c9909f8923902be09e43868ce29deb5b178d03c2d3bbb2700f2bb76f67b2a58a51df930b3bdd41c4134922ed90bd6b2a1f0990ad

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.3.4.2 (November 28, 2021)
+  - added 2 executables to bin to display eod- and intraday-swaps
+  - helpers: adding ignorance to load_swaps and other, adding .mark_ignored
+  - intraday_stencil: allowing absence of :zero in #use
+
 ## 0.3.4.1 (October 09, 2021)
   - intraday_stencil: fixing @index, that did not work when used outside active hours
 

data/VERSION

@@ -1 +1 @@
-0.3.4.1
+0.3.4.2

data/bin/iswaps.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/cotcube-level.rb'
+
+HELP = <<HEREDOC
+Display current intraday swaps.
+    > USAGE: iswaps.rb <contract> [json]
+    > contract      a contract known to the system
+    > json          switch to toggle json output instead of human readable
+HEREDOC
+if ARGV.empty?
+  puts HELP
+  exit
+end
+
+contract   = ARGV[0].nil? ? nil : ARGV[0].upcase
+json       = ARGV.include? 'json'
+
+sym        = Cotcube::Helpers.get_id_set(contract: contract) rescue "Could not determine contract #{contract}"
+if sym.is_a? Sring; puts sym; puts HELP; exit 1; end
+
+swaps      = Cotcube::Level::load_swaps(interval: 30.minutes, swap_type: :full, contract: contract, sym: sym).
+               select{|swap| not(swap[:empty]) and 
+                             not(swap[:ignored]) and 
+                             not(swap[:exceeded].presence ? (swap[:exceeded] < DateTime.now - 2.days) : false)
+               }
+stencil = Cotcube::Level::Intraday_Stencil.new( interval: 30.minutes, swap_type: :full, asset: contract[..1])
+swaps.map!{|swap| stencil.use with: swap, sym: sym}
+
+if json
+  puts swaps.to_json
+else
+  puts '<none>' if swaps.empty?
+  swaps.each {|swap|
+    notice = if swap[:exceeded]
+               "EXCEEDED #{swap[:exceeded]}"
+             elsif swap[:ignored]
+               'IGNORED'
+             else
+               "Current: #{format sym[:format], swap[:current_value]}"
+             end
+    Cotcube::Level.puts_swap(swap, format: sym[:format], notice: notice)
+  }
+end
+

data/bin/swaps.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/cotcube-level.rb'
+
+HELP = <<HEREDOC
+swaps.rb: Display current eod swaps.
+    > USAGE: swaps.rb <contract> [json]
+    > contract      a contract known to the system
+    > json          switch to toggle json output instead of human readable
+HEREDOC
+if ARGV.empty?
+  puts HELP
+  exit
+end
+
+
+contract   = ARGV[0].nil? ? nil : ARGV[0].upcase
+json       = ARGV.include? 'json'
+
+sym     = Cotcube::Helpers.get_id_set(contract: contract) rescue "ERROR: Could not determine contract '#{contract}'."
+
+if sym.is_a? String; puts sym; puts HELP; exit 1; end
+
+swaps   = Cotcube::Level::load_swaps(interval: :daily, swap_type: :full, contract: contract, quiet: true).
+            select{|swap| not(swap[:empty]) and 
+                       not(swap[:ignored]) and 
+                       not(swap[:exceeded].presence ? (swap[:exceeded] < DateTime.now - 2.days) : false)
+            }
+stencil = Cotcube::Level::EOD_Stencil.new( interval: :daily, swap_type: :full)
+swaps.map!{|swap| stencil.use with: swap, sym: sym}
+if json
+  puts swaps.to_json
+else
+  puts '<none>' if swaps.empty?
+  swaps.each {|swap| 
+    notice = if swap[:exceeded]
+               "EXCEEDED #{swap[:exceeded].strftime('%Y-%m-%d')}"
+             elsif swap[:ignored] 
+               'IGNORED'
+             else
+               "Current: #{format sym[:format], swap[:current_value]}"
+             end
+    Cotcube::Level.puts_swap(swap, format: sym[:format], notice: notice)
+  }
+end

data/lib/cotcube-level/eod_stencil.rb

@@ -13,7 +13,7 @@ module Cotcube
       #
       # Current daily stencils contain dates from 2020-01-01 to 2023-12-31
       #
-      def self.provide_raw_stencil(type:, interval: :daily, version: nil)
+      def self.provide_raw_stencil(type:, interval: :daily, version: nil, timezone: Cotcube::Helpers::CHICAGO)
         loading = lambda do |typ|
           file_base = "/var/cotcube/level/stencils/stencil_#{interval.to_s}_#{typ.to_s}.csv_"
           if Dir["#{file_base}?*"].empty?
@@ -27,7 +27,7 @@ module Cotcube
               raise ArgumentError, "Cannot open stencil from non-existant file #{file}."
             end
           end
-          CSV.read(file).map{|x| { datetime: CHICAGO.parse(x.first).freeze, x: x.last.to_i.freeze } }
+          CSV.read(file).map{|x| { datetime: timezone.parse(x.first).freeze, x: x.last.to_i.freeze } }
         end
         unless const_defined? :RAW_STENCILS
           const_set :RAW_STENCILS, { daily:
@@ -80,7 +80,7 @@ module Cotcube
           raise ArgumentError, "Each stencil members should contain at least :datetime and :x" unless stencil.nil? or
             stencil.map{|x| ([:datetime, :x] - x.keys).empty? and [ActiveSupport::TimeWithZone, Day].include?( x[:datetime] ) and x[:x].is_a?(Integer)}.reduce(:&)
 
-          base = stencil || EOD_Stencil.provide_raw_stencil(type: stencil_type, interval: :daily, version: version)
+          base = stencil || EOD_Stencil.provide_raw_stencil(type: stencil_type, interval: :daily, version: version, timezone: timezone)
 
           # fast rewind to previous trading day
           date = timezone.parse(date) unless [NilClass, Date, ActiveSupport::TimeWithZone].include? date.class
@@ -111,7 +111,12 @@ module Cotcube
       end
 
       def zero
-        @zero ||=  @base.find{|b| b[:x].zero? }
+        index(0)
+      end
+
+      def index(offset = 0)
+        @index ||= @base.index{|b| b[:x].zero? }
+        @base[@index + offset]
       end
 
       def apply(to: )
@@ -136,7 +141,7 @@ module Cotcube
         to.reject!{|x| x[:x].nil? }
       end
 
-      def use(with:, sym:, zero:, grace: -2)
+      def use(with:, sym:, zero: nil, grace: -2)
         # todo: validate with (check if vslid swap
         #                sym  (check keys)
         #                zero (ohlc with x.zero?)
@@ -147,14 +152,16 @@ module Cotcube
         start = base.find{|x| swap[:datetime] == x[:datetime]}
         swap[:current_change] = (swap[:tpi] * start[:x]).round(8)
         swap[:current_value]  =  swap[:members].last[ ohlc ] + swap[:current_change] * sym[:ticksize]
-        swap[:current_diff]   = (swap[:current_value] - zero[ohlc]) * (high ? 1 : -1 )
-        swap[:current_dist]   = (swap[:current_diff] / sym[:ticksize]).to_i
-        swap[:exceeded]       =  zero[:datetime] if swap[:current_dist] < grace
+        unless zero.nil? 
+          swap[:current_diff]   = (swap[:current_value] - zero[ohlc]) * (high ? 1 : -1 )
+          swap[:current_dist]   = (swap[:current_diff] / sym[:ticksize]).to_i
+          swap[:exceeded]       =  zero[:datetime] if swap[:current_dist] < grace
+        end
         swap
       end
-    end
+end
 
-  end
+end
 
 end
 

data/lib/cotcube-level/helpers.rb

@@ -23,7 +23,7 @@ module Cotcube
 
     # human readable output
     # please note the format must be given, that should be taken from :sym
-    def member_to_human(member,side: ,format:, daily: false)
+    def member_to_human(member,side: ,format:, daily: false, tws: false)
       high = (side == :upper)
       "#{                         member[:datetime].strftime("%a, %Y-%m-%d#{daily ? "" :" %I:%M%p"}")
         }  x: #{format '%-4d',    member[:x]
@@ -40,33 +40,74 @@ module Cotcube
     # format: e.g. sym[:format]
     # short:  print one line / less verbose
     # notice: add this to output as well
-    def puts_swap(swap, format: , short: true, notice: nil, hash: 3)
-      return if swap[:empty]
+    def puts_swap(swap, format: , short: true, notice: nil, hash: 3, tws: false)
+      return '' if swap[:empty]
+
+      # if presenting swaps from json, the datetimes need to be parsed first
+      swap[:datetime] = DateTime.parse(swap[:datetime]) if swap[:datetime].is_a? String
+      swap[:exceeded] = DateTime.parse(swap[:exceeded]) if swap[:exceeded].is_a? String
+      swap[:ignored]  = DateTime.parse(swap[:ignored])  if swap[:ignored ].is_a? String
+      swap[:side]     = swap[:side].to_sym
+      swap[:members].each do |mem|
+        mem[:datetime] = DateTime.parse(mem[:datetime]) if mem[:datetime].is_a? String
+      end
+
+      # TODO: create config-entry to contain 1.hour -- set of contracts ; 7.hours -- set of contracts [...]
+      #       instead of hard-coding in here
+      # TODO: add also to :member_to_human
+      #       then commit
+      if tws
+        case swap[:contract][0...2]
+        when *%w[ GC SI PL PA HG NG CL HO RB ] 
+          delta_datetime = 1.hour
+        when *%w[ GG DX ]
+          delta_datetime = 7.hours
+        else
+          delta_datetime = 0
+        end
+      else
+        delta_datetime = 0 
+      end
       daily =  %i[ continuous daily ].include?(swap[:interval].to_sym) rescue false
       datetime_format = daily ? '%Y-%m-%d' : '%Y-%m-%d %I:%M %p'
       high = swap[:side] == :high
       ohlc = high ? :high : :low
       if notice.nil? and swap[:exceeded]
-        notice = "exceeded #{swap[:exceeded].strftime(datetime_format)}"
+        notice = "exceeded #{(swap[:exceeded] + delta_datetime).strftime(datetime_format)}"
+      end
+      if swap[:ignored] 
+        notice += "  IGNORED"
       end
       if short
-        puts (hash ? "#{swap[:digest][...hash]}    ".colorize(:light_white) : '') +
-             "S: #{swap[:side]
-            } L: #{   format '%4d', swap[:length]
-            } R: #{   format '%4d', swap[:rating]
-            } D: #{   format '%4d', swap[:depth]
-            } P: #{   format '%10s', (format '%5.2f', swap[:ppi])
-            }   F: #{ format format, swap[:members].last[ ohlc ]
-            }   S: #{ swap[:members].first[:datetime].strftime(datetime_format)
-            } - #{    swap[:members].last[:datetime].strftime(datetime_format)
-            }#{"    NOTE: #{notice}" unless notice.nil?}".colorize(swap[:color] || :white )
+        res ="#{format '%7s', swap[:digest][...hash]
+            } #{   swap[:contract]
+            } #{   swap[:side].to_s
+            }".colorize( swap[:side] == :upper ? :light_green : :light_red ) +
+           " (#{   format '%4d', swap[:length]
+            },#{   format '%4d', swap[:rating]
+            },#{   format '%4d', swap[:depth]
+        }) P: #{   format '%6s', (format '%4.2f', swap[:ppi])
+           }  #{
+                if swap[:current_value].nil?
+              "I: #{   format '%8s', (format format, swap[:members].last[ ohlc ]) }"
+                else
+              "C: #{   format '%8s', (format format, swap[:current_value]) } "
+                end
+          } [#{ (swap[:members].first[:datetime] + delta_datetime).strftime(datetime_format)
+         } - #{    (swap[:members].last[:datetime] + delta_datetime).strftime(datetime_format)
+           }]#{"    NOTE: #{notice}" unless notice.nil?
+           }".colorize(swap[:color] || :white )
+        puts res
       else
-        puts "side: #{swap[:side] }\tlen: #{swap[:length]}  \trating: #{swap[:rating]}".colorize(swap[:color] || :white )
-        puts "diff: #{swap[:ticks]}\tdif: #{swap[:diff].round(7)}\tdepth: #{swap[:depth]}".colorize(swap[:color] || :white )
-        puts "tpi:  #{swap[:tpi]  }\tppi: #{swap[:ppi]}".colorize(swap[:color] || :white )
-        puts "NOTE: #{notice}".colorize(:light_white) unless notice.nil?
-        swap[:members].each {|x| puts member_to_human(x, side: swap[:side], format: format, daily: daily) }
+        res = ["side: #{swap[:side] }\tlen: #{swap[:length]}  \trating: #{swap[:rating]}".colorize(swap[:color] || :white )]
+        res <<  "diff: #{swap[:ticks]}\tdif: #{swap[:diff].round(7)}\tdepth: #{swap[:depth]}".colorize(swap[:color] || :white )
+        res << "tpi:  #{swap[:tpi]  }\tppi: #{swap[:ppi]}".colorize(swap[:color] || :white )
+        res << "NOTE: #{notice}".colorize(:light_white) unless notice.nil?
+        swap[:members].each {|x| res << member_to_human(x, side: swap[:side], format: format, daily: daily) }
+        res = res.join("\n")
+        puts res
       end
+      res
     end
 
     # create a standardized name for the cache files
@@ -81,7 +122,9 @@ module Cotcube
       `mkdir -p #{dir}`         unless File.exist?(dir)
       `ln -s #{dir} #{symlink}` unless File.exist?(symlink)
       file = "#{dir}/#{contract}_#{interval.to_s}_#{swap_type.to_s}.jsonl"
-      `touch #{file}`
+      unless File.exist? file
+        `touch #{file}`
+      end
       file
     end
 
@@ -117,7 +160,9 @@ module Cotcube
 
     # loading of swaps is also straight forward
     # it takes few more efforts to normalize the values to their expected format
-    def load_swaps(interval:, swap_type:, contract:, sym: nil, datetime: nil, recent: false, digest: nil, quiet: false, exceed: false)
+    #
+    # it is not too nice that some actual interactive process is done here in the load section
+    def load_swaps(interval:, swap_type:, contract:, sym: nil, datetime: nil, recent: false, digest: nil, quiet: false, exceed: false, keep_ignored: false)
       file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
       jsonl = File.read(file)
       data = jsonl.
@@ -128,12 +173,13 @@ module Cotcube
           tap do |sw|
             sw[:datetime] = DateTime.parse(sw[:datetime]) rescue nil
             (sw[:exceeded] = DateTime.parse(sw[:exceeded]) rescue nil) if sw[:exceeded]
+            (sw[:ignored] = DateTime.parse(sw[:ignored]) rescue nil) if sw[:ignored]
             sw[:interval] = interval
             sw[:swap_type] = swap_type
             sw[:contract] = contract
             %i[ side ].each {|key| sw[key] = sw[key].to_sym rescue false }
-            unless sw[:empty] or sw[:exceeded]
-              sw[:color]    = sw[:color].to_sym
+            unless sw[:empty] or sw[:exceeded] or sw[:ignored]
+              sw[:color]    = sw[:color].to_sym 
               sw[:members].map{|mem| mem[:datetime] = DateTime.parse(mem[:datetime]) }
             end
         end
@@ -144,13 +190,20 @@ module Cotcube
         raise RuntimeError, "Inconsistent history for '#{exc}'. Origin not found." if swap.nil?
         swap[:exceeded] = exc[:exceeded]
       end
+      # assign ignorance data to actual swaps
+      data.select{|swap| swap[:ignored] }.each do |ign|
+	swap = data.find{|ref| ref[:digest] == ign[:ref]}
+        raise RuntimeError, "Inconsistent history for '#{ign}'. Origin not found." if swap.nil?
+        swap[:ignored] = ign[:ignored]
+      end
       # do not return bare exceedance information
-      data.reject!{|swap| swap[:exceeded] and swap[:members].nil? }
+      data.reject!{|swap| (swap[:ignored] or swap[:exceeded]) and swap[:members].nil? }
       # do not return swaps that are found 'later'
       data.reject!{|swap| swap[:datetime] > datetime } unless datetime.nil?
       # do not return exceeded swaps, that are exceeded in the past
       recent  = 7.days  if recent.is_a? TrueClass
       recent += 5.hours if recent
+      data.reject!{|swap| swap[:ignored] } unless keep_ignored
       data.reject!{|swap| swap[:exceeded] and swap[:exceeded] < datetime - (recent ? recent : 0) } unless datetime.nil?
       # remove exceedance information that is found 'later'
       data.map{|swap| swap.delete(:exceeded) if swap[:exceeded] and swap[:exceeded] > datetime} unless datetime.nil?
@@ -202,20 +255,31 @@ module Cotcube
           save_swaps to_save, interval: swap[:interval], swap_type: swap[:swap_type], contract: contract, sym: sym, quiet: (not debug)
           swap[:exceeded] = update[:exceeded]
         end
-        %i[ current_change current_value current_diff current_dist ].map{|key| swap[key] = update[key] }
+        %i[ current_change current_value current_diff current_dist alert].map{|key| swap[key] = update[key] }
         swap
       end.compact
     end
 
-    def mark_exceeded(swap:, datetime:, debug: false)
+    def mark_exceeded(swap:, datetime:, debug: false, sym: nil)
       to_save = {
         datetime: datetime,
         ref:      swap[:digest],
         side:     swap[:side],
         exceeded: datetime
       }
-      save_swaps to_save, interval: swap[:interval], swap_type: swap[:swap_type], sym: Cotcube::Helpers.get_id_set(contract: swap[:contract]), contract: swap[:contract], quiet: (not debug)
-      swap[:exceeded] = datetime
+      sym ||=  Cotcube::Helpers.get_id_set(contract: swap[:contract])
+      save_swaps to_save, interval: swap[:interval], swap_type: swap[:swap_type], sym: sym, contract: swap[:contract], quiet: (not debug)
+      swap
+    end
+
+    def mark_ignored(swap:, datetime: DateTime.now, sym: , debug: true)
+      to_save = {
+        datetime: datetime,
+        ref:      swap[:digest],
+        side:     swap[:side],
+        ignored:  datetime
+      }
+      save_swaps to_save, interval: swap[:interval],  swap_type: swap[:swap_type], sym: sym, contract: swap[:contract], quiet: (not debug)
       swap
     end
 

data/lib/cotcube-level/intraday_stencil.rb

@@ -35,6 +35,7 @@ module Cotcube
         debug: false,
         weeks: 6,
         future: 2,
+        measuring: false,
         version: nil,               # when referring to a specicic version of the stencil
         stencil: nil,               # instead of preparing, use this one if set
         warnings: true              # be more quiet
@@ -51,10 +52,22 @@ module Cotcube
         @datetime  += interval while @datetime <= datetime - interval
         @datetime  -= interval
 
-        const = "RAW_INTRA_STENCIL_#{@shiftset[:nr]}_#{interval.in_minutes.to_i}".to_sym
+        now         = DateTime.now
+        measure = lambda {|x| puts "\nMeasured #{(Time.now - now).to_f.round(2)}: ".colorize(:light_yellow) +  x + "\n\n" if measuring }
+
+        measure.call "Starting initialization for asset '#{asset}' "
+
+        const = "RAW_INTRA_STENCIL_#{@shiftset[:nr]}_#{interval.in_minutes.to_i}_#{weeks}_#{future}".to_sym
+        cachefile = "/var/cotcube/level/stencils/cache/#{swap_type.to_s}_#{interval}_#{@datetime.strftime('%Y-%m-%d-%H-%M')}.json"
+
         if Object.const_defined? const
+          measure.call 'getting cached base from memory'
           @base = (Object.const_get const).map{|z| z.dup}
+        elsif File.exist? cachefile
+          measure.call 'getting cached base from file'
+          @base = JSON.parse(File.read(cachefile), symbolize_names: true).map{|z| z[:datetime] = DateTime.parse(z[:datetime]); z[:type] = z[:type].to_sym; z }
         else
+          measure.call 'creating base from shiftset'
           start_time    = lambda {|x| @shiftset[x].split('-').first rescue '' }
           start_hours   = lambda {|x| @shiftset[x].split('-').first[ 0.. 1].to_i.send(:hours)   rescue 0 }
           start_minutes = lambda {|x| @shiftset[x].split('-').first[-2..-1].to_i.send(:minutes) rescue 0 }
@@ -62,7 +75,7 @@ module Cotcube
           end_hours     = lambda {|x| @shiftset[x].split('-').last [ 0.. 1].to_i.send(:hours)   rescue 0 }
           end_minutes   = lambda {|x| @shiftset[x].split('-').last [-2..-1].to_i.send(:minutes) rescue 0 }
 
-         runner = (@datetime -
+          runner = (@datetime -
                     weeks * 7.days).beginning_of_week(:sunday)
           tm_runner = lambda { runner.strftime('%H%M') }
           @base = []
@@ -113,7 +126,9 @@ module Cotcube
             end
           end
           Object.const_set(const, @base.map{|z| z.dup})
+          File.open(cachefile, 'w'){|f| f.write(@base.to_json)}
         end
+        measure.call "base created with #{@base.size} records"
 
         case swap_type
         when :full
@@ -131,42 +146,44 @@ module Cotcube
         else
           raise ArgumentError, "Unknown stencil/swap type '#{swap_type}'"
         end
+        measure.call "swaptype #{swap_type} applied"
         @base.map!{|z| z.dup}
+        measure.call 'base dupe\'d'
 
         # zero is, were either x[:datetime] == @datetime (when we are intraday)
         #         or otherwise {x[:datetime] <= @datetime}.last (when on maintenance)
-        @index = @base.index{|x| x == @base.select{|y| y[:datetime] <= @datetime }.last }
+        selector =  @base.select{|y| y[:datetime] <= @datetime }.last
+        @index = @base.index{|x| x == selector }
+        measure.call 'index selected'
         @index -= 1 while %i[sow sod mpre mpost eod eow].include? @base[@index][:type]
+        measure.call 'index adjusted'
         @datetime = @base[@index][:datetime]
         @zero  = @base[@index]
         counter = 0
+        measure.call "Applying counter to past"
         while @base[@index - counter] and @index - counter >= 0
           @base[@index - counter][:x] = counter
           counter += 1
         end
         counter = 0
+        measure.call "Applying counter to future"
         while @base[@index + counter] and @index + counter < @base.length
           @base[@index + counter][:x] = -counter
           counter += 1
         end
+        measure.call 'initialization finished'
       end
 
-=begin
-      def dup
-        Intraday_Stencil.new(
-          debug:      @debug,
-          interval:   @interval,
-          swap_type:  @swap_type,
-          datetime:   @datetime,
-          stencil:    @base.map{|x| x.dup}
-        )
-      end
-=end
-
       def zero
         @zero ||=  @base.find{|b| b[:x].zero? }
       end
 
+      def index(offset = 0)
+        @index ||= @base.index{|b| b[:x].zero? }
+        @base[@index + offset]
+      end
+
+
       def apply(to: )
         offset = 0
         @base.each_index do |i|
@@ -190,7 +207,7 @@ module Cotcube
         to.reject!{|x| x[:x].nil? }
       end
 
-      def use(with:, sym:, zero:, grace: -2)
+      def use(with:, sym:, zero: nil, grace: -2)
         # todo: validate with (check if vslid swap
         #                sym  (check keys)
         #                zero (ohlc with x.zero?)
@@ -201,9 +218,12 @@ module Cotcube
         start = base.find{|x| swap[:datetime] == x[:datetime]}
         swap[:current_change] = (swap[:tpi] * start[:x]).round(8)
         swap[:current_value]  =  swap[:members].last[ ohlc ] + swap[:current_change] * sym[:ticksize]
-        swap[:current_diff]   = (swap[:current_value] - zero[ohlc]) * (high ? 1 : -1 )
-        swap[:current_dist]   = (swap[:current_diff] / sym[:ticksize]).to_i
-        swap[:exceeded]       =  zero[:datetime] if swap[:current_dist] < grace
+        unless zero.nil?
+          swap[:current_diff]   = (swap[:current_value] - zero[ohlc]) * (high ? 1 : -1 )
+          swap[:current_dist]   = (swap[:current_diff] / sym[:ticksize]).to_i
+          swap[:alert]          = (swap[:current_diff] / zero[:atr5]).round(2)
+          swap[:exceeded]       =  zero[:datetime] if swap[:current_dist] < grace
+        end
         swap
       end
     end

data/lib/cotcube-level.rb

@@ -40,6 +40,8 @@ module Cotcube
                     :get_jsonl_name,
                     :load_swaps,
                     :check_exceedance,
+                    :mark_exceeded,
+                    :mark_ignored,
                     :member_to_human
     
     # please note that module_functions of sources provided in non-public files must slso be published within these

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-level
 version: !ruby/object:Gem::Version
-  version: 0.3.4.1
+  version: 0.3.4.2
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-09 00:00:00.000000000 Z
+date: 2021-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -120,6 +120,8 @@ files:
 - Gemfile
 - README.md
 - VERSION
+- bin/iswaps.rb
+- bin/swaps.rb
 - cotcube-level.gemspec
 - lib/cotcube-level.rb
 - lib/cotcube-level/detect_slope.rb
@@ -149,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A gem to shear a time series