rigetticomputing__pyquil-115

{
  "status": "ok",
  "stdout": "/workspace/pyquil/api.py:373:        :param list operators: A list of PauliTerms. Default is Identity operator.\n/workspace/pyquil/paulis.py:51:class PauliTerm(object):\n/workspace/pyquil/paulis.py:70:            raise ValueError(\"coefficient of PauliTerm must be a Number.\")\n/workspace/pyquil/paulis.py:76:        Returns the unique identifier string for the PauliTerm (ignoring the coefficient).\n/workspace/pyquil/paulis.py:77:         Used in the simplify method of PauliSum.\n/workspace/pyquil/paulis.py:92:        if not isinstance(other, (PauliTerm, PauliSum)):\n/workspace/pyquil/paulis.py:93:            raise TypeError(\"Can't compare PauliTerm with object of type {}.\".format(type(other)))\n/workspace/pyquil/paulis.py:94:        elif isinstance(other, PauliSum):\n/workspace/pyquil/paulis.py:107:        The length of the PauliTerm is the number of Pauli operators in the term. A term that\n/workspace/pyquil/paulis.py:114:        Properly creates a new PauliTerm, with a completely new dictionary\n/workspace/pyquil/paulis.py:117:        new_term = PauliTerm(\"I\", 0, 1.0)  # create new object\n/workspace/pyquil/paulis.py:129:        \"\"\"Gets all the qubits that this PauliTerm operates on.\n/workspace/pyquil/paulis.py:142:        new_term = PauliTerm(\"I\", 0)\n/workspace/pyquil/paulis.py:160:        \"\"\"Multiplies this Pauli Term with another PauliTerm, PauliSum, or number according to the\n/workspace/pyquil/paulis.py:163:        :param term: (PauliTerm or PauliSum or Number) A term to multiply by.\n/workspace/pyquil/paulis.py:164:        :returns: The product of this PauliTerm and term.\n/workspace/pyquil/paulis.py:165:        :rtype: PauliTerm\n/workspace/pyquil/paulis.py:169:        elif isinstance(term, PauliSum):\n/workspace/pyquil/paulis.py:170:            return (PauliSum([self]) * term).simplify()\n/workspace/pyquil/paulis.py:172:            new_term = PauliTerm(\"I\", 0, 1.0)\n/workspace/pyquil/paulis.py:181:        \"\"\"Multiplies this PauliTerm with another object, probably a number.\n/workspace/pyquil/paulis.py:183:        :param other: A number or PauliTerm to multiply by\n/workspace/pyquil/paulis.py:184:        :returns: A new PauliTerm\n/workspace/pyquil/paulis.py:185:        :rtype: PauliTerm\n/workspace/pyquil/paulis.py:191:        \"\"\"Raises this PauliTerm to power.\n/workspace/pyquil/paulis.py:193:        :param int power: The power to raise this PauliTerm to.\n/workspace/pyquil/paulis.py:195:        :rtype: PauliTerm\n/workspace/pyquil/paulis.py:201:        identities = [PauliTerm('I', qubit) for qubit in self.get_qubits()]\n/workspace/pyquil/paulis.py:212:        \"\"\"Adds this PauliTerm with another one.\n/workspace/pyquil/paulis.py:214:        :param other: A PauliTerm object or a Number\n/workspace/pyquil/paulis.py:215:        :returns: A PauliSum object representing the sum of this PauliTerm and other\n/workspace/pyquil/paulis.py:216:        :rtype: PauliSum\n/workspace/pyquil/paulis.py:219:            return self + PauliTerm(\"I\", 0, other)\n/workspace/pyquil/paulis.py:220:        elif isinstance(other, PauliSum):\n/workspace/pyquil/paulis.py:223:            new_sum = PauliSum([self, other])\n/workspace/pyquil/paulis.py:227:        \"\"\"Adds this PauliTerm with a Number.\n/workspace/pyquil/paulis.py:229:        :param other: A PauliTerm object or a Number\n/workspace/pyquil/paulis.py:230:        :returns: A new PauliTerm\n/workspace/pyquil/paulis.py:231:        :rtype: PauliTerm\n/workspace/pyquil/paulis.py:237:        \"\"\"Subtracts a PauliTerm from this one.\n/workspace/pyquil/paulis.py:239:        :param other: A PauliTerm object or a Number\n/workspace/pyquil/paulis.py:240:        :returns: A PauliSum object representing the difference of this PauliTerm and term\n/workspace/pyquil/paulis.py:241:        :rtype: PauliSum\n/workspace/pyquil/paulis.py:246:        \"\"\"Subtracts this PauliTerm from a Number or PauliTerm.\n/workspace/pyquil/paulis.py:248:        :param other: A PauliTerm object or a Number\n/workspace/pyquil/paulis.py:249:        :returns: A PauliSum object representing the difference of this PauliTerm and term\n/workspace/pyquil/paulis.py:250:        :rtype: PauliSum\n/workspace/pyquil/paulis.py:266:ID = PauliTerm(\"I\", 0)\n/workspace/pyquil/paulis.py:270:sI = lambda q: PauliTerm(\"I\", q)\n/workspace/pyquil/paulis.py:275::returns: A PauliTerm object\n/workspace/pyquil/paulis.py:276::rtype: PauliTerm\n/workspace/pyquil/paulis.py:278:sX = lambda q: PauliTerm(\"X\", q)\n/workspace/pyquil/paulis.py:283::returns: A PauliTerm object\n/workspace/pyquil/paulis.py:284::rtype: PauliTerm\n/workspace/pyquil/paulis.py:286:sY = lambda q: PauliTerm(\"Y\", q)\n/workspace/pyquil/paulis.py:291::returns: A PauliTerm object\n/workspace/pyquil/paulis.py:292::rtype: PauliTerm\n/workspace/pyquil/paulis.py:294:sZ = lambda q: PauliTerm(\"Z\", q)\n/workspace/pyquil/paulis.py:299::returns: A PauliTerm object\n/workspace/pyquil/paulis.py:300::rtype: PauliTerm\n/workspace/pyquil/paulis.py:306:    Change the coefficient of a PauliTerm.\n/workspace/pyquil/paulis.py:308:    :param Pauli",
  "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\nclass 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:",
  "start_line": 1,
  "end_line": 150,
  "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": "ok",
  "filepath": "pyquil/paulis.py",
  "content": ":rtype: PauliTerm\n\"\"\"\n\n\ndef term_with_coeff(term, coeff):\n    \"\"\"\n    Change the coefficient of a PauliTerm.\n\n    :param PauliTerm term: A PauliTerm object\n    :param Number coeff: The coefficient to set on the PauliTerm\n    :returns: A new PauliTerm that duplicates term but sets coeff\n    :rtype: PauliTerm\n    \"\"\"\n    if not isinstance(coeff, Number):\n        raise ValueError(\"coeff must be a Number\")\n    new_pauli = term.copy()\n    # We cast to a complex number to ensure that internally the coefficients remain compatible.\n    new_pauli.coefficient = complex(coeff)\n    return new_pauli\n\n\nclass 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": 300,
  "end_line": 400,
  "total_lines": 795,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Comparing sum1 and 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",
  "start_line": 1,
  "end_line": 30,
  "total_lines": 795,
  "is_truncated": false
}

