Example #1
0
    def test_pp_append_singles(self):
        # Test pp append saving - single cubes.
        
        # load 2 arrays of >2D cubes
        cube = stock.simple_pp()
        
        reference_txt_path = tests.get_result_path(('cube_to_pp', 'append_single.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=[cube, cube]) as temp_pp_path:
            iris.save(cube, temp_pp_path)                # Create file
            iris.save(cube, temp_pp_path, append=True)   # Append to file

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'replace_single.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cube) as temp_pp_path:
            iris.save(cube, temp_pp_path)                # Create file
            iris.save(cube, temp_pp_path)                # Replace file
Example #2
0
 def test_rotated_latlon(self):
     source_grib = tests.get_data_path(("GRIB", "rotated_nae_t", "sensible_pole.grib2"))
     reference_text = tests.get_result_path(("grib_save", "rotated_latlon.grib_compare.txt"))
     # TODO: Investigate small change in test result:
     #       long [iDirectionIncrement]: [109994] != [109993]
     #       Consider the change in dx_dy() to "InDegrees" too.
     self.save_and_compare(source_grib, reference_text)
Example #3
0
 def test_simple(self):
     cube = Cube(np.array([0, 1, 2, 3, 4.4]), long_name="foo")
     dim_coord = DimCoord([5, 6, 7, 8, 9], long_name="bar")
     cube.add_dim_coord(dim_coord, 0)
     series = iris.pandas.as_series(cube)
     self.assertArrayEqual(series, cube.data)
     self.assertString(str(series), tests.get_result_path(("pandas", "as_series", "simple.txt")))
Example #4
0
    def test_name2_field(self):
        filepath = tests.get_data_path(('NAME', 'NAMEII_field.txt'))
        name_cubes = iris.load(filepath)
        # Check gribapi version, because we currently have a known load/save
        # problem with gribapi 1v14 (at least).
        gribapi_ver = gribapi.grib_get_api_version()
        gribapi_fully_supported_version = \
            (StrictVersion(gribapi.grib_get_api_version()) <
             StrictVersion('1.13'))
        for i, name_cube in enumerate(name_cubes):
            if not gribapi_fully_supported_version:
                data = name_cube.data
                if np.min(data) == np.max(data):
                    msg = ('NAMEII cube #{}, "{}" has empty data : '
                           'SKIPPING test for this cube, as save/load will '
                           'not currently work with gribabi > 1v12.')
                    warnings.warn(msg.format(i, name_cube.name()))
                    continue

            with self.temp_filename('.grib2') as temp_filename:
                iris.save(name_cube, temp_filename)
                grib_cube = iris.load_cube(temp_filename, callback=name_cb)
                self.check_common(name_cube, grib_cube)
                self.assertCML(
                    grib_cube, tests.get_result_path(
                        ('integration', 'name_grib', 'NAMEII',
                         '{}_{}.cml'.format(i, name_cube.name()))))
Example #5
0
    def test_pp_append_lists(self):
        # Test PP append saving - lists of cubes.
        # For each of the first four time-steps in the 4D cube,
        # pull out the bottom two levels.
        cube_4d = stock.realistic_4d()
        cubes = [cube_4d[i, :2, :, :] for i in range(4)]

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'append_multi.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cubes) as temp_pp_path:
            iris.save(cubes[:2], temp_pp_path)
            iris.save(cubes[2:], temp_pp_path, append=True)

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'replace_multi.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cubes[2:]) as temp_pp_path:
            iris.save(cubes[:2], temp_pp_path)
            iris.save(cubes[2:], temp_pp_path)
Example #6
0
 def test_time_gregorian(self):
     cube = Cube(np.array([0, 1, 2, 3, 4]), long_name="ts")
     time_coord = DimCoord([0, 100.1, 200.2, 300.3, 400.4], long_name="time", units="days since 2000-01-01 00:00")
     cube.add_dim_coord(time_coord, 0)
     series = iris.pandas.as_series(cube)
     self.assertArrayEqual(series, cube.data)
     self.assertString(str(series), tests.get_result_path(("pandas", "as_series", "time_gregorian.txt")))
Example #7
0
 def test_no_y_coord(self):
     cube = Cube(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]), long_name="foo")
     x_coord = DimCoord([10, 11, 12, 13, 14], long_name="bar")
     cube.add_dim_coord(x_coord, 1)
     data_frame = iris.pandas.as_data_frame(cube)
     self.assertArrayEqual(data_frame, cube.data)
     self.assertString(str(data_frame), tests.get_result_path(("pandas", "as_dataframe", "no_y_coord.txt")))
