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

imap_processing/tests/ena_maps/test_map_utils.py

@@ -28,27 +28,19 @@ class TestENAMapMappingUtils:
         """Test coverage for bin_single_array_at_indices function w/ simple 2D input,
         Corresponding to an extra axis that is not spatially binned.
         """
-        # Binning will occur along axis 0 (combining 1, 2, 3 and 4, 5, 6 separately)
+        # Binning will occur along axis 1 seen below
+        # (combining 1, 2, 3 and 4, 5, 6 separately).
         value_array = np.array(
             [
-                [1, 4],
-                [2, 5],
-                [3, 6],
+                [1, 2, 3],
+                [4, 5, 6],
             ]
         )
         input_indices = np.array([0, 1, 2, 2])
         projection_indices = np.array([1, 0, 1, 6])
         projection_grid_shape = (7, 1)
         expected_projection_values = np.array(
-            [
-                [2, 5],
-                [4, 10],
-                [0, 0],
-                [0, 0],
-                [0, 0],
-                [0, 0],
-                [3, 6],
-            ]
+            [[2, 4, 0, 0, 0, 0, 3], [5, 10, 0, 0, 0, 0, 6]]
         )
         projection_values = map_utils.bin_single_array_at_indices(
             value_array,
@@ -76,7 +68,7 @@ class TestENAMapMappingUtils:
         extra_axis_size = 11  # Another axis which is not spatially binned, e.g. energy
         input_grid_size = np.prod(input_grid_shape)
         projection_grid_size = np.prod(projection_grid_shape)
-        value_array = np.random.rand(input_grid_size, extra_axis_size)
+        value_array = np.random.rand(extra_axis_size, input_grid_size)
         input_indices = np.random.randint(0, input_grid_size, size=1000)
         projection_indices = np.random.randint(0, projection_grid_size, size=1000)
         projection_values = map_utils.bin_single_array_at_indices(
@@ -90,16 +82,16 @@ class TestENAMapMappingUtils:
         np.testing.assert_equal(
             projection_values.shape,
             (
-                projection_grid_size,
                 extra_axis_size,
+                projection_grid_size,
             ),
         )
 
         # Create the expected projection values by summing the input values in a loop
         # This is different from the binning function, which uses np.bincount
-        expected_projection_values = np.zeros((projection_grid_size, extra_axis_size))
+        expected_projection_values = np.zeros((extra_axis_size, projection_grid_size))
         for ii, ip in zip(input_indices, projection_indices):
-            expected_projection_values[ip, :] += value_array[ii, :]
+            expected_projection_values[:, ip] += value_array[:, ii]
 
         np.testing.assert_allclose(projection_values, expected_projection_values)
 
@@ -117,7 +109,7 @@ class TestENAMapMappingUtils:
         extra_axes_sizes = np.full(num_extra_dims, 3, dtype=int).tolist()
         input_grid_size = np.prod(input_grid_shape)
         projection_grid_size = np.prod(projection_grid_shape)
-        value_array = np.random.rand(input_grid_size, *extra_axes_sizes)
+        value_array = np.random.rand(*extra_axes_sizes, input_grid_size)
         input_indices = np.random.randint(0, input_grid_size, size=1000)
         projection_indices = np.random.randint(0, projection_grid_size, size=1000)
         projection_values = map_utils.bin_single_array_at_indices(
@@ -130,14 +122,14 @@ class TestENAMapMappingUtils:
         # Explicitly check that the shape of the output is the same as projection grid
         np.testing.assert_equal(
             projection_values.shape,
-            (projection_grid_size, *extra_axes_sizes),
+            (*extra_axes_sizes, projection_grid_size),
         )
 
         # Create the expected projection values by summing the input values in a loop
         # This is different from the binning function, which uses np.bincount
-        expected_projection_values = np.zeros((projection_grid_size, *extra_axes_sizes))
+        expected_projection_values = np.zeros((*extra_axes_sizes, projection_grid_size))
         for ii, ip in zip(input_indices, projection_indices):
-            expected_projection_values[ip, ...] += value_array[ii, ...]
+            expected_projection_values[..., ip] += value_array[..., ii]
 
         np.testing.assert_allclose(projection_values, expected_projection_values)
 
@@ -155,28 +147,59 @@ class TestENAMapMappingUtils:
         scale_factor_1d = 1.5
         input_values_1d_2 = input_values_1d_1 * scale_factor_1d
 
-        # 2D input values. The second axis (different cols) will be summed independently
+        # 2D input values. The 0 axis (different rows) will be summed independently
         input_values_2d = np.array(
             [
-                [-0.5, 0, 0.5],
-                [1, 2, 3],
-                [4, 5, 6],
-                [7, 8, 9],
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
+                [
+                    -0.5,
+                    1,
+                    4,
+                    7,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                [
+                    0,
+                    2,
+                    5,
+                    8,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                [
+                    0.5,
+                    3,
+                    6,
+                    9,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
             ]
         )
-        extra_axis_size_2d = input_values_2d.shape[1]
+
+        extra_axis_size_2d = input_values_2d.shape[0]
 
         # 3D input values
-        input_values_3d = np.zeros((input_values_2d.shape[0], 3, 3))
-        input_values_3d[:2] = np.array(
+        input_values_3d = np.zeros((3, 3, input_values_2d.shape[-1]))
+        input_values_3d[:, :, :2] = np.array(
             [
                 [
                     [1, 2, 3],
@@ -189,8 +212,8 @@ class TestENAMapMappingUtils:
                     [16, 17, 18],
                 ],
             ]
-        )
-        extra_axes_size_3d = input_values_3d.shape[1:]
+        ).transpose(1, 2, 0)
+        extra_axes_size_3d = input_values_3d.shape[:-1]
 
         # Set up the expected projection values
         expected_projection_values_1d_1 = np.zeros(projection_grid_shape).ravel()
@@ -199,13 +222,13 @@ class TestENAMapMappingUtils:
             expected_projection_values_1d_1 * scale_factor_1d
         )
         expected_projection_values_2d = np.zeros(
-            (np.prod(projection_grid_shape), extra_axis_size_2d)
+            (extra_axis_size_2d, np.prod(projection_grid_shape))
         )
-        expected_projection_values_2d[0, :] = np.array([11.5, 15, 18.5])
+        expected_projection_values_2d[:, 0] = np.array([11.5, 15, 18.5])
         expected_projection_values_3d = np.zeros(
-            (np.prod(projection_grid_shape), *extra_axes_size_3d)
+            (*extra_axes_size_3d, np.prod(projection_grid_shape))
         )
-        expected_projection_values_3d[0, :, :] = np.array(
+        expected_projection_values_3d[:, :, 0] = np.array(
             [
                 [11, 13, 15],
                 [17, 19, 21],

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.",
@@ -26,20 +26,20 @@ def test_build_spatial_bins():
     )
 
     assert az_bin_edges[0] == 0
-    assert az_bin_edges[-1] == 2 * np.pi
+    assert az_bin_edges[-1] == 360
     assert len(az_bin_edges) == 721
 
-    assert el_bin_edges[0] == -np.pi / 2
-    assert el_bin_edges[-1] == np.pi / 2
+    assert el_bin_edges[0] == -90
+    assert el_bin_edges[-1] == 90
     assert len(el_bin_edges) == 361
 
     assert len(az_bin_midpoints) == 720
-    np.testing.assert_allclose(az_bin_midpoints[0], np.deg2rad(0.25), atol=1e-4)
-    np.testing.assert_allclose(az_bin_midpoints[-1], np.deg2rad(359.75), atol=1e-4)
+    np.testing.assert_allclose(az_bin_midpoints[0], 0.25, atol=1e-4)
+    np.testing.assert_allclose(az_bin_midpoints[-1], 359.75, atol=1e-4)
 
     assert len(el_bin_midpoints) == 360
-    np.testing.assert_allclose(el_bin_midpoints[0], np.deg2rad(-89.75), atol=1e-4)
-    np.testing.assert_allclose(el_bin_midpoints[-1], np.deg2rad(89.75), atol=1e-4)
+    np.testing.assert_allclose(el_bin_midpoints[0], -89.75, atol=1e-4)
+    np.testing.assert_allclose(el_bin_midpoints[-1], 89.75, atol=1e-4)
 
 
 @pytest.mark.parametrize("spacing", valid_spacings)
@@ -91,7 +91,7 @@ def test_rewrap_even_spaced_az_el_grid_1d(order):
     )
     rewrapped_grid_known_shape = spatial_utils.rewrap_even_spaced_az_el_grid(
         raveled_values,
-        shape=orig_shape,
+        grid_shape=orig_shape,
         order=order,
     )
 
@@ -102,19 +102,19 @@ def test_rewrap_even_spaced_az_el_grid_1d(order):
 @pytest.mark.parametrize("order", ["C", "F"])
 def test_rewrap_even_spaced_az_el_grid_2d(order):
     """Test rewrap_even_spaced_az_el_grid function, with extra axis."""
-    orig_shape = (360 * 12, 180 * 12, 5)
+    orig_shape = (5, 360 * 12, 180 * 12)
     orig_grid = np.fromfunction(lambda i, j, k: i**2 + j + k, orig_shape, dtype=int)
-    raveled_values = orig_grid.reshape(-1, 5, order=order)
+    raveled_values = orig_grid.reshape(5, -1, order=order)
     rewrapped_grid_infer_shape = spatial_utils.rewrap_even_spaced_az_el_grid(
         raveled_values,
         order=order,
     )
     rewrapped_grid_known_shape = spatial_utils.rewrap_even_spaced_az_el_grid(
         raveled_values,
-        shape=orig_shape,
+        grid_shape=orig_shape[-2:],
         order=order,
     )
-    assert raveled_values.shape == (360 * 12 * 180 * 12, 5)
+    assert raveled_values.shape == (5, 360 * 12 * 180 * 12)
     assert np.array_equal(rewrapped_grid_infer_shape, orig_grid)
     assert np.array_equal(rewrapped_grid_known_shape, orig_grid)
 
@@ -141,21 +141,17 @@ class TestAzElSkyGrid:
         )
         npt.assert_allclose(
             grid.az_bin_midpoints,
-            np.deg2rad(expected_azimuth_bin_midpoints_deg),
+            expected_azimuth_bin_midpoints_deg,
             atol=1e-11,
         )
         npt.assert_allclose(
             grid.el_bin_midpoints,
-            np.deg2rad(expected_elevation_bin_midpoints_deg),
+            expected_elevation_bin_midpoints_deg,
             atol=1e-11,
         )
 
         # Check bin edges in degrees, radians
         expected_az_bin_edges_deg = np.arange(0, 360 + spacing, spacing)
         expected_el_bin_edges_deg = np.arange(-90, 90 + spacing, spacing)
-        npt.assert_allclose(
-            grid.az_bin_edges, np.deg2rad(expected_az_bin_edges_deg), atol=1e-11
-        )
-        npt.assert_allclose(
-            grid.el_bin_edges, np.deg2rad(expected_el_bin_edges_deg), atol=1e-11
-        )
+        npt.assert_allclose(grid.az_bin_edges, expected_az_bin_edges_deg, atol=1e-11)
+        npt.assert_allclose(grid.el_bin_edges, expected_el_bin_edges_deg, atol=1e-11)

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