snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/number.py

@@ -6,11 +6,12 @@ from .sage_helper import _within_sage
 from .pari import *
 import re
 
-strip_zeros = re.compile(r'(.*\..*?[0-9]{1})0*$')
+strip_zeros = re.compile(r'(-?\d+\.\d*?\d)0*((\s?[eE]-?\d+)?)$')
 left_zeros = re.compile(r'0\.0*')
+precision_of_exact_GEN = pari(0).precision()
 
 if _within_sage:
-    from sage.all import RealField, Integer, Rational, ZZ, QQ, RR, CC, SR
+    from .sage_helper import RealField, Integer, Rational, ZZ, QQ, RR, CC
     from sage.structure.parent import Parent
     from sage.structure.unique_representation import UniqueRepresentation
     from sage.categories.homset import Hom
@@ -22,7 +23,6 @@ if _within_sage:
     from sage.rings.real_mpfr import RealField_class
     from sage.misc.classcall_metaclass import ClasscallMetaclass
     from .sage_helper import ComplexField, ComplexField_class
-    from six import add_metaclass
 
     class SnappyNumbersMetaclass(ClasscallMetaclass):
         """
@@ -55,8 +55,8 @@ if _within_sage:
             result._precision = self.target_precision
             return result
 
-    @add_metaclass(SnappyNumbersMetaclass)
-    class SnapPyNumbers(UniqueRepresentation, Parent):
+    class SnapPyNumbers(UniqueRepresentation, Parent,
+                        metaclass=SnappyNumbersMetaclass):
         """
         Sage parents of SnapPy Number objects.
         """
@@ -66,8 +66,13 @@ if _within_sage:
             self._precision = precision
             self.register_coercion(MorphismToSPN(ZZ, self, self._precision))
             self.register_coercion(MorphismToSPN(QQ, self, self._precision))
-            to_SR = Hom(self, SR, Sets())(lambda x: SR(x.sage()))
-            SR.register_coercion(to_SR)
+            try:
+                from sage.symbolic.ring import SR
+            except ImportError:
+                pass
+            else:
+                to_SR = Hom(self, SR, Sets())(lambda x: SR(x.sage()))
+                SR.register_coercion(to_SR)
 
         def _repr_(self):
             return "SnapPy Numbers with %s bits precision" % self._precision
@@ -119,9 +124,9 @@ if _within_sage:
         if isinstance(x, int) or isinstance(x, Integer) or isinstance(x, Rational):
             return True
         if isinstance(x, Gen):
-            return x.precision() == 0
+            return x.precision() == precision_of_exact_GEN
         if isinstance(x, Number):
-            return x.gen.precision() == 0
+            return x.gen.precision() == precision_of_exact_GEN
         return False
 
     def float_to_gen(x, precision):
@@ -137,9 +142,9 @@ else:  # We are not in Sage
         if isinstance(x, int):
             return True
         if isinstance(x, Gen):
-            return x.precision() == 0
+            return x.precision() == precision_of_exact_GEN
         if isinstance(x, Number):
-            return x.gen.precision() == 0
+            return x.gen.precision() == precision_of_exact_GEN
         return False
 
     def float_to_gen(x, precision):
@@ -150,7 +155,7 @@ else:  # We are not in Sage
             pari._real_coerced_to_bits_prec(x.real, precision),
             pari._real_coerced_to_bits_prec(x.imag, precision))
 
-    class SnapPyNumbers(object):
+    class SnapPyNumbers():
         """
         Surrogate parent for a SnapPy Number, to make calls to Number.parent() work
         in or out of Sage.  This allows the following paradigm to work:
@@ -163,12 +168,37 @@ else:  # We are not in Sage
         >>> y
         2.500000000000000000000000000000000000000000000000000000000000
 
