dkist-processing-common 10.5.4__py3-none-any.whl → 12.1.0rc1__py3-none-any.whl

dkist_processing_common/tests/test_dkist_location.py

@@ -0,0 +1,15 @@
+import pytest
+from astropy.coordinates import EarthLocation
+
+from dkist_processing_common.models.dkist_location import location_of_dkist
+
+
+@pytest.mark.flaky(max_reruns=10)
+def test_location_of_dkist():
+    """
+    Given: function for retrieving the dkist location on earth
+    When: Call function
+    Then: result is the same as what is in the astropy online database
+    """
+    itrs = location_of_dkist
+    assert itrs == EarthLocation.of_site("dkist")

dkist_processing_common/tests/test_fits_access.py

@@ -1,8 +1,11 @@
+from enum import StrEnum
+
 import numpy as np
 import pytest
 from astropy.io import fits
 
 from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 from dkist_processing_common.parsers.l1_fits_access import L1FitsAccess
 
@@ -22,19 +25,21 @@ def hdu_with_complete_common_header(complete_common_header):
 def hdu_with_special_keys(hdu_with_complete_common_header, request):
     """
     An HDU with data and a header that includes variations on the special keys that make headers
-    different from dict's.
+    different from dicts.
+
+    The base complete_common_header already has history and comment cards so this fixture adds extras.
     """
     add_special = request.param
     hdu = hdu_with_complete_common_header
     if add_special == "history":
         hdu.header.add_history("test history")
-        return hdu
+        return hdu, request.param
     if add_special == "comment":
-        hdu.header.add_history("test comment")
-        return hdu
+        hdu.header.add_comment("test comment")
+        return hdu, request.param
     if add_special == "continue":
         hdu.header["LONG_VAL"] = " " * 100
-        return hdu
+        return hdu, request.param
 
 
 @pytest.fixture()
@@ -91,14 +96,15 @@ def hdu_with_no_data(complete_common_header):
 
 
 @pytest.fixture()
-def hdu_with_incomplete_common_header(tmp_path):
+def hdu_with_incomplete_common_header(complete_common_header):
     """
-    An HDU with data and a header missing one of the expected common by-frame keywords
+    An HDU with data and a header missing two of the expected common by-frame keywords
     """
+    incomplete_header = complete_common_header
+    incomplete_header.pop(MetadataKey.elevation)
+    incomplete_header.pop(MetadataKey.azimuth)
     data = np.arange(9).reshape(3, 3)
-    hdu = fits.PrimaryHDU(data)
-    hdu.header["TELEVATN"] = 6.28
-    hdu.header["TAZIMUTH"] = 3.14
+    hdu = fits.PrimaryHDU(data, header=incomplete_header)
     return hdu
 
 
@@ -125,19 +131,45 @@ def fits_file_path_with_data_in_imagehdu(tmp_path, complete_common_header):
     return file_path
 
 
+class MetadataKeyWithNaxisKeys(StrEnum):
+    naxis = "NAXIS"
+    naxis1 = "NAXIS1"
+    naxis2 = "NAXIS2"
+
+
 class FitsAccessWithNaxisKeys(FitsAccessBase):
     def __init__(self, hdu, name):
         super().__init__(hdu, name)