{
  "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 sum1 and sum2...\nResult of comparison: False\nWarning caught: 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": "/workspace/pyquil/paulis.py:47:class UnequalLengthWarning(Warning):\n/workspace/pyquil/paulis.py:49:        super(UnequalLengthWarning, self).__init__(*args, **kwargs)\n/workspace/pyquil/paulis.py:350:            warnings.warn(\"These PauliSums have a different number of terms.\", UnequalLengthWarning)\n/workspace/pyquil/tests/test_paulis.py:19:from pyquil.paulis import (PauliTerm, PauliSum, exponential_map, ID, UnequalLengthWarning,\n/workspace/pyquil/tests/test_paulis.py:541:    with pytest.raises(UnequalLengthWarning):\n/workspace/pyquil/tests/test_paulis.py:543:    with pytest.raises(UnequalLengthWarning):\n",
  "stderr": "grep: /workspace/pyquil/__pycache__/paulis.cpython-37.pyc: binary file matches\ngrep: /workspace/pyquil/tests/__pycache__/test_paulis.cpython-37-pytest-7.4.4.pyc: binary file matches\n",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "/workspace/pyquil/tests/test_paulis.py:541:    with pytest.raises(UnequalLengthWarning):\n/workspace/pyquil/tests/test_paulis.py:543:    with pytest.raises(UnequalLengthWarning):\n",
  "stderr": "",
  "exit_code": 0
}

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

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