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

snappy/ptolemy/processRurFile.py

@@ -7,9 +7,11 @@ from .rur import RUR
 from . import processFileBase
 from ..pari import pari
 
+
 def contains_rur(text):
     return 'RUR=DECOMPOSITION=BEGINS' in text
 
+
 def decomposition_from_rur(text):
 
     py_eval = processFileBase.get_py_eval(text)
@@ -26,6 +28,7 @@ def decomposition_from_rur(text):
 
     return result
 
+
 def _process_rur_component(text, py_eval, manifold_thunk):
     lines = text.split('\n')
 
@@ -52,20 +55,20 @@ def _process_rur_component(text, py_eval, manifold_thunk):
                 raise Exception("Unrecognized key %s" % key)
         else:
             body += line + "\n"
-   
+
     if dimension is None:
         return NonZeroDimensionalComponent()
     if dimension > 0:
-        return NonZeroDimensionalComponent(dimension = dimension)
+        return NonZeroDimensionalComponent(dimension=dimension)
 
     if format is None:
         raise Exception("No format specified")
 
     if format == "MAPLE-LIKE":
         d = parse_maple_like_rur(body.strip())
-        return PtolemyCoordinates(d, is_numerical = False,
-                                  py_eval_section = py_eval,
-                                  manifold_thunk = manifold_thunk)
+        return PtolemyCoordinates(d, is_numerical=False,
+                                  py_eval_section=py_eval,
+                                  manifold_thunk=manifold_thunk)
     else:
         raise Exception("Unknown format %s" % format)
 
@@ -86,8 +89,9 @@ def parse_maple_like_rur(text):
     return dict([_parse_assignment(assignment, poly)
                  for assignment in assignments_text.split(',')])
 
+
 def parse_rs_rur(text, variables):
-    
+
     m = re.match(r'\[([^,\]]+),\s*([^,\]]+),\s*\[([^\]]+)\]\s*,\s*\[\s*\]\s*\]',
                  text, re.DOTALL)
 
@@ -102,25 +106,28 @@ def parse_rs_rur(text, variables):
     denominator = pari(denominator_str.replace(var, 'x'))
     numerators = [ pari(numerator_str.replace(var, 'x'))
                    for numerator_str in numerators_str.split(',') ]
