Make parse_optional_parameter accept multiple params.

filter_functions/numeric.py

@@ -335,7 +335,7 @@ def calculate_control_matrix_periodic(phases: ndarray, R: ndarray,
     return R_tot
 
 
-@util.parse_optional_parameter('which', ('total', 'correlations'))
+@util.parse_optional_parameters({'which': ('total', 'correlations')})
 def calculate_cumulant_function(
         pulse: 'PulseSequence',
         S: ndarray,
@@ -478,7 +478,7 @@ def calculate_cumulant_function(
     return K.real
 
 
-@util.parse_optional_parameter('which', ('total', 'correlations'))
+@util.parse_optional_parameters({'which': ('total', 'correlations')})
 def calculate_decay_amplitudes(
         pulse: 'PulseSequence',
         S: ndarray,
@@ -888,7 +888,7 @@ def error_transfer_matrix(
     return U
 
 
-@util.parse_optional_parameter('which', ('total', 'correlations'))
+@util.parse_optional_parameters({'which': ('total', 'correlations')})
 def infidelity(pulse: 'PulseSequence',
                S: Union[Coefficients, Callable],
                omega: Union[Coefficients, Dict[str, Union[int, str]]],

filter_functions/pulse_sequence.py

@@ -836,8 +836,8 @@ def nbytes(self) -> int:
 
         return sum(_nbytes)
 
-    @util.parse_optional_parameter(
-        'method', ('conservative', 'greedy', 'frequency dependent', 'all'))
+    @util.parse_optional_parameters(
+        {'method': ('conservative', 'greedy', 'frequency dependent', 'all')})
     def cleanup(self, method: str = 'conservative') -> None:
         """
         Delete cached byproducts of the calculation of the filter function that

filter_functions/util.py

@@ -79,8 +79,8 @@
 import string
 import sys
 from itertools import zip_longest
-from typing import (Callable, Generator, Iterable, List, Optional, Sequence,
-                    Tuple, Union)
+from typing import (Callable, Dict, Generator, Iterable, List, Optional,
+                    Sequence, Tuple, Union)
 
 import numpy as np
 import qutip as qt
@@ -1119,34 +1119,36 @@ def progressbar_range(*args, show_progressbar: Optional[bool] = True,
     return range(*args)
 
 
-def parse_optional_parameter(name: str, allowed: Sequence) -> Callable:
+def parse_optional_parameters(params_dict: Dict[str, Sequence]) -> Callable:
     """Decorator factory to parse optional parameter with certain legal values.
 
-    If the parameter value corresponding to ``name`` (either in args or kwargs)
-    is not contained in ``allowed`` a ``ValueError`` is raised.
+    For ``params_dict = {name: allowed, ...}``: If the parameter value
+    corresponding to ``name`` (either in args or kwargs of the decorated
+    function) is not contained in ``allowed`` a ``ValueError`` is raised.
     """
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
             parameters = inspect.signature(func).parameters
-            idx = tuple(parameters).index(name)
-            try:
-                value = args[idx]
-            except IndexError:
-                value = kwargs.get(name, parameters[name].default)
-
-            if value not in allowed:
-                raise ValueError(
-                    "Invalid value for {}: {}. ".format(name, value) +
-                    "Should be one of {}.".format(allowed)
-                )
+            for name, allowed in params_dict.items():
+                idx = tuple(parameters).index(name)
+                try:
+                    value = args[idx]
+                except IndexError:
+                    value = kwargs.get(name, parameters[name].default)
+
+                if value not in allowed:
+                    raise ValueError(
+                        "Invalid value for {}: {}. ".format(name, value) +
+                        "Should be one of {}.".format(allowed)
+                    )
             return func(*args, **kwargs)
         return wrapper
     return decorator
 
 
-parse_which_FF_parameter = parse_optional_parameter(
-    'which', ('fidelity', 'generalized'))
+parse_which_FF_parameter = parse_optional_parameters(
+    {'which': ('fidelity', 'generalized')})
 
 
 class CalculationError(Exception):

tests/test_util.py

@@ -609,9 +609,9 @@ def test_progressbar_range(self):
 
         self.assertEqual(ii, list(range(523, 123, -32)))
 
-    def test_parse_optional_parameter(self):
+    def test_parse_optional_parameters(self):
 
-        @util.parse_optional_parameter('foo', [1, 'bar', (2, 3)])
+        @util.parse_optional_parameters({'foo': [1, 'bar', (2, 3)]})
         def foobar(a, b, foo=None, x=2):
             pass