cotcube-level 0.3.3 → 0.3.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a349cee7bdea128658af11ee026dcc2ff995d711c930c5ee188396b1cca045a
-  data.tar.gz: edc2b404b579336d585efeba20b12d8e2572ae3242a939aa060c286b405eee4e
+  metadata.gz: 7a77d2be53fcf299f94403671818d6b31a8f0a3bf5bf59e24ac2ab55986fca91
+  data.tar.gz: 84f71776307891edfee1a60fed2c8ae20def673f698becf7b6ad64b817f19971
 SHA512:
-  metadata.gz: e395bcc4db6052b95b08a1daad0d3ed1b344f533aa779d257de64ba205daf23ccc40853e284ff55dace36c8d3e4e6053e2694a37cee75def861c29e8cab28efe
-  data.tar.gz: c6e059bd6dfbac4a4a4e3da069ff557f9ebecf46596983f056c78c6675447f6a3cd3eedde2b0ad2f48f9552c1e5bc01ba3fc2057a5f81f4129db3360d501ce50
+  metadata.gz: 0f8620c5666ace4d7cea949f0b3cb28a73acfc9ba3167f4d14742e8637daccb5edf50e37aa62008f966941c36ddd7c3167dd88cb9937e7d4500980affcdd77e4
+  data.tar.gz: e63bb887f9b6616aa3f43b7704541094334f79e2398f76c95d7751df58961a844378f5462d2ff3096bc7bf061a3dc98b34355c608d8784f215e0b08b436c2415

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 0.3.4.3 (December 23, 2021)
+  - gemspec: raised activesupport to v7
+  - intraday_stencil: changed naming scheme for cachefile
+  - eod_stencil: added :timezone to self.provide_eod_stencil
+
+## 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

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.3.4.3

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/cotcube-level.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activesupport',      '~> 6'
+  spec.add_dependency 'activesupport',      '~> 7'
   spec.add_dependency 'colorize',           '~> 0.8'
   spec.add_dependency 'cotcube-helpers',    '~> 0.1'
   spec.add_dependency 'yaml',               '~> 0.1'

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,37 +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: true, notice: nil, hash: 3)
-      return if swap[:empty]
-      daily =  %i[ continuous daily ].include?(swap[:interval].to_sym)
-      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 (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)
-            }#{       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'
@@ -79,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
 
@@ -115,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.
@@ -126,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
@@ -142,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?
@@ -200,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

@@ -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/#{asset.to_s}_#{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
+        index(0)
       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.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.3
+  version: 0.3.4.3
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-05 00:00:00.000000000 Z
+date: 2021-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -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