cotcube-helpers 0.1.9.1 → 0.2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb81f4056cbca5f2a1630a3ddc3a63070bcf00030b78cad54163e9fca057aaaa
-  data.tar.gz: 80cfdd92008406204cabb9add25987d49c1c3ba28b32db5c935e743e1d276470
+  metadata.gz: 1228015a21f3920ec5b1d87e3c5918e3c69e0a577746b6a18579ae51e1528ce2
+  data.tar.gz: 431798647c5d4e9d5a7a32816636bd768c4e0e9c70d789dd491c374fde75f768
 SHA512:
-  metadata.gz: bedbd01706f4f4896acf7dc7258371c31ace12f81b8c65c6f0c057129b824d1b3087f806fe48bd8a38d0a2894c1028ec5113fa6a1f9abbd2036ea156a86ca266
-  data.tar.gz: c17bbb49e51ced51f8ef8edefa6a781dc54598fb8ed7912df41434b6702096567f495f0cd0c873efbe020e36132e9402ac9f336e4607b151d1a34ae4600a2c3f
+  metadata.gz: b931c2dad6f54a1f2de64590e703c1be03ed2330691a299c2e4d4a64f5cb5d20d3be9ba44584866db66116160c2d01c87cd17f7d84f5ae82ae2668f5a8cf0bae
+  data.tar.gz: 18b50ba7237d373dec19d3144814ad55c5ec3d36274213c5749041bbf66ce008461d2be89cda0240245529e29ed383110352d945af4a82cb761d53a6d702f09a

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 0.2.1.1 (November 10, 2021)
+  - Bump version to 0.2.1.
+  - Bump version to 0.2.1.
+
+## 0.2.1 (November 10, 2021)
+  - added new class 'dataclient' for communication with dataproxy
+  - added .translate_ib_contract
+
+## 0.2.0 (November 07, 2021)
+  - added module Candlestick_Recognition
+  - added instance_inspect method to 'scan' objects for contents of instance variables
+  - symbols: made selection of symbols more versatile by key
+  - added headers (:ib_symbol, :internal, :exchange, :currency) to symbol headers as well as symbol examples
+  - added scripts/symbols to list (and filter) symbols from command line (put to PATH!)
+
+## 0.1.10 (October 28, 2021)
+  - added script cron_ruby_wrapper.sh (linkable as /usr/local/bin/cruw.sh)
+  - added numeric ext .with_delimiter to support printing like 123_456_789.00121
+  - added micros to module
+  - added Helpers.micros to symbols.rb
+  - subpattern: excaping regex pattern to avoid ESC errors
+  - minor change
+
+## 0.1.9.2 (July 24, 2021)
+  - added missing module_functions
+  - init: minor fix
+  - datetime_ext: added warning comment / TODO, as switch from to daylight time will produce erroneous results
+  - constants: minor fix (typo)
+  - array_ext: added param to provide a default return value if result is an empty array
+
 ## 0.1.9.1 (May 07, 2021)
   - moved 'get_id_set' to Cotcube::Helpers
   - minor fix to suppress some warning during build

data/Gemfile

@@ -4,3 +4,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in bitangent.gemspec
 gemspec
+gem 'parallel'
+gem 'bunny'

data/VERSION

@@ -1 +1 @@
-0.1.9.1
+0.2.1.1

data/lib/cotcube-helpers/array_ext.rb

@@ -29,10 +29,10 @@ class Array
   # This method iterates over an Array by calling the given block on all 2 consecutive elements
   # it returns a Array of self.size - 1
   #
-  def pairwise(ret=nil, &block)
+  def pairwise(ret=nil, empty: nil, &block)
     raise ArgumentError, 'Array.one_by_one needs an arity of 2 (i.e. |a, b|)' unless block.arity == 2
-    raise ArgumentError, 'Each element of Array should respond to []=, at least the last one fails.' unless self.last.respond_to?(:[]=)
-    return [] if size <= 1
+    raise ArgumentError, 'Each element of Array should respond to []=, at least the last one fails.' if not ret.nil? and not  self.last.respond_to?(:[]=)
+    return empty ||= [] if size <= 1
 
     each_index.map do |i|
       next if i.zero?
@@ -47,7 +47,7 @@ class Array
   # same as pairwise, but with arity of three
   def triplewise(ret=nil, &block)
     raise ArgumentError, 'Array.triplewise needs an arity of 3 (i.e. |a, b, c|)' unless block.arity == 3
-    raise ArgumentError, 'Each element of Array should respond to []=, at least the last one fails.' unless self.last.respond_to?(:[]=)
+    raise ArgumentError, 'Each element of Array should respond to []=, at least the last one fails.' if not ret.nil? and not self.last.respond_to?(:[]=)
     return [] if size <= 2
 
     each_index.map do |i|

data/lib/cotcube-helpers/constants.rb

@@ -1,11 +1,15 @@
-
-zen_string_literal: true
+#frozen_string_literal: true
 
 module Cotcube
-  module SwapSeeker
+  module Helpers
     SYMBOL_EXAMPLES = [
-      { id: '13874U', symbol: 'ET', ticksize: 0.25, power: 1.25, months: 'HMUZ', bcf: 1.0, reports: 'LF', format: '8.2f', name: 'S&P 500 MICRO' },
-      { id: '209747', symbol: 'NM', ticksize: 0.25, power: 0.5,  monhts: 'HMUZ', bcf: 1.0, reports: 'LF', format: '8.2f', name: 'NASDAQ 100 MICRO' }
+      { id: '13874U', symbol: 'ES', ib_symbol: 'ES', internal: 'ES', exchange: 'GLOBEX', currency: 'USD', ticksize: 0.25, power: 12.5, months: 'HMUZ', bcf: 1.0, reports: 'LF', format: '8.2f', name: 'S&P 500 MICRO' },
+      { id: '209747', symbol: 'NQ', ib_symbol: 'NQ', internal: 'NQ', exchange: 'GLOBEx', currency: 'USD', ticksize: 0.25, power: 5.0,  monhts: 'HMUZ', bcf: 1.0, reports: 'LF', format: '8.2f', name: 'NASDAQ 100 MICRO' }
+    ].freeze
+
+    MICRO_EXAMPLES = [
+      { id: '13874U', symbol: 'ET', ib_symbol: 'MES', internal: 'MES', exchange: 'GLOBEX', currency: 'USD', ticksize: 0.25, power: 1.25, months: 'HMUZ', bcf: 1.0, reports: 'LF', format: '8.2f', name: 'MICRO S&P 500 MICRO' },
+      { id: '209747', symbol: 'NM', ib_symbol: 'MNQ', internal: 'MNQ', exchange: 'GLOBEX', currency: 'USD', ticksize: 0.25, power: 0.5,  monhts: 'HMUZ', bcf: 1.0, reports: 'LF', format: '8.2f', name: 'MICRO NASDAQ 100 MICRO' }
     ].freeze
 
     COLORS         = %i[light_red light_yellow light_green red yellow green cyan magenta blue].freeze
@@ -19,9 +23,9 @@ module Cotcube
                        'J' => 4,  'K' =>  5, 'M' =>  6,
                        'N' => 7,  'Q' =>  8, 'U' =>  9,
                        'V' => 10, 'X' => 11, 'Z' => 12,
-                        1 => 'F',  2 => 'G',  3 => 'H',
-                        4 => 'J',  5 => 'K',  6 => 'M',
-                        7 => 'N',  8 => 'Q',  9 => 'U',
+                       1 => 'F',  2 => 'G',  3 => 'H',
+                       4 => 'J',  5 => 'K',  6 => 'M',
+                       7 => 'N',  8 => 'Q',  9 => 'U',
                        10 => 'V', 11 => 'X', 12 => 'Z' }.freeze
 
 
@@ -29,6 +33,12 @@ module Cotcube
 
     DATE_FMT = '%Y-%m-%d'
 
