pyomo__pyomo-3017

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, in <module>\n  File \"/workspace/pyomo/core/base/units_container.py\", line 1532, in __getattribute__\n    return getattr(pint_module, attr)\n  File \"/workspace/pyomo/common/dependencies.py\", line 75, in __getattr__\n    raise DeferredImportError(self._moduleunavailable_message())\npyomo.common.errors.DeferredImportError: The \"pint\" package failed to import. This package is necessary to use Pyomo units. (import raised ModuleNotFoundError: No module named 'pint')\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, in <module>\n  File \"/workspace/pyomo/core/base/units_container.py\", line 1532, in __getattribute__\n    return getattr(pint_module, attr)\n  File \"/workspace/pyomo/common/dependencies.py\", line 75, in __getattr__\n    raise DeferredImportError(self._moduleunavailable_message())\npyomo.common.errors.DeferredImportError: The \"pint\" package failed to import. This package is necessary to use Pyomo units. (import raised ModuleNotFoundError: No module named 'pint')\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"/workspace/pyomo/common/collections/component_map.py\", line 71, in __getitem__\n    return self._dict[id(obj)][1]\nKeyError: 132337228096144\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n  File \"<stdin>\", line 17, in <module>\n  File \"/workspace/pyomo/core/expr/calculus/derivatives.py\", line 96, in differentiate\n    res = reverse_sd(expr=expr)\n  File \"/workspace/pyomo/core/expr/calculus/diff_with_pyomo.py\", line 484, in reverse_sd\n    return _reverse_diff_helper(expr, False)\n  File \"/workspace/pyomo/core/expr/calculus/diff_with_pyomo.py\", line 442, in _reverse_diff_helper\n    _diff_GeneralExpression(e, val_dict, der_dict)\n  File \"/workspace/pyomo/core/expr/calculus/diff_with_pyomo.py\", line 331, in _diff_GeneralExpression\n    der_dict[node.expr] += der_dict[node]\n  File \"/workspace/pyomo/common/collections/component_map.py\", line 73, in __getitem__\n    raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\nKeyError: \"Component with id '132337228096144': 2.0\"\n",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pyomo/common/collections/component_map.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom collections.abc import MutableMapping as collections_MutableMapping\nfrom collections.abc import Mapping as collections_Mapping\nfrom pyomo.common.autoslots import AutoSlots\n\n\ndef _rebuild_ids(encode, val):\n    if encode:\n        return val\n    else:\n        # object id() may have changed after unpickling,\n        # so we rebuild the dictionary keys\n        return {id(obj): (obj, v) for obj, v in val.values()}\n\n\nclass ComponentMap(AutoSlots.Mixin, collections_MutableMapping):\n    \"\"\"\n    This class is a replacement for dict that allows Pyomo\n    modeling components to be used as entry keys. The\n    underlying mapping is based on the Python id() of the\n    object, which gets around the problem of hashing\n    subclasses of NumericValue. This class is meant for\n    creating mappings from Pyomo components to values. The\n    use of non-Pyomo components as entry keys should be\n    avoided.\n\n    A reference to the object is kept around as long as it\n    has a corresponding entry in the container, so there is\n    no need to worry about id() clashes.\n\n    We also override __setstate__ so that we can rebuild the\n    container based on possibly updated object ids after\n    a deepcopy or pickle.\n\n    *** An instance of this class should never be\n    deepcopied/pickled unless it is done so along with the\n    components for which it contains map entries (e.g., as\n    part of a block). ***\n    \"\"\"\n\n    __slots__ = (\"_dict\",)\n    __autoslot_mappers__ = {'_dict': _rebuild_ids}\n\n    def __init__(self, *args, **kwds):\n        # maps id(obj) -> (obj,val)\n        self._dict = {}\n        # handle the dict-style initialization scenarios\n        self.update(*args, **kwds)\n\n    def __str__(self):\n        \"\"\"String representation of the mapping.\"\"\"\n        tmp = {str(c) + \" (id=\" + str(id(c)) + \")\": v for c, v in self.items()}\n        return \"ComponentMap(\" + str(tmp) + \")\"\n\n    #\n    # Implement MutableMapping abstract methods\n    #\n\n    def __getitem__(self, obj):\n        try:\n            return self._dict[id(obj)][1]\n        except KeyError:\n            raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\n\n    def __setitem__(self, obj, val):\n        self._dict[id(obj)] = (obj, val)\n\n    def __delitem__(self, obj):\n        try:\n            del self._dict[id(obj)]\n        except KeyError:\n            raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\n\n    def __iter__(self):\n        return (obj for obj, val in self._dict.values())\n\n    def __len__(self):\n        return self._dict.__len__()\n\n    #\n    # Overload MutableMapping default implementations\n    #\n\n    # We want to avoid generating Pyomo expressions due to\n    # comparison of values, so we convert both objects to a\n    # plain dictionary mapping key->(type(val), id(val)) and\n    # compare that instead.\n    def __eq__(self, other):\n        if not isinstance(other, collections_Mapping):\n            return False\n        return {(type(key), id(key)): val for key, val in self.items()} == {\n            (type(key), id(key)): val for key, val in other.items()\n        }\n\n    def __ne__(self, other):\n        return not (self == other)\n\n    #\n    # The remaining methods have slow default\n    # implementations for MutableMapping. In particular,\n    # they rely KeyError catching, which is slow for this\n    # class because KeyError messages use fully qualified\n    # names.\n    #\n\n    def __contains__(self, obj):\n        return id(obj) in self._dict\n\n    def clear(self):\n        'D.clear() -> None.  Remove all items from D.'\n        self._dict.clear()\n\n    def get(self, key, default=None):\n        'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.'\n        if key in self:\n            return self[key]\n        return default\n\n    def setdefault(self, key, default=None):\n        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'\n        if key in self:\n            return self[key]\n        else:\n            self[key] = default\n        return default",
  "start_line": 1,
  "end_line": 135,
  "total_lines": 135,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom pyomo.common.collections import ComponentMap, ComponentSet\nimport pyomo.core.expr as _expr\nfrom pyomo.core.expr.visitor import ExpressionValueVisitor, nonpyomo_leaf_types\nfrom pyomo.core.expr.numvalue import value, is_constant\nfrom pyomo.core.expr import exp, log, sin, cos\nimport math\n\n\n\"\"\"\nThe purpose of this file is to perform symbolic differentiation and \nfirst order automatic differentiation directly with pyomo \nexpressions. This is certainly not as efficient as doing AD in C or \nC++, but it avoids the translation from pyomo expressions to a form \nwhere AD can be performed efficiently. The only functions that are \nmeant to be used by users are reverse_ad and reverse_sd. First, \nvalues are propagated from the leaves to each node in the tree with \nthe LeafToRoot visitors. Then derivative values are propagated from \nthe root to the leaves with the RootToLeaf visitors.\n\"\"\"\n\n\nclass DifferentiationException(Exception):\n    pass\n\n\ndef _diff_ProductExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.ProductExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    der_dict[arg1] += der * val_dict[arg2]\n    der_dict[arg2] += der * val_dict[arg1]\n\n\ndef _diff_SumExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.SumExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der = der_dict[node]\n    for arg in node.args:\n        der_dict[arg] += der\n\n\ndef _diff_PowExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.PowExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    val1 = val_dict[arg1]\n    val2 = val_dict[arg2]\n    der_dict[arg1] += der * val2 * val1 ** (val2 - 1)\n    if arg2.__class__ not in nonpyomo_leaf_types:\n        der_dict[arg2] += der * val1**val2 * log(val1)\n\n\ndef _diff_DivisionExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.DivisionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    num = node.args[0]\n    den = node.args[1]\n    der = der_dict[node]\n    der_dict[num] += der * (1 / val_dict[den])\n    der_dict[den] -= der * val_dict[num] / val_dict[den] ** 2\n\n\ndef _diff_NegationExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] -= der\n\n\ndef _diff_exp(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der * exp(val_dict[arg])\n\n\ndef _diff_log(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der / val_dict[arg]\n\n\ndef _diff_log10(node, val_dict, der_dict):\n    \"\"\"\n",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 484,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom pyomo.common.collections import ComponentMap, ComponentSet\nimport pyomo.core.expr as _expr\nfrom pyomo.core.expr.visitor import ExpressionValueVisitor, nonpyomo_leaf_types\nfrom pyomo.core.expr.numvalue import value, is_constant\nfrom pyomo.core.expr import exp, log, sin, cos\nimport math\n\n\n\"\"\"\nThe purpose of this file is to perform symbolic differentiation and \nfirst order automatic differentiation directly with pyomo \nexpressions. This is certainly not as efficient as doing AD in C or \nC++, but it avoids the translation from pyomo expressions to a form \nwhere AD can be performed efficiently. The only functions that are \nmeant to be used by users are reverse_ad and reverse_sd. First, \nvalues are propagated from the leaves to each node in the tree with \nthe LeafToRoot visitors. Then derivative values are propagated from \nthe root to the leaves with the RootToLeaf visitors.\n\"\"\"\n\n\nclass DifferentiationException(Exception):\n    pass\n\n\ndef _diff_ProductExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.ProductExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    der_dict[arg1] += der * val_dict[arg2]\n    der_dict[arg2] += der * val_dict[arg1]\n\n\ndef _diff_SumExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.SumExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der = der_dict[node]\n    for arg in node.args:\n        der_dict[arg] += der\n\n\ndef _diff_PowExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.PowExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    val1 = val_dict[arg1]\n    val2 = val_dict[arg2]\n    der_dict[arg1] += der * val2 * val1 ** (val2 - 1)\n    if arg2.__class__ not in nonpyomo_leaf_types:\n        der_dict[arg2] += der * val1**val2 * log(val1)\n\n\ndef _diff_DivisionExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.DivisionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    num = node.args[0]\n    den = node.args[1]\n    der = der_dict[node]\n    der_dict[num] += der * (1 / val_dict[den])\n    der_dict[den] -= der * val_dict[num] / val_dict[den] ** 2\n\n\ndef _diff_NegationExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] -= der\n\n\ndef _diff_exp(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der * exp(val_dict[arg])\n\n\ndef _diff_log(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der / val_dict[arg]\n\n\ndef _diff_log10(node, val_dict, der_dict):\n    \"\"\"\n",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 484,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom pyomo.common.collections import ComponentMap, ComponentSet\nimport pyomo.core.expr as _expr\nfrom pyomo.core.expr.visitor import ExpressionValueVisitor, nonpyomo_leaf_types\nfrom pyomo.core.expr.numvalue import value, is_constant\nfrom pyomo.core.expr import exp, log, sin, cos\nimport math\n\n\n\"\"\"\nThe purpose of this file is to perform symbolic differentiation and \nfirst order automatic differentiation directly with pyomo \nexpressions. This is certainly not as efficient as doing AD in C or \nC++, but it avoids the translation from pyomo expressions to a form \nwhere AD can be performed efficiently. The only functions that are \nmeant to be used by users are reverse_ad and reverse_sd. First, \nvalues are propagated from the leaves to each node in the tree with \nthe LeafToRoot visitors. Then derivative values are propagated from \nthe root to the leaves with the RootToLeaf visitors.\n\"\"\"\n\n\nclass DifferentiationException(Exception):\n    pass\n\n\ndef _diff_ProductExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.ProductExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    der_dict[arg1] += der * val_dict[arg2]\n    der_dict[arg2] += der * val_dict[arg1]\n\n\ndef _diff_SumExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.SumExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der = der_dict[node]\n    for arg in node.args:\n        der_dict[arg] += der\n\n\ndef _diff_PowExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.PowExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    val1 = val_dict[arg1]\n    val2 = val_dict[arg2]\n    der_dict[arg1] += der * val2 * val1 ** (val2 - 1)\n    if arg2.__class__ not in nonpyomo_leaf_types:\n        der_dict[arg2] += der * val1**val2 * log(val1)\n\n\ndef _diff_DivisionExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.DivisionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    num = node.args[0]\n    den = node.args[1]\n    der = der_dict[node]\n    der_dict[num] += der * (1 / val_dict[den])\n    der_dict[den] -= der * val_dict[num] / val_dict[den] ** 2\n\n\ndef _diff_NegationExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] -= der\n\n\ndef _diff_exp(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der * exp(val_dict[arg])\n\n\ndef _diff_log(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der / val_dict[arg]\n\n\ndef _diff_log10(node, val_dict, der_dict):\n    \"\"\"\n",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 484,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    if node.getname() in _unary_map:\n        _unary_map[node.getname()](node, val_dict, der_dict)\n    else:\n        raise DifferentiationException(\n            'Unsupported expression type for differentiation: {0}'.format(type(node))\n        )\n\n\ndef _diff_GeneralExpression(node, val_dict, der_dict):\n    \"\"\"\n    Reverse automatic differentiation for named expressions.\n\n    Parameters\n    ----------\n    node: The named expression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der_dict[node.expr] += der_dict[node]\n\n\ndef _diff_ExternalFunctionExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.ExternalFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der = der_dict[node]\n    vals = tuple(val_dict[i] for i in node.args)\n    derivs = node._fcn.evaluate_fgh(vals, fgh=1)[1]\n    for ndx, arg in enumerate(node.args):\n        der_dict[arg] += der * derivs[ndx]\n\n\n_diff_map = dict()\n_diff_map[_expr.ProductExpression] = _diff_ProductExpression\n_diff_map[_expr.DivisionExpression] = _diff_DivisionExpression\n_diff_map[_expr.PowExpression] = _diff_PowExpression\n_diff_map[_expr.SumExpression] = _diff_SumExpression\n_diff_map[_expr.MonomialTermExpression] = _diff_ProductExpression\n_diff_map[_expr.NegationExpression] = _diff_NegationExpression\n_diff_map[_expr.UnaryFunctionExpression] = _diff_UnaryFunctionExpression\n_diff_map[_expr.ExternalFunctionExpression] = _diff_ExternalFunctionExpression\n_diff_map[_expr.LinearExpression] = _diff_SumExpression\n_diff_map[_expr.AbsExpression] = _diff_abs\n\n_diff_map[_expr.NPV_ProductExpression] = _diff_ProductExpression\n_diff_map[_expr.NPV_DivisionExpression] = _diff_DivisionExpression\n_diff_map[_expr.NPV_PowExpression] = _diff_PowExpression\n_diff_map[_expr.NPV_SumExpression] = _diff_SumExpression\n_diff_map[_expr.NPV_NegationExpression] = _diff_NegationExpression\n_diff_map[_expr.NPV_UnaryFunctionExpression] = _diff_UnaryFunctionExpression\n_diff_map[_expr.NPV_ExternalFunctionExpression] = _diff_ExternalFunctionExpression\n_diff_map[_expr.NPV_AbsExpression] = _diff_abs\n\n\ndef _symbolic_value(x):\n    return x\n\n\ndef _numeric_apply_operation(node, values):\n    return node._apply_operation(values)\n\n\ndef _symbolic_apply_operation(node, values):\n    return node\n\n\nclass _LeafToRootVisitor(ExpressionValueVisitor):\n    def __init__(self, val_dict, der_dict, expr_list, numeric=True):\n        \"\"\"\n        Parameters\n        ----------\n        val_dict: ComponentMap\n        der_dict: ComponentMap\n        \"\"\"\n        self.val_dict = val_dict\n        self.der_dict = der_dict\n        self.expr_list = expr_list\n        assert len(self.expr_list) == 0\n        assert len(self.val_dict) == 0\n        assert len(self.der_dict) == 0\n        if numeric:\n            self.value_func = value\n            self.operation_func = _numeric_apply_operation\n        else:\n            self.value_func = _symbolic_value\n            self.operation_func = _symbolic_apply_operation\n\n    def visit(self, node, values):\n        self.val_dict[node] = self.operation_func(node, values)\n        self.der_dict[node] = 0\n        self.expr_list.append(node)\n        return self.val_dict[node]\n\n    def visiting_potential_leaf(self, node):\n        if node in self.val_dict:\n            return True, self.val_dict[node]\n\n        if node.__class__ in nonpyomo_leaf_types:\n            self.val_dict[node] = node\n            self.der_dict[node] = 0\n            return True, node\n\n        if not node.is_expression_type():\n            val = self.value_func(node)\n            self.val_dict[node] = val\n            self.der_dict[node] = 0\n            return True, val\n\n        return False, None\n\n\ndef _reverse_diff_helper(expr, numeric=True):\n    val_dict = ComponentMap()\n    der_dict = ComponentMap()\n    expr_list = list()\n\n    visitorA = _LeafToRootVisitor(val_dict, der_dict, expr_list, numeric=numeric)\n    visitorA.dfs_postorder_stack(expr)\n\n    der_dict[expr] = 1\n    for e in reversed(expr_list):\n        if e.__class__ in _diff_map:\n            _diff_map[e.__class__](e, val_dict, der_dict)\n        elif e.is_named_expression_type():\n            _diff_GeneralExpression(e, val_dict, der_dict)\n        else:\n            raise DifferentiationException(\n                'Unsupported expression type for differentiation: {0}'.format(type(e))\n            )\n\n    return der_dict\n\n\ndef reverse_ad(expr):\n    \"\"\"\n    First order reverse automatic differentiation\n\n    Parameters\n    ----------\n    expr: pyomo.core.expr.numeric_expr.NumericExpression\n        expression to differentiate\n\n    Returns\n    -------\n    ComponentMap\n        component_map mapping variables to derivatives with respect\n        to the corresponding variable\n    \"\"\"\n    return _reverse_diff_helper(expr, True)\n\n\ndef reverse_sd(expr):\n    \"\"\"\n    First order reverse symbolic differentiation\n\n    Parameters\n    ----------\n    expr: pyom",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "25:    nonpyomo_leaf_types,\n323:            if type(node) in nonpyomo_leaf_types or not node.is_expression_type():\n395:            if type(node) in nonpyomo_leaf_types or not node.is_expression_type():\n450:        if type(node) in nonpyomo_leaf_types or not node.is_expression_type():\n531:            if type(expr) in nonpyomo_leaf_types or not expr.is_expression_type():\n609:                            type(child) in nonpyomo_leaf_types\n734:                    c.__class__ in nonpyomo_leaf_types\n766:            node.__class__ in nonpyomo_leaf_types\n785:                    c.__class__ in nonpyomo_leaf_types\n1181:        if node.__class__ in nonpyomo_leaf_types:\n1216:        if node.__class__ in nonpyomo_leaf_types:\n1368:        if node.__class__ in nonpyomo_leaf_types:\n1420:        if node.__class__ in nonpyomo_leaf_types:\n1462:        if node.__class__ in nonpyomo_leaf_types:\n1511:        if node.__class__ in nonpyomo_leaf_types:\n1561:            elif arg.__class__ in nonpyomo_leaf_types:\n1598:        if node.__class__ in nonpyomo_leaf_types:\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/visitor.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom __future__ import division\n\nimport inspect\nimport logging\nimport sys\nfrom copy import deepcopy\nfrom collections import deque\n\nlogger = logging.getLogger('pyomo.core')\n\nfrom pyomo.common.deprecation import deprecated, deprecation_warning\nfrom pyomo.common.errors import DeveloperError, TemplateExpressionError\nfrom pyomo.common.numeric_types import (\n    nonpyomo_leaf_types,\n    native_types,\n    native_numeric_types,\n    value,\n)\nimport pyomo.core.expr.expr_common as common\nfrom pyomo.core.expr.symbol_map import SymbolMap\n\ntry:\n    # sys._getframe is slightly faster than inspect's currentframe, but\n    # is not guaranteed to exist everywhere\n    currentframe = sys._getframe\nexcept AttributeError:\n    currentframe = inspect.currentframe\n\n\ndef get_stack_depth():\n    n = -1  # skip *this* frame in the count\n    f = currentframe()\n    while f is not None:\n        n += 1\n        f = f.f_back\n    return n\n\n\n# For efficiency, we want to run recursively, but don't want to hit\n# Python's recursion limit (because that would be difficult to recover\n# from cleanly).  However, there is a non-trivial cost to determine the\n# current stack depth - and we don't want to hit that for every call.\n# Instead, we will assume that the walker is always called with at\n# least RECURSION_LIMIT frames available on the stack.  When we hit the\n# end of that limit, we will actually check how much space is left on\n# the stack and run recursively until only 2*RECURSION_LIMIT frames are\n# left.  For the vast majority of well-formed expressions this approach\n# avoids a somewhat costly call to get_stack_depth, but still catches\n# the vast majority of cases that could generate a recursion error.\nRECURSION_LIMIT = 50\n\n\nclass RevertToNonrecursive(Exception):\n    pass\n\n\n# NOTE: This module also has dependencies on numeric_expr; however, to\n# avoid circular dependencies, we will NOT import them here.  Instead,\n# until we can resolve the circular dependencies, they will be injected\n# into this module by the .current module (which must be imported\n# *after* numeric_expr, logocal_expr, and this module.\n\n\n# -------------------------------------------------------\n#\n# Visitor Logic\n#\n# -------------------------------------------------------\n\n\nclass StreamBasedExpressionVisitor(object):\n    \"\"\"This class implements a generic stream-based expression walker.\n\n     This visitor walks an expression tree using a depth-first strategy\n     and generates a full event stream similar to other tree visitors\n     (e.g., the expat XML parser).  The following events are triggered\n     through callback functions as the traversal enters and leaves nodes\n     in the tree:\n\n       initializeWalker(expr) -> walk, result\n       enterNode(N1) -> args, data\n       {for N2 in args:}\n         beforeChild(N1, N2) -> descend, child_result\n           enterNode(N2) -> N2_args, N2_data\n           [...]\n           exitNode(N2, n2_data) -> child_result\n         acceptChildResult(N1, data, child_result) -> data\n         afterChild(N1, N2) -> None\n       exitNode(N1, data) -> N1_result\n       finalizeWalker(result) -> result\n\n     Individual event callbacks match the following signatures:\n\n    walk, result = initializeWalker(self, expr):\n\n         initializeWalker() is called to set the walker up and perform\n         any preliminary processing on the root node.  The method returns\n         a flag indicating if the tree should be walked and a result.  If\n         `walk` is True, then result is ignored.  If `walk` is False,\n         then `result` is returned as the final result from the walker,\n         bypassing all other callbacks (including finalizeResult).\n\n    args, data = enterNode(self, node):\n\n         enterNode() is called when the walker first enters a node (from\n         above), and is passed the node being entered.  It is expected to\n         return a tuple of child `args` (as either a tuple or list) and a\n         user-specified data structure for collecting results.  If None\n         is returned for args, the node's args attribute is used for\n         expression types and the empty tuple for leaf nodes.  Returning\n         None is equivalent to returning (None,None).  If the callback is\n         not defined, the default behavior is equivalent to returning\n         (None, []).\n\n     node_result = exitNode(self, node, data):\n\n         exitNode() is called after the node is completely processed (as\n         the walker returns up the tree to the parent node).  It is\n         passed the node and the results data structure (defined by\n         enterNode() and possibly further modified by\n         acceptChildResult()), and is expected to return the \"result\" for\n         this node.  If not specified, the default action is to return\n         the data object from enterNode().\n\n     descend, child_result = beforeChild(self, node, child, child_idx):\n\n         beforeChild() is called by a node for every child before\n         entering the child node.  The node, child node, and child index\n         (position in the args list from enterNode()) are passed as\n         arguments.  beforeChild should return a tuple (descend,\n         child_result).  If descend is False, the child node will not be\n         entered and the value returned to child_result will be passed to\n         the node's acceptChildResult callback.  Returning None is\n         equivalent to (True, None).  The default behavior if not\n         specified is equivalent to (True, None).\n\n     data = acceptChildResult(self, node, data, child_result, child_idx):\n\n         acceptChildResult() is called for each child result being",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 1660,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pyomo/common/numeric_types.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nimport logging\nimport sys\n\nfrom pyomo.common.deprecation import deprecated, relocated_module_attribute\nfrom pyomo.common.errors import TemplateExpressionError\n\nlogger = logging.getLogger(__name__)\n\n#: Python set used to identify numeric constants, boolean values, strings\n#: and instances of\n#: :class:`NonNumericValue <pyomo.core.expr.numvalue.NonNumericValue>`,\n#: which is commonly used in code that walks Pyomo expression trees.\n#:\n#: :data:`nonpyomo_leaf_types` = :data:`native_types <pyomo.core.expr.numvalue.native_types>` + { :data:`NonNumericValue <pyomo.core.expr.numvalue.NonNumericValue>` }\nnonpyomo_leaf_types = set()\n\n# It is *significantly* faster to build the list of types we want to\n# test against as a \"static\" set, and not to regenerate it locally for\n# every call.  Plus, this allows us to dynamically augment the set\n# with new \"native\" types (e.g., from NumPy)\n#\n# Note: These type sets are used in set_types.py for domain validation\n#       For backward compatibility reasons, we include str in the set\n#       of valid types for bool. We also avoid updating the numeric\n#       and integer type sets when a new boolean type is registered\n#       because not all boolean types exhibit numeric properties\n#       (e.g., numpy.bool_)\n#\n\n#: Python set used to identify numeric constants.  This set includes\n#: native Python types as well as numeric types from Python packages\n#: like numpy, which may be registered by users.\nnative_numeric_types = {int, float, complex}\nnative_integer_types = {int}\nnative_logical_types = {bool}\npyomo_constant_types = set()  # includes NumericConstant\n\n_native_boolean_types = {int, bool, str, bytes}\nrelocated_module_attribute(\n    'native_boolean_types',\n    'pyomo.common.numeric_types._native_boolean_types',\n    version='6.6.0',\n    msg=\"The native_boolean_types set will be removed in the future: the set \"\n    \"contains types that were convertible to bool, and not types that should \"\n    \"be treated as if they were bool (as was the case for the other \"\n    \"native_*_types sets).  Users likely should use native_logical_types.\",\n)\n\n\n#: Python set used to identify numeric constants and related native\n#: types.  This set includes\n#: native Python types as well as numeric types from Python packages\n#: like numpy.\n#:\n#: :data:`native_types` = :data:`native_numeric_types <pyomo.core.expr.numvalue.native_numeric_types>` + { str }\nnative_types = set([bool, str, type(None), slice, bytes])\nnative_types.update(native_numeric_types)\nnative_types.update(native_integer_types)\nnative_types.update(_native_boolean_types)\nnative_types.update(native_logical_types)\n\nnonpyomo_leaf_types.update(native_types)\n\n\ndef RegisterNumericType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized to handle numeric values.\n\n    The argument should be a class (e.g, numpy.float64).\n    \"\"\"\n    native_numeric_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\ndef RegisterIntegerType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized to handle integer values. This also registers the type\n    as numeric but does not register it as boolean.\n\n    The argument should be a class (e.g., numpy.int64).\n    \"\"\"\n    native_numeric_types.add(new_type)\n    native_integer_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\n@deprecated(\n    \"The native_boolean_types set (and hence RegisterBooleanType) \"\n    \"is deprecated.  Users likely should use RegisterLogicalType.\",\n    version='6.6.0',\n)\ndef RegisterBooleanType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized as handling boolean values. This function does not\n    register the type of integer or numeric.\n\n    The argument should be a class (e.g., numpy.bool_).\n    \"\"\"\n    _native_boolean_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\ndef RegisterLogicalType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized as handling boolean values. This function does not\n    register the type of integer or numeric.\n\n    The argument should be a class (e.g., numpy.bool_).\n    \"\"\"\n    _native_boolean_types.add(new_type)\n    native_logical_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\ndef check_if_numeric_type(obj):\n    \"\"\"Test if the argument behaves like a numeric type.\n\n    We check for \"numeric types\" by checking if we can add zero to it\n    without changing the object's type.  If that works, then we register\n    the type in native_numeric_types.\n\n    \"\"\"\n    obj_class = obj.__class__\n    # Do not re-evaluate known native types\n    if obj_class in native_types:\n        return obj_class in native_numeric_types\n\n    try:\n        obj_plus_0 = obj + 0\n        obj_p0_class = obj_plus_0.__class__\n        # ensure that the object is comparable to 0 in a meaningful way",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 266,
  "is_truncated": true
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "grep: pyomo/common/collections.py: No such file or directory\n",
  "details": {
    "stdout": "",
    "stderr": "grep: pyomo/common/collections.py: No such file or directory\n",
    "exit_code": 2
  }
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "pyomo/common/plugins.py\npyomo/common/errors.py\npyomo/common/log.py\npyomo/common/formatting.py\npyomo/common/_common.py\npyomo/common/tempfiles.py\npyomo/common/gc_manager.py\npyomo/common/collections/bunch.py\npyomo/common/collections/__init__.py\npyomo/common/collections/orderedset.py\npyomo/common/collections/component_set.py\npyomo/common/collections/component_map.py\npyomo/common/plugin_base.py\npyomo/common/autoslots.py\npyomo/common/config.py\npyomo/common/deprecation.py\npyomo/common/sorting.py\npyomo/common/getGSL.py\npyomo/common/pyomo_typing.py\npyomo/common/backports.py\npyomo/common/timing.py\npyomo/common/numeric_types.py\npyomo/common/dependencies.py\npyomo/common/extensions.py\npyomo/common/_command.py\npyomo/common/shutdown.py\npyomo/common/tee.py\npyomo/common/__init__.py\npyomo/common/envvar.py\npyomo/common/modeling.py\npyomo/common/gsl.py\npyomo/common/cmake_builder.py\npyomo/common/download.py\npyomo/common/multithread.py\npyomo/common/unittest.py\npyomo/common/env.py\npyomo/common/plugin.py\npyomo/common/factory.py\npyomo/common/fileutils.py\npyomo/common/tests/test_unittest.py\npyomo/common/tests/import_ex.py\npyomo/common/tests/test_env.py\npyomo/common/tests/relo_mod.py\npyomo/common/tests/test_tempfile.py\npyomo/common/tests/test_orderedset.py\npyomo/common/tests/relocated.py\npyomo/common/tests/dep_mod_except.py\npyomo/common/tests/test_bunch.py\npyomo/common/tests/config_plugin.py\npyomo/common/tests/test_errors.py\npyomo/common/tests/test_sorting.py\npyomo/common/tests/test_formatting.py\npyomo/common/tests/test_modeling.py\npyomo/common/tests/test_typing.py\npyomo/common/tests/test_config.py\npyomo/common/tests/test_download.py\npyomo/common/tests/__init__.py\npyomo/common/tests/test_deprecated.py\npyomo/common/tests/test_fileutils.py\npyomo/common/tests/test_plugin.py\npyomo/common/tests/deps.py\npyomo/common/tests/dep_mod.py\npyomo/common/tests/test_tee.py\npyomo/common/tests/test_dependencies.py\npyomo/common/tests/relo_mod_new.py\npyomo/common/tests/test_log.py\npyomo/common/tests/test_gc.py\npyomo/common/tests/test_multithread.py\npyomo/common/tests/test_timing.py\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pyomo/common/collections/component_map.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom collections.abc import MutableMapping as collections_MutableMapping\nfrom collections.abc import Mapping as collections_Mapping\nfrom pyomo.common.autoslots import AutoSlots\n\n\ndef _rebuild_ids(encode, val):\n    if encode:\n        return val\n    else:\n        # object id() may have changed after unpickling,\n        # so we rebuild the dictionary keys\n        return {id(obj): (obj, v) for obj, v in val.values()}\n\n\nclass ComponentMap(AutoSlots.Mixin, collections_MutableMapping):\n    \"\"\"\n    This class is a replacement for dict that allows Pyomo\n    modeling components to be used as entry keys. The\n    underlying mapping is based on the Python id() of the\n    object, which gets around the problem of hashing\n    subclasses of NumericValue. This class is meant for\n    creating mappings from Pyomo components to values. The\n    use of non-Pyomo components as entry keys should be\n    avoided.\n\n    A reference to the object is kept around as long as it\n    has a corresponding entry in the container, so there is\n    no need to worry about id() clashes.\n\n    We also override __setstate__ so that we can rebuild the\n    container based on possibly updated object ids after\n    a deepcopy or pickle.\n\n    *** An instance of this class should never be\n    deepcopied/pickled unless it is done so along with the\n    components for which it contains map entries (e.g., as\n    part of a block). ***\n    \"\"\"\n\n    __slots__ = (\"_dict\",)\n    __autoslot_mappers__ = {'_dict': _rebuild_ids}\n\n    def __init__(self, *args, **kwds):\n        # maps id(obj) -> (obj,val)\n        self._dict = {}\n        # handle the dict-style initialization scenarios\n        self.update(*args, **kwds)\n\n    def __str__(self):\n        \"\"\"String representation of the mapping.\"\"\"\n        tmp = {str(c) + \" (id=\" + str(id(c)) + \")\": v for c, v in self.items()}\n        return \"ComponentMap(\" + str(tmp) + \")\"\n\n    #\n    # Implement MutableMapping abstract methods\n    #\n\n    def __getitem__(self, obj):\n        try:\n            return self._dict[id(obj)][1]\n        except KeyError:\n            raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\n\n    def __setitem__(self, obj, val):\n        self._dict[id(obj)] = (obj, val)\n\n    def __delitem__(self, obj):\n        try:\n            del self._dict[id(obj)]\n        except KeyError:\n            raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\n\n    def __iter__(self):\n        return (obj for obj, val in self._dict.values())\n\n    def __len__(self):\n        return self._dict.__len__()\n\n    #\n    # Overload MutableMapping default implementations\n    #\n\n    # We want to avoid generating Pyomo expressions due to\n    # comparison of values, so we convert both objects to a\n    # plain dictionary mapping key->(type(val), id(val)) and\n    # compare that instead.\n    def __eq__(self, other):\n        if not isinstance(other, collections_Mapping):\n            return False\n        return {(type(key), id(key)): val for key, val in self.items()} == {\n            (type(key), id(key)): val for key, val in other.items()\n        }\n\n    def __ne__(self, other):\n        return not (self == other)\n\n    #\n    # The remaining methods have slow default\n    # implementations for MutableMapping. In particular,\n    # they rely KeyError catching, which is slow for this\n    # class because KeyError messages use fully qualified\n    # names.\n    #\n\n    def __contains__(self, obj):\n        return id(obj) in self._dict\n\n    def clear(self):\n        'D.clear() -> None.  Remove all items from D.'\n        self._dict.clear()\n\n    def get(self, key, default=None):\n        'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.'\n        if key in self:\n            return self[key]\n        return default\n\n    def setdefault(self, key, default=None):\n        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'\n        if key in self:\n            return self[key]\n        else:\n            self[key] = default\n        return default",
  "start_line": 1,
  "end_line": 135,
  "total_lines": 135,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "861:    def dfs_postorder_stack(self, node):\n1061:    def dfs_postorder_stack(self, expr):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/visitor.py",
  "content": "    def dfs_postorder_stack(self, node):\n        \"\"\"\n        Perform a depth-first search in postorder using a stack\n        implementation.\n\n        Note:\n            This method has the same functionality as the\n            PyUtilib :class:`ValueVisitor.dfs_postorder_stack <pyutilib.misc.visitor.ValueVisitor.dfs_postorder_stack>`\n            method.  The difference is that this method\n            is tailored to efficiently walk Pyomo expression trees.\n\n        Args:\n            node: The root node of the expression tree\n                that is searched.\n\n        Returns:\n            The return value is determined by the :func:`finalize` function,\n            which may be defined by the user.\n        \"\"\"\n        flag, value = self.visiting_potential_leaf(node)\n        if flag:\n            return self.finalize(value)\n        # _stack = [ (node, self.children(node), 0, len(self.children(node)), [])]\n        _stack = [(node, node._args_, 0, node.nargs(), [])]\n        #\n        # Iterate until the stack is empty\n        #\n        # Note: 1 is faster than True for Python 2.x\n        #\n        while 1:\n            #\n            # Get the top of the stack\n            #   _obj        Current expression object\n            #   _argList    The arguments for this expression object\n            #   _idx        The current argument being considered\n            #   _len        The number of arguments\n            #   _result     The return values\n            #\n            _obj, _argList, _idx, _len, _result = _stack.pop()\n            #\n            # Iterate through the arguments\n            #\n            while _idx < _len:\n                _sub = _argList[_idx]\n                _idx += 1\n                flag, value = self.visiting_potential_leaf(_sub)\n                if flag:\n                    _result.append(value)\n                else:\n                    #\n                    # Push an expression onto the stack\n                    #\n                    _stack.append((_obj, _argList, _idx, _len, _result))\n                    _obj = _sub\n                    # _argList                = self.children(_sub)\n                    _argList = _sub._args_\n                    _idx = 0\n                    _len = _sub.nargs()\n                    _result = []\n            #\n            # Process the current node\n            #\n            ans = self.visit(_obj, _result)\n            if _stack:\n                #\n                # \"return\" the recursion by putting the return value on the end of the results stack\n                #\n                _stack[-1][-1].append(ans)\n            else:\n                return self.finalize(ans)\n\n\ndef replace_expressions(\n    expr,\n    substitution_map,\n    descend_into_named_expressions=True,\n    remove_named_expressions=True,\n):\n    \"\"\"\n\n    Parameters\n    ----------\n    expr : Pyomo expression\n       The source expression\n    substitution_map : dict\n       A dictionary mapping object ids in the source to the replacement objects.\n    descend_into_named_expressions : bool\n       True if replacement should go into named expression objects, False to halt at\n       a named expression\n    remove_named_expressions : bool\n       True if the named expressions should be replaced with a standard expression,\n       and False if the named expression should be left in place\n\n    Returns\n    -------\n       Pyomo expression : returns the new expression object\n    \"\"\"\n    return ExpressionReplacementVisitor(\n        substitute=substitution_map,\n        descend_into_named_expressions=descend_into_named_expressions,\n        remove_named_expressions=remove_named_expressions,\n    ).walk_expression(expr)\n\n\nclass ExpressionReplacementVisitor(StreamBasedExpressionVisitor):\n    def __init__(\n        self,\n        substitute=None,\n        descend_into_named_expressions=True,\n        remove_named_expressions=True,\n    ):\n        if substitute is None:\n            substitute = {}\n        # Note: preserving the attribute names from the previous\n        # implementation of the expression walker.\n        self.substitute = substitute\n        self.enter_named_expr = descend_into_named_expressions\n        self.rm_named_expr = remove_named_expressions\n\n        kwds = {}\n        if hasattr(self, 'visiting_potential_leaf'):\n            deprecation_warning(\n                \"ExpressionReplacementVisitor: this walker has been ported \"\n                \"to derive from StreamBasedExpressionVisitor.  \"\n                \"visiting_potential_leaf() has been replaced by beforeChild()\"\n                \"(note to implementers: the sense of the bool return value \"\n                \"has been inverted).\",\n                version='6.2',\n            )\n\n            def beforeChild(node, child, child_idx):\n                is_leaf, ans = self.visiting_potential_leaf(child)\n                return not is_leaf, ans\n\n            kwds['beforeChild'] = beforeChild\n\n        if hasattr(self, 'visit'):\n            raise DeveloperError(\n                \"ExpressionReplacementVisitor: this walker has been ported \"\n                \"to derive from StreamBasedExpressionVisitor.  \"\n                \"overriding visit() has no effect (and is likely to generate \"\n                \"invalid expression trees)\"\n            )\n        super().__init__(**kwds)\n\n    def initializeWalker(self, expr):\n        walk, result = self.beforeChild(None, expr, 0)\n        if not walk:\n            return False, result\n        return True, expr",
  "start_line": 861,
  "end_line": 1010,
  "total_lines": 1660,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/visitor.py",
  "content": "    def dfs_postorder_stack(self, expr):\n        return self.walk_expression(expr)\n\n\ndef evaluate_fixed_subexpressions(\n    expr, descend_into_named_expressions=True, remove_named_expressions=True\n):\n    return EvaluateFixedSubexpressionVisitor(\n        descend_into_named_expressions=descend_into_named_expressions,\n        remove_named_expressions=remove_named_expressions,\n    ).walk_expression(expr)\n\n\nclass EvaluateFixedSubexpressionVisitor(ExpressionReplacementVisitor):\n    def __init__(\n        self, descend_into_named_expressions=False, remove_named_expressions=False\n    ):\n        super().__init__(\n            descend_into_named_expressions=descend_into_named_expressions,\n            remove_named_expressions=remove_named_expressions,\n        )\n\n    def beforeChild(self, node, child, child_idx):\n        if type(child) in native_types:\n            return False, child\n        elif not child.is_expression_type():\n            if child.is_fixed():\n                return False, child()\n            else:\n                return False, child\n        elif child.is_named_expression_type():\n            if not self.enter_named_expr:\n                return False, child\n        return True, None\n\n\n# -------------------------------------------------------\n#\n# Functions used to process expression trees\n#",
  "start_line": 1061,
  "end_line": 1100,
  "total_lines": 1660,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom pyomo.common.collections import ComponentMap, ComponentSet\nimport pyomo.core.expr as _expr\nfrom pyomo.core.expr.visitor import ExpressionValueVisitor, nonpyomo_leaf_types\nfrom pyomo.core.expr.numvalue import value, is_constant\nfrom pyomo.core.expr import exp, log, sin, cos\nimport math\n\n\n\"\"\"\nThe purpose of this file is to perform symbolic differentiation and \nfirst order automatic differentiation directly with pyomo \nexpressions. This is certainly not as efficient as doing AD in C or \nC++, but it avoids the translation from pyomo expressions to a form \nwhere AD can be performed efficiently. The only functions that are \nmeant to be used by users are reverse_ad and reverse_sd. First, \nvalues are propagated from the leaves to each node in the tree with \nthe LeafToRoot visitors. Then derivative values are propagated from \nthe root to the leaves with the RootToLeaf visitors.\n\"\"\"\n\n\nclass DifferentiationException(Exception):\n    pass\n\n\ndef _diff_ProductExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.ProductExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    der_dict[arg1] += der * val_dict[arg2]\n    der_dict[arg2] += der * val_dict[arg1]\n\n\ndef _diff_SumExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.SumExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der = der_dict[node]\n    for arg in node.args:\n        der_dict[arg] += der\n\n\ndef _diff_PowExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.PowExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    arg1, arg2 = node.args\n    der = der_dict[node]\n    val1 = val_dict[arg1]\n    val2 = val_dict[arg2]\n    der_dict[arg1] += der * val2 * val1 ** (val2 - 1)\n    if arg2.__class__ not in nonpyomo_leaf_types:\n        der_dict[arg2] += der * val1**val2 * log(val1)\n\n\ndef _diff_DivisionExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.DivisionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 2\n    num = node.args[0]\n    den = node.args[1]\n    der = der_dict[node]\n    der_dict[num] += der * (1 / val_dict[den])\n    der_dict[den] -= der * val_dict[num] / val_dict[den] ** 2\n\n\ndef _diff_NegationExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] -= der\n\n\ndef _diff_exp(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der * exp(val_dict[arg])\n\n\ndef _diff_log(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.UnaryFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    assert len(node.args) == 1\n    arg = node.args[0]\n    der = der_dict[node]\n    der_dict[arg] += der / val_dict[arg]\n\n\ndef _diff_log10(node, val_dict, der_dict):\n    \"\"\"\n",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 484,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "321:def _diff_GeneralExpression(node, val_dict, der_dict):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "def _diff_GeneralExpression(node, val_dict, der_dict):\n    \"\"\"\n    Reverse automatic differentiation for named expressions.\n\n    Parameters\n    ----------\n    node: The named expression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der_dict[node.expr] += der_dict[node]\n\n\ndef _diff_ExternalFunctionExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.ExternalFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der = der_dict[node]\n    vals = tuple(val_dict[i] for i in node.args)\n    derivs = node._fcn.evaluate_fgh(vals, fgh=1)[1]\n    for ndx, arg in enumerate(node.args):\n        der_dict[arg] += der * derivs[ndx]\n\n\n_diff_map = dict()",
  "start_line": 321,
  "end_line": 350,
  "total_lines": 484,
  "is_truncated": false,
  "budget_warning": "Only 9 tool call(s) remaining (21/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "384:class _LeafToRootVisitor(ExpressionValueVisitor):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 8 tool call(s) remaining (22/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "class _LeafToRootVisitor(ExpressionValueVisitor):\n    def __init__(self, val_dict, der_dict, expr_list, numeric=True):\n        \"\"\"\n        Parameters\n        ----------\n        val_dict: ComponentMap\n        der_dict: ComponentMap\n        \"\"\"\n        self.val_dict = val_dict\n        self.der_dict = der_dict\n        self.expr_list = expr_list\n        assert len(self.expr_list) == 0\n        assert len(self.val_dict) == 0\n        assert len(self.der_dict) == 0\n        if numeric:\n            self.value_func = value\n            self.operation_func = _numeric_apply_operation\n        else:\n            self.value_func = _symbolic_value\n            self.operation_func = _symbolic_apply_operation\n\n    def visit(self, node, values):\n        self.val_dict[node] = self.operation_func(node, values)\n        self.der_dict[node] = 0\n        self.expr_list.append(node)\n        return self.val_dict[node]\n\n    def visiting_potential_leaf(self, node):\n        if node in self.val_dict:\n            return True, self.val_dict[node]\n\n        if node.__class__ in nonpyomo_leaf_types:\n            self.val_dict[node] = node\n            self.der_dict[node] = 0\n            return True, node\n\n        if not node.is_expression_type():\n            val = self.value_func(node)\n            self.val_dict[node] = val\n            self.der_dict[node] = 0\n            return True, val\n\n        return False, None\n\n\ndef _reverse_diff_helper(expr, numeric=True):\n    val_dict = ComponentMap()",
  "start_line": 384,
  "end_line": 430,
  "total_lines": 484,
  "is_truncated": false,
  "budget_warning": "Only 7 tool call(s) remaining (23/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  },
  "budget_warning": "Only 6 tool call(s) remaining (24/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "grep: invalid option -- '/'\nUsage: grep [OPTION]... PATTERNS [FILE]...\nTry 'grep --help' for more information.\n",
  "details": {
    "stdout": "",
    "stderr": "grep: invalid option -- '/'\nUsage: grep [OPTION]... PATTERNS [FILE]...\nTry 'grep --help' for more information.\n",
    "exit_code": 2
  },
  "budget_warning": "Only 5 tool call(s) remaining (25/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "25:    nonpyomo_leaf_types,\n323:            if type(node) in nonpyomo_leaf_types or not node.is_expression_type():\n395:            if type(node) in nonpyomo_leaf_types or not node.is_expression_type():\n450:        if type(node) in nonpyomo_leaf_types or not node.is_expression_type():\n531:            if type(expr) in nonpyomo_leaf_types or not expr.is_expression_type():\n609:                            type(child) in nonpyomo_leaf_types\n734:                    c.__class__ in nonpyomo_leaf_types\n766:            node.__class__ in nonpyomo_leaf_types\n785:                    c.__class__ in nonpyomo_leaf_types\n1181:        if node.__class__ in nonpyomo_leaf_types:\n1216:        if node.__class__ in nonpyomo_leaf_types:\n1368:        if node.__class__ in nonpyomo_leaf_types:\n1420:        if node.__class__ in nonpyomo_leaf_types:\n1462:        if node.__class__ in nonpyomo_leaf_types:\n1511:        if node.__class__ in nonpyomo_leaf_types:\n1561:            elif arg.__class__ in nonpyomo_leaf_types:\n1598:        if node.__class__ in nonpyomo_leaf_types:\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 4 tool call(s) remaining (26/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/visitor.py",
  "content": "import logging\nimport sys\nfrom copy import deepcopy\nfrom collections import deque\n\nlogger = logging.getLogger('pyomo.core')\n\nfrom pyomo.common.deprecation import deprecated, deprecation_warning\nfrom pyomo.common.errors import DeveloperError, TemplateExpressionError\nfrom pyomo.common.numeric_types import (\n    nonpyomo_leaf_types,\n    native_types,\n    native_numeric_types,\n    value,\n)\nimport pyomo.core.expr.expr_common as common\nfrom pyomo.core.expr.symbol_map import SymbolMap\n\ntry:\n    # sys._getframe is slightly faster than inspect's currentframe, but\n    # is not guaranteed to exist everywhere\n    currentframe = sys._getframe\nexcept AttributeError:\n    currentframe = inspect.currentframe\n\n",
  "start_line": 15,
  "end_line": 40,
  "total_lines": 1660,
  "is_truncated": false,
  "budget_warning": "Only 3 tool call(s) remaining (27/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "pyomo/common/numeric_types.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nimport logging\nimport sys\n\nfrom pyomo.common.deprecation import deprecated, relocated_module_attribute\nfrom pyomo.common.errors import TemplateExpressionError\n\nlogger = logging.getLogger(__name__)\n\n#: Python set used to identify numeric constants, boolean values, strings\n#: and instances of\n#: :class:`NonNumericValue <pyomo.core.expr.numvalue.NonNumericValue>`,\n#: which is commonly used in code that walks Pyomo expression trees.\n#:\n#: :data:`nonpyomo_leaf_types` = :data:`native_types <pyomo.core.expr.numvalue.native_types>` + { :data:`NonNumericValue <pyomo.core.expr.numvalue.NonNumericValue>` }\nnonpyomo_leaf_types = set()\n\n# It is *significantly* faster to build the list of types we want to\n# test against as a \"static\" set, and not to regenerate it locally for\n# every call.  Plus, this allows us to dynamically augment the set\n# with new \"native\" types (e.g., from NumPy)\n#\n# Note: These type sets are used in set_types.py for domain validation\n#       For backward compatibility reasons, we include str in the set\n#       of valid types for bool. We also avoid updating the numeric\n#       and integer type sets when a new boolean type is registered\n#       because not all boolean types exhibit numeric properties\n#       (e.g., numpy.bool_)\n#\n\n#: Python set used to identify numeric constants.  This set includes\n#: native Python types as well as numeric types from Python packages\n#: like numpy, which may be registered by users.\nnative_numeric_types = {int, float, complex}\nnative_integer_types = {int}\nnative_logical_types = {bool}\npyomo_constant_types = set()  # includes NumericConstant\n\n_native_boolean_types = {int, bool, str, bytes}\nrelocated_module_attribute(\n    'native_boolean_types',\n    'pyomo.common.numeric_types._native_boolean_types',\n    version='6.6.0',\n    msg=\"The native_boolean_types set will be removed in the future: the set \"\n    \"contains types that were convertible to bool, and not types that should \"\n    \"be treated as if they were bool (as was the case for the other \"\n    \"native_*_types sets).  Users likely should use native_logical_types.\",\n)\n\n\n#: Python set used to identify numeric constants and related native\n#: types.  This set includes\n#: native Python types as well as numeric types from Python packages\n#: like numpy.\n#:\n#: :data:`native_types` = :data:`native_numeric_types <pyomo.core.expr.numvalue.native_numeric_types>` + { str }\nnative_types = set([bool, str, type(None), slice, bytes])\nnative_types.update(native_numeric_types)\nnative_types.update(native_integer_types)\nnative_types.update(_native_boolean_types)\nnative_types.update(native_logical_types)\n\nnonpyomo_leaf_types.update(native_types)\n\n\ndef RegisterNumericType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized to handle numeric values.\n\n    The argument should be a class (e.g, numpy.float64).\n    \"\"\"\n    native_numeric_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\ndef RegisterIntegerType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized to handle integer values. This also registers the type\n    as numeric but does not register it as boolean.\n\n    The argument should be a class (e.g., numpy.int64).\n    \"\"\"\n    native_numeric_types.add(new_type)\n    native_integer_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\n@deprecated(\n    \"The native_boolean_types set (and hence RegisterBooleanType) \"\n    \"is deprecated.  Users likely should use RegisterLogicalType.\",\n    version='6.6.0',\n)\ndef RegisterBooleanType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized as handling boolean values. This function does not\n    register the type of integer or numeric.\n\n    The argument should be a class (e.g., numpy.bool_).\n    \"\"\"\n    _native_boolean_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\ndef RegisterLogicalType(new_type):\n    \"\"\"\n    A utility function for updating the set of types that are\n    recognized as handling boolean values. This function does not\n    register the type of integer or numeric.\n\n    The argument should be a class (e.g., numpy.bool_).\n    \"\"\"\n    _native_boolean_types.add(new_type)\n    native_logical_types.add(new_type)\n    native_types.add(new_type)\n    nonpyomo_leaf_types.add(new_type)\n\n\ndef check_if_numeric_type(obj):\n    \"\"\"Test if the argument behaves like a numeric type.\n\n    We check for \"numeric types\" by checking if we can add zero to it\n    without changing the object's type.  If that works, then we register\n    the type in native_numeric_types.\n\n    \"\"\"\n    obj_class = obj.__class__\n    # Do not re-evaluate known native types\n    if obj_class in native_types:\n        return obj_class in native_numeric_types\n\n    try:\n        obj_plus_0 = obj + 0\n        obj_p0_class = obj_plus_0.__class__\n        # ensure that the object is comparable to 0 in a meaningful way",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 266,
  "is_truncated": true,
  "budget_warning": "Only 2 tool call(s) remaining (28/30 used). Finalize your edits and call submit_patch soon."
}