Type check all exception arguments in component __call__ implementations

pyomo/core/base/param.py

@@ -201,12 +201,21 @@ def set_value(self, value, idx=NOTSET):
             self._value = old_value
             raise
 
-    def __call__(self, exception=True):
+    def __call__(self, exception=NOTSET):
         """
         Return the value of this object.
         """
+        if exception is NOTSET:
+            raise_exception = True
+        elif type(exception) is not bool:
+            raise ValueError(
+                "Param '%s' was called with a non-boolean argument for "
+                "'exception': %s" % (self.name, exception)
+            )
+        else:
+            raise_exception = exception
         if self._value is Param.NoValue:
-            if exception:
+            if raise_exception:
                 raise ValueError(
                     "Error evaluating Param value (%s):\n\tThe Param value is "
                     "currently set to an invalid value.  This is\n\ttypically "
@@ -929,10 +938,20 @@ def __init__(self, *args, **kwds):
     # up both the Component and Data base classes.
     #
 
-    def __call__(self, exception=True):
+    def __call__(self, exception=NOTSET):
         """
         Return the value of this parameter.
         """
+        if exception is NOTSET:
+            raise_exception = True
+        elif type(exception) is not bool:
+            raise ValueError(
+                "Param '%s' was called with a non-boolean argument for "
+                "'exception': %s" % (self.name, exception)
+            )
+        else:
+            raise_exception = exception
+
         if self._constructed:
             if not self._data:
                 if self._mutable:
@@ -943,8 +962,8 @@ def __call__(self, exception=True):
                     # Immutable Param defaults never get added to the
                     # _data dict
                     return self[None]
-            return super(ScalarParam, self).__call__(exception=exception)
-        if exception:
+            return super(ScalarParam, self).__call__(exception=raise_exception)
+        if raise_exception:
             raise ValueError(
                 "Evaluating the numeric value of parameter '%s' before\n\t"
                 "the Param has been constructed (there is currently no "
@@ -976,9 +995,19 @@ class SimpleParam(metaclass=RenamedClass):
 
 
 class IndexedParam(Param):
-    def __call__(self, exception=True):
+    def __call__(self, exception=NOTSET):
         """Compute the value of the parameter"""
-        if exception:
+        if exception is NOTSET:
+            raise_exception = True
+        elif type(exception) is not bool:
+            raise ValueError(
+                "IndexedParam '%s' was called with a non-boolean argument for "
+                "'exception': %s" % (self.name, exception)
+            )
+        else:
+            raise_exception = exception
+
+        if raise_exception:
             raise TypeError(
                 'Cannot compute the value of an indexed Param (%s)' % (self.name,)
             )

pyomo/core/tests/unit/test_param.py

@@ -1625,6 +1625,31 @@ def test_nonfinite_pprint(self):
             "     bb :     4\n",
         )
 
+    def test_invalid_exception_argument(self):
+        m = ConcreteModel()
+        m.p = Param(initialize=7, mutable=True)
+        m.indexed = Param([1, 2], initialize={1: 3, 2: 4}, mutable=True)
+        with self.assertRaisesRegex(
+            ValueError,
+            r"Param 'p' was called with a non-boolean argument for 'exception': "
+            r"p \+ 2",
+        ):
+            m.p(m.p + 2)
+
+        with self.assertRaisesRegex(
+            ValueError,
+            r"Param 'indexed\[1\]' was called with a non-boolean argument for "
+            r"'exception': 3.2",
+        ):
+            m.indexed[1](3.2)
+
+        with self.assertRaisesRegex(
+            ValueError,
+            r"IndexedParam 'indexed' was called with a non-boolean argument for "
+            r"'exception': hi",
+        ):
+            m.indexed('hi')
+
 
 def createNonIndexedParamMethod(func, init_xy, new_xy, tol=1e-10):
     def testMethod(self):