dkist-processing-visp 3.3.0__py3-none-any.whl → 5.1.1__py3-none-any.whl

dkist_processing_visp/tests/test_lamp.py

@@ -6,13 +6,12 @@ import pytest
 from astropy.io import fits
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.lamp import LampCalibration
-from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import VispConstantsDb
 from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
+from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import write_frames_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_darks_to_task
 from dkist_processing_visp.tests.header_models import VispHeadersInputLampGainFrames
@@ -24,9 +23,10 @@ def make_lamp_array_data(
     frame: VispHeadersInputLampGainFrames, dark_signal: float, beam_border: int
 ):
     num_raw_frames_per_fpa = frame.header()["CAM__014"]
+    modstate = frame.current_modstate("")  # Weird signature due to @key_function
     data = np.zeros(frame.array_shape)
-    data[0, :beam_border, :] = (1.1 + dark_signal) * num_raw_frames_per_fpa
-    data[0, beam_border:, :] = (1.2 + dark_signal) * num_raw_frames_per_fpa
+    data[0, :beam_border, :] = (1.0 + 0.1 * modstate + dark_signal) * num_raw_frames_per_fpa
+    data[0, beam_border:, :] = (2.0 + 0.1 * modstate + dark_signal) * num_raw_frames_per_fpa
 
     return data
 
@@ -91,14 +91,16 @@ def lamp_calibration_task(
             task._purge()
 
 
-def test_lamp_calibration_task(lamp_calibration_task, assign_input_dataset_doc_to_task, mocker):
+def test_lamp_calibration_task(
+    lamp_calibration_task, assign_input_dataset_doc_to_task, mocker, fake_gql_client
+):
     """
     Given: A LampCalibration task
     When: Calling the task instance
     Then: The correct number of output lamp gain frames exists, and are tagged correctly
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # Given
     task, num_modstates, readout_exp_time = lamp_calibration_task
@@ -131,27 +133,21 @@ def test_lamp_calibration_task(lamp_calibration_task, assign_input_dataset_doc_t
         VispTag.task_lamp_gain(),
         VispTag.intermediate(),
     ]
-    assert len(list(task.read(tags=tags))) == num_modstates * 2  # 2 from beams
-
-    for i in range(num_modstates):
-        for beam in [1, 2]:
-            tags = [
-                VispTag.task_lamp_gain(),
-                VispTag.intermediate(),
-                VispTag.modstate(i + 1),
-                VispTag.beam(beam),
-            ]
-            files = list(task.read(tags=tags))
-            assert len(files) == 1
-            hdu = fits.open(files[0])[0]
-            np.testing.assert_allclose(hdu.data, np.ones((10, 10)) * (1 + (0.1 * beam)))
+    assert len(list(task.read(tags=tags))) == 2  # One per beam
 
-    tags = [
-        VispTag.task_lamp_gain(),
-        VispTag.intermediate(),
-    ]
-    for filepath in task.read(tags=tags):
-        assert filepath.exists()
+    for beam in [1, 2]:
+        tags = [
+            VispTag.task_lamp_gain(),
+            VispTag.intermediate(),
+            VispTag.beam(beam),
+        ]
+        files = list(task.read(tags=tags))
+        assert len(files) == 1
+
+        expected_signal = beam + np.mean(np.arange(1, num_modstates + 1)) * 0.1
+
+        hdu = fits.open(files[0])[0]
+        np.testing.assert_allclose(hdu.data, np.ones(intermediate_shape) * expected_signal)
 
     quality_files = task.read(tags=[Tag.quality("TASK_TYPES")])
     for file in quality_files:

dkist_processing_visp/tests/test_make_movie_frames.py

@@ -1,7 +1,7 @@
 import pytest
 from astropy.io import fits
 from dkist_processing_common._util.scratch import WorkflowFileSystem
-from dkist_processing_common.tests.conftest import FakeGQLClient
+from dkist_processing_common.models.fits_access import MetadataKey
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.make_movie_frames import MakeVispMovieFrames
@@ -30,14 +30,14 @@ def movie_frames_task(tmp_path, recipe_run_id, init_visp_constants_db):
 
 
 @pytest.mark.parametrize("pol_mode", ["observe_polarimetric", "observe_intensity"])
-def test_make_movie_frames(movie_frames_task, pol_mode, mocker):
+def test_make_movie_frames(movie_frames_task, pol_mode, mocker, fake_gql_client):
     """
     Given: A MakeVispMovieFrames task
     When: Calling the task instance
     Then: a fits file is made for each raster scan containing the movie frame for that scan
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task, num_maps, num_steps = movie_frames_task
     spectral_size = 3
@@ -57,5 +57,5 @@ def test_make_movie_frames(movie_frames_task, pol_mode, mocker):
     for filepath in task.read(tags=[VispTag.movie_frame()]):
         assert filepath.exists()
         hdul = fits.open(filepath)
-        assert hdul[0].header["INSTRUME"] == "VISP"
+        assert hdul[0].header[MetadataKey.instrument] == "VISP"
         assert hdul[0].data.shape == expected_movie_fram_shape

dkist_processing_visp/tests/test_map_repeats.py

@@ -14,6 +14,7 @@ from dkist_processing_common.parsers.single_value_single_key_flower import (
 )
 
 from dkist_processing_visp.models.constants import VispBudName
+from dkist_processing_visp.models.fits_access import VispMetadataKey
 from dkist_processing_visp.models.tags import VispStemName
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.parsers.map_repeats import MapScanFlower
@@ -90,7 +91,8 @@ class ParseTaskJustMapStuff(ParseL0VispInputData):
             MapScanFlower(),
             RasterScanStepFlower(),
             SingleValueSingleKeyFlower(
-                tag_stem_name=VispStemName.modstate.value, metadata_key="modulator_state"
+                tag_stem_name=VispStemName.modstate.value,
+                metadata_key=VispMetadataKey.modulator_state,
             ),
         ]
 