Example #8
0
 def test_default_coord_system(self):
     GeogCS = iris.coord_systems.GeogCS
     cube = iris.tests.stock.lat_lon_cube()
     reference_txt_path = tests.get_result_path(('cube_to_pp',
                                                 'default_coord_system.txt'))
     # Remove all coordinate systems.
     for coord in cube.coords():
         coord.coord_system = None
     # Ensure no coordinate systems available.
     self.assertIsNone(cube.coord_system(GeogCS))
     self.assertIsNone(cube.coord_system(None))
     with self.cube_save_test(reference_txt_path, reference_cubes=cube) as \
             temp_pp_path:
         # Save cube to PP with no coordinate system.
         iris.save(cube, temp_pp_path)
         pp_cube = iris.load_cube(temp_pp_path)
         # Ensure saved cube has the default coordinate system.
         self.assertIsInstance(pp_cube.coord_system(GeogCS),
                               iris.coord_systems.GeogCS)
         self.assertIsNotNone(pp_cube.coord_system(None))
         self.assertIsInstance(pp_cube.coord_system(None),
                               iris.coord_systems.GeogCS)
         self.assertIsNotNone(pp_cube.coord_system())
         self.assertIsInstance(pp_cube.coord_system(),
                               iris.coord_systems.GeogCS)
Example #9
0
    def test_series_object(self):
        class Thing(object):
            def __repr__(self):
                return "A Thing"

        series = pandas.Series([0, 1, 2, 3, 4], index=[Thing(), Thing(), Thing(), Thing(), Thing()])
        self.assertCML(iris.pandas.as_cube(series), tests.get_result_path(("pandas", "as_cube", "series_object.cml")))
Example #10
0
 def test_data_frame_masked(self):
     data_frame = pandas.DataFrame(
         [[0, float("nan"), 2, 3, 4], [5, 6, 7, np.nan, 9]], index=[10, 11], columns=[12, 13, 14, 15, 16]
     )
     self.assertCML(
         iris.pandas.as_cube(data_frame), tests.get_result_path(("pandas", "as_cube", "data_frame_masked.cml"))
     )
Example #11
0
 def test_masked(self):
     data = np.ma.MaskedArray([0, 1, 2, 3, 4.4], mask=[0, 1, 0, 1, 0])
     cube = Cube(data, long_name="foo")
     series = iris.pandas.as_series(cube)
     self.assertArrayEqual(series, cube.data.astype('f').filled(np.nan))
     self.assertString(
         str(series),
         tests.get_result_path(('pandas', 'as_series', 'masked.txt')))
Example #12
0
 def test_time_360(self):
     cube = Cube(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]), long_name="ts")
     time_unit = cf_units.Unit("days since 2000-01-01 00:00", calendar=cf_units.CALENDAR_360_DAY)
     time_coord = DimCoord([100.1, 200.2], long_name="time", units=time_unit)
     cube.add_dim_coord(time_coord, 0)
     data_frame = iris.pandas.as_data_frame(cube)
     self.assertArrayEqual(data_frame, cube.data)
     self.assertString(str(data_frame), tests.get_result_path(("pandas", "as_dataframe", "time_360.txt")))
Example #13
0
 def test_no_dim_coord(self):
     cube = Cube(np.array([0, 1, 2, 3, 4]), long_name="foo")
     series = iris.pandas.as_series(cube)
     self.assertArrayEqual(series, cube.data)
     self.assertString(
         str(series),
         tests.get_result_path(('pandas', 'as_series',
                                'no_dim_coord.txt')))
Example #14
0
 def test_time_360(self):
     cube = Cube(np.array([0, 1, 2, 3, 4]), long_name="ts")
     time_unit = cf_units.Unit("days since 2000-01-01 00:00", calendar=cf_units.CALENDAR_360_DAY)
     time_coord = DimCoord([0, 100.1, 200.2, 300.3, 400.4], long_name="time", units=time_unit)
     cube.add_dim_coord(time_coord, 0)
     series = iris.pandas.as_series(cube)
     self.assertArrayEqual(series, cube.data)
     self.assertString(str(series), tests.get_result_path(("pandas", "as_series", "time_360.txt")))
Example #15
0
 def test_latlon_forecast_plev(self):
     source_grib = tests.get_data_path(("GRIB", "uk_t", "uk_t.grib2"))
     if self.problem_gribapi_ver:
         result_file = "latlon_forecast_plev.grib_compare.pre1-12-0.txt"
     else:
         result_file = "latlon_forecast_plev.grib_compare.post1-12-0.txt"
     reference_text = tests.get_result_path(("grib_save", result_file))
     self.save_and_compare(source_grib, reference_text)
