cotcube-level 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1c9fc6eb075ccc486c29c13d9989e52b5e659330cba2b900bdd4f420d085bb8
-  data.tar.gz: 6303babcc58fd8def53c747174c0feaa669c848787c0c32eaa811e0f76aad61f
+  metadata.gz: 7756ccc0318477cf223fc205720c986daaaad4304439108b960ca410a15acf79
+  data.tar.gz: ba7a79e928da4c89b0e7103394899096ab42f5977986892c5e7396fe5d4abeff
 SHA512:
-  metadata.gz: a5bc9e406caecd100ad2aebaf5934f9c2b6f0b3c43dc51aa76b63575bb52bd77fec7b06f5b183801149f6b35fb367462261e93bb2c174ef8b10b29bb61ee2370
-  data.tar.gz: b1de063e02b133b76aea5ffe01b357fad9b9ed99461225cf8780b7cc592ea00bd043afef6d957a3a2f78db02e75291bfac775aa2c56c3cd36886378fbd7f7767
+  metadata.gz: ceb38b4a6c827b0d8a7b09e0c0f86e9050e49dce54504cf5075d2d2da5fb9fe99186c8e9aa3403a14b61d5d6fa831e86a43886279dea8e20efd1c818e119d1f0
+  data.tar.gz: f53b20c6848b4d7cc825a18819ace61ebade1238706dbd125e76318eeb2dd1e4abbc6dca2d9872accb0069df8ac9edb16762c45ea7bc9a8293b95452d36102a6

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.3.1 (August 24, 2021)
+  - renaming triangulation to tritangulation
+  - minor fixes in README and gemspec
+
+## 0.3.0 (August 24, 2021)
+  - removed tests, moving to cotcube-jobs
+  - all: added documentation
+  - triangulate: added continuous support and documentation
+  - eod_stencil: added support for continuous futures
+  - adapted tests to recent changes
+  - cotcube-level: included intraday_stencil
+  - intraday_stencil: added to repo
+  - eod_stencil: fixing minor typo
+  - triangulate: fixed indention
+  - stencil: slight changes, incl rename to EODStencil
+  - detect_slope: now returns all members, regardless of amount (i.e. check whether it is a valid swap will be done later)
+
 ## 0.2.0 (August 17, 2021)
   - cotcube-level: added new module_functions, added restrictive constants for intervals and swaptypes
   - adding new features to so-called 'test suite'

data/README.md

@@ -5,20 +5,20 @@ of the development process. All in the beginning was the wish to create an algor
 lines. So for like 2 year I was whirling my head on how to put an algorithmic ruler on a chart and rotate it until
 one or a set of trend lines are concise outpout. 
 
-As most hard do accomplish thing turn out to be much easier when you put them up side down, same happend to me in this
+As most hard to accomplish things turn out to be much easier when you put them up side down, same happened to me in this
 matter. I found rotating the ruler is too hard for, but instead transforming (shearing) the chart itself while keeping
 the ruler at its _level_ is much more eligible.
 
 The idea and the development of the algorithm had taken place within another Cotcube project named 'SwapSeeker'. At
-some point the SwapSeeker has become too complex so I decided to decouple the Level and the Stencil as independent
+some point the SwapSeeker has become too complex so I decided to decouple the Level and the Stencils as separate
 functional unit, that can be used on arbitrary time series.
 
 ### The shear mapping
 
 There is really no magic in it. The timeseries (or basically an interval of a timeseries) needs to be prepared to locate
 in Cartesian Quadrant I with fitting x==0 to y==0, and then a binary search on shearing angles determines the resulting 
-muiltitangent of which as the origin ('now') one point already is given. As limitation only shearing between 0 and 90
-deg is supported. 
+muiltitangent of which the origin ('now') as one point already is given. One limitation applies: Only shearing between
+0 and 90 degrees is supported. 
 
 The result contains 
 
@@ -28,17 +28,25 @@ to happen if _deg -> 0_.
 - the origin and two or more points residing on the same level--what is the desired result showing mathematical accuracy where 
 human eye cannot detect it in time. 
 
+### Tritangulation
+
+The 'tri' is about that to find an artificially supported slope (i.e. a swap) at least 3 points 
+have to reside on it. It is leaned to triangulate, but instead of working with angles we are working with tangents here.
+
+Shear mapping and slope detection might find a slope meeting the requirements. But in tritangulate, near misses are
+considered and added as members. 
+
 ### The stencil
 
 The shearing transformation is based on _x_ and _y_ values, where y obviously are the values of the series while _x_
 refers to the time. It turned out a much bigger challenge to create an expedient mapping from DateTime to Integer,
 where, as you foresee, 'now' should result in _x.zero?_. 
 
-## Usage
+## Usage (pure template text)
 
 TODO: Write usage instructions here
 
-## Development
+## Development (pure template text)
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.1

data/cotcube-level.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['donkeybridge@jtown.eu']
 
   spec.summary       = 'A gem to shear a time series '
-  spec.description   = 'A gem to shear a time series, basically serving as a yet unssen class of indicators.'
+  spec.description   = 'A gem to shear a time series, basically serving as a yet unseen class of indicators.'
 
   spec.homepage      = 'https://github.com/donkeybridge/' + spec.name
   spec.license       = 'BSD-3-Clause'

data/lib/cotcube-level/detect_slope.rb

@@ -1,117 +1,98 @@
 module Cotcube
   module Level
-    #
-      # TODO: add support for slopes not only exactly matching but also allow 'dip' of n x ticksize
-      def detect_slope(base:, max: 90, debug: false, format: '% 5.2f', calculus: false, ticksize: nil, max_dev: 200)
-        raise ArgumentError, "'0 < max < 90, but got '#{max}'" unless max.is_a? Numeric and 0 < max and max <= 90
-        #
-        # aiming for a shearing angle, all but those in a line below the abscissa
-        #
-        # doing a binary search starting at part = 45 degrees
-        # on each iteration,
-        #   part is halved and added or substracted based on current success
-        #   if more than the mandatory result is found, all negative results are removed and degrees are increased by part
-        #
-        raise ArgumentError, 'detect_slope needs param Array :base' unless base.is_a? Array
-
-        # from given base, choose non-negative stencil containing values
-        old_base = base.dup.select{|b| b[:x] >= 0 and not b[:y].nil? }
+    def detect_slope(base:, max: 90, debug: false, format: '% 5.2f', calculus: false, ticksize: nil, max_dev: 200)
+      raise ArgumentError, "'0 < max < 90, but got '#{max}'" unless max.is_a? Numeric and 0 < max and max <= 90
+      #
+      # this method processes a 'well prepared' stencil in a way, that :y values are sheared around stencil.zero,
+      #     resulting to a temporary :yy value for each point. this process is iterated until no more :yy
+      #     values are above the abscissa ( yy > 0 ) but at least one other values is on (yy == 0)
+      #
+      # the entire process initially aimed to find slopes that contain 3 or more members. the current version 
+      #     is confident with 2 members--or even one member, which results in an even slope.
+      #
+      # it works by running a binary search, whereon each iteration,
+      #   - :part is halved and added or substracted based on current success
+      #   - if more than the mandatory result is found, all negative results are removed and degrees are increased by part
+      #   - if no results are found, the process is repeated with the same current base after degrees are decreased by part
+      #
+      raise ArgumentError, 'detect_slope needs param Array :base' unless base.is_a? Array
 
-        # some debug output
-        old_base.each {|x| p x} if old_base.size < 50 and debug
+      # from given base, choose non-negative stencil containing values
+      old_base = base.dup.select{|b| b[:x] >= 0 and not b[:y].nil? }
 
-        # set initial shearing angle if not given as param
-        deg ||= -max / 2.0 
+      # set initial shearing angle if not given as param. This is a prepared functionality, that is not yet used.
+      # when implemented to use in tritangulate, it would speed up the binary search process, but initial part 
+      # has to be set in a different way
+      deg ||= -max / 2.0
 
-        # create first sheering. please note how selection working with d[:yy]
-        new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 } #-ticksize }
+      # create first shearing. please note how selection works with d[:yy]
+      new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 }
 
-        # debug output
-        puts "Iterating slope:\t#{format '% 7.5f',deg
+      # debug output
+      puts "Iterating slope:\t#{format '% 7.5f',deg
                            }\t\t#{new_base.size
                            } || #{new_base.values_at(*[0]).map{|f| "'#{f[:x]
                                                                     } | #{format format,f[:y]
                                                                     } | #{format format,f[:yy]}'"}.join(" || ") }" if debug
-        # set initial part to deg
-        part = deg.abs
-        #
-        # the loop, that runs until either
-        #   - only two points are left on the slope
-        #   - the slope has even angle
-        #   - several points are on the slope in quite a good approximation ('round(7)')
-        #
-        until deg.round(PRECISION).zero? || part.round(PRECISION).zero? ||
-            ((new_base.size >= 2) && (new_base.map { |f| f[:yy].round(PRECISION).zero? }.uniq.size == 1))
-
-          part /= 2.0
-          if new_base.size == 1
-            # the graph was sheared too far, reuse old_base
-            deg = deg + part
-          else
-            # the graph was sheared too short, continue with new base
-            deg = deg - part
-            old_base = new_base.dup unless deg.round(PRECISION).zero?
-          end
+      # set initial part to deg
+      part = deg.abs
+      #
+      # the loop, that runs until either
+      #   - only two points are left on the slope
+      #   - the slope has even angle
+      #   - several points are found on the slope in quite a good approximation ('round(PRECISION)')
+      #
+      until deg.round(PRECISION).zero? || part.round(PRECISION).zero? ||
+          ((new_base.size >= 2) && (new_base.map { |f| f[:yy].round(PRECISION / 2).zero? }.uniq.size == 1))
 
-          # the actual sheering operation
-          # note that this basically maps old_base with yy = y + (dx||x * tan(deg) )
-          #
-          new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 } #-ticksize }
-          new_base.last[:dx] = 0.0 
-          if debug
-            print " #{format '% 8.5f',deg}"
-            puts "Iterating slope:\t#{format '% 8.5f',deg
-                                 }\t#{new_base.size
-                               } || #{new_base.values_at(*[0]).map{|f| "'#{f[:x]
-                                                                     } | #{format '%4.5f', part
-                                                                     } | #{format format,f[:y]
-                                                                     } | #{format format,f[:yy]}'"}.join(" || ") }"
-          end
+        part /= 2.0
+        if new_base.size == 1
+          # the graph was sheared too far, reuse old_base
+          deg += part
+        else
+          # the graph was sheared too short, continue with new base
+          deg -= part
+          old_base = new_base.dup unless deg.round(PRECISION).zero?
         end
-        puts ' done.' if debug
 
-        ### Sheering ends here
+        # the actual shearing operation
+        # this basically maps old_base with yy = y + (dx||x * tan(deg) )
+        #
+        new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 }
+        new_base.last[:dx] = 0.0
 
-        # define the approximited result as (also) 0.0
-        new_base.each{|x| x[:yy] = 0.0}
-        if debug
-          puts "RESULT: #{deg} #{deg2rad(deg)}"
-          new_base.each {|f| puts "\t#{f.inspect}" }
-        end
-        # there is speacial treatment for even slopes
-        if deg.round(PRECISION).zero?
-          #puts "found even slope"
-          # this is intentionally voided as evenness is calculated somewhere else
-          # even_base = base.dup.select{|b| b[:x] >= 0 and not b[:y].nil? }[-2..-1].map{|x| x.dup}
-          # last_barrier is the last bar, that exceeds
-          #binding.irb
-          #last_barrier = even_base.select{|bar| (bar[:y] - even_base.last[:y]).abs > evenness * ticksize}.last
-          #even_base.select!{|bar| (bar[:y] - even_base.last[:y]).abs <= evenness * ticksize}
-          # could be, that no last barrier exists, when there is a top or bottom plateau
-          #even_base.select!{|bar| bar[:x] < last_barrier[:x]} unless last_barrier.nil?
-          # TODO
-          return { deg: 0,  slope: 0, members: [] } #, members: even_base.map { |x| xx = x.dup; %i[y yy].map { |z|  xx[z]=nil }; xx } })
+        # debug output is reduced by appr. 70%
+        if debug and Random.rand < 0.3
+          print " #{format '% 18.15f',deg}\t"
+          puts "Iterating slope:\t#{format '% 18.10f',deg
+                               }\t#{new_base.size
+                             } || #{new_base.values_at(*[0]).map{|f| "'#{f[:x]
+                                                                   } | #{format '%4.5f', part
+                                                                   } | #{format format,f[:y]
+                                                          } | #{format format,f[:yy]}'"}.join(" || ") }"
         end
+      end
+      ### Sheering ends here
 
+      # define the approximited result as (also) 0.0
+      new_base.each{|x| x[:yy] = 0.0}
 
-        #####################################################################################
-        # Calculate the slope bsaed on the angle that resulted above
-        #     y = m x + n -->
-        #                     m = delta-y / delta-x
-        #                     n = y0 - m * x0
-        #
-        slope     = (new_base.first[:y] - new_base.last[:y]) / (
-                        (new_base.first[:dx].nil? ? new_base.first[:x] : new_base.first[:dx]).to_f - 
-                        (new_base. last[:dx].nil? ? new_base. last[:x] : new_base. last[:dx]).to_f 
-                    )
-        # the result
-        {
-          deg:        deg,
-          slope:      slope,
-          members:   new_base.map { |x| x.dup }
-        }
-      end
+      #####################################################################################
+      # Calculate the slope based on the angle that resulted above
+      #     y = m x + n -->
+      #                     m = delta-y / delta-x
+      #                     n = y0 - m * x0
+      #
+      slope     = deg.zero? ? 0 : (new_base.first[:y] - new_base.last[:y]) / (
+        (new_base.first[:dx].nil? ? new_base.first[:x] : new_base.first[:dx]).to_f -
+        (new_base. last[:dx].nil? ? new_base. last[:x] : new_base. last[:dx]).to_f
+      )
+      # the result
+      {
+        deg:       deg,
+        slope:     slope,
+        members:   new_base.map { |x| x.dup }
+      }
+    end
   end
 end
-
-

data/lib/cotcube-level/{stencil.rb → eod_stencil.rb}

@@ -3,7 +3,7 @@
 module Cotcube
   module Level
 
-    class Stencil
+    class EOD_Stencil
       attr_accessor :base
       attr_reader   :interval
 
@@ -43,20 +43,17 @@ module Cotcube
         range: nil,                 # used to shrink the stencil size, accepts String or Date
         interval:,
         swap_type:,
-        ranges: nil,                # currently not used, prepared to be used in connection intraday
         contract: nil,
         date: nil,
         debug: false,
         version: nil,               # when referring to a specicic version of the stencil
-        timezone: CHICAGO,
-        stencil: nil,               # instead of loading, use this data
-        #config: init,
-        warnings: true
+        timezone: Cotcube::Helpers::CHICAGO,
+        stencil: nil,               # instead of preparing, use this one if set
+        warnings: true              # be more quiet
       )
         @debug     = debug
-        @interval  = interval
+        @interval  = interval == :continuous ? :daily : interval
         @swap_type = swap_type
-        @swaps     = []
         @contract  = contract
         @warnings = warnings
         step =  case @interval
@@ -81,14 +78,14 @@ module Cotcube
                          swap_type
                        end
           # TODO: Check / warn / raise whether stencil (if provided) is a proper data type
-          raise ArgumentError, "Stencil should be nil or Array" unless [NilClass, Array].include? stencil.class
+          raise ArgumentError, "EOD_Stencil should be nil or Array" unless [NilClass, Array].include? stencil.class
           raise ArgumentError, "Each stencil members should contain at least :datetime and :x" unless stencil.nil? or
             stencil.map{|x| ([:datetime, :x] - x.keys).empty? and [ActiveSupport::TimeWithZone, Day].include?( x[:datetime] ) and x[:x].is_a?(Integer)}.reduce(:&)
 
-          base = stencil || Stencil.provide_raw_stencil(type: stencil_type, interval: :daily, version: version)
+          base = stencil || EOD_Stencil.provide_raw_stencil(type: stencil_type, interval: :daily, version: version)
 
-          # fast forward to prev trading day
-          date = CHICAGO.parse(date) unless [NilClass, Date, ActiveSupport::TimeWithZone].include? date.class
+          # fast rewind to previous trading day
+          date = timezone.parse(date) unless [NilClass, Date, ActiveSupport::TimeWithZone].include? date.class
           @date = date || Date.today
           best_match = base.select{|x| x[:datetime].to_date <= @date}.last[:datetime]
           @date  = best_match
@@ -106,7 +103,7 @@ module Cotcube
       end
 
       def dup
-        Stencil.new(
+        EOD_Stencil.new(
           debug:      @debug,
           interval:   @interval,
           swap_type:  @swap_type,

data/lib/cotcube-level/helpers.rb

@@ -2,99 +2,108 @@
 
 module Cotcube
   module Level
-      def rad2deg(deg)
-        deg * 180 / Math::PI
-      end
-
-      def deg2rad(rad)
-        rad * Math::PI / 180
-      end
 
-      def shear_to_deg(base:, deg:)
-        shear_to_rad(base: base, rad: deg2rad(deg))
-      end
+    # 3 simple, self-explaining helpers
+    def rad2deg(deg); deg * 180 / Math::PI; end
+    def deg2rad(rad); rad * Math::PI / 180; end
+    def shear_to_deg(base:, deg:); shear_to_rad(base: base, rad: deg2rad(deg)); end
 
-      def shear_to_rad(base: , rad:)
-        tan = Math.tan(rad)
-        base.map { |bar|
-          # separating lines for easier debugging
-          bar[:yy] =
-            bar[:y] +
-            (bar[:dx].nil? ? bar[:x] : bar[:dx]) * tan
-          bar
-        }
-      end
+    # the actual shearing takes place here. please not that shifting of :x takes place
+    #     by setting the new :x as :dx. so if :dx is found, it is used, otherwise :x
+    def shear_to_rad(base: , rad:)
+      tan = Math.tan(rad)
+      base.map { |member|
+        # separating lines for easier debugging
+        member[:yy] =
+          member[:y] +
+          (member[:dx].nil? ? member[:x] : member[:dx]) * tan
+        bar
+      }
+    end
 
-      def member_to_human(member,side: ,format:)
-        high = side == :high
-             "#{member[:datetime].strftime("%a, %Y-%m-%d %H:%M")
+    # human readable output
+    # please note the format must be given, that should be taken from :sym
+    def member_to_human(member,side: ,format:)
+      high = side == :upper
+      "#{member[:datetime].strftime("%a, %Y-%m-%d %I:%M%p")
         }  x: #{format '%-4d', member[:x]
         } dx: #{format '%-8.3f', (member[:dx].nil? ? member[:x] : member[:dx].round(3))
             } #{high ? "high" : "low"
            }: #{format format, member[high ? :high : :low]
          } i: #{(format '%4d', member[:i]) unless member[:i].nil?
-            } #{member[:miss].nil? ? '' : "miss: #{member[:miss]}" }"
-      end
+         } d: #{format '%6.2f', member[:dev] unless member[:dev].nil?
+            } #{member[:near].nil? ? '' : "near: #{member[:near]}"
+         }"
+    end
 
-      def puts_swaps(swaps, format: )
-        swaps = [ swaps ] unless swaps.is_a? Array
-        swaps.each do |swap|
-          puts "side: #{swap[:side] }\tlen: #{swap[:length]}  \trating: #{swap[:rating]}".colorize(swap[:color] || :white )
-          puts "diff: #{swap[:ticks]}\tdif: #{swap[:diff].round(7)}\tdepth: #{swap[:depth]}".colorize(swap[:color] || :white )
-          puts "tpi:  #{swap[:tpi]  }\tppi: #{swap[:ppi]}".colorize(swap[:color] || :white )
-          swap[:members].each {|x| puts member_to_human(x, side: swap[:side], format: format) }
-        end
+    # human readable output
+    # list all swaps contained in an array (e.g. result of tritangulate)
+    def puts_swaps(swaps, format: )
+      swaps = [ swaps ] unless swaps.is_a? Array
+      swaps.each do |swap|
+        puts "side: #{swap[:side] }\tlen: #{swap[:length]}  \trating: #{swap[:rating]}".colorize(swap[:color] || :white )
+        puts "diff: #{swap[:ticks]}\tdif: #{swap[:diff].round(7)}\tdepth: #{swap[:depth]}".colorize(swap[:color] || :white )
+        puts "tpi:  #{swap[:tpi]  }\tppi: #{swap[:ppi]}".colorize(swap[:color] || :white )
+        swap[:members].each {|x| puts member_to_human(x, side: swap[:side], format: format) }
       end
+    end
 
