Merge branch 'main' into doc-reorg

Author: jsiirola

pyomo/common/collections/component_map.py

@@ -47,6 +47,18 @@ def _unhashable(val):
     def _tuple(self, val):
         return tuple(self[i.__class__](i) for i in val)
 
+    def hashable(self, obj, hashable=None):
+        if isinstance(obj, type):
+            cls = obj
+        else:
+            cls = type(obj)
+        if hashable is None:
+            fcn = self.get(cls, None)
+            if fcn is None:
+                raise KeyError(obj)
+            return fcn is self._hashable
+        self[cls] = self._hashable if hashable else self._unhashable
+
 
 _hasher = _Hasher()
 
@@ -78,6 +90,8 @@ class ComponentMap(AutoSlots.Mixin, collections.abc.MutableMapping):
 
     __slots__ = ("_dict",)
     __autoslot_mappers__ = {'_dict': _rehash_keys}
+    # Expose a "public" interface to the global _hasher dict
+    hasher = _hasher
 
     def __init__(self, *args, **kwds):
         # maps id_hash(obj) -> (obj,val)

pyomo/common/collections/component_set.py

@@ -61,6 +61,8 @@ class ComponentSet(AutoSlots.Mixin, collections_MutableSet):
 
     __slots__ = ("_data",)
     __autoslot_mappers__ = {'_data': _rehash_keys}
+    # Expose a "public" interface to the global _hasher dict
+    hasher = _hasher
 
     def __init__(self, iterable=None):
         # maps id_hash(obj) -> obj

pyomo/common/tests/test_component_map.py

@@ -49,6 +49,27 @@ def test_tuple(self):
         self.assertIn((1, (2, m.v)), m.cm)
         self.assertNotIn((1, (2, m.v)), i.cm)
 
+    def test_hasher(self):
+        m = ComponentMap()
+        a = 'str'
+        m[a] = 5
+        self.assertTrue(m.hasher.hashable(a))
+        self.assertTrue(m.hasher.hashable(str))
+        self.assertEqual(m._dict, {a: (a, 5)})
+        del m[a]
+
+        m.hasher.hashable(a, False)
+        m[a] = 5
+        self.assertFalse(m.hasher.hashable(a))
+        self.assertFalse(m.hasher.hashable(str))
+        self.assertEqual(m._dict, {id(a): (a, 5)})
+
+        class TMP:
+            pass
+
+        with self.assertRaises(KeyError):
+            m.hasher.hashable(TMP)
+
 
 class TestDefaultComponentMap(unittest.TestCase):
     def test_default_component_map(self):

pyomo/core/base/param.py

@@ -898,8 +898,12 @@ def _pprint(self):
             dataGen = lambda k, v: [v._value]
         else:
             dataGen = lambda k, v: [v]
+        if self.index_set().isfinite() or self._default_val is Param.NoValue:
+            _len = len(self)
+        else:
+            _len = 'inf'
         headers = [
-            ("Size", len(self)),
+            ("Size", _len),
             ("Index", self._index_set if self.is_indexed() else None),
             ("Domain", self.domain.name),
             ("Default", default),

pyomo/core/base/set.py

@@ -1493,18 +1493,7 @@ def _cb_validate_filter(self, mode, val_iter):
                 try:
                     flag = fcn(block, (), *vstar)
                     if flag:
-                        deprecation_warning(
-                            f"{self.__class__.__name__} {self.name}: '{mode}=' "
-                            "callback signature matched (block, *value).  "
-                            "Please update the callback to match the signature "
-                            f"(block, value{', *index' if comp.is_indexed() else ''}).",
-                            version='6.8.0',
-                        )
-                        orig_fcn = fcn._fcn
-                        fcn = ParameterizedScalarCallInitializer(
-                            lambda m, v: orig_fcn(m, *v), True
-                        )
-                        setattr(comp, '_' + mode, fcn)
+                        self._filter_validate_scalar_api_deprecation(mode, warning=True)
                         yield value
                         continue
                 except TypeError:
@@ -1545,6 +1534,21 @@ def _cb_validate_filter(self, mode, val_iter):
             )
             raise exc from None
 