Example #16
0
    def test_no_forecast_time(self):
        cube = stock.lat_lon_cube()
        coord = iris.coords.DimCoord(np.array([24], dtype=np.int64), standard_name="time", units="hours since epoch")
        cube.add_aux_coord(coord)
        self.assertCML(cube, ["cube_to_pp", "no_forecast_time.cml"])

        reference_txt_path = tests.get_result_path(("cube_to_pp", "no_forecast_time.txt"))
        with self.cube_save_test(reference_txt_path, reference_cubes=cube) as temp_pp_path:
            iris.save(cube, temp_pp_path)
Example #17
0
 def check_dot(self, cube, reference_filename):
     test_string = iris.fileformats.dot.cube_text(cube)
     reference_path = tests.get_result_path(reference_filename)
     if os.path.isfile(reference_path):
         reference = ''.join(open(reference_path, 'r').readlines())
         self._assert_str_same(reference, test_string, reference_filename, type_comparison_name='DOT files')
     else:
         tests.logger.warning('Creating result file: %s', reference_path)
         open(reference_path, 'w').writelines(test_string)
Example #18
0
 def test_no_dim_coords(self):
     cube = Cube(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]),
                 long_name="foo")
     data_frame = iris.pandas.as_data_frame(cube)
     self.assertArrayEqual(data_frame, cube.data)
     self.assertString(
         str(data_frame),
         tests.get_result_path(('pandas', 'as_dataframe',
                                'no_dim_coords.txt')))
Example #19
0
 def test_time_mean(self):
     # This test for time-mean fields also tests negative forecast time.
     source_grib = tests.get_data_path(("GRIB", "time_processed", "time_bound.grib2"))
     if self.problem_gribapi_ver:
         result_file = "time_mean.grib_compare.pre1-12-0.txt"
     else:
         result_file = "time_mean.grib_compare.post1-12-0.txt"
     reference_text = tests.get_result_path(("grib_save", result_file))
     self.save_and_compare(source_grib, reference_text)
Example #20
0
 def test_data_frame_nonotonic(self):
     data_frame = pandas.DataFrame([[0, 1, 2, 3, 4],
                                    [5, 6, 7, 8, 9]],
                                   index=[10, 10],
                                   columns=[12, 12, 14, 15, 16])
     self.assertCML(
         iris.pandas.as_cube(data_frame),
         tests.get_result_path(('pandas', 'as_cube',
                                'data_frame_nonotonic.cml')))
Example #21
0
 def test_time_mean(self):
     # This test for time-mean fields also tests negative forecast time.
     # Because the results depend on the presence of our api patch,
     # we currently have results for both a patched and unpatched api.
     # If the api ever allows -ve ft, we should revert to a single result.
     source_grib = tests.get_data_path(("GRIB", "time_processed",
                                        "time_bound.grib2"))
     reference_text = tests.get_result_path(("grib_save",
                                             "time_mean.grib_compare.txt"))
     # TODO: It's not ideal to have grib patch awareness here...
     import unittest
     try:
         self.save_and_compare(source_grib, reference_text)
     except unittest.TestCase.failureException:
         reference_text = tests.get_result_path((
                                     "grib_save",
                                     "time_mean.grib_compare.FT_PATCH.txt"))
         self.save_and_compare(source_grib, reference_text)
Example #22
0
 def test_data_frame_datetime_gregorian(self):
     data_frame = pandas.DataFrame(
         [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]],
         index=[datetime.datetime(2001, 1, 1, 1, 1, 1), datetime.datetime(2002, 2, 2, 2, 2, 2)],
         columns=[10, 11, 12, 13, 14],
     )
     self.assertCML(
         iris.pandas.as_cube(data_frame),
         tests.get_result_path(("pandas", "as_cube", "data_frame_datetime_gregorian.cml")),
     )
Example #23
0
 def test_data_frame_netcdftime_360(self):
     data_frame = pandas.DataFrame(
         [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]],
         index=[netcdftime.datetime(2001, 1, 1, 1, 1, 1), netcdftime.datetime(2002, 2, 2, 2, 2, 2)],
         columns=[10, 11, 12, 13, 14],
     )
     self.assertCML(
         iris.pandas.as_cube(data_frame, calendars={0: cf_units.CALENDAR_360_DAY}),
         tests.get_result_path(("pandas", "as_cube", "data_frame_netcdftime_360.cml")),
     )
