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

imap_processing/tests/mag/validation/L1b/T011/mag-l1a-l1b-t011-in.csv

@@ -0,0 +1,17 @@
+sequence,x_pri,y_pri,z_pri,rng_pri,x_sec,y_sec,z_sec,rng_sec,pri_coarse,pri_fine,sec_coarse,sec_fine,compression,compression_width_bits
+14,13,-27,-1,1,2,-5,7,0,476381218,64355,476381218,64357,0,16
+14,26,-30,-13,1,7,-10,-5,0,476381218,64355,476381218,64357,0,16
+14,38,-51,-24,1,0,-14,0,0,476381218,64355,476381218,64357,0,16
+14,44,-53,-39,2,-1,-20,5,0,476381218,64355,476381218,64357,0,16
+14,50,-48,-50,2,12,-27,8,1,476381218,64355,476381218,64357,0,16
+14,52,-59,-48,2,9,-32,4,1,476381218,64355,476381218,64357,0,16
+14,53,-78,-44,2,17,-26,-4,1,476381218,64355,476381218,64357,0,16
+14,58,-87,-51,2,29,-36,-16,1,476381218,64355,476381218,64357,0,16
+14,51,-100,-68,3,41,-54,-29,1,476381218,64355,476381218,64357,0,16
+14,26,-114,-70,3,47,-51,-43,2,476381218,64355,476381218,64357,0,16
+14,34,-125,-67,3,50,-49,-49,2,476381218,64355,476381218,64357,0,16
+14,39,-121,-70,3,53,-66,-48,2,476381218,64355,476381218,64357,0,16
+14,29,-96,-54,3,54,-80,-44,2,476381218,64355,476381218,64357,0,16
+14,3,-9,-2,0,59,-91,-56,2,476381218,64355,476381218,64357,0,16
+14,0,-1,8,0,43,-103,-71,3,476381218,64355,476381218,64357,0,16
+14,5,-10,-2,0,23,-119,-67,3,476381218,64355,476381218,64357,0,16

imap_processing/tests/mag/validation/L1b/T011/mag-l1a-l1b-t011-magi-out.csv

@@ -0,0 +1,17 @@
+t,coarse,fine,sequence,x,y,z,range,compression,compression_width
+2025-02-04T16:06:58.982024,476381218,64357,14,4.55075124996,-11.19786196854,15.77425592322,0,0,16
+2025-02-04T16:06:59.482024,476381218,64357,14,15.92762937486,-22.40731698594,-11.07018889848,0,0,16
+2025-02-04T16:06:59.982024,476381218,64357,14,0,-31.33237315404,0.16302044052,0,0,16
+2025-02-04T16:07:00.482024,476381218,64357,14,-2.27537562498,-44.75666872758,11.44735711164,0,0,16
+2025-02-04T16:07:00.982024,476381218,64357,14,0.885096288,-1.952868096,0.590544504,1,0,16
+2025-02-04T16:07:01.482024,476381218,64357,14,0.663822216,-2.313845568,0.302605344,1,0,16
+2025-02-04T16:07:01.982024,476381218,64357,14,1.253886408,-1.881232704,-0.277225488,1,0,16
+2025-02-04T16:07:02.482024,476381218,64357,14,2.138982696,-2.605478976,-1.139884128,1,0,16
+2025-02-04T16:07:02.982024,476381218,64357,14,3.024078984,-3.907900224,-2.071901592,1,0,16
+2025-02-04T16:07:03.482024,476381218,64357,14,0.88482713616,-0.9431913528,-0.78778074834,2,0,16
+2025-02-04T16:07:03.982024,476381218,64357,14,0.941305464,-0.90634074822,-0.89873597394,2,0,16
+2025-02-04T16:07:04.482024,476381218,64357,14,0.99778379184,-1.22037879546,-0.87847855812,2,0,16
+2025-02-04T16:07:04.982024,476381218,64357,14,1.01660990112,-1.47895667604,-0.80315324496,2,0,16
+2025-02-04T16:07:05.482024,476381218,64357,14,1.11074044752,-1.68224447592,-1.02364442208,2,0,16
+2025-02-04T16:07:05.982024,476381218,64357,14,0.19710391041,-0.46535117637,-0.31706811786,3,0,16
+2025-02-04T16:07:06.482024,476381218,64357,14,0.10542767301,-0.53738602233,-0.29896071126,3,0,16

