Merge pull request #383 from AstarVienna/fh/reqkeys

Make `required_keys` always a `set`

scopesim/effects/apertures.py

@@ -78,6 +78,8 @@ class ApertureMask(Effect):
 
     """
 
+    required_keys = {"filename", "table", "array_dict"}
+
     def __init__(self, **kwargs):
         if not np.any([key in kwargs for key in ["filename", "table",
                                                  "array_dict"]]):
@@ -108,7 +110,6 @@ def __init__(self, **kwargs):
         self._mask = None
         self.mask_sum = None
 
-        self.required_keys = ["filename", "table", "array_dict"]
         check_keys(kwargs, self.required_keys, "warning", all_any="any")
 
     def apply_to(self, obj, **kwargs):
@@ -200,13 +201,15 @@ def plot(self, axes=None):
 
 
 class RectangularApertureMask(ApertureMask):
+    required_keys = {"x", "y", "width", "height"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         params = {"x_unit": "arcsec",
                   "y_unit": "arcsec"}
         self.meta.update(params)
         self.meta.update(kwargs)
-        check_keys(self.meta, ["x", "y", "width", "height"])
+        check_keys(self.meta, self.required_keys)
 
         self.table = self.get_table(**kwargs)
 
@@ -284,8 +287,9 @@ def __init__(self, **kwargs):
         self.meta.update(kwargs)
 
         if self.table is not None:
-            required_keys = ["id", "left", "right", "top", "bottom", "angle",
-                             "conserve_image", "shape"]
+            # Why not always?
+            required_keys = {"id", "left", "right", "top", "bottom", "angle",
+                             "conserve_image", "shape"}
             check_keys(self.table.colnames, required_keys)
 
     def apply_to(self, obj, **kwargs):

scopesim/effects/effects.py

@@ -34,6 +34,8 @@ class Effect(DataContainer):
 
     """
 
+    required_keys = set()
+
     def __init__(self, filename=None, **kwargs):
         super().__init__(filename=filename, **kwargs)
         self.meta["z_order"] = []

scopesim/effects/electronic.py

@@ -84,14 +84,15 @@ class DetectorModePropertiesSetter(Effect):
 
     """
 
+    required_keys = {"mode_properties"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         params = {"z_order": [299, 900]}
         self.meta.update(params)
         self.meta.update(kwargs)
 
-        required_keys = ["mode_properties"]
-        check_keys(self.meta, required_keys, action="error")
+        check_keys(self.meta, self.required_keys, action="error")
 
         self.mode_properties = kwargs["mode_properties"]
 
@@ -176,6 +177,8 @@ class AutoExposure(Effect):
 
     """
 
+    required_keys = {"fill_frac", "full_well", "mindit"}
+
     def __init__(self, **kwargs):
         """
         The effect is the first detector effect, hence essentially operates
@@ -189,8 +192,7 @@ def __init__(self, **kwargs):
             from scopesim import UserCommands
             self.cmds = UserCommands()
 
-        required_keys = ["fill_frac", "full_well", "mindit"]
-        check_keys(self.meta, required_keys, action="error")
+        check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, obj, **kwargs):
         if isinstance(obj, (ImagePlaneBase, DetectorBase)):
@@ -238,14 +240,15 @@ def apply_to(self, obj, **kwargs):
 class SummedExposure(Effect):
     """Simulates a summed stack of ``ndit`` exposures."""
 
+    required_keys = {"dit", "ndit"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         params = {"z_order": [860]}
         self.meta.update(params)
         self.meta.update(kwargs)
 
-        required_keys = ["dit", "ndit"]
-        check_keys(self.meta, required_keys, action="error")
+        check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, obj, **kwargs):
         if isinstance(obj, DetectorBase):
@@ -260,14 +263,15 @@ def apply_to(self, obj, **kwargs):
 class Bias(Effect):
     """Adds a constant bias level to readout."""
 
+    required_keys = {"bias"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         params = {"z_order": [855]}
         self.meta.update(params)
         self.meta.update(kwargs)
 
-        required_keys = ["bias"]
-        check_keys(self.meta, required_keys, action="error")
+        check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, obj, **kwargs):
         if isinstance(obj, DetectorBase):
@@ -277,20 +281,23 @@ def apply_to(self, obj, **kwargs):
         return obj
 
 class PoorMansHxRGReadoutNoise(Effect):
+    required_keys = {"noise_std", "n_channels", "ndit"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        params = {"z_order": [811],
-                  "pedestal_fraction": 0.3,
-                  "read_fraction": 0.4,
-                  "line_fraction": 0.25,
-                  "channel_fraction": 0.05,
-                  "random_seed": "!SIM.random.seed",
-                  "report_plot_include": False,
-                  "report_table_include": False}
+        params = {
+            "z_order": [811],
+            "pedestal_fraction": 0.3,
+            "read_fraction": 0.4,
+            "line_fraction": 0.25,
+            "channel_fraction": 0.05,
+            "random_seed": "!SIM.random.seed",
+            "report_plot_include": False,
+            "report_table_include": False,
+        }
         self.meta.update(params)
         self.meta.update(kwargs)
 
-        self.required_keys = ["noise_std", "n_channels", "ndit"]
         check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, det, **kwargs):
@@ -332,13 +339,14 @@ def plot_hist(self, det, **kwargs):
 class BasicReadoutNoise(Effect):
     """Readout noise computed as: ron * sqrt(NDIT)."""
 
+    required_keys = {"noise_std", "ndit"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.meta["z_order"] = [811]
         self.meta["random_seed"] = "!SIM.random.seed"
         self.meta.update(kwargs)
 
-        self.required_keys = ["noise_std", "ndit"]
         check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, det, **kwargs):
@@ -417,12 +425,14 @@ class DarkCurrent(Effect):
     """
     required: dit, ndit, value
     """
+
+    required_keys = {"value", "dit", "ndit"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.meta["z_order"] = [830]
 
-        required_keys = ["value", "dit", "ndit"]
-        check_keys(self.meta, required_keys, action="error")
+        check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, obj, **kwargs):
         if isinstance(obj, DetectorBase):
@@ -487,6 +497,8 @@ class LinearityCurve(Effect):
 
     """
 
