cdo 1.1.0 → 1.2.0

data/README.rdoc

@@ -24,20 +24,20 @@ Cdo.rb requires a working CDO binary, but has not special requirement to Ruby
 
 * File information
     
-    Cdo.infov(:in => ifile)
-    Cdo.showlevels(:in => ifile)
+    Cdo.infov(:input => ifile)
+    Cdo.showlevels(:input => ifile)
 
 * Operators with regular output files
 
-    Cdo.timmin(:in => ifile,:out => ofile)
+    Cdo.timmin(:input => ifile,:output => ofile)
 
 * Operators with options
 
-    Cdo.remap([gridfile,weightfile],:in => ifile, :out => ofile)
+    Cdo.remap([gridfile,weightfile],:input => ifile, :output => ofile)
 
 * Set global CDO options
 
-   Cdo.copy(:in => ifile, :out => ofile,:options => "-f nc4")
+   Cdo.copy(:input => ifile, :output => ofile,:options => "-f nc4")
 
 More examples can be found in test/cdo-examples.rb.
 

data/gemspec

@@ -3,7 +3,7 @@ $:.unshift File.join(File.dirname(__FILE__),"..","lib")
 
 spec = Gem::Specification.new do |s|
   s.name              = "cdo"
-  s.version           = '1.1.0'
+  s.version           = '1.2.0'
   s.platform          = Gem::Platform::RUBY
   s.files             = ["lib/cdo.rb"] + ["gemspec","COPYING","README.rdoc","ChangeLog"]
   s.test_file         = "test/test_cdo.rb"

data/lib/cdo.rb

@@ -1,4 +1,5 @@
 require 'pp'
+require 'open3'
 
 # Copyright (C) 2011-2012 Ralf Mueller, ralf.mueller@zmaw.de
 # See COPYING file for copying and redistribution conditions.
