cotcube-level 0.3.2 → 0.3.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81e95a5e617ba6dd8fdf5df13c0395455ff19a337e2e72e79f485a37489049c0
-  data.tar.gz: d592daecc1be2e4686fd3a6807d82c5f5429de6b451b96e4aee30430fe0fbe9d
+  metadata.gz: 4bbf4fc1b2edf64ffee60a29ffe7d72a71a4c0f8fb99b889026dce9dbca7399f
+  data.tar.gz: 59469c2431a20e9e1f07a99e0af61a4fed59ca276a02d654a2f2bd28a8543c04
 SHA512:
-  metadata.gz: 78459e2694a2c1f97357307d550df8c9920b18be785b1c28d712b8d61c074ba4326c867b107b62985030fac412805c548858ee086f13802dec13b01e75c10f9c
-  data.tar.gz: 0a7ccd8153cda7309f70fbffb2fc2fe7f2595194ddf4688bcc13d28c86418fbe0f23322f5c47a2fba7b4aca0832e95b877747158bd17ad1da33a634bbc3eb529
+  metadata.gz: 78a4cb1a3bc80de5086befc5e927cafc86c38ef62410c4fc9d61e716e929f3847ad4a6ac870d30b94168e10dd72d22267aba8d4d4ae2f52a5e7170454a6864f5
+  data.tar.gz: 79ed8087a1936cef86257e24c9909f8923902be09e43868ce29deb5b178d03c2d3bbb2700f2bb76f67b2a58a51df930b3bdd41c4134922ed90bd6b2a1f0990ad

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 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
+
+## 0.3.4 (October 06, 2021)
+  - intraday_stencil: major rework resp. rebuild ... now beta-ready
+  - helpers: preparing puts_swap and get_jsonl_name to work intraday
+  - puts_swap: changed output scheme to provide exceedance as NOTE
+
+## 0.3.3 (October 05, 2021)
+  - helpers::load_swaps: added :exceed to allow 1(sic) swap to be exceeded while loading
+  - tritangulate: added :manual for feature of manual swap creation with base of 2 members
+  - helpers::load_swap added :digest to filter for swaps starting with pattern
+  - helpers: minor readability improvements
+  - eod_stencil: minor readability improvements
+  - helpers: few optimizations
+
 ## 0.3.2 (August 29, 2021)
   - tritangulate: fixing 'finalize', as Integer zero won't comparte to Float zero
   - cotcube-level.rb: added :check_exceedance

data/VERSION

@@ -1 +1 @@
-0.3.2
+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?)
@@ -146,15 +151,17 @@ module Cotcube
         ohlc  = high ? :high : :low
         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
+        swap[:current_value]  =  swap[:members].last[ ohlc ] + swap[:current_change] * sym[:ticksize]
+        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,15 +23,15 @@ 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)
-      high = side == :upper
-      "#{member[:datetime].strftime("%a, %Y-%m-%d#{daily ? "" :" %I:%M%p"}")
-        }  x: #{format '%-4d', member[:x]
+    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]
         } dx: #{format '%-8.3f', (member[:dx].nil? ? member[:x] : member[:dx].round(3))
             } #{high ? "high" : "low"
-           }: #{format format, member[high ? :high : :low]
-         } i: #{(format '%4d', member[:i]) unless member[:i].nil?
-         } d: #{format '%6.2f', member[:dev] unless member[:dev].nil?
+           }: #{format format,    member[high ? :high : :low]
+         } i: #{(format '%4d',    member[:i]) unless member[:i].nil?
+         } d: #{format '%6.2f',   member[:dev] unless member[:dev].nil?
             } #{member[:near].nil? ? '' : "near: #{member[:near]}"
          }"
     end
@@ -40,36 +40,80 @@ 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: false, notice: nil)
-      return if swap[:empty]
-      daily =  %i[ continuous daily ].include?(swap[:interval])
-      datetime_format = daily ? '%Y-%m-%d' : '%Y-%m-%d %H:%M'
+    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] + delta_datetime).strftime(datetime_format)}"
+      end
+      if swap[:ignored] 
+        notice += "  IGNORED"
+      end
       if short
-        puts "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)
-            }#{format('%20s', (swap[:exceeded] ? "  XXX: #{swap[:exceeded].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
     # and, on-the-fly, create these files plus their directory
     def get_jsonl_name(interval:, swap_type:, contract:, sym: nil)