Example #24
0
 def test_masked(self):
     data = np.ma.MaskedArray([[0, 1, 2, 3, 4.4], [5, 6, 7, 8, 9]],
                              mask=[[0, 1, 0, 1, 0], [1, 0, 1, 0, 1]])
     cube = Cube(data, long_name="foo")
     data_frame = iris.pandas.as_data_frame(cube)
     self.assertArrayEqual(data_frame, cube.data.astype('f').filled(np.nan))
     self.assertString(
         str(data_frame),
         tests.get_result_path(('pandas', 'as_dataframe',
                                'masked.txt')))
Example #25
0
    def test_pp_save_rules(self):
        # Test pp save rules without user rules.

        #read
        in_filename = tests.get_data_path(('PP', 'simple_pp', 'global.pp'))
        cubes = iris.load(in_filename, callback=itab_callback)

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'simple.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cubes) as temp_pp_path:
            iris.save(cubes, temp_pp_path)
Example #26
0
 def check_dot(self, cube, reference_filename):
     test_string = iris.fileformats.dot.cube_text(cube)
     reference_path = tests.get_result_path(reference_filename)
     if os.path.isfile(reference_path):
         with open(reference_path, 'r') as reference_fh:
             reference = ''.join(reference_fh.readlines())
         self._assert_str_same(reference, test_string, reference_filename, type_comparison_name='DOT files')
     else:
         tests.logger.warning('Creating result file: %s', reference_path)
         with open(reference_path, 'w') as reference_fh:
             reference_fh.writelines(test_string)
Example #27
0
 def test_no_y_coord(self):
     cube = Cube(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]),
                 long_name="foo")
     x_coord = DimCoord([10, 11, 12, 13, 14], long_name="bar")
     cube.add_dim_coord(x_coord, 1)
     data_frame = iris.pandas.as_data_frame(cube)
     self.assertArrayEqual(data_frame, cube.data)
     self.assertString(
         str(data_frame),
         tests.get_result_path(('pandas', 'as_dataframe',
                                'no_y_coord.txt')))
Example #28
0
 def test_data_frame_nonotonic(self):
     data_frame = pandas.DataFrame(
         [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]],
         index=[10, 10],
         columns=[12, 12, 14, 15, 16],
     )
     self.assertCML(
         iris.pandas.as_cube(data_frame),
         tests.get_result_path(
             ("pandas", "as_cube", "data_frame_nonotonic.cml")),
     )
Example #29
0
    def test_no_forecast_time(self):
        cube = stock.lat_lon_cube()
        coord = iris.coords.DimCoord(np.array([24], dtype=np.int64),
                                     standard_name='time',
                                     units='hours since epoch')
        cube.add_aux_coord(coord)
        self.assertCML(cube, ['cube_to_pp', 'no_forecast_time.cml'])

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'no_forecast_time.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cube) as temp_pp_path:
            iris.save(cube, temp_pp_path)
Example #30
0
 def test_data_frame_masked(self):
     data_frame = pandas.DataFrame(
         [[0, float("nan"), 2, 3, 4], [5, 6, 7, np.nan, 9]],
         index=[10, 11],
         columns=[12, 13, 14, 15, 16],
     )
     self.assertCML(
         iris.pandas.as_cube(data_frame),
         tests.get_result_path(
             ("pandas", "as_cube", "data_frame_masked.cml")),
     )
Example #31
0
    def test_no_forecast_time(self):
        cube = stock.lat_lon_cube()
        coord = iris.coords.DimCoord(24,
                                     standard_name='time',
                                     units='hours since epoch')
        cube.add_aux_coord(coord)
        self.assertCML(cube, ['cube_to_pp', 'no_forecast_time.cml'])

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'no_forecast_time.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cube) as temp_pp_path:
            iris.save(cube, temp_pp_path)
Example #32
0
 def test_no_x_coord(self):
     cube = Cube(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]),
                 long_name="foo")
     y_coord = DimCoord([10, 11], long_name="bar")
     cube.add_dim_coord(y_coord, 0)
     data_frame = iris.pandas.as_data_frame(cube)
     self.assertArrayEqual(data_frame, cube.data)
     self.assertString(
         str(data_frame),
         tests.get_result_path(('pandas', 'as_dataframe',
                                'no_x_coord.txt')))
Example #33
0
 def test_data_frame_datetime_gregorian(self):
     data_frame = pandas.DataFrame(
         [[0, 1, 2, 3, 4],
          [5, 6, 7, 8, 9]],
         index=[datetime.datetime(2001, 01, 01, 01, 01, 01),
                datetime.datetime(2002, 02, 02, 02, 02, 02)],
         columns=[10, 11, 12, 13, 14])
     self.assertCML(
         iris.pandas.as_cube(data_frame),
         tests.get_result_path(('pandas', 'as_cube',
                                'data_frame_datetime_gregorian.cml')))