+    # Simple mapper to get from MONTH to LETTER
+    LETTERS = { "JAN"=> "F", "FEB"=> "G", "MAR"=> "H",
+                "APR"=> "J", "MAY"=> "K", "JUN"=> "M",
+                "JUL"=> "N", "AUG"=> "Q", "SEP"=> "U",
+                "OCT"=> "V", "NOV"=> "X", "DEC"=> "Z" }
+
   end
 end
 

data/lib/cotcube-helpers/data_client.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+require 'bunny'
+require 'json'
+
+module Cotcube
+  module Helpers
+    class DataClient
+
+      def initialize
+        @connection = Bunny.new(automatically_recover: true)
+        @connection.start
+
+        @channel  = connection.create_channel
+        @exchange = channel.direct('dataproxy_commands', auto_delete: true)
+        @requests = {} 
+        @persistent = { depth: {}, realtimebars: {}, ticks: {} }
+        @response = nil
+
+        setup_reply_queue
+      end
+
+      def help
+        puts "The following commands are available:\n\n"\
+          "\tcontracts  = client.get_contracts(symbol:)\n"\
+          "\tbars       = client.get_historical(contract:, duration:, interval:, before: nil)"\
+          "\trequest_id = client.start_realtimebars(contract: )\n"\
+          "\t             client.stop_realtimebars(request_id: )\n"\
+          "\trequest_id = client.start_ticks(contract: )\n"\
+          "\t             client.stop_ticks(request_id: )\n"
+      end
+
+      def send_command(command, timeout: 5)
+        command = { command: command.to_s } unless command.is_a? Hash
+        command[:timestamp] ||= (Time.now.to_f * 1000).to_i
+        request_id = Digest::SHA256.hexdigest(command.to_json)[..6]
+        requests[request_id] = { request: command, id: request_id }
+
+        exchange.publish(command.to_json,
+                         content_type: 'application/json',
+                         routing_key: 'dataproxy_commands',
+                         correlation_id: request_id,
+                         reply_to: reply_queue.name)
+
+        # wait for the signal to continue the execution
+        lock.synchronize { 
+          condition.wait(lock, timeout) 
+        } 
+
+        response
+      end
+
+      def stop
+        channel.close
+        connection.close
+      end
+
+
+      def get_contracts(symbol: )
+        send_command( { command: :get_contracts, symbol: symbol } )
+      end
+
+      def get_historical(contract:, interval:, duration: nil, before: nil, rth_only: false, based_on: :trades)
+        # rth.true? means data outside of rth is skipped
+        rth_only = rth_only ? 1 : 0
+        default_durations = {
+          sec1:  '30_M',
+          sec5:   '2_H',
+          sec15:  '6_H',
+          sec30: '12_H',
+          min1:   '1_D',
+          min2:   '2_D',
+          min5:   '5_D',
+          min15:  '1_W',
+          min30:  '1_W',
+          hour1:  '1_W',
+          day1:   '1_Y'
+        } 
+        raise "Invalid interval '#{interval}', should be in '#{default_durations.keys}'." unless default_durations.keys.include? interval
+        # TODO: Check for valid duration specification
+        duration ||= default_durations[interval] 
+        send_command( { 
+          command: :historical,
+          contract: contract,
+          interval: interval,
+          duration: duration,
+          based_on: based_on.to_s.upcase,
+          rth_only: rth_only,
+          before: nil
+        }, timeout: 20 )
+      end
+
+      def start_persistent(contract:, type: :realtimebars, &block)
+        unless %i[ depth ticks realtimebars].include? type.to_sym
+          puts "ERROR: Inappropriate type in stop_realtimebars with #{type}"
+          return false
+        end
+
+        ib_contract = Cotcube::Helpers.get_ib_contract(contract)
+        exchange = channel.fanout( "dataproxy_#{type.to_s}_#{contract}", auto_delete: true)
+        queue  = channel.queue('', exclusive: true, auto_delete: true)
+        queue.bind(exchange)
+        block ||= ->(bar){ puts "#{bar}" }
+        queue.subscribe do  |_delivery_info, properties, payload|
+          block.call(JSON.parse(payload, symbolize_names: true))
+        end
+        command = { command: type, contract: contract, con_id: ib_contract[:con_id], delivery: queue.name, exchange: exchange.name }
+        persistent[type][queue.name] = command
+        persistent[type][queue.name][:queue] = queue
+        send_command(command)
+      end
+
+      def stop_persistent(contract:, type: :realtimebars )
+        unless %i[ depth ticks realtimebars].include? type.to_sym
+          puts "ERROR: Inappropriate type in stop_realtimebars with #{type}"
+          return false
+        end
+        ib_contract = Cotcube::Helpers.get_ib_contract(contract)
+        command = { command: "stop_#{type}", contract: contract, con_id: ib_contract[:con_id] }
+        send_command(command)
+      end
+
+      attr_accessor :response
+      attr_reader   :lock, :condition
+
+      private
+      attr_reader :call_id, :connection, :requests, :persistent,
+        :channel, :server_queue_name, :reply_queue, :exchange
+
+
+      def setup_reply_queue
+        @lock = Mutex.new
+        @condition = ConditionVariable.new
+        that = self
+        @reply_queue = channel.queue('', exclusive: true, auto_delete: true)
+        @reply_queue.bind(channel.exchange('dataproxy_replies', auto_delete: true), routing_key: @reply_queue.name)
+
+        reply_queue.subscribe do |delivery_info, properties, payload|
+
+          __id__ = properties[:correlation_id] 
+
+          if __id__.nil?
+            puts "Received without __id__: #{delivery_info.map{|k,v| "#{k}\t#{v}"}.join("\n")
+                      }\n\n#{properties   .map{|k,v| "#{k}\t#{v}"}.join("\n")
+                      }\n\n#{JSON.parse(payload).map{|k,v| "#{k}\t#{v}"}.join("\n")}"
+
+          elsif requests[__id__].nil?
+            puts "Received non-matching response: \n\n#{_delivery_info}\n\n#{properties}\n\n#{payload}\n."
+          else 
+            that.response = payload
+
+            # sends the signal to continue the execution of #call
+            requests.delete(__id__)
+            that.lock.synchronize { that.condition.signal }
+          end
+        end
+      end
+
+    end
+  end
+end
+
+__END__
+begin 
+  client = DataClient.new
+  reply = client.send_command( { command: 'ping' } ) #{ command: :hist, contract: 'A6Z21', con_id: 259130514, interval: :min15 } )
+  puts reply.nil? ? 'nil' : JSON.parse(reply)
+  reply = client.get_historical( contract: 'A6Z21',  con_id: 259130514, interval: :min15 , rth_only: false)
+  JSON.parse(reply, symbolize_names: true)[:result].map{|z| 
+    z[:datetime] = Cotcube::Helpers::CHICAGO.parse(z[:time]).strftime('%Y-%m-%d %H:%M:%S')
+    z.delete(:created_at)
+    z.delete(:time)
+    p z.slice(*%i[datetime open high low close volume]).values
+
+  } 
+ensure
+  client.stop
+  e,nd

data/lib/cotcube-helpers/datetime_ext.rb

@@ -4,6 +4,9 @@
 class DateTime
   # based on the fact that sunday is 'wday 0' plus that trading week starts
   #   sunday 0:00 (as trading starts sunday 5pm CT to fit tokyo monday morning)
+  #
+  # TODO: there is a slight flaw, that 1 sunday per year is 1 hour too short and another is 1 hour too long
+  #
   def to_seconds_since_sunday_morning
     wday * 86_400 + hour * 3600 + min * 60 + sec
   end

data/lib/cotcube-helpers/get_id_set.rb

@@ -3,12 +3,13 @@
 module Cotcube
   module Helpers
 
-    def get_id_set(symbol: nil, id: nil, contract: nil, config: init)
+    def get_id_set(symbol: nil, id: nil, contract: nil, config: init, mini: false, micro: false)
+      micro = mini || micro
       contract = contract.to_s.upcase if contract.is_a? Symbol
       id       =       id.to_s.upcase if       id.is_a? Symbol
       symbol   =   symbol.to_s.upcase if   symbol.is_a? Symbol
 
