Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 58 insertions, 58 deletions

diff --git a/contrib/tools/python3/src/Lib/fractions.py b/contrib/tools/python3/src/Lib/fractions.py
index b5df2760d50..de3e23b7592 100644
--- a/contrib/tools/python3/src/Lib/fractions.py
+++ b/contrib/tools/python3/src/Lib/fractions.py
@@ -10,7 +10,7 @@ import operator
 import re
 import sys
 
-__all__ = ['Fraction'] 
+__all__ = ['Fraction']
 
 
 # Constants related to the hash implementation;  hash(x) is based
@@ -155,9 +155,9 @@ class Fraction(numbers.Rational):
         if denominator == 0:
             raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
         if _normalize:
-            g = math.gcd(numerator, denominator) 
-            if denominator < 0: 
-                g = -g 
+            g = math.gcd(numerator, denominator)
+            if denominator < 0:
+                g = -g
             numerator //= g
             denominator //= g
         self._numerator = numerator
@@ -190,14 +190,14 @@ class Fraction(numbers.Rational):
                 (cls.__name__, dec, type(dec).__name__))
         return cls(*dec.as_integer_ratio())
 
-    def as_integer_ratio(self): 
-        """Return the integer ratio as a tuple. 
- 
-        Return a tuple of two integers, whose ratio is equal to the 
-        Fraction and with a positive denominator. 
-        """ 
-        return (self._numerator, self._denominator) 
- 
+    def as_integer_ratio(self):
+        """Return the integer ratio as a tuple.
+
+        Return a tuple of two integers, whose ratio is equal to the
+        Fraction and with a positive denominator.
+        """
+        return (self._numerator, self._denominator)
+
     def limit_denominator(self, max_denominator=1000000):
         """Closest Fraction to self with denominator at most max_denominator.
 
@@ -409,27 +409,27 @@ class Fraction(numbers.Rational):
 
     __truediv__, __rtruediv__ = _operator_fallbacks(_div, operator.truediv)
 
-    def _floordiv(a, b): 
+    def _floordiv(a, b):
         """a // b"""
-        return (a.numerator * b.denominator) // (a.denominator * b.numerator) 
+        return (a.numerator * b.denominator) // (a.denominator * b.numerator)
 
-    __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv) 
+    __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv)
 
-    def _divmod(a, b): 
-        """(a // b, a % b)""" 
-        da, db = a.denominator, b.denominator 
-        div, n_mod = divmod(a.numerator * db, da * b.numerator) 
-        return div, Fraction(n_mod, da * db) 
+    def _divmod(a, b):
+        """(a // b, a % b)"""
+        da, db = a.denominator, b.denominator
+        div, n_mod = divmod(a.numerator * db, da * b.numerator)
+        return div, Fraction(n_mod, da * db)
 
-    __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod) 
- 
-    def _mod(a, b): 
+    __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod)
+
+    def _mod(a, b):
         """a % b"""
-        da, db = a.denominator, b.denominator 
-        return Fraction((a.numerator * db) % (b.numerator * da), da * db) 
+        da, db = a.denominator, b.denominator
+        return Fraction((a.numerator * db) % (b.numerator * da), da * db)
+
+    __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod)
 
-    __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod) 
- 
     def __pow__(a, b):
         """a ** b
 
@@ -494,16 +494,16 @@ class Fraction(numbers.Rational):
             return a._numerator // a._denominator
 
     def __floor__(a):
-        """math.floor(a)""" 
+        """math.floor(a)"""
         return a.numerator // a.denominator
 
     def __ceil__(a):
-        """math.ceil(a)""" 
+        """math.ceil(a)"""
         # The negations cleverly convince floordiv to return the ceiling.
         return -(-a.numerator // a.denominator)
 
     def __round__(self, ndigits=None):
-        """round(self, ndigits) 
+        """round(self, ndigits)
 
         Rounds half toward even.
         """
@@ -530,34 +530,34 @@ class Fraction(numbers.Rational):
     def __hash__(self):
         """hash(self)"""
 
-        # To make sure that the hash of a Fraction agrees with the hash 
-        # of a numerically equal integer, float or Decimal instance, we 
-        # follow the rules for numeric hashes outlined in the 
-        # documentation.  (See library docs, 'Built-in Types'). 
+        # To make sure that the hash of a Fraction agrees with the hash
+        # of a numerically equal integer, float or Decimal instance, we
+        # follow the rules for numeric hashes outlined in the
+        # documentation.  (See library docs, 'Built-in Types').
 
-        try: 
-            dinv = pow(self._denominator, -1, _PyHASH_MODULUS) 
-        except ValueError: 
-            # ValueError means there is no modular inverse. 
+        try:
+            dinv = pow(self._denominator, -1, _PyHASH_MODULUS)
+        except ValueError:
+            # ValueError means there is no modular inverse.
             hash_ = _PyHASH_INF
         else:
-            # The general algorithm now specifies that the absolute value of 
-            # the hash is 
-            #    (|N| * dinv) % P 
-            # where N is self._numerator and P is _PyHASH_MODULUS.  That's 
-            # optimized here in two ways:  first, for a non-negative int i, 
-            # hash(i) == i % P, but the int hash implementation doesn't need 
-            # to divide, and is faster than doing % P explicitly.  So we do 
-            #    hash(|N| * dinv) 
-            # instead.  Second, N is unbounded, so its product with dinv may 
-            # be arbitrarily expensive to compute.  The final answer is the 
-            # same if we use the bounded |N| % P instead, which can again 
-            # be done with an int hash() call.  If 0 <= i < P, hash(i) == i, 
-            # so this nested hash() call wastes a bit of time making a 
-            # redundant copy when |N| < P, but can save an arbitrarily large 
-            # amount of computation for large |N|. 
-            hash_ = hash(hash(abs(self._numerator)) * dinv) 
-        result = hash_ if self._numerator >= 0 else -hash_ 
+            # The general algorithm now specifies that the absolute value of
+            # the hash is
+            #    (|N| * dinv) % P
+            # where N is self._numerator and P is _PyHASH_MODULUS.  That's
+            # optimized here in two ways:  first, for a non-negative int i,
+            # hash(i) == i % P, but the int hash implementation doesn't need
+            # to divide, and is faster than doing % P explicitly.  So we do
+            #    hash(|N| * dinv)
+            # instead.  Second, N is unbounded, so its product with dinv may
+            # be arbitrarily expensive to compute.  The final answer is the
+            # same if we use the bounded |N| % P instead, which can again
+            # be done with an int hash() call.  If 0 <= i < P, hash(i) == i,
+            # so this nested hash() call wastes a bit of time making a
+            # redundant copy when |N| < P, but can save an arbitrarily large
+            # amount of computation for large |N|.
+            hash_ = hash(hash(abs(self._numerator)) * dinv)
+        result = hash_ if self._numerator >= 0 else -hash_
         return -2 if result == -1 else result
 
     def __eq__(a, b):
@@ -621,9 +621,9 @@ class Fraction(numbers.Rational):
 
     def __bool__(a):
         """a != 0"""
-        # bpo-39274: Use bool() because (a._numerator != 0) can return an 
-        # object which is not a bool. 
-        return bool(a._numerator) 
+        # bpo-39274: Use bool() because (a._numerator != 0) can return an
+        # object which is not a bool.
+        return bool(a._numerator)
 
     # support for pickling, copy, and deepcopy