Example #34
0
 def test_data_frame_multidim(self):
     data_frame = pandas.DataFrame(
         [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]],
         index=[0, 1],
         columns=["col_1", "col_2", "col_3", "col_4", "col_5"],
     )
     self.assertCML(
         iris.pandas.as_cube(data_frame),
         tests.get_result_path(
             ("pandas", "as_cube", "data_frame_multidim.cml")),
     )
Example #35
0
    def test_pp_append_lists(self):
        # Test PP append saving - lists of cubes.
        # For each of the first four time-steps in the 4D cube,
        # pull out the bottom two levels.
        cube_4d = stock.realistic_4d()
        cubes = [cube_4d[i, :2, :, :] for i in range(4)]

        reference_txt_path = tests.get_result_path(
            ('cube_to_pp', 'append_multi.txt'))
        with self.cube_save_test(reference_txt_path,
                                 reference_cubes=cubes) as temp_pp_path:
            iris.save(cubes[:2], temp_pp_path)
            iris.save(cubes[2:], temp_pp_path, append=True)

        reference_txt_path = tests.get_result_path(
            ('cube_to_pp', 'replace_multi.txt'))
        with self.cube_save_test(reference_txt_path,
                                 reference_cubes=cubes[2:]) as temp_pp_path:
            iris.save(cubes[:2], temp_pp_path)
            iris.save(cubes[2:], temp_pp_path)
Example #36
0
 def test_data_frame_cftime_360(self):
     data_frame = pandas.DataFrame([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]],
                                   index=[
                                       cftime.datetime(2001, 1, 1, 1, 1, 1),
                                       cftime.datetime(2002, 2, 2, 2, 2, 2)
                                   ],
                                   columns=[10, 11, 12, 13, 14])
     self.assertCML(
         iris.pandas.as_cube(data_frame,
                             calendars={0: cf_units.CALENDAR_360_DAY}),
         tests.get_result_path(
             ('pandas', 'as_cube', 'data_frame_netcdftime_360.cml')))
Example #37
0
    def test_pp_save_rules(self):
        # Test pp save rules without user rules.

        #read
        in_filename = tests.get_data_path(('PP', 'simple_pp', 'global.pp'))
        cubes = iris.load(in_filename, callback=itab_callback)

        reference_txt_path = tests.get_result_path(
            ('cube_to_pp', 'simple.txt'))
        with self.cube_save_test(reference_txt_path,
                                 reference_cubes=cubes) as temp_pp_path:
            iris.save(cubes, temp_pp_path)