-      if contract.is_a?(String) && (contract.length == 5)
+      if contract.is_a?(String) && ([2,3,4,5].include? contract.length)
         c_symbol = contract[0..1]
         if (not symbol.nil?) && (symbol != c_symbol)
           raise ArgumentError,
@@ -19,25 +20,26 @@ module Cotcube
       end
 
       unless symbol.nil?
-        sym = symbols.select { |s| s[:symbol] == symbol.to_s.upcase }.first
+        sym = symbols(symbol: symbol).presence || micros(symbol: symbol)
         if sym.nil? || sym[:id].nil?
           raise ArgumentError,
-                "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}"
+                "Could not find match in #{config[:symbols_file]} or #{config[:micros_file]} for given symbol #{symbol}"
         end
         raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if (not id.nil?) && (sym[:id] != id)
 
-        return sym
+        return micro ? micros(id: sym[:id])  : sym
       end
       unless id.nil?
-        sym = symbols.select { |s| s[:id] == id.to_s }.first
+        sym = symbols(id: id)
         if sym.nil? || sym[:id].nil?
           raise ArgumentError,
                 "Could not find match in #{config[:symbols_file]} for given id #{id}"
         end
-        return sym
+        return micro ? micros(id: sym[:id]) : sym
       end
       raise ArgumentError, 'Need :id, :symbol or valid :contract '
     end
+
   end
 end
 

data/lib/cotcube-helpers/ib_contracts.rb

@@ -0,0 +1,69 @@
+module Cotcube
+  module Helpers
+    def get_ib_contract(contract)
+      symbol = contract[..1]
+      # TODO consider file location to be found in configfile
+      filepath =  '/etc/cotcube/ibsymbols/'
+      result = YAML.load(File.read( "#{filepath}/#{symbol}.yml"))[contract].transform_keys(&:to_sym) rescue nil
+      result.nil? ? update_ib_contracts(symbol: contract[..1]) : (return result)
+      YAML.load(File.read( "#{filepath}/#{symbol}.yml"))[contract].transform_keys(&:to_sym) rescue nil
+    end
+
+    def update_ib_contracts(symbol: nil)
+      begin
+        client = DataClient.new
+        (Cotcube::Helpers.symbols + Cotcube::Helpers.micros).each do |sym|
+
+          # TODO: consider file location to be located in config
+          file = "/etc/cotcube/ibsymbols/#{sym[:symbol]}.yml"
+
+          # TODO: VI publishes weekly options which dont match, the 3 others need multiplier enabled to work
+          next if %w[ DY TM SI VI ].include? sym[:symbol]
+          next if symbol and sym[:symbol] != symbol
+          begin
+            if File.exist? file
+              next if Time.now - File.mtime(file) < 5.days
+              data = nil
+              data = YAML.load(File.read(file))
+            else
+              data = {}
+            end
+            p file
+            %w[ symbol sec_type exchange multiplier ticksize power internal ].each {|z| data.delete z}
+            raw   = client.get_contracts(symbol: sym[:symbol])
+            reply = JSON.parse(raw)['result']
+            reply.each do |set|
+              contract = translate_ib_contract set['local_symbol']
+              data[contract] ||= set
+            end
+            keys = data.keys.sort_by{|z| z[2]}.sort_by{|z| z[-2..] }.select{|z| z[..1] == sym[:symbol] }
+            data = data.slice(*keys)
+            File.open(file, 'w'){|f| f.write(data.to_yaml) }
+          rescue Exception => e
+            puts e.full_message
+            p sym
+            binding.irb
+          end
+        end
+      ensure 
+        client.stop
+        true
+      end
+    end
+
+    def translate_ib_contract(contract)
+      short = contract.split(" ").size == 1
+      sym_a = contract.split(short ? '' : ' ')
+      year  = sym_a.pop.to_i + (short ? 20 : 0)
+      if short and sym_a[-1].to_i > 0
+        year = year - 20 + sym_a.pop.to_i * 10
+      end
+      month = short ? sym_a.pop : LETTERS[sym_a.pop]
+      sym   = Cotcube::Helpers.symbols(internal: sym_a.join)[:symbol] rescue nil
+      sym ||= Cotcube::Helpers.micros(internal: sym_a.join)[:symbol] rescue nil
+      sym.nil? ? false : "#{sym}#{month}#{year}"
+    end
+
+  end
+end
+

data/lib/cotcube-helpers/init.rb

@@ -23,10 +23,11 @@ module Cotcube
              gem_name: nil,
              debug: false)
       gem_name ||= self.ancestors.first.to_s
-      config_file_name = "#{gem_name.down_case}.yml"
+      config_file_name = "#{gem_name.downcase.split('::').last}.yml"
       config_file = config_path + "/#{config_file_name}"
 
       if File.exist?(config_file)
+        require 'yaml'
         config      = YAML.load(File.read config_file).transform_keys(&:to_sym)
       else
         config      = {} 

data/lib/cotcube-helpers/numeric_ext.rb

@@ -0,0 +1,8 @@
+class Numeric
+  def with_delimiter(deli=nil)
+    raise ArgumentError, "Param delimiter can't be nil" if deli.nil?
+    pre, post = self.to_s.split('.')
+    pre = pre.chars.to_a.reverse.each_slice(3).map(&:join).join(deli).reverse
+    post.nil? ? pre : [pre,post].join('.')
+  end
+end

data/lib/cotcube-helpers/output.rb

@@ -0,0 +1,20 @@
+module Cotcube
+  module Helpers
+
+    def instance_inspect(obj, keylength: 20, &block)
+      obj.instance_variables.map do |var| 
+        if block_given?
+          block.call(var, obj.instance_variable_get(var))
+        else
+          puts "#{format "%-#{keylength}s", var
+                         }: #{obj.instance_variable_get(var).inspect.scan(/.{1,120}/).join( "\n" + ' '*(keylength+2)) 
+                         }" 
+        end
+      end
+    end
+
+    module_function :instance_inspect
+
+  end
+end
+

data/lib/cotcube-helpers/recognition.rb

