forecaster 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a5197a183958f87c3231d9794568fd71794c5b5
-  data.tar.gz: d33426c83219a0a7d813be7dea525a8426cc61ad
+  metadata.gz: f918096d5bc3c84b8b1be9ded8a0e9597a3bf700
+  data.tar.gz: 73a46ed9e59a3c3f05cc45c5a654d8548055fa58
 SHA512:
-  metadata.gz: f7c2cda2ff2a646779c9326ef40b93c8e12593753dd62c3418f7def70b4bc9104640a1353652259a613b17dfb686bce95486bf9f6b286511a0a15f1da966b2d3
-  data.tar.gz: 973f053a188acd33f48f4305280f5106181749d65942c86bff946c98921fe8b18377d9b35c3687fb1c0107bf286ac8082e77aa36fac4b98539c66a72cfa5d009
+  metadata.gz: dac29049eb42eb4cee58446c28a15d090c9abdfe76426db8c732e499b2cd1dcf8f9405d7a0bfa3479496525291de9e417c54a3cbdc687b87b1d9d73aa5fbe05a
+  data.tar.gz: 7406bb7e8d9de0afa5ff34854d826d71a34e5412a14871f82c0766d3f9793e0f212238473c32176518f8c45ed6402081efe43d7b3beee83f13dbd2a4f5221e71

data/bin/forecast

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "forecaster"
+
+Forecaster::CLI.start(ARGV, ENV)

data/lib/forecaster/cli.rb