Example #38
0
    def test_pp_append_lists(self):
        # Test pp append saving - lists of cubes.
        
        # Locate the first 4 files from the analysis dataset
        names = ['2008120%d1200__qwqu12ff.initanl.pp' % i for i in range(1, 5)]
        prefix = ['PP', 'trui', 'air_temp_init']
        paths = [tests.get_data_path(prefix + [name]) for name in names]

        # Grab the first two levels from each file
        cubes = [iris.load_strict(path, callback=itab_callback) for path in paths]
        cubes = [cube[:2] for cube in cubes]

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'append_multi.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cubes) as temp_pp_path:
            iris.save(cubes[:2], temp_pp_path)
            iris.save(cubes[2:], temp_pp_path, append=True)

        reference_txt_path = tests.get_result_path(('cube_to_pp', 'replace_multi.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cubes[2:]) as temp_pp_path:
            iris.save(cubes[:2], temp_pp_path)
            iris.save(cubes[2:], temp_pp_path)
Example #39
0
    def check_tiff_header(self, geotiff_fh, reference_filename):
        """
        Checks the given tiff file handle's metadata matches the
        reference file contents.

        """
        im = PIL.Image.open(geotiff_fh)
        tiff_header = '\n'.join(
            str((tag, val)) if not isinstance(val, unicode) else "(%s, '%s')" %
            (tag, val) for tag, val in sorted(im.tag.items()))
        reference_path = tests.get_result_path(reference_filename)
        self.assertString(tiff_header, reference_path)
Example #40
0
 def test_name2_field(self):
     filepath = tests.get_data_path(('NAME', 'NAMEII_field.txt'))
     name_cubes = iris.load(filepath)
     for i, name_cube in enumerate(name_cubes):
         with self.temp_filename('.grib2') as temp_filename:
             iris.save(name_cube, temp_filename)
             grib_cube = iris.load_cube(temp_filename, callback=name_cb)
             self.check_common(name_cube, grib_cube)
             self.assertCML(
                 grib_cube, tests.get_result_path(
                     ('integration', 'name_grib', 'NAMEII',
                      '{}_{}.cml'.format(i, name_cube.name()))))
Example #41
0
 def test_series_datetime_gregorian(self):
     series = pandas.Series(
         [0, 1, 2, 3, 4],
         index=[datetime.datetime(2001, 1, 1, 1, 1, 1),
                datetime.datetime(2002, 2, 2, 2, 2, 2),
                datetime.datetime(2003, 3, 3, 3, 3, 3),
                datetime.datetime(2004, 4, 4, 4, 4, 4),
                datetime.datetime(2005, 5, 5, 5, 5, 5)])
     self.assertCML(
         iris.pandas.as_cube(series),
         tests.get_result_path(('pandas', 'as_cube',
                                'series_datetime_gregorian.cml')))
Example #42
0
 def test_rotated_latlon(self):
     source_grib = tests.get_data_path(
         ("GRIB", "rotated_nae_t", "sensible_pole.grib2"))
     if self.problem_gribapi_ver:
         result_file = "rotated_latlon.grib_compare.pre1-12-0.txt"
     else:
         result_file = "rotated_latlon.grib_compare.post1-12-0.txt"
     reference_text = tests.get_result_path(("grib_save", result_file))
     # TODO: Investigate small change in test result:
     #       long [iDirectionIncrement]: [109994] != [109993]
     #       Consider the change in dx_dy() to "InDegrees" too.
     self.save_and_compare(source_grib, reference_text)
Example #43
0
 def test_time_gregorian(self):
     cube = Cube(np.array([0, 1, 2, 3, 4]), long_name="ts")
     time_coord = DimCoord([0, 100.1, 200.2, 300.3, 400.4],
                           long_name="time",
                           units="days since 2000-01-01 00:00")
     cube.add_dim_coord(time_coord, 0)
     series = iris.pandas.as_series(cube)
     self.assertArrayEqual(series, cube.data)
     self.assertString(
         str(series),
         tests.get_result_path(
             ('pandas', 'as_series', 'time_gregorian.txt')))
Example #44
0
    def test_name3_field(self):
        filepath = tests.get_data_path(('NAME', 'NAMEIII_field.txt'))
        name_cubes = iris.load(filepath)
        for i, name_cube in enumerate(name_cubes):
            with self.temp_filename('.grib2') as temp_filename:
                iris.save(name_cube, temp_filename)
                grib_cube = iris.load_cube(temp_filename, callback=name_cb)

                self.check_common(name_cube, grib_cube)
                self.assertCML(
                    grib_cube, tests.get_result_path(
                        ('integration', 'name_grib', 'NAMEIII',
                         '{}_{}.cml'.format(i, name_cube.name()))))
Example #45
0
 def test_series_netcdftime_360(self):
     series = pandas.Series(
         [0, 1, 2, 3, 4],
         index=[netcdftime.datetime(2001, 1, 1, 1, 1, 1),
                netcdftime.datetime(2002, 2, 2, 2, 2, 2),
                netcdftime.datetime(2003, 3, 3, 3, 3, 3),
                netcdftime.datetime(2004, 4, 4, 4, 4, 4),
                netcdftime.datetime(2005, 5, 5, 5, 5, 5)])
     self.assertCML(
         iris.pandas.as_cube(series,
                             calendars={0: cf_units.CALENDAR_360_DAY}),
         tests.get_result_path(('pandas', 'as_cube',
                                'series_netcdfimte_360.cml')))
Example #46
0
 def test_time_360(self):
     cube = Cube(np.array([0, 1, 2, 3, 4]), long_name="ts")
     time_unit = iris.unit.Unit("days since 2000-01-01 00:00",
                                calendar=iris.unit.CALENDAR_360_DAY)
     time_coord = DimCoord([0, 100.1, 200.2, 300.3, 400.4],
                           long_name="time",
                           units=time_unit)
     cube.add_dim_coord(time_coord, 0)
     series = iris.pandas.as_series(cube)
     self.assertArrayEqual(series, cube.data)
     self.assertString(
         str(series),
         tests.get_result_path(('pandas', 'as_series', 'time_360.txt')))
Example #47
0
    def test_series_object(self):
        class Thing(object):
            def __repr__(self):
                return "A Thing"

        series = pandas.Series(
            [0, 1, 2, 3, 4],
            index=[Thing(), Thing(),
                   Thing(), Thing(),
                   Thing()])
        self.assertCML(
            iris.pandas.as_cube(series),
            tests.get_result_path(('pandas', 'as_cube', 'series_object.cml')))
Example #48
0
    def check_tiff_header(self, geotiff_fh, reference_filename):
        """
        Checks the given tiff file handle's metadata matches the
        reference file contents.

        """
        im = PIL.Image.open(geotiff_fh)
        tiff_header = '\n'.join(str((tag, val))
                                for tag, val in sorted(im.tag.items()))

        reference_path = tests.get_result_path(reference_filename)

        self._check_same(tiff_header, reference_path, reference_filename,
                         type_comparison_name='Tiff header')
Example #49
0
 def test_time_360(self):
     cube = Cube(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]),
                 long_name="ts")
     time_unit = iris.unit.Unit("days since 2000-01-01 00:00",
                                calendar=iris.unit.CALENDAR_360_DAY)
     time_coord = DimCoord([100.1, 200.2],
                           long_name="time",
                           units=time_unit)
     cube.add_dim_coord(time_coord, 0)
     data_frame = iris.pandas.as_data_frame(cube)
     self.assertArrayEqual(data_frame, cube.data)
     self.assertString(
         str(data_frame),
         tests.get_result_path(('pandas', 'as_dataframe', 'time_360.txt')))