@@ -0,0 +1,509 @@
+module Cotcube
+  module Helpers
+    module Candlestick_Recognition
+
+      SUPERFLUOUS = %i[wap datetime prev_slope upper lower bar_size body_size lower_wick upper_wick ranges vranges vavg trades type bullish bearish doji contract]
+      COMMON = [:symbol, :timestamp, :size, :rth, :time_end,
+                :open, :high, :vhigh, :vlow, :low, :close,
+                :interval, :offset, :appeared, :datetime, :volume, :dist, :vperd, :vol_i, :contract, :date, 
+                :bar_size, :upper_wick, :lower_wick, :body_size, :upper, :lower, :slope, :rel, :tr, :atr, :ranges, :vranges, :vavg]
+
+      # recognize serves as interface
+      def recognize(contract:, interval: :quarters, short: true, base:, return_as_string: false, sym: )
+        s = bas
+        CR::candles  s, ticksize: sym[:ticksize]
+        CR::patterns s, contract: contract, ticksize: sym[:ticksize]
+        s.map{|x| x[:datetime] += 7.hours } if s and %w[                      GG DY ].include?(contract[..1]) and interval == :quarters 
+        s.map{|x| x[:datetime] += 1.hour  } if s and %w[ GC PA PL SI HG NG HO RB CL ].include?(contract[..1]) and interval == :quarters
+        make_string = lambda {|c| "#{contract
+                              }\t#{c[:datetime].strftime( interval == :quarters ? '%Y-%m-%d %H:%M' : '%Y-%m-%d' )}".colorize(:light_white) + 
+                              "\t#{print_bar(bar: c, format: sym[:format], power: sym[:power], short: short)
+                               } #{"\n\n" if c[:datetime].wday == 5 and interval == :days}" }
+        return_as_string ? s[-count..].map{|candle| make_string.call(candle) }.join("\n") : s
+      end
+
+
+      def print_bar(bar:, format:, power:, short: false)
+        x = bar.dup
+        dir = x[:bullish] ? :bullish : x[:bearish] ? :bearish : x[:doji] ? :doji : :none
+        contract = bar[:contract]
+        SUPERFLUOUS.map{|s| x.delete(s)}
+        %i[ UPPER_PIVOT LOWER_PIVOT UPPER_ISOPIVOT LOWER_ISOPIVOT ].map{|s| x.delete(s)}
+
+
+        vol = x.keys.select{|x| x.to_s =~ /_volume/}[0]
+        x.delete vol
+
+        vol = vol.to_s.split("_")[0]
+        col = case dir 
+              when :bullish
+                :light_green
+              when :bearish 
+                :light_red
+              when :doji
+                :light_blue
+                else:light_black
+              end
+
+        special = lambda do |s| 
+          case s
+          when *%i[ THRUSTING_LINE SHOOTING_STAR HANGING_MAN EVENING_STAR EVENING_DOJI_STAR UPSIDEGAP_TWO_CROWS UMKEHRSTAB_BEARISH ]
+            s.to_s.colorize(:light_red)
+          when *%i[ PIERCING_LINE INVERTED_HAMMER HAMMER    MORNING_STAR MORNING_DOJI_STAR DOWNGAP_TWO_RIVERS  UMKEHRSTAB_BULLISH ]
+            s.to_s.colorize(:light_green)
+          else
+            s.to_s.colorize(:light_cyan)
+          end 
+        end
+
+
+
+        "#{ format '%12s', (format % x[:open  ]) }"              +
+          "  #{format '%12s', (format % x[:high  ])}".colorize( (x.keys.include?(:UPPER_PIVOT) or x.keys.include?(:UPPER_ISOPIVOT)) ? :light_blue : :white ) +
+          "  #{format '%12s', (format % x[:low   ])}".colorize( (x.keys.include?(:LOWER_PIVOT) or x.keys.include?(:LOWER_ISOPIVOT)) ? :light_blue : :white ) +
+          "  #{format '%12s', ( format % x[:close ])}"          +
+          (short ? "" : "  #{"%10s" % ("[ % -4.1f ]" % x[:slope])}".colorize( if x[:slope].abs < 3; :yellow; elsif x[:slope] >= 3; :green; else; :red; end))               +
+          (short ? "" : "  #{"% 8d" % x[:volume]}")               +
+          "  #{vol}".colorize( case vol; when *["BREAKN", "FAINTN"]; :light_blue; when *["RISING","FALLIN"]; :cyan; else; :white; end) +
+          (short ? "" : "  D:#{"%5d"   % x[:dist]}"      )           +
+          (short ? "" : "  P:#{"%10.2f"   % (x[:dist] * power)}  ".cyan )     +
+          format('%10s', dir.to_s).colorize(col) +
+          (short ? "" : format('%-22s', "  >>> #{x.keys.map{|v| (COMMON.include?(v) or v.upcase == v)? nil : v}.compact.join(" ")}").colorize( col )) +
+          "\t#{x.keys.map{|v| (COMMON.include?(v) or v.upcase != v)? nil : special.call(v)}.compact.join(" ")}"
+  end
+
+  def candles(candles, debug: false, sym: )
+    ticksize = sym[:ticksize]
+
+    candles.each_with_index do |bar, i| 
+      # rel simply sets a grace limit based on the full height of the bar, so we won't need to use the hard limit of zero
+      begin 
+        rel  = ((bar[:high] - bar[:low]) * 0.05).round(8) 
+        rel  = 2 * ticksize if rel < 2 * ticksize
+      rescue 
+        puts "Warning, found inappropriate bar".light_white + " #{bar}"
+        raise
+      end
+      bar[:rel]        = rel
+      bar[:dist]     ||= ((bar[:high] - bar[:low])/ticksize).round(8)
+
+      bar[:upper]      = [bar[:open], bar[:close]].max
+      bar[:lower]      = [bar[:open], bar[:close]].min
+      bar[:bar_size]   = (bar[:high] - bar[:low])
+      bar[:body_size]  = (bar[:open] - bar[:close]).abs
+      bar[:lower_wick] = (bar[:lower] - bar[:low])
+      bar[:upper_wick] = (bar[:high] - bar[:upper])
+      bar.each{|k,v| bar[k] = v.round(8) if v.is_a? Float}
+
+      # a doji's open and close are same (or only differ by rel)
+      bar[:doji]    = true if bar[:body_size] <= rel and bar[:dist] >= 3
+      bar[:tiny]    = true if bar[:dist] <= 5
+
+      next if bar[:tiny]
+
+      bar[:bullish]  = true if not bar[:doji] and bar[:close] > bar[:open]
+      bar[:bearish]  = true if not bar[:doji] and bar[:close] < bar[:open]
+
+      bar[:spinning_top] = true if bar[:body_size]       <= bar[:bar_size] / 4 and 
+        bar[:lower_wick] >= bar[:bar_size] / 4 and
+        bar[:upper_wick] >= bar[:bar_size] / 4
+
+      # a marubozu open at high or low and closes at low or high
+      bar[:marubozu] = true if bar[:upper_wick] < rel and bar[:lower_wick] < rel
+
+      # a bar is considered bearish if it has at least a dist of 5 ticks and it's close it near high (low resp)
+      bar[:bullish_close] = true if (bar[:high] - bar[:close]) <= rel and not bar[:marubozu]
+      bar[:bearish_close] = true if (bar[:close] - bar[:low])  <= rel and not bar[:marubozu]
+
+      # the distribution of main volume is shown in 5 segments, like [0|0|0|4|5] shows that most volume concentrated at the bottom, [0|0|3|0|0] is heavily centered
+      # TODO
+
+    end 
+    candles
+  end
+
+  def comparebars(prev, curr)
+    bullishscore  = 0
+    bearishscore  = 0
+    bullishscore += 1 if prev[:high]  <= curr[:high]
+    bullishscore += 1 if prev[:low]   <= curr[:low]
+    bullishscore += 1 if prev[:close] <= curr[:close]
+    bearishscore += 1 if prev[:close] >= curr[:close]
+    bearishscore += 1 if prev[:low]   >= curr[:low]
+    bearishscore += 1 if prev[:high]  >= curr[:high]
+    r = {}
+    r[:bullish] = true if bullishscore >= 2
+    r[:bearish] = true if bearishscore >= 2
+    return r
+  end
+
+
+  def patterns(candles, debug: false, size: 5, contract:, ticksize: nil )
+    candles.each_with_index do |bar, i|
+      preceeding = candles.select{|x| x[:datetime] <= bar[:datetime] } 
+      if i.zero?
+        bar[:slope] = 0
+        next
+      end
+      ppprev= candles[i-3]
+      pprev= candles[i-2]
+      prev = candles[i-1]
+      succ = candles[i+1]
+
+      bar[:huge]     = true if bar[:true_range] >= bar[:atr] * 1.5
+      bar[:small]    = true if bar[:true_range] <= bar[:atr5] * 0.6666
+
+      bar[:vavg]     = (bar[:vranges].reduce(:+) / bar[:vranges].size.to_f).round  if bar[:vranges] and bar[:vranges].compact.size > 0
+      bar[:vranges]  = prev[:vranges].nil? ? [ bar[:volume] ] : prev[:vranges] + [ bar[:volume] ] 
+      bar[:vranges].shift while bar[:vranges].size > size
+      bar[:vavg]   ||= (bar[:vranges].reduce(:+) / bar[:vranges].size.to_f).round  if bar[:vranges] and bar[:vranges].compact.size > 0
+
+
+
+      # VOLUME
+      if bar[:volume] > bar[:vavg] * 1.3
+        bar[:BREAKN_volume] = true 
+      elsif bar[:volume] >= bar[:vavg] * 1.1
+        bar[:RISING_volume] = true 
+      elsif bar[:volume] <  bar[:vavg]   * 0.7
+        bar[:FAINTN_volume] = true
+      elsif bar[:volume] <= bar[:vavg]  * 0.9 
+        bar[:FALLIN_volume] = true
+      else
+        bar[:STABLE_volume] = true
+      end
+
+      # GAPS 
+      bar[:bodygap] = true if bar[:lower] > prev[:upper] or bar[:upper] < prev[:lower] 
+      bar[:gap]     = true if bar[:low] > prev[:high] or bar[:high] < prev[:low]
+
+
+      bar[:slope] = slopescore(pprev, prev, bar, debug)
+      bar[:prev_slope] = prev[:slope] 
+
+      # UPPER_PIVOTs define by having higher highs and higher lows than their neighor
+      bar[:UPPER_ISOPIVOT] = true if succ and prev[:high]  < bar[:high] and prev[:low] <= bar[:low] and succ[:high] <  bar[:high] and succ[:low] <= bar[:low] and bar[:lower] >= [prev[:upper], succ[:upper]].max
+      bar[:LOWER_ISOPIVOT] = true if succ and prev[:high] >= bar[:high] and prev[:low] >  bar[:low] and succ[:high] >= bar[:high] and succ[:low] >  bar[:low] and bar[:upper] <= [prev[:lower], succ[:lower]].min
+      bar[:UPPER_PIVOT] = true if succ and prev[:high]  < bar[:high] and prev[:low] <= bar[:low] and succ[:high] <  bar[:high] and succ[:low] <= bar[:low] and not bar[:UPPER_ISOPIVOT]
+      bar[:LOWER_PIVOT] = true if succ and prev[:high] >= bar[:high] and prev[:low] >  bar[:low] and succ[:high] >= bar[:high] and succ[:low] >  bar[:low] and not bar[:LOWER_ISOPIVOT]
+
+      # stopping volume is defined as high volume candle during downtrend then closes above mid candle (i.e. lower_wick > body_size)
+      bar[:stopping_volume] = true if (bar[:BREAKN_volume] or bar[:RISING_volume]) and prev[:slope] < -5 and bar[:lower_wick] >= bar[:body_size]
+      bar[:stopping_volume] = true if (bar[:BREAKN_volume] or bar[:RISING_volume]) and prev[:slope] >  5 and bar[:upper_wick] >= bar[:body_size]
+      bar[:volume_lower_wick] = true if bar[:vhigh] and (bar[:vol_i].nil? or bar[:vol_i] >= 2) and bar[:vhigh] <= bar[:lower] and not bar[:FAINTN_volume] and not bar[:FALLIN_volume]
+      bar[:volume_upper_wick] = true if bar[:vlow]  and (bar[:vol_i].nil? or bar[:vol_i] >= 2) and bar[:vlow]  >= bar[:upper] and not bar[:FAINTN_volume] and not bar[:FALLIN_volume]
+
+
+      ###################################
+      # SINGLE CANDLE PATTERNS 
+      ################################### 
+
+      # a hammer is a bar, whose open or close is at the high and whose body is lte 1/3 of the size, found on falling slope, preferrably gapping away
+      bar[:HAMMER]          = true if bar[:upper_wick] <=  bar[:rel] and bar[:body_size] <= bar[:bar_size] / 3 and bar[ :slope] <= -6
+      # same shape, but found at a raising slope without the need to gap away
+      bar[:HANGING_MAN]     = true if bar[:upper_wick] <=  bar[:rel] and bar[:body_size] <= bar[:bar_size] / 3 and prev[:slope] >=  6
+
+      # a shooting star is the inverse of the hammer, while the inverted hammer is the inverse of the hanging man
+      bar[:SHOOTING_STAR]   = true if bar[:lower_wick] <= bar[:rel] and bar[:body_size] <= bar[:bar_size] / 2.5 and bar[ :slope] >= 6      
+      bar[:INVERTED_HAMMER] = true if bar[:lower_wick] <= bar[:rel] and bar[:body_size] <= bar[:bar_size] / 3   and prev[:slope] <= -6
+
+      # a star is simply gapping away the preceding slope
+      if ((bar[:lower] > prev[:upper] and bar[:slope] >= 6    and bar[:high] >= prev[:high]) or 
+          (bar[:upper] < prev[:lower] and bar[:slope] <= -6)  and bar[:low]  <= prev[:low])
+        bar[:doji] ? bar[:DOJI_STAR] = true : bar[:STAR] = true
+      end
+
+
+      # a belthold is has a gap in the open, but reverses strong
+      bar[:BULLISH_BELTHOLD] = true if bar[:lower_wick] <= bar[:rel] and bar[:body_size] >= bar[:bar_size] / 2 and 
+        prev[:slope] <= -4 and bar[:lower] <= prev[:low ] and bar[:bullish] and not prev[:bullish] and bar[:bar_size] >= prev[:bar_size]
+      bar[:BEARISH_BELTHOLD] = true if bar[:upper_wick] <= bar[:rel] and bar[:body_size] >= bar[:bar_size] / 2 and 
+        prev[:slope] >= -4 and bar[:upper] <= prev[:high] and bar[:bearish] and not prev[:bearish] and bar[:bar_size] >= prev[:bar_size]
+
+
+      ###################################
+      # DUAL CANDLE PATTERNS
+      ###################################
+
+
+      # ENGULFINGS
+      bar[:BULLISH_ENGULFING] = true if bar[:bullish] and prev[:bearish] and bar[:lower] <= prev[:lower] and bar[:upper] >  prev[:upper] and prev[:slope] <= -6
+      bar[:BEARISH_ENGULFING] = true if bar[:bearish] and prev[:bullish] and bar[:lower] <  prev[:lower] and bar[:upper] >= prev[:upper] and prev[:slope] >=  6
+
+
+      # DARK-CLOUD-COVER / PIERCING-LINE (on-neck / in-neck / thrusting / piercing / PDF pg 63)
+      bar[:DARK_CLOUD_COVER]  = true if bar[:slope] > 5  and prev[:bullish] and bar[:open] > prev[:high] and bar[:close] < prev[:upper] - prev[:body_size] * 0.5  and 
+        not bar[:BEARISH_ENGULFING]
+      bar[:PIERCING_LINE]     = true if bar[:slope] < -5 and prev[:bearish] and bar[:open] < prev[:low ] and bar[:close] > prev[:lower] + prev[:body_size] * 0.5  and 
+        not bar[:BULLISH_ENGULFING]
+      bar[:SMALL_CLOUD_COVER] = true if bar[:slope] > 5  and prev[:bullish] and bar[:open] > prev[:high] and bar[:close] < prev[:upper] - prev[:body_size] * 0.25 and 
+        not bar[:BEARISH_ENGULFING] and not bar[:DARK_CLOUD_COVER]
+      bar[:THRUSTING_LINE]    = true if bar[:slope] < -5 and prev[:bearish] and bar[:open] < prev[:low ] and bar[:close] > prev[:lower] + prev[:body_size] * 0.25 and 
+        not bar[:BULLISH_ENGULFING] and not bar[:PIERCING_LINE]
+
+
+      # COUNTER ATTACKS are like piercings / cloud covers, but insist on a large reverse while only reaching the preceding close
+      bar[:BULLISH_COUNTERATTACK] = true if bar[:slope] < 6 and prev[:bearish] and bar[:bar_size] > bar[:atr] * 0.66 and (bar[:close] - prev[:close]).abs < 2 * bar[:rel] and 
+        bar[:body_size] >= bar[:bar_size] * 0.5 and bar[:bullish]
+      bar[:BEARISH_COUNTERATTACK] = true if bar[:slope] > 6 and prev[:bullish] and bar[:bar_size] > bar[:atr] * 0.66 and (bar[:close] - prev[:close]).abs < 2 * bar[:rel] and
+        bar[:body_size] >= bar[:bar_size] * 0.5 and bar[:bearish]
+
+
+      # HARAMIs are an unusual long body embedding the following small body
+      bar[:HARAMI]       = true if bar[:body_size] < prev[:body_size] / 2.5 and prev[:bar_size] >= bar[:atr] and 
+        prev[:upper] > bar[:upper] and prev[:lower] < bar[:lower] and not bar[:doji]
+      bar[:HARAMI_CROSS] = true if bar[:body_size] < prev[:body_size] / 2.5 and prev[:bar_size] >= bar[:atr] and
+        prev[:upper] > bar[:upper] and prev[:lower] < bar[:lower] and     bar[:doji]
+      if bar[:HARAMI] or bar[:HARAMI_CROSS]
+        puts [ :date, :open, :high, :low, :close, :upper, :lower ].map{|x| prev[x]}.join("\t") if debug
+        puts [ :date, :open, :high, :low, :close, :upper, :lower ].map{|x| bar[ x]}.join("\t") if debug
+        puts  "" if debug
+      end
+
+      # TODO TWEEZER_TOP and TWEEZER_BOTTOM
+      # actually being a double top / bottom, this dual candle pattern has to be unfolded. It is valid on daily or weekly charts, 
+      # and valid if 
+      #     1 it has an according 
+
+
+      ###################################
+      # TRIPLE CANDLE PATTERNS
+      ###################################
+
+      # morning star, morning doji star
+      next unless prev and pprev
+      bar[:MORNING_STAR]      = true if prev[:STAR]      and bar[:bullish] and bar[:close] >= pprev[:lower] and prev[:slope] < -6
+      bar[:MORNING_DOJI_STAR] = true if prev[:DOJI_STAR] and bar[:bullish] and bar[:close] >= pprev[:lower] and prev[:slope] < -6 
+      bar[:EVENING_STAR]      = true if prev[:STAR]      and bar[:bearish] and bar[:close] <= pprev[:upper] and prev[:slope] >  6
+      bar[:EVENING_DOJI_STAR] = true if prev[:DOJI_STAR] and bar[:bearish] and bar[:close] <= pprev[:upper] and prev[:slope] >  6
+
+      # the abandoned baby escalates above stars by gapping the inner star candle to both framing it
+      bar[:ABANDONED_BABY]    = true if (bar[:MORNING_STAR] or bar[:MORNING_DOJI_STAR]) and prev[:high] <= [ pprev[:low ], bar[:low ] ].min
+      bar[:ABANDONED_BABY]    = true if (bar[:EVENING_STAR] or bar[:EVENING_DOJI_STAR]) and prev[:low ] >= [ pprev[:high], bar[:high] ].max
+
+      # UPSIDEGAP_TWO_CROWS
+      bar[:UPSIDEGAP_TWO_CROWS] = true if (prev[:STAR] or prev[:DOJI_STAR]) and prev[:slope] > 4 and bar[:bearish] and prev[:bearish] and bar[:close] > pprev[:close]
+      bar[:DOWNGAP_TWO_RIVERS]  = true if (prev[:STAR] or prev[:DOJI_STAR]) and prev[:slope] < 4 and bar[:bullish] and prev[:bullish] and bar[:close] < pprev[:close]
+
+      # THREE BLACK CROWS / THREE WHITE SOLDIERS
+      bar[:THREE_BLACK_CROWS]   = true if [ bar, prev, pprev ].map{|x| x[:bearish] and x[:bar_size] > 0.5 * bar[:atr] }.reduce(:&) and 
+        pprev[:close] - prev[ :close] > bar[:atr] * 0.2 and 
+        prev[ :close] - bar[  :close] > bar[:atr] * 0.2
+      bar[:THREE_WHITE_SOLDIERS] = true if [ bar, prev, pprev ].map{|x| x[:bullish] and x[:bar_size] > 0.5 * bar[:atr] }.reduce(:&) and
+        prev[:close]  - pprev[:close] > bar[:atr] * 0.2 and 
+        bar[ :close]  - prev[ :close] > bar[:atr] * 0.2
+
+      #### MARKTTECHNIK ####
+
+      # Umkehrstäbe
+      # Ein Umkehrstab bullish ist ein Candle, der zumindest einen Downtrend aus 3 Kerzen beenden könnte.
+      # dazu muss der stab selber ein niedrigers tief haben als seine beiden vorgänger,
+      # der TR muss above average sein und der vorgänger muss einen slopescore von < -5 haben 
+      #
+      if pprev[:low] > prev[:low] and prev[:low] > bar[:low] and
+          ( bar[:tr] > bar[:atr] * 1.25 or bar[:BREAKN_volume] ) and
+          prev[:slope] <= -5 and 
+          bar[:close] - bar[:low] >= (bar[:bar_size]) * 0.7
+        #bar[:close] >= (bar[:high] + bar[:low]) / 2.0 
+        bar[:UMKEHRSTAB_BULLISH] = true
+        bar[:CLASSIC] = true
+      end
+
+      if pprev[:high] < prev[:high] and prev[:high] < bar[:high] and 
+          ( bar[:tr] > bar[:atr] * 1.25 or bar[:BREAKN_volume] ) and
+          prev[:slope] >= 5 and
+          bar[:high] - bar[:close] >= (bar[:bar_size]) * 0.7
+        #bar[:close] <= (bar[:high] + bar[:low]) / 2.0
+        bar[:UMKEHRSTAB_BEARISH] = true 
+        bar[:CLASSIC] = true
+      end
+
+      # TINY REVERSALS only work for short periods of time (i.e. lte 5 min)
+
+      if bar[:datetime] and bar[:datetime].respond_to?(:-) and bar[:datetime] - prev[:datetime] <= 5*60
+        if pprev[:low] > prev[:low] and prev[:low] > bar[:low] and
+            ((not bar[:tiny] and bar[:bar_size] >= 0.75 * bar[:atr]) or bar[:BREAKN_volume]) and 
+            bar[:high] - bar[:close] < bar[:bar_size] / 2.5
+          bar[:UMKEHRSTAB_BULLISH] = true 
+          bar[:TINY] = true
+        end
+        if pprev[:high] < prev[:high] and prev[:high] < bar[:high] and
+            ((not bar[:tiny] and bar[:bar_size] >= 0.75 * bar[:atr]) or bar[:BREAKN_volume]) and
+            bar[:close] - bar[:low]  < bar[:bar_size] / 2.5
+          bar[:UMKEHRSTAB_BEARISH] = true
+          bar[:TINY] = true
+        end
+      end
+
+      # GEM reversals are just another set of criteria
+      if prev[:low] > bar[:low] and prev[:high] > bar[:high] and
+          (bar[:bar_size] >= bar[:atr] or bar[:BREAKN_volume]) and
+          bar[:high] - bar[:close] < bar[:bar_size] / 4.0
+        bar[:UMKEHRSTAB_BULLISH] = true
+        bar[:GEM] = true
+      end
+      if prev[:low] < bar[:low] and prev[:high] < bar[:high] and
+          (bar[:bar_size] >= bar[:atr] or bar[:BREAKN_volume]) and
+          bar[:close] - bar[:low] < bar[:bar_size] / 4.0
+        bar[:UMKEHRSTAB_BEARISH] = true
+        bar[:GEM] = true
+      end
+
+      # DOUBLEBAR reversals are reversals, that span over 2 bars instead of one
+      unless ppprev.nil? or pprev[:slope].nil?
+        pot = { 
+          open:  prev[:open],
+          high: [prev[:high], bar[:high]].max,
+          low:  [prev[:low], bar[:low]].min,
+          close: bar[:close]
+        }
+        pot[:size] = (pot[:high] - pot[:low]).round(8)
+        if (pprev[:slope] >=8 or (prev[:low] > pprev[:low] and pprev[:low] > ppprev[:low])) and pot[:high] > pprev[:high] and
+            pot[:high] - pot[:close] >=  pot[:size] * 0.7
+          bar[:UMKEHRSTAB_BEARISH] = true
+          bar[:DOUBLE] = true
+        end
+        if (pprev[:slope] <=-8 or (prev[:high] < pprev[:high] and pprev[:high] < ppprev[:high])) and 
+            pot[:low] < pprev[:low] and
+            pot[:close] - pot[:low] >= pot[:size] * 0.7
+          bar[:UMKEHRSTAB_BULLISH] = true
+          bar[:DOUBLE] = true
+        end
+      end
+
+      # BULLISH_MOVE und BEARISH_MOVE
+
+      unless  pprev[:atr].nil?
+        if pprev[:high] > prev[:high] and prev[:high] > bar[:high] and
+            pprev[:low]  > prev[:low]  and prev[:low]  > bar[:low]  and
+            bar[:bar_size] >= pprev[:atr] and pprev[:bar_size] >= pprev[:atr] and prev[:bar_size] >= pprev[:atr] and
+            bar[:close] - bar[:low] < bar[:bar_size] / 3 
+          bar[:BEARISH_MOVE] = prev[:BEARISH_MOVE].nil? ? (pprev[:BEARISH_MOVE].nil? ? 1 : pprev[:BEARISH_MOVE] + 2) : prev[:BEARISH_MOVE] + 1 
+        end
+        if pprev[:high] < prev[:high] and prev[:high] < bar[:high] and
+            pprev[:low]  < prev[:low]  and prev[:low]  < bar[:low]  and
+            bar[:bar_size] >= pprev[:atr] and pprev[:bar_size] >= pprev[:atr] and prev[:bar_size] >= pprev[:atr] and
+            bar[:high] - bar[:close] < bar[:bar_size] / 3
+          bar[:BULLISH_MOVE] = prev[:BULLISH_MOVE].nil? ? (pprev[:BULLISH_MOVE].nil? ? 1 : pprev[:BULLISH_MOVE] + 2) : prev[:BULLISH_MOVE] + 1
+        end
+      end
+
+      # support and resistance
+
+    end
+  end
+
+
+  # SLOPE SCORE
+  def slopescore(pprev, prev, bar, debug = false)
+    # the slope between to bars is considered bullish, if 2 of three points match
+    #     - higher high
+    #     - higher close
+    #     - higher low
+    # the opposite counts for bearish
+    # 
+    # this comparison is done between the current bar and previous bar
+    #     - if it confirms the score of the previous bar, the new slope score is prev + curr
+    #     - otherwise the is compared to score of the pprevious bar
+    #         - if it confirms there, the new slope score is pprev + curr
+    #         - otherwise the trend is destroyed and tne new score is solely curr
+
+    if bar[:bullish]
+      curr  = 1
+      curr += 1   if bar[:bullish_close]
+    elsif bar[:bearish]
+      curr  = -1 
+      curr -=  1  if bar[:bearish_close]
+    else
+      curr  = 0
+    end
+    puts "curr set to #{curr} @ #{bar[:date]}".yellow if debug
+    if prev.nil?
+      puts "no prev found, score == curr: #{curr}" if debug
+      score = curr
+    else
+      comp = comparebars(prev, bar)
+
+      puts prev.select{|k,v| [:high,:low,:close,:score].include?(k)} if debug
+      puts bar if debug
+      puts "COMPARISON 1: #{comp}" if debug
+
+      if prev[:slope] >= 0 and comp[:bullish]     # bullish slope confirmed
+        score  = prev[:slope]
+        score += curr if curr > 0
+        [ :gap, :bodygap ] .each {|x| score += 0.5  if bar[x] }
+        score += 1 if bar[:RISING_volume]
+        score += 2 if bar[:BREAKN_volume]
+        puts "found bullish slope confirmed, new score #{score}" if debug
+      elsif prev[:slope] <= 0 and comp[:bearish]  # bearish slope confirmed
+        score  = prev[:slope] 
+        score += curr if curr < 0
+        [ :gap, :bodygap ] .each {|x| score -= 0.5  if bar[x] }
+        score -= 1 if bar[:RISING_volume]
+        score -= 2 if bar[:BREAKN_volume]
+        puts "found bearish slope confirmed, new score #{score} (including #{curr} and #{bar[:bodygap]} and #{bar[:gap]}" if debug
+      else #if prev[:slope] > 0                     # slopes failed
+        puts "confirmation failed: " if debug
+        if pprev.nil? 
+          score = curr
+        else
+          comp2 = comparebars(pprev, bar)
+          puts "\t\tCOMPARISON 2: #{comp2}" if debug
+          if pprev[:slope] >= 0 and comp2[:bullish]     # bullish slope confirmed on pprev
+            score  = pprev[:slope]
+            score += curr if curr > 0
+            [ :gap, :bodygap ] .each {|x| score += 0.5  if bar[x] }
+            puts "\t\tfound bullish slope confirmed, new score #{score}" if debug
+            score += 1 if bar[:RISING_volume]
+            score += 2 if bar[:BREAKN_volume]
+          elsif pprev[:slope] <= 0 and comp2[:bearish]  # bearish slope confirmed
+            score  = pprev[:slope]
+            score += curr if curr < 0
+            [ :gap, :bodygap ] .each {|x| score -= 0.5  if bar[x] }
+            score -= 1 if bar[:RISING_volume]
+            score -= 2 if bar[:BREAKN_volume]
+            puts "\t\tfound bearish slope confirmed, new score #{score}" if debug
+          else                                          #slope confirmation finally failed
+            comp3 = comparebars(pprev, prev)
+            if prev[:slope] > 0 # was bullish, turning bearish now
+              score  = curr                     
+              score -= 1 if comp3[:bearish]
+              score -= 1 if comp[:bearish]
+              score -= 1 if prev[:bearish]
+              score -= 1 if prev[:RISING_volume] and comp3[:bearish]
+              score -= 2 if prev[:BREAKN_volume] and comp3[:bearish]
+              score -= 1 if bar[:RISING_volume] and comp[:bearish]
+              score -= 2 if bar[:BREAKN_volume] and comp[:bearish]
+              score -= 1 if bar[:RISING_volume] and comp[:bearish]
+              score -= 2 if bar[:BREAKN_volume] and comp[:bearish]
+              [ :gap, :bodygap ] .each {|x| score += 0.5  if bar[x] } 
+              puts "\t\tfinally gave up, turning bearish now, new score #{score}" if debug
+            elsif prev[:slope] < 0
+              score = curr
+              score += 1 if comp3[:bullish]
+              score += 1 if comp[:bullish]
+              score += 1 if prev[:bullish]
+              score += 1 if prev[:RISING_volume] and comp3[:bullish]
+              score += 2 if prev[:BREAKN_volume] and comp3[:bullish]
+              score += 1 if bar[:RISING_volume] and comp[:bullish]
+              score += 2 if bar[:BREAKN_volume] and comp[:bullish]
+              score += 1 if bar[:RISING_volume] and comp[:bullish]
+              score += 2 if bar[:BREAKN_volume] and comp[:bullish]
+              [ :gap, :bodygap ] .each {|x| score -= 0.5  if bar[x] } if curr < 0
+              puts "\t\tfinally gave up, turning bullish now, new score #{score}" if debug
+            else
+              score = 0
+            end
+          end
+        end
+      end
+    end
+    puts "" if debug
+    score
+  end
+
+end
+
+CR = Candlestick_Recognition
+end
+end