@@ -16,7 +17,7 @@ require 'pp'
 # CDO calling mechnism
 module Cdo
 
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 
   State = {
     :debug       => false,
@@ -89,9 +90,10 @@ module Cdo
     cmd = "#{@@CDO} -O #{options} #{cmd} "
     case ofile
     when $stdout
-      cmd << " 2>/dev/null"
-      puts cmd if Cdo.debug
-      return IO.popen(cmd).readlines.map {|l| l.chomp.strip}
+      stdin, stdout, stderr, status =  Open3.popen3(cmd)
+      retval = stdout.read.split($/).map {|l| l.chomp.strip}
+      pp stderr.read
+      return retval
     else
       force = State[:forceOutput] if force.nil?
       if force or not File.exists?(ofile.to_s)
@@ -102,7 +104,9 @@ module Cdo
         warn "Use existing file '#{ofile}'" if Cdo.debug
       end
     end
-    if returnCdf or State[:returnCdf]
+    if not returnArray.nil?
+      Cdo.readArray(ofile,returnArray)
+    elsif returnCdf or State[:returnCdf]
       Cdo.readCdf(ofile)
     else
       return ofile
@@ -118,17 +122,15 @@ module Cdo
     return [io,opts]
   end
   def Cdo.method_missing(sym, *args, &block)
-    ## args is expected to look like [opt1,...,optN,:in => iStream,:out => oStream] where
+    ## args is expected to look like [opt1,...,optN,:input => iStream,:output => oStream] where
     # iStream could be another CDO call (timmax(selname(Temp,U,V,ifile.nc))
     puts "Operator #{sym.to_s} is called" if State[:debug]
     if getOperators.include?(sym.to_s)
       io,opts = Cdo.parseArgs(args)
       if @@outputOperatorsPattern.match(sym)
-        run(" -#{sym.to_s}#{opts} #{io[:in]} ",$stdout)
+        run(" -#{sym.to_s}#{opts} #{io[:input]} ",$stdout)
       else
-        #if opts[:force] or not File.exist?(opts[:out]) then
-          run(" -#{sym.to_s}#{opts} #{io[:in]} ",io[:out],io[:options],io[:returnCdf],io[:force])
-        #end
+        run(" -#{sym.to_s}#{opts} #{io[:input]} ",io[:output],io[:options],io[:returnCdf],io[:force],io[:returnArray])
       end
     else
       warn "Operator #{sym.to_s} not found"
@@ -212,7 +214,7 @@ module Cdo
   # Addional operotors:
   #------------------------------------------------------------------
   def Cdo.boundaryLevels(args)
-    ilevels         = Cdo.showlevel(:in => args[:in])[0].split.map(&:to_f)
+    ilevels         = Cdo.showlevel(:input => args[:input])[0].split.map(&:to_f)
     bound_levels    = Array.new(ilevels.size+1)
     bound_levels[0] = 0
     (1..ilevels.size).each {|i| 
@@ -236,6 +238,17 @@ module Cdo
     NetCDF.open(iFile)
   end
 
+  def Cdo.readArray(iFile,varname)
+    filehandle = Cdo.readCdf(iFile)
+    if filehandle.var_names.include?(varname)
+      # return the data array
+      filehandle.var(varname).get
+    else
+      warn "Cannot find variable '#{varname}'"
+      raise ArgumentError
+    end
+  end
+
   def Cdo.selindexlist(args)
     
   end

data/test/test_cdo.rb

@@ -36,17 +36,17 @@ class TestCdo < Test::Unit::TestCase
 
   def test_outputOperators
     Cdo.debug = true
-    levels = Cdo.showlevel(:in => "-stdatm,0")
+    levels = Cdo.showlevel(:input => "-stdatm,0")
     assert_equal([0,0].map(&:to_s),levels)
 
-    info = Cdo.sinfo(:in => "-stdatm,0")
+    info = Cdo.sinfo(:input => "-stdatm,0")
     assert_equal("File format: GRIB",info[0])
 
-    values = Cdo.outputkey("value",:in => "-stdatm,0")
+    values = Cdo.outputkey("value",:input => "-stdatm,0")
     assert_equal(["1013.25", "288"],values)
-    values = Cdo.outputkey("value",:in => "-stdatm,0,10000")
+    values = Cdo.outputkey("value",:input => "-stdatm,0,10000")
     assert_equal(["1013.25", "271.913", "288", "240.591"],values)
-    values = Cdo.outputkey("level",:in => "-stdatm,0,10000")
+    values = Cdo.outputkey("level",:input => "-stdatm,0,10000")
     assert_equal(["0", "10000","0", "10000"],values)
   end
   def test_CDO_version
@@ -59,39 +59,38 @@ class TestCdo < Test::Unit::TestCase
     ofile1 = MyTempfile.path
     ofile2 = MyTempfile.path
     ofile3 = MyTempfile.path
-    Cdo.stdatm(0,20,40,80,200,230,400,600,1100,:out => ofile0)
-    Cdo.intlevel(0,10,50,100,500,1000,  :in => ofile0,:out => ofile1)
-    Cdo.intlevel([0,10,50,100,500,1000],:in => ofile0,:out => ofile2)
-    Cdo.sub(:in => [ofile1,ofile2].join(' '),:out => ofile3)
-    info = Cdo.infon(:in => ofile3)
+    Cdo.stdatm(0,20,40,80,200,230,400,600,1100,:output => ofile0)
+    Cdo.intlevel(0,10,50,100,500,1000,  :input => ofile0,:output => ofile1)
+    Cdo.intlevel([0,10,50,100,500,1000],:input => ofile0,:output => ofile2)
+    Cdo.sub(:input => [ofile1,ofile2].join(' '),:output => ofile3)
+    info = Cdo.infon(:input => ofile3)
     (1...info.size).each {|i| assert_equal(0.0,info[i].split[-1].to_f)}
   end
   def test_operator_options
     targetLevels = [0,10,50,100,200,400,1000]
     ofile = Cdo.stdatm(targetLevels)
-    levels = Cdo.showlevel(:in => ofile)
+    levels = Cdo.showlevel(:input => ofile)
     [0,1].each {|i| assert_equal(targetLevels.map(&:to_s),levels[i].split)}
   end
   def test_CDO_options
-    names = Cdo.showname(:in => "-stdatm,0",:options => "-f nc")
+    names = Cdo.showname(:input => "-stdatm,0",:options => "-f nc")
     assert_equal(["P T"],names)
 
-    ofile = MyTempfile.path
-    Cdo.topo(:out => ofile,:options => "-z szip")
-    assert_equal(["GRIB SZIP"],Cdo.showformat(:in => ofile))
+    ofile = Cdo.topo(:output => ofile,:options => "-z szip")
+    assert_equal(["GRIB SZIP"],Cdo.showformat(:input => ofile))
   end
   def test_chain
-    ofile     = MyTempfile.path
-    Cdo.Debug = true
-    Cdo.setname('veloc',:in => " -copy -random,r1x1",:out => ofile,:options => "-f nc")
-    assert_equal(["veloc"],Cdo.showname(:in => ofile))
+    Cdo.debug = true
+    ofile = Cdo.setname('veloc',:input => " -copy -random,r1x1",:options => "-f nc")
+    assert_equal(["veloc"],Cdo.showname(:input => ofile))
   end
 
   def test_diff
-    diffv = Cdo.diffn(:in => "-random,r1x1 -random,r1x1")
+    Cdo.debug = true
+    diffv = Cdo.diffn(:input => "-random,r1x1 -random,r1x1")
     assert_equal(diffv[1].split(' ')[-1],"random")
     assert_equal(diffv[1].split(' ')[-3],"0.53060")
-    diff  = Cdo.diff(:in => "-random,r1x1 -random,r1x1")
+    diff  = Cdo.diff(:input => "-random,r1x1 -random,r1x1")
     assert_equal(diff[1].split(' ')[-3],"0.53060")
   end
 
@@ -101,21 +100,20 @@ class TestCdo < Test::Unit::TestCase
   end
 
   def test_bndLevels
-    ofile = MyTempfile.path
-    Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc")
+    ofile = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc")
     assert_equal([0, 50.0, 150.0, 350.0, 650.0, 1100.0, 1700.0, 2500.0, 3500.0, 4500.0, 5500.0],
-                 Cdo.boundaryLevels(:in => "-selname,T #{ofile}"))
+                 Cdo.boundaryLevels(:input => "-selname,T #{ofile}"))
     assert_equal([50.0, 100.0, 200.0, 300.0, 450.0, 600.0, 800.0, 1000.0, 1000.0, 1000.0],
-                 Cdo.thicknessOfLevels(:in => ofile))
+                 Cdo.thicknessOfLevels(:input => ofile))
   end
 
   def test_combine
     ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-    Cdo.fldsum(:in => Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:out => ofile0)