+        >>> Number("1.0e20", precision = 53)
+        1.000000000000000 E20
+        >>> Number("1.0e20", precision = 53, accuracy = 0)
+        1.0 E20
+        >>> Number("1.0e20", precision = 53, accuracy = 3)
+        1.000 E20
+        >>> Number("1.23456", precision = 53)
+        1.234560000000000
+        >>> Number("1.23456", precision = 53, accuracy = 0)
+        1.23456
+        >>> Number("1.23456", precision = 53, accuracy = 4)
+        1.2346
+        >>> Number("0.01", precision = 53)
+        0.010000000000000
+        >>> Number("0.01", precision = 53, accuracy = 0)
+        0.01
+        >>> Number("0.01", precision = 53, accuracy = 3)
+        0.010
+        >>> Number("3.0123e-20", precision = 53)
+        3.01230000000000 E-20
+        >>> Number("3.0123e-20", precision = 53, accuracy = 0)
+        3.0123 E-20
+        >>> Number("3.0123e-20", precision = 53, accuracy = 3)
+        3.01 E-20
+
         """
         _cache = {}
 
         def __new__(cls, precision=53):
             if precision not in SnapPyNumbers._cache:
-                obj = super(SnapPyNumbers, cls).__new__(cls)
+                obj = super().__new__(cls)
                 obj._precision = precision
                 SnapPyNumbers._cache[precision] = obj
                 return obj
@@ -200,7 +230,7 @@ else:  # We are not in Sage
             return min + normalizer * gen.random(limit.gen)
 
 
-class SupportsMultiplicationByNumber(object):
+class SupportsMultiplicationByNumber():
     pass
 
 
@@ -270,7 +300,8 @@ class Number(Number_baseclass):
             self.accuracy = self.decimal_precision
         else:
             if accuracy is None:
-                accuracy = prec_words_to_dec(self.gen.sizeword())
+                accuracy = prec_bits_to_dec(64 * (self.gen.sizeword() - 2))
+
             self.accuracy = min(accuracy, self.decimal_precision)
         self._parent = SnapPyNumbers(self._precision)
         if _within_sage:
@@ -321,7 +352,12 @@ class Number(Number_baseclass):
         if accuracy:
             # Trick PARI into rounding to the correct number of digits.
             # Simulates the printf %.Nf format, where N is the accuracy.
-            int_part = gen.truncate().abs()
+            try:
+                int_part = gen.truncate().abs()
+            except PariError:
+                # Happens if gen holds large number.
+                # Setting to 1 so that we display something.
+                int_part = 1
             if int_part == 0:
                 # Deal with zeros to the right of the decimal point.
                 try:
@@ -341,10 +377,9 @@ class Number(Number_baseclass):
         else:
             old_precision = pari.set_real_precision(self.decimal_precision)
             result = str(gen)
-            try:
-                result = strip_zeros.findall(result)[0]
-            except IndexError:
-                pass
+            m = strip_zeros.match(result)
+            if m:
+                result = m.group(1) + m.group(2)
             pari.set_real_precision(old_precision)
         return result
 
@@ -546,7 +581,7 @@ class Number(Number_baseclass):
     def sqrtn(self, n):
         """
         >>> r = Number(2.0, precision=100)
-        >>> r.sqrtn(10)
+        >>> r.sqrtn(10) # doctest: +NUMERIC27
         (1.071773462536293164213006325023, 0.809016994374947424102293417183 + 0.587785252292473129168705954639*I)
         """
         a, b = self.gen.sqrtn(n, precision=self._precision)
@@ -579,3 +614,44 @@ for trig in ['cos', 'cosh', 'sin', 'sinh', 'tan', 'tanh']:
     setattr(Number, 'arc' + trig, getattr(Number, 'a' + trig))
 
 Number.argument = Number.arg
+
+
+def use_field_conversion(func):
+    global number_to_native_number
+
+    if func == 'sage':
+        def number_to_native_number(n):
+            """
+            Converts a SnapPy number to the corresponding SageMath type.
+
+            In general snappy.number.number_to_native_number converts a SnapPy number to
+            the corresponding SageMath type (when in SageMath) or just returns
+            the SnapPy number itself (when SageMath is not available).
+
+            However, this behavior can be overridden by
+            snappy.number.use_field_conversion which replaces
+            number_to_native_number.
+            """
+            return n.sage()
+    elif func == 'snappy':
+        def number_to_native_number(n):
+            """
+            Simply returns the given SnapPy number.
+
+            In general snappy.number.number_to_native_number converts a SnapPy number to
+            the corresponding SageMath type (when in SageMath) or just returns
+            the SnapPy number itself (when SageMath is not available).
+
+            However, this behavior can be overridden by
+            snappy.number.use_field_conversion which replaces
+            number_to_native_number.
+            """
+            return n
+    else:
+        number_to_native_number = func
+
+
+if _within_sage:
+    use_field_conversion('sage')
+else:
+    use_field_conversion('snappy')

snappy/numeric_output_checker.py

@@ -1,5 +1,3 @@
-from builtins import range
-
 """
 Provides the NumericOutputChecker implementing doctest's OutputChecker.
 