Example #50
0
 def test_data_frame_datetime_gregorian(self):
     data_frame = pandas.DataFrame(
         [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]],
         index=[
             datetime.datetime(2001, 1, 1, 1, 1, 1),
             datetime.datetime(2002, 2, 2, 2, 2, 2),
         ],
         columns=[10, 11, 12, 13, 14],
     )
     self.assertCML(
         iris.pandas.as_cube(data_frame),
         tests.get_result_path(
             ("pandas", "as_cube", "data_frame_datetime_gregorian.cml")),
     )
Example #51
0
    def test_series_object(self):
        class Thing:
            def __repr__(self):
                return "A Thing"

        series = pandas.Series(
            [0, 1, 2, 3, 4],
            index=[Thing(), Thing(),
                   Thing(), Thing(),
                   Thing()],
        )
        self.assertCML(
            iris.pandas.as_cube(series),
            tests.get_result_path(("pandas", "as_cube", "series_object.cml")),
        )
Example #52
0
 def test_series_datetime_gregorian(self):
     series = pandas.Series(
         [0, 1, 2, 3, 4],
         index=[
             datetime.datetime(2001, 1, 1, 1, 1, 1),
             datetime.datetime(2002, 2, 2, 2, 2, 2),
             datetime.datetime(2003, 3, 3, 3, 3, 3),
             datetime.datetime(2004, 4, 4, 4, 4, 4),
             datetime.datetime(2005, 5, 5, 5, 5, 5),
         ],
     )
     self.assertCML(
         iris.pandas.as_cube(series),
         tests.get_result_path(
             ("pandas", "as_cube", "series_datetime_gregorian.cml")),
     )
Example #53
0
 def test_series_cftime_360(self):
     series = pandas.Series(
         [0, 1, 2, 3, 4],
         index=[
             cftime.datetime(2001, 1, 1, 1, 1, 1),
             cftime.datetime(2002, 2, 2, 2, 2, 2),
             cftime.datetime(2003, 3, 3, 3, 3, 3),
             cftime.datetime(2004, 4, 4, 4, 4, 4),
             cftime.datetime(2005, 5, 5, 5, 5, 5),
         ],
     )
     self.assertCML(
         iris.pandas.as_cube(series,
                             calendars={0: cf_units.CALENDAR_360_DAY}),
         tests.get_result_path(
             ("pandas", "as_cube", "series_netcdfimte_360.cml")),
     )
Example #54
0
    def test_name3_field(self):
        filepath = tests.get_data_path(("NAME", "NAMEIII_field.txt"))
        name_cubes = iris.load(filepath)
        for i, name_cube in enumerate(name_cubes):
            with self.temp_filename(".grib2") as temp_filename:
                iris.save(name_cube, temp_filename)
                grib_cube = iris.load_cube(temp_filename, callback=name_cb)

                self.check_common(name_cube, grib_cube)
                self.assertCML(
                    grib_cube,
                    tests.get_result_path((
                        "integration",
                        "name_grib",
                        "NAMEIII",
                        "{}_{}.cml".format(i, name_cube.name()),
                    )),
                )