-    Cdo.fldsum(:in => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:out => ofile1)
+    Cdo.fldsum(:input => Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:output => ofile0)
+    Cdo.fldsum(:input => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:output => ofile1)
     Cdo.setReturnCdf
     MyTempfile.showFiles
-    diff = Cdo.sub(:in => [ofile0,ofile1].join(' ')).var('T').get
+    diff = Cdo.sub(:input => [ofile0,ofile1].join(' ')).var('T').get
     assert_equal(0.0,diff.min)
     assert_equal(0.0,diff.max)
     Cdo.setReturnCdf(false)
@@ -132,23 +130,24 @@ class TestCdo < Test::Unit::TestCase
   end
 
   def test_returnCdf
-    ofile = MyTempfile.path
-    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc",:force => true)
+    ofile = rand(0xfffff).to_s + '_test_returnCdf.nc'
+    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
     assert_equal(ofile,vals)
     Cdo.setReturnCdf
-    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc")
+    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
     assert_equal(["lon","lat","level","P","T"],vals.var_names)
     assert_equal(276,vals.var("T").get.flatten.mean.floor)
     Cdo.unsetReturnCdf
-    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc")
+    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
     assert_equal(ofile,vals)
+    FileUtils.rm(ofile)
   end
   def test_simple_returnCdf
     ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-    sum = Cdo.fldsum(:in => Cdo.stdatm(0,:options => "-f nc"),
+    sum = Cdo.fldsum(:input => Cdo.stdatm(0,:options => "-f nc"),
                :returnCdf => true).var("P").get
     assert_equal(1013.25,sum.min)
-    sum = Cdo.fldsum(:in => Cdo.stdatm(0,:options => "-f nc"),:out => ofile0)
+    sum = Cdo.fldsum(:input => Cdo.stdatm(0,:options => "-f nc"),:output => ofile0)
     assert_equal(ofile0,sum)
     test_returnCdf
   end
@@ -161,9 +160,9 @@ class TestCdo < Test::Unit::TestCase
 
     # deticated output, force = true
     outs.clear
-    outs << Cdo.stdatm(0,10,20,:out => 'test_force')
+    outs << Cdo.stdatm(0,10,20,:output => 'test_force')
     mtime0 = File.stat(outs[-1]).mtime
-    outs << Cdo.stdatm(0,10,20,:out => 'test_force')
+    outs << Cdo.stdatm(0,10,20,:output => 'test_force')
     mtime1 = File.stat(outs[-1]).mtime
     assert_not_equal(mtime0,mtime1)
     assert_equal(outs[0],outs[1])
@@ -172,9 +171,9 @@ class TestCdo < Test::Unit::TestCase
 
     # dedicated output, force = false
     ofile = 'test_force_false'
-    outs << Cdo.stdatm(0,10,20,:out => ofile,:force => false)
+    outs << Cdo.stdatm(0,10,20,:output => ofile,:force => false)
     mtime0 = File.stat(outs[-1]).mtime
-    outs << Cdo.stdatm(0,10,20,:out => ofile,:force => false)
+    outs << Cdo.stdatm(0,10,20,:output => ofile,:force => false)
     mtime1 = File.stat(outs[-1]).mtime
     assert_equal(mtime0,mtime1)
     assert_equal(outs[0],outs[1])
@@ -184,9 +183,9 @@ class TestCdo < Test::Unit::TestCase
     # dedicated output, global force setting
     ofile = 'test_force_global'
     Cdo.forceOutput = false
-    outs << Cdo.stdatm(0,10,20,:out => ofile)
+    outs << Cdo.stdatm(0,10,20,:output => ofile)
     mtime0 = File.stat(outs[-1]).mtime
-    outs << Cdo.stdatm(0,10,20,:out => ofile)
+    outs << Cdo.stdatm(0,10,20,:output => ofile)
     mtime1 = File.stat(outs[-1]).mtime
     assert_equal(mtime0,mtime1)
     assert_equal(outs[0],outs[1])
@@ -197,42 +196,58 @@ class TestCdo < Test::Unit::TestCase
   def test_thickness
     levels            = "25 100 250 500 875 1400 2100 3000 4000 5000".split
     targetThicknesses = [50.0,  100.0,  200.0,  300.0,  450.0,  600.0,  800.0, 1000.0, 1000.0, 1000.0]
-    assert_equal(targetThicknesses, Cdo.thicknessOfLevels(:in => "-selname,T -stdatm,#{levels.join(',')}"))
+    assert_equal(targetThicknesses, Cdo.thicknessOfLevels(:input => "-selname,T -stdatm,#{levels.join(',')}"))
   end
 
   def test_showlevels
     sourceLevels = %W{25 100 250 500 875 1400 2100 3000 4000 5000}
     assert_equal(sourceLevels,
-                 Cdo.showlevel(:in => "-selname,T #{Cdo.stdatm(*sourceLevels,:options => '-f nc')}")[0].split)
+                 Cdo.showlevel(:input => "-selname,T #{Cdo.stdatm(*sourceLevels,:options => '-f nc')}")[0].split)
   end
 
   def test_verticalLevels
     Cdo.debug = true
     targetThicknesses = [50.0,  100.0,  200.0,  300.0,  450.0,  600.0,  800.0, 1000.0, 1000.0, 1000.0]
     sourceLevels = %W{25 100 250 500 875 1400 2100 3000 4000 5000}