@@ -11,6 +9,7 @@ See init_precisions(...) for the precisions we support.
 See documentation of NumericExample for more.
 """
 
+
 class NumericExample:
     """
     The actual result (3.141592653589793) differs from the given result,
@@ -25,14 +24,17 @@ class NumericExample:
         >>> ['a', 4.5, 6.9] # doctest: +NUMERIC6
         ['a', 4.5,       6.9000000001]
 
-    Intervals in the notation emitted by sage are allows::
+    Intervals in the notation emitted by sage are allowed::
 
         >>> print("4.5?e-1") # doctest: +NUMERIC6
         4.50000000001?e-1
 
     """
 
-import doctest, re, decimal
+
+import doctest
+import re
+import decimal
 
 # Generate flags NUMERIC6, ...
 
@@ -41,7 +43,8 @@ NUMERIC_LIST = []
 # Store in dict precision : FLAG
 NUMERIC_DICT = {}
 # All or'ed together
-ALL_NUMERIC  = 0
+ALL_NUMERIC = 0
+
 
 def init_precisions(precisions):
     """
@@ -65,9 +68,11 @@ def init_precisions(precisions):
             NUMERIC_DICT[precision] = flag
             ALL_NUMERIC |= flag
 
+
 # The precisions NUMERIC0, ... we support are hard-coded here:
 init_precisions(range(0,33,3))
 
+
 def get_precision(optionflags):
     """
     Get precision from optionflags
@@ -79,6 +84,7 @@ def get_precision(optionflags):
 # Regular expressions matching numbers and intervals such as
 # 23, 2.3, 3.5e-4, 3.4 E-5, 3.4?, 5.6?e-3
 
+
 mantissa_pat = r'(-?[0-9]+(?:\.[0-9]+)?)'
 # Intervals can be 3.4? or 3.4?e-2, account for the "?"
 interval_pat = r'(\?)?'
@@ -87,7 +93,7 @@ exponent_pat = r'(?:\ ?([eE][+-]?[0-9]+))?'
 
 # 4.5?e-3 would split into groups ('4.5?e-3', '4.5', '?", 'e-3').
 number_re = re.compile('(' + mantissa_pat + interval_pat + exponent_pat + ')')
-number_group_count  = 4
+number_group_count = 4
 number_split_stride = number_group_count + 1
 
 # Use whitespace normalization for text pieces
@@ -95,6 +101,8 @@ NUMERIC_DEFAULT_OPTIONFLAGS = doctest.NORMALIZE_WHITESPACE
 
 # Given the above groups, e.g., ('4.5?e-3', '4.5', '?", 'e-3'), return
 # decimal.Decimal("4.5E-3")
+
+
 def to_decimal(groups):
     number, mantissa, interval, exponent = groups
     if exponent:
@@ -103,6 +111,7 @@ def to_decimal(groups):
         n = mantissa
     return decimal.Decimal(n)
 
+
 class NumericOutputChecker(doctest.OutputChecker):
     """
     Implements doctest's OutputChecker, see documentation of