dkist_processing_visp/tests/test_parameters.py

@@ -1,13 +1,15 @@
 from dataclasses import asdict
 from dataclasses import dataclass
 
+import astropy.units as u
 import numpy as np
 import pytest
+from hypothesis import HealthCheck
 from hypothesis import example
 from hypothesis import given
-from hypothesis import HealthCheck
 from hypothesis import settings
 from hypothesis import strategies as st
+from pydantic import BaseModel
 
 from dkist_processing_visp.models.parameters import VispParameters
 from dkist_processing_visp.models.parameters import VispParsingParameters
@@ -15,10 +17,27 @@ from dkist_processing_visp.tasks.visp_base import VispTaskBase
 from dkist_processing_visp.tests.conftest import VispConstantsDb
 from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
 
-# The property names of all parameters on `VispParsingParameters`
-PARSE_PARAMETER_NAMES = [
-    k for k, v in vars(VispParsingParameters).items() if isinstance(v, property)
-]
+
+@pytest.fixture(scope="session")
+def parse_parameter_names() -> list[str]:
+    # The property names of all parameters on `VispParsingParameters`
+    return [k for k, v in vars(VispParsingParameters).items() if isinstance(v, property)]
+
+
+@pytest.fixture(scope="session")
+def arm_parameter_names() -> list[str]:
+    return [
+        "wavecal_camera_lens_parameters",
+    ]
+
+
+@pytest.fixture(scope="session")
+def unit_parameter_names_and_units() -> dict[str, u.Unit | list[u.Unit]]:
+    return {
+        "solar_vignette_crval_bounds_px": u.pix,
+        "wavecal_camera_lens_parameters": [u.m, u.m / u.nm, u.m / u.nm**2],
+        "wavecal_pixel_pitch_micron_per_pix": u.um / u.pix,
+    }
 
 
 @pytest.fixture(scope="function")
