flukso4r 0.3.6 → 0.3.7

data/Rakefile

@@ -17,9 +17,10 @@ begin
     gem.files = FileList["[A-Z]*", "{lib,etc,test}/**/*"]
      
     #gem.add_dependency('oauth', '~> 0.3.6')
-    gem.add_dependency('httparty', '~> 0.4.3')
-    gem.add_dependency('sqlite3-ruby', '~> 1.2.5')
-    #gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_dependency('httparty')
+    gem.add_dependency('crack')
+    gem.add_dependency('sqlite3-ruby')
+    gem.add_development_dependency("shoulda")
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -27,28 +28,29 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
+#require 'rake/testtask'
+#Rake::TestTask.new(:test) do |test|
+#  test.libs << 'lib' << 'test'
+#  test.pattern = 'test/**/test_*.rb'
+#  test.verbose = true
+#end
+#
+#begin
+#  require 'rcov/rcovtask'
+#  Rcov::RcovTask.new do |test|
+#    test.libs << 'test'
+#    test.pattern = 'test/**/test_*.rb'
+#    test.verbose = true
+#  end
+#rescue LoadError
+#  task :rcov do
+#    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+#  end
+#end
+#
+#task :test => :check_dependencies
 
-task :test => :check_dependencies
-task :default => :test
+task :default => :check_dependencies
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.3.7

data/etc/flukso4rrc

@@ -2,5 +2,5 @@ DB_FILE:  "/tmp/demo_database.sqlite3"
 DB_TABLE_NAME: "UTCReadings"
 ACCESS_TOKEN: "3f..."
 SENSOR_ID: "0e...."
-BASE_URL: "https://api.flukso.net/sensor"
+BASE_URL: "https://api.mysmartgrid.de:8443/sensor"
 

data/lib/flukso.rb

@@ -23,8 +23,9 @@
 require 'forwardable'
 require 'rubygems'
  
-gem 'httparty', '~> 0.4.3'
+gem 'httparty'
 require 'httparty'
+require 'crack'
  
 module Flukso
   class FluksoError < StandardError
@@ -56,3 +57,5 @@ require File.join(directory, 'flukso', 'request')
 require File.join(directory, 'flukso', 'api')
 require File.join(directory, 'flukso', 'database')
 require File.join(directory, 'flukso', 'export')
+require File.join(directory, 'flukso', 'R')
+require File.join(directory, 'flukso', 'plots')

data/lib/flukso/R.rb