-    thicknesses = Cdo.thicknessOfLevels(:in => "-selname,T #{Cdo.stdatm(*sourceLevels,:options => '-f nc')}")
+    thicknesses = Cdo.thicknessOfLevels(:input => "-selname,T #{Cdo.stdatm(*sourceLevels,:options => '-f nc')}")
     assert_equal(targetThicknesses,thicknesses)
   end
 
   def test_parseArgs
-    io,opts = Cdo.parseArgs([1,2,3,:in => '1',:out => '2',:force => true,:returnCdf => "T"])
-    assert_equal("1",io[:in])
-    assert_equal("2",io[:out])
+    io,opts = Cdo.parseArgs([1,2,3,:input => '1',:output => '2',:force => true,:returnCdf => "T"])
+    assert_equal("1",io[:input])
+    assert_equal("2",io[:output])
     assert_equal(true,io[:force])
     assert_equal("T",io[:returnCdf])
     pp [io,opts]
   end 
 
+  def test_returnArray
+    temperature = Cdo.stdatm(0,:options => '-f nc',:returnCdf => true).var('T').get.flatten[0]
+    assert_raise ArgumentError do
+      Cdo.stdatm(0,:options => '-f nc',:returnArray => 'TT')
+    end
+    temperature = Cdo.stdatm(0,:options => '-f nc',:returnArray => 'T')
+    assert_equal(288.0,temperature.flatten[0])
+    pressure = Cdo.stdatm(0,1000,:options => '-f nc -b F64',:returnArray => 'P')
+    assert_equal("1013.25 898.543456035875",pressure.flatten.to_a.join(' '))
+  end
+
+
   if 'thingol' == `hostname`.chomp  then
     def test_readCdf
       input = "-settunits,days  -setyear,2000 -for,1,4"
