knmi 0.1.4 → 0.2.0

data/lib/knmi/httpservice.rb

@@ -0,0 +1,125 @@
+require 'httparty'
+module KNMI
+  class HttpService 
+    include HTTParty
+    
+    class << self
+      
+      def get_daily(station_object, parameter_object, start_at = nil, end_at = nil, seasonal = false)
+        # select YYYYMMDD (drops hour term)
+        query = [station(station_object),  parameters(parameter_object), 
+                 start_date(start_at)[0..13], end_date(end_at)[0..11],
+                 seasonal(seasonal)].compact
+        result = get('http://www.knmi.nl/climatology/daily_data/getdata_day.cgi', { :query => "#{query * "&"}" } )
+        
+        data = parse(station_object, parameter_object, result)
+        
+        return new({"query" => query, "data" => data})
+      end
+  
+      def get_hourly(station_object, parameter_object, start_at = nil, end_at = nil, seasonal = false)
+        query = [station(station_object),  parameters(parameter_object), 
+                 start_date(start_at), end_date(end_at),
+                 seasonal(seasonal)].compact
+        result = get('http://www.knmi.nl/klimatologie/uurgegevens/getdata_uur.cgi', { :query => "#{query * "&"}" } )
+        
+        data = parse(station_object, parameter_object, result)
+        
+        return new({"query" => query, "data" => data})
+      end
+        
+      private
+    
+      # Generates string for station 
+      def station(station_object) 
+        "stns=#{station_object.id}"
+      end
+    
+      # pulls parameter names from parameter object defaults to All
+      def parameters(parameter_object)
+        vars = []
+        parameter_object.each { |p| vars << p.parameter }                    
+        "vars=#{vars * ":"}"
+      end      
+  
+      # Select Data seasonally? between selected dates for each year.
+      def seasonal(bool)
+        if bool == false
+          nil
+        else
+          "inseason=true"
+        end
+      end
+  
+      # YYYYMMDDHH Default is previous day
+      # if starts is nil returns string for one day prior to current
+      def start_date(starts)
+        if starts.nil?
+          t = Time.now
+          t = Time.utc(t.year, t.month, t.day)
+          t = t - 24 * 60 * 60  
+          "start" + time_str(t)
+        elsif starts.kind_of?(Time)
+          "start" + time_str(starts)
+        end
+      end
+  
+      # YYYYMMDDHH Default is current day
+      # if ends is nil returns string for current time
+      def end_date(ends)
+        if ends.nil?
+          "end" + time_str(Time.now)
+        elsif ends.kind_of?(Time)
+          "end" + time_str(ends)
+        end
+      end
+      
+      # Hours requires 01-24
+      def time_str(t)
+        hour = ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24"]
+        "=#{t.year}#{t.strftime("%m")}#{t.day}#{hour[t.hour]}"
+      end
+      
+      # Grab the Http response data and convert to array of hashes
+      def parse(station_object, parameter_object, data)
+        # Number stations
+        nstn = 1
+        # Number parameters
+        nparams = parameter_object.length
+
+        # Split lines into array
+        data = data.split(/\n/)
+
+        # Get and clean data
+        data = data[(8 + nstn + nparams)..data.length]
+        data = data.join.tr("\s+", "")
+        data = data.tr("#", "")
+
+        # Parse into array and then hash with var name
+        data = CSV.parse(data, {:skip_blanks => true})
+        header = data.shift.map {|i| i.to_s.intern }
+        string_data = data.map {|row| row.map {|cell| cell.to_s } }
+        data = string_data.map {|row| Hash[*header.zip(row).flatten] }
+      
+        return data
+      end
+    
+    end
+  
+    #
+    # Returns query string used in HTTP get request
+    # KNMI::HttpService.get_daily(210) #=> @ query =>[ "stns=210", "vars=ALL", "start=2011051500", "end=2011051613"]
+    attr_reader :query
+  
+    #
+    # Parsed HTTP request
+    # Array of Hashes     
+    attr_reader :data
+  
+    def initialize(properties)
+      @query, @data = %w(query data).map do |p|
+        properties[p]
+      end
+    end
+  end
+end

data/lib/knmi/parameters.rb