@@ -0,0 +1,93 @@
+# This file is part of Flukso4R
+# (c) 2010 Mathias Dalheimer, md@gonium.net
+#
+# Flukso4R is free software; you can 
+# redistribute it and/or modify it under the terms of the GNU General Public 
+# License as published by the Free Software Foundation; either version 2 of 
+# the License, or any later version.
+#
+# CGWG is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with CGWG; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "tempfile"
+directory = File.expand_path(File.dirname(__FILE__))
+require File.join(directory, 'plots')
+#require "ruby-debug"
+
+module Flukso
+  # Run R without saving of environment, as quiet as possible.
+  R_CMD = "Rscript --vanilla"  
+
+  class RRunner
+    def initialize(workingdir)
+      # TODO: Check whether R command is available.
+      @workingdir = workingdir
+      puts "Using working directory #{@workingdir}" if $verbose
+    end
+
+    # returns a preamble string: which file to use etc.
+    def createPreamble(outfilename)
+      absOutFilename = File.expand_path(File.join(@workingdir, outfilename))
+      cmd= <<-END_OF_CMD
+      pdf("#{absOutFilename}");
+    END_OF_CMD
+      puts "using filename #{absOutFilename} for output." if $verbose
+      return cmd
+    end
+
+    # returns a closing string - close file, terminate R
+    def createClosing()
+      close=<<-END_OF_CMD
+      q()
+    END_OF_CMD
+      return close
+    end
+
+    # Executes the given command. Expects a string that contains the 
+    # commands to execute.
+    def executeCommandString(outfilename, commands) 
+      cmdSet = createPreamble(outfilename)
+      cmdSet << commands << createClosing
+      # The Tempfile will get deleted automagically when ruby terminates.
+      cmdfile=Tempfile.new("r-cmd", @workingdir)
+      cmdfile.print(cmdSet)
+      cmdfile.close()
+      puts "executing commands:\n#{cmdSet}" if $verbose
+      commandline="#{R_CMD} #{cmdfile.path}"
+      puts "using commandline: #{commandline}" if $verbose
+      stdout = %x[#{commandline}]
+      puts "R (Exitcode: #{$?}) said: #{stdout}" if $verbose
+    end
+
+    def execute(outfilename, commands)
+      puts commands.class
+      if commands.class != Array
+        raise "Please provide an array of commands to the execute call."
+      end
+      cmdString=""
+      commands.each{|command|
+        cmdString << command.cmd();
+        cmdString << "# command separator\n"
+      }
+      executeCommandString(outfilename, cmdString);
+    end
+
+  end
+end
+
+
+# Test routines below - execute this file directly...
+if __FILE__ == $0
+  $verbose=true;
+  runner=Flukso::RRunner.new(".");
+  plotCmd=Flukso::TestPlot.new();
+  plots=Array.new();
+  plots << plotCmd;
+  runner.execute("foo.pdf", plots);
+end

data/lib/flukso/database.rb

@@ -187,6 +187,6 @@ SQL
     end
   end
 
-      class ElementNotFoundError < RuntimeError
-      end
-    end
+  class ElementNotFoundError < RuntimeError
+  end
+end

data/lib/flukso/plots.rb

@@ -0,0 +1,490 @@
+# This file is part of Flukso4R
+# (c) 2010 Mathias Dalheimer, md@gonium.net
+#
+# Flukso4R is free software; you can 
+# redistribute it and/or modify it under the terms of the GNU General Public 
+# License as published by the Free Software Foundation; either version 2 of 
+# the License, or any later version.
+#
+# CGWG is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with CGWG; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+def generateRandomString()
+    chars = ("a".."z").to_a + ("1".."9").to_a 
+    return Array.new(16, '').collect{chars[rand(chars.size)]}.join
+  end
+
+module Flukso
+  # a simple scatterplot
+  class ScatterPlotDaily
+    def initialize(annotation)
+      @annotation=annotation;
+      @readings=Array.new()
+      @dataset_id="data"+generateRandomString();
+    end
+    def addReading(reading);
+      @readings << reading
+    end
+    def create_dataframe_cmd()
+      cmd_create_dataframe= <<-END_OF_CMD
+        #{@dataset_id} <- data.frame( 
+          date=character(), 
+          dayofweek=character(), 
+          period=numeric(), 
+          value=numeric() 
+        );
+      END_OF_CMD
+      @readings.each{|reading|
+        # calculate some values.
+        currenttime=Time.at(reading.utc_timestamp);
+        cmd_compose_data= <<-END_OF_CMD
+          newline<-data.frame(#{reading.utc_timestamp}, "#{reading.dayOfWeek}", #{reading.period}, #{reading.value}); 
+          colnames(newline)<- colnames(#{@dataset_id});
+          #{@dataset_id} <- rbind(#{@dataset_id}, newline);
+        END_OF_CMD
+        cmd_create_dataframe << cmd_compose_data;
+      }
+      return cmd_create_dataframe
+    end
+    def cmd()
+      dataframe=create_dataframe_cmd();
+      cmd= <<-END_OF_CMD
+        # plot commmands. 
+        library(lattice);
+        y_max=max(#{@dataset_id}$value);
+        title<-paste("Daily Power Consumption", "#{@annotation}");
+        data_points<-paste("Number of data points:",nrow(#{@dataset_id}));
+        cat("Plotting scatterplot:", title, data_points, "\n");
+        xyplot(#{@dataset_id}$value ~ #{@dataset_id}$period, main=title, 
+          ylab="Power Usage [W]", xlab="Time Period [15min Intervals]", 
+          sub=data_points, ylim=c(0,y_max), xlim=c(0,95));
+      END_OF_CMD
+      return dataframe << cmd
+    end
+  end
+
+  # Plot a single day as a line.
+  class DailyLine
+    def initialize(annotation, day, month, year)
+      @annotation=annotation;
+      @day=day
+      @month=month
+      @year=year
+      @readings=Array.new()
+      @dataset_id="data"+generateRandomString();
+    end
+    def addReading(reading);
+      # Check wether the reading is on our day.
+      if reading.isOnDay?(@day, @month, @year)
+        @readings << reading
+      #  puts "adding reading." if $verbose
+      #else
+      #  puts "skipping reading (not on desired day)" if $verbose
+      end
+    end
+    def create_dataframe_cmd()
+      cmd_create_dataframe= <<-END_OF_CMD
+        #{@dataset_id} <- data.frame( 
+          date=character(), 
+          dayofweek=character(), 
+          period=numeric(), 
+          value=numeric() 
+        );
+      END_OF_CMD
+      @readings.each{|reading|
+        # calculate some values.
+        currenttime=Time.at(reading.utc_timestamp);
+        cmd_compose_data= <<-END_OF_CMD
+          newline<-data.frame(#{reading.utc_timestamp}, "#{reading.dayOfWeek}", #{reading.period}, #{reading.value}); 
+          colnames(newline)<- colnames(#{@dataset_id});
+          #{@dataset_id} <- rbind(#{@dataset_id}, newline);
+        END_OF_CMD
+        cmd_create_dataframe << cmd_compose_data;
+      }
+      return cmd_create_dataframe
+    end
+    def cmd()
+      if @readings.empty?
+        raise "no values selected - cannot create DailyLine plot for #{@year}-#{@month}-#{@day}"
+      end
+      dataframe=create_dataframe_cmd();
+      cmd= <<-END_OF_CMD
+        # plot commmands. 
+        library(lattice);
+        y_max=max(#{@dataset_id}$value);
+        title<-paste("Daily Power Consumption", "#{@annotation}")
+        data_points<-paste("Number of data points:",nrow(#{@dataset_id}));
+        plot(#{@dataset_id}$value ~ #{@dataset_id}$period, main=title, type="l",
+        ylab="Power Usage [W]", xlab="Time Period [15min Intervals]", 
+        sub=data_points, ylim=c(0,y_max), xlim=c(0,95));
+      END_OF_CMD
+      return dataframe << cmd
+    end
+
+  end
+
+  # Simple test plot that plots 100 points.
+  class TestPlot
+    def cmd()
+      cmd= <<-END_OF_CMD
+        v=1:100
+        p=1:100
+        plot(v,p)
+      END_OF_CMD
+      return cmd
+    end
+  end
+
+end
+
+# The following classes provide some ideas. Not used.
+class RExperimentAnalysis
+  def initialize(path, datafile, loadlevel)
+    @workingdir=path
+    @datafile = File.expand_path(File.join(path, datafile))
+    @loadlevel = loadlevel
+    puts "Using data from file #{@datafile}" if $verbose
+    @runner = RRunner.new(path)
+  end
+
+  def plotSingleRun_Queuetimes
+    drawcmd=<<-END_OF_CMD
+      plot(data$stime, data$qtime,
+        main="Queuetime for all jobs",
+        xlab="submittime",
+        ylab="queuetime"
+      )
+    END_OF_CMD
+    outfile="queuetimes-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+
+  def plotSingleRun_Price
+    drawcmd=<<-END_OF_CMD
+      plot(data$price,
+        main="Price for all jobs",
+        xlab="Job ID",
+        ylab="price"
+      )
+    END_OF_CMD
+    outfile="price-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+
+  def plotSingleRun_PricePrefVsPrice()
+    drawcmd=<<-END_OF_CMD
+      plot(data$pricepref, data$pricert,
+        main="Price preference vs. price per second",
+        xlab="Price Preference",
+        ylab="price/runtime [price/s]"
+      )
+    END_OF_CMD
+    outfile="priceprefvspricert-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end 
+
+  def plotSingleRun_PerfPrefVsQueueTime()
+    drawcmd=<<-END_OF_CMD
+      plot(data$perfpref, data$qtime,
+        main="Performance preference vs. queuetime",
+        xlab="Performance Preference",
+        ylab="absolute queuetime [s]"
+      )
+    END_OF_CMD
+    outfile="perfprefvsqtime-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+
+  def plotSingleRun_PricePerSecond
+    drawcmd=<<-END_OF_CMD
+      plot(data$pricert,
+        main="Price per second for all jobs",
+        xlab="Job ID",
+        ylab="price/runtime [price/s]"
+      )
+    END_OF_CMD
+    outfile="pricepersecond-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+
+  def plotSingleRun_PriceHistogram
+    drawcmd=<<-END_OF_CMD
+      hist(data$pricert,
+        main="Histogram of prices per second",
+        xlab="Price per second",
+        ylab="Frequency"
+      )
+    END_OF_CMD
+    outfile="histpricepersecond-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+
+  def plotSingleRun_QueuetimeHistogram
+    drawcmd=<<-END_OF_CMD
+      hist(data$qtime,
+        main="Histogram of queuetimes",
+        xlab="Queuetime [s]",
+        ylab="Frequency"
+      )
+    END_OF_CMD
+    outfile="histqueuetimes-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+
+  def plotSingleRun_perfPrefHistogram
+    drawcmd=<<-END_OF_CMD
+      hist(data$perfpref,
+        main="Histogram of user preferences",
+        xlab="Performance Preference",
+        ylab="Frequency"
+      )
+    END_OF_CMD
+    outfile="histperfpref-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+
+  def plotSingleRun
+    methods.grep(/^plotSingleRun_/){|m|
+      self.send(m)
+    }
+    sleep(1)
+  end
+end
+
+
+class PAES_Analysis
+  def initialize(path, annotationsfile)
+    @workingdir=path
+    @annotationsfile=annotationsfile
+    if @annotationsfile != nil
+      @annotations=AnnotationCollection.new(@annotationsfile)
+    end
+    @runner = RRunner.new(path)
+  end
+  def plotSingleRun
+    methods.grep(/^plotSingleRun_/){|m|
+      self.send(m)
+    }
+    sleep(1)
+  end
+  def arrayToC(input)
+    retval="c("
+    input.each{|element|
+      if element.instance_of?(String)
+        retval += "\"#{element}\","
+      else
+        retval += "#{element},"
+      end
+    }
+    retval.sub!(/,$/, "");   # delete the last comma
+    return retval+")";
+  end
+  ###
+  ## takes a drawcommand as an argument and adds annotations
+  ## as needed.
+  ## TODO: Points are not plotted if they are out of the range of
+  ## the plot - this might be necessary in the future.
+  #
+  def appendAnnotations(drawcmd)
+    if @annotations != nil
+      puts "Adding annotations\n#{@annotations.to_s}"
+      colors=Array.new()
+      labels=Array.new()
+      ltyInfo=Array.new()
+      pchInfo=Array.new()
+      counter=0;
+      pointlines=""
+      @annotations.each{|a|
+        counter+=1;
+        colors << counter;
+        labels << a.text;
+        pointlines+="points(#{a.qt}, #{a.price}, type=\"p\", pty=2, col=#{counter})\n"
+        ltyInfo << -1;
+        pchInfo << 1;
+      }
+      cols=arrayToC(colors)
+      labelList=arrayToC(labels)
+      ltyList=arrayToC(ltyInfo)
+      pchList=arrayToC(pchInfo)
+      drawcmd+=<<-EOC
+        cols=#{cols}
+        labels=#{labelList}
+        #{pointlines}
+        legend("topright", labels, col = cols,
+           text.col = "black", lty = #{ltyList}, pch = #{pchList},
+           bg = 'gray90')
+      EOC
+    end
+    return drawcmd
+  end
+  def plotSingleRun_ParetoSchedules_Absolute
+    basename="absolute-results"
+    #main="Pareto Front (absolute values)",
+    drawcmd=<<-END_OF_CMD
+      plot(data$QT, data$Price, type="b",
+        xlab="queue time (s)",
+        ylab="price"
+      )
+    END_OF_CMD
+    infile=File.join(@workingdir, basename+".txt")
+    outfile=basename+".eps"
+    puts "infile: #{infile}"
+    puts "outfile: #{outfile}"
+    @runner.execute(infile, outfile, drawcmd)
+  end
+  def plotSingleRun_ParetoSchedules_Relative
+    basename="relative-results"
+    max_qt_annotation = @annotations.getMaxQT()
+    max_price_annotation = @annotations.getMaxPrice()
+    min_qt_annotation = @annotations.getMinQT()
+    min_price_annotation = @annotations.getMinPrice()
+    puts "### Calculated: #{max_qt_annotation}, #{max_price_annotation}"
+    #main="Pareto Front (relative values)",
+    drawcmd=<<-END_OF_CMD
+      max_qt<-max(data$QT, #{max_qt_annotation});
+      max_price<-max(data$Price, #{max_price_annotation});
+      min_qt<-min(data$QT, #{min_qt_annotation});
+      min_price<-min(data$Price, #{min_price_annotation});
+      qt_range<-c(min_qt,max_qt);
+      price_range<-c(min_price,max_price);
+      plot(qt_range, price_range, type="n",
+        xlab="queue time (s)",
+        ylab="price / second"
+      )
+      points(data$QT, data$Price, type="b")
+    END_OF_CMD
+    drawcmd=appendAnnotations(drawcmd)
+    infile=File.join(@workingdir, basename+".txt")
+    outfile=basename+".eps"
+    puts "infile: #{infile}"
+    puts "outfile: #{outfile}"
+    @runner.execute(infile, outfile, drawcmd)
+  end
+  def plotSingleRun_Runtime
+    basename="runtime-report"
+    drawcmd=<<-END_OF_CMD
+      l<-length(data$acc)
+      range<-1:l
+      plot(range, data$acc, type="n",
+        xlab="Iteration (x 1000)",
+        ylab="Dominant Solutions"
+      )
+      points(range, data$acc, type="l", lty=1)
+    END_OF_CMD
+    infile=File.join(@workingdir, basename+".txt")
+    outfile=basename+".eps"
+    puts "infile: #{infile}"
+    puts "outfile: #{outfile}"
+    @runner.execute(infile, outfile, drawcmd)
+  end
+  def plotSingleRun_Runtime_Distance
+    basename="runtime-report"
+    drawcmd=<<-END_OF_CMD
+      l<-length(data$distance)
+      range<-1:l
+      plot(range, data$distance, type="n",
+        xlab="Iteration (x 1000)",
+        ylab="Distance"
+      )
+      points(range, data$distance, type="l", lty=2)
+    END_OF_CMD
+    infile=File.join(@workingdir, basename+".txt")
+    outfile=basename+"-distance.eps"
+    puts "infile: #{infile}"
+    puts "outfile: #{outfile}"
+    @runner.execute(infile, outfile, drawcmd)
+  end
+
+  def plotSingleRun_ParetoSchedules_Intermediates
+    # Search for all intermediate-* files in the data directory
+    Dir.foreach(@workingdir) {|file|
+      #puts "checking #{file}"
+      if file =~ /^intermediate-/
+        if not file =~ /.eps$/
+          plotIntermediate(file)
+        end
+      end
+    }
+  end
+  def plotIntermediate(filename)
+    drawcmd=<<-END_OF_CMD
+      plot(data$QT, data$Price, type="b",
+        main="Pareto Front (absolute values)",
+        xlab="queue time (s)",
+        ylab="price"
+      )
+    END_OF_CMD
+    infile=File.join(@workingdir, filename)
+    outfile=filename+".eps"
+    puts "infile: #{infile}"
+    puts "outfile: #{outfile}"
+    @runner.execute(infile, outfile, drawcmd)
+  end
+
+end
+
+
+
+class SA_Analysis
+  def initialize(path, datafile, loadlevel)
+    @workingdir=path
+    @datafile = File.expand_path(File.join(path, datafile))
+    @loadlevel = loadlevel
+    puts "Using data from file #{@datafile}" if $verbose
+    @runner = RRunner.new(path)
+  end
+  def plotSingleRun
+    methods.grep(/^plotSingleRun_/){|m|
+      self.send(m)
+    }
+    sleep(1)
+  end
+  def plotSingleRun_Energy
+    drawcmd=<<-END_OF_CMD
+      l<-length(data$Energy)
+      range<-1:l
+      plot(range, data$Energy, type="n",
+        main="Energy of the Solutions",
+        xlab="Iteration",
+        ylab="Absolute Energy"
+      )
+      points(range, data$Energy)
+    END_OF_CMD
+    outfile="sa-energy-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+  def plotSingleRun_Temperature
+    drawcmd=<<-END_OF_CMD
+      l<-length(data$Temperature)
+      range<-1:l
+      plot(range, data$Temperature, type="n",
+        main="Temperature of the Solutions",
+        xlab="Iteration",
+        ylab="Temperature"
+      )
+      points(range, data$Temperature, pch=1)
+    END_OF_CMD
+    outfile="sa-temperature-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+  def plotSingleRun_Accepted
+    drawcmd=<<-END_OF_CMD
+      l<-length(data$Accepted)
+      range<-1:l
+      plot(range, data$Accepted, type="n",
+        main="Number of Accepted Solutions",
+        xlab="Iteration",
+        ylab="# Accepted"
+      )
+      points(range, data$Accepted, pch=1)
+    END_OF_CMD
+    outfile="sa-accepted-"+@loadlevel.to_s
+    @runner.execute(@datafile, outfile, drawcmd)
+  end
+end
+

data/lib/flukso/reading.rb

@@ -41,6 +41,28 @@ module Flukso
     def to_s
       return "#{@utc_timestamp} -> #{@value}"
     end
+    def time
+      return Time.at(@utc_timestamp);
+    end
+    def dayOfWeek
+      currenttime=Time.at(@utc_timestamp);
+      return currenttime.strftime("%a");
+    end
+    def isOnDay?(day,month,year)
+      starttime=Time.mktime(year, month, day, 0, 0);
+      endtime=Time.mktime(year, month, day, 23, 59);
+      event=Time.at(@utc_timestamp);
+      if ((starttime <= event) and (event <= endtime))
+        return true
+      else
+        return false
+      end
+    end
+    def period
+      currenttime=Time.at(@utc_timestamp);
+      period=(currenttime.hour * 4) + (currenttime.min / 15);
+      return period
+    end
   end
 
 end

metadata

@@ -1,92 +1,133 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: flukso4r
-version: !ruby/object:Gem::Version 
-  version: 0.3.6
+version: !ruby/object:Gem::Version
+  version: 0.3.7
+  segments:
+  - 0
+  - 3
+  - 7
+  prerelease: false
 platform: ruby
-authors: 
+authors:
 - Mathias Dalheimer
-autorequire: 
+autorequire: !!null 
 bindir: bin
 cert_chain: []
-
-date: 2010-06-08 00:00:00 +02:00
+date: 2011-11-09 00:00:00.000000000 +01:00
 default_executable: flukso_query
-dependencies: 
-- !ruby/object:Gem::Dependency 
+dependencies:
+- !ruby/object:Gem::Dependency
   name: httparty
+  requirement: &74856550 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 0.4.3
-    version: 
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: *74856550
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: &74856170 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+  type: :runtime
+  prerelease: false
+  version_requirements: *74856170
+- !ruby/object:Gem::Dependency
   name: sqlite3-ruby
+  requirement: &74855780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 1.2.5
-    version: 
-description: This gem provides a library for the Flukso API. See http://flukso.net for more information.
+  prerelease: false
+  version_requirements: *74855780
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &74855330 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+  type: :development
+  prerelease: false
+  version_requirements: *74855330
+description: This gem provides a library for the Flukso API. See http://flukso.net
+  for more information.
 email: md@gonium.net
-executables: 
+executables:
 - flukso_archive_watts
 - flukso_create_db
 - flukso_export_db
 - flukso_query
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README.rdoc
-files: 
+files:
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
 - etc/flukso4rrc
 - lib/flukso.rb
+- lib/flukso/R.rb
 - lib/flukso/api.rb
 - lib/flukso/database.rb
 - lib/flukso/export.rb
 - lib/flukso/http_auth.rb
+- lib/flukso/plots.rb
 - lib/flukso/reading.rb
 - lib/flukso/request.rb
 - test/helper.rb
 - test/test_flukso4r.rb
+- bin/flukso_archive_watts
+- bin/flukso_create_db
+- bin/flukso_export_db
+- bin/flukso_query
 has_rdoc: true
 homepage: http://gonium.net/md/flukso4r
 licenses: []
-
-post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+post_install_message: !!null 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.5
-signing_key: 
+rubyforge_project: !!null 
+rubygems_version: 1.3.7
+signing_key: !!null 
 specification_version: 3
 summary: A Ruby Library for the Flukso Webservice
-test_files: 
-- test/helper.rb
-- test/test_flukso4r.rb
+test_files: []