cotcube-level 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81e95a5e617ba6dd8fdf5df13c0395455ff19a337e2e72e79f485a37489049c0
-  data.tar.gz: d592daecc1be2e4686fd3a6807d82c5f5429de6b451b96e4aee30430fe0fbe9d
+  metadata.gz: 9a349cee7bdea128658af11ee026dcc2ff995d711c930c5ee188396b1cca045a
+  data.tar.gz: edc2b404b579336d585efeba20b12d8e2572ae3242a939aa060c286b405eee4e
 SHA512:
-  metadata.gz: 78459e2694a2c1f97357307d550df8c9920b18be785b1c28d712b8d61c074ba4326c867b107b62985030fac412805c548858ee086f13802dec13b01e75c10f9c
-  data.tar.gz: 0a7ccd8153cda7309f70fbffb2fc2fe7f2595194ddf4688bcc13d28c86418fbe0f23322f5c47a2fba7b4aca0832e95b877747158bd17ad1da33a634bbc3eb529
+  metadata.gz: e395bcc4db6052b95b08a1daad0d3ed1b344f533aa779d257de64ba205daf23ccc40853e284ff55dace36c8d3e4e6053e2694a37cee75def861c29e8cab28efe
+  data.tar.gz: c6e059bd6dfbac4a4a4e3da069ff557f9ebecf46596983f056c78c6675447f6a3cd3eedde2b0ad2f48f9552c1e5bc01ba3fc2057a5f81f4129db3360d501ce50

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 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.3

data/lib/cotcube-level/eod_stencil.rb

@@ -146,10 +146,10 @@ 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_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[:exceeded]       =  zero[:datetime] if swap[:current_dist] < grace
         swap
       end
     end

data/lib/cotcube-level/helpers.rb

@@ -24,14 +24,14 @@ 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]
+      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,22 +40,23 @@ 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)
+    def puts_swap(swap, format: , short: true, notice: nil, hash: 3)
       return if swap[:empty]
-      daily =  %i[ continuous daily ].include?(swap[:interval])
+      daily =  %i[ continuous daily ].include?(swap[:interval].to_sym)
       datetime_format = daily ? '%Y-%m-%d' : '%Y-%m-%d %H:%M'
       high = swap[:side] == :high
       ohlc = high ? :high : :low
       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)}" : ''))
+        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 )
       else
         puts "side: #{swap[:side] }\tlen: #{swap[:length]}  \trating: #{swap[:rating]}".colorize(swap[:color] || :white )
@@ -114,7 +115,7 @@ 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)
+    def load_swaps(interval:, swap_type:, contract:, sym: nil, datetime: nil, recent: false, digest: nil, quiet: false, exceed: false)
       file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
       jsonl = File.read(file)
       data = jsonl.
@@ -123,22 +124,22 @@ 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[: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
         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
       # do not return bare exceedance information
@@ -146,9 +147,38 @@ module Cotcube
       # 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[: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
 
@@ -175,6 +205,18 @@ module Cotcube
       end.compact
     end
 
+    def mark_exceeded(swap:, datetime:, debug: false)
+      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
+      swap
+    end
+
   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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-level
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-29 00:00:00.000000000 Z
+date: 2021-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport