unageanu-jiji 0.1.0

data/lib/jiji/configuration.rb

@@ -0,0 +1,80 @@
+
+require 'jiji/util/fix_yaml_bug'
+require 'jiji/util/file_lock'
+
+module JIJI
+
+  #
+  #==設定値
+  #
+  class Configuration
+
+    #コンストラクタ
+    #configuration_file:: 設定ファイルのパス
+    def initialize( configuration_file=nil )
+      if configuration_file && File.exist?( configuration_file )
+        FileLock.new( configuration_file ).readlock {|f|
+          tmp = YAML.load f
+          @conf = key_to_sym( tmp )
+        }
+      else
+        @conf = {}
+      end
+    end
+
+    #値を取得する。
+    #names:: 値を示すパス 例) [:foo, :var]
+    #default:: 値が存在しない場合の初期値
+    #return:: 値
+    def get( names, default )
+      v = names.inject(@conf) {|conf,i|
+        if conf.kind_of?(Hash)
+          conf[i]
+        else
+          break default
+        end
+      }
+      v == nil ? default : v
+    end
+
+    #値を設定する。
+    #※設定した値は元のファイルには反映されない。プログラムを終了すると失われる。
+    #names:: 値を示すパス 例) [:foo, :var]
+    #value:: 値
+    def set( names, value=nil)
+      key = names.pop
+      names.inject(@conf) {|conf, i|
+        if conf[i].kind_of?(Hash)
+          conf[i]
+        elsif conf[i] == nil
+          conf[i] = {}
+        else
+          raise "illegal key."
+        end
+      }[key] = value
+    end
+
+    #値が存在するか評価する。
+    #names:: 値を示すパス 例) [:foo, :var]
+    #return:: 値があればtrue
+    def key?( names )
+      v = names.inject(@conf) {|conf,i|
+        if conf.kind_of?(Hash)
+          conf[i]
+        else
+          break nil
+        end
+      }
+      v != nil
+    end
+
+    private
+    def key_to_sym( map )
+      map.inject({}) {|r,e|
+         v = e[1].kind_of?(Hash) ? key_to_sym( e[1] ) : e[1]
+         r.store(e[0].to_sym, v)
+         r
+      }
+    end
+  end
+end

data/lib/jiji/dao/rate_dao.rb