-        self.naxis = self.header["NAXIS"]
-        self.naxis1 = self.header["NAXIS1"]
-        self.naxis2 = self.header["NAXIS2"]
+        self.naxis = self.header[MetadataKeyWithNaxisKeys.naxis]
+        self.naxis1 = self.header[MetadataKeyWithNaxisKeys.naxis1]
+        self.naxis2 = self.header[MetadataKeyWithNaxisKeys.naxis2]
+
+
+def test_metadata_keys_in_access_bases(hdu_with_no_data):
+    """
+    Given: a set of metadata key names in the MetadataKey sting enumeration
+    When: the FITS access classes define a set of attributes/properties
+    Then: the sets are the same and the values of the attributes/properties are correct
+    """
+    all_metadata_key_names = {mk.name for mk in MetadataKey}
+    hdu = hdu_with_no_data
+    fits_obj = L0FitsAccess(hdu=hdu)
+    fits_access_defined_attributes = {
+        k for k, v in fits_obj.__dict__.items() if k not in ["_hdu", "name", "auto_squeeze"]
+    }
+    l0_access_properties = {k for k, v in L0FitsAccess.__dict__.items() if isinstance(v, property)}
+    l1_access_properties = {k for k, v in L1FitsAccess.__dict__.items() if isinstance(v, property)}
+    fits_access_properties = l0_access_properties | l1_access_properties
+    assert fits_access_defined_attributes | fits_access_properties == all_metadata_key_names
+    for key in fits_access_defined_attributes:
+        assert getattr(fits_obj, key) == fits_obj.header[MetadataKey[key]]
 
 
 def test_from_single_hdu(hdu_with_complete_common_header):
     """
     Given: an HDU with expected, common by-frame keywords
     When: loading the HDU with the L0FitsAccess class
-    Then: all values for common keywords are exposed as properties on the fits_obj class
+    Then: values for common keywords are exposed as properties on the fits_obj class
     """
     fits_obj = L0FitsAccess(hdu_with_complete_common_header)
     assert fits_obj.elevation == 6.28
@@ -152,7 +184,7 @@ def test_l1_only_fits_access(hdu_with_complete_l1_only_header):
     """
     Given: an HDU with 214 L1-only headers
     When: loading the HDU with the L1FitsAccess class
-    Then: no errors are raised and all values are exposed
+    Then: no errors are raised and values are exposed
     """
     fits_obj = L1FitsAccess(hdu_with_complete_l1_only_header)
     assert fits_obj.elevation == 6.28
@@ -220,7 +252,7 @@ def test_as_subclass(hdu_with_complete_common_header):
     class InstFitsAccess(L0FitsAccess):
         def __init__(self, hdu, name):
             super().__init__(hdu, name)
-            self.foo: str = self.header["INST_FOO"]
+            self.foo: str = self.header["VISP_012"]
 
     fits_obj = InstFitsAccess(hdu_with_complete_common_header, name="foo")
     assert fits_obj.foo == "bar"
@@ -282,11 +314,16 @@ def test_header_dict(hdu_with_special_keys):
     """
     Given: A FitsAccess object with data and a header including special header keys
     When: Accessing the header_dict method
-    Then: The object's header is successfully exported as a dict of the same length as the header
+    Then: The object's header is successfully exported as a dict of the same length as the header when accounting for multiple HISTORY or COMMENT cards
     """
-    fits_obj = FitsAccessBase(hdu_with_special_keys)
+    hdu, added_header_key = hdu_with_special_keys
+    fits_obj = FitsAccessBase(hdu)
     assert isinstance(fits_obj.header_dict, dict)