imap_processing/tests/mag/validation/L1b/T011/mag-l1a-l1b-t011-mago-out.csv

@@ -0,0 +1,17 @@
+t,coarse,fine,sequence,x,y,z,range,compression,compression_width
+2025-02-04T16:06:58.981994,476381218,64355,14,0.959660208,-1.952789976,-0.065792592,1,0,16
+2025-02-04T16:06:59.481994,476381218,64355,14,1.919320416,-2.168504496,-0.934627104,1,0,16
+2025-02-04T16:06:59.981994,476381218,64355,14,2.805160608,-3.687134832,-1.725878016,1,0,16
+2025-02-04T16:07:00.481994,476381218,64355,14,0.82931140512,-0.97823230506,-0.71816753502,2,0,16
+2025-02-04T16:07:00.981994,476381218,64355,14,0.942399324,-0.8856151974,-0.922033134,2,0,16
+2025-02-04T16:07:01.481994,476381218,64355,14,0.98009529696,-1.08887713398,-0.88430215752,2,0,16
+2025-02-04T16:07:01.981994,476381218,64355,14,0.99894328344,-1.44004598082,-0.8089813125,2,0,16
+2025-02-04T16:07:02.481994,476381218,64355,14,1.09318321584,-1.60624150722,-0.93784261842,2,0,16
+2025-02-04T16:07:02.981994,476381218,64355,14,0.23448643983,-0.4504876167,-0.30422097897,3,0,16
+2025-02-04T16:07:03.481994,476381218,64355,14,0.11954210658,-0.5137174926,-0.31298135118,3,0,16
+2025-02-04T16:07:03.981994,476381218,64355,14,0.15632429322,-0.5632591128,-0.29918061558,3,0,16
+2025-02-04T16:07:04.481994,476381218,64355,14,0.17931315987,-0.5452042089,-0.31278820557,3,0,16
+2025-02-04T16:07:04.981994,476381218,64355,14,0.13333542657,-0.4325684769,-0.24123552375,3,0,16
+2025-02-04T16:07:05.481994,476381218,64355,14,6.89166060498,-20.13180037308,-4.42656442566,0,0,16
+2025-02-04T16:07:05.981994,476381218,64355,14,0,-2.23802879004,18.00488498574,0,0,16
+2025-02-04T16:07:06.481994,476381218,64355,14,11.4861010083,-22.3628566716,-4.42269580368,0,0,16

imap_processing/tests/spice/test_geometry.py

@@ -1,23 +1,24 @@
 """Tests coverage for imap_processing/spice/geometry.py"""
 
+from unittest import mock
+
 import numpy as np
-import pandas as pd
 import pytest
-import spiceypy as spice
+import spiceypy
 
 from imap_processing.spice.geometry import (
     SpiceBody,
     SpiceFrame,
     basis_vectors,
+    cartesian_to_latitudinal,
     cartesian_to_spherical,
     frame_transform,
-    get_instrument_spin_phase,
+    frame_transform_az_el,
     get_rotation_matrix,
-    get_spacecraft_spin_phase,
     get_spacecraft_to_instrument_spin_phase_offset,
-    get_spin_data,
     imap_state,
     instrument_pointing,
+    solar_longitude,
     spherical_to_cartesian,
 )
 from imap_processing.spice.kernels import ensure_spice
@@ -47,116 +48,6 @@ def test_imap_state_ecliptic():
     assert state.shape == (6,)
 
 