@@ -0,0 +1,243 @@
+require "yaml/store"
+require "trollop"
+require "chronic"
+require "timezone"
+require "geocoder"
+require "ruby-progressbar"
+
+require "forecaster"
+
+# Fetch and read data from the Global Forecast System.
+module Forecaster
+  # Command line interface printing the forecast for a time and a location.
+  class CLI
+    include Singleton # TODO: Find how best to organize CLI class
+
+    FORECAST_FORMAT = "  %-15s % 7.1f %s".freeze
+
+    def self.start(args, env)
+      instance.start(args, env)
+    end
+
+    def initialize
+      @store = nil
+    end
+
+    def start(args, env)
+      opts = parse(args)
+
+      configure(opts)
+
+      cache_file = File.join(Forecaster.configuration.cache_dir, "forecast.yml")
+      @store = YAML::Store.new(cache_file)
+
+      puts "GFS Weather Forecast"
+      puts
+
+      lat, lon = get_location(opts, env)
+
+      Trollop.die("Could not parse location") if lat.nil? || lon.nil?
+
+      ENV["TZ"] = get_timezone(lat, lon, env) || env["TZ"]
+      time = get_time(opts)
+      forecast = get_forecast(time, opts)
+      print_forecast(forecast, lat, lon)
+      ENV["TZ"] = env["TZ"] # Restore TZ
+    end
+
+    # Parse command line options
+    def parse(args)
+      opts = Trollop.options(args) do
+        usage           "for <time> in <location>"
+        version         "Forecaster v#{Forecaster::VERSION}"
+        opt :time,      "Set time in any format",  :type => String
+        opt :location,  "Set location name",       :type => String
+        opt :latitude,  "Set latitude in degree",  :type => Float, :short => "a"
+        opt :longitude, "Set longitude in degree", :type => Float, :short => "o"
+        opt :cache,     "Set cache directory",     :default => "/tmp/forecaster"
+        opt :debug,     "Enable debug mode"
+      end
+
+      cmd_opts = { :time => [], :location => [] }
+      key = :time
+      args.each do |word|
+        case word
+        when "for"
+          key = :time
+        when "in"
+          key = :location
+        else
+          cmd_opts[key] << word
+        end
+      end
+      opts[:time] ||= cmd_opts[:time].join(" ")
+      opts[:location] ||= cmd_opts[:location].join(" ")
+
+      opts
+    end
+
+    # Configure gem
+    def configure(opts)
+      Forecaster.configure do |config|
+        config.cache_dir = opts[:cache]
+        config.records = {
+          :prate => ":PRATE:surface:",
+          :pres  => ":PRES:surface:",
+          :rh    => ":RH:2 m above ground:",
+          :tmp   => ":TMP:2 m above ground:",
+          :ugrd  => ":UGRD:10 m above ground:",
+          :vgrd  => ":VGRD:10 m above ground:",
+          :tcdc  => ":TCDC:entire atmosphere:"
+        }
+      end
+      FileUtils.mkpath(Forecaster.configuration.cache_dir)
+    end
+
+    # Get location
+    def get_location(opts, env)
+      if opts[:location]
+        @store.transaction do
+          if opts[:debug]
+            puts format("%-15s '%s'", "Geolocalizing:", opts[:location])
+          end
+
+          key = "geocoder:#{opts[:location]}"
+          lat, lon = @store[key] ||= geolocalize(opts[:location])
+
+          if opts[:debug]
+            if lat && lon
+              puts format("%-15s %s, %s", "Found:", lat, lon)
+            else
+              puts "Not found"
+            end
+            puts
+          end
+
+          [lat, lon]
+        end
+      elsif opts[:latitude] && opts[:longitude]
+        [opts[:latitude], opts[:longitude]]
+      else
+        [env["FORECAST_LATITUDE"], env["FORECAST_LONGITUDE"]]
+      end
+    end
+
+    # Get timezone
+    def get_timezone(lat, lon, env)
+      tz = nil
+      if env["GEONAMES_USERNAME"]
+        Timezone::Lookup.config(:geonames) do |config|
+          config.username = env["GEONAMES_USERNAME"]
+        end
+        @store.transaction do
+          key = "timezone:#{lat}:#{lon}"
+          tz = @store[key] || @store[key] = Timezone.lookup(lat, lon).name
+        end
+      end
+
+      tz
+    end
+
+    # Get time
+    def get_time(opts)
+      if opts[:time]
+        # TODO: Look for a timestamp first
+        time = Chronic.parse(opts[:time])
+        Trollop.die(:time, "could not be parsed") if time.nil?
+        time.utc
+      else
+        Time.now.utc
+      end
+    end
+
+    # Get forecast
+    def get_forecast(time, opts)
+      forecast = Forecast.at(time)
+
+      if opts[:debug]
+        puts format("%-15s %s", "Requested time:", time.localtime)
+        puts format("%-15s %s", "GFS run time:", forecast.run_time.localtime)
+        puts format("%-15s %s", "Forecast time:", forecast.time.localtime)
+        puts
+      end
+
+      unless forecast.fetched?
+        if opts[:debug]
+          puts "Downloading: '#{forecast.url}'"
+
+          puts "Reading index file..."
+          ranges = forecast.fetch_index
+
+          filesize = ranges.reduce(0) do |acc, range|
+            first, last = range.split("-").map(&:to_i)
+            acc + last - first
+          end
+          filesize_in_megabytes = (filesize.to_f / (1 << 20)).round(2)
+          puts "Length: #{filesize} (#{filesize_in_megabytes}M)"
+          puts
+
+          progressbar = ProgressBar.create(
+            :format => "%p%% [%b>%i] %r KB/s %e",
+            :rate_scale => lambda { |rate| rate / 1024 }
+          )
+
+          progress_block = lambda do |progress, total|
+            progressbar.total = total
+            progressbar.progress = progress
+          end
+
+          forecast.fetch_grib2(ranges, :progress_block => progress_block)
+
+          progressbar.finish
+          puts
+        else
+          forecast.fetch # That's a lot easier ^^
+        end
+      end
+
+      forecast
+    end
+
+    # Print forecast
+    def print_forecast(forecast, lat, lon)
+      forecast_time = forecast.time.localtime
+
+      puts format("  %-11s % 11s", "Date:", forecast_time.strftime("%Y-%m-%d"))
+      puts format("  %-11s % 11s", "Time:", forecast_time.strftime("%T"))
+      puts format("  %-11s % 11s", "Zone:", forecast_time.strftime("%z"))
+      puts format(FORECAST_FORMAT, "Latitude:",  lat, "°")
+      puts format(FORECAST_FORMAT, "Longitude:", lon, "°")
+      puts
+
+      pres  = forecast.read(:pres,  :latitude => lat, :longitude => lon).to_f
+      tmp   = forecast.read(:tmp,   :latitude => lat, :longitude => lon).to_f
+      ugrd  = forecast.read(:ugrd,  :latitude => lat, :longitude => lon).to_f
+      vgrd  = forecast.read(:vgrd,  :latitude => lat, :longitude => lon).to_f
+      prate = forecast.read(:prate, :latitude => lat, :longitude => lon).to_f
+      rh    = forecast.read(:rh,    :latitude => lat, :longitude => lon).to_f
+      tcdc  = forecast.read(:tcdc,  :latitude => lat, :longitude => lon).to_f
+
+      pressure       = pres / 100.0
+      temperature    = tmp - 273.15
+      wind_speed     = Math.sqrt(ugrd**2 + vgrd**2)
+      wind_direction = (270 - Math.atan2(ugrd, vgrd) * 180 / Math::PI) % 360
+      precipitation  = prate * 3600
+      humidity       = rh
+      cloud_cover    = tcdc
+
+      puts format(FORECAST_FORMAT, "Pressure:",       pressure,       "hPa")
+      puts format(FORECAST_FORMAT, "Temperature:",    temperature,    "°C")
+      puts format(FORECAST_FORMAT, "Wind Speed:",     wind_speed,     "m/s")
+      puts format(FORECAST_FORMAT, "Wind Direction:", wind_direction, "°")
+      puts format(FORECAST_FORMAT, "Precipitation:",  precipitation,  "mm")
+      puts format(FORECAST_FORMAT, "Humidity:",       humidity,       "%")
+      puts format(FORECAST_FORMAT, "Cloud Cover:",    cloud_cover,    "%")
+    end
+
+    def geolocalize(location)
+      Geocoder.configure(:timeout => 10)
+      res = Geocoder.search(location).first
+      [res.latitude, res.longitude] if res
+    end
+  end
+end