data/lib/cotcube-helpers/subpattern.rb

@@ -22,12 +22,12 @@ module Cotcube
         lambda do |x|
           return false if x.nil? || (x.size < minimum)
 
-          return ((pattern =~ /^#{x}/i).nil? ? false : true)
+          return ((pattern =~ /^#{Regexp.escape x}/i).nil? ? false : true)
         end
       when Array
         pattern.map do |x|
           unless [String, Symbol, NilClass].include? x.class
-            raise TypeError, "Unsupported class '#{x.class}' for '#{x}'in pattern '#{pattern}'."
+            raise TypeError, "Unsupported class '#{x.class}' for '#{x}' in pattern '#{pattern}'."
           end
         end
         lambda do |x|
@@ -35,13 +35,13 @@ module Cotcube
             sub = sub.to_s
             return false if x.size < minimum
 
-            result = ((sub =~ /^#{x}/i).nil? ? false : true)
+            result = ((sub =~ /^#{Regexp.escape x}/i).nil? ? false : true)
             return true if result
           end
           return false
         end
       else
-        raise TypeError, "Unsupported class #{pattern.class} in Cotcube::Core::sub"
+        raise TypeError, "Unsupported class #{pattern.class} in Cotcube::Helpers::sub"
       end
     end
   end

data/lib/cotcube-helpers/symbols.rb

@@ -4,18 +4,66 @@ module Cotcube
   # Missing top level documentation
   module Helpers
 
-  def symbols(config: init, type: nil, symbol: nil)
+    SYMBOL_HEADERS = %i[ id symbol ib_symbol internal exchange currency ticksize power months type bcf reports format name ]
+
+    def symbols(config: init, **args)
       if config[:symbols_file].nil?
         SYMBOL_EXAMPLES
       else
         CSV
-          .read(config[:symbols_file], headers: %i{ id symbol ticksize power months type bcf reports format name})
+          .read(config[:symbols_file], headers: SYMBOL_HEADERS)
           .map{|row| row.to_h }
-          .map{|row| [ :ticksize, :power, :bcf ].each {|z| row[z] = row[z].to_f}; row[:format] = "%#{row[:format]}f"; row }
+          .map{|row|
+            [ :ticksize, :power, :bcf ].each {|z| row[z] = row[z].to_f}
+            row[:format] = "%#{row[:format]}f"
+            row[:currency] ||= 'USD'
+            row[:multiplier] = (row[:power] / row[:ticksize]).round(8)
+            row
+          }
           .reject{|row| row[:id].nil? }
-          .tap{|all| all.select!{|x| x[:type] == type} unless type.nil? }
-          .tap { |all| all.select! { |x| x[:symbol] == symbol } unless symbol.nil? }
+          .tap{ |all|
+            args.keys.each { |header|
+              unless SYMBOL_HEADERS.include? header
+                puts "WARNING in Cotcube::Helpers.symbols: '#{header}' is not a valid symbol header. Skipping..."
+                next
+              end
+              all.select!{|x| x[header] == args[header]} unless args[header].nil?
+              return all.first if all.size == 1
+            }
+            return all
+          }
       end
     end
 
+    def micros(config: init, **args)
+      if config[:micros_file].nil?
+        MICRO_EXAMPLES
+      else
+        CSV
+          .read(config[:micros_file], headers: SYMBOL_HEADERS)
+          .map{|row| row.to_h }
+          .map{|row|
+            [ :ticksize, :power, :bcf ].each {|z| row[z] = row[z].to_f }
+            row[:format] = "%#{row[:format]}f"
+            row[:currency] ||= 'USD'
+            row[:multiplier] = (row[:power] / row[:ticksize]).round(8)
+            row
+          }
+          .reject{|row| row[:id].nil? }
+          .tap{ |all|
+            args.keys.each { |header|
+             unless SYMBOL_HEADERS.include? header
+                puts "WARNING in Cotcube::Helpers.micros: '#{header}' is not a valid symbol header. Skipping..."
+                next
+              end
+              all.select!{|x| x[header] == args[header]} unless args[header].nil?
+              return all.first if all.size == 1
+            }
+            return all
+          }
+      end
+    end
+
+  end
+
 end

data/lib/cotcube-helpers.rb

@@ -6,6 +6,9 @@ require 'active_support'
 require 'active_support/core_ext/time'
 require 'active_support/core_ext/numeric'
 require 'parallel'
+require 'csv'
+require 'yaml'
+require 'json'
 
 require_relative 'cotcube-helpers/array_ext'
 require_relative 'cotcube-helpers/enum_ext'
@@ -13,26 +16,37 @@ require_relative 'cotcube-helpers/hash_ext'
 require_relative 'cotcube-helpers/range_ext'
 require_relative 'cotcube-helpers/string_ext'
 require_relative 'cotcube-helpers/datetime_ext'
+require_relative 'cotcube-helpers/numeric_ext'
 require_relative 'cotcube-helpers/subpattern'
 require_relative 'cotcube-helpers/parallelize'
 require_relative 'cotcube-helpers/simple_output'
 require_relative 'cotcube-helpers/simple_series_stats'
+require_relative 'cotcube-helpers/constants'
 require_relative 'cotcube-helpers/input'
+require_relative 'cotcube-helpers/output'
 require_relative 'cotcube-helpers/reduce'
-require_relative 'cotcube-helpers/constants'
 require_relative 'cotcube-helpers/symbols'
 require_relative 'cotcube-helpers/init'
 require_relative 'cotcube-helpers/get_id_set'
+require_relative 'cotcube-helpers/ib_contracts'
+require_relative 'cotcube-helpers/recognition'
+require_relative 'cotcube-helpers/data_client'
 
 module Cotcube
   module Helpers
     module_function :sub,
                     :parallelize,
+                    :config_path,
+                    :config_prefix,
                     :reduce,
                     :simple_series_stats,
                     :keystroke,
                     :symbols,
+                    :micros,
                     :get_id_set,
+                    :get_ib_contract,
+                    :update_ib_contracts,
+                    :translate_ib_contract,
                     :init
 
     # please not that module_functions of source provided in private files must be published there

data/scripts/cron_ruby_wrapper.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+export rubyenv=/home/pepe/.rvm/environments/default
+
+. $rubyenv 
+cd /home/pepe/GEMS/${1}
+export LC_ALL="en_US.utf8"
+
+ruby ${2} ${3} ${4} ${5} ${6}
+
+ 
+exit
+for testing run 
+env - `cat /home/pepe/bin/cron_ruby_wrapper.sh | tail -n 6` /bin/bash
+
+HOME=/home/pepe
+LOGNAME=pepe
+PATH=/usr/bin:/bin
+LANG=en_US.UTF-8
+SHELL=/bin/sh
+PWD=/home/pepe
+
+
+
+

data/scripts/symbols

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+option=$1
+headers='ID,Symbol,ticksize,power,months,type,factor,reports,format,name'
+
+if [ -z "${option}" ]
+then
+  (echo ${headers} && cat /etc/cotcube/symbols.csv /etc/cotcube/symbols_micros.csv) |  sed 's/,/ , /g' | column -s, -t
+else
+  (echo ${headers} && cat /etc/cotcube/symbols.csv /etc/cotcube/symbols_micros.csv) | grep -i "$option\|reports,format" | sed 's/,/ , /g' | column -s, -t
+fi
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-helpers
 version: !ruby/object:Gem::Version
-  version: 0.1.9.1
+  version: 0.2.1.1
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-07 00:00:00.000000000 Z
+date: 2021-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -97,14 +97,19 @@ files:
 - lib/cotcube-helpers.rb
 - lib/cotcube-helpers/array_ext.rb
 - lib/cotcube-helpers/constants.rb
+- lib/cotcube-helpers/data_client.rb
 - lib/cotcube-helpers/datetime_ext.rb
 - lib/cotcube-helpers/enum_ext.rb
 - lib/cotcube-helpers/get_id_set.rb
 - lib/cotcube-helpers/hash_ext.rb
+- lib/cotcube-helpers/ib_contracts.rb
 - lib/cotcube-helpers/init.rb
 - lib/cotcube-helpers/input.rb
+- lib/cotcube-helpers/numeric_ext.rb
+- lib/cotcube-helpers/output.rb
 - lib/cotcube-helpers/parallelize.rb
 - lib/cotcube-helpers/range_ext.rb
+- lib/cotcube-helpers/recognition.rb
 - lib/cotcube-helpers/reduce.rb
 - lib/cotcube-helpers/simple_output.rb
 - lib/cotcube-helpers/simple_series_stats.rb
@@ -114,6 +119,8 @@ files:
 - lib/cotcube-helpers/swig/fill_x.rb
 - lib/cotcube-helpers/swig/recognition.rb
 - lib/cotcube-helpers/symbols.rb
+- scripts/cron_ruby_wrapper.sh
+- scripts/symbols
 homepage: https://github.com/donkeybridge/cotcube-helpers
 licenses:
 - BSD-4-Clause
@@ -136,7 +143,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: Some helpers and core extensions as part of the Cotcube Suite.