@@ -146,18 +155,18 @@ class NumericOutputChecker(doctest.OutputChecker):
     >>> b   = "[4.5000001, 67.00000001, 2.0000000000000000001e+3]"
     >>> N.compare_numeric(a, b, NUMERIC_DICT[6])
     ('OK', None)
-    >>> N.compare_numeric(a, b, NUMERIC_DICT[12])    
+    >>> N.compare_numeric(a, b, NUMERIC_DICT[12])
     ('NUMERIC', ([('4.5', '4.5000001', True, Decimal('1E-7')), ('6.7e1', '67.00000001', True, Decimal('1E-8')), ('2e+3', '2.0000000000000000001e+3', False, Decimal('1E-16'))], Decimal('1E-7')))
 
     Account for pari adding a space before the E::
 
-    >>> a   = "4.5e-9"
-    >>> b   = "4.5 E-9"
-    >>> N.compare_numeric(a, b, NUMERIC_DICT[12])
-    ('OK', None)
+        >>> a   = "4.5e-9"
+        >>> b   = "4.5 E-9"
+        >>> N.compare_numeric(a, b, NUMERIC_DICT[12])
+        ('OK', None)
 
     """
-    
+
     def compare_numeric(self, want, got, optionflags):
         """
         Compares want and got by scanning for numbers. The numbers are
@@ -173,13 +182,13 @@ class NumericOutputChecker(doctest.OutputChecker):
 
         # "[4.5e-9]" yields ('[', '4.5e-9', '4.5', None, 'e-9', ']')
         split_want = re.split(number_re, want)