+    def _filter_validate_scalar_api_deprecation(self, mode, warning):
+        comp = self.parent_component()
+        fcn = getattr(comp, '_' + mode)
+        if warning:
+            deprecation_warning(
+                f"{self.__class__.__name__} {self.name}: '{mode}=' "
+                "callback signature matched (block, *value).  "
+                "Please update the callback to match the signature "
+                f"(block, value{', *index' if comp.is_indexed() else ''}).",
+                version='6.8.0',
+            )
+        orig_fcn = fcn._fcn
+        fcn = ParameterizedScalarCallInitializer(lambda m, v: orig_fcn(m, *v), True)
+        setattr(comp, '_' + mode, fcn)
+
     def _cb_normalized_dimen_verifier(self, dimen, val_iter):
         for value in val_iter:
             if value.__class__ in native_types:
@@ -2265,14 +2269,20 @@ def __init__(self, *args, **kwds):
             self._init_values._init = CountedCallInitializer(
                 self, self._init_values._init
             )
-        # HACK: the DAT parser needs to know the domain of a set in
-        # order to correctly parse the data stream.
+
         if not self.is_indexed():
+            # HACK: the DAT parser needs to know the domain of a set in
+            # order to correctly parse the data stream.
             if self._init_domain.constant():
                 self._domain = self._init_domain(self.parent_block(), None, self)
             if self._init_dimen.constant():
                 self._dimen = self._init_dimen(self.parent_block(), None)
 
+            if self._filter.__class__ is ParameterizedIndexedCallInitializer:
+                self._filter_validate_scalar_api_deprecation('filter', warning=False)
+            if self._validate.__class__ is ParameterizedIndexedCallInitializer:
+                self._filter_validate_scalar_api_deprecation('validate', warning=False)
+
     @deprecated(
         "check_values() is deprecated: Sets only contain valid members", version='5.7'
     )

pyomo/core/tests/unit/test_param.py

@@ -1561,6 +1561,70 @@ def test_scalar_set_mutable_when_not_present(self):
         m.p = 20
         self.assertEqual(m.x_p.bounds, (0, 20))
 
+    def test_nonfinite_pprint(self):
+        m = ConcreteModel()
+
+        # Test from #3379
+        m.p = Param(Any, default=1)
+        self.assertEqual(m.p['foo'], 1)
+        OUT = StringIO()
+        m.p.pprint(OUT)
+        self.assertEqual(
+            OUT.getvalue(),
+            "p : Size=inf, Index=Any, Domain=Any, Default=1, Mutable=False\n"
+            "    Key : Value\n",
+        )
+
+        # Other useful checks
+        m.q = Param(Any, default=1, initialize={1: 2, 'a': 3, 'bb': 4})
+        OUT = StringIO()
+        m.q.pprint(OUT)
+        self.assertEqual(
+            OUT.getvalue(),
+            "q : Size=inf, Index=Any, Domain=Any, Default=1, Mutable=False\n"
+            "    Key : Value\n"
+            "      1 :     2\n"
+            "      a :     3\n"
+            "     bb :     4\n",
+        )
+
+        m.r = Param(Any, initialize={1: 2, 'a': 3, 'bb': 4})
+        OUT = StringIO()
+        m.r.pprint(OUT)
+        self.assertEqual(
+            OUT.getvalue(),
+            "r : Size=3, Index=Any, Domain=Any, Default=None, Mutable=False\n"
+            "    Key : Value\n"
+            "      1 :     2\n"
+            "      a :     3\n"
+            "     bb :     4\n",
+        )
+
+        # Other useful (mutable) checks
+        m.q = Param(Any, default=1, mutable=True, initialize={1: 2, 'a': 3, 'bb': 4})
+        OUT = StringIO()
+        m.q.pprint(OUT)
+        self.assertEqual(
+            OUT.getvalue(),
+            "q : Size=inf, Index=Any, Domain=Any, Default=1, Mutable=True\n"
+            "    Key : Value\n"
+            "      1 :     2\n"
+            "      a :     3\n"
+            "     bb :     4\n",
+        )
+
+        m.r = Param(Any, mutable=True, initialize={1: 2, 'a': 3, 'bb': 4})
+        OUT = StringIO()
+        m.r.pprint(OUT)
+        self.assertEqual(
+            OUT.getvalue(),
+            "r : Size=3, Index=Any, Domain=Any, Default=None, Mutable=True\n"
+            "    Key : Value\n"
+            "      1 :     2\n"
+            "      a :     3\n"
+            "     bb :     4\n",
+        )
+
 
 def createNonIndexedParamMethod(func, init_xy, new_xy, tol=1e-10):
     def testMethod(self):

