From 7c6d394c93ed4bf5f0339a228d19a3014a225d70 Mon Sep 17 00:00:00 2001 From: rht Date: Mon, 9 Oct 2017 10:45:26 +0200 Subject: [PATCH] Introduce PEP484 type hints to paulis.py --- pyquil/paulis.py | 56 ++++++++++++++++++++++++++++++++++++++++-------- requirements.txt | 1 + setup.py | 1 + 3 files changed, 49 insertions(+), 9 deletions(-) diff --git a/pyquil/paulis.py b/pyquil/paulis.py index c2fadc922..4284e010c 100644 --- a/pyquil/paulis.py +++ b/pyquil/paulis.py @@ -30,6 +30,8 @@ from six import integer_types from six.moves import range +from typing import Dict, Iterator, List, Tuple, Union # noqa: F401 + PAULI_OPS = ["X", "Y", "Z", "I"] PAULI_PROD = {'ZZ': 'I', 'YY': 'I', 'XX': 'I', 'II': 'I', 'XY': 'Z', 'XZ': 'Y', 'YX': 'Z', 'YZ': 'X', 'ZX': 'Y', @@ -53,6 +55,7 @@ class PauliTerm(object): """ def __init__(self, op, index, coefficient=1.0): + # type: (str, int, float) -> None """ Create a new Pauli Term with a Pauli operator at a particular index and a leading coefficient. @@ -63,15 +66,16 @@ def __init__(self, op, index, coefficient=1.0): assert op in PAULI_OPS assert isinstance(index, integer_types) and index >= 0 - self._ops = {} + self._ops = {} # type: Dict[int,str] if op != "I": self._ops[index] = op if not isinstance(coefficient, Number): raise ValueError("coefficient of PauliTerm must be a Number.") - self.coefficient = complex(coefficient) - self._id = None + self.coefficient = complex(coefficient) # type: complex + self._id = "" # type: str def id(self): + # type: () -> str """ Returns the unique identifier string for the PauliTerm (ignoring the coefficient). Used in the simplify method of PauliSum. @@ -79,7 +83,7 @@ def id(self): :return: The unique identifier for this term. :rtype: string """ - if self._id is not None: + if self._id is not "": return self._id else: s = "" @@ -89,6 +93,7 @@ def id(self): return s def __eq__(self, other): + # type: (PauliTerm) -> bool if not isinstance(other, (PauliTerm, PauliSum)): raise TypeError("Can't compare PauliTerm with object of type {}.".format(type(other))) elif isinstance(other, PauliSum): @@ -97,12 +102,14 @@ def __eq__(self, other): return self.id() == other.id() and np.isclose(self.coefficient, other.coefficient) def __ne__(self, other): + # type: (PauliTerm) -> bool # x!=y and x<>y call __ne__() instead of negating __eq__ # This is only a weirdness in python2 as in python 3 __ne__ defaults to the inversion of # __eq__ return not self.__eq__(other) def __len__(self): + # type: () -> int """ The length of the PauliTerm is the number of Pauli operators in the term. A term that consists of only a scalar has a length of zero. @@ -110,6 +117,7 @@ def __len__(self): return len(self._ops) def copy(self): + # type: () -> PauliTerm """ Properly creates a new PauliTerm, with a completely new dictionary of operators @@ -126,19 +134,23 @@ def copy(self): return new_term def get_qubits(self): + # type () -> List[int] """Gets all the qubits that this PauliTerm operates on. """ # sort the keys to get a deterministic iteration order over qubits return sorted(self._ops.keys()) def __getitem__(self, i): + # type: (int) -> str return self._ops.get(i, "I") def __iter__(self): + # type: () -> Iterator[Tuple[int, str]] for i in self.get_qubits(): yield i, self[i] def _multiply_factor(self, factor, index): + # type: (str, int) -> PauliTerm new_term = PauliTerm("I", 0) new_coeff = self.coefficient new_ops = self._ops.copy() @@ -157,6 +169,7 @@ def _multiply_factor(self, factor, index): return new_term def __mul__(self, term): + # type: (Union[PauliTerm, PauliSum, Number]) -> PauliTerm """Multiplies this Pauli Term with another PauliTerm, PauliSum, or number according to the Pauli algebra rules. @@ -178,6 +191,7 @@ def __mul__(self, term): return term_with_coeff(new_term, new_term.coefficient * new_coeff) def __rmul__(self, other): + # type: (Number) -> PauliTerm """Multiplies this PauliTerm with another object, probably a number. :param other: A number or PauliTerm to multiply by @@ -188,6 +202,7 @@ def __rmul__(self, other): return self * other def __pow__(self, power): + # type: (int) -> PauliTerm """Raises this PauliTerm to power. :param int power: The power to raise this PauliTerm to. @@ -209,6 +224,7 @@ def __pow__(self, power): return result def __add__(self, other): + # type: (Union[PauliTerm, Number]) -> PauliSum """Adds this PauliTerm with another one. :param other: A PauliTerm object or a Number @@ -216,7 +232,7 @@ def __add__(self, other): :rtype: PauliSum """ if isinstance(other, Number): - return self + PauliTerm("I", 0, other) + return self + PauliTerm("I", 0, float(other)) elif isinstance(other, PauliSum): return other + self else: @@ -224,6 +240,7 @@ def __add__(self, other): return new_sum.simplify() def __radd__(self, other): + # type: (Number) -> PauliSum """Adds this PauliTerm with a Number. :param other: A PauliTerm object or a Number @@ -234,6 +251,7 @@ def __radd__(self, other): return self + other def __sub__(self, other): + # type: (Union[PauliTerm, Number]) -> PauliSum """Subtracts a PauliTerm from this one. :param other: A PauliTerm object or a Number @@ -243,6 +261,7 @@ def __sub__(self, other): return self + -1. * other def __rsub__(self, other): + # type: (Union[PauliTerm, Number]) -> PauliSum """Subtracts this PauliTerm from a Number or PauliTerm. :param other: A PauliTerm object or a Number @@ -252,6 +271,7 @@ def __rsub__(self, other): return other + -1. * self def __str__(self): + # type: () -> str term_strs = [] for index in sorted(self._ops.keys()): term_strs.append("%s%s" % (self[index], index)) @@ -347,6 +367,7 @@ def sZ(q): def term_with_coeff(term, coeff): + # type: (PauliTerm, Number) -> PauliTerm """ Change the coefficient of a PauliTerm. @@ -368,6 +389,7 @@ class PauliSum(object): """ def __init__(self, terms): + # type: (List[PauliTerm]) -> None """ :param Sequence terms: A Sequence of PauliTerms. """ @@ -380,9 +402,10 @@ def __init__(self, terms): self.terms = terms def __eq__(self, other): + # type: (Union[PauliTerm, PauliSum]) -> bool """Equality testing to see if two PauliSum's are equivalent. - :param PauliSum other: The PauliSum to compare this PauliSum with. + :param PauliTerm or PauliSum other: The PauliSum to compare this PauliSum with. :return: True if other is equivalent to this PauliSum, False otherwise. :rtype: bool """ @@ -396,24 +419,28 @@ def __eq__(self, other): return all([term == other.terms[i] for i, term in enumerate(self.terms)]) def __ne__(self, other): + # type: (Union[PauliTerm, PauliSum]) -> bool """Inequality testing to see if two PauliSum's are not equivalent. - :param PauliSum other: The PauliSum to compare this PauliSum with. + :param PauliTerm or PauliSum other: The PauliSum to compare this PauliSum with. :return: False if other is equivalent to this PauliSum, True otherwise. :rtype: bool """ return not self == other def __str__(self): + # type: () -> str return " + ".join([str(term) for term in self.terms]) def __len__(self): + # type () -> int """ The length of the PauliSum is the number of PauliTerms in the sum. """ return len(self.terms) def __getitem__(self, item): + # type (int) -> PauliTerm """ :param int item: The index of the term in the sum to return :return: The PauliTerm at the index-th position in the PauliSum @@ -422,9 +449,11 @@ def __getitem__(self, item): return self.terms[item] def __iter__(self): + # type () -> Iterator[PauliTerm] return self.terms.__iter__() def __mul__(self, other): + # type: (Union[PauliSum, PauliTerm, Number]) -> PauliSum """ Multiplies together this PauliSum with PauliSum, PauliTerm or Number objects. The new term is then simplified according to the Pauli Algebra rules. @@ -445,6 +474,7 @@ def __mul__(self, other): return new_sum.simplify() def __rmul__(self, other): + # type: (Union[PauliSum, PauliTerm, Number]) -> PauliSum """ Multiples together this PauliSum with PauliSum, PauliTerm or Number objects. The new term is then simplified according to the Pauli Algebra rules. @@ -460,6 +490,7 @@ def __rmul__(self, other): return PauliSum(new_terms).simplify() def __pow__(self, power): + # type: (int) -> PauliSum """Raises this PauliSum to power. :param int power: The power to raise this PauliSum to. @@ -485,6 +516,7 @@ def __pow__(self, power): return result def __add__(self, other): + # type: (Union[PauliSum, PauliTerm, Number]) -> PauliSum """ Adds together this PauliSum with PauliSum, PauliTerm or Number objects. The new term is then simplified according to the Pauli Algebra rules. @@ -503,6 +535,7 @@ def __add__(self, other): return new_sum.simplify() def __radd__(self, other): + # type: (Union[PauliSum, PauliTerm, Number]) -> PauliSum """ Adds together this PauliSum with PauliSum, PauliTerm or Number objects. The new term is then simplified according to the Pauli Algebra rules. @@ -515,6 +548,7 @@ def __radd__(self, other): return self + other def __sub__(self, other): + # type: (Union[PauliSum, PauliTerm, Number]) -> PauliSum """ Finds the difference of this PauliSum with PauliSum, PauliTerm or Number objects. The new term is then simplified according to the Pauli Algebra rules. @@ -526,6 +560,7 @@ def __sub__(self, other): return self + -1. * other def __rsub__(self, other): + # type: (Union[PauliSum, PauliTerm, Number]) -> PauliSum """ Finds the different of this PauliSum with PauliSum, PauliTerm or Number objects. The new term is then simplified according to the Pauli Algebra rules. @@ -537,6 +572,8 @@ def __rsub__(self, other): return other + -1. * self def get_qubits(self): + # type () -> List[Any] + # TODO: precisify """ The support of all the operators in the PauliSum object. @@ -546,6 +583,7 @@ def get_qubits(self): return list(set().union(*[term.get_qubits() for term in self.terms])) def simplify(self): + # type: () -> PauliSum """ Simplifies the sum of Pauli operators according to Pauli algebra rules. """ @@ -554,7 +592,7 @@ def coalesce(d): for k in sorted(d): term_list = d[k] if (len(term_list) == 1 and not - np.isclose(term_list[0].coefficient, 0.0)): + np.isclose(term_list[0].coefficient, 0.0)): terms.append(term_list[0]) else: coeff = sum(t.coefficient for t in term_list) @@ -562,7 +600,7 @@ def coalesce(d): terms.append(term_with_coeff(term_list[0], coeff)) return PauliSum(terms) - like_terms = {} + like_terms = {} # type: Dict[str, List[PauliTerm]] for term in self.terms: id = term.id() if id not in like_terms: diff --git a/requirements.txt b/requirements.txt index 25fdce510..5a475e183 100644 --- a/requirements.txt +++ b/requirements.txt @@ -27,3 +27,4 @@ tox==2.9.1 typing==3.6.2 urllib3==1.22 virtualenv==15.1.0 +typing==3.6.2 diff --git a/setup.py b/setup.py index 1bd576733..83989d233 100755 --- a/setup.py +++ b/setup.py @@ -42,6 +42,7 @@ tests_require=[ 'pytest >= 3.0.0', 'mock', + 'typing == 3.6.2', ], test_suite='pyquil.tests', entry_points={