rigetticomputing__pyquil-115

{
  "status": "ok",
  "stdout": "pyquil/api.py:373:        :param list operators: A list of PauliTerms. Default is Identity operator.\npyquil/paulis.py:51:class PauliTerm(object):\npyquil/paulis.py:70:            raise ValueError(\"coefficient of PauliTerm must be a Number.\")\npyquil/paulis.py:76:        Returns the unique identifier string for the PauliTerm (ignoring the coefficient).\npyquil/paulis.py:92:        if not isinstance(other, (PauliTerm, PauliSum)):\npyquil/paulis.py:93:            raise TypeError(\"Can't compare PauliTerm with object of type {}.\".format(type(other)))\npyquil/paulis.py:107:        The length of the PauliTerm is the number of Pauli operators in the term. A term that\npyquil/paulis.py:114:        Properly creates a new PauliTerm, with a completely new dictionary\npyquil/paulis.py:117:        new_term = PauliTerm(\"I\", 0, 1.0)  # create new object\npyquil/paulis.py:129:        \"\"\"Gets all the qubits that this PauliTerm operates on.\npyquil/paulis.py:142:        new_term = PauliTerm(\"I\", 0)\npyquil/paulis.py:160:        \"\"\"Multiplies this Pauli Term with another PauliTerm, PauliSum, or number according to the\npyquil/paulis.py:163:        :param term: (PauliTerm or PauliSum or Number) A term to multiply by.\npyquil/paulis.py:164:        :returns: The product of this PauliTerm and term.\npyquil/paulis.py:165:        :rtype: PauliTerm\npyquil/paulis.py:172:            new_term = PauliTerm(\"I\", 0, 1.0)\npyquil/paulis.py:181:        \"\"\"Multiplies this PauliTerm with another object, probably a number.\npyquil/paulis.py:183:        :param other: A number or PauliTerm to multiply by\npyquil/paulis.py:184:        :returns: A new PauliTerm\npyquil/paulis.py:185:        :rtype: PauliTerm\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "pyquil/paulis.py:77:         Used in the simplify method of PauliSum.\npyquil/paulis.py:92:        if not isinstance(other, (PauliTerm, PauliSum)):\npyquil/paulis.py:94:        elif isinstance(other, PauliSum):\npyquil/paulis.py:160:        \"\"\"Multiplies this Pauli Term with another PauliTerm, PauliSum, or number according to the\npyquil/paulis.py:163:        :param term: (PauliTerm or PauliSum or Number) A term to multiply by.\npyquil/paulis.py:169:        elif isinstance(term, PauliSum):\npyquil/paulis.py:170:            return (PauliSum([self]) * term).simplify()\npyquil/paulis.py:215:        :returns: A PauliSum object representing the sum of this PauliTerm and other\npyquil/paulis.py:216:        :rtype: PauliSum\npyquil/paulis.py:220:        elif isinstance(other, PauliSum):\npyquil/paulis.py:223:            new_sum = PauliSum([self, other])\npyquil/paulis.py:240:        :returns: A PauliSum object representing the difference of this PauliTerm and term\npyquil/paulis.py:241:        :rtype: PauliSum\npyquil/paulis.py:249:        :returns: A PauliSum object representing the difference of this PauliTerm and term\npyquil/paulis.py:250:        :rtype: PauliSum\npyquil/paulis.py:321:class PauliSum(object):\npyquil/paulis.py:331:            raise ValueError(\"PauliSum's are currently constructed from Sequences of PauliTerms.\")\npyquil/paulis.py:338:        \"\"\"Equality testing to see if two PauliSum's are equivalent.\npyquil/paulis.py:340:        :param PauliSum other: The PauliSum to compare this PauliSum with.\npyquil/paulis.py:341:        :return: True if other is equivalent to this PauliSum, False otherwise.\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "\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        \n        identities = [PauliTerm('I', qubit) for qubit in self.get_qubits()]\n        if not identities:\n            # There weren't any nontrivial operators\n            return term_with_coeff(self, 1)\n        for identity in identities:\n            result *= identity\n        for _ in range(power):\n            result *= self\n        return result\n\n    def __add__(self, other):\n        \"\"\"Adds this PauliTerm with another one.\n\n        :param other: A PauliTerm object or a Number\n        :returns: A PauliSum object representing the sum of this PauliTerm and other\n        :rtype: PauliSum\n        \"\"\"\n        if isinstance(other, Number):\n            return self + PauliTerm(\"I\", 0, other)\n        elif isinstance(other, PauliSum):\n            return other + self\n        else:\n            new_sum = PauliSum([self, other])\n            return new_sum.simplify()\n\n    def __radd__(self, other):\n        \"\"\"Adds this PauliTerm with a Number.\n\n        :param other: A PauliTerm object or a Number\n        :returns: A new PauliTerm\n        :rtype: PauliTerm\n        \"\"\"\n        assert isinstance(other, Number)\n        return self + other\n\n    def __sub__(self, other):\n        \"\"\"Subtracts a PauliTerm from this one.\n\n        :param other: A PauliTerm object or a Number",
  "start_line": 90,
  "end_line": 239,
  "total_lines": 795,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pyquil/paulis.py",
  "content": "class PauliSum(object):\n    \"\"\"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()",
  "start_line": 321,
  "end_line": 400,
  "total_lines": 795,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "46:class UnequalLengthWarning(Warning):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Comparing s1 (len 1) and s2 (len 2)\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",
  "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": "ok",
  "filepath": "pyquil/paulis.py",
  "occurrences": 1,
  "strategy": "exact",
  "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",
  "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 s1 (len 1) and s2 (len 2)\nResult: False\nCaught exception: AttributeError: 'list' object has no attribute 'warnings'\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Comparing s1 (len 1) and s2 (len 2)\nResult: False\nWarnings caught: 1\nWarning: UnequalLengthWarning: These PauliSums have a different number of terms.\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Comparing s1 (len 1) and s2 (len 1)\nResult: True\nWarnings caught: 0\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Comparing s1 (len 1) and s2 (len 1)\nResult: False\nWarnings caught: 0\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.33s\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.33s\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": " M pyquil/paulis.py\ndiff --git a/pyquil/paulis.py b/pyquil/paulis.py\nindex 0f79f9c..444a4af 100644\n--- a/pyquil/paulis.py\n+++ b/pyquil/paulis.py\n@@ -22,6 +22,7 @@ from __future__ import division\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@@ -346,7 +347,7 @@ class PauliSum(object):\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",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "patch_size": 849,
  "files_changed": 1
}