-      raise "Interval #{interval } is not supported, please choose from #{INTERVALS}" unless INTERVALS.include? interval
+      raise "Interval #{interval } is not supported, please choose from #{INTERVALS}" unless INTERVALS.include?(interval) || interval.is_a?(Integer)
       raise "Swaptype #{swap_type} is not supported, please choose from #{SWAPTYPES}" unless SWAPTYPES.include? swap_type
       sym ||= Cotcube::Helpers.get_id_set(contract: contract)
       root = '/var/cotcube/level'
@@ -78,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
 
@@ -114,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)
+    #
+    # 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.
@@ -123,32 +171,69 @@ module Cotcube
         JSON.parse(x).
           deep_transform_keys(&:to_sym).
           tap do |sw|
-          sw[:datetime] = DateTime.parse(sw[:datetime]) rescue nil
-          (sw[:exceeded] = DateTime.parse(sw[:exceeded]) rescue nil) if sw[:exceeded]
-          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
-            sw[:members].map{|mem| mem[:datetime] = DateTime.parse(mem[:datetime]) }
-          end
+            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] or sw[:ignored]
+              sw[:color]    = sw[:color].to_sym 
+              sw[:members].map{|mem| mem[:datetime] = DateTime.parse(mem[:datetime]) }
+            end
         end
       end
       # assign exceedance data to actual swaps
       data.select{|swap| swap[:exceeded] }.each do |exc|
         swap = data.find{|ref| ref[:digest] == exc[:ref]}
-        raise RuntimeError, "Consistent history for '#{exc}'. Origin not found." if swap.nil?
+        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
-      data.reject!{|swap| swap[:exceeded] and swap[:exceeded] < datetime } unless datetime.nil?
+      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}
+      data.map{|swap| swap.delete(:exceeded) if swap[:exceeded] and swap[:exceeded] > datetime} unless datetime.nil?
+      unless digest.nil?
+        data.select! do |z|
+          (Cotcube::Helpers.sub(minimum: digest.length){ z[:digest] } === digest) and
+          not z[:empty]
+        end
+        case data.size
+        when 0
+          puts "No swaps found for digest '#{digest}'." unless quiet
+        when 1
+          sym ||= Cotcube::Helpers.get_id_set(contract: contract)
+          if not quiet or exceed
+            puts "Found 1 digest: "
+            data.each {|d| puts_swap( d, format: sym[:format], short: true, hash: digest.size + 2) }
+            if exceed
+              exceed = DateTime.now if exceed.is_a? TrueClass
+              mark_exceeded(swap: data.first, datetime: exceed)
+              puts "Swap marked exceeded."
+            end
+          end
+        else
+          sym ||= Cotcube::Helpers.get_id_set(contract: contract)
+          unless quiet
+            puts "Too many digests found for digest '#{digest}', please consider sending more figures: "
+            data.each {|d| puts_swap( d, format: sym[:format], short: true, hash: digest.size + 3)}
+          end
+        end
+      end
       data
     end
 