@@ -0,0 +1,98 @@
+module KNMI
+  class Parameters
+    class << self
+      attr_writer :keys_file
+      
+      #
+      # Retrieve information about Parameter can be string or array
+      #
+      # KNMI::Parameter.find(period = "daily", "TA")  #=> KNMI::Parameter object for TG (Daily Max temperature)
+      # KNMI::Parameter.find(period = "daily", ["TG", "TX"])  #=> KNMI::Parameter array of objects TG (Daily Mean temperature) and TX (Daily Max Temperature)
+      def find(period, parameter)
+        parameter = [parameter].flatten
+        
+        list = []
+        parameter.uniq.each do |p|
+          list << keys.find { |k| k.parameter == p and k.period == period }
+        end
+        
+        return list
+      end     
+      
+      #
+      # Retrieve each parameter within a category
+      # an Array of structs
+      #
+      # KNMI.Parameter.category(period = "daily, ""WIND") #=> [#<Parameter:0x00000100b433f8 @parameter="SQ", @category="RADT", @description="Sunshine Duration", @validate="(-1..6).include?(n)", @conversion="n == -1 ? 0.05 : (n / 10) * 60", @units="minutes">, #<Daily:0x00000100b43290 @parameter="SP", @category="RADT", @description="Percent of Maximum Sunshine Duration", @validate="(0..100).include?(n)", @conversion=nil, @units="%">, #<Daily:0x00000100b43128 @parameter="Q", @category="RADT", @description="Global Radiation", @validate="n.integer?", @conversion=nil, @units="J/cm^2">]
+      # KNMI.Parameter.category(period = "daily, ["WIND", "TEMP"]) 
+      def category(period, category)        
+        category = [category].flatten
+        
+        list = []
+        category.uniq.each do |c|
+          list << keys.select { |k| k.category == c and k.period == period }
+        end
+        
+        return list.flatten!
+      end
+      
+      #
+      # Retrieve all Parameters
+      # an Array of structs
+      def all(period)      
+        list = []
+        list << keys.select { |k| k.period == period }
+        list.flatten!
+      end
+      
+      private
+            
+      # Parameters
+      def keys
+        File.open(keys_file) do |file|
+          yaml = YAML.load(file) || raise("Can't parse #{file.path}")
+          yaml.map { |key_hash| new(key_hash) }
+        end
+      end
+
+      def keys_file
+        @keys_file ||= File.join(File.dirname(__FILE__), '..', '..', 'data', 'data_key.yml')
+      end
+      
+    end
+    
+    # Paramter shortname
+    attr_reader :parameter
+    
+    # Categories grouping parameters
+    attr_reader :category
+    
+    # Description of parameter
+    attr_reader :description 
+    
+    # Code to validate data as accurate
+    attr_reader :validate
+    
+    # Code to convert data into appropriate format/units
+    attr_reader :conversion
+    
+    # Unit of converted format
+    attr_reader :units 
+    
+    # Time Period
+    attr_reader :period
+    
+    def initialize(properties)
+      @parameter, @category, @description, @validate, @conversion, @units, @period = %w(parameter category description validate conversion units period).map do |p|
+        properties[p]
+      end
+    end
+    
+    def detail
+      {:parameter => @parameter, :category => @category, 
+       :description => @description, :validate => @validate, 
+       :conversion => @conversion, :units => @units, :period => @period}
+    end
+
+  end
+end

data/lib/knmi/station.rb