-    assert len(fits_obj.header_dict) == len(fits_obj.header)
+    if added_header_key == "continue":
+        assert len(fits_obj.header_dict) == len(fits_obj.header)
+    if added_header_key in ["history", "comment"]:
+        # HISTORY and COMMENT keys get "squeezed"
+        assert len(fits_obj.header_dict) == len(fits_obj.header) - 1
 
 
 @pytest.mark.parametrize(

dkist_processing_common/tests/test_flower_pot.py

@@ -4,11 +4,13 @@ from typing import Hashable
 import pytest
 
 from dkist_processing_common.models.flower_pot import FlowerPot
+from dkist_processing_common.models.flower_pot import ListStem
+from dkist_processing_common.models.flower_pot import SetStem
 from dkist_processing_common.models.flower_pot import SpilledDirt
 from dkist_processing_common.models.flower_pot import Stem
 
 
-@pytest.fixture()
+@pytest.fixture
 def simple_flower():
     class Flower(Stem):
         def setter(self, value: Any) -> Any:
@@ -22,7 +24,7 @@ def simple_flower():
     return Flower(stem_name="simple_flower")
 
 
-@pytest.fixture()
+@pytest.fixture
 def simple_flower_pot(simple_flower):
     flower_pot = FlowerPot()
     flower_pot.stems += [simple_flower]
@@ -30,16 +32,66 @@ def simple_flower_pot(simple_flower):
     return flower_pot
 
 
-@pytest.fixture()
+@pytest.fixture
 def simple_key_values():
     return {f"thing{i}": i for i in range(5)}
 
 
+@pytest.fixture
+def stem_bud():
+    class Bud(Stem):
+        def setter(self, value: int) -> int:
+            return value % 3
+
+        def getter(self, key: str) -> int:
+            return len(set(self.key_to_petal_dict.values()))
+
+    return Bud(stem_name="StemBud")
+
+
+@pytest.fixture
+def setstem_bud():
+    # Computes the same result as `stem_bud`
+    class SetBud(SetStem):
+        def setter(self, value: int) -> int:
+            return value % 3
+
+        def getter(self) -> int:
+            return len(self.value_set)
+
+    return SetBud(stem_name="SetStemBud")
+
+
+@pytest.fixture
+def liststem_bud():
+    # Highlights the difference between using a `set` and a `list` in these more efficient buds
+    class ListBud(ListStem):
+        def setter(self, value: int) -> int:
+            return value % 3
+
+        def getter(self) -> int:
+            return len(self.value_list)
+
+    return ListBud(stem_name="ListStemBud")
+
+
+@pytest.fixture
+def simple_bud_pot(stem_bud, setstem_bud, liststem_bud):
+    bud_pot = FlowerPot()
+    bud_pot.stems += [stem_bud, liststem_bud, setstem_bud]
+    return bud_pot
+
+
+@pytest.fixture
+def bud_key_values():
+    return {f"DOESN'T_MATTER_THAT'S_THE_POINT_{i}": i for i in [0, 1, 3, 4]}
+
+
 def test_simple_flower_pot(simple_flower_pot, simple_key_values):
     """
     Given: A FlowerPot with a simple Flower
-    When: Updating rock and flower with key: value pairs
-    Then: The rock and flower are correctly updated
+    When: Updating flower with key: value pairs
+    Then: The flower are correctly updated
     """
     assert len(simple_flower_pot) == 1
 
@@ -51,6 +103,8 @@ def test_simple_flower_pot(simple_flower_pot, simple_key_values):
 
     petals = sorted(list(flower.petals), key=lambda x: x.value)
     assert len(petals) == 2
+    assert flower.bud.value == petals[0].value
+    assert flower.bud.keys == petals[0].keys
     assert petals[0].value == 0
     assert petals[0].keys == ["thing0", "thing2", "thing4"]
     assert petals[1].value == 1
@@ -67,8 +121,12 @@ def test_cached_petal(simple_flower):
     value1 = 4
     simple_flower.update(key1, value1)
     assert len(simple_flower.petals) == 1
+
+    # Assert twice to hit the cache
     assert simple_flower.petals[0].value == value1 % 2  # % 2 because of simple_flower's `setter`
     assert simple_flower.petals[0].keys == [key1]
+    assert simple_flower.petals[0].value == value1 % 2
+    assert simple_flower.petals[0].keys == [key1]
 
     key2 = "thing2"
     value2 = 3
@@ -79,6 +137,10 @@ def test_cached_petal(simple_flower):
     assert sorted_petals[0].keys == [key1]
     assert sorted_petals[1].value == value2 % 2
     assert sorted_petals[1].keys == [key2]
+    assert sorted_petals[0].value == value1 % 2
+    assert sorted_petals[0].keys == [key1]
+    assert sorted_petals[1].value == value2 % 2
+    assert sorted_petals[1].keys == [key2]
 
 
 def test_spilled_dirt_flower(simple_flower):
@@ -103,3 +165,83 @@ def test_unhashable_dirt(simple_flower_pot):
     value = "never gonna get here"
     with pytest.raises(TypeError):
         simple_flower_pot.add_dirt(unhashable_key, value)
+
+
+def test_buds(simple_bud_pot, bud_key_values):
+    """
+    Given: A Flower pot with two Buds that compute the same thing; one a `Stem` and one a `SetStem`, and a `ListStem` bud
+    When: Updating the pot with key: value pairs
+    Then: The computed buds are correct and the `Stem` and `SetStem` buds match
+    """
+    assert len(simple_bud_pot) == 3
+
+    assert simple_bud_pot[0].stem_name == "StemBud"
+    assert simple_bud_pot[1].stem_name == "ListStemBud"
+    assert simple_bud_pot[2].stem_name == "SetStemBud"
+
+    for k, m in bud_key_values.items():
+        simple_bud_pot.add_dirt(k, m)
+
+    assert simple_bud_pot[0].bud.value == 2
+    assert simple_bud_pot[1].bud.value == 4
+    assert simple_bud_pot[2].bud.value == simple_bud_pot[0].bud.value
+
+    assert len(simple_bud_pot[0].petals) == 1
+    assert simple_bud_pot[0].petals[0].value == 2
+    assert simple_bud_pot[0].petals[0].keys == [
+        f"DOESN'T_MATTER_THAT'S_THE_POINT_{i}" for i in [0, 1, 3, 4]
+    ]
+
+    with pytest.raises(
+        AttributeError,
+        match="ListBud subclasses ListStem and therefore does not define the `petals` property",
+    ):
+        _ = simple_bud_pot[1].petals
+
+    with pytest.raises(
+        AttributeError,
+        match="SetBud subclasses SetStem and therefore does not define the `petals` property",
+    ):
+        _ = simple_bud_pot[2].petals
+
+
+def test_liststem_cached_bud(liststem_bud):
+    """
+    Given: A `ListStem` instance and some different input values
+    When: Computing the `bud` property after each value is ingested
+    Then: The `bud` value correctly updates based on the state of the `ListStem` object
+    """
+    key = "Who cares"
+    value1 = 3
+    liststem_bud.update(key, value1)
+
+    # Assert twice so we hit the cache
+    assert liststem_bud.bud.value == 1
+    assert liststem_bud.bud.value == 1
+
+    value2 = 1
+    liststem_bud.update(key, value2)
+
+    assert liststem_bud.bud.value == 2
+    assert liststem_bud.bud.value == 2
+
+
+def test_setstem_cached_bud(setstem_bud):
+    """
+    Given: A `SetStem` instance and some different input values
+    When: Computing the `bud` property after each value is ingested
+    Then: The `bud` value correctly updates based on the state of the `SetStem` object
+    """
+    key = "Who cares"
+    value1 = 3
+    setstem_bud.update(key, value1)
+
+    # Assert twice so we hit the cache
+    assert setstem_bud.bud.value == 1
+    assert setstem_bud.bud.value == 1
+
+    value2 = 1
+    setstem_bud.update(key, value2)
+
+    assert setstem_bud.bud.value == 2
+    assert setstem_bud.bud.value == 2

dkist_processing_common/tests/test_fried_parameter.py

@@ -0,0 +1,27 @@
+import pytest
+
+from dkist_processing_common.models.fried_parameter import r0_valid
+
+
+@pytest.mark.parametrize(
+    "r0, ao_lock, oob_shift, should_r0_exist",
+    [
+        pytest.param(0.2, True, 17, True, id="AO_LOCK_True_good_R0_good_oob"),
+        pytest.param(1, True, 17, False, id="AO_LOCK_True_bad_R0_good_oob"),
+        pytest.param(0.2, False, 17, False, id="AO_LOCK_False_good_R0_good_oob"),
+        pytest.param(1, False, 17, False, id="AO_LOCK_False_bad_R0_good_oob"),
+        pytest.param(0.2, True, 150, False, id="AO_LOCK_True_good_R0_bad_oob"),
+        pytest.param(1, True, 150, False, id="AO_LOCK_True_bad_R0_bad_oob"),
+        pytest.param(0.2, False, 150, False, id="AO_LOCK_False_good_R0_bad_oob"),
+        pytest.param(1, False, 150, False, id="AO_LOCK_False_bad_R0_bad_oob"),
+        pytest.param(0.2, None, 17, False, id="AO_LOCK_missing"),
+        pytest.param(0.2, True, None, True, id="OOBSHIFT_missing"),
+    ],
+)
+def test_check_r0_valid(r0, ao_lock, oob_shift, should_r0_exist):
+    """
+    :Given: values for r0, the ao_lock status, and the ao out of bound shift value
+    :When: checking for a valid state to use r0
+    :Then: valid conditions are marked True, invalid conditions marked False
+    """
+    assert r0_valid(r0, ao_lock, oob_shift) == should_r0_exist