@@ -170,11 +255,34 @@ 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, sym: nil)
+      to_save = {
+        datetime: datetime,
+        ref:      swap[:digest],
+        side:     swap[:side],
+        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
+
   end
 end
 

data/lib/cotcube-level/intraday_stencil.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Cotcube
   module Level
-    # TODO: Missing documentation of shiftsets, swap_types and stencil_types
+
     class Intraday_Stencil
 
-      GLOBAL_SOW = { 'CT' => '0000-1700' }
-      GLOBAL_EOW = { 'CT' => '1700-0000' }
-      GLOBAL_EOD = { 'CT' => '1600-1700' }
 
+      # Class method that loads the (latest) shiftset for given asset
+      # These raw stencils are located in /var/cotcube/level/stencils/shiftsets.csv
+      #
 
       def self.shiftset(asset:, sym: nil)
         shiftset_file = '/var/cotcube/level/stencils/shiftsets.csv'
@@ -18,45 +20,66 @@ module Cotcube
         sym ||= Cotcube::Helpers.get_id_set(symbol: asset)
         current_set = shiftsets.find{|s| s[:symbols] =~ /#{sym[:type]}/ }
         return current_set.tap{|s| headers.map{|h| s[h] = nil if s[h] == '---------' }; s[:rth5] ||= s[:rth]; s[:mpost5] ||= s[:mpost] }  unless current_set.nil?
-        raise "Cannot get shiftset for #{sym[:type]}: #{asset}, please prepare #{shiftset_file} before!" 
+        raise "Cannot get shiftset for #{sym[:type]}: #{asset}, please prepare #{shiftset_file} before!"
       end
 
       attr_reader :base, :shiftset, :timezone, :datetime, :zero, :index
 
-      # asset:    the asset the stencil will be applied to--or :full, if default stencil is desired
-      # datetime: the datetime that will become 'zero'. 
-      #           it will be calculated to the beginning of the previous interval
-      #           it must match the timezone of the asset
-      # interval: the interval as minutes
-      # weeks:    the amount of weeks before the beginning of the current week
-      # future:   the amount of weeks after  the beginning of the current week
-      def initialize(asset:, sym: nil, datetime:, interval:, weeks:, future: 1, debug: false, type:, base: )
-        @shiftset = Intraday_Stencils.shiftset(asset: asset)
-        @timezone = TIMEZONES[@shiftset[:tz]]
-        @debug    = debug
-        datetime  = @timezone.at(datetime.to_i) unless datetime.is_a? ActiveSupport::TimeWithZone
-        # slight flaw, as datetime does not carry the actuall timezone information but just the abbr. timezone name (like CDT or CEST)
-        raise "Zone mismatch: Timezone of asset is #{@timezone.now.zone} but datetime given is #{dateime.zone}" unless @timezone.now.zone == datetime.zone
-        @datetime = datetime.beginning_of_day
-        @datetime += interval while @datetime <= datetime - interval
-        @datetime -= interval 
-        const = "RAW_INTRA_STENCIL_#{@shiftset[:nr]}_#{interval.in_minutes.to_i}".to_sym
+
+
+      def initialize(
+        asset:,
+        interval: 30.minutes,
+        swap_type: :full,
+        datetime: nil,
+        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
+      )
+        @shiftset   = Intraday_Stencil.shiftset(asset: asset)
+        @timezone   = Cotcube::Level::TIMEZONES[@shiftset[:tz]]
+        @debug      = debug
+        @interval   = interval
+        @swap_type  = swap_type
+        @warnings   = warnings
+        datetime  ||= DateTime.now
+        datetime    = @timezone.at(datetime.to_i) unless datetime.is_a? ActiveSupport::TimeWithZone
+        @datetime   = datetime.beginning_of_day
+        @datetime  += interval while @datetime <= datetime - interval
+        @datetime  -= interval
+
+        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 }
           end_time      = lambda {|x| @shiftset[x].split('-').last  rescue '' }
           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 } 
+          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 = [] 
-          (weeks+future).times do 
+          @base = []
+          (weeks+future).times do
             while tm_runner.call < GLOBAL_SOW[@shiftset[:tz]].split('-').last
               # if daylight is switched, this phase will be shorter or longer
               @base << { datetime: runner, type: :sow }
@@ -81,10 +104,10 @@ module Cotcube
                       yet_rth = true
                     end
                   end
-                  while ((sophase > eophase) ? (tm_runner.call >= sophase or tm_runner.call < eophase) : (tm_runner.call < eophase)) 
+                  while ((sophase > eophase) ? (tm_runner.call >= sophase or tm_runner.call < eophase) : (tm_runner.call < eophase))
                     current = { datetime: runner, type: phase }
                     if phase == :rth and not yet_rth
-                      current[:block] = true 
+                      current[:block] = true
                       yet_rth = true
                     end
                     @base << current
@@ -100,80 +123,111 @@ module Cotcube
             while runner < end_of_week
               @base << { datetime: runner, type: :eow }
               runner += interval
-            end     
+            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
+          @base.select!{|x| %i[ pre rth post ].include?(x[:type]) }
+        when :rth
+          @base.select!{|x| x[:type] == :rth  }
+        when :flow
+          @base.reject!{|x| %i[ sow eow mpost mpost ].include?(x[:type]) }
+          @base.
+            map{ |x|
+            [:high, :low, :volume].map{|z| x[z] = nil} unless x[:type] == :rth
+          }
+        when :run
+          @base.select!{|x| %i[ pre rth post ].include? x[:type]}
+        else
+          raise ArgumentError, "Unknown stencil/swap type '#{swap_type}'"
         end
-        self.apply to: base, type: type
-        @index = @base.index{|x| x[:datetime] == @datetime } 
-        @index -= 1 while %i[sow sod mpre mpost eod eow].include? @base[@index][:type] 
+        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)
+        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 
+        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 
+        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
-        @base.select!{|z| z[:x] <= 0 or z[:high]}
+        measure.call 'initialization finished'
+      end
+
+      def zero
+        @zero ||=  @base.find{|b| b[:x].zero? }
       end
 
-      def apply!(to:, type:) 
-        apply(to: to, type: type, force: true)
+      def index(offset = 0)
+        @index ||= @base.index{|b| b[:x].zero? }
+        @base[@index + offset]
       end
 
-      # :force will apply values to each bar regardless of existing ones
-      def apply(to:, type:, force: false, debug: false)
+
+      def apply(to: )
         offset = 0
