cotcube-helpers 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b44c8314e88c5aca5675c78b3295f082730ddce80afc445d80228260e5c566e
-  data.tar.gz: 1bb545d175194aa375675b715ac63defbc1bef7101d828197d3d2aac6456cc4f
+  metadata.gz: 38df15256f996b15dfeb1755f7464e932a98541e62aa43efda0a264be58bafb2
+  data.tar.gz: cd336b6a91442a6d3bbace66ec8a25049ae979ab78eef03d1c8b44a548da8023
 SHA512:
-  metadata.gz: 1bf9097c6a01afb4d68bb4bf884d7766fad12481f585ee8df9a6def9fbc82b0cef5ce0fa98eeaaad65d682406d9ac11bae8993f760a60ae390cea23aceeba791
-  data.tar.gz: 1f987e28e73bc9cbb66da5f8d51f7d0c4200f03c683ee36dc7f228b3684149b33aa6ed9d2d490ace172e5c8811d1f344e427324449066a2621fca55394556e67
+  metadata.gz: bcfc562ab118939e7c23dc37b89fee881871552b6b7b17ec7066cb4a2028fa2661e50cd5512725da28332dd1b983d6817d416d31ba05059dd15d824a0e101f7c
+  data.tar.gz: 9ca3305120eb630283e303206b764cf9d8dd533ceaf0a2aa044f702fa2f2a01055ff70a4331ec865d854580b1dcf367f365c5addbb988605537c0ee9b9b6fad9

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 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
+
 ## 0.1.9 (May 07, 2021)
   - added constants, init and symbols to helpers
 

data/VERSION

@@ -1 +1 @@
-0.1.9
+0.2.0

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
 
 

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Helpers
+
+    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) && ([2,3,4,5].include? contract.length)
+        c_symbol = contract[0..1]
+        if (not symbol.nil?) && (symbol != c_symbol)
+          raise ArgumentError,
+                "Mismatch between given symbol #{symbol} and contract #{contract}"
+        end
+
+        symbol = c_symbol
+      end
+
+      unless symbol.nil?
+        sym = symbols(symbol: symbol)
+        if sym.nil? || sym[:id].nil?
+          raise ArgumentError,
+                "Could not find match in #{config[:symbols_file]} for given symbol #{symbol}"
+        end
+        raise ArgumentError, "Mismatching symbol #{symbol} and given id #{id}" if (not id.nil?) && (sym[:id] != id)
+
+        return micro ? micros(id: sym[:id])  : sym
+      end
+      unless id.nil?
+        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 micro ? micros(id: sym[:id]) : sym
+      end
+      raise ArgumentError, 'Need :id, :symbol or valid :contract '
+    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,64 @@ 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[:currency] ||= 'USD'
+            row[:multiplier] = (row[:ticksize] / row[:power]).round(8)
+            row
+          }
+          .reject{|row| row[:id].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, symbol: nil, id: nil)
+      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 }
+          .map{|row|
+            [ :ticksize, :power, :bcf ].each {|z| row[z] = row[z].to_f }
+            row[:format] = "%#{row[:format]}f"
+            row[:currency] ||= 'USD'
+            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
+  end
 
 end

data/lib/cotcube-helpers.rb

@@ -6,6 +6,7 @@ require 'active_support'
 require 'active_support/core_ext/time'
 require 'active_support/core_ext/numeric'
 require 'parallel'
+require 'csv'
 
 require_relative 'cotcube-helpers/array_ext'
 require_relative 'cotcube-helpers/enum_ext'
@@ -13,24 +14,32 @@ 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-heleprs/init'
+require_relative 'cotcube-helpers/init'
+require_relative 'cotcube-helpers/get_id_set'
+require_relative 'cotcube-helpers/recognition'
 
 module Cotcube
   module Helpers
     module_function :sub,
                     :parallelize,
+                    :config_path,
+                    :config_prefix,
                     :reduce,
                     :simple_series_stats,
                     :keystroke,
                     :symbols,
+                    :micros,
+                    :get_id_set,
                     :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
+  version: 0.2.0
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-07 00:00:00.000000000 Z
+date: 2021-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -99,11 +99,15 @@ files:
 - lib/cotcube-helpers/constants.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/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
@@ -113,6 +117,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
@@ -135,7 +141,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.