+    required_keys = {"ndit"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         params = {
@@ -497,7 +509,6 @@ def __init__(self, **kwargs):
         self.meta.update(params)
         self.meta.update(kwargs)
 
-        self.required_keys = ["ndit"]
         check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, obj, **kwargs):
@@ -562,11 +573,12 @@ def plot(self, implane, **kwargs):
 
 
 class BinnedImage(Effect):
+    required_keys = {"bin_size"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.meta["z_order"] = [870]
 
-        self.required_keys = ["bin_size"]
         check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, det, **kwargs):
@@ -580,11 +592,12 @@ def apply_to(self, det, **kwargs):
         return det
 
 class UnequalBinnedImage(Effect):
+    required_keys = {"binx","biny"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.meta["z_order"] = [870]
 
-        self.required_keys = ["binx","biny"]
         check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, det, **kwargs):

scopesim/effects/obs_strategies.py

@@ -50,8 +50,10 @@ class ChopNodCombiner(Effect):
 
     """
 
+    required_keys = {"chop_offsets", "pixel_scale"}
+
     def __init__(self, **kwargs):
-        check_keys(kwargs, ["chop_offsets", "pixel_scale"])
+        check_keys(kwargs, self.required_keys)
 
         super().__init__(**kwargs)
         params = {

scopesim/effects/psfs.py

@@ -166,13 +166,14 @@ def __init__(self, **kwargs):
 class Vibration(AnalyticalPSF):
     """Creates a wavelength independent kernel image."""
 
+    required_keys = {"fwhm", "pixel_scale"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.meta["z_order"] = [244, 744]
         self.meta["width_n_fwhms"] = 4
         self.convolution_classes = ImagePlaneBase
 
-        self.required_keys = ["fwhm", "pixel_scale"]
         check_keys(self.meta, self.required_keys, action="error")
         self.kernel = None
 
@@ -197,6 +198,8 @@ class NonCommonPathAberration(AnalyticalPSF):
     Accepted: kernel_width, strehl_drift
     """
 
+    required_keys = {"pixel_scale"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.meta["z_order"] = [241, 641]
@@ -210,7 +213,6 @@ def __init__(self, **kwargs):
         self.valid_waverange = [0.1 * u.um, 0.2 * u.um]
 
         self.convolution_classes = FieldOfViewBase
-        self.required_keys = ["pixel_scale"]
         check_keys(self.meta, self.required_keys, action="error")
 
     def fov_grid(self, which="waveset", **kwargs):
@@ -435,6 +437,8 @@ class AnisocadoConstPSF(SemiAnalyticalPSF):
 
     """
 
+    required_keys = {"filename", "strehl", "wavelength"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         params = {
@@ -446,7 +450,6 @@ def __init__(self, **kwargs):
         self.meta.update(params)
         self.meta.update(kwargs)
 
-        self.required_keys = ["filename", "strehl", "wavelength"]
         check_keys(self.meta, self.required_keys, action="error")
         self.nmRms      # check to see if it throws an error
 
@@ -593,11 +596,13 @@ class FieldConstantPSF(DiscretePSF):
     For spectroscopy, a wavelength-dependent PSF cube is built, where for each
     wavelength the reference PSF is scaled proportional to wavelength.
     """
+
+    required_keys = {"filename"}
+
     def __init__(self, **kwargs):
         # sub_pixel_flag and flux_accuracy are taken care of in PSF base class
         super().__init__(**kwargs)
 
-        self.required_keys = ["filename"]
         check_keys(self.meta, self.required_keys, action="error")
 
         self.meta["z_order"] = [262, 662]
@@ -723,11 +728,12 @@ class FieldVaryingPSF(DiscretePSF):
 
     """
 
+    required_keys = {"filename"}
+
     def __init__(self, **kwargs):
         # sub_pixel_flag and flux_accuracy are taken care of in PSF base class
         super().__init__(**kwargs)
 
-        self.required_keys = ["filename"]
         check_keys(self.meta, self.required_keys, action="error")
 
         self.meta["z_order"] = [261, 661]

scopesim/effects/rotation.py

@@ -23,14 +23,15 @@ class Rotate90CCD(Effect):
 
     """
 
+    required_keys = {"rotations"}
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         params = {"z_order": [809]}
         self.meta.update(params)
         self.meta.update(kwargs)
 
-        required_keys = ["rotations"]
-        utils.check_keys(self.meta, required_keys, action="error")
+        utils.check_keys(self.meta, self.required_keys, action="error")
 
     def apply_to(self, obj, **kwargs):
         """See parent docstring."""