pyomo/core/tests/unit/test_set.py

@@ -4181,6 +4181,19 @@ def test_indexed_set(self):
         self.assertIs(type(m.I[3]), InsertionOrderSetData)
         self.assertEqual(m.I.data(), {1: (4, 2, 5), 2: (4, 2, 5), 3: (4, 2, 5)})
 
+        # Explicit (constant dict) construction
+        m = ConcreteModel()
+        m.I = Set([1, 2], initialize={1: (4, 2, 5), 2: (7, 6)})
+        self.assertEqual(len(m.I), 2)
+        self.assertEqual(list(m.I[1]), [4, 2, 5])
+        self.assertEqual(list(m.I[2]), [7, 6])
+        self.assertIsNot(m.I[1], m.I[2])
+        self.assertTrue(m.I[1].isordered())
+        self.assertTrue(m.I[2].isordered())
+        self.assertIs(type(m.I[1]), InsertionOrderSetData)
+        self.assertIs(type(m.I[2]), InsertionOrderSetData)
+        self.assertEqual(m.I.data(), {1: (4, 2, 5), 2: (7, 6)})
+
         # Explicit (constant) construction
         m = ConcreteModel()
         m.I = Set([1, 2, 3], initialize=(4, 2, 5), ordered=Set.SortedOrder)
@@ -4255,7 +4268,7 @@ def test_indexing(self):
     def test_add_filter_validate(self):
         m = ConcreteModel()
         m.I = Set(domain=Integers)
-        self.assertIs(m.I.filter, None)
+        self.assertIs(m.I._filter, None)
         with self.assertRaisesRegex(
             ValueError,
             r"Cannot add value 1.5 to Set I.\n"
@@ -4302,7 +4315,7 @@ def _l_tri(model, i, j):
             return i >= j
 
         m.K = Set(initialize=RangeSet(3) * RangeSet(3), filter=_l_tri)
-        self.assertIsInstance(m.K.filter, ParameterizedScalarCallInitializer)
+        self.assertIsInstance(m.K._filter, ParameterizedScalarCallInitializer)
         self.assertEqual(list(m.K), [(1, 1), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3)])
 
         output = StringIO()
@@ -4334,6 +4347,18 @@ def _lt_3(model, i):
         self.assertEqual(output.getvalue(), "")
         self.assertEqual(list(m.L[2]), [1, 2, 0])
 
+        # This tests that the deprecation path works correctly in the
+        # case that the callback doesn't raise an error or ever return
+        # False
+
+        def _l_off_diag(model, i, j):
+            self.assertIs(model, m)
+            return i != j
+
+        m.M = Set(initialize=RangeSet(3) * RangeSet(3), filter=_l_off_diag)
+        self.assertIsInstance(m.M._filter, ParameterizedScalarCallInitializer)
+        self.assertEqual(list(m.M), [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)])
+
         m = ConcreteModel()
 
         def _validate(model, val):
@@ -4374,12 +4399,15 @@ def _validate(model, i, j):
         m.I2 = Set(validate=_validate)
         with LoggingIntercept(module='pyomo.core') as output:
             self.assertTrue(m.I2.add((0, 1)))
-            self.assertRegex(
-                output.getvalue().replace('\n', ' '),
-                r"DEPRECATED: OrderedScalarSet I2: 'validate=' callback "
-                r"signature matched \(block, \*value\).  Please update the "
-                r"callback to match the signature \(block, value\)",
-            )
+            # Note that we are not emitting a deprecation warning (yet)
+            # for scalar sets
+            # self.assertEqual(output.getvalue(), "")
+            #     output.getvalue().replace('\n', ' '),
+            #     r"DEPRECATED: OrderedScalarSet I2: 'validate=' callback "
+            #     r"signature matched \(block, \*value\).  Please update the "
+            #     r"callback to match the signature \(block, value\)",
+            # )
+            self.assertEqual(output.getvalue(), "")
         with LoggingIntercept(module='pyomo.core') as output:
             with self.assertRaisesRegex(
                 ValueError,