Remove expression _args_ tuple

pyomo/contrib/appsi/cmodel/src/expression.cpp

@@ -1660,7 +1660,7 @@ void prep_for_repn_helper(py::handle expr, py::handle named_exprs,
     break;
   }
   case product: {
-    py::tuple args = expr.attr("_args_");
+    py::tuple args = expr.attr("args");
     for (py::handle arg : args) {
       prep_for_repn_helper(arg, named_exprs, variables, fixed_vars,
                            external_funcs, expr_types);
@@ -1676,7 +1676,7 @@ void prep_for_repn_helper(py::handle expr, py::handle named_exprs,
     break;
   }
   case negation: {
-    py::tuple args = expr.attr("_args_");
+    py::tuple args = expr.attr("args");
     for (py::handle arg : args) {
       prep_for_repn_helper(arg, named_exprs, variables, fixed_vars,
                            external_funcs, expr_types);
@@ -1693,23 +1693,23 @@ void prep_for_repn_helper(py::handle expr, py::handle named_exprs,
     break;
   }
   case power: {
-    py::tuple args = expr.attr("_args_");
+    py::tuple args = expr.attr("args");
     for (py::handle arg : args) {
       prep_for_repn_helper(arg, named_exprs, variables, fixed_vars,
                            external_funcs, expr_types);
     }
     break;
   }
   case division: {
-    py::tuple args = expr.attr("_args_");
+    py::tuple args = expr.attr("args");
     for (py::handle arg : args) {
       prep_for_repn_helper(arg, named_exprs, variables, fixed_vars,
                            external_funcs, expr_types);
     }
     break;
   }
   case unary_func: {
-    py::tuple args = expr.attr("_args_");
+    py::tuple args = expr.attr("args");
     for (py::handle arg : args) {
       prep_for_repn_helper(arg, named_exprs, variables, fixed_vars,
                            external_funcs, expr_types);
@@ -1744,7 +1744,7 @@ void prep_for_repn_helper(py::handle expr, py::handle named_exprs,
     break;
   }
   case unary_abs: {
-    py::tuple args = expr.attr("_args_");
+    py::tuple args = expr.attr("args");
     for (py::handle arg : args) {
       prep_for_repn_helper(arg, named_exprs, variables, fixed_vars,
                            external_funcs, expr_types);

pyomo/contrib/appsi/solvers/maingo_solvermodel.py

@@ -76,7 +76,7 @@ def maingo_atanh(cls, x):
     def visit(self, node, values):
         """Visit nodes that have been expanded"""
         for i, val in enumerate(values):
-            arg = node._args_[i]
+            arg = node.arg(i)
 
             if arg is None:
                 values[i] = "Undefined"
@@ -94,7 +94,7 @@ def visit(self, node, values):
                     elif node.PRECEDENCE == arg.PRECEDENCE:
                         if i == 0:
                             parens = node.ASSOCIATIVITY != LEFT_TO_RIGHT
-                        elif i == len(node._args_) - 1:
+                        elif i == node.nargs() - 1:
                             parens = node.ASSOCIATIVITY != RIGHT_TO_LEFT
                         else:
                             parens = True

pyomo/contrib/cp/scheduling_expr/precedence_expressions.py

@@ -11,14 +11,22 @@
 
 
 class PrecedenceExpression(BooleanExpression):
+    __slots__ = ('_args',)
     PRECEDENCE = None
 
+    def __init__(self, args: tuple["IntervalVarData", "IntervalVarData", int]):
+        self._first, self._second, self._delay = args
+
     def nargs(self):
         return 3
 
+    @property
+    def args(self):
+        return self._first, self._second, self._delay
+
     @property
     def delay(self):
-        return self._args_[2]
+        return self._delay
 
     def _to_string_impl(self, values, relation):
         delay = values[2]

pyomo/contrib/cp/scheduling_expr/scheduling_logic.py

@@ -8,10 +8,11 @@
 # ____________________________________________________________________________________
 
 
-from pyomo.core.expr.logical_expr import NaryBooleanExpression, _flattened
+from pyomo.core.expr.base import NaryExpression_Mixin
+from pyomo.core.expr.logical_expr import BooleanExpression, _flattened
 
 
-class SpanExpression(NaryBooleanExpression):
+class SpanExpression(NaryExpression_Mixin, BooleanExpression):
     """
     Expression over IntervalVars representing that the first arg spans all the
     following args in the schedule. The first arg is absent if and only if all
@@ -21,17 +22,21 @@ class SpanExpression(NaryBooleanExpression):
         args (tuple): Child nodes, of type IntervalVar
     """
 
+    __slots__ = ('_args',)
+
     def _to_string(self, values, verbose, smap):
         return "%s.spans(%s)" % (values[0], ", ".join(values[1:]))
 
 
-class AlternativeExpression(NaryBooleanExpression):
+class AlternativeExpression(NaryExpression_Mixin, BooleanExpression):
     """
     Expression over IntervalVars representing that if the first arg is present,
     then exactly one of the following args must be present. The first arg is
     absent if and only if all the others are absent.
     """
 
+    __slots__ = ('_args',)
+
     # [ESJ 4/4/24]: docplex takes an optional 'cardinality' argument with this
     # too--it generalized to "exactly n" of the intervals have to exist,
     # basically. It would be nice to include this eventually, but this is
@@ -41,13 +46,15 @@ def _to_string(self, values, verbose, smap):
         return "alternative(%s, [%s])" % (values[0], ", ".join(values[1:]))
 
 
-class SynchronizeExpression(NaryBooleanExpression):
+class SynchronizeExpression(NaryExpression_Mixin, BooleanExpression):
     """
     Expression over IntervalVars synchronizing the first argument with all of the
     following arguments. That is, if the first argument is present, the remaining
     arguments start and end at the same time as it.
     """
 
+    __slots__ = ('_args',)
+
     def _to_string(self, values, verbose, smap):
         return "synchronize(%s, [%s])" % (values[0], ", ".join(values[1:]))
 

pyomo/contrib/cp/scheduling_expr/sequence_expressions.py

@@ -7,10 +7,11 @@
 # software.  This software is distributed under the 3-clause BSD License.
 # ____________________________________________________________________________________
 
+from pyomo.core.expr.base import BinaryExpression_Mixin, UnaryExpression_Mixin
 from pyomo.core.expr.logical_expr import BooleanExpression
 
 
-class NoOverlapExpression(BooleanExpression):
+class NoOverlapExpression(UnaryExpression_Mixin, BooleanExpression):
     """
     Expression representing that none of the IntervalVars in a SequenceVar overlap
     (if they are scheduled)
@@ -19,14 +20,13 @@ class NoOverlapExpression(BooleanExpression):
         args (tuple): Child node of type SequenceVar
     """
 
-    def nargs(self):
-        return 1
+    __slots__ = ('_arg',)
 
     def _to_string(self, values, verbose, smap):
         return "no_overlap(%s)" % values[0]
 
 
-class FirstInSequenceExpression(BooleanExpression):
+class FirstInSequenceExpression(BinaryExpression_Mixin, BooleanExpression):
     """
     Expression representing that the specified IntervalVar is the first in the
     sequence specified by SequenceVar (if it is scheduled)
@@ -36,14 +36,13 @@ class FirstInSequenceExpression(BooleanExpression):
                       SequenceVar
     """
 
-    def nargs(self):
-        return 2
+    __slots__ = ('_l_arg', '_r_arg')
 
     def _to_string(self, values, verbose, smap):
         return "first_in(%s, %s)" % (values[0], values[1])
 
 
-class LastInSequenceExpression(BooleanExpression):
+class LastInSequenceExpression(BinaryExpression_Mixin, BooleanExpression):
     """
     Expression representing that the specified IntervalVar is the last in the
     sequence specified by SequenceVar (if it is scheduled)
@@ -53,9 +52,6 @@ class LastInSequenceExpression(BooleanExpression):
                       SequenceVar
     """
 
-    def nargs(self):
-        return 2
-
     def _to_string(self, values, verbose, smap):
         return "last_in(%s, %s)" % (values[0], values[1])
 
@@ -65,14 +61,26 @@ class BeforeInSequenceExpression(BooleanExpression):
     Expression representing that one IntervalVar occurs before another in the
     sequence specified by the given SequenceVar (if both are scheduled)
 
-    args:
-        args (tuple): Child nodes, the IntervalVar that must be before, the
-                      IntervalVar that must be after, and the SequenceVar
+    Parameters
+    ----------
+    args : tuple["IntervalVar", "IntervalVar", "SequenceVar"]
+
+        The child nodes, consisting of the predecessor IntervalVar, the successor
+        IntervalVar, and the SequenceVar
     """
 
+    __slots__ = ('_before', '_after', '_sequence')
+
+    def __init__(self, args):
+        self._before, self._after, self._sequence = args
+
     def nargs(self):
         return 3
 
+    @property
+    def args(self):
+        return self._before, self._after, self._sequence
+
     def _to_string(self, values, verbose, smap):
         return "before_in(%s, %s, %s)" % (values[0], values[1], values[2])
 
@@ -82,14 +90,27 @@ class PredecessorToExpression(BooleanExpression):
     Expression representing that one IntervalVar is a direct predecessor to another
     in the sequence specified by the given SequenceVar (if both are scheduled)
 
-    args:
-        args (tuple): Child nodes, the predecessor IntervalVar, the successor
-                      IntervalVar, and the SequenceVar
+    Parameters
+    ----------
+    args : tuple["IntervalVar", "IntervalVar", "SequenceVar"]
+
+        The child nodes, consisting of the predecessor IntervalVar, the successor
+        IntervalVar, and the SequenceVar
+
     """
 
+    __slots__ = ('_predecessor', '_successor', '_sequence')
+
+    def __init__(self, args):
+        self._predecessor, self._successor, self._sequence = args
+
     def nargs(self):
         return 3
 
+    @property
+    def args(self):
+        return self._predecessor, self._successor, self._sequence
+
     def _to_string(self, values, verbose, smap):
         return "predecessor_to(%s, %s, %s)" % (values[0], values[1], values[2])