data/lib/forecaster/configuration.rb

@@ -1,11 +1,12 @@
+# Fetch and read data from the Global Forecast System.
 module Forecaster
+  # Configure how to fetch and read from a forecast file.
   class Configuration
     attr_accessor :server, :cache_dir, :curl_path, :wgrib2_path, :records
 
     def initialize
       @server = "http://www.ftp.ncep.noaa.gov/data/nccf/com/gfs/prod"
       @cache_dir = "/tmp/forecaster"
-      @curl_path = "curl"
       @wgrib2_path = "wgrib2"
 
       # See: http://www.nco.ncep.noaa.gov/pmb/products/gfs/gfs_upgrade/gfs.t06z.pgrb2.0p25.f006.shtml

data/lib/forecaster/forecast.rb

@@ -1,33 +1,68 @@
 require "fileutils"
+require "excon"
 
+# Fetch and read data from the Global Forecast System.
 module Forecaster
+  # Fetch and read a specific forecast from a GFS run.
+  #
+  # See: http://www.nco.ncep.noaa.gov/pmb/products/gfs/
   class Forecast
-    def initialize(year, month, day, hour_of_run, hour_of_forecast)
+    def self.last_run_at
+      # There is a new GFS run every 6 hours starting at midnight UTC, and it
+      # takes approximately 3 to 5 hours before a run is available online, so
+      # to be on the safe side we return the previous one.
+      now = Time.now.utc
+      run = Time.new(now.year, now.month, now.day, (now.hour / 6) * 6)
+
+      run - 6 * 3600
+    end
+
+    def self.at(time)
+      # There is a forecast every 3 hours after a run for 384 hours.
+      t = time.utc
+      fct = Time.new(t.year, t.month, t.day, (t.hour / 3) * 3)
+      run = Time.new(t.year, t.month, t.day, (t.hour / 6) * 6)
+      run -= 6 * 3600 if run == fct
+
+      last_run = Forecast.last_run_at
+      run = last_run if run > last_run
+
+      fct_hour = (fct - run) / 3600
+
+      raise "Time too far in the future" if fct_hour > 384
+
+      Forecast.new(run.year, run.month, run.day, run.hour, fct_hour)
+    end
+
+    def initialize(year, month, day, run_hour, fct_hour)
       @year = year
       @month = month
       @day = day
-      @hour_of_run = hour_of_run
-      @hour_of_forecast = hour_of_forecast
+      @run_hour = run_hour
+      @fct_hour = fct_hour
+    end
+
+    def run_time
+      Time.utc(@year, @month, @day, @run_hour)
+    end
+
+    def time
+      run_time + @fct_hour * 3600
     end
 
     def dirname
-      subdir = "%04d%02d%02d%02d" % [
-        @year, @month, @day, @hour_of_run
-      ]
+      subdir = format("%04d%02d%02d%02d", @year, @month, @day, @run_hour)
       File.join(Forecaster.configuration.cache_dir, subdir)
     end
 
     def filename
-      "gfs.t%02dz.pgrb2.0p25.f%03d" % [
-        @hour_of_run, @hour_of_forecast
-      ]
+      format("gfs.t%02dz.pgrb2.0p25.f%03d", @run_hour, @fct_hour)
     end
 
     def url
       server = Forecaster.configuration.server
-      "%s/gfs.%04d%02d%02d%02d/%s" % [
-        server, @year, @month, @day, @hour_of_run, filename
-      ]
+      subdir = format("gfs.%04d%02d%02d%02d", @year, @month, @day, @run_hour)
+      format("%s/%s/%s", server, subdir, filename)
     end
 
     def fetched?
@@ -38,44 +73,54 @@ module Forecaster
     # But only the parts of the file containing the fields defined in
     # the configuration will be downloaded.
     def fetch