@@ -0,0 +1,149 @@
+
+require 'thread'
+require 'jiji/util/csv_append_support'
+require 'jiji/util/util'
+require 'jiji/models'
+require 'jiji/dao/timed_data_dao'
+
+module JIJI
+  module Dao
+
+    # レートDAO
+    class RateDao
+
+      def initialize( data_dir, scales=[] )
+        @data_dir = data_dir
+        @scales = scales
+        @daos = {}
+        @mutex = Mutex.new
+      end
+
+      # 所定の期間のレートデータを得る。
+      def each( scale=:raw, pair=:USDJPY, start_date=nil, end_date=nil )
+        dao( pair ).each_data( scale, start_date, end_date ) {|row,time|
+           yield row
+        }
+      end
+
+      # 所定の期間のすべての通貨ペアのレートデータを得る。
+      def each_all_pair_rates( scale=:raw, start_date=nil, end_date=nil, &block )
+        pairs = list_pairs
+        its  = nil
+        begin
+          its = pairs.map {|p|
+            dao(p).each_data( scale,start_date,end_date )
+          }
+          _each_all_pair_rates( pairs, its, &block )
+        ensure
+          its.each {|i| i.close } if its
+        end
+      end
+
+      # 次のレートを追加する。
+      def next_rates( rates )
+        rates.each_pair {|pair,v|
+          dao(pair) << v
+        }
+      end
+
+      # ペアに対応するdaoを取得する
+      def dao(pair)
+        @mutex.synchronize {
+          return @daos[pair] if @daos.key? pair
+
+          dir = "#{@data_dir}/#{pair.to_s}"
+          FileUtils.mkdir_p dir unless File.exists? dir
+
+          aggregators = @scales.map {|s| RatesAggregator.new(s) }
+          aggregators << RawRatesAggregator.new
+
+          @daos[pair] = TimedDataDao.new( dir, aggregators )
+          @daos[pair]
+        }
+      end
+
+      def list_pairs
+        list = []
+        Dir.glob( "#{@data_dir}/*" ) {|d|
+         next unless File.directory? d
+         next unless d =~ /\/([A-Z]+)$/
+         list << $1
+        }
+        list
+      end
+
+    private
+      def _each_all_pair_rates( pairs, its )
+        buff = PairBuffer.new
+        exist_next = true
+        while( exist_next )
+          exist_next = false
+          its.each_index {|index|
+            it = its[index]
+            if ( it.next? )
+              # 末尾のデータはDAOで使うための日時指定で不要なので取り除く
+              item = it.next
+              item.pop
+              buff.add( pairs[index],  item )
+              exist_next = true
+            else
+              exist_next = exist_next || false
+            end
+          }
+          yield buff.next if buff.next?
+        end
+        yield buff.next while buff.next?
+      end
+
+
+      class RatesAggregator < JIJI::Dao::AbstractAggregator
+        def initialize( scale )
+          super
+        end
+        def aggregate( timed_data )
+          unless @rate
+            @rate = PeriodicallyRate.new
+            @rate.start_time = timed_data.time
+          end
+          @rate << timed_data
+        end
+        def aggregated
+          @rate.end_time = @end
+          vs = @rate
+          @rate = PeriodicallyRate.new
+          @rate.start_time = @end
+          return vs
+        end
+      end
+
+      class RawRatesAggregator < JIJI::Dao::Aggregator
+        def initialize
+          super( "raw" )
+        end
+        def next( timed_data )
+          yield timed_data
+        end
+      end
+
+      class PairBuffer
+        def initialize
+          @buff = {}
+        end
+        def add( pair, data )
+          time = data.last.to_i
+          @buff[time] = {} unless @buff[time]
+          @buff[time][pair.to_sym] = data
+        end
+        def next?
+          @buff.length > 0
+        end
+        def next
+          keys = @buff.keys.sort!
+          @buff.delete keys[0]
+        end
+      end
+
+    end
+  end
+
+end

data/lib/jiji/dao/timed_data_dao.rb