@@ -27,6 +46,7 @@ def basic_science_task_with_parameter_mixin(
     assign_input_dataset_doc_to_task,
     init_visp_constants_db,
     testing_obs_ip_start_time,
+    arm_id,
 ):
     def make_task(
         parameters_part: dataclass,
@@ -34,8 +54,7 @@ def basic_science_task_with_parameter_mixin(
         obs_ip_start_time=testing_obs_ip_start_time,
     ):
         class Task(VispTaskBase):
-            def run(self):
-                ...
+            def run(self): ...
 
         init_visp_constants_db(recipe_run_id, VispConstantsDb())
         task = Task(
@@ -49,8 +68,9 @@ def basic_science_task_with_parameter_mixin(
                 parameters_part,
                 parameter_class=parameter_class,
                 obs_ip_start_time=obs_ip_start_time,
+                arm_id=arm_id,
             )
-            yield task, parameters_part
+            yield task, asdict(parameters_part)
         except:
             raise
         finally:
@@ -59,7 +79,14 @@ def basic_science_task_with_parameter_mixin(
     return make_task
 
 
-def test_non_wave_parameters(basic_science_task_with_parameter_mixin):
+@pytest.mark.parametrize("arm_id", [pytest.param("1"), pytest.param("2"), pytest.param("3")])
+def test_non_wave_parameters(
+    basic_science_task_with_parameter_mixin,
+    parse_parameter_names,
+    arm_parameter_names,
+    unit_parameter_names_and_units,
+    arm_id,
+):
     """
     Given: A Science task with the parameter mixin
     When: Accessing properties for parameters that do not depend on wavelength
@@ -69,15 +96,41 @@ def test_non_wave_parameters(basic_science_task_with_parameter_mixin):
         basic_science_task_with_parameter_mixin(VispInputDatasetParameterValues())
     )
     task_param_attr = task.parameters
-    for pn, pv in asdict(expected).items():
-        property_name = pn.removeprefix("visp_")
+    parameter_properties = [k for k, v in vars(VispParameters).items() if isinstance(v, property)]
+    for parameter_name in parameter_properties:
+        pn = f"visp_{parameter_name}"
+        if parameter_name in arm_parameter_names:
+            pn = f"{pn}_{arm_id}"
+        pv = expected[pn]
+        is_wavelength_param = isinstance(pv, dict) and "wavelength" in pv
         if (
-            type(pv) is not dict and property_name not in PARSE_PARAMETER_NAMES
-        ):  # Don't test wavelength dependent parameters
-            assert getattr(task_param_attr, property_name) == pv
+            parameter_name not in parse_parameter_names
+            and not is_wavelength_param
+            and parameter_name != "solar_vignette_wavecal_fit_kwargs"
+        ):
+            param_obj_value = getattr(task_param_attr, parameter_name)
+            if isinstance(pv, tuple):
+                pv = list(pv)
 
+            if parameter_name in unit_parameter_names_and_units:
+                expected_units = unit_parameter_names_and_units[parameter_name]
+                if not isinstance(param_obj_value, list):
+                    param_obj_value = [param_obj_value]
+                    pv = [pv]
+                    expected_units = [expected_units]
 
-def test_parse_parameters(basic_science_task_with_parameter_mixin):
+                assert all([param_obj_value[i].value == pv[i] for i in range(len(pv))])
+                assert all(
+                    [param_obj_value[i].unit == expected_units[i] for i in range(len(pv))]
+                ), f"Units {[v.unit for v in param_obj_value]} does not match expected {expected_units}"
+            elif isinstance(param_obj_value, BaseModel):
+                assert param_obj_value.model_dump() == pv
+            else:
+                assert getattr(task_param_attr, parameter_name) == pv
+
+
+@pytest.mark.parametrize("arm_id", ["1"])
+def test_parse_parameters(basic_science_task_with_parameter_mixin, parse_parameter_names):
     """
     Given: A Science task with Parsing parameters
     When: Accessing properties for Parse parameters
@@ -91,16 +144,19 @@ def test_parse_parameters(basic_science_task_with_parameter_mixin):
         )
     )
     task_param_attr = task.parameters
-    for pn, pv in asdict(expected).items():
+    for pn, pv in expected.items():
         property_name = pn.removeprefix("visp_")
-        if property_name in PARSE_PARAMETER_NAMES and type(pv) is not dict:
+        if property_name in parse_parameter_names and type(pv) is not dict:
             assert getattr(task_param_attr, property_name) == pv
 
 
 @given(wave=st.floats(min_value=500.0, max_value=2000.0))
 @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
 @example(wave=492.5)
-def test_wave_parameters(basic_science_task_with_parameter_mixin, wave):
+@pytest.mark.parametrize("arm_id", ["1"])
+def test_wave_parameters(
+    basic_science_task_with_parameter_mixin, parse_parameter_names, arm_parameter_names, wave
+):
     """
     Given: A Science task with the paramter mixin
     When: Accessing properties for parameters that depend on wavelength
@@ -111,10 +167,55 @@ def test_wave_parameters(basic_science_task_with_parameter_mixin, wave):
     )
     task_param_attr = task.parameters
     task_param_attr._wavelength = wave
-    pwaves = np.array(expected.visp_solar_zone_normalization_percentile.wavelength)
+    pwaves = np.array(expected["visp_geo_zone_normalization_percentile"]["wavelength"])
     midpoints = 0.5 * (pwaves[1:] + pwaves[:-1])
     idx = np.sum(midpoints < wave)
-    for pn, pv in asdict(expected).items():
+    for pn, pv in expected.items():
         property_name = pn.removeprefix("visp_")
-        if type(pv) is dict and property_name not in PARSE_PARAMETER_NAMES:
+        is_wavelength_param = isinstance(pv, dict) and "wavelength" in pv
+        if is_wavelength_param and property_name not in parse_parameter_names + arm_parameter_names:
             assert getattr(task_param_attr, property_name) == pv["values"][idx]
+
+
+class AnyInt:
+    pass
+
+
+@pytest.mark.parametrize("arm_id", [pytest.param("1")])
+@pytest.mark.parametrize(
+    "db_value, expected",
+    [
+        pytest.param({"method": "nelder"}, {"method": "nelder"}, id="non_rng_method"),
+        pytest.param(
+            {"method": "basinhopping"}, {"method": "basinhopping", "rng": AnyInt}, id="random_rng"
+        ),
+        pytest.param(
+            {"method": "differential_evolution", "rng": 6.28},
+            {"method": "differential_evolution", "rng": 6.28},
+            id="override_rng",
+        ),
+        pytest.param(dict(), dict(), id="no_kwargs"),
+    ],
+)
+def test_fit_kwarg_parameters(
+    basic_science_task_with_parameter_mixin,
+    db_value,
+    expected,
+):
+    """
+    Given: A Science task with the parameter mixin
+    When: Accessing properties for parameters that do not depend on wavelength
+    Then: The correct value is returned
+    """
+    task, _ = next(
+        basic_science_task_with_parameter_mixin(
+            VispInputDatasetParameterValues(visp_solar_vignette_wavecal_fit_kwargs=db_value)
+        )
+    )
+    kwarg_dict = task.parameters.solar_vignette_wavecal_fit_kwargs
+    assert kwarg_dict.keys() == expected.keys()
+    for k in expected.keys():
+        if expected[k] is AnyInt:
+            assert type(kwarg_dict[k]) is int
+        else:
+            assert expected[k] == kwarg_dict[k]