@@ -0,0 +1,113 @@
+module KNMI
+  class Station
+    class <<self
+      attr_writer :stations_file #:nodoc:
+
+      #
+      # Retrieve information about a station given a station ID
+      #
+      #   KNMI::Station.find(210)  #=> KNMI::Station object for Valkenburg
+      def find(id)
+        stations.find { |station| station.id == id }
+      end
+
+      # 
+      # Find the station closest to a given location. Can accept arguments in any of the following
+      # three forms (all are equivalent):
+      #
+      #   KNMI::Station.closest_to(52.165, 4.419)
+      #   KNMI::Station.closest_to([52.165, 4.419])
+      #   KNMI::Station.closest_to(GeoKit::LatLng.new(52.165, 4.419))
+      def closest_to(*args)
+        if args.length == 1
+          if args.first.respond_to?(:distance_to)
+            closest_to_coordinates(args.first)
+          elsif %w(first last).all? { |m| args.first.respond_to?(m) }
+            closest_to_lat_lng(args.first)
+          else
+            raise ArgumentError, "expected two-element Array or GeoKit::LatLng"
+          end
+        elsif args.length == 2
+          closest_to_lat_lng(args)
+        else
+          raise ArgumentError, "closest_to() will accept one Array argument, one GeoKit::LatLng argument, or two FixNum arguments"
+        end
+      end
+
+      private
+
+      def closest_to_lat_lng(pair)
+        closest_to_coordinates(GeoKit::LatLng.new(pair.first, pair.last))
+      end
+
+      def closest_to_coordinates(coordinates)
+        stations.map do |station|
+          [coordinates.distance_to(station.coordinates), station]
+        end.min do |p1, p2|
+          p1.first <=> p2.first # compare distance
+        end[1]
+      end
+
+      def stations
+        File.open(stations_file) do |file|
+          yaml = YAML.load(file) || raise("Can't parse #{file.path} - be sure to run noaa-update-stations")
+          yaml.map { |station_hash| new(station_hash) }
+        end
+      end
+
+      def stations_file
+        @stations_file ||= File.join(File.dirname(__FILE__), '..', '..', 'data', 'current_stations.yml')
+      end
+    end
+
+    # GeoKit::LatLng containing the station's coordinates
+    attr_reader :coordinates
+
+    # Station ID (e.g., 210)
+    attr_reader :id
+
+    # Station name (e.g., "Valkenburg")
+    attr_reader :name
+    
+    # Station Elevation
+    attr_reader :elevation
+    alias_method :elev, :elevation
+    alias_method :altitude, :elevation
+    alias_method :alt, :elevation
+    
+    # Link to Station Photo
+    attr_reader :photo
+    
+    # Link to map of station location
+    attr_reader :map
+    
+    # Link to Metadata page listing
+    attr_reader :web
+    
+    attr_reader :instrumentation
+
+    def initialize(properties)
+      @id, @name, @elevation, @photo, @map, @web, @instrumentation = %w(id name elevation photo map web instrumentation).map do |p|
+        properties[p]
+      end
+      @coordinates = GeoKit::LatLng.new(properties['lat'], properties['lng'])
+    end
+    
+    # Latitude of station
+    def latitude
+      @coordinates.lat
+    end
+    alias_method :lat, :latitude
+
+    # Longitude of station
+    def longitude
+      @coordinates.lng
+    end
+    alias_method :lng, :longitude
+    alias_method :lon, :longitude
+    
+    def detail
+      {:id => @id, :name => @name, :elev => @elevation, :lat => latitude, :lng => longitude}    
+    end
+  end
+end

data/test/helper.rb

@@ -8,11 +8,14 @@ rescue Bundler::BundlerError => e
   exit e.status_code
 end
 require 'test/unit'
-require 'shoulda'
+require 'shoulda-context'
+require 'pry'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'knmi'
 
-class Test::Unit::TestCase
+module KNMI
+  class TestCase < Test::Unit::TestCase
+  end
 end

data/test/test_httpservice.rb

@@ -0,0 +1,53 @@
+require 'helper'
+
+class TestHttpService < KNMI::TestCase
+  context "get daily data from station" do
+    setup do
+      station = KNMI.station_by_id(235)
+      parameter = KNMI.parameters("daily", "TX")
+      start_at = Time.utc(2010, 6, 28)
+      end_at = Time.utc(2010, 6, 29)
+      
+      @response = KNMI::HttpService.get_daily(station, parameter, start_at, end_at)
+    end
+    
+    should "have HTTParty::Response class" do
+      assert_equal @response.class, KNMI::HttpService
+    end
+    
+    should "have query" do
+      assert_equal @response.query, ["stns=235", "vars=TX", "start=20100628", "end=20100629"]
+    end
+    
+    should "have result" do
+      assert_equal @response.data, [{:STN=>"235", :YYYYMMDD=>"20100628", :TX=>"263"}, {:STN=>"235", :YYYYMMDD=>"20100629", :TX=>"225"}]
+    end    
+  end
+  
+  context "get hourly data from station" do
+    setup do
+      station = KNMI.station_by_id(235)
+      parameter = KNMI.parameters("hourly", "T")
+      start_at = Time.utc(2010, 4, 27, 0)
+      end_at = Time.utc(2010, 4, 27, 2)
+      
+      @response = KNMI::HttpService.get_hourly(station, parameter, start_at, end_at)
+    end
+    
+    should "have HTTParty::Response class" do
+      assert_equal @response.class, KNMI::HttpService
+    end
+    
+    should "have query" do
+      assert_equal @response.query, ["stns=235", "vars=T", "start=2010042701", "end=2010042703"]
+    end
+    
+    should "have result" do
+      assert_equal @response.data, [
+        {:STN=>"235", :YYYYMMDD=>"20100427", :HH=>"1", :T=>"88"},
+        {:STN=>"235", :YYYYMMDD=>"20100427", :HH=>"2", :T=>"79"},
+        {:STN=>"235", :YYYYMMDD=>"20100427", :HH=>"3", :T=>"73"} ]
+    end
+  end
+
+end