-    
+
     fracs = [
-        RUR( [ (  numerator.Mod(extension),  1),
+        RUR( [ (  numerator.Mod(extension), 1),
                (denominator.Mod(extension), -1) ] )
         for numerator in numerators ]
 
     return dict(list(zip(variables, fracs)) + [('1', RUR.from_int(1))])
-    
+
+
 def _find_var_of_poly(text):
     return re.search(r'[_A-Za-z][_A-Za-z0-9]*',text).group(0)
 
+
 def _parse_assignment(text, poly):
     var, expression = re.match(r'\s*([_A-Za-z][_A-Za-z0-9]*)\s*=\s*(.*)$',
                                text).groups()
-    
+
     return (
         var,
         RUR.from_pari_fraction_and_number_field(pari(expression), poly))
 
+
 _test_case = """
 _Z^6-3*_Z^5+3*_Z^4-2*_Z^3+_Z-1 = 0,
  {c_0012_0 = 1, c_0012_2 = _Z^5-3*_Z^4+3*_Z^3-_Z^2-2*_Z+1, c_0111_2 = -_Z*(_Z^4-2*_Z^3+_Z-1), c_1011_0 = -_Z^2*(-1+_Z), c_1101_0 = -_Z*(-1+_Z), c_1101_1 = _Z*(-1+_Z), c_1110_0 = _Z, a = (_Z^3+_Z^2)/(_Z^3+34*_Z^2+3)}
@@ -131,7 +138,7 @@ class SolutionContainer():
     def __init__(self, solutions):
         self._solutions = solutions
 
-    def solutions(self, numerical = False):
+    def solutions(self, numerical=False):
         if numerical:
             return self._solutions.numerical()
         else:

snappy/ptolemy/ptolemyGeneralizedObstructionClass.py

@@ -1,11 +1,9 @@
-from __future__ import print_function
-
 from . import matrix
 from .polynomial import Polynomial
 from ..pari import pari
 
-class PtolemyGeneralizedObstructionClass(object):
 
+class PtolemyGeneralizedObstructionClass():
     """
     Represents an obstruction cocycle of a PSL(n,C) representation in
     H^2(M,partial M;Z/n).
@@ -13,28 +11,34 @@ class PtolemyGeneralizedObstructionClass(object):
     >>> from snappy import Manifold
     >>> M = Manifold("m004")
 
-    Create an obstruction class, this has to be in the kernel of d^2
+    Create an obstruction class, this has to be in the kernel of d^2:
+
     >>> c = PtolemyGeneralizedObstructionClass([2,0,0,1])
 
-    For better accounting, give it an index
+    For better accounting, give it an index:
+
     >>> c = PtolemyGeneralizedObstructionClass([2,0,0,1], index = 1)
 
-    Get corresponding ptolemy variety
-    >>> p=M.ptolemy_variety(N = 3, obstruction_class = c)
+    Get corresponding ptolemy variety:
+
+    >>> p = M.ptolemy_variety(N=3, obstruction_class=c)
+
+    Canonical filename base:
 
-    Canonical filename base
     >>> p.filename_base()
     'm004__sl3_c1'
 
-    Now pick something not in the kernel
+    Now pick something not in the kernel:
+
     >>> c = PtolemyGeneralizedObstructionClass([1,0,0,1])
-    >>> p=M.ptolemy_variety(N = 3, obstruction_class = c)
+    >>> p = M.ptolemy_variety(N=3, obstruction_class=c)
     Traceback (most recent call last):
-       ...
+    ...
     AssertionError: PtolemyGeneralizedObstructionClass not in kernel of d2
+
     """
-    
-    def __init__(self, H2_class, index = None, N = None, manifold = None):
+
+    def __init__(self, H2_class, index=None, N=None, manifold=None):
 
         self.H2_class = H2_class
         self._index = index
@@ -42,11 +46,11 @@ class PtolemyGeneralizedObstructionClass(object):
         self._manifold = manifold
 
     def _checkManifoldAndN(self, manifold, N):
-        if not self._manifold is None:
+        if self._manifold is not None:
             assert manifold == self._manifold, (
                 "PtolemyGeneralizedObstructionClass for wrong manifold")
 
-        if not self._N is None:
+        if self._N is not None:
             assert N == self._N, (
                 "PtolemyGeneralizedObstructionClass for wrong N")
 
@@ -67,7 +71,7 @@ class PtolemyGeneralizedObstructionClass(object):
                 N)), ("PtolemyGeneralizedObstructionClass not in kernel of "
                       "d2")
 
-    def _is_non_trivial(self, N):        
+    def _is_non_trivial(self, N):
         for h in self.H2_class:
             if h % N != 0:
                 return True
@@ -96,4 +100,3 @@ class PtolemyGeneralizedObstructionClass(object):
 
     def __repr__(self):
         return "PtolemyGeneralizedObstructionClass(%s)" % self.H2_class
-

snappy/ptolemy/ptolemyObstructionClass.py

@@ -1,14 +1,11 @@
-from __future__ import print_function
-
-class PtolemyObstructionClass(object):
-
+class PtolemyObstructionClass():
     """
     Represents an obstruction cocycle of a pSL(n,C) representation as
     described in Definition 1.7 of
-    
+
     Garoufalidis, Thurston, Zickert
     The Complex Volume of SL(n,C)-Representations of 3-Manifolds
-    http://arxiv.org/abs/1111.2828
+    https://arxiv.org/abs/1111.2828
 
     To generate such an obstruction class, call:
 
@@ -17,14 +14,15 @@ class PtolemyObstructionClass(object):
     >>> cs = M.ptolemy_obstruction_classes()
 
     Print out the values:
+
     >>> for c in cs: print(c)
     PtolemyObstructionClass(s_0_0 - 1, s_1_0 - 1, s_2_0 - 1, s_3_0 - 1, s_0_0 - s_0_1, s_1_0 - s_3_1, s_2_0 - s_2_1, s_3_0 - s_1_1)
     PtolemyObstructionClass(s_0_0 + 1, s_1_0 - 1, s_2_0 - 1, s_3_0 + 1, s_0_0 - s_0_1, s_1_0 - s_3_1, s_2_0 - s_2_1, s_3_0 - s_1_1)
     """
-    
+
     def __init__(self, manifold, index, H2_element, explain_basis,
                  identified_face_classes):
-        
+
         self._manifold = manifold
         self._index = index
         self._H2_element = H2_element
@@ -32,17 +30,16 @@ class PtolemyObstructionClass(object):
         self._identified_face_classes = identified_face_classes
 
         def H2_element_entry_to_identified_variable(entry, variable):
-            return ( (-1)**entry, 0, variable, 1)
+            return ((-1)**entry, 0, variable, 1)
 
         self.identified_variables = (
-            [ H2_element_entry_to_identified_variable(entry, variable)
-              for entry, variable in zip(H2_element, explain_basis)]
-            + 
-            [ (+1, 0, var1, var2)
-              for sign, power, var1, var2 in self._identified_face_classes])
+            [H2_element_entry_to_identified_variable(entry, variable)
+             for entry, variable in zip(H2_element, explain_basis)] +
+            [(+1, 0, var1, var2)
+             for sign, power, var1, var2 in self._identified_face_classes])
 
     def _checkManifoldAndN(self, manifold, N):
-        if not self._manifold is None:
+        if self._manifold is not None:
             assert manifold == self._manifold, (
                 "PtolemyObstructionClass for wrong manifold")
 
@@ -64,5 +61,4 @@ class PtolemyObstructionClass(object):
                 return var1 + " + " + var2
 
         return "PtolemyObstructionClass(%s)" % ', '.join(
-            [to_string(i) for i in self.identified_variables])
-
+            to_string(i) for i in self.identified_variables)