-      return self if fetched?
-
-      curl = Forecaster.configuration.curl_path
-
-      FileUtils.mkpath(File.join(dirname))
-
-      path = File.join(dirname, filename)
+      return if fetched?
+      ranges = fetch_index
+      fetch_grib2(ranges)
+    end
 
-      # puts "Downloading '#{url}.idx' ..."
-      cmd = "#{curl} -fsS -o #{path}.idx #{url}.idx"
-      raise "Download of '#{url}.idx' failed" unless system(cmd)
+    def fetch_index
+      begin
+        res = Excon.get("#{url}.idx")
+      rescue Excon::Errors::Error
+        raise "Download of '#{url}.idx' failed"
+      end
 
-      lines = IO.readlines("#{path}.idx")
-      n = lines.count
-      ranges = lines.each_index.reduce([]) do |r, i|
+      lines = res.body.lines
+      lines.each_index.reduce([]) do |r, i|
         records = Forecaster.configuration.records
         if records.values.any? { |record| lines[i].include?(record) }
           first = lines[i].split(":")[1].to_i
           last = ""
 
           j = i
-          while (j += 1) < n
+          while (j += 1) < lines.count
             last = lines[j].split(":")[1].to_i - 1
             break if last != first - 1
           end
 
-          r << "#{first}-#{last}" # cURL syntax for a range
+          r << "#{first}-#{last}" # Range header syntax
         else
           r
         end
       end
-      system("rm #{path}.idx")
+    end
 
-      # puts "Downloading '#{url}' ..."
-      cmd = "#{curl} -fsS -r #{ranges.join(",")} -o #{path} #{url}"
-      raise "Download of '#{url}' failed" unless system(cmd)
+    def fetch_grib2(ranges, progress_block: nil)
+      FileUtils.mkpath(dirname)
+      path = File.join(dirname, filename)
 
-      self
+      streamer = lambda do |chunk, remaining, total|
+        File.open(path, "ab") { |f| f.write(chunk) }
+        progress_block.call(total - remaining, total) if progress_block
+      end
+
+      headers = { "Range" => "bytes=#{ranges.join(',')}" }
+      begin
+        Excon.get(url, :headers => headers, :response_block => streamer)
+      rescue Excon::Errors::Error => e
+        File.delete(path)
+        raise "Download of '#{url}' failed: #{e}"
+      end
     end
 
     def read(field, latitude: 0.0, longitude: 0.0)
@@ -83,7 +128,7 @@ module Forecaster
       record = Forecaster.configuration.records[field]
       path = File.join(dirname, filename)
 
-      raise "'#{path}' not found" unless File.exists?(path)
+      raise "'#{path}' not found" unless File.exist?(path)
 
       coords = "#{longitude} #{latitude}"
       output = `#{wgrib2} #{path} -lon #{coords} -match "#{record}"`

data/lib/forecaster/version.rb

@@ -0,0 +1,4 @@
+# Fetch and read data from the Global Forecast System.
+module Forecaster
+  VERSION = "0.1.0".freeze
+end

data/lib/forecaster.rb

@@ -1,6 +1,9 @@
 require "forecaster/configuration"
 require "forecaster/forecast"
+require "forecaster/version"
+require "forecaster/cli"
 
+# Fetch and read data from the Global Forecast System.
 module Forecaster
   class << self
     attr_accessor :configuration
@@ -12,6 +15,13 @@ module Forecaster
   end
 
   def self.fetch(year, month, day, hour_of_run, hour_of_forecast)
-    Forecaster::Forecast.new(year, month, day, hour_of_run, hour_of_forecast).fetch
+    y = year
+    m = month
+    d = day
+    c = hour_of_run
+    h = hour_of_forecast
+    forecast = Forecaster::Forecast.new(y, m, d, c, h)
+    forecast.fetch
+    forecast
   end
 end

metadata

@@ -1,24 +1,148 @@
 --- !ruby/object:Gem::Specification
 name: forecaster
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Vincent Ollivier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-09 00:00:00.000000000 Z
-dependencies: []
+date: 2016-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.49.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.49.0
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: timezone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.99.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.99.0
+- !ruby/object:Gem::Dependency
+  name: geocoder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
 description: Wrapper around curl and wgrib2 to fetch and read GFS data
 email: v@vinc.cc
-executables: []
+executables:
+- forecast
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/forecast
 - lib/forecaster.rb
+- lib/forecaster/cli.rb
 - lib/forecaster/configuration.rb
 - lib/forecaster/forecast.rb
+- lib/forecaster/version.rb
 homepage: https://github.com/vinc/forecaster
 licenses:
 - MIT