-      cdfFile = Cdo.copy(:options =>"-f nc",:in=>input)
+      cdfFile = Cdo.copy(:options =>"-f nc",:input=>input)
       cdf     = Cdo.readCdf(cdfFile)
       assert_equal(['lon','lat','time','for'],cdf.var_names)
     end
     def test_selIndexListFromIcon
       input = "~/data/icon/oce.nc"
     end
+    def test_readArray
+      ifile = '/home/ram/data/examples/EH5_AMIP_1_TSURF_1991-1995.nc'
+      assert_equal([192, 96, 10],Cdo.readArray(Cdo.seltimestep('1/10',:input => ifile), 'tsurf').shape)
+    end
   end
 
 end
@@ -241,30 +256,30 @@ end
 #  #
 #  # merge:
 #  #   let files be an erray of valid filenames and ofile is a string
-#  Cdo.merge(:in => outvars.join(" "),:out => ofile)
+#  Cdo.merge(:input => outvars.join(" "),:output => ofile)
 #  #   or with multiple arrays:
-#  Cdo.merge(:in => [ifiles0,ifiles1].flatten.join(' '),:out => ofile)
+#  Cdo.merge(:input => [ifiles0,ifiles1].flatten.join(' '),:output => ofile)
 #  # selname:
 #  #   lets grep out some variables from ifile:
 #  ["T","U","V"].each {|varname|
 #    varfile = varname+".nc"
