Adds support for required/ mandatory parameter values

examples/user_guide/Parameters.ipynb

@@ -35,6 +35,7 @@
  "- **instantiate**: Whether to deepcopy the default value into a Parameterized instance when it is created. False by default for Parameter and most of its subtypes, but some Parameter types commonly used with mutable containers default to `instantiate=True` to avoid interaction between separate Parameterized instances, and users can control this when declaring the Parameter (see below). \n",
  "- **per_instance**: whether a separate Parameter instance will be created for every Parameterized instance created. Similar to `instantiate`, but applies to the Parameter object rather than to its value.\n",
  "- **precedence**: Optional numeric value controlling whether this parameter is visible in a listing and if so in what order.\n",
+ "- **required**: Whether a value must be provided on instantiation of a Parameterized object.\n",
  "\n",
  "Most of these settings (apart from **name**) are accepted as keyword arguments to the Parameter's constructor, with `default` also accepted as a positional argument:"
  ]

param/parameterized.py

@@ -986,7 +986,7 @@ class Foo(Bar):
  __slots__ = ['name', '_internal_name', 'default', 'doc',
  'precedence', 'instantiate', 'constant', 'readonly',
  'pickle_default_value', 'allow_None', 'per_instance',
- 'watchers', 'owner', '_label']
+ 'watchers', 'owner', '_label', 'required']
 
  # Note: When initially created, a Parameter does not know which
  # Parameterized class owns it, nor does it know its names
