imap-processing 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

imap_processing/tests/ena_maps/test_spatial_utils.py

@@ -7,7 +7,7 @@ import pytest
 from imap_processing.ena_maps.utils import spatial_utils
 
 # Parameterize with spacings (degrees here):
-valid_spacings = [0.25, 0.5, 1, 5, 10, 20]
+valid_spacings = [0.25, 0.5, 1, 5, 6, 6.666666666666667, 10, 20]
 invalid_spacings = [0, -1, 11]
 invalid_spacings_match_str = [
     "Spacing must be positive valued, non-zero.",

imap_processing/tests/glows/conftest.py

@@ -1,4 +1,3 @@
-from functools import reduce
 from pathlib import Path
 
 import pytest
@@ -10,13 +9,13 @@ from imap_processing.glows.l1b.glows_l1b import glows_l1b
 from imap_processing.glows.l2.glows_l2 import glows_l2
 
 
-@pytest.fixture()
+@pytest.fixture
 def packet_path():
     current_directory = Path(__file__).parent
     return current_directory / "validation_data" / "glows_test_packet_20110921_v01.pkts"
 
 
-@pytest.fixture()
+@pytest.fixture
 def decom_test_data(packet_path):
     """Read test data from file"""
 
@@ -24,31 +23,28 @@ def decom_test_data(packet_path):
     return data_packet_list
 
 
-@pytest.fixture()
+@pytest.fixture
 def l1a_test_data(decom_test_data):
     hist_l1a = []
 
     for hist in decom_test_data[0]:
         hist_l1a.append(HistogramL1A(hist))
 
-    de_l1a_dict = process_de_l0(decom_test_data[1])
-
-    # Flatten the dictionary to one list of DE values
-    de_l1a = reduce(list.__add__, [value for value in de_l1a_dict.values()])
+    de_l1a = process_de_l0(decom_test_data[1])
 
     return hist_l1a, de_l1a
 
 
-@pytest.fixture()
+@pytest.fixture
 def l1a_dataset(packet_path):
-    return glows_l1a(packet_path, "v001")
+    return glows_l1a(packet_path)
 
 
-@pytest.fixture()
+@pytest.fixture
 def l1b_hist_dataset(l1a_dataset):
-    return glows_l1b(l1a_dataset[1], "v001")
+    return glows_l1b(l1a_dataset[0])
 
 
-@pytest.fixture()
+@pytest.fixture
 def l2_hist_dataset(l1b_datasets):
-    return glows_l2(l1b_datasets, "v001")
+    return glows_l2(l1b_datasets)

imap_processing/tests/glows/test_glows_decom.py

@@ -45,14 +45,14 @@ def test_glows_hist_data(decom_test_data):
         "ELVAR": 0,
         "EVENTS": 95978,
     }
-    for key in expected_data.keys():
-        assert getattr(decom_test_data[0][0], key) == expected_data[key]
+    for key, expected_val in expected_data.items():
+        assert getattr(decom_test_data[0][0], key) == expected_val
 
 
 def test_glows_de_data(decom_test_data):
     expected_data = {"MET": 54233694, "SEC": 54232338, "LEN": 1, "SEQ": 0}
-    for key in expected_data.keys():
-        assert getattr(decom_test_data[1][0], key) == expected_data[key]
+    for key, expected_val in expected_data.items():
+        assert getattr(decom_test_data[1][0], key) == expected_val
 
 
 def test_bad_header():

imap_processing/tests/glows/test_glows_l1a_cdf.py

@@ -1,39 +1,18 @@
 import dataclasses
-from functools import reduce
 
 import numpy as np
-import pytest
 
-from imap_processing.glows.l0 import decom_glows
 from imap_processing.glows.l1a.glows_l1a import (
     create_glows_attr_obj,
     generate_de_dataset,
     generate_histogram_dataset,
-    process_de_l0,
 )
-from imap_processing.glows.l1a.glows_l1a_data import HistogramL1A
 from imap_processing.glows.utils.constants import TimeTuple
 
 
