rigetticomputing__pyquil-115

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

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

{
  "status": "ok",
  "stdout": "51:class PauliTerm(object):\n70:            raise ValueError(\"coefficient of PauliTerm must be a Number.\")\n76:        Returns the unique identifier string for the PauliTerm (ignoring the coefficient).\n92:        if not isinstance(other, (PauliTerm, PauliSum)):\n93:            raise TypeError(\"Can't compare PauliTerm with object of type {}.\".format(type(other)))\n107:        The length of the PauliTerm is the number of Pauli operators in the term. A term that\n114:        Properly creates a new PauliTerm, with a completely new dictionary\n117:        new_term = PauliTerm(\"I\", 0, 1.0)  # create new object\n129:        \"\"\"Gets all the qubits that this PauliTerm operates on.\n142:        new_term = PauliTerm(\"I\", 0)\n160:        \"\"\"Multiplies this Pauli Term with another PauliTerm, PauliSum, or number according to the\n163:        :param term: (PauliTerm or PauliSum or Number) A term to multiply by.\n164:        :returns: The product of this PauliTerm and term.\n165:        :rtype: PauliTerm\n172:            new_term = PauliTerm(\"I\", 0, 1.0)\n181:        \"\"\"Multiplies this PauliTerm with another object, probably a number.\n183:        :param other: A number or PauliTerm to multiply by\n184:        :returns: A new PauliTerm\n185:        :rtype: PauliTerm\n191:        \"\"\"Raises this PauliTerm to power.\n193:        :param int power: The power to raise this PauliTerm to.\n195:        :rtype: PauliTerm\n201:        identities = [PauliTerm('I', qubit) for qubit in self.get_qubits()]\n212:        \"\"\"Adds this PauliTerm with another one.\n214:        :param other: A PauliTerm object or a Number\n215:        :returns: A PauliSum object representing the sum of this PauliTerm and other\n219:            return self + PauliTerm(\"I\", 0, other)\n227:        \"\"\"Adds this PauliTerm with a Number.\n229:        :param other: A PauliTerm object or a Number\n230:        :returns: A new PauliTerm\n231:        :rtype: PauliTerm\n237:        \"\"\"Subtracts a PauliTerm from this one.\n239:        :param other: A PauliTerm object or a Number\n240:        :returns: A PauliSum object representing the difference of this PauliTerm and term\n246:        \"\"\"Subtracts this PauliTerm from a Number or PauliTerm.\n248:        :param other: A PauliTerm object or a Number\n249:        :returns: A PauliSum object representing the difference of this PauliTerm and term\n266:ID = PauliTerm(\"I\", 0)\n270:sI = lambda q: PauliTerm(\"I\", q)\n275::returns: A PauliTerm object\n276::rtype: PauliTerm\n278:sX = lambda q: PauliTerm(\"X\", q)\n283::returns: A PauliTerm object\n284::rtype: PauliTerm\n286:sY = lambda q: PauliTerm(\"Y\", q)\n291::returns: A PauliTerm object\n292::rtype: PauliTerm\n294:sZ = lambda q: PauliTerm(\"Z\", q)\n299::returns: A PauliTerm object\n300::rtype: PauliTerm\n306:    Change the coefficient of a PauliTerm.\n308:    :param PauliTerm term: A PauliTerm object\n309:    :param Number coeff: The coefficient to set on the PauliTerm\n310:    :returns: A new PauliTerm that duplicates term but sets coeff\n311:    :rtype: PauliTerm\n322:    \"\"\"A sum of one or more PauliTerms.\n327:        :param Sequence terms: A Sequence of PauliTerms.\n330:                all([isinstance(term, PauliTerm) for term in terms])):\n331:            raise ValueError(\"PauliSum's are currently constructed from Sequences of PauliTerms.\")\n344:        if not isinstance(other, (PauliTerm, PauliSum)):\n346:        elif isinstance(other, PauliTerm):\n367:        The length of the PauliSum is the number of PauliTerms in the sum.\n374:        :return: The PauliTerm at the index-th position in the PauliSum\n375:        :rtype: PauliTerm\n384:        Multiplies together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n387:        :param other: a PauliSum, PauliTerm or Number object\n391:        if not isinstance(other, (Number, PauliTerm, PauliSum)):\n392:            raise ValueError(\"Cannot multiply PauliSum by term that is not a Number, PauliTerm, or\"\n404:        Multiples together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n407:        :param other: a PauliSum, PauliTerm or Number object\n436:                    result *= PauliTerm(\"I\", qubit_id)\n444:        Adds together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n447:        :param other: a PauliSum, PauliTerm or Number object\n451:        if isinstance(other, PauliTerm):\n462:        Adds together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n465:        :param other: a PauliSum, PauliTerm or Number object\n474:        Finds the difference of this PauliSum with PauliSum, PauliTerm or Number objects. The new\n477:        :param other: a PauliSum, PauliTerm or Number object\n485:        Finds the different of this PauliSum with PauliSum, PauliTerm or Number objects. The new\n488:        :param other: a PauliSum, PauliTerm or Number object\n533:    Check if commuting a PauliTerm commutes with a list of other terms by natural calculation.\n537:    :param list pauli_list: A list of PauliTerm objects\n538:   ",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "class PauliTerm(object):\n    \"\"\"A term is a product of Pauli operators operating on different qubits.\n    \"\"\"\n\n    def __init__(self, op, index, coefficient=1.0):\n        \"\"\" Create a new Pauli Term with a Pauli operator at a particular index and a leading\n        coefficient.\n\n        :param string op: The Pauli operator as a string \"X\", \"Y\", \"Z\", or \"I\"\n        :param int index: The qubit index that that operator is applied to.\n        :param float coefficient: The coefficient multiplying the operator, e.g. 1.5 * Z_1\n        \"\"\"\n        assert op in PAULI_OPS\n        assert isinstance(index, integer_types) and index >= 0\n\n        self._ops = {}\n        if op != \"I\":\n            self._ops[index] = op\n        if not isinstance(coefficient, Number):\n            raise ValueError(\"coefficient of PauliTerm must be a Number.\")\n        self.coefficient = complex(coefficient)\n        self._id = None\n\n    def id(self):\n        \"\"\"\n        Returns the unique identifier string for the PauliTerm (ignoring the coefficient).\n         Used in the simplify method of PauliSum.\n\n        :return: The unique identifier for this term.\n        :rtype: string\n        \"\"\"\n        if self._id is not None:\n            return self._id\n        else:\n            s = \"\"\n            for index in sorted(self._ops.keys()):\n                s += \"%s%s\" % (self[index], index)\n            self._id = s\n            return s\n\n    def __eq__(self, other):\n        if not isinstance(other, (PauliTerm, PauliSum)):\n            raise TypeError(\"Can't compare PauliTerm with object of type {}.\".format(type(other)))\n        elif isinstance(other, PauliSum):\n            return other == self\n        else:\n            return self.id() == other.id() and np.isclose(self.coefficient, other.coefficient)\n\n    def __ne__(self, other):\n        # x!=y and x<>y call __ne__() instead of negating __eq__\n        # This is only a weirdness in python2 as in python 3 __ne__ defaults to the inversion of\n        # __eq__\n        return not self.__eq__(other)\n\n    def __len__(self):\n        \"\"\"\n        The length of the PauliTerm is the number of Pauli operators in the term. A term that\n        consists of only a scalar has a length of zero.\n        \"\"\"\n        return len(self._ops)\n\n    def copy(self):\n        \"\"\"\n        Properly creates a new PauliTerm, with a completely new dictionary\n        of operators\n        \"\"\"\n        new_term = PauliTerm(\"I\", 0, 1.0)  # create new object\n        # manually copy all attributes over\n        for key in self.__dict__.keys():\n            val = self.__dict__[key]\n            if isinstance(val, (dict, list, set)):  # mutable types\n                new_term.__dict__[key] = copy.copy(val)\n            else:  # immutable types\n                new_term.__dict__[key] = val\n\n        return new_term\n\n    def get_qubits(self):\n        \"\"\"Gets all the qubits that this PauliTerm operates on.\n        \"\"\"\n        # sort the keys to get a deterministic iteration order over qubits\n        return sorted(self._ops.keys())\n\n    def __getitem__(self, i):\n        return self._ops.get(i, \"I\")\n\n    def __iter__(self):\n        for i in self.get_qubits():\n            yield i, self[i]\n\n    def _multiply_factor(self, factor, index):\n        new_term = PauliTerm(\"I\", 0)\n        new_coeff = self.coefficient\n        new_ops = self._ops.copy()\n\n        ops = self[index] + factor\n        new_op = PAULI_PROD[ops]\n        if new_op != \"I\":\n            new_ops[index] = new_op\n        else:\n            del new_ops[index]\n        new_coeff *= PAULI_COEFF[ops]\n\n        new_term._ops = new_ops\n        new_term.coefficient = new_coeff\n\n        return new_term\n\n    def __mul__(self, term):\n        \"\"\"Multiplies this Pauli Term with another PauliTerm, PauliSum, or number according to the\n        Pauli algebra rules.\n\n        :param term: (PauliTerm or PauliSum or Number) A term to multiply by.\n        :returns: The product of this PauliTerm and term.\n        :rtype: PauliTerm\n        \"\"\"\n        if isinstance(term, Number):\n            return term_with_coeff(self, self.coefficient * term)\n        elif isinstance(term, PauliSum):\n            return (PauliSum([self]) * term).simplify()\n        else:\n            new_term = PauliTerm(\"I\", 0, 1.0)\n            new_term._ops = self._ops.copy()\n            new_coeff = self.coefficient * term.coefficient\n            for index, op in term:\n                new_term = new_term._multiply_factor(op, index)\n\n            return term_with_coeff(new_term, new_term.coefficient * new_coeff)\n\n    def __rmul__(self, other):\n        \"\"\"Multiplies this PauliTerm with another object, probably a number.\n\n        :param other: A number or PauliTerm to multiply by\n        :returns: A new PauliTerm\n        :rtype: PauliTerm\n        \"\"\"\n        assert isinstance(other, Number)\n        return self * other\n\n    def __pow__(self, power):\n        \"\"\"Raises this PauliTerm to power.\n\n        :param int power: The power to raise this PauliTerm to.\n        :return: The power-fold product of power.\n        :rtype: PauliTerm\n        \"\"\"\n        if not isinstance(power, int) or power < 0:\n            raise ValueError(\"The power must be a non-negative integer.\")\n        result = 1\n        ",
  "start_line": 51,
  "end_line": 200,
  "total_lines": 795,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "    \"\"\"A sum of one or more PauliTerms.\n    \"\"\"\n\n    def __init__(self, terms):\n        \"\"\"\n        :param Sequence terms: A Sequence of PauliTerms.\n        \"\"\"\n        if not (isinstance(terms, Sequence) and\n                all([isinstance(term, PauliTerm) for term in terms])):\n            raise ValueError(\"PauliSum's are currently constructed from Sequences of PauliTerms.\")\n        if len(terms) == 0:\n            self.terms = [0.0 * ID]\n        else:\n            self.terms = terms\n\n    def __eq__(self, other):\n        \"\"\"Equality testing to see if two PauliSum's are equivalent.\n\n        :param PauliSum other: The PauliSum to compare this PauliSum with.\n        :return: True if other is equivalent to this PauliSum, False otherwise.\n        :rtype: bool\n        \"\"\"\n        if not isinstance(other, (PauliTerm, PauliSum)):\n            raise TypeError(\"Can't compare PauliSum with object of type {}.\".format(type(other)))\n        elif isinstance(other, PauliTerm):\n            return self == PauliSum(other)\n        elif len(self.terms) != len(other.terms):\n            raise UnequalLengthWarning(\"These PauliSums have a different number of terms.\")\n            return False\n        return all([term == other.terms[i] for i, term in enumerate(self.terms)])\n\n    def __ne__(self, other):\n        \"\"\"Inequality testing to see if two PauliSum's are not equivalent.\n\n        :param PauliSum other: The PauliSum to compare this PauliSum with.\n        :return: False if other is equivalent to this PauliSum, True otherwise.\n        :rtype: bool\n        \"\"\"\n        return not self == other\n\n    def __str__(self):\n        return \" + \".join([str(term) for term in self.terms])\n\n    def __len__(self):\n        \"\"\"\n        The length of the PauliSum is the number of PauliTerms in the sum.\n        \"\"\"\n        return len(self.terms)\n\n    def __getitem__(self, item):\n        \"\"\"\n        :param int item: The index of the term in the sum to return\n        :return: The PauliTerm at the index-th position in the PauliSum\n        :rtype: PauliTerm\n        \"\"\"\n        return self.terms[item]\n\n    def __iter__(self):\n        return self.terms.__iter__()\n\n    def __mul__(self, other):\n        \"\"\"\n        Multiplies together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n        is then simplified according to the Pauli Algebra rules.\n\n        :param other: a PauliSum, PauliTerm or Number object\n        :return: A new PauliSum object given by the multiplication.\n        :rtype: PauliSum\n        \"\"\"\n        if not isinstance(other, (Number, PauliTerm, PauliSum)):\n            raise ValueError(\"Cannot multiply PauliSum by term that is not a Number, PauliTerm, or\"\n                             \"PauliSum\")\n        elif isinstance(other, PauliSum):\n            other_terms = other.terms\n        else:\n            other_terms = [other]\n        new_terms = [lterm * rterm for lterm, rterm in product(self.terms, other_terms)]\n        new_sum = PauliSum(new_terms)\n        return new_sum.simplify()\n\n    def __rmul__(self, other):\n        \"\"\"\n        Multiples together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n        is then simplified according to the Pauli Algebra rules.\n\n        :param other: a PauliSum, PauliTerm or Number object\n        :return: A new PauliSum object given by the multiplication.\n        :rtype: PauliSum\n        \"\"\"\n        assert isinstance(other, Number)\n        new_terms = [term.copy() for term in self.terms]\n        for term in new_terms:\n            term.coefficient *= other\n        return PauliSum(new_terms).simplify()\n\n    def __pow__(self, power):\n        \"\"\"Raises this PauliSum to power.\n\n        :param int power: The power to raise this PauliSum to.\n        :return: The power-th power of this PauliSum.\n        :rtype: PauliSum\n        \"\"\"\n        if not isinstance(power, int) or power < 0:\n            raise ValueError(\"The power must be a non-negative integer.\")\n        result = 1\n\n        if not self.get_qubits():\n            # There aren't any nontrivial operators\n            terms = [term_with_coeff(term, 1) for term in self.terms]\n            for term in terms:\n                result *= term\n        else:\n            for term in self.terms:\n                for qubit_id in term.get_qubits():\n                    result *= PauliTerm(\"I\", qubit_id)\n\n        for _ in range(power):\n            result *= self\n        return result\n\n    def __add__(self, other):\n        \"\"\"\n        Adds together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n        is then simplified according to the Pauli Algebra rules.\n\n        :param other: a PauliSum, PauliTerm or Number object\n        :return: A new PauliSum object given by the addition.\n        :rtype: PauliSum\n        \"\"\"\n        if isinstance(other, PauliTerm):\n            other = PauliSum([other])\n        elif isinstance(other, Number):\n            other = PauliSum([other * ID])\n        new_terms = [term.copy() for term in self.terms]\n        new_terms.extend(other.terms)\n        new_sum = PauliSum(new_terms)\n        return new_sum.simplify()\n\n    def __radd__(self, other):\n        \"\"\"\n        Adds together this PauliSum with PauliSum, PauliTerm or Number objects. The new term\n        is then simplified according to the Pauli Algebra rules.\n\n        :param other: a PauliSum, PauliTerm or Number object\n        :return: A new PauliSum object given by the addition.\n        :rtype: PauliSum\n        \"\"\"\n        assert isinstance(other, Number)\n        return self + other\n",
  "start_line": 322,
  "end_line": 471,
  "total_lines": 795,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "46:class UnequalLengthWarning(Warning):\n48:        super(UnequalLengthWarning, self).__init__(*args, **kwargs)\n349:            raise UnequalLengthWarning(\"These PauliSums have a different number of terms.\")\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "#!/usr/bin/python\n##############################################################################\n# Copyright 2016-2017 Rigetti Computing\n#\n#    Licensed under the Apache License, Version 2.0 (the \"License\");\n#    you may not use this file except in compliance with the License.\n#    You may obtain a copy of the License at\n#\n#        http://www.apache.org/licenses/LICENSE-2.0\n#\n#    Unless required by applicable law or agreed to in writing, software\n#    distributed under the License is distributed on an \"AS IS\" BASIS,\n#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n#    See the License for the specific language governing permissions and\n#    limitations under the License.\n##############################################################################\n\"\"\"\nModule for working with Pauli algebras.\n\"\"\"\n\nfrom __future__ import division\nfrom itertools import product\nimport numpy as np\nimport copy\nfrom .quil import Program\nfrom .gates import H, RZ, RX, CNOT, X, PHASE\nfrom . import quilbase as pqb\nfrom numbers import Number\nfrom collections import Sequence\nfrom six import integer_types\nfrom six.moves import range\n\nPAULI_OPS = [\"X\", \"Y\", \"Z\", \"I\"]\nPAULI_PROD = {'ZZ': 'I', 'YY': 'I', 'XX': 'I', 'II': 'I',\n              'XY': 'Z', 'XZ': 'Y', 'YX': 'Z', 'YZ': 'X', 'ZX': 'Y',\n              'ZY': 'X', 'IX': 'X', 'IY': 'Y', 'IZ': 'Z',\n              'ZI': 'Z', 'YI': 'Y', 'XI': 'X',\n              'X': 'X', 'Y': 'Y', 'Z': 'Z', 'I': 'I'}\nPAULI_COEFF = {'ZZ': 1.0, 'YY': 1.0, 'XX': 1.0, 'II': 1.0,\n               'XY': 1.0j, 'XZ': -1.0j, 'YX': -1.0j, 'YZ': 1.0j, 'ZX': 1.0j,\n               'ZY': -1.0j, 'IX': 1.0, 'IY': 1.0, 'IZ': 1.0, 'ZI': 1.0,\n               'YI': 1.0, 'XI': 1.0,\n               'X': 1.0, 'Y': 1.0, 'Z': 1.0, 'I': 1.0}\n\n\nclass UnequalLengthWarning(Warning):\n    def __init__(self, *args, **kwargs):\n        super(UnequalLengthWarning, self).__init__(*args, **kwargs)\n\n",
  "start_line": 1,
  "end_line": 50,
  "total_lines": 795,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Comparing sum1 == sum2...\nCaught exception: UnequalLengthWarning: These PauliSums have a different number of terms.\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "#!/usr/bin/python\n##############################################################################\n# Copyright 2016-2017 Rigetti Computing\n#\n#    Licensed under the Apache License, Version 2.0 (the \"License\");\n#    you may not use this file except in compliance with the License.\n#    You may obtain a copy of the License at\n#\n#        http://www.apache.org/licenses/LICENSE-2.0\n#\n#    Unless required by applicable law or agreed to in writing, software\n#    distributed under the License is distributed on an \"AS IS\" BASIS,\n#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n#    See the License for the specific language governing permissions and\n#    limitations under the License.\n##############################################################################\n\"\"\"\nModule for working with Pauli algebras.\n\"\"\"\n\nfrom __future__ import division\nfrom itertools import product\nimport numpy as np\nimport copy\nfrom .quil import Program\nfrom .gates import H, RZ, RX, CNOT, X, PHASE\nfrom . import quilbase as pqb\nfrom numbers import Number\nfrom collections import Sequence\nfrom six import integer_types\nfrom six.moves import range\n\nPAULI_OPS = [\"X\", \"Y\", \"Z\", \"I\"]\nPAULI_PROD = {'ZZ': 'I', 'YY': 'I', 'XX': 'I', 'II': 'I',\n              'XY': 'Z', 'XZ': 'Y', 'YX': 'Z', 'YZ': 'X', 'ZX': 'Y',\n              'ZY': 'X', 'IX': 'X', 'IY': 'Y', 'IZ': 'Z',\n              'ZI': 'Z', 'YI': 'Y', 'XI': 'X',\n              'X': 'X', 'Y': 'Y', 'Z': 'Z', 'I': 'I'}\nPAULI_COEFF = {'ZZ': 1.0, 'YY': 1.0, 'XX': 1.0, 'II': 1.0,\n               'XY': 1.0j, 'XZ': -1.0j, 'YX': -1.0j, 'YZ': 1.0j, 'ZX': 1.0j,\n               'ZY': -1.0j, 'IX': 1.0, 'IY': 1.0, 'IZ': 1.0, 'ZI': 1.0,\n               'YI': 1.0, 'XI': 1.0,\n               'X': 1.0, 'Y': 1.0, 'Z': 1.0, 'I': 1.0}\n\n\nclass UnequalLengthWarning(Warning):\n    def __init__(self, *args, **kwargs):\n        super(UnequalLengthWarning, self).__init__(*args, **kwargs)\n\n",
  "start_line": 1,
  "end_line": 50,
  "total_lines": 795,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "occurrences": 1,
  "strategy": "unescaped",
  "diff": "--- a/pyquil/paulis.py\n+++ b/pyquil/paulis.py\n@@ -22,6 +22,7 @@\n from itertools import product\n import numpy as np\n import copy\n+import warnings\n from .quil import Program\n from .gates import H, RZ, RX, CNOT, X, PHASE\n from . import quilbase as pqb\n",
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "\n        :param PauliSum other: The PauliSum to compare this PauliSum with.\n        :return: True if other is equivalent to this PauliSum, False otherwise.\n        :rtype: bool\n        \"\"\"\n        if not isinstance(other, (PauliTerm, PauliSum)):\n            raise TypeError(\"Can't compare PauliSum with object of type {}.\".format(type(other)))\n        elif isinstance(other, PauliTerm):\n            return self == PauliSum(other)\n        elif len(self.terms) != len(other.terms):\n            raise UnequalLengthWarning(\"These PauliSums have a different number of terms.\")\n            return False\n        return all([term == other.terms[i] for i, term in enumerate(self.terms)])\n\n    def __ne__(self, other):\n        \"\"\"Inequality testing to see if two PauliSum's are not equivalent.",
  "start_line": 340,
  "end_line": 355,
  "total_lines": 796,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "occurrences": 1,
  "strategy": "unescaped",
  "diff": "--- a/pyquil/paulis.py\n+++ b/pyquil/paulis.py\n@@ -347,7 +347,7 @@\n         elif isinstance(other, PauliTerm):\n             return self == PauliSum(other)\n         elif len(self.terms) != len(other.terms):\n-            raise UnequalLengthWarning(\"These PauliSums have a different number of terms.\")\n+            warnings.warn(\"These PauliSums have a different number of terms.\", UnequalLengthWarning)\n             return False\n         return all([term == other.terms[i] for i, term in enumerate(self.terms)])\n \n",
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Comparing sum1 == sum2...\nResult: False\nCaught exception: AttributeError: 'list' object has no attribute 'warnings'\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Comparing sum1 == sum2...\nResult: False\nWarnings caught: 1\nWarning message: These PauliSums have a different number of terms.\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "....................................F                                    [100%]\n=================================== FAILURES ===================================\n______________________________ test_sum_equality _______________________________\npyquil/tests/test_paulis.py:542: in test_sum_equality\n    assert pauli_sum != pauli_sum + sZ(0)\nE   Failed: DID NOT RAISE <class 'pyquil.paulis.UnequalLengthWarning'>\n=============================== warnings summary ===============================\n../pyquil/pyquil/paulis.py:30\n  /pyquil/pyquil/paulis.py:30: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3,and in 3.9 it will stop working\n    from collections import Sequence\n\npyquil/tests/test_paulis.py::test_sum_equality\n  /pyquil/pyquil/paulis.py:350: UnequalLengthWarning: These PauliSums have a different number of terms.\n    warnings.warn(\"These PauliSums have a different number of terms.\", UnequalLengthWarning)\n\n-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n=========================== short test summary info ============================\nFAILED pyquil/tests/test_paulis.py::test_sum_equality - Failed: DID NOT RAISE...\n1 failed, 36 passed, 2 warnings in 0.31s\n",
  "details": {
    "stdout": "....................................F                                    [100%]\n=================================== FAILURES ===================================\n______________________________ test_sum_equality _______________________________\npyquil/tests/test_paulis.py:542: in test_sum_equality\n    assert pauli_sum != pauli_sum + sZ(0)\nE   Failed: DID NOT RAISE <class 'pyquil.paulis.UnequalLengthWarning'>\n=============================== warnings summary ===============================\n../pyquil/pyquil/paulis.py:30\n  /pyquil/pyquil/paulis.py:30: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3,and in 3.9 it will stop working\n    from collections import Sequence\n\npyquil/tests/test_paulis.py::test_sum_equality\n  /pyquil/pyquil/paulis.py:350: UnequalLengthWarning: These PauliSums have a different number of terms.\n    warnings.warn(\"These PauliSums have a different number of terms.\", UnequalLengthWarning)\n\n-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n=========================== short test summary info ============================\nFAILED pyquil/tests/test_paulis.py::test_sum_equality - Failed: DID NOT RAISE...\n1 failed, 36 passed, 2 warnings in 0.31s\n",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "pyquil/tests/test_paulis.py",
  "content": "\ndef test_term_with_coeff():\n    assert PauliTerm('X', 0, 1.j) == term_with_coeff(sX(0), 1.j)\n    assert PauliTerm('X', 0, -1.0) == term_with_coeff(sX(0), -1)\n    with pytest.raises(ValueError):\n        term_with_coeff(sI(0), None)\n\n\ndef test_sum_equality():\n    pauli_sum = sY(0) - sX(0)\n    assert pauli_sum != 2 * pauli_sum\n    with pytest.raises(UnequalLengthWarning):\n        assert pauli_sum != pauli_sum + sZ(0)\n    with pytest.raises(UnequalLengthWarning):\n        assert pauli_sum + sZ(0) != pauli_sum\n    assert pauli_sum != sY(1) - sX(1)\n    assert pauli_sum == -1.0 * sX(0) + sY(0)\n    assert pauli_sum == pauli_sum * 1.0\n    with pytest.raises(TypeError):\n        assert pauli_sum != 0",
  "start_line": 530,
  "end_line": 549,
  "total_lines": 549,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "./pyquil/paulis.py:47:class UnequalLengthWarning(Warning):\n./pyquil/paulis.py:49:        super(UnequalLengthWarning, self).__init__(*args, **kwargs)\n./pyquil/paulis.py:350:            warnings.warn(\"These PauliSums have a different number of terms.\", UnequalLengthWarning)\n./pyquil/tests/test_paulis.py:19:from pyquil.paulis import (PauliTerm, PauliSum, exponential_map, ID, UnequalLengthWarning,\n./pyquil/tests/test_paulis.py:541:    with pytest.raises(UnequalLengthWarning):\n./pyquil/tests/test_paulis.py:543:    with pytest.raises(UnequalLengthWarning):\n",
  "stderr": "grep: ./pyquil/__pycache__/paulis.cpython-37.pyc: binary file matches\ngrep: ./pyquil/tests/__pycache__/test_paulis.cpython-37-pytest-7.4.4.pyc: binary file matches\n",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "        \"\"\"\n        The length of the PauliTerm is the number of Pauli operators in the term. A term that\n        consists of only a scalar has a length of zero.\n        \"\"\"\n        return len(self._ops)\n\n    def copy(self):\n        \"\"\"\n        Properly creates a new PauliTerm, with a completely new dictionary\n        of operators",
  "start_line": 107,
  "end_line": 116,
  "total_lines": 796,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "                new_term.__dict__[key] = val\n\n        return new_term\n\n    def get_qubits(self):\n        \"\"\"Gets all the qubits that this PauliTerm operates on.\n        \"\"\"\n        # sort the keys to get a deterministic iteration order over qubits\n        return sorted(self._ops.keys())\n\n    def __getitem__(self, i):\n        return self._ops.get(i, \"I\")\n\n    def __iter__(self):\n        for i in self.get_qubits():\n            yield i, self[i]",
  "start_line": 125,
  "end_line": 140,
  "total_lines": 796,
  "is_truncated": false,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "92:    def __eq__(self, other):\n101:        # x!=y and x<>y call __ne__() instead of negating __eq__\n103:        # __eq__\n104:        return not self.__eq__(other)\n338:    def __eq__(self, other):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 9 tool call(s) remaining (21/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "        else:\n            s = \"\"\n            for index in sorted(self._ops.keys()):\n                s += \"%s%s\" % (self[index], index)\n            self._id = s\n            return s\n\n    def __eq__(self, other):\n        if not isinstance(other, (PauliTerm, PauliSum)):\n            raise TypeError(\"Can't compare PauliTerm with object of type {}.\".format(type(other)))\n        elif isinstance(other, PauliSum):\n            return other == self\n        else:\n            return self.id() == other.id() and np.isclose(self.coefficient, other.coefficient)\n\n    def __ne__(self, other):",
  "start_line": 85,
  "end_line": 100,
  "total_lines": 796,
  "is_truncated": false,
  "budget_warning": "Only 8 tool call(s) remaining (22/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "            warnings.warn(\"These PauliSums have a different number of terms.\", UnequalLengthWarning)\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 7 tool call(s) remaining (23/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "import warnings\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 6 tool call(s) remaining (24/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "        else:\n            self.terms = terms\n\n    def __eq__(self, other):\n        \"\"\"Equality testing to see if two PauliSum's are equivalent.\n\n        :param PauliSum other: The PauliSum to compare this PauliSum with.\n        :return: True if other is equivalent to this PauliSum, False otherwise.\n        :rtype: bool\n        \"\"\"\n        if not isinstance(other, (PauliTerm, PauliSum)):\n            raise TypeError(\"Can't compare PauliSum with object of type {}.\".format(type(other)))\n        elif isinstance(other, PauliTerm):\n            return self == PauliSum(other)\n        elif len(self.terms) != len(other.terms):\n            warnings.warn(\"These PauliSums have a different number of terms.\", UnequalLengthWarning)\n            return False\n        return all([term == other.terms[i] for i, term in enumerate(self.terms)])\n\n    def __ne__(self, other):\n        \"\"\"Inequality testing to see if two PauliSum's are not equivalent.",
  "start_line": 335,
  "end_line": 355,
  "total_lines": 796,
  "is_truncated": false,
  "budget_warning": "Only 5 tool call(s) remaining (25/30 used). Finalize your edits and call submit_patch soon."
}