@@ -999,14 +999,14 @@ class Foo(Bar):
  _slot_defaults = dict(
  default=None, precedence=None, doc=None, _label=None, instantiate=False,
  constant=False, readonly=False, pickle_default_value=True, allow_None=False,
- per_instance=True
+ per_instance=True, required=False
  )
 
  def __init__(self, default=Undefined, doc=Undefined, # pylint: disable-msg=R0913
  label=Undefined, precedence=Undefined,
  instantiate=Undefined, constant=Undefined, readonly=Undefined,
  pickle_default_value=Undefined, allow_None=Undefined,
- per_instance=Undefined):
+ per_instance=Undefined, required=Undefined):
 
  """Initialize a new Parameter object and store the supplied attributes:
 
@@ -1074,6 +1074,9 @@ def __init__(self, default=Undefined, doc=Undefined, # pylint: disable-msg=R0913
  allowed. If the default value is defined as None, allow_None
  is set to True automatically.
 
+ required: If True a value must be provided on instantiation of a
+ Parameterized object.
+
  default, doc, and precedence all default to None, which allows
  inheritance of Parameter slots (attributes) from the owning-class'
  class hierarchy (see ParameterizedMetaclass).
@@ -1093,6 +1096,7 @@ class hierarchy (see ParameterizedMetaclass).
  self._set_allow_None(allow_None)
  self.watchers = {}
  self.per_instance = per_instance
+ self.required = required
 
  @classmethod
  def serialize(cls, value):
@@ -1653,6 +1657,36 @@ def _generate_name(self_):
  self = self_.param.self
  self.param._set_name('%s%05d' % (self.__class__.__name__ ,object_count))
 
+ @as_uninitialized
+ def _check_required(self_, **params):
+ cls = self_.param.cls
+
+ # Map of all the class parameters
+ parameters = {}
+ for class_ in classlist(cls):
+ for name, val in class_.__dict__.items():
+ if isinstance(val, Parameter):
+ parameters[name] = val
+ # Find what Parameters are required but were not passed to the
+ # constructor.
+ missing = [
+ pname
+ for pname, p in parameters.items()
+ if p.required and pname not in params
+ ]
+ # Format the error
+ if missing:
+ missing = [f'{s!r}' for s in missing]
+ if len(missing) > 1:
+ kw = ', '.join(missing[:-1])
+ kw = kw + f'{"," if len(missing) > 2 else ""} and {missing[-1]}'
+ else:
+ kw = missing[0]
+ message = (
+ f"{cls.name}.__init__() missing {len(missing)} required keyword-only "
+ f"argument{'s' if len(missing) >1 else ''}: {kw}"
+ )
+ raise TypeError(message)
 
  @as_uninitialized
  def _setup_params(self_,**params):
@@ -3205,6 +3239,7 @@ def __init__(self, **params):
  self._dynamic_watchers = defaultdict(list)
 
  self.param._generate_name()
+ self.param._check_required(**params)
  self.param._setup_params(**params)
  object_count += 1
 

tests/testparameterizedobject.py

@@ -824,6 +824,99 @@ class B(A):
  assert B.p == 1
 
 
+@pytest.mark.parametrize(["default", "value"], [
+ (None,"v"), ("d", "v")
+])
+def test_required(default, value):
+ """Test that you can make a parameter required and it will not raise
+ an error if provided."""
+ class P(param.Parameterized):
+ value1 = param.Parameter(default=default, required=True)
+ value2 = param.Parameter(default=default, required=True)
+ notrequired = param.Parameter(default=default, required=False)
+
+ po = P(value1=value, value2=value)
+ assert po.value1 == value
+ assert po.value2 == value
+
+
+@pytest.mark.parametrize("default", [None, "d"])
+def test_required_raises(default):
+ """Test that you can make a parameter required and it will raise
+ an error if not provided."""
+ class P(param.Parameterized):
+ value1 = param.Parameter(default=default, required=True)
+ notrequired = param.Parameter(default=default, required=False)
+
+ with pytest.raises(
+ TypeError,
+ match=re.escape(r"P.__init__() missing 1 required keyword-only argument: 'value1'"),
+ ):
+ P()
+
+ class Q(param.Parameterized):
+ value1 = param.Parameter(default=default, required=True)
+ value2 = param.Parameter(default=default, required=True)
+ notrequired = param.Parameter(default=default, required=False)
+
+ with pytest.raises(
+ TypeError,
+ match=re.escape(r"Q.__init__() missing 2 required keyword-only arguments: 'value1' and 'value2'"),
+ ):
+ Q()
+
+ class R(param.Parameterized):
+ value1 = param.Parameter(default=default, required=True)
+ value2 = param.Parameter(default=default, required=True)
+ value3 = param.Parameter(default=default, required=True)
+ notrequired = param.Parameter(default=default, required=False)
+
+ with pytest.raises(
+ TypeError,
+ match=re.escape(r"R.__init__() missing 3 required keyword-only arguments: 'value1', 'value2', and 'value3'"),
+ ):
+ R()
+
+
+def test_required_inheritance():
+ class A(param.Parameterized):
+ p = param.Parameter(default=1, required=True, doc='aaa')
+
+ class B(A):
+ pass
+
+ class C(B):
+ p = param.Parameter(required=False, doc='bbb')
+
+ with pytest.raises(
+ TypeError,
+ match=re.escape(r"A.__init__() missing 1 required keyword-only argument: 'p'"),
+ ):
+ A()
+
+ with pytest.raises(
+ TypeError,
+ match=re.escape(r"B.__init__() missing 1 required keyword-only argument: 'p'"),
+ ):
+ B()
+
+ c = C()
+
+ assert c.p == 1
+
+ C.param.p.required = True
+
+ with pytest.raises(
+ TypeError,
+ match=re.escape(r"C.__init__() missing 1 required keyword-only argument: 'p'"),
+ ):
+ C()
+
+ c = C(p=2)
+
+ assert c.p == 2
+
+
 @pytest.fixture
 def custom_parameter1():
  class CustomParameter(param.Parameter):

tests/utils.py

@@ -93,3 +93,5 @@ def check_defaults(parameter, label, skip=[]):
  assert parameter.per_instance is True
  if 'label' not in skip:
  assert parameter.label == label
+ if 'required' not in skip:
+ assert parameter.required is False