-@pytest.fixture()
-def l1a_data(packet_path):
-    """Read test data from file"""
-
-    histogram_l0, de_l0 = decom_glows.decom_packets(packet_path)
-
-    histogram_l1a = [HistogramL1A(hist) for hist in histogram_l0]
-
-    de_l1a_dict = process_de_l0(de_l0)
-
-    # Flatten the dictionary to one list of DE values
-    de_l1a = reduce(list.__add__, [value for value in de_l1a_dict.values()])
-
-    return (histogram_l1a, de_l1a)
-
-
-def test_generate_histogram_dataset(l1a_data):
-    histogram_l1a, _ = l1a_data
-    glows_attrs = create_glows_attr_obj("v001")
+def test_generate_histogram_dataset(l1a_test_data):
+    histogram_l1a, _ = l1a_test_data
+    glows_attrs = create_glows_attr_obj()
     dataset = generate_histogram_dataset(histogram_l1a, glows_attrs)
 
     assert (dataset["histogram"].data[0] == histogram_l1a[0].histogram).all()
@@ -62,9 +41,9 @@ def test_generate_histogram_dataset(l1a_data):
         assert (dataset["histogram"].data[i] == histogram_l1a[i].histogram).all()
 
 
-def test_generate_de_dataset(l1a_data):
-    _, de_l1a = l1a_data
-    glows_attrs = create_glows_attr_obj("v001")
+def test_generate_de_dataset(l1a_test_data):
+    _, de_l1a = l1a_test_data
+    glows_attrs = create_glows_attr_obj()
     dataset = generate_de_dataset(de_l1a, glows_attrs)
     assert len(dataset["epoch"].values) == len(de_l1a)
 

imap_processing/tests/glows/test_glows_l1a_data.py

@@ -18,14 +18,14 @@ from imap_processing.glows.utils.constants import DirectEvent, GlowsConstants, T
 from imap_processing.spice.time import met_to_ttj2000ns
 
 
-@pytest.fixture()
+@pytest.fixture
 def histogram_test_data(decom_test_data):
     histl0 = decom_test_data[0][0]
     hist = HistogramL1A(histl0)
     return hist
 
 
-@pytest.fixture()
+@pytest.fixture
 def de_test_data(decom_test_data):
     del0 = decom_test_data[1][0]
     de = DirectEventL1A(del0)
@@ -41,19 +41,17 @@ def test_histogram_list(histogram_test_data, decom_test_data):
 
 
 def test_histogram_obs_day(packet_path):
-    l1a = glows_l1a(packet_path, "v001")
+    l1a = glows_l1a(packet_path)
 
-    assert len(l1a) == 3
+    assert len(l1a) == 2
 
     assert "hist" in l1a[0].attrs["Logical_source"]
-    assert "hist" in l1a[1].attrs["Logical_source"]
 
     # Numbers pulled from the validation data.
     # this test assumes that the "is_night" flag switching from true to false is the
     # start of the observation day.
 
     assert np.array_equal(l1a[0]["imap_start_time"].data[0], 54232215.0)
-    assert np.array_equal(l1a[1]["imap_start_time"].data[0], 54232455.0)
 
 
 def test_histogram_attributes(histogram_test_data):
@@ -270,7 +268,7 @@ def test_combine_direct_events(decom_test_data):
     de1 = DirectEventL1A(de0_first)
     assert not de1.direct_events
     if not de1.direct_events:
-        de1.append(de0_second)
+        de1.merge_de_packets(de0_second)
 
     assert de1.direct_events
 
@@ -293,7 +291,7 @@ def test_combine_direct_events_with_missing(decom_test_data):
     de1 = DirectEventL1A(de0_first)
     assert not de1.direct_events
     if not de1.direct_events:
-        de1.append(de0_second)
+        de1.merge_de_packets(de0_second)
 
     assert de1.direct_events
     # Missing one value

imap_processing/tests/glows/test_glows_l1b.py

@@ -15,7 +15,7 @@ from imap_processing.glows.l1b.glows_l1b_data import (
 )
 
 
-@pytest.fixture()
+@pytest.fixture
 def hist_dataset():
     variables = {
         "flight_software_version": np.zeros((20,)),
@@ -64,13 +64,13 @@ def hist_dataset():
         coords={"epoch": epoch, "bins": bins},
     )
 