-#    Cdo.selname(varname,:in => ifile,:out => varfile)
+#    Cdo.selname(varname,:input => ifile,:output => varfile)
 #  }
 #  #   a threaded version of this could look like:
 #  ths = []
 #  ["T","U","V"].each {|outvar|
 #    ths << Thread.new(outvar) {|ovar|
 #      varfile = varname+".nc"
-#      Cdo.selname(varname,:in => ifile,:out => varfile)
+#      Cdo.selname(varname,:input => ifile,:output => varfile)
 #    }
 #  }
 #  ths.each {|th| th.join}
 #  # another example with sub:
-#  Cdo.sub(:in => [oldfile,newfile].join(' '), :out => diff)
+#  Cdo.sub(:input => [oldfile,newfile].join(' '), :output => diff)
 #  
 #  # It is possible too use the 'send' method
 #  operator  = /grb/.match(File.extname(ifile)) ? :showcode : :showname
-#  inputVars = Cdo.send(operator,:in => ifile)
+#  inputVars = Cdo.send(operator,:input => ifile)
 #  # show and info operators are writing to stdout. cdo.rb tries to collects this into arrays
 #  #
 #  # Same stuff with other operators:
@@ -274,15 +289,15 @@ end
 #             else
 #               warn "Wrong usage of variable identifier for '#{var}' (class #{var.class})!"
 #             end
-#  Cdo.send(operator,var,:in => @ifile, :out => varfile)
+#  Cdo.send(operator,var,:input => @ifile, :output => varfile)
 #  
 #  # Pass an array for operators with multiple options:
 #  #   Perform conservative remapping with pregenerated weights
-#  Cdo.remap([gridfile,weightfile],:in => copyfile,:out => outfile)
+#  Cdo.remap([gridfile,weightfile],:input => copyfile,:output => outfile)
 #  #   Create vertical height levels out of hybrid model levels
-#  Cdo.ml2hl([0,20,50,100,200,400,800,1200].join(','),:in => hybridlayerfile, :out => reallayerfile)
+#  Cdo.ml2hl([0,20,50,100,200,400,800,1200].join(','),:input => hybridlayerfile, :output => reallayerfile)
 #  # or use multiple arguments directly
-#  Cdo.remapeta(vctfile,orofile,:in => ifile,:out => hybridlayerfile)
+#  Cdo.remapeta(vctfile,orofile,:input => ifile,:output => hybridlayerfile)
 #  
 #  # the powerfull expr operator:
 #  # taken from the tutorial in https://code.zmaw.de/projects/cdo/wiki/Tutorial#The-_expr_-Operator
@@ -293,8 +308,8 @@ end
 #  TEMP_EXPR    = lambda {|height| "213.0+75.0*exp(-#{height}/#{SCALEHEIGHT})"}
 #  
 #  # Create Pressure and Temperature out of a height field 'geopotheight' from ifile
-#  Cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :in => ifile, :out => presFile)
-#  Cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :in => ifile, :out => tempFile)
+#  Cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :input => ifile, :output => presFile)
+#  Cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :input => ifile, :output => tempFile)
 #  
 #  
 #  # TIPS: I often work with temporary files and for getting rid of handling them manually the MyTempfile module can be used:
@@ -304,8 +319,8 @@ end
 #  end
 #  # As an example, the computation of simple atmospherric density could look like
 #  presFile, tempFile = tfile, tfile
-#  Cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :in => ifile, :out => presFile)
-#  Cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :in => ifile, :out => tempFile)
+#  Cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :input => ifile, :output => presFile)
+#  Cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :input => ifile, :output => tempFile)
 #  Cdo.chainCall("setname,#{rho} -divc,#{C_R} -div",in: [presFile,tempFile].join(' '), out: densityFile)
 #  
 #  # For debugging, it is helpfull, to avoid the automatic cleanup at the end of the scripts:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cdo
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-15 00:00:00.000000000 Z
+date: 2012-11-21 00:00:00.000000000 Z
 dependencies: []
 description: Easy access to the Climate Data operators
 email: stark.dreamdetective@gmail.com