greenbutton 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 52012aa618542579f16c93ee0ad2c7a14509423a
+  data.tar.gz: 5c66932af049ff6ed7bb5b01bf8c9c149bce6065
+SHA512:
+  metadata.gz: 1ee88c5b6cf336011e92f7a175c2a7ee0903eb96076c0c098030d919bf7b8a5ccab9e43af69eb34f2307b0442644cfdffae1f0f5b4467e18bf6177cd00ac6c25
+  data.tar.gz: 230b9e587e05057f66689d57d1d9e3362dc1d82ba1afcd472fea5ea38e151b920b61bb64cae05cfcd65707adb1ac5506c987333b60329e996f4db8a492afbdda

data/.gitignore

@@ -0,0 +1,5 @@
+notes.txt
+test.rb
+.project
+.DS_Store
+.bundle/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+greenbuttonparser

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    greenbutton (0.0.1)
+      nokogiri (~> 1.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    mini_portile (0.5.2)
+    nokogiri (1.6.1)
+      mini_portile (~> 0.5.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.5)
+  greenbutton!
+  rspec (~> 2.14)

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/Readme.md

@@ -0,0 +1,10 @@
+
+## Sample Green Button Parser Implemented in Ruby ##
+
+[![Code Climate](https://codeclimate.com/github/cew821/greenbutton.png)](https://codeclimate.com/github/cew821/greenbutton)
+
+This is a sample implementation of a parser for [Green Button Data](http://services.greenbuttondata.org/), written in Ruby.
+
+This parser parsers Green Button XML into ruby objects.
+
+This software is free, and is released as open source under the MIT license. See license.txt for complete details.

data/greenbutton.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name        = 'greenbutton'
+  s.version     = '0.0.1'
+  s.date        = '2014-03-17'
+  s.summary     = "Ruby parser for the GreenButton data standard."
+  s.description = "This parser programmatically creates a Ruby object from a GreenButton data file. See https://collaborate.nist.gov/twiki-sggrid/bin/view/SmartGrid/GreenButtonSDK for more information on GreenButton. It is under active development and participation is encouraged. It is not yet stable."
+  s.authors     = ["Charles Worthington", "Eric Hulburd"]
+  s.email       = ['c.e.worthington@gmail.com','eric@arbol.org']
+  s.files       = `git ls-files`.split("\n")
+  s.homepage    = 'https://github.com/cew821/greenbutton'
+  s.license     = 'MIT'
+
+  s.add_dependency "nokogiri", "~>1.6"
+  s.add_development_dependency "bundler", "~>1.5"
+  s.add_development_dependency "rspec", "~>2.14"
+
+  s.test_files  = Dir.glob('spec/*_spec.rb')
+end

data/lib/greenbutton.rb

@@ -0,0 +1,60 @@
+module GreenButton
+	require 'nokogiri'
+	require 'greenbutton/gb_classes.rb'
+	
+	UsagePoint = GreenButtonClasses::UsagePoint
+	  
+  # could also load this from the data custodian:feed
+  # url = "http://services.greenbuttondata.org:80/DataCustodian/espi/1_1/resource/RetailCustomer/1/DownloadMyData"
+
+  def self.load_xml_from_web(url)
+    xml_file = Nokogiri.XML(open(url))
+    xml_file.remove_namespaces!
+    Parser.new(xml_file)
+  end
+
+  def self.load_xml_from_file(path)
+    xml_file = Nokogiri.XML(File.open(path, 'rb'))
+    xml_file.remove_namespaces!
+    Parser.new(xml_file)
+  end
+	  
+
+	class Parser
+		attr_accessor :doc, :usage_points
+
+		def initialize(doc)
+			@doc = doc
+			@usage_points = []
+			doc.xpath('//UsagePoint').each do |usage_point|
+        @usage_points << UsagePoint.new(usage_point.parent.parent, self)
+      end
+		end
+		
+		def filter_usage_points(params)
+		  # customer_id, service_kind, title, id, href
+		  filtered = []
+		  @usage_points.each do |usage_point|
+		    params.each_pair do |key, value|
+		      filtered << usage_point if usage_point.send(key) == value
+		    end
+		  end
+		  filtered
+		end
+		
+		def get_unique(attr)
+		  #customer_id, service_kind, title
+		  unique = []
+      @usage_points.each do |usage_point|
+        val = usage_point.send(attr)
+        if !unique.include?(val)
+          unique << val
+        end
+      end
+      unique
+		end
+		
+	end
+end
+
+

data/lib/greenbutton/gb_classes.rb

@@ -0,0 +1,361 @@
+module GreenButtonClasses
+  require 'greenbutton/helpers.rb'
+  require 'nokogiri'
+  
+  Rule = Helper::Rule
+  RULES = [
+    Rule.new(:href, "./link[@rel='self']/@href", :string),
+    Rule.new(:parent_href, "./link[@rel='up']/@href", :string),
+    Rule.new(:id, "./id", :string),
+    Rule.new(:title, "./title", :string),
+    Rule.new(:date_published, "./published", :datetime),
+    Rule.new(:date_updated, "./updated", :datetime)
+  ]
+    
+  
+  class GreenButtonEntry
+    attr_accessor :id, :title, :href, :published, :updated, :parent_href, :related_hrefs, :other_related
+    
+    def initialize(entry_xml, parent)
+      if !entry_xml.nil?
+        @entry_xml = entry_xml
+        self.related_hrefs = []
+        self.other_related = []
+        pre_rule_assignment(parent)
+        assign_rules
+        find_related_entries
+      end
+    end
+    
+    def pre_rule_assignment(parent)
+      raise self.class + 'failed to implement pre_rule_assignment'
+    end
+    
+    def additional_rules
+      []
+    end
+    
+    def doc
+      self.usage_point.doc
+    end
+    
+    def find_by_href(href)
+      doc.xpath("//link[@rel='self' and @href='#{href}']/..")[0]
+    end
+    
+    def assign_rules
+      (RULES + additional_rules).each do |rule|
+        create_attr(rule.attr_name)
+        rule_xml = @entry_xml.xpath(rule.xpath)
+        value = rule_xml.empty? ? nil : rule_xml.text
+        translated_value = value.nil? ? nil : Helper.translate(rule.type, value)
+        self.send(rule.attr_name.to_s+"=", translated_value)
+      end
+    end
+    
+    def find_related_entries
+      self.related_hrefs = []
+      @entry_xml.xpath("./link[@rel='related']/@href").each do |href|
+        if /\/\d+$/i.match(href.text)
+          related_entry = find_by_href(href.text)
+          if related_entry
+            parse_related_entry(related_entry)
+            self.related_hrefs << href.text
+          else
+            warn 'no link found for href: ' + href.text
+          end
+        else  
+          doc.xpath("//link[@rel='up' and @href='#{href.text}']").each do |link|
+            self.related_hrefs << link.attr('href')
+            parse_related_entry(link.parent)
+          end
+        end
+      end
+    end
+    
+    def parse_related_entry(entry_xml)
+      name = get_related_name(entry_xml)
+      classParser = GreenButtonClasses.const_get(name)
+      if !classParser.nil?
+        self.add_related(Helper.underscore(name), classParser.new(entry_xml, self))
+      else
+        other_related.push(xml)
+      end
+    end 
+    
+    def add_related(type, parser)
+      raise self.class + ' does not have any recognized relations.'
+    end
+    
+    private 
+    
+      def get_related_name(xml)
+        name = nil
+        xml.xpath('./content').children.each do |elem|
+          if elem.name != 'text'
+            name = elem.name
+            break
+          end
+        end
+        name
+      end
+      
+      def alt_link(href)
+        # SDGE links map as .../MeterReading to .../MeterReading/\d+
+        regex =  Regexp.new(href + '\/\d+$')
+        related_link = doc.xpath("//link[@rel='self']").select do |e| 
+          if e['href'] =~ regex 
+            e.parent
+          end
+        end
+        related_link[0]
+      end 
+    
+      def create_method( name, &block )
+        self.class.send( :define_method, name, &block )
+      end
+    
+      def create_attr( name )
+        create_method( "#{name.to_s}=".to_sym ) { |val| 
+          instance_variable_set( "@" + name.to_s, val)
+        }
+        create_method( name.to_sym ) { 
+          instance_variable_get( "@" + name.to_s ) 
+        }
+      end
+    
+  end
+  
+  class UsagePoint < GreenButtonEntry
+    attr_accessor :local_time_parameters, :meter_readings, :electric_power_usage_summaries, 
+                  :electric_power_quality_summaries, :green_button
+   
+    def pre_rule_assignment(parent)
+      self.green_button = parent
+      self.meter_readings = []
+      self.electric_power_quality_summaries = []
+      self.electric_power_usage_summaries = []
+    end
+    
+    def doc
+      self.green_button.doc
+    end
+    
+    def add_related(type, parser)
+      case type
+      when 'local_time_parameters'
+        self.local_time_parameters = parser
+      when 'meter_reading', 'electric_power_usage_summary', 'electric_power_quality_summary'
+        self.send(Helper.pluralize(type)) << parser
+      else 
+        raise 'Not a recognized relation for UsagePoint: ' + type
+      end
+    end
+    
+    def additional_rules
+      [ Rule.new(:service_kind, "//ServiceCategory/kind", :ServiceKind) ]
+    end
+    
+    def customer_id
+      if @customer_id.nil?
+        match = /\/([^\/]+)\/UsagePoint/i.match(self.href)
+        @customer_id = match.nil? ? nil : match[1]
+      end
+      @customer_id
+    end
+    
+  end
+  
+  class MeterReading < GreenButtonEntry
+    attr_accessor :reading_type, :interval_blocks, :usage_point
+    
+    def pre_rule_assignment(parent)
+      self.usage_point = parent
+      self.interval_blocks = []
+    end
+    
+    def add_related(type, parser)
+      case type
+      when 'reading_type'
+        self.reading_type = parser
+      when 'interval_block'
+        self.interval_blocks << parser
+      else
+        raise 'Not a recognized relation for MeterReading'
+      end
+    end
+  end
+  
+  class ReadingType < GreenButtonEntry
+    attr_accessor :meter_reading
+    ATTRS = ['accumulationBehaviour', 'commodity', 'currency', 'dataQualifier', 'flowDirection', 'intervalLength',
+        'kind', 'phase', 'powerOfTenMultiplier', 'timeAttribute', 'uom']
+    
+    def pre_rule_assignment(parent)
+      self.meter_reading = parent
+    end
+    
+    def doc
+      self.meter_reading.doc
+    end
+
+    def additional_rules
+      rules = []
+      ATTRS.each do |attr|
+        rules << Rule.new( Helper.underscore(attr).to_sym, './/'+attr, :integer )
+      end
+      rules
+    end
+  end
+  
+  class ElectricPowerUsageSummary < GreenButtonEntry
+    attr_accessor :usage_point
+    ATTRS = ['billLastPeriod', 'billToDate', 'costAdditionalLastPeriod', 'currency', 
+      'qualityOfReading', 'statusTimeStamp']
+    
+    def pre_rule_assignment(parent)
+      self.usage_point = parent
+    end
+    
+    def additional_rules
+      rules = [
+        Rule.new(:bill_duration, ".//duration", :integer),
+        Rule.new(:bill_start, ".//start", :unix_time),
+        Rule.new(:last_power_ten, ".//overallConsumptionLastPeriod/powerOfTenMultiplier", :integer),
+        Rule.new(:last_uom, ".//overallConsumptionLastPeriod/uom", :integer),
+        Rule.new(:last_value, ".//overallConsumptionLastPeriod/value", :integer),
+        Rule.new(:current_power_ten, ".//currentBillingPeriodOverAllConsumption/powerOfTenMultiplier", :integer),
+        Rule.new(:current_uom, ".//currentBillingPeriodOverAllConsumption/uom", :integer),
+        Rule.new(:current_value, ".//currentBillingPeriodOverAllConsumption/value", :integer),   
+        Rule.new(:current_timestamp, ".//currentBillingPeriodOverAllConsumption/timeStamp", :unix_time)   
+      ]
+      ATTRS.each do |attr|
+        rules << Rule.new( Helper.underscore(attr).to_sym, '//'+attr, :integer )
+      end
+      rules
+    end
+  end
+  
+  class ElectricPowerQualitySummary < GreenButtonEntry
+    attr_accessor :usage_point
+    def pre_rule_assignment(parent)
+      self.usage_point = parent
+    end
+  end
+  
+  class LocalTimeParameters < GreenButtonEntry
+    attr_accessor :usage_point
+    
+    def pre_rule_assignment(parent)
+      self.usage_point = parent
+    end
+    
+    def additional_rules
+      [
+        Rule.new(:dst_end_rule, ".//dstEndRule", :string),
+        Rule.new(:dst_offset, ".//dstOffset", :integer),
+        Rule.new(:dst_start_rule, ".//dstStartRule", :string),
+        Rule.new(:tz_offset, ".//tzOffset", :integer)
+      ]
+    end
+  end
+  
+  class IntervalBlock < GreenButtonEntry
+    attr_accessor :meter_reading
+    
+    def pre_rule_assignment(parent)
+      self.meter_reading = parent
+    end
+    
+    def additional_rules
+      [
+        Rule.new(:start_time, './/interval/start', :unix_time),
+        Rule.new(:duration, './/interval/duration', :integer)
+      ]
+    end
+    
+    def doc
+      self.meter_reading.doc
+    end
+    
+    def end_time
+      self.start_time + self.duration
+    end
+    
+    def power_of_ten_multiplier
+      self.meter_reading.reading_type.power_of_ten_multiplier
+    end
+    
+    def reading_at_time(time)
+      if (time >= self.start_time) && (time < end_time)
+        @entry_xml.xpath('.//IntervalReading').each do |interval_reading|
+           intervalReading = IntervalReading.new(interval_reading)
+           if (intervalReading.start_time <= time) && (intervalReading.end_time > time)
+             return intervalReading
+           end
+        end   
+      end
+    end
+    
+    def value_at_time(time)
+      reading_at_time(time).value*10**power_of_ten_multiplier
+    end
+    
+    def total
+      if @total.nil?
+        @total = sum
+      end
+      @total
+    end
+    
+    def average_interval_value
+      total/n_readings
+    end
+    
+    def n_readings
+      @entry_xml.xpath('.//IntervalReading').length
+    end
+    
+    def sum(starttime=nil, endtime=nil)
+      starttime = starttime.nil? ? self.start_time : starttime.utc
+      endtime = endtime.nil? ? self.end_time : endtime.utc
+      sum = 0
+      @entry_xml.xpath('.//IntervalReading').each do |interval_reading|
+        intervalReading = IntervalReading.new(interval_reading)
+        if intervalReading.start_time >= starttime && intervalReading.start_time < endtime
+          if intervalReading.end_time <= endtime
+            sum += intervalReading.value
+          else
+            ratio = (intervalReading.end_time.to_i - endtime.to_i)/intervalReading.duration
+            sum += ratio*intervalReading.value
+            break
+          end
+        end
+      end
+      sum*10**power_of_ten_multiplier  
+    end  
+  end
+  
+  class IntervalReading
+    def initialize(reading_xml)
+      @reading_xml = reading_xml
+    end
+    
+    def value
+      @reading_xml.xpath('./value').text.to_f
+    end
+    
+    def start_time
+      Time.at(@reading_xml.xpath('./timePeriod/start').text.to_i).utc
+    end
+    
+    def duration
+      @reading_xml.xpath('./timePeriod/duration').text.to_i
+    end
+    
+    def end_time
+      start_time + duration
+    end
+  end
+  
+end