Example #55
0
    def test_no_forecast_period(self):
        cube = stock.lat_lon_cube()
        # Add a bounded scalar time coord and a forecast_reference_time.
        time_coord = iris.coords.DimCoord(
            10.958333, standard_name='time',
            units='days since 2013-05-10 12:00',
            bounds=[10.916667, 11.0])
        cube.add_aux_coord(time_coord)
        forecast_reference_time = iris.coords.DimCoord(
            2.0, standard_name='forecast_reference_time',
            units='weeks since 2013-05-07')
        cube.add_aux_coord(forecast_reference_time)

        self.assertCML(cube, ['cube_to_pp', 'no_forecast_period.cml'])
        reference_txt_path = tests.get_result_path(('cube_to_pp',
                                                    'no_forecast_period.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=cube) as \
                temp_pp_path:
            iris.save(cube, temp_pp_path)
Example #56
0
    def test_save_and_merge(self):
        cube = self._load_3d_cube()

        # extract the 2d field that has SOME missing values
        masked_slice = cube[0]
        masked_slice.data.fill_value = 123456
        
        # test saving masked data
        reference_txt_path = tests.get_result_path(('cdm', 'masked_save_pp.txt'))
        with self.cube_save_test(reference_txt_path, reference_cubes=masked_slice) as temp_pp_path:
            iris.save(masked_slice, temp_pp_path)
        
            # test merge keeps the mdi we just saved
            cube1 = iris.load_cube(temp_pp_path)
            cube2 = cube1.copy()
            # make cube1 and cube2 differ on a scalar coord, to make them mergeable into a 3d cube
            cube2.coord("pressure").points[0] = 1001.0
            merged_cubes = iris.cube.CubeList([cube1, cube2]).merge()
            self.assertEqual(len(merged_cubes), 1, "expected a single merged cube")
            merged_cube = merged_cubes[0]
            self.assertEqual(merged_cube.data.fill_value, 123456)
Example #57
0
    def check_pp(self, pp_fields, reference_filename):
        """
        Checks the given iterable of PPField objects matches the reference file, or creates the
        reference file if it doesn't exist.

        """
        # turn the generator into a list 
        pp_fields = list(pp_fields)
        
        # Load deferred data for all of the fields (but don't do anything with it)
        for pp_field in pp_fields:
            pp_field.data
            
        test_string = str(pp_fields)
        reference_path = tests.get_result_path(reference_filename)
        if os.path.isfile(reference_path):
            with open(reference_path, 'r') as reference_fh:
                reference = ''.join(reference_fh.readlines())
            self._assert_str_same(reference+'\n', test_string+'\n', reference_filename, type_comparison_name='PP files')
        else:
            with open(reference_path, 'w') as reference_fh:
                reference_fh.writelines(test_string)
Example #58
0
    def test_user_pp_save_rules(self):
        # Test pp save rules with user rules.
        
        #create a user rules file
        user_rules_filename = iris.util.create_temp_filename(suffix='.txt')
        try:
            with open(user_rules_filename, "wt") as user_rules_file:
                user_rules_file.write("IF\ncm.standard_name == 'air_temperature'\nTHEN\npp.lbuser[3] = 9222")
            iris.fileformats.pp.add_save_rules(user_rules_filename)
            try:
                #read pp
                in_filename = tests.get_data_path(('PP', 'simple_pp', 'global.pp'))
                cubes = iris.load(in_filename, callback=itab_callback)

                reference_txt_path = tests.get_result_path(('cube_to_pp', 'user_rules.txt'))
                with self.cube_save_test(reference_txt_path, reference_cubes=cubes) as temp_pp_path:
                    iris.save(cubes, temp_pp_path)

            finally:
                iris.fileformats.pp.reset_save_rules()
        finally:
            os.remove(user_rules_filename)
Example #59
0
    def test_no_forecast_period(self):
        cube = stock.lat_lon_cube()
        # Add a bounded scalar time coord and a forecast_reference_time.
        time_coord = iris.coords.DimCoord(
            10.958333,
            standard_name="time",
            units="days since 2013-05-10 12:00",
            bounds=[10.916667, 11.0],
        )
        cube.add_aux_coord(time_coord)
        forecast_reference_time = iris.coords.DimCoord(
            2.0,
            standard_name="forecast_reference_time",
            units="weeks since 2013-05-07",
        )
        cube.add_aux_coord(forecast_reference_time)

        self.assertCML(cube, ["cube_to_pp", "no_forecast_period.cml"])
        reference_txt_path = tests.get_result_path(
            ("cube_to_pp", "no_forecast_period.txt"))
        with self.cube_save_test(reference_txt_path,
                                 reference_cubes=cube) as temp_pp_path:
            iris.save(cube, temp_pp_path)