-      def get_jsonl_name(interval:, swap_type:, contract:, sym: nil)
-        raise "Interval #{interval } is not supported, please choose from #{INTERVALS}" unless INTERVALS.include? interval
-        raise "Swaptype #{swap_type} is not supported, please choose from #{SWAPTYPES}" unless SWAPTYPES.include? swap_type
-        sym ||= Cotcube::Helpers.get_id_set(contract: contract)
-        root = '/var/cotcube/level'
-        dir     = "#{root}/#{sym[:id]}"
-        symlink = "#{root}/#{sym[:symbol]}"
-        `mkdir -p #{dir}`         unless File.exist?(dir)
-        `ln -s #{dir} #{symlink}` unless File.exist?(symlink)
-        file = "#{dir}/#{contract}_#{interval.to_s}_#{swap_type.to_s}.jsonl"
-        `touch #{file}`
-        file
-      end
+    # create a standardized name for the cache files
+    # and, on-the-fly, create these files plus their directory
+    def get_jsonl_name(interval:, swap_type:, contract:, sym: nil)
+      raise "Interval #{interval } is not supported, please choose from #{INTERVALS}" unless INTERVALS.include? interval
+      raise "Swaptype #{swap_type} is not supported, please choose from #{SWAPTYPES}" unless SWAPTYPES.include? swap_type
+      sym ||= Cotcube::Helpers.get_id_set(contract: contract)
+      root = '/var/cotcube/level'
+      dir     = "#{root}/#{sym[:id]}"
+      symlink = "#{root}/#{sym[:symbol]}"
+      `mkdir -p #{dir}`         unless File.exist?(dir)
+      `ln -s #{dir} #{symlink}` unless File.exist?(symlink)
+      file = "#{dir}/#{contract}_#{interval.to_s}_#{swap_type.to_s}.jsonl"
+      `touch #{file}`
+      file
+    end
 
-      def save_swaps(swaps, interval:, swap_type:, contract:, sym: nil)
-        file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
-        swaps.each do |swap|
-          swap_json = swap.to_json
-          digest = Digest::SHA256.hexdigest swap_json
-          res = `cat #{file} | grep #{digest}`.strip
-          unless res.empty?
-            puts "Cannot save swap, it is already in #{file}:"
-            p swap
-          else
-            swap[:digest] = digest
-            File.open(file, 'a+'){|f| f.write(swap.to_json + "\n") }
-          end
+    # the name says it all.
+    # just note the addition of a digest, that serves to check whether same swap has been yet saved
+    # to the cache
+    def save_swaps(swaps, interval:, swap_type:, contract:, sym: nil)
+      file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
+      swaps.each do |swap|
+        swap_json = swap.to_json
+        digest = Digest::SHA256.hexdigest swap_json
+        res = `cat #{file} | grep #{digest}`.strip
+        unless res.empty?
+          puts "Cannot save swap, it is already in #{file}:"
+          p swap
+        else
+          swap[:digest] = digest
+          File.open(file, 'a+'){|f| f.write(swap.to_json + "\n") }
         end
       end
+    end
 
-      def load_swaps(interval:, swap_type:, contract:, sym: nil)
-        file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
-        jsonl = File.read(file)
-        jsonl.
-          each_line.
-          map do |x|
-          JSON.parse(x).
-            deep_transform_keys(&:to_sym).
-            tap do |sw|
-            sw[:datetime] = DateTime.parse(sw[:datetime]) rescue nil
-            sw[:side]     = sw[:side].to_sym
-            unless sw[:empty]
-              sw[:color]    = sw[:color].to_sym
-              sw[:members].map{|mem| mem[:datetime] = DateTime.parse(mem[:datetime]) }
-            end
+    # loading of swaps is also straight forward
+    # it takes few more efforts to normalize the values to their expected format
+    def load_swaps(interval:, swap_type:, contract:, sym: nil)
+      file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
+      jsonl = File.read(file)
+      jsonl.
+        each_line.
+        map do |x|
+        JSON.parse(x).
+          deep_transform_keys(&:to_sym).
+          tap do |sw|
+          sw[:datetime] = DateTime.parse(sw[:datetime]) rescue nil
+          sw[:side]     = sw[:side].to_sym
+          unless sw[:empty]
+            sw[:color]    = sw[:color].to_sym
+            sw[:members].map{|mem| mem[:datetime] = DateTime.parse(mem[:datetime]) }
           end
         end
       end
-  end
+    end
 
+  end
 end