time_series 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis_timeseries.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 panos
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# TimeSeries
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'time_series'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install time_series
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+`reset`
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib/time_series'
+  t.test_files = FileList['spec/*spec.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/key.rb

@@ -0,0 +1,205 @@
+# coding: utf-8
+
+require 'bundler/setup'
+require 'redis'
+require 'hiredis'
+require 'date'
+#require 'json'
+require 'awesome_print'
+
+class Time
+#  def self.from_key key
+#    key.gsub!(/^[^:]*:[^:]*:[^:]*:/, '')
+#    Time.strptime(key, "%Y:%m:%d:%H:%M:%S") # TODO works only with second-resolution
+#  end
+
+  def human
+    a = (Time.now-self).to_i
+    case a
+      when 0 then 'just now'
+      when 1 then 'a second ago'
+      when 2..59 then a.to_s+' seconds ago' 
+      when 60..119 then 'a minute ago' #120 = 2 minutes
+      when 120..3540 then (a/60).to_i.to_s+' minutes ago'
+      when 3541..7100 then 'an hour ago' # 3600 = 1 hour
+      when 7101..82800 then ((a+99)/3600).to_i.to_s+' hours ago' 
+      when 82801..172000 then 'a day ago' # 86400 = 1 day
+      when 172001..518400 then ((a+800)/(60*60*24)).to_i.to_s+' days ago'
+      when 518400..1036800 then 'a week ago'
+      else ((a+180000)/(60*60*24*7)).to_i.to_s+' weeks ago'
+    end
+  end
+end
+
+class String
+  
+  def redis
+    @redis = $redis ||= Redis.new(:path => "/tmp/redis.sock",:driver => :hiredis)
+    return @redis
+  end
+  
+  def prefix
+    matchdata = /(^[^:]+:[^:]+:[^:]+:)/.match(self)
+    return matchdata[1] unless matchdata.nil?
+  end
+  
+  def exists?
+    redis.exists self
+  end
+  
+  #deprecated
+  def parent_key
+    parent
+  end
+    
+  def parent
+    self.gsub(/:[^:]*$/, '')
+  end
+
+  def has_persistant_children?
+    not persistant_children.empty?
+  end
+
+  def has_children?
+    has_persistant_children?
+  end
+  
+  #deprecated  
+  def has_parent?
+    parent.exists?
+  end
+
+  def volatile?
+    redis.ttl(self) >= 0  
+  end
+  
+    def persistant?
+    redis.ttl(self)==-1 and exists?  
+  end
+  
+  def ttl
+    redis.ttl self  
+  end 
+
+  #deprecated
+  def has_persistant_parent?
+    redis.ttl(parent_key) < 0 and parent.exists?
+  end
+
+  #deprecated  
+  def has_volatile_parent?
+    redis.ttl(parent_key) >= 0
+  end
+  
+  def children
+    redis.keys(self+":*")
+  end
+
+  def persistant_children
+    keys = redis.keys(self+":*")
+    keys.delete_if{|k| k.volatile?}
+    return keys
+  end  
+  
+  def siblings_keys
+    redis.keys(self.gsub(/:[^:]*$/, ':*'))
+  end
+  
+
+  def unionize_persistant_children
+    children = persistant_children
+    redis.zunionstore self, children
+    
+    if recent?
+      redis.expire self, 60
+    else
+      redis.expire self, 600      
+    end
+    
+  end
+  
+  def resolution
+    case self.count(':')
+      when 8 then :second
+      when 7 then :minute
+      when 6 then :hour
+      when 5 then :day
+      when 4 then :month
+      when 3 then :year
+    end   
+  end
+  
+  def year?;   resolution == :year end
+  def month?;  resolution == :month end
+  def day?;    resolution == :day end
+  def hour?;   resolution == :hour end
+  def minute?; resolution == :minute end
+  def second?; resolution == :second end
+              
+  def year;   /[^:]+:[^:]+:[^:]+:([^:]+)/.match(self)[1].to_i end
+  def month;  /[^:]+:[^:]+:[^:]+:[^:]+:([^:]+)/.match(self)[1].to_i end
+  def day;    /[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:([^:]+)/.match(self)[1].to_i end
+  def hour;   /[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:([^:]+)/.match(self)[1].to_i end    
+  def minute; /[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:([^:]+)/.match(self)[1].to_i end    
+  def second; /[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:([^:]+)/.match(self)[1].to_i end
+  
+  def time
+    key = self.gsub(/^[^:]*:[^:]*:[^:]*:/, '') #remove prefix
+    case resolution
+      when :year   then return DateTime.new(year).to_time
+      when :month  then return DateTime.new(year, month).to_time
+      when :day    then return DateTime.new(year, month, day).to_time
+      when :hour   then return DateTime.new(year, month, day, hour, 0,      0,      '+3').to_time
+      when :minute then return DateTime.new(year, month, day, hour, minute, 0,      '+3').to_time
+      when :second then return DateTime.new(year, month, day, hour, minute, second, '+3').to_time
+    end  
+  end
+  
+  def recent?
+    case resolution
+      when :year   then year == Time.now.year
+      when :month  then year == Time.now.year
+      when :day    then year == Time.now.year and month == Time.now.month
+      when :hour   then year == Time.now.year and month == Time.now.month and day == Time.now.day
+      when :minute then year == Time.now.year and month == Time.now.month and day == Time.now.day and hour == Time.now.hour
+      when :second then year == Time.now.year and month == Time.now.month and day == Time.now.day and hour == Time.now.hour and minute == Time.now.min
+    end  
+  end
+ 
+  def get_array
+    redis.zrevrange self, 0, -1, :with_scores => true
+  end
+
+  def array_to_hash array
+    hash = Hash.new
+    array.each{|a| hash[a[0]] = a[1].to_f }
+    return hash
+  end
+    
+  def get
+    if exists?
+      ;
+    elsif has_children?
+      unionize_persistant_children
+    else
+      if not year?
+        parent.get
+        # http://rubydoc.info/github/redis/redis-rb/Redis:zunionstore
+        p = parent #TODO Test the case when the immediate parent has no persistant children so weights has infinite values
+        while !p.has_children?
+          p = p.parent
+        end
+        weights = [ 1.0 / p.persistant_children.size ]      
+        redis.zunionstore self, [parent], :weights => weights
+        if recent?
+          redis.expire self, 60
+        else
+          redis.expire self, 600      
+        end
+      else
+        return {}
+      end
+    end
+    array_to_hash get_array
+  end
+end

data/lib/redis_connection.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+require 'bundler/setup'
+require 'redis'
+require 'hiredis'
+
+
+# Initialize a connection to Redis.
+# Currently the path to redis socket is hardcoded (/tmp/redis.sock),
+# as well as the driver (:hiredis).
+# global variable $redis gets set.
+# 
+# 
+class RedisConnection
+  attr_reader :redis
+  def initialize *args
+    #@key= key
+    $redis ||= Redis.new(:path => "/tmp/redis.sock",:driver => :hiredis)
+    @redis = $redis
+    #puts green "Connected to Redis"
+  end # end initialize
+end

data/lib/time_series.rb

@@ -0,0 +1,383 @@
+# coding: utf-8
+require 'bundler/setup'
+
+require 'active_support/core_ext/numeric/time.rb'
+
+#require 'active_support/core_ext/time/calculations.rb'
+require_relative "version"
+require_relative 'redis_connection'
+require_relative 'key'
+
+##
+# TimeSeries Class
+#
+class TimeSeries < RedisConnection
+  attr_reader :name, :duration, :resolution
+  
+##
+# Create Timeseries.
+#
+# @param [String] name The timeseries name.
+# @param [Hash] options The options hash.
+# @option options [String] :resolution The time resolution: :year, :month, :day, :hour, :minute, :second
+# @option options [Integer] :duration Duration is under development. It will allow for example 10, 20 or 30 seconds keys. Now only keys with :minute resolution are available.
+  def initialize name, options={}
+    super # initialize RedisConnection
+    
+    @name = name
+    @prefix="#{$app_prefix}:ts:#{@name}:"
+    
+    # parse the resolution option
+    if options.has_key? :resolution
+      @resolution = options[:resolution]
+      resolutions = [:year, :month, :day, :hour, :minute, :second]
+      #if the resolution option is invalid raise an exception
+      unless resolutions.include?(@resolution) #or @resolution.is_a?(Integer)
+        raise ArgumentError.new("resolution can be either :year or :month or :day or :hour or :minute or :second")
+      end  
+    elsif keys.empty? # default resolution is :second
+          @resolution = :second
+    else # try to guess resolution from existing keys
+      max_res = 0
+      keys.each do |k|
+        res = k.count(':')
+        max_res = res if res > max_res
+      end
+      
+      case max_res
+        when 8 then @resolution = :second
+        when 7 then @resolution = :minute
+        when 6 then @resolution = :hour
+        when 5 then @resolution = :day
+        when 4 then @resolution = :month
+        when 3 then @resolution = :year
+        else raise ArgumentError.new("Cannot guess resolution from existing keys")
+      end #case
+    end # if
+    
+    # define the @duration based on @resolution
+    case @resolution
+      when :year   then @duration = 12*30*24*3600
+      when :month  then @duration = 30*24*3600
+      when :day    then @duration = 24*3600
+      when :hour   then @duration = 3600
+      when :minute then @duration = 60
+      when :second then @duration = options[:duration] ||= 20
+    end
+  end
+
+  # Returns the current time.
+  #
+  # @return [Time] the current time
+  def current_time
+    time=Time.at(Time.now.to_i) # this way nsec and usec is 0
+    if @resolution == :second
+      sec = time.strftime("%S").to_i % @duration
+      time = time - sec
+    end  
+    return time
+  end
+
+  # Returns the time of the last key.
+  # 
+  # @return [Time] the last key's  time
+  def last_time
+    current_time - @duration
+  end
+
+  # Returns the time of the previous key.
+  #
+  # @return [Time] the previous key's  time  
+  def previous_time
+    current_time - 2 * @duration
+  end
+
+  # Returns the current key
+  #
+  # @return [String] current key    
+  def current_key
+    time_to_key current_time, @resolution
+  end
+
+  # Returns the last key
+  #
+  # @return [String] last key    
+  def last_key
+    time_to_key last_time, @resolution
+  end
+
+  # Returns the previous key
+  #
+  # @return [String] previous key 
+  def previous_key
+   time_to_key previous_time, @resolution
+  end
+
+  # Returns all the keys
+  #
+  # @return [Array] all the keys in a String Array
+  def keys
+    return @redis.keys"#{$app_prefix}:ts:#{@name}:*"
+  end
+
+  # Deletes all the keys
+  #
+  # @return Number of keys deleted
+  def clear
+    i = 0
+    keys.each{|k| @redis.del k; i+=1}
+    return i 
+  end
+
+  # Returns the contents of all the keys
+  # TODO Considering to remove this method
+  #
+  # @return [Hash] contents of all the keys
+  def all
+    all = Hash.new
+    keys.each{ |k| all[k.gsub(/#{@prefix}/,'')]=k.get}
+    return all
+  end
+
+  # Returns the contents of the last key
+  #
+  # @return [Hash] contents of the last key
+  def last
+    last_key.get
+  end  
+
+  # Returns the contents of the previous key
+  #
+  # @return [Hash] contents of the previous key
+  def previous
+    previous_key.get
+  end
+
+  # Push a new Term into the Timeseries
+  def push term
+    @redis.zincrby current_key, 1, term
+  end     
+
+  # Convert a Time object to the respective Key
+  # TODO Refactoring
+  #
+  # @param [Time] time The Time 
+  # @option [String] resolution The time resolution: :year, :month, :day, :hour, :minute, :second
+  # @return [String] The Key
+  def time_to_key time, *resolution
+    if resolution.empty?
+      return time.strftime("#{@prefix}%Y:%m:%d:%H:%M:%S")
+    else
+      resolution = resolution.first
+      case resolution
+        when :year   then return time.strftime("#{@prefix}%Y")
+        when :month  then return time.strftime("#{@prefix}%Y:%m")
+        when :day    then return time.strftime("#{@prefix}%Y:%m:%d")
+        when :hour   then return time.strftime("#{@prefix}%Y:%m:%d:%H")
+        when :minute then return time.strftime("#{@prefix}%Y:%m:%d:%H:%M")
+        when :second then return time.strftime("#{@prefix}%Y:%m:%d:%H:%M:%S")
+        else puts red "wrong resolution in time_to_key"
+      end
+    end
+  end
+
+  # Removes recent keys from a key array
+  #
+  # @param [Array] array Array of Keys 
+  # @param [Integer] Number of seconds that a key is considered recent
+  # @return [Array] The new array
+  def array_older_than array, time
+    array.keep_if { |k| k.time <= Time.now - time }
+  end
+
+  # Keys with second resolution
+  #
+  # @param [Array] time
+  # @return [Array] Array with the keys
+  def seconds *time
+    array = keys.keep_if { |k| k.second? and k.persistant?}
+    if time.empty?
+      return array
+    else
+      time = time.first
+      return array_older_than array, time
+    end
+  end
+
+  # Keys with minute resolution
+  #
+  # @param [Array] time
+  # @return [Array] Array with the keys  
+  def minutes *time
+    array = keys.keep_if { |k| k.minute? and k.persistant?}
+    if time.empty?
+      return array
+    else
+      time = time.first
+      return array_older_than array, time
+    end    
+  end
+
+  # Keys with hour resolution
+  #
+  # @param [Array] time
+  # @return [Array] Array with the keys  
+  def hours *time
+    array = keys.keep_if { |k| k.hour? and k.persistant?}
+    if time.empty?
+      return array
+    else
+      time = time.first
+      return array_older_than array, time
+    end    
+  end
+
+  # Keys with day resolution
+  #
+  # @param [Array] time
+  # @return [Array] Array with the keys  
+  def days *time
+    array = keys.keep_if { |k| k.day? and k.persistant?}
+    if time.empty?
+      return array
+    else
+      time = time.first
+      return array_older_than array, time
+    end    
+  end
+
+  # Keys with month resolution
+  #
+  # @param [Array] time
+  # @return [Array] Array with the keys  
+  def months *time
+    array = keys.keep_if { |k| k.month? and k.persistant?}  
+    if time.empty?
+      return array
+    else
+      time = time.first
+      return array_older_than array, time
+    end  
+
+  end
+
+  # Keys with year resolution
+  #
+  # @param [Array] time
+  # @return [Array] Array with the keys  
+  def years *time
+    array = keys.keep_if { |k| k.year? and k.persistant?}  
+    if time.empty?
+      return array
+    else
+      time = time.first
+      return array_older_than array, time
+    end  
+
+  end
+
+  # Compress keys
+  # Key compression merges the given keys of the same resolution to keys
+  # of greater resolution. For example seconds are merged into minutes and
+  # days are merged into months.
+  # The values of the keys are merged too.
+  # After the merge the keys are deleted.
+  #
+  # @param [Array] keys to be compressed
+  # @return [Integer] Number of keys compressed
+  def compress keys
+    parents = []
+    keys.each do |key|
+      unless key.recent? or key.year?
+        parent = key.parent
+        parents << parent unless parents.include? parent
+      end
+    end
+    
+    i = 0
+    parents.each do |parent|
+      unless parent.recent?
+        children = parent.persistant_children
+        @redis.zunionstore parent, children
+        children.each{|k| @redis.del k; i+=1}
+      end
+    end
+    return i 
+  end         
+
+  # Remove terms with low scores
+  #
+  # @param [Array] keys that will be examined
+  # @return [Array] Number of keys the operation took place, it doesn't mean that something changed
+  def remove_by_score keys, *population
+    if population.empty?
+      population = 1
+    else
+      population = population.first
+    end
+    i = 0    
+    keys.each {|k| @redis.zremrangebyscore(k, '-inf', population); i+=1} # TODO What zremrangebyscore returns?
+    return i     
+  end
+
+  #def term_weights terms, factor
+  #  terms.each do |term, value|
+  #    terms[term]=value*factor
+  #  end
+  #  return terms
+  #end
+  
+  def year time;   time_to_key(time, :year).get end 
+  def month time;  time_to_key(time, :month).get end 
+  def day time;    time_to_key(time, :day).get end 
+  def hour time;   time_to_key(time, :hour).get end 
+  def minute time; time_to_key(time, :minute).get end 
+  def second time; time_to_key(time, :second).get end 
+ 
+end
+
+
+  
+__END__
+=begin     
+  def get_by_time time
+    key = time_to_key time
+    if key.exists?
+      return get(key) 
+    elsif false
+      return nil
+    end
+    #array_to_hash @redis.zrange key, 0, -1, :with_scores => true 
+  end
+  
+
+  def get_by_resolution time, resolution
+    key = time_to_key time, resolution
+    if key.exists?
+      ;
+    elsif key.has_children?
+      key.unionize_persistant_children     
+    else
+      return get_parent time, resolution
+      # fix data
+      # add ttl
+    end
+    
+    return get(key) 
+  end
+
+  def get_parent time, resolution
+    case resolution
+      when :month  then get_year time
+      when :day    then get_month time
+      when :hour   then get_day time
+      when :minute then get_hour time
+      when :second then get_minute time
+      else get_year time
+    end        
+  end
+    
+  
+=end 
+
+