@@ -0,0 +1,334 @@
+require 'jiji/error'
+require 'date'
+require 'jiji/util/csv_append_support'
+require 'jiji/util/file_lock'
+require 'jiji/util/iterator'
+
+module JIJI
+  module Dao
+
+    # 時間を持つデータ
+    module TimedData
+      def values
+        []
+      end
+      attr :time, true
+    end
+
+    BasicTimedData = Struct.new( :values, :time )
+
+    # 時間を持つデータをCSVで記録するためのDao
+    # 　データの記録、
+    # 　一定期間のデータの集約結果の記録、
+    # 　一定期間のデータの読み込み、
+    # をサポート。
+    #
+    class TimedDataDao
+
+      DATE_FORMAT = "%Y-%m-%d"
+      MONTHLY_DATE_FORMAT = "%Y-%m"
+
+      def initialize( root_dir, aggregator=[] )
+        @root_dir = root_dir
+        @aggregator = aggregator
+      end
+
+      # 指定期間のデータを読み込む
+      def each_data( scale=:raw, start_time=nil, end_time=nil, &block )
+        sd = start_time || first_day( scale )
+        ed = end_time || last_day( scale )
+
+        it = ( !sd || !ed ) \
+          ? EmptyIterator.new \
+          : TimedDataIterator.new( scale, sd, ed, self )
+        if block_given?
+          it.each {|row|
+            time = row.pop.to_i
+            block.call( row, time )
+          }
+        else
+          return it
+        end
+      end
+
+      # データを強制的に書き込む
+      # バックテストで取引が完了し場合に使用し、結果を表性的に書き出す。
+      def flush( time )
+        @aggregator.each {|ag|
+          ag_dir = ag_dir(ag)
+          ag.flush( time ) {|data|
+            out( ag, ag_dir, data )
+          }
+        }
+      end
+
+      # データを追加する
+      def <<(timed_data)
+        @aggregator.each {|ag|
+          ag_dir = ag_dir(ag)
+          ag.next( timed_data ) {|data|
+            out( ag, ag_dir, data )
+          }
+        }
+      end
+
+      # 利用可能なデータ一覧を得る
+      def list_data_files( scale, pattern="*" )
+        Dir.glob( "#{@root_dir}/#{scale.to_s}/#{pattern}.csv" ).map{|d| File.basename(d) }.sort!
+      end
+      # 利用可能な最後のデータ
+      def last_day( scale )
+        l = list_data_files( scale )
+        return nil if l.empty?
+        if TimedDataDao.dairy?(scale)
+          to_time( l.last[0..-5], true ) + 24*60*60
+        else
+          to_time( l.last[0..-5], false ) + 24*60*60*31
+        end
+      end
+      # 利用可能な最初のデータ
+      def first_day( scale )
+        l = list_data_files( scale )
+        l.empty? ? nil : to_time( l.first[0..-5], TimedDataDao.dairy?(scale) )
+      end
+      # 利用可能な最後のデータ
+      def last_time( scale )
+        l = list_data_files( scale )
+        return nil if l.empty?
+        date = nil
+        it = each_file_data( "#{@root_dir}/#{scale}/#{l.last}" )
+        it.each { |row|
+          date = row.last
+        }
+        date.to_i
+      end
+      # 利用可能な最初のデータ
+      def first_time( scale )
+        l = list_data_files( scale )
+        return nil if l.empty?
+        date = nil
+        it = each_file_data( "#{@root_dir}/#{scale}/#{l.first}" )
+        it.each { |row|
+          date = row.last
+          break
+        }
+        date.to_i
+      end
+      # 文字列を時刻に変換する
+      def to_time( str, dairy=true )
+        d = DateTime.strptime(str, dairy ? DATE_FORMAT : MONTHLY_DATE_FORMAT)
+        Time.local( d.year, d.month, d.day )
+      end
+      # 時刻を日を示す文字列に変換する
+      def to_date_str( time, dairy=true )
+        time.strftime( dairy ? DATE_FORMAT : MONTHLY_DATE_FORMAT)
+      end
+      def self.dairy?(scale)
+        scale.to_s =~ /^(raw|\d+[smh])$/
+      end
+
+      # 特定の日のデータを列挙する
+      def each_dairy_data( scale, date, start_date=nil, end_date=nil)
+        file = "#{@root_dir}/#{scale}/#{to_date_str(date, TimedDataDao.dairy?(scale))}.csv"
+        each_file_data( file, start_date, end_date )
+      end
+
+      attr_reader :aggregator
+
+    private
+
+      # データを保存する
+      def out( ag, ag_dir, data )
+        date = to_date_str( data.time, TimedDataDao.dairy?(ag.scale) )
+        file = "#{ag_dir}/#{date}.csv"
+        CSV.open( file, 'a' ) {|w|
+          w << ( data.values.map{|i|i.to_s} << data.time.to_i )
+        }
+      end
+
+      # アグリゲーターが使用するデータ保存先ディレクトリを作成する。
+      def ag_dir( ag )
+        dir = "#{@root_dir}/#{ag.scale}"
+        FileUtils.mkdir_p dir unless File.exist? dir
+        return dir
+      end
+
+      # ファイルのデータを列挙する
+      def each_file_data( file, start_date=nil, end_date=nil)
+        return EmptyIterator.new  unless File.exist? file
+        it =  CSVIterator.new( CSV.open( file, 'r' ) )
+        return Filter.new( it ) {|row|
+          time = row.last.to_i
+          if start_date && time < start_date.to_i
+            :next
+          elsif end_date && time > end_date.to_i
+            :break
+          else
+            :true
+          end
+        }
+      end
+    end
+
+    # CSVReaderをIteratorにする。
+    class CSVIterator < Iterator
+      def initialize( reader )
+        super()
+        @reader = reader
+        @item = @reader.shift
+      end
+      def next?
+        !@item.empty?
+      end
+      def next
+        begin
+          @item
+        ensure
+          @item = @reader.shift
+        end
+      end
+      def close
+        @reader.close
+      end
+    end
+
+    # 複数のCSVファイルのデータを順番に読み込む。
+    class TimedDataIterator < Iterator
+      def initialize( scale, start_time, end_time, dao )
+        super()
+        @dao = dao
+        @start_time = start_time
+        @end_time = end_time
+        @scale = scale
+        @current = start_time
+        @current_date = Date.new( @current.year, @current.mon, \
+          TimedDataDao.dairy?(@scale)  ? @current.day : 1 )
+        next_iterator
+      end
+      def next?
+        @it && @it.next?
+      end
+      def next
+        begin
+          @it.next
+        ensure
+          next_iterator unless @it.next?
+        end
+      end
+      def close
+        @it.close if @it
+      end
+      def next_iterator
+        @it.close if @it
+        @it = nil
+        while ( @current.to_f <= @end_time.to_f )
+          begin
+            it = @dao.each_dairy_data( @scale, @current, @start_time, @end_time)
+            if it != nil && it.next?
+              @it = it
+              return
+            else
+              it.close
+            end
+          ensure
+            @current_date = TimedDataDao.dairy?(@scale) ? @current_date+1 : @current_date >> 1
+            @current = Time.local(@current_date.year, @current_date.mon, @current_date.day)
+          end
+        end
+      end
+    end
+
+    # 一定期間のデータを集約するクラス
+    class Aggregator
+      def initialize( scale )
+        @scale = scale
+      end
+      # データを受け取り、集約したデータがある場合、それを引数としてブロックを実行する。
+      def next( timed_data )
+      end
+      # 集約したデータがある場合、それを引数としてブロックを実行する。
+      def flush( time )
+      end
+      attr_reader :scale
+    end
+
+    # 集約を行なわないAggregator
+    class RawAggregator < Aggregator
+      def initialize
+        super("raw")
+      end
+      def next( timed_data )
+        yield timed_data
+      end
+    end
+
+    # 一定期間のデータを集約するクラス
+    class AbstractAggregator < Aggregator
+      def initialize( scale )
+        super
+        @period = JIJI::Util.parse_scale(scale)
+        @next = nil
+      end
+      # データを受け取り、集約したデータがある場合、それを引数としてブロックを実行する。
+      def next( timed_data )
+        now = timed_data.time
+        unless @next
+          @next = Time.at(((now.to_i / @period)+1) * @period )
+          @start = Time.at(@next.to_i-@period)
+        end
+        aggregate( timed_data )
+        if now >= @next
+          @end = @next
+          yield aggregated
+          @start = @next
+          @end = nil
+          @next += @period while @next <= now
+        end
+      end
+      def flush( time )
+        @end = time
+        yield aggregated
+        @start = @next
+        @end = nil
+        @next += @period while @next <= time
+      end
+      def aggregate( timed_data )
+      end
+      def aggregated
+      end
+      def next_date
+        @next
+      end
+      attr_reader :start
+    end
+
+    # 平均を取るAggregator
+    class AvgAggregator < AbstractAggregator
+      def aggregate( timed_data )
+        @values = [] unless @values
+        timed_data.values.each_index {|i|
+          @values[i] = [] unless @values[i]
+          @values[i] << timed_data.values[i]
+        }
+      end
+      def aggregated
+        avgs = @values.map{|vs|
+          vs.inject(0){|t,v| t+=v }/vs.length
+        }
+        @values = []
+        BasicTimedData.new(avgs + [@start.to_i, @end.to_i], @end)
+      end
+    end
+
+    # 最後の値を返すAggregator
+    class LastAggregator < AbstractAggregator
+      def aggregate( timed_data )
+        @values = timed_data.values
+      end
+      def aggregated
+        BasicTimedData.new( @values + [@start.to_i, @end.to_i], @end)
+      end
+    end
+
+  end
+end