-    for var in variables:
-        ds[var] = xr.DataArray(variables[var], dims=["epoch"], coords={"epoch": epoch})
+    for var, data in variables.items():
+        ds[var] = xr.DataArray(data, dims=["epoch"], coords={"epoch": epoch})
 
     return ds
 
 
-@pytest.fixture()
+@pytest.fixture
 def de_dataset():
     variables = {
         "seq_count_in_pkts_file": np.zeros((20,)),
@@ -139,13 +139,13 @@ def de_dataset():
         },
     )
 
-    for var in variables:
-        ds[var] = xr.DataArray(variables[var], dims=["epoch"], coords={"epoch": epoch})
+    for var, data in variables.items():
+        ds[var] = xr.DataArray(data, dims=["epoch"], coords={"epoch": epoch})
 
     return ds
 
 
-@pytest.fixture()
+@pytest.fixture
 def ancillary_dict():
     dictionary = {
         "description": "Table for conversion/decoding ancillary parameters collected "
@@ -289,7 +289,7 @@ def test_process_de(de_dataset, ancillary_dict):
 
 
 def test_glows_l1b(de_dataset, hist_dataset):
-    hist_output = glows_l1b(hist_dataset, "V001")
+    hist_output = glows_l1b(hist_dataset)
 
     assert hist_output["histogram"].dims == ("epoch", "bins")
     assert hist_output["histogram"].shape == (20, 3600)
@@ -341,7 +341,7 @@ def test_glows_l1b(de_dataset, hist_dataset):
     for key in expected_hist_data:
         assert key in hist_output
 
-    de_output = glows_l1b(de_dataset, "V001")
+    de_output = glows_l1b(de_dataset)
 
     # From table 15 in the algorithm document
     expected_de_data = [
@@ -364,14 +364,14 @@ def test_glows_l1b(de_dataset, hist_dataset):
 
 
 def test_generate_histogram_dataset(hist_dataset):
-    l1b_data = glows_l1b(hist_dataset, "v001")
+    l1b_data = glows_l1b(hist_dataset)
     output_path = write_cdf(l1b_data)
 
     assert Path.exists(output_path)
 
 
 def test_generate_de_dataset(de_dataset):
-    l1b_data = glows_l1b(de_dataset, "v001")
+    l1b_data = glows_l1b(de_dataset)
 
     output_path = write_cdf(l1b_data)
 

imap_processing/tests/glows/test_glows_l1b_data.py

@@ -48,8 +48,8 @@ def test_glows_l1b_ancillary_file():
     }
 
     ancillary = AncillaryParameters(fake_good_input)
-    for key in fake_good_input:
-        assert getattr(ancillary, key) == fake_good_input[key]
+    for key, data in fake_good_input.items():
+        assert getattr(ancillary, key) == data
 
     fake_bad_input = {
         "version": "0.1",
@@ -80,7 +80,7 @@ def test_glows_l1b_de():
 
 
 def test_validation_data_histogram(l1a_dataset):
-    l1b = [glows_l1b(l1a_dataset[0], "v001"), glows_l1b(l1a_dataset[1], "v001")]
+    l1b = [glows_l1b(l1a_dataset[0]), glows_l1b(l1a_dataset[1])]
     end_time = l1b[0]["epoch"].data[-1]
 
     validation_data = (
@@ -147,9 +147,9 @@ def test_validation_data_histogram(l1a_dataset):
 
 
 def test_validation_data_de(l1a_dataset):
-    de_data = l1a_dataset[2]
+    de_data = l1a_dataset[1]
 
-    l1b = glows_l1b(de_data, "v001")
+    l1b = glows_l1b(de_data)
     validation_data = (
         Path(__file__).parent / "validation_data" / "imap_glows_l1b_de_output.json"
     )

imap_processing/tests/glows/test_glows_l2.py

@@ -10,7 +10,7 @@ from imap_processing.glows.l2.glows_l2 import (
 from imap_processing.glows.l2.glows_l2_data import DailyLightcurve
 
 
-@pytest.fixture()
+@pytest.fixture
 def l1b_hists():
     epoch = xr.DataArray(np.arange(4), name="epoch", dims=["epoch"])
     bins = xr.DataArray(np.arange(5), name="bins", dims=["bins"])
@@ -29,18 +29,12 @@ def l1b_hists():
 
 
 def test_glows_l2(l1b_hist_dataset):
-    l2 = glows_l2(l1b_hist_dataset, "v001")[0]
+    l2 = glows_l2(l1b_hist_dataset)[0]
     assert l2.attrs["Logical_source"] == "imap_glows_l2_hist"
 
     assert np.allclose(l2["filter_temperature_average"].values, [57.6], rtol=0.1)
 
 
-@pytest.mark.skip(reason="Spin table not yet complete")
-def test_split_by_observational_day(l1b_hist_dataset):
-    # TODO: Complete test when spin table is complete
-    raise NotImplementedError
-
-
 def test_filter_good_times():
     active_flags = np.ones((17,))
     active_flags[16] = 0

imap_processing/tests/hi/conftest.py

@@ -48,7 +48,7 @@ def check_sum(bits_size):
     return f"{0:0{bits_size}b}"
 
 
-@pytest.fixture()
+@pytest.fixture
 def create_de_data(tmp_path):
     """Fixture to create fake direct event data. Note that there has been no
     effort to make simulate this data meaning that packets are not self

imap_processing/tests/hi/test_hi_l1b.py

@@ -7,7 +7,6 @@ import pytest
 import xarray as xr
 
 from imap_processing.cdf.utils import load_cdf
-from imap_processing.hi.l1a.hi_l1a import hi_l1a
 from imap_processing.hi.l1b.hi_l1b import (
     compute_coincidence_type_and_tofs,
     compute_hae_coordinates,
@@ -24,15 +23,14 @@ def test_hi_l1b_hk(hi_l0_test_data_path):
     housekeeping L1A as input"""
     # TODO: once things are more stable, check in an L1A HK file as test data
     bin_data_path = hi_l0_test_data_path / "H90_NHK_20241104.bin"
-    data_version = "001"
-    processed_data = hi_l1a(packet_file_path=bin_data_path, data_version=data_version)
 
-    l1b_dataset = hi_l1b(processed_data[0], data_version=data_version)
-    assert l1b_dataset.attrs["Logical_source"] == "imap_hi_l1b_90sensor-hk"
+    l1b_datasets = hi_l1b(bin_data_path)
+    assert len(l1b_datasets) == 1
+    assert l1b_datasets[0].attrs["Logical_source"] == "imap_hi_l1b_90sensor-hk"
 
 
-@pytest.mark.external_test_data()
-@pytest.mark.external_kernel()
+@pytest.mark.external_test_data
+@pytest.mark.external_kernel
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
 def test_hi_l1b_de(
     hi_l1_test_data_path, spice_test_data_path, use_fake_spin_data_for_time
@@ -45,15 +43,15 @@ def test_hi_l1b_de(
         hi_l1_test_data_path / "imap_hi_l1a_45sensor-de_20250415_v999.cdf"
     )
     # Process using test data
-    data_version = "001"
     l1a_dataset = load_cdf(l1a_test_file_path)
 
-    l1b_dataset = hi_l1b(l1a_dataset, data_version=data_version)
-    assert l1b_dataset.attrs["Logical_source"] == "imap_hi_l1b_45sensor-de"
-    assert len(l1b_dataset.data_vars) == 15
+    l1b_datasets = hi_l1b(l1a_dataset)
+    assert len(l1b_datasets) == 1
+    assert l1b_datasets[0].attrs["Logical_source"] == "imap_hi_l1b_45sensor-de"
+    assert len(l1b_datasets[0].data_vars) == 15
 
 
-@pytest.fixture()
+@pytest.fixture
 def synthetic_trigger_id_and_tof_data():
     """Create synthetic minimum dataset for testing the
     coincidence_type_and_time_deltas algorithm."""

imap_processing/tests/hi/test_hi_l1c.py

@@ -27,21 +27,20 @@ def hi_test_cal_prod_config_path(hi_l1_test_data_path):
 @mock.patch("imap_processing.hi.l1c.hi_l1c.generate_pset_dataset")
 def test_hi_l1c(mock_generate_pset_dataset, hi_test_cal_prod_config_path):
     """Test coverage for hi_l1c function"""
-    mock_generate_pset_dataset.return_value = xr.Dataset(attrs={"Data_version": None})
-    pset = hi_l1c.hi_l1c(
-        [xr.Dataset(), hi_test_cal_prod_config_path], data_version="99"
-    )
-    assert pset.attrs["Data_version"] == "99"
+    mock_generate_pset_dataset.return_value = xr.Dataset()
+    pset = hi_l1c.hi_l1c([xr.Dataset(), hi_test_cal_prod_config_path])[0]
+    # Empty attributes, global values get added in post-processing
+    assert pset.attrs == {}
 
 
 def test_hi_l1c_not_implemented():
     """Test coverage for hi_l1c function with unrecognized dependencies"""
     with pytest.raises(NotImplementedError):
-        hi_l1c.hi_l1c([None, None], "0")
+        hi_l1c.hi_l1c([None, None])
 
 
-@pytest.mark.external_test_data()
-@pytest.mark.external_kernel()
+@pytest.mark.external_test_data
+@pytest.mark.external_kernel
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
 def test_generate_pset_dataset(
     hi_l1_test_data_path, hi_test_cal_prod_config_path, use_fake_spin_data_for_time
@@ -54,9 +53,7 @@ def test_generate_pset_dataset(
         l1b_dataset, hi_test_cal_prod_config_path
     )
 
-    assert l1c_dataset.epoch.data[0] == np.mean(l1b_dataset.epoch.data[[0, -1]]).astype(
-        np.int64
-    )
+    assert l1c_dataset.epoch.data[0] == l1b_dataset.epoch.data[0].astype(np.int64)
 
     np.testing.assert_array_equal(l1c_dataset.despun_z.data.shape, (1, 3))
     np.testing.assert_array_equal(l1c_dataset.hae_latitude.data.shape, (1, 3600))
@@ -70,7 +67,6 @@ def test_generate_pset_dataset(
         np.testing.assert_array_equal(l1c_dataset[var].data.shape, (1, 9, 2, 3600))
 
     # Test ISTP compliance by writing CDF
-    l1c_dataset.attrs["Data_version"] = 1
     write_cdf(l1c_dataset)
 
 
@@ -81,7 +77,7 @@ def test_empty_pset_dataset():
     n_calibration_prods = 5
     sensor_str = HIAPID.H90_SCI_DE.sensor
     dataset = hi_l1c.empty_pset_dataset(
-        l1b_esa_energy_steps, n_calibration_prods, sensor_str
+        100, l1b_esa_energy_steps, n_calibration_prods, sensor_str
     )
 
     assert dataset.epoch.size == 1
@@ -138,7 +134,7 @@ def test_pset_geometry(mock_frame_transform, mock_geom_frame_transform, sensor_s
     )
 
 
-@pytest.mark.external_test_data()
+@pytest.mark.external_test_data
 def test_pset_counts(hi_l1_test_data_path, hi_test_cal_prod_config_path):
     """Test coverage for pset_counts function."""
     l1b_de_path = hi_l1_test_data_path / "imap_hi_l1b_45sensor-de_20250415_v999.cdf"
@@ -147,6 +143,7 @@ def test_pset_counts(hi_l1_test_data_path, hi_test_cal_prod_config_path):
         hi_test_cal_prod_config_path
     )
     empty_pset = hi_l1c.empty_pset_dataset(
+        100,
         l1b_dataset.esa_energy_step.data,
         cal_config_df.cal_prod_config.number_of_products,
         HIAPID.H90_SCI_DE.sensor,
@@ -213,7 +210,7 @@ def test_pset_exposure(
 ):
     """Test coverage for pset_exposure function"""
     empty_pset = hi_l1c.empty_pset_dataset(
-        np.arange(2) + 1, 2, HIAPID.H90_SCI_DE.sensor
+        100, np.arange(2) + 1, 2, HIAPID.H90_SCI_DE.sensor
     )
     # Set the mock of find_second_de_packet_data to return a xr.Dataset
     # with some dummy data. ESA 1 will get binned data once, ESA 2 will get
@@ -245,7 +242,7 @@ def test_pset_exposure(
     # All the setup is done, call the pset_exposure function
     exposure_dict = hi_l1c.pset_exposure(empty_pset.coords, l1b_dataset)
 
-    # Based on the spin phase and clock_tick mocks, the expected output is:
+    # Based on the spin phase and clock_tick mocks, the expected clock ticks are:
     # - Repeated values of 3, 1 for the first half of the spin bins
     # - Repeated values of 3, 2 for the second half of the spin bins
     expected_values = np.stack(
@@ -253,8 +250,14 @@ def test_pset_exposure(
             np.tile([3, 1], hi_l1c.N_SPIN_BINS // 2),
             np.tile([6, 2], hi_l1c.N_SPIN_BINS // 2),
         ]
-    )[None, :, :]
-    np.testing.assert_array_equal(exposure_dict["exposure_times"].data, expected_values)
+    ).astype(float)[None, :, :]
+    # Convert expected clock ticks to seconds
+    expected_values *= DE_CLOCK_TICK_S
+    np.testing.assert_allclose(
+        exposure_dict["exposure_times"].data,
+        expected_values,
+        atol=DE_CLOCK_TICK_S / 100,
+    )
 
 
 def test_find_second_de_packet_data():
@@ -296,7 +299,7 @@ def fake_spin_df():
     # Generate some spin periods that vary by a random fraction of a second
     spin_period = np.full(10, 15) + np.random.randn(10) / 10
     d = {
-        "spin_start_time": np.add.accumulate(spin_period),
+        "spin_start_met": np.add.accumulate(spin_period),
         "spin_period_sec": spin_period,
     }
     spin_df = pd.DataFrame.from_dict(d)
@@ -310,8 +313,8 @@ def test_get_de_clock_ticks_for_esa_step(fake_spin_df):
     # the end spin in the table + 1/2 spin period
     for _, spin_row in fake_spin_df.iloc[8:].iterrows():
         for ccsds_met in np.linspace(
-            spin_row.spin_start_time,
-            spin_row.spin_start_time + np.floor(spin_row.spin_period_sec / 2),
+            spin_row.spin_start_met,
+            spin_row.spin_start_met + np.floor(spin_row.spin_period_sec / 2),
             10,
         ):
             clock_tick_mets, clock_tick_weights = (
@@ -321,7 +324,7 @@ def test_get_de_clock_ticks_for_esa_step(fake_spin_df):
             # Verify last weight entry
             exp_final_weight = (
                 np.absolute(
-                    fake_spin_df.spin_start_time.to_numpy() - clock_tick_mets[-1]
+                    fake_spin_df.spin_start_met.to_numpy() - clock_tick_mets[-1]
                 ).min()
                 / DE_CLOCK_TICK_S
             )
@@ -333,7 +336,7 @@ def test_get_de_clock_ticks_for_esa_step_exceptions(fake_spin_df):
     """Test the exception logic in the get_de_clock_ticks_for_esa_step function."""
     # Test the ccsds_met being > 1/2 spin period past the spin start
     bad_ccsds_met = (
-        fake_spin_df.iloc[8].spin_start_time
+        fake_spin_df.iloc[8].spin_start_met
         + fake_spin_df.iloc[8].spin_period_sec / 2
         + 0.1
     )
@@ -343,7 +346,7 @@ def test_get_de_clock_ticks_for_esa_step_exceptions(fake_spin_df):
         hi_l1c.get_de_clock_ticks_for_esa_step(bad_ccsds_met, fake_spin_df)
 
     # Test the ccsds_met being too close to the start of the spin table
-    bad_ccsds_met = fake_spin_df.iloc[7].spin_start_time
+    bad_ccsds_met = fake_spin_df.iloc[7].spin_start_met
     with pytest.raises(
         ValueError, match="Error determining start/end time for exposure time"
     ):

imap_processing/tests/hi/test_l1a.py

@@ -11,15 +11,14 @@ def test_sci_de_decom(hi_l0_test_data_path):
     """Test science direct event data"""
 
     bin_data_path = hi_l0_test_data_path / "H90_sci_de_20241104.bin"
-    processed_data = hi_l1a(bin_data_path, data_version="001")
+    processed_data = hi_l1a(bin_data_path)
 
     assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_90sensor-de"
-    assert processed_data[0].attrs["Data_version"] == "001"
 
     # TODO: Verify correct unpacking of sample data. Issue: #1186
 
     # Write to CDF
-    cdf_filename = "imap_hi_l1a_90sensor-de_20241105_v001.cdf"
+    cdf_filename = "imap_hi_l1a_90sensor-de_20241105_v999.cdf"
     cdf_filepath = write_cdf(processed_data[0])
     assert cdf_filepath.name == cdf_filename
 
@@ -27,10 +26,10 @@ def test_sci_de_decom(hi_l0_test_data_path):
 def test_diag_fee_decom(hi_l0_test_data_path):
     """Test diag_fee data"""
     bin_data_path = hi_l0_test_data_path / "H45_diag_fee_20250208.bin"
-    processed_data = hi_l1a(packet_file_path=bin_data_path, data_version="001")
+    processed_data = hi_l1a(packet_file_path=bin_data_path)
     dataset = processed_data[0]
     cdf_filepath = write_cdf(processed_data[0], istp=False)
-    assert cdf_filepath.name == "imap_hi_l1a_45sensor-diagfee_20250208_v001.cdf"
+    assert cdf_filepath.name == "imap_hi_l1a_45sensor-diagfee_20250208_v999.cdf"
 
     assert np.unique(processed_data[0]["pkt_apid"].values) == HIAPID.H45_DIAG_FEE.value
 
@@ -58,11 +57,10 @@ def test_app_nhk_decom(hi_l0_test_data_path):
 
     # Unpack housekeeping data
     bin_data_path = hi_l0_test_data_path / "H90_NHK_20241104.bin"
-    processed_data = hi_l1a(packet_file_path=bin_data_path, data_version="001")
+    processed_data = hi_l1a(packet_file_path=bin_data_path)
 
     assert np.unique(processed_data[0]["pkt_apid"].values) == HIAPID.H90_APP_NHK.value
     assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_90sensor-hk"
-    assert processed_data[0].attrs["Data_version"] == "001"
     # TODO: compare with validation data once we have it. Issue: #1184
 
     # Write CDF
@@ -70,13 +68,13 @@ def test_app_nhk_decom(hi_l0_test_data_path):
 
     # TODO: ask Vivek about this date mismatch between the file name
     # and the data. May get resolved when we have good sample data.
-    assert cem_raw_cdf_filepath.name == "imap_hi_l1a_90sensor-hk_20241105_v001.cdf"
+    assert cem_raw_cdf_filepath.name == "imap_hi_l1a_90sensor-hk_20241105_v999.cdf"
 
 
 def test_app_hist_decom(hi_l0_test_data_path):
     """Test histogram (SCI_CNT) data"""
     bin_data_path = hi_l0_test_data_path / "H90_sci_cnt_20241104.bin"
-    processed_data = hi_l1a(packet_file_path=bin_data_path, data_version="001")
+    processed_data = hi_l1a(packet_file_path=bin_data_path)
 
     assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_90sensor-hist"
     # TODO: compare with validation data once we have it. Issue: #1185

imap_processing/tests/hi/test_science_direct_event.py

@@ -30,8 +30,8 @@ def test_parse_direct_events():
     bytes_obj = bytes([int(bin_str[i : i + 8], 2) for i in range(0, len(bin_str), 8)])
     # Parse the fake events and check values
     de_dict = parse_direct_events(bytes_obj)
-    for key in exp_dict.keys():
-        np.testing.assert_array_equal(de_dict[key], exp_dict[key])
+    for key, expected_val in exp_dict.items():
+        np.testing.assert_array_equal(de_dict[key], expected_val)
 
 
 def test_create_dataset():