-        split_got  = re.split(number_re, got)
+        split_got = re.split(number_re, got)
 
         # Check same number of numbers
         if len(split_want) != len(split_got):
             return ('COUNT',
                     (len(split_want) // number_split_stride,
-                     len(split_got)  // number_split_stride))
+                     len(split_got) // number_split_stride))
 
         # Compare text pieces between numbers
         flags = optionflags | NUMERIC_DEFAULT_OPTIONFLAGS
@@ -188,7 +197,7 @@ class NumericOutputChecker(doctest.OutputChecker):
             if not doctest.OutputChecker.check_output(
                     self, split_want[i], split_got[i], flags):
                 return ('TEXT', (split_want[i], split_got[i], i))
-        
+
         epsilon = decimal.Decimal(0.1) ** get_precision(optionflags)
 
         rows = []
@@ -197,17 +206,17 @@ class NumericOutputChecker(doctest.OutputChecker):
         for i in range(1, len(split_want), number_split_stride):
             # Number how it literally appears
             number_want = split_want[i]
-            number_got  = split_got [i]
+            number_got = split_got[i]
 
             # Check whether both intervals or numbers
             is_interval_want = bool(split_want[i + 2])
-            is_interval_got  = bool(split_got [i + 2])
+            is_interval_got = bool(split_got[i + 2])
             if is_interval_want != is_interval_got:
                 return ('TYPE', (is_interval_want, number_got))
-            
+
             # Number (or crushed interval) as decimal.Decimal
-            decimal_want = to_decimal(split_want[i : i + number_group_count])
-            decimal_got  = to_decimal(split_got [i : i + number_group_count])
+            decimal_want = to_decimal(split_want[i: i + number_group_count])
+            decimal_got = to_decimal(split_got[i: i + number_group_count])
 
             # Compute diff
             diff = abs(decimal_want - decimal_got)
@@ -266,7 +275,7 @@ class NumericOutputChecker(doctest.OutputChecker):
         """
 
         status, data = self.compare_numeric(want, got, optionflags)
-        
+
         return self.format_compare_numeric_result(status, data)
 
     def check_output(self, want, got, optionflags):
@@ -301,7 +310,7 @@ class NumericOutputChecker(doctest.OutputChecker):
             flags = optionflags | NUMERIC_DEFAULT_OPTIONFLAGS
             base_result = doctest.OutputChecker.output_difference(
                 self, example, got, flags)
-            
+
             # Our compare result
             compare_result = self.formatted_compare_numeric(
                 example.want, got, optionflags)
@@ -309,13 +318,14 @@ class NumericOutputChecker(doctest.OutputChecker):
             # Concatenate together
             return base_result + '\nReason for failure: ' + compare_result + '\n'
 
-def run_doctests(verbose = False):
+
+def run_doctests(verbose=False, print_info=True):
     failed, attempted = 0, 0
 
     finder = doctest.DocTestFinder()
-    
+
     # Use the default docTest.OutputChecker to test our NumericOutputChecker
-    runner = doctest.DocTestRunner(verbose = verbose)
+    runner = doctest.DocTestRunner(verbose=verbose)
     for test in finder.find(NumericOutputChecker):
         runner.run(test)
     result = runner.summarize()
@@ -323,7 +333,7 @@ def run_doctests(verbose = False):
     attempted += result.attempted
 
     # Test our NumericOutputChecker in action!
-    runner = doctest.DocTestRunner(checker = NumericOutputChecker(), verbose = verbose)
+    runner = doctest.DocTestRunner(checker=NumericOutputChecker(), verbose=verbose)
     for test in finder.find(NumericExample):
         runner.run(test)
         result = runner.summarize()
@@ -332,4 +342,4 @@ def run_doctests(verbose = False):
 
     return doctest.TestResults(failed, attempted)
 
-run_doctests.__name__ = 'NumericOutputChecker'
+run_doctests.__name__ = __name__

snappy/pari.py

@@ -3,78 +3,39 @@ Import pari and associated classes and functions here, to be more DRY,
 while supporting both old and new versions of cypari and sage.pari and
 accounting for all of the various idiosyncrasies.
 """
-from pkg_resources import parse_version
+
+from packaging.version import parse as parse_version
 from .sage_helper import _within_sage
 
 if _within_sage:
-    from sage.version import version as sage_version
-    sage_version = parse_version(sage_version)
-    if sage_version < parse_version('7.5'):
-        from sage.libs.pari.gen import gen as Gen
-        if sage_version < parse_version('6.1'):
-            from sage.libs.pari.gen import pari
-            from sage.libs.pari.gen import (prec_words_to_dec,
-                                            prec_words_to_bits,
-                                            prec_bits_to_dec,
-                                            prec_dec_to_bits)
-        else:
-            from sage.libs.pari.pari_instance import pari
-            from sage.libs.pari.pari_instance import (prec_words_to_dec,
-                                                      prec_words_to_bits,
-                                                      prec_bits_to_dec,
-                                                      prec_dec_to_bits)
-    elif sage_version < parse_version('7.6'):
-        from sage.libs.cypari2 import pari
-        from sage.libs.cypari2.gen import gen as Gen
-        from sage.libs.cypari2.pari_instance import (
-            prec_words_to_dec,
-            prec_words_to_bits,
-            prec_bits_to_dec,
-            prec_dec_to_bits)
-    elif sage_version < parse_version('8.0'):
-        from sage.libs.pari import pari
-        from sage.libs.cypari2 import Gen
-        from sage.libs.cypari2.pari_instance import (
-            prec_words_to_dec,
-            prec_words_to_bits,
-            prec_bits_to_dec,
-            prec_dec_to_bits)
-    else: # Sage 8.0 or newer
-        from sage.libs.pari import pari
-        from cypari2 import Gen
-        from cypari2.pari_instance import (
-            prec_words_to_dec,
-            prec_words_to_bits,
-            prec_bits_to_dec,
-            prec_dec_to_bits)
-        
-    from sage.all import PariError
-    shut_up  = lambda : None
-    speak_up = lambda : None   
-    
-else: # Plain Python, use CyPari
-    import cypari
-    cypari_version = parse_version(cypari.__version__)
+    from sage.version import version as s_version
+    sage_version = parse_version(s_version)
+    if sage_version < parse_version('9.0'):
+        raise ValueError("you need a more recent version of SageMath")
+    from sage.libs.pari import pari
+    from cypari2 import Gen
+    from cypari2.pari_instance import (prec_words_to_bits,
+                                       prec_bits_to_dec,
+                                       prec_dec_to_bits)
     try:
-        from cypari import pari
+        from sage.all import PariError
     except ImportError:
-        from cypari.gen import pari
-    if cypari_version < parse_version('2.2.0'):
-        from cypari.gen import (
-            gen as Gen,
-            PariError,
-            prec_words_to_dec,
-            prec_words_to_bits,
-            prec_bits_to_dec,
-            prec_dec_to_bits)
-    else:
-        from cypari._pari import (
-            Gen,
-            PariError,
-            prec_words_to_dec,
-            prec_words_to_bits,
-            prec_bits_to_dec,
-            prec_dec_to_bits)
-    shut_up  = lambda : pari.shut_up()
-    speak_up = lambda : pari.speak_up()
+        from sage.libs.pari.all import PariError
 
+    shut_up = lambda: None
+    speak_up = lambda: None
+
+else:  # Plain Python, use CyPari
+    import cypari
+    cypari_version = parse_version(cypari.__version__)
+    if cypari_version < parse_version('2.3'):
+        raise ValueError("you need a more recent version of CyPari")
+    from cypari import pari
+    from cypari._pari import (Gen,
+                              PariError,
+                              prec_words_to_dec,
+                              prec_words_to_bits,
+                              prec_bits_to_dec,
+                              prec_dec_to_bits)
+    shut_up = lambda: pari.shut_up()
+    speak_up = lambda: pari.speak_up()

snappy/phone_home.py

@@ -1,8 +1,11 @@
 import sys
-from http.client import HTTPConnection
 from threading import Thread
-from .version import version as this_version
-from distutils.version import LooseVersion
+from .version import version as current
+from packaging.version import parse as parse_version
+
+import ssl
+from urllib import request
+version_url = 'http://snappy.computop.org/current.txt'
 
 
 class Phoner(Thread):
@@ -11,42 +14,44 @@ class Phoner(Thread):
         self.answer = None
 
     def run(self):
-        newest_version = None
+        this_version = parse_version(current)
+        latest = None
         try:
-            connection = HTTPConnection('snappy.math.uic.edu', timeout=1)
-            connection.request('GET', '/current.txt')
-            response = connection.getresponse()
-            if response.status != 200:
-                return
-            newest_version = response.read().strip()
-            connection.close()
+            # Below code would allow switching to https urls in our
+            # macOS app where certs are broken.
+            #
+            # ctx = ssl.create_default_context()
+            # ctx.check_hostname = False
+            # ctx.verify_mode = ssl.CERT_NONE
+            # with request.urlopen(version_url, context=ctx) as response:
+            with request.urlopen(version_url) as response:
+                latest = response.read().decode('ascii').strip()
+                latest_version = parse_version(latest)
         except Exception:
             return
-        if isinstance(newest_version, bytes):
-            newest_version = newest_version.decode()
-        if newest_version and LooseVersion(newest_version) > LooseVersion(this_version):
-            self.answer = (newest_version, this_version)
+        if latest and latest_version > this_version:
+            self.answer = (latest, current)
 
 
 def update_needed():
     ET = Phoner()
     ET.start()
-    ET.join(1.0) # Wait up to 1.0 seconds for an answer
+    ET.join(1.0)  # Wait up to 1.0 seconds for an answer
     if ET.is_alive():
         return ''
     elif ET.answer:
         return ("**Please upgrade to %s from %s via "
                 "http://snappy.computop.org**\n" % ET.answer)
     else:
-         return ''
+        return ''
+
 
 if __name__ == '__main__':
-    import sys
     if len(sys.argv) > 1:
-        this_version = '0.0.0'
+        current = '0.0.0'
     else:
         print('To provoke an update response add an argument.')
     import time
     start = time.time()
     print(update_needed())
-    print('Elapsed time: %ss'%(time.time() - start))
+    print('Elapsed time: %ss' % (time.time() - start))