data/test/test_knmi.rb

@@ -1,7 +1,147 @@
 require 'helper'
 
-class TestKnmi < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
+class TestKNMI < KNMI::TestCase
+  context "a station by location" do 
+    setup do
+      @station = KNMI.station_by_location(52.165, 4.419)
+    end
+    
+    should "be a struct" do
+      assert_equal @station.class, KNMI::Station
+    end
+    
+    should 'find id 210' do
+      assert_equal @station.id, 210
+    end
   end
-end
+  
+  context "a station by id" do 
+    setup do
+      @station = KNMI.station_by_id(210)
+    end
+    
+    should "be a struct" do
+      assert_equal @station.class, KNMI::Station
+    end
+    
+    should 'find id 210' do
+      assert_equal @station.id, 210
+    end
+    
+  end
+  
+  
+  # Test KNMI.Parameters Daily
+  context "fetch daily - a single parameter" do
+    setup do
+      @params = KNMI.parameters(period = "daily", "TX")
+    end
+    
+    should "be kind of Array" do
+      assert_equal @params.class, Array
+    end
+    
+    should "contain KNMI::Parameters object" do
+      assert_equal @params[0].class, KNMI::Parameters
+    end
+    
+    should "be length 1" do
+      assert_equal @params.length, 1
+    end
+  end
+    
+  context "fetch daily - more than one parameter" do
+    setup do
+      @params = KNMI.parameters(period = "daily", ["TX", "TG"])
+    end
+    
+    should "be length 2" do
+      assert_equal @params.length, 2
+    end
+  end
+    
+  context "fetch daily - one doubly named parameter" do
+    setup do
+      @params = KNMI.parameters(period = "daily", ["TX", "TX"])
+    end
+    
+    should "be length 1" do
+      assert_equal @params.length, 1
+    end
+  end
+
+  context "fetch daily - a single parameter category" do
+    setup do
+      @params = KNMI.parameters(period = "daily", params = "", categories = "TEMP")
+    end
+    
+    should "be length 7" do
+      assert_equal @params.length, 7
+    end
+  end
+  
+  context "fetch daily - more than one parameter category" do
+    setup do
+      @params = KNMI.parameters(period = "daily", params = "", categories = ["TEMP", "WIND"])
+    end
+    
+    should "be length 16" do
+      assert_equal @params.length, 16
+    end
+  end
+  
+  context "fetch daily - one doubly named parameter category" do
+    setup do
+      @params = KNMI.parameters(period = "daily", params = "", categories = ["WIND", "WIND"])
+    end
+    
+    should "be length 9" do
+      assert_equal @params.length, 9
+    end
+  end
+  
+  context "fetch daily - a single parameter and a single parameter category of same grouping" do
+    setup do
+      @params = KNMI.parameters(period = "daily", params = "TX", categories = "TEMP")
+    end
+    
+    should "be length 7" do
+      assert_equal @params.length, 7
+    end
+  end
+  
+  context "fetch daily - an param or category which isn't available" do
+    setup do
+      @params = KNMI.parameters(period = "daily", "Tmax")
+    end
+    
+    should "be length 0" do
+      assert_equal @params.length, 0 
+    end
+  end
+  
+  context "get data over daily timestep" do
+    setup do
+      station = KNMI.station_by_location(52.165, 4.419)
+      params = KNMI.parameters(period = "daily", "TX")
+      start_at = Time.utc(2010, 6, 28)
+      end_at = Time.utc(2010, 6, 29)
+      @response = KNMI.get_data(station, params, start_at, end_at)
+    end
+    
+    should "have HTTParty::Response class" do
+      assert_equal @response.class, KNMI::HttpService
+    end
+    
+    should "have query" do
+      assert_equal @response.query, ["stns=210", "vars=TX", "start=20100628", "end=20100629"]
+    end
+    
+    should "have result" do
+      assert_equal @response.data, [
+        {:STN=>"210", :YYYYMMDD=>"20100628", :TX=>"268"},
+        {:STN=>"210", :YYYYMMDD=>"20100629", :TX=>"239"}]
+    end    
+  end
+  
+end