-@pytest.fixture()
-def fake_spin_data(monkeypatch, spice_test_data_path):
-    """Generate fake spin dataframe for testing"""
-    fake_spin_path = spice_test_data_path / "fake_spin_data.csv"
-    monkeypatch.setenv("SPIN_DATA_FILEPATH", str(fake_spin_path))
-    return fake_spin_path
-
-
-@pytest.mark.parametrize(
-    "query_met_times, expected",
-    [
-        (15, 0.0),  # Scalar test
-        (np.array([15.1, 30.1]), np.array([0.1 / 15, 0.1 / 15])),  # Array test
-        (np.array([]), None),  # Empty array test
-        (np.array([50]), np.array([5 / 15])),  # Single element array test
-        # The first spin has thruster firing set, but should return valid value
-        (5.0, 5 / 15),
-        # Test invalid spin period flag causes nan
-        (106.0, np.nan),
-        # Test invalid spin phase flag causes nans
-        (np.array([121, 122, 123]), np.full(3, np.nan)),
-        # Test that invalid spin period causes nans
-        (np.array([110, 111]), np.full(2, np.nan)),
-        # Test for time in missing spin
-        (65, np.nan),
-        (np.array([65.1, 66]), np.full(2, np.nan)),
-        # Combined test
-        (
-            np.array([7.5, 30, 61, 75, 106, 121, 136]),
-            np.array([0.5, 0, np.nan, 0, np.nan, np.nan, 1 / 15]),
-        ),
-    ],
-)
-def test_get_spacecraft_spin_phase(query_met_times, expected, fake_spin_data):
-    """Test get_spacecraft_spin_phase() with generated spin data."""
-    # Call the function
-    spin_phases = get_spacecraft_spin_phase(query_met_times=query_met_times)
-
-    # Test the returned type
-    if isinstance(expected, float):
-        assert isinstance(spin_phases, float), "Spin phase must be a float."
-    elif expected is None:
-        assert len(spin_phases) == 0, "Spin phase must be empty."
-    else:
-        assert spin_phases.shape == expected.shape
-    # Test the value
-    np.testing.assert_array_almost_equal(spin_phases, expected)
-
-
-@pytest.mark.parametrize("query_met_times", [-1, 165])
-def test_get_spacecraft_spin_phase_value_error(query_met_times, fake_spin_data):
-    """Test get_spacecraft_spin_phase() for raising ValueError."""
-    with pytest.raises(ValueError, match="Query times"):
-        _ = get_spacecraft_spin_phase(query_met_times)
-
-
-@pytest.mark.usefixtures("use_fake_spin_data_for_time")
-def test_get_spin_data(use_fake_spin_data_for_time):
-    """Test get_spin_data() with generated spin data."""
-    use_fake_spin_data_for_time(453051323.0 - 56120)
-    spin_data = get_spin_data()
-
-    (
-        np.testing.assert_array_equal(spin_data["spin_number"], np.arange(5761)),
-        "One day should have 5,761 records of 15 seconds when including end_met.",
-    )
-    assert isinstance(spin_data, pd.DataFrame), "Return type must be pandas.DataFrame."
-
-    assert set(spin_data.columns) == {
-        "spin_number",
-        "spin_start_sec",
-        "spin_start_subsec",
-        "spin_period_sec",
-        "spin_period_valid",
-        "spin_phase_valid",
-        "spin_period_source",
-        "thruster_firing",
-        "spin_start_time",
-    }, "Spin data must have the specified fields."
-
-
-@pytest.mark.parametrize(
-    "instrument",
-    [
-        SpiceFrame.IMAP_LO,
-        SpiceFrame.IMAP_HI_45,
-        SpiceFrame.IMAP_HI_90,
-        SpiceFrame.IMAP_ULTRA_45,
-        SpiceFrame.IMAP_ULTRA_90,
-        SpiceFrame.IMAP_SWAPI,
-        SpiceFrame.IMAP_IDEX,
-        SpiceFrame.IMAP_CODICE,
-        SpiceFrame.IMAP_HIT,
-        SpiceFrame.IMAP_SWE,
-        SpiceFrame.IMAP_GLOWS,
-        SpiceFrame.IMAP_MAG,
-    ],
-)
-def test_get_instrument_spin_phase(instrument, fake_spin_data):
-    """Test coverage for get_instrument_spin_phase()"""
-    met_times = np.array([7.5, 30, 61, 75, 106, 121, 136])
-    expected_nan_mask = np.array([False, False, True, False, True, True, False])
-    inst_phase = get_instrument_spin_phase(met_times, instrument)
-    assert inst_phase.shape == met_times.shape
-    np.testing.assert_array_equal(np.isnan(inst_phase), expected_nan_mask)
-    assert np.logical_and(
-        0 <= inst_phase[~expected_nan_mask], inst_phase[~expected_nan_mask] < 1
-    ).all()
-
-
 @pytest.mark.parametrize(
     "instrument, expected_offset",
     [
@@ -233,7 +124,7 @@ def test_frame_transform(et_strings, position, from_frame, to_frame, furnish_ker
     ]
     with furnish_kernels(kernels):
         # Test single et and position calculation
-        et = np.array([spice.utc2et(et_str) for et_str in et_strings])
+        et = np.array([spiceypy.utc2et(et_str) for et_str in et_strings])
         et_arg = et[0] if len(et) == 1 else et
         result = frame_transform(et_arg, position, from_frame, to_frame)
         # check the result shape before modifying for value checking.
@@ -255,11 +146,33 @@ def test_frame_transform(et_strings, position, from_frame, to_frame, furnish_ker
             position = np.broadcast_to(position, (len(et), 3))
             result = np.broadcast_to(result, (len(et), 3))
         for spice_et, spice_position, test_result in zip(et, position, result):
-            rotation_matrix = spice.pxform(from_frame.name, to_frame.name, spice_et)
-            spice_result = spice.mxv(rotation_matrix, spice_position)
+            rotation_matrix = spiceypy.pxform(from_frame.name, to_frame.name, spice_et)
+            spice_result = spiceypy.mxv(rotation_matrix, spice_position)
             np.testing.assert_allclose(test_result, spice_result, atol=1e-12)
 
 
+@pytest.mark.parametrize(
+    "spice_frame",
+    [
+        SpiceFrame.IMAP_DPS,
+        SpiceFrame.IMAP_SPACECRAFT,
+        SpiceFrame.ECLIPJ2000,
+    ],
+)
+@pytest.mark.parametrize(
+    "position",
+    [
+        np.array([1, 0, 0]),
+        np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+        np.random.rand(10, 3),
+    ],
+)
+def test_frame_transform_same_frame(position, spice_frame):
+    """Test that frame_transform returns position when input/output frames are same."""
+    result = frame_transform(0, position, spice_frame, spice_frame)
+    assert result is position
+
+
 def test_frame_transform_exceptions():
     """Test that the proper exceptions get raised when input arguments are invalid."""
     with pytest.raises(
@@ -287,6 +200,45 @@ def test_frame_transform_exceptions():
         )
 
 
+@pytest.mark.parametrize(
+    "spice_frame",
+    [
+        SpiceFrame.IMAP_DPS,
+        SpiceFrame.IMAP_SPACECRAFT,
+        SpiceFrame.ECLIPJ2000,
+    ],
+)
+@pytest.mark.parametrize("degrees_bool", [True, False])
+def test_frame_transform_az_el_same_frame(spice_frame, degrees_bool):
+    """Test that frame_transform returns az/el when input/output frames are same."""
+    az_el_points = np.array(
+        [
+            [0, -90],
+            [0, 0],
+            [0, 89.999999],
+            [90, -90],
+            [90, 0],
+            [90, 89.999999],
+            [180, -90],
+            [180, 0],
+            [180, 89.999999],
+            [270, -90],
+            [270, 0],
+            [270, 89.999999],
+            [359.999999, -90],
+            [359.999999, 0],
+            [359.999999, 89.999999],
+            [360, 90],
+        ]
+    )
+    if not degrees_bool:
+        az_el_points = np.deg2rad(az_el_points)
+    result = frame_transform_az_el(
+        0, az_el_points, spice_frame, spice_frame, degrees=degrees_bool
+    )
+    np.testing.assert_allclose(result, az_el_points)
+
+
 def test_get_rotation_matrix(furnish_kernels):
     """Test coverage for get_rotation_matrix()."""
     kernels = [
@@ -297,7 +249,7 @@ def test_get_rotation_matrix(furnish_kernels):
         "sim_1yr_imap_pointing_frame.bc",
     ]
     with furnish_kernels(kernels):
-        et = spice.utc2et("2025-09-30T12:00:00.000")
+        et = spiceypy.utc2et("2025-09-30T12:00:00.000")
         # test input of float
         rotation = get_rotation_matrix(
             et, SpiceFrame.IMAP_IDEX, SpiceFrame.IMAP_SPACECRAFT
@@ -319,7 +271,7 @@ def test_instrument_pointing(furnish_kernels):
         "sim_1yr_imap_pointing_frame.bc",
     ]
     with furnish_kernels(kernels):
-        et = spice.utc2et("2025-06-12T12:00:00.000")
+        et = spiceypy.utc2et("2025-06-12T12:00:00.000")
         # Single et input
         ins_pointing = instrument_pointing(
             et, SpiceFrame.IMAP_HI_90, SpiceFrame.ECLIPJ2000
@@ -344,7 +296,7 @@ def test_basis_vectors():
     """Test coverage for basis_vectors()."""
     # This call to SPICE needs to be wrapped with `ensure_spice` so that kernels
     # get furnished automatically
-    et = ensure_spice(spice.utc2et)("2025-09-30T12:00:00.000")
+    et = ensure_spice(spiceypy.utc2et)("2025-09-30T12:00:00.000")
     # test input of float
     sc_axes = basis_vectors(et, SpiceFrame.IMAP_SPACECRAFT, SpiceFrame.IMAP_SPACECRAFT)
     np.testing.assert_array_equal(sc_axes, np.eye(3))
@@ -378,18 +330,11 @@ def test_cartesian_to_spherical():
 
     for point in cartesian_points:
         r, az, el = cartesian_to_spherical(point)
-        r_spice, colat_spice, slong_spice = spice.recsph(point)
-
-        # Convert SPICE co-latitude to elevation
-        el_spice = 90 - np.degrees(colat_spice)
-        az_spice = np.degrees(slong_spice)
-
-        # Normalize azimuth to [0, 360]
-        az_spice = az_spice % 360
+        range, ra, dec = spiceypy.recrad(point)
 
-        np.testing.assert_allclose(r, r_spice, atol=1e-5)
-        np.testing.assert_allclose(az, az_spice, atol=1e-5)
-        np.testing.assert_allclose(el, el_spice, atol=1e-5)
+        np.testing.assert_allclose(r, range, atol=1e-5)
+        np.testing.assert_allclose(az, np.degrees(ra), atol=1e-5)
+        np.testing.assert_allclose(el, np.degrees(dec), atol=1e-5)
 
 
 def test_spherical_to_cartesian():
@@ -403,12 +348,62 @@ def test_spherical_to_cartesian():
     spherical_points = np.stack(
         (r * np.ones_like(theta).ravel(), theta.ravel(), elev.ravel()), axis=-1
     )
+    spherical_points_degrees = np.stack(
+        (
+            r * np.ones_like(theta).ravel(),
+            np.degrees(theta.ravel()),
+            np.degrees(elev.ravel()),
+        ),
+        axis=-1,
+    )
 
     # Convert elevation to colatitude for SPICE
     colat = np.pi / 2 - spherical_points[:, 2]
 
+    cartesian_from_degrees = spherical_to_cartesian(
+        spherical_points_degrees, degrees=True
+    )
+
     for i in range(len(colat)):
         cartesian_coords = spherical_to_cartesian(np.array([spherical_points[i]]))
-        spice_coords = spice.sphrec(r, colat[i], spherical_points[i, 1])
+        spice_coords = spiceypy.sphrec(r, colat[i], spherical_points[i, 1])
 
         np.testing.assert_allclose(cartesian_coords[0], spice_coords, atol=1e-5)
+        np.testing.assert_allclose(cartesian_from_degrees[i], spice_coords, atol=1e-5)
+
+
+def test_cartesian_to_latitudinal():
+    """Test cartesian_to_latitudinal()."""
+    # example cartesian coords
+    coords = np.ones(3)
+
+    # test with one coord vector
+    lat_coords = cartesian_to_latitudinal(coords, degrees=True)
+    assert lat_coords.shape == (3,)
+    assert lat_coords[1] == 45
+    assert lat_coords[2] == 35.264389682754654
+
+    # Test with multiple coord vectors
+    coords = np.tile(coords, (10, 1))
+    lat_coords = cartesian_to_latitudinal(coords, degrees=True)
+    assert lat_coords.shape == (10, 3)
+
+
+@mock.patch("imap_processing.spice.geometry.imap_state")
+def test_solar_longitude(mock_state):
+    """Test solar_longitude()."""
+
+    mock_state.side_effect = lambda t, observer: (
+        np.ones(6) if (isinstance(t, int)) else np.ones((len(t), 6))
+    )
+    # example et time
+    et = 798033670
+
+    # test for one time interval
+    lon = solar_longitude(et, degrees=True)
+    assert lon == 45
+
+    # Test with multiple time intervals
+    et = np.tile(et, (10, 1))
+    lon = solar_longitude(et, degrees=True)
+    assert lon.shape == (10,)

imap_processing/tests/spice/test_kernels.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 import pytest
-import spiceypy as spice
+import spiceypy
 from spiceypy.utils.exceptions import SpiceyError
 
 from imap_processing.spice.kernels import (
@@ -45,11 +45,11 @@ def multiple_pointing_kernels(spice_test_data_path):
 @pytest.fixture()
 def et_times(pointing_frame_kernels):
     """Tests get_et_times function."""
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.furnsh(pointing_frame_kernels)
 
-    ck_kernel, _, _, _ = spice.kdata(0, "ck")
-    ck_cover = spice.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
-    et_start, et_end = spice.wnfetd(ck_cover, 0)
+    ck_kernel, _, _, _ = spiceypy.kdata(0, "ck")
+    ck_cover = spiceypy.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
+    et_start, et_end = spiceypy.wnfetd(ck_cover, 0)
     et_times = _get_et_times(et_start, et_end)
 
     return et_times
@@ -58,7 +58,7 @@ def et_times(pointing_frame_kernels):
 @ensure_spice
 def single_wrap_et2utc(et, fmt, prec):
     """Directly decorate a spice function with ensure_spice for use in tests"""
-    return spice.et2utc(et, fmt, prec)
+    return spiceypy.et2utc(et, fmt, prec)
 
 
 @ensure_spice
@@ -72,7 +72,7 @@ def double_wrap_et2utc(et, fmt, prec):
 @ensure_spice(time_kernels_only=True)
 def single_wrap_et2utc_tk_only(et, fmt, prec):
     """Directly wrap a spice function with optional time_kernels_only set True"""
-    return spice.et2utc(et, fmt, prec)
+    return spiceypy.et2utc(et, fmt, prec)
 
 
 @ensure_spice(time_kernels_only=True)
@@ -101,7 +101,7 @@ def test_ensure_spice_emus_mk_path(func, use_test_metakernel):
 @pytest.mark.usefixtures("_unset_metakernel_path")
 def test_ensure_spice_time_kernels():
     """Test functionality of ensure spice with timekernels set"""
-    wrapped = ensure_spice(spice.et2utc, time_kernels_only=True)
+    wrapped = ensure_spice(spiceypy.et2utc, time_kernels_only=True)
     # TODO: Update/remove this test when a decision has been made about
     #   whether IMAP will use the time_kernels_only functionality and the
     #   ensure_spice decorator has been update.
@@ -113,7 +113,7 @@ def test_ensure_spice_time_kernels():
 @pytest.mark.usefixtures("_unset_metakernel_path")
 def test_ensure_spice_key_error():
     """Test functionality of ensure spice when all branches fail"""
-    wrapped = ensure_spice(spice.et2utc)
+    wrapped = ensure_spice(spiceypy.et2utc)
     # The ensure_spice decorator should raise a SpiceyError when all attempts to
     # furnish a set of kernels with sufficient coverage for the spiceypy
     # functions that it decorates.
@@ -123,7 +123,7 @@ def test_ensure_spice_key_error():
 
 def test_average_quaternions(et_times, pointing_frame_kernels):
     """Tests average_quaternions function."""
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.furnsh(pointing_frame_kernels)
     q_avg = _average_quaternions(et_times)
 
     # Generated from MATLAB code results
@@ -133,10 +133,10 @@ def test_average_quaternions(et_times, pointing_frame_kernels):
 
 def test_create_rotation_matrix(et_times, pointing_frame_kernels):
     """Tests create_rotation_matrix function."""
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.furnsh(pointing_frame_kernels)
     rotation_matrix = _create_rotation_matrix(et_times)
     q_avg = _average_quaternions(et_times)
-    z_avg = spice.q2m(list(q_avg))[:, 2]
+    z_avg = spiceypy.q2m(list(q_avg))[:, 2]
 
     rotation_matrix_expected = np.array(
         [[0.0000, 0.0000, 1.0000], [0.9104, -0.4136, 0.0000], [0.4136, 0.9104, 0.0000]]
@@ -151,8 +151,8 @@ def test_create_pointing_frame(
     spice_test_data_path, pointing_frame_kernels, tmp_path, et_times
 ):
     """Tests create_pointing_frame function."""
-    spice.kclear()
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.kclear()
+    spiceypy.furnsh(pointing_frame_kernels)
     create_pointing_frame(
         pointing_frame_path=tmp_path / "imap_dps.bc",
         ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
@@ -161,9 +161,9 @@ def test_create_pointing_frame(
     # After imap_dps.bc has been created.
     dps_kernel = str(tmp_path / "imap_dps.bc")
 
-    spice.furnsh(dps_kernel)
-    rotation_matrix_1 = spice.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 100)
-    rotation_matrix_2 = spice.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 1000)
+    spiceypy.furnsh(dps_kernel)
+    rotation_matrix_1 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 100)
+    rotation_matrix_2 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 1000)
 
     # All the rotation matrices should be the same.
     assert np.array_equal(rotation_matrix_1, rotation_matrix_2)
@@ -178,7 +178,7 @@ def test_create_pointing_frame(
     assert (tmp_path / "imap_dps.bc").exists()
 
     # Tests error handling when incorrect kernel is loaded.
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.furnsh(pointing_frame_kernels)
     with pytest.raises(
         ValueError, match="Error: Expected CK kernel badname_kernel.bc"
     ):  # Replace match string with expected error message
@@ -189,11 +189,11 @@ def test_create_pointing_frame(
 
 def test_et_times(pointing_frame_kernels):
     """Tests get_et_times function."""
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.furnsh(pointing_frame_kernels)
 
-    ck_kernel, _, _, _ = spice.kdata(0, "ck")
-    ck_cover = spice.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
-    et_start, et_end = spice.wnfetd(ck_cover, 0)
+    ck_kernel, _, _, _ = spiceypy.kdata(0, "ck")
+    ck_cover = spiceypy.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
+    et_start, et_end = spiceypy.wnfetd(ck_cover, 0)
     et_times = _get_et_times(et_start, et_end)
 
     assert et_times[0] == et_start
@@ -204,7 +204,7 @@ def test_et_times(pointing_frame_kernels):
 
 def test_multiple_attempts(pointing_frame_kernels, tmp_path, spice_test_data_path):
     """Tests create_pointing_frame function with multiple pointing kernels."""
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.furnsh(pointing_frame_kernels)
 
     # Check that a single segment is added regardless of how many times
     # create_pointing_frame is called.
@@ -212,32 +212,32 @@ def test_multiple_attempts(pointing_frame_kernels, tmp_path, spice_test_data_pat
         pointing_frame_path=tmp_path / "imap_dps.bc",
         ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
     )
-    ck_cover = spice.ckcov(
+    ck_cover = spiceypy.ckcov(
         str(tmp_path / "imap_dps.bc"), -43901, True, "INTERVAL", 0, "TDB"
     )
-    num_intervals = spice.wncard(ck_cover)
+    num_intervals = spiceypy.wncard(ck_cover)
     assert num_intervals == 1
 
     create_pointing_frame(
         pointing_frame_path=tmp_path / "imap_dps.bc",
         ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
     )
-    ck_cover = spice.ckcov(
+    ck_cover = spiceypy.ckcov(
         str(tmp_path / "imap_dps.bc"), -43901, True, "INTERVAL", 0, "TDB"
     )
-    num_intervals = spice.wncard(ck_cover)
+    num_intervals = spiceypy.wncard(ck_cover)
     assert num_intervals == 1
 
 
 def test_multiple_pointings(pointing_frame_kernels, spice_test_data_path, tmp_path):
     """Tests create_pointing_frame function with multiple pointing kernels."""
-    spice.furnsh(pointing_frame_kernels)
+    spiceypy.furnsh(pointing_frame_kernels)
 
     create_pointing_frame(
         pointing_frame_path=tmp_path / "imap_pointing_frame.bc",
         ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
     )
-    ck_cover_pointing = spice.ckcov(
+    ck_cover_pointing = spiceypy.ckcov(
         str(tmp_path / "imap_pointing_frame.bc"),
         -43901,
         True,
@@ -245,10 +245,10 @@ def test_multiple_pointings(pointing_frame_kernels, spice_test_data_path, tmp_pa
         0,
         "TDB",
     )
-    num_intervals = spice.wncard(ck_cover_pointing)
-    et_start_pointing, et_end_pointing = spice.wnfetd(ck_cover_pointing, 0)
+    num_intervals = spiceypy.wncard(ck_cover_pointing)
+    et_start_pointing, et_end_pointing = spiceypy.wnfetd(ck_cover_pointing, 0)
 
-    ck_cover = spice.ckcov(
+    ck_cover = spiceypy.ckcov(
         str(spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc"),
         -43000,
         True,
@@ -256,8 +256,8 @@ def test_multiple_pointings(pointing_frame_kernels, spice_test_data_path, tmp_pa
         0,
         "TDB",
     )
-    num_intervals_expected = spice.wncard(ck_cover)
-    et_start_expected, et_end_expected = spice.wnfetd(ck_cover, 0)
+    num_intervals_expected = spiceypy.wncard(ck_cover)
+    et_start_expected, et_end_expected = spiceypy.wnfetd(ck_cover, 0)
 
     assert num_intervals == num_intervals_expected
     assert et_start_pointing == et_start_expected
@@ -265,8 +265,8 @@ def test_multiple_pointings(pointing_frame_kernels, spice_test_data_path, tmp_pa
 
     et_times = _get_et_times(et_start_pointing, et_end_pointing)
 
-    spice.furnsh(str(tmp_path / "imap_pointing_frame.bc"))
-    rotation_matrix_1 = spice.pxform("ECLIPJ2000", "IMAP_DPS", et_times[100])
-    rotation_matrix_2 = spice.pxform("ECLIPJ2000", "IMAP_DPS", et_times[1000])
+    spiceypy.furnsh(str(tmp_path / "imap_pointing_frame.bc"))
+    rotation_matrix_1 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[100])
+    rotation_matrix_2 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[1000])
 
     assert np.array_equal(rotation_matrix_1, rotation_matrix_2)