-        to.each_index do |i|
+        @base.each_index do |i|
           begin
-            offset += 1 while @base[i+offset][:datetime] < to[i][:datetime]
-            puts "#{i}\t#{offset}\t#{@base[i+offset][:datetime]} < #{to[i][:datetime]}" if debug
+            offset += 1 while to[i+offset][:datetime] < @base[i][:datetime]
           rescue
             # appending
-            puts "appending #{i}\t#{offset}\t#{@base[i+offset][:datetime]} < #{to[i][:datetime]}" if debug
-            @base << to[i]
+            to << @base[i]
             next
           end
-          if @base[i+offset][:datetime] > to[i][:datetime]
+          if to[i+offset][:datetime] > @base[i][:datetime]
             # skipping
-            puts "skipping #{i}\t#{offset}\t#{@base[i+offset][:datetime]} < #{to[i][:datetime]}" if debug
             offset -= 1
             next
           end
           # merging
-          j = i + offset
-          @base[j]=@base[j].merge(to[i]) if force or (@base[j][:high].nil? and @base[j][:low].nil?)
-          puts "MERGED:\t#{i}\t#{offset}\t#{@base[j]}" if debug
+          to[i+offset][:x] = @base[i][:x]
+          to[i+offset][:type] = @base[i][:type]
         end
         # finally remove all bars that do not belong to the stencil (i.e. holidays)
-        case type
-        when :full
-          @base.select!{|x| %i[ pre rth post ].include?(x[:type]) }
-        when :rth
-          @base.select!{|x| x[:type] == :rth  }
-          # to.map{    |x| [:high, :low, :volume].map{|z| x[z] = nil} if x[:block] } 
-        when :flow
-          @base.reject!{|x| %i[ meow postmm postmm5 ].include?(x[:type]) }
-          @base.
-            map{ |x| 
-            [:high, :low, :volume].map{|z| x[z] = nil} unless x[:type] == :rth 
-            # [:high, :low, :volume].map{|z| x[z] = nil} if x[:block]
-          }
-        when :run
-          @base.select!{|x| %i[ premarket rth postmarket ].include? x[:type]}
-        else
-          raise ArgumentError, "Unknown stencil/swap type '#{type}'"
-        end
-        @base.map!{|z| z.dup}
+        to.reject!{|x| x[:x].nil? }
       end
 
+      def use(with:, sym:, zero: nil, grace: -2)
+        # todo: validate with (check if vslid swap
+        #                sym  (check keys)
+        #                zero (ohlc with x.zero?)
+        #                side ( upper or lower)
+        swap  = with.dup
+        high  = swap[:side] == :upper
+        ohlc  = high ? :high : :low
+        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]
+        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
 
-    Intraday_Stencils = Intraday_Stencil
   end
+
 end

data/lib/cotcube-level/tritangulate.rb

@@ -19,6 +19,7 @@ module Cotcube
       swap_type: nil,       # if not given, a warning is printed and swaps won't be saved or loaded
       with_flaws: 0,        # the maximum amount of consecutive bars that would actually break the current swap
                             # should be set to 0 for dailies and I suggest no more than 3 for intraday
+      manual: false,        # some triggers must be set differently when manual entry is used
       deviation: 2          # the maximum shift of :x-values of found members
     )
 
@@ -70,8 +71,10 @@ module Cotcube
 
       # abs_peak is the absolute high / low of the base. the shearing operation ends there,
       # but results might be influenced when abs_peak becomes affected by :with_flaws
-      abs_peak = base.send(high ? :max_by : :min_by){|x| x[high ? :high : :low] }[:datetime]
-      base.reject!{|x| x[:datetime] < abs_peak}
+      unless manual
+        abs_peak = base.send(high ? :max_by : :min_by){|x| x[high ? :high : :low] }[:datetime]
+        base.reject!{|x| x[:datetime] < abs_peak}
+      end
 
       ###########################################################################################################################z
       # only if (and only if) the range portion above change the underlying base
@@ -155,7 +158,7 @@ module Cotcube
           # first member is solitary
           if new_members.empty?
             mem_sorted=members.sort
-            if mem_sorted[1] == mem_sorted[0] + 1
+            if mem_sorted[1] == mem_sorted[0] + 1 and not manual
               b2 = b[mem_sorted[1]..mem_sorted[-1]].map{|x| x.dup; x[:dx] = nil; x}
               puts 'starting recursive rerun'.light_red if debug
               alternative_slope = get_slope.call(b2)

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.2
+  version: 0.3.4.2
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-29 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