Update to python3.10

pycodestyle

padic.py

@@ -1,6 +1,7 @@
 from fractions import Fraction
-from sys import maxint
-from modp import *
+from sys import maxsize
+from modp import ModP
+
 
 class PAdic:
     def __init__(self, p):
@@ -17,7 +18,9 @@ class PAdic:
             self.val = str(int(self._nextdigit())) + self.val
             self.prec += 1
         if self.order < 0:
-            return (self.val[:self.order] + ('.' if decimal else '') + self.val[self.order:])[-prec-1:]
+            return (
+                self.val[:self.order] + ('.' if decimal else '') +
+                self.val[self.order:])[-prec-1:]
         return (self.val + self.order * '0')[-prec:]
 
     def _nextdigit(self):
@@ -26,33 +29,43 @@ class PAdic:
 
     def getdigit(self, index):
         'Return digit at given index.'
-        return int(self.get(index + 1, False)[0]) #int(self.get(index+1+int(index < -self.order))[-int(index < -self.order)])
+        return int(self.get(index + 1, False)[0])
+        # int(
+        #    self.get(index+1+int(index < -self.order)
+        # )[-int(index < -self.order)])
 
     # return value with precision up to 32 bits
     def __int__(self):
         return int(self.get(32), self.p)
+
     def __str__(self):
         return self.get(32)
 
     # arithmetic operations
     def __neg__(self):
         return PAdicNeg(self.p, self)
+
     def __add__(self, other):
         return PAdicAdd(self.p, self, other)
+
     def __radd__(self, other):
         return PAdicAdd(self.p, other, self)
+
     def __sub__(self, other):
         return PAdicAdd(self.p, self, PAdicNeg(self.p, other))
+
     def __rsub__(self, other):
         return PAdicAdd(self.p, other, PAdicNeg(self.p, self))
+
     def __mul__(self, other):
         return PAdicMul(self.p, self, other)
+
     def __rmul__(self, other):
         return PAdicMul(self.p, other, self)
 
     # p-adic norm
     def __abs__(self):
-        if self.order == maxint:
+        if self.order == maxsize:
             return 0
         numer = denom = 1
         if self.order > 0:
@@ -61,6 +74,7 @@ class PAdic:
             denom = self.p ** self.order
         return Fraction(numer, denom)
 
+
 class PAdicConst(PAdic):
     def __init__(self, p, value):
         PAdic.__init__(self, p)
@@ -70,7 +84,7 @@ class PAdicConst(PAdic):
         if value == 0:
             self.value = value
             self.val = '0'
-            self.order = maxint
+            self.order = maxsize
             return
 
         self.order = 0
@@ -91,11 +105,13 @@ class PAdicConst(PAdic):
 
     def _nextdigit(self):
         'Calculate next digit of p-adic number.'
-        rem = ModP(self.p, self.value.numerator) / ModP(self.p, self.value.denominator)
+        rem = ModP(self.p, self.value.numerator) /\
+            ModP(self.p, self.value.denominator)
         self.value -= int(rem)
         self.value /= self.p
         return rem
 
+
 class PAdicAdd(PAdic):
     'Sum of two p-adic numbers.'
     def __init__(self, p, arg1, arg2):
@@ -103,7 +119,8 @@ class PAdicAdd(PAdic):
         self.carry = 0
         self.arg1 = arg1
         self.arg2 = arg2
-        self.order = self.prec = min(arg1.order, arg2.order) # might be larger than this
+        # might be larger than this
+        self.order = self.prec = min(arg1.order, arg2.order)
         arg1.order -= self.order
         arg2.order -= self.order
         # loop until first nonzero digit is found
@@ -117,11 +134,13 @@ class PAdicAdd(PAdic):
         self.prec = 1
 
     def _nextdigit(self):
-        s = self.arg1.getdigit(self.index) + self.arg2.getdigit(self.index) + self.carry
+        s = self.arg1.getdigit(self.index) + \
+            self.arg2.getdigit(self.index) + self.carry
         self.carry = s // self.p
         self.index += 1
         return s % self.p
 
+
 class PAdicNeg(PAdic):
     'Negation of a p-adic number.'
     def __init__(self, p, arg):
@@ -131,9 +150,11 @@ class PAdicNeg(PAdic):
 
     def _nextdigit(self):
         if self.prec == 0:
-            return self.p - self.arg.getdigit(0) # cannot be p, 0th digit of arg must be nonzero
+            # cannot be p, 0th digit of arg must be nonzero
+            return self.p - self.arg.getdigit(0)
         return self.p - 1 - self.arg.getdigit(self.prec)
 
+
 class PAdicMul(PAdic):
     'Product of two p-adic numbers.'
     def __init__(self, p, arg1, arg2):
@@ -146,7 +167,10 @@ class PAdicMul(PAdic):
         self.index = 0
 
     def _nextdigit(self):
-        s = sum(self.arg1.getdigit(i) * self.arg2.getdigit(self.index - i) for i in xrange(self.index + 1)) + self.carry
+        s = sum(
+            self.arg1.getdigit(i) * self.arg2.getdigit(self.index - i)
+            for i in xrange(self.index + 1)
+            ) + self.carry
         self.carry = s // self.p
         self.index += 1
         return s % self.p