def test_grib_get_data():
gid = eccodes.codes_grib_new_from_samples("GRIB1")
ggd = eccodes.codes_grib_get_data(gid)
assert len(ggd) == 65160
eccodes.codes_release(gid)
gid = eccodes.codes_grib_new_from_samples("reduced_gg_pl_32_grib2")
ggd = eccodes.codes_grib_get_data(gid)
assert len(ggd) == 6114
elem1 = ggd[0] # This is a 'Bunch' derived off dict
assert "lat" in elem1.keys()
assert "lon" in elem1.keys()
assert "value" in elem1.keys()
eccodes.codes_release(gid)
def test_grib_read():
gid = eccodes.codes_grib_new_from_samples("regular_ll_sfc_grib1")
assert eccodes.codes_get(gid, "Ni") == 16
assert eccodes.codes_get(gid, "Nj") == 31
assert eccodes.codes_get(gid, "const") == 1
assert eccodes.codes_get(gid, "centre", str) == "ecmf"
assert eccodes.codes_get(gid, "packingType", str) == "grid_simple"
assert eccodes.codes_get(gid, "gridType", str) == "regular_ll"
eccodes.codes_release(gid)
gid = eccodes.codes_grib_new_from_samples("sh_ml_grib2")
assert eccodes.codes_get(gid, "const") == 0
assert eccodes.codes_get(gid, "gridType", str) == "sh"
assert eccodes.codes_get(gid, "typeOfLevel", str) == "hybrid"
assert eccodes.codes_get_long(gid, "avg") == 185
eccodes.codes_release(gid)
def test_grib_ecc_1042():
# Issue ECC-1042: Python3 interface writes integer arrays incorrectly
gid = eccodes.codes_grib_new_from_samples("regular_ll_sfc_grib2")
# Trying write with inferred dtype
write_vals = np.array([1, 2, 3])
eccodes.codes_set_values(gid, write_vals)
read_vals = eccodes.codes_get_values(gid)
length = len(read_vals)
assert read_vals[0] == 1
assert read_vals[length - 1] == 3
# Trying write with explicit dtype
write_vals = np.array(
[
1,
2,
3,
],
dtype=float,
)
eccodes.codes_set_values(gid, write_vals)
read_vals = eccodes.codes_get_values(gid)
assert read_vals[0] == 1
assert read_vals[length - 1] == 3
eccodes.codes_release(gid)
def test_grib_keys_iterator_skip():
gid = eccodes.codes_grib_new_from_samples("reduced_gg_pl_1280_grib1")
iterid = eccodes.codes_keys_iterator_new(gid, "ls")
count = 0
eccodes.codes_skip_computed(iterid)
# codes_skip_coded(iterid)
eccodes.codes_skip_edition_specific(iterid)
eccodes.codes_skip_duplicates(iterid)
eccodes.codes_skip_read_only(iterid)
eccodes.codes_skip_function(iterid)
while eccodes.codes_keys_iterator_next(iterid):
keyname = eccodes.codes_keys_iterator_get_name(iterid)
keyval = eccodes.codes_get_string(gid, keyname)
assert len(keyval) > 0
count += 1
# centre, level and dataType
assert count == 3
eccodes.codes_keys_iterator_delete(iterid)
iterid = eccodes.codes_keys_iterator_new(gid)
count = 0
eccodes.codes_skip_coded(iterid)
while eccodes.codes_keys_iterator_next(iterid):
count += 1
assert count == 141
eccodes.codes_keys_iterator_delete(iterid)
eccodes.codes_release(gid)
def test_grib_dump(tmp_path):
gid = eccodes.codes_grib_new_from_samples("GRIB2")
p = tmp_path / "dump.txt"
with open(p, "w") as fout:
eccodes.codes_dump(gid, fout)
eccodes.codes_dump(gid, fout, "debug")
eccodes.codes_release(gid)
def test_grib_codes_set_missing():
gid = eccodes.codes_grib_new_from_samples("reduced_rotated_gg_ml_grib2")
eccodes.codes_set(gid, "typeOfFirstFixedSurface", "sfc")
eccodes.codes_set_missing(gid, "scaleFactorOfFirstFixedSurface")
eccodes.codes_set_missing(gid, "scaledValueOfFirstFixedSurface")
assert eccodes.eccodes.codes_is_missing(gid,
"scaleFactorOfFirstFixedSurface")
def test_grib_write(tmpdir):
gid = eccodes.codes_grib_new_from_samples("GRIB2")
eccodes.codes_set(gid, "backgroundProcess", 44)
output = tmpdir.join("test_grib_write.grib")
with open(str(output), "wb") as fout:
eccodes.codes_write(gid, fout)
eccodes.codes_release(gid)
def test_grib_float_array():
gid = eccodes.codes_grib_new_from_samples("regular_ll_sfc_grib2")
for ftype in (float, np.float16, np.float32, np.float64):
values = np.ones((100000, ), ftype)
eccodes.codes_set_array(gid, "values", values)
assert (eccodes.codes_get_values(gid) == 1.0).all()
eccodes.codes_set_values(gid, values)
assert (eccodes.codes_get_values(gid) == 1.0).all()
def test_grib_set_error():
gid = eccodes.codes_grib_new_from_samples("regular_ll_sfc_grib1")
with pytest.raises(TypeError):
eccodes.codes_set_long(gid, "centre", "kwbc")
with pytest.raises(TypeError):
eccodes.codes_set_double(gid, "centre", "kwbc")
with pytest.raises(eccodes.CodesInternalError):
eccodes.codes_set(gid, "centre", [])
def test_codes_get_native_type():
gid = eccodes.codes_grib_new_from_samples("GRIB2")
assert eccodes.codes_get_native_type(gid, "date") is int
assert eccodes.codes_get_native_type(gid, "referenceValue") is float
assert eccodes.codes_get_native_type(gid, "stepType") is str
assert eccodes.codes_get_native_type(gid, "section_1") is None
with pytest.raises(eccodes.InvalidGribError):
eccodes.codes_get_native_type(0, "aKey")
def test_grib_clone():
gid = eccodes.codes_grib_new_from_samples("GRIB2")
clone = eccodes.codes_clone(gid)
assert gid
assert clone
assert eccodes.codes_get(clone, "identifier") == "GRIB"
assert eccodes.codes_get(clone, "totalLength") == 179
eccodes.codes_release(gid)
eccodes.codes_release(clone)
def test_grib_get_array():
gid = eccodes.codes_grib_new_from_samples("reduced_gg_pl_160_grib1")
pl = eccodes.codes_get_array(gid, "pl")
assert pl[0] == 18
pli = eccodes.codes_get_array(gid, "pl", int)
assert np.array_equal(pl, pli)
pls = eccodes.codes_get_array(gid, "centre", str)
assert pls == ["ecmf"]
eccodes.codes_release(gid)
def test_grib_uuid_get_set():
# ECC-1167
gid = eccodes.codes_grib_new_from_samples("GRIB2")
eccodes.codes_set(gid, "gridType", "unstructured_grid")
uuid = eccodes.codes_get_string(gid, "uuidOfHGrid")
assert uuid == "00000000000000000000000000000000"
eccodes.codes_set_string(gid, "uuidOfHGrid",
"DEfdBEef10203040b00b1e50001100FF")
uuid = eccodes.codes_get_string(gid, "uuidOfHGrid")
assert uuid == "defdbeef10203040b00b1e50001100ff"
eccodes.codes_release(gid)
def test_grib_get_double_elements():
gid = eccodes.codes_grib_new_from_samples("gg_sfc_grib1")
values = eccodes.codes_get_values(gid)
num_vals = len(values)
indexes = [0, int(num_vals / 2), num_vals - 1]
elems = eccodes.codes_get_double_elements(gid, "values", indexes)
assert math.isclose(elems[0], 259.6935, abs_tol=0.001)
assert math.isclose(elems[1], 299.9064, abs_tol=0.001)
assert math.isclose(elems[2], 218.8146, abs_tol=0.001)
elems2 = eccodes.codes_get_elements(gid, "values", indexes)
assert elems == elems2
def test_grib_ecc_1007():
# Issue ECC-1007: Python3 interface cannot write large arrays
gid = eccodes.codes_grib_new_from_samples("regular_ll_sfc_grib2")
numvals = 1501 * 1501
values = np.zeros((numvals, ))
values[0] = 12 # Make sure it's not a constant field
eccodes.codes_set_values(gid, values)
maxv = eccodes.eccodes.codes_get(gid, "max")
minv = eccodes.eccodes.codes_get(gid, "min")
assert minv == 0
assert maxv == 12
eccodes.codes_release(gid)
def test_grib_keys_iterator():
gid = eccodes.codes_grib_new_from_samples("reduced_gg_pl_1280_grib1")
iterid = eccodes.eccodes.codes_keys_iterator_new(gid, "ls")
count = 0
while eccodes.codes_keys_iterator_next(iterid):
keyname = eccodes.codes_keys_iterator_get_name(iterid)
keyval = eccodes.codes_get_string(gid, keyname)
assert len(keyval) > 0
count += 1
assert count == 10
eccodes.codes_keys_iterator_rewind(iterid)
eccodes.eccodes.codes_keys_iterator_delete(iterid)
eccodes.codes_release(gid)
def cli(output_file_path):
handle = eccodes.codes_grib_new_from_samples('regular_ll_pl_grib2')
value_size = eccodes.codes_get_size(handle, 'values')
values = []
for i in range(0, value_size):
values.append(i)
eccodes.codes_set_values(handle, values)
with open(output_file_path, 'wb') as output_file:
eccodes.codes_write(handle, output_file)
eccodes.codes_release(handle)
def test_grib_set_key_vals():
gid = eccodes.codes_grib_new_from_samples("GRIB2")
# String
eccodes.codes_set_key_vals(gid, "shortName=z,dataDate=20201112")
assert eccodes.codes_get(gid, "shortName", str) == "z"
assert eccodes.codes_get(gid, "date", int) == 20201112
# List
eccodes.codes_set_key_vals(gid, ["shortName=2t", "dataDate=20191010"])
assert eccodes.codes_get(gid, "shortName", str) == "2t"
assert eccodes.codes_get(gid, "date", int) == 20191010
# Dictionary
eccodes.codes_set_key_vals(gid, {"shortName": "msl", "dataDate": 20181010})
assert eccodes.codes_get(gid, "shortName", str) == "msl"
assert eccodes.codes_get(gid, "date", int) == 20181010
eccodes.codes_release(gid)
def test_new_from_message():
gid = eccodes.codes_grib_new_from_samples("sh_sfc_grib1")
message = eccodes.codes_get_message(gid)
eccodes.codes_release(gid)
assert len(message) == 9358
newgid = eccodes.codes_new_from_message(message)
assert eccodes.codes_get(newgid, "packingType") == "spectral_complex"
assert eccodes.codes_get(newgid, "gridType") == "sh"
eccodes.codes_release(newgid)
# This time read from a string rather than a file
metar_str = "METAR LQMO 022350Z 09003KT 6000 FEW010 SCT035 BKN060 08/08 Q1003="
newgid = eccodes.codes_new_from_message(metar_str)
cccc = eccodes.codes_get(newgid, "CCCC")
assert cccc == "LQMO"
eccodes.codes_release(newgid)
def test_grib_geoiterator():
gid = eccodes.codes_grib_new_from_samples("reduced_gg_pl_256_grib2")
iterid = eccodes.codes_grib_iterator_new(gid, 0)
i = 0
while 1:
result = eccodes.codes_grib_iterator_next(iterid)
if not result:
break
[lat, lon, value] = result
assert -90.0 < lat < 90.00
assert 0.0 <= lon < 360.0
assert math.isclose(value, 1.0, abs_tol=0.001)
i += 1
assert i == 348528
eccodes.codes_grib_iterator_delete(iterid)
eccodes.codes_release(gid)
def test_grib_multi_field_write(tmpdir):
# Note: eccodes.codes_grib_multi_new() calls codes_grib_multi_support_on()
# hence the 'finally' block
try:
gid = eccodes.codes_grib_new_from_samples("GRIB2")
mgid = eccodes.codes_grib_multi_new()
section_num = 4
for step in range(12, 132, 12):
eccodes.codes_set(gid, "step", step)
eccodes.codes_grib_multi_append(gid, section_num, mgid)
output = tmpdir.join("test_grib_multi_field_write.grib2")
with open(str(output), "wb") as fout:
eccodes.codes_grib_multi_write(mgid, fout)
eccodes.codes_grib_multi_release(mgid)
eccodes.codes_release(gid)
finally:
eccodes.codes_grib_multi_support_off()
def test_grib_nearest2():
if "codes_grib_nearest_new" not in dir(eccodes):
return
gid = eccodes.codes_grib_new_from_samples("gg_sfc_grib2")
lat, lon = 40, 20
flags = eccodes.CODES_GRIB_NEAREST_SAME_GRID | eccodes.CODES_GRIB_NEAREST_SAME_POINT
nid = eccodes.codes_grib_nearest_new(gid)
assert nid > 0
nearest = eccodes.codes_grib_nearest_find(nid, gid, lat, lon, flags)
assert len(nearest) == 4
expected_indexes = (2679, 2678, 2517, 2516)
returned_indexes = (
nearest[0].index,
nearest[1].index,
nearest[2].index,
nearest[3].index,
)
assert sorted(expected_indexes) == sorted(returned_indexes)
assert math.isclose(nearest[0].value, 295.22085, abs_tol=0.0001)
assert math.isclose(nearest[2].distance, 24.16520, abs_tol=0.0001)
eccodes.codes_release(gid)
eccodes.codes_grib_nearest_delete(nid)
def test_grib_nearest():
gid = eccodes.codes_grib_new_from_samples("reduced_gg_ml_grib2")
lat, lon = 30, -20
nearest = eccodes.codes_grib_find_nearest(gid, lat, lon)[0]
assert nearest.index == 1770
lat, lon = 10, 0
nearest = eccodes.codes_grib_find_nearest(gid, lat, lon)[0]
assert nearest.index == 2545
lat, lon = 10, 20
nearest = eccodes.codes_grib_find_nearest(gid, lat, lon, False, 4)
expected_indexes = (2553, 2552, 2425, 2424)
returned_indexes = (
nearest[0].index,
nearest[1].index,
nearest[2].index,
nearest[3].index,
)
assert sorted(expected_indexes) == sorted(returned_indexes)
# Cannot do more than 4 nearest neighbours
with pytest.raises(ValueError):
eccodes.codes_grib_find_nearest(gid, lat, lon, False, 5)
eccodes.codes_release(gid)
def test_grib_set_string():
gid = eccodes.codes_grib_new_from_samples("regular_gg_sfc_grib2")
eccodes.codes_set(gid, "gridType", "reduced_gg")
eccodes.codes_release(gid)
def test_codes_is_defined():
gid = eccodes.codes_grib_new_from_samples("sh_sfc_grib1")
assert eccodes.codes_is_defined(gid, "JS")
def test_grib_get_error():
gid = eccodes.codes_grib_new_from_samples("regular_ll_sfc_grib2")
# Note: AssertionError can be raised when type checks are enabled
with pytest.raises((ValueError, AssertionError)):
eccodes.codes_get(gid, None)
def test_grib_get_message_size():
gid = eccodes.codes_grib_new_from_samples("GRIB2")
assert eccodes.codes_get_message_size(gid) == 179
def test_grib_get_message_offset():
gid = eccodes.codes_grib_new_from_samples("GRIB2")
assert eccodes.codes_get_message_offset(gid) == 0
def test_grib_get_double_element():
gid = eccodes.codes_grib_new_from_samples("gg_sfc_grib2")
elem = eccodes.codes_get_double_element(gid, "values", 1)
assert math.isclose(elem, 259.9865, abs_tol=0.001)
eccodes.codes_release(gid)