snappy 3.1.1__cp311-cp311-macosx_11_0_arm64.whl → 3.2__cp311-cp311-macosx_11_0_arm64.whl

snappy/raytracing/test.py

@@ -0,0 +1,29 @@
+from snappy import testing
+import snappy
+
+from snappy import raytracing
+import snappy.raytracing.geodesic_tube_info
+import snappy.raytracing.geodesics
+import snappy.raytracing.ideal_raytracing_data
+import snappy.raytracing.upper_halfspace_utilities
+
+modules = [
+    raytracing.cohomology_fractal,
+    raytracing.geodesic_tube_info,
+    raytracing.geodesics,
+    raytracing.ideal_raytracing_data,
+    raytracing.upper_halfspace_utilities
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold'  : snappy.Manifold,
+             'ManifoldHP': snappy.ManifoldHP}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = raytracing.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/raytracing/tooltip.py

@@ -0,0 +1,146 @@
+"""
+Module defining the ToolTip widget
+
+From https://github.com/gnikit/tkinter-tooltip
+"""
+
+import time
+import tkinter as tk
+from typing import Callable
+
+# This code is based on Tucker Beck's implementation licensed under an MIT License
+# Original code: http://code.activestate.com/recipes/576688-tooltip-for-tkinter/
+
+
+class ToolTip(tk.Toplevel):
+    """
+    Creates a ToolTip (pop-up) widget for tkinter
+    """
+
+    def __init__(
+        self,
+        widget: tk.Widget,
+        msg = None, # : str | Callable
+        delay: float = 1.0,
+        follow: bool = True,
+        refresh: float = 1.0,
+        x_offset: int = +10,
+        y_offset: int = +10,
+        parent_kwargs: dict = {"bg": "black", "padx": 1, "pady": 1},
+        **message_kwargs,
+    ):
+        """Create a ToolTip. Allows for `**kwargs` to be passed on both
+            the parent frame and the ToolTip message
+
+        Parameters
+        ----------
+        widget : tk.Widget
+            The widget this ToolTip is assigned to
+        msg : `Union[str, Callable]`, optional
+            A string message (can be dynamic) assigned to the ToolTip.
+            Alternatively, it can be set to a function thatreturns a string,
+            by default None
+        delay : `float`, optional
+            Delay in seconds before the ToolTip appears, by default 0.0
+        follow : `bool`, optional
+            ToolTip follows motion, otherwise hides, by default True
+        refresh : `float`, optional
+            Refresh rate in seconds for strings and functions when mouse is
+            stationary and inside the widget, by default 1.0
+        x_offset : `int`, optional
+            x-coordinate offset for the ToolTip, by default +10
+        y_offset : `int`, optional
+            y-coordinate offset for the ToolTip, by default +10
+        parent_kwargs : `dict`, optional
+            Optional kwargs to be passed into the parent frame,
+            by default `{"bg": "black", "padx": 1, "pady": 1}`
+        **message_kwargs : tkinter `**kwargs` passed directly into the ToolTip
+        """
+        self.widget = widget
+        # ToolTip should have the same parent as the widget unless stated
+        # otherwise in the `parent_kwargs`
+        tk.Toplevel.__init__(self, **parent_kwargs)
+        self.withdraw()  # Hide initially in case there is a delay
+        # Disable ToolTip's title bar
+        self.overrideredirect(True)
+
+        # StringVar instance for msg string|function
+        self.msgVar = tk.StringVar()
+        # This can be a string or a function
+        # Do not bother doing any sort of checks here since it sometimes results
+        # into multiple spawn-hide calls being made when swapping between tooltips
+        self.msg = msg
+        self.delay = delay
+        self.follow = follow
+        self.refresh = refresh
+        self.x_offset = x_offset
+        self.y_offset = y_offset
+        # visibility status of the ToolTip inside|outside|visible
+        self.status = "outside"
+        self.last_moved = 0
+        # use Message widget to host ToolTip
+        tk.Message(self, textvariable=self.msgVar, aspect=1000, **message_kwargs).grid()
+        # Add bindings to the widget without overriding the existing ones
+        self.widget.bind("<Enter>", self.on_enter, add="+")
+        self.widget.bind("<Leave>", self.on_leave, add="+")
+        self.widget.bind("<Motion>", self.on_enter, add="+")
+        self.widget.bind("<ButtonPress>", self.on_leave, add="+")
+
+    def on_enter(self, event) -> None:
+        """
+        Processes motion within the widget including entering and moving.
+        """
+        self.last_moved = time.time()
+
+        # Set the status as inside for the very first time
+        if self.status == "outside":
+            self.status = "inside"
+
+        # If the follow flag is not set, motion within the widget will
+        # make the ToolTip disappear
+        if not self.follow:
+            self.status = "inside"
+            self.withdraw()
+
+        # Offsets the ToolTip using the coordinates od an event as an origin
+        self.geometry(f"+{event.x_root + self.x_offset}+{event.y_root + self.y_offset}")
+
+        # Time is integer and in milliseconds
+        self.after(int(self.delay * 1000), self._show)
+
+    def on_leave(self, event=None) -> None:
+        """
+        Hides the ToolTip.
+        """
+        self.status = "outside"
+        self.withdraw()
+
+    def _show(self) -> None:
+        """
+        Displays the ToolTip.
+
+        Recursively queues `_show` in the scheduler every `self.refresh` seconds
+        """
+        if self.status == "inside" and time.time() - self.last_moved > self.delay:
+            self.status = "visible"
+
+        if self.status == "visible":
+            # Update the string with the latest function call
+            # Try and call self.msg as a function, if msg is not callable try and
+            # set it as a normal string if that fails throw an error
+            try:
+                self.msgVar.set(self.msg())
+            except TypeError:
+                # Intentionally do not check if msg is str, can be a list of str
+                self.msgVar.set(self.msg)
+            except:
+                raise (
+                    "Error: ToolTip `msg` must be a string or string returning "
+                    + f"function instead `msg` of type {type(self.msg)} was input"
+                )
+            self.deiconify()
+
+            # Recursively call _show to update ToolTip with the newest value of msg
+            # This is a race condition which only exits when upon a binding change
+            # that in turn changes the `status` to outside
+            self.after(int(self.refresh * 1000), self._show)

snappy/raytracing/upper_halfspace_utilities.py

@@ -1,6 +1,9 @@
-from snappy.SnapPy import matrix
+from ..matrix import make_matrix
 from ..upper_halfspace.ideal_point import Infinity
+from ..upper_halfspace import pgl2c_to_o13, sl2c_inverse
 
+from ..snap.t3mlite import simplex
+from ..snap.t3mlite import Mcomplex
 
 def symmetric_vertices_for_tetrahedron(z):
     """
@@ -22,25 +25,25 @@ def pgl2_matrix_taking_0_1_inf_to_given_points(z0, z1, zinf):
     if z0 == Infinity:
         CF = z1.parent()
         m = zinf - z1
-        return matrix([[ -zinf, m ],
-                       [ -1, 0 ]], ring=CF)
+        return make_matrix([[ -zinf, m ],
+                            [ -1, 0 ]], ring=CF)
 
     if z1 == Infinity:
         CF = zinf.parent()
-        return matrix([[ -zinf, z0 ],
-                       [ -1, 1  ]], ring=CF)
+        return make_matrix([[ -zinf, z0 ],
+                            [ -1, 1  ]], ring=CF)
 
     if zinf == Infinity:
         CF = z0.parent()
         l = z0 - z1
-        return matrix([[ -l, z0 ],
-                       [  0, 1  ]], ring=CF)
+        return make_matrix([[ -l, z0 ],
+                            [  0, 1  ]], ring=CF)
 
     l = z0 - z1
     m = zinf - z1
 
-    return matrix([[ -l * zinf, m * z0 ],
-                   [ -l, m      ]])
+    return make_matrix([[ -l * zinf, m * z0 ],
+                        [ -l, m      ]])
 
 
 def are_sl_matrices_close(m1, m2, epsilon=1e-5):
@@ -63,3 +66,33 @@ def are_psl_matrices_close(m1, m2, epsilon=1e-5):
     return (
         are_sl_matrices_close(m1, m2, epsilon) or
         are_sl_matrices_close(m1, -m2, epsilon))
+
+def o13_matrix_taking_ideal_vertices_to_ideal_vertices(verts0, verts1):
+    m1 = pgl2_matrix_taking_0_1_inf_to_given_points(*verts0)
+    m2 = pgl2_matrix_taking_0_1_inf_to_given_points(*verts1)
+
+    return pgl2c_to_o13(m2 * sl2c_inverse(m1))
+
+def add_coordinate_transform_to_mcomplex(mcomplex : Mcomplex):
+    """
+    Most places in SnapPy/SnapPea kernel develop the tetrahedra
+    so that they form a fundamental domain - so that pairing
+    matrices are the identity for faces that are internal to the
+    fundamental domain.
+
+    However, for the raytracing shader, we pick the vertices of each
+    tetrahedron so that the center is at the origin.
+
+    Compute the matrix that can take structures in the coordinate
+    system native to SnapPy/SnapPea kernel to the coordinate system
+    used by the raytracing shader.
+
+    """
+    for tet in mcomplex.Tetrahedra:
+        z = tet.ShapeParameters[simplex.E01]
+        vert0 = [ tet.ideal_vertices[v]
+                  for v in simplex.ZeroSubsimplices[:3]]
+        vert1 = symmetric_vertices_for_tetrahedron(z)[:3]
+        tet.to_coordinates_in_symmetric_tet = (
+            o13_matrix_taking_ideal_vertices_to_ideal_vertices(
+                vert0, vert1))

snappy/sage_helper.py

@@ -9,45 +9,99 @@ than the usual ">>>".
 """
 
 try:
-    import sage.all
+    import sage.structure.sage_object
     _within_sage = True
 except ImportError:
     _within_sage = False
-    import decorator
-
-import sys
-import doctest
-import re
-import types
-
-from .numeric_output_checker import NumericOutputChecker
-
 
 class SageNotAvailable(Exception):
     pass
 
-
 if _within_sage:
     def sage_method(function):
         function._sage_method = True
         return function
 
+    try:
+        # Monolithic Sage library
+        from sage.all import RealField, RealDoubleElement, gcd, xgcd, prod, powerset
+        from sage.all import MatrixSpace, matrix, vector, ZZ
+        from sage.all import Integer, Rational, QQ, RR, CC
+        from sage.all import sqrt
+        from sage.all import I, Infinity
+        from sage.all import arccosh
+        from sage.all import RIF, CIF
+        from sage.all import (cached_method, real_part, imag_part, round, ceil, floor, log,
+                              CDF, ComplexDoubleField, ComplexField, CyclotomicField, NumberField, PolynomialRing, identity_matrix)
+        from sage.all import FiniteField as GF
+        from sage.all import VectorSpace, ChainComplex
+        from sage.all import ComplexBallField, exp, sin, block_matrix, prime_range, det
+        from sage.all import LaurentPolynomialRing, AbelianGroup, GroupAlgebra
+        from sage.all import is_prime
+    except ImportError:
+        # Modularized Sage library
+        from sage.algebras.group_algebra import GroupAlgebra
+        from sage.arith.misc import gcd, xgcd, is_prime
+        from sage.combinat.subset import powerset
+        from sage.functions.hyperbolic import arccosh
+        from sage.functions.log import exp
+        from sage.functions.other import (real as real_part,
+                                          imag as imag_part,
+                                          ceil,
+                                          floor)
+        from sage.functions.trig import sin
+        from sage.groups.abelian_gps.abelian_group import AbelianGroup
+        from sage.homology.chain_complex import ChainComplex
+        from sage.matrix.constructor import Matrix as matrix
+        from sage.matrix.matrix_space import MatrixSpace
+        from sage.matrix.special import block_matrix, identity_matrix
+        from sage.misc.cachefunc import cached_method
+        from sage.misc.functional import det, log, round, sqrt
+        from sage.misc.misc_c import prod
+        from sage.modules.free_module import VectorSpace
+        from sage.modules.free_module_element import free_module_element as vector
+        from sage.rings.cc import CC
+        from sage.rings.cif import CIF
+        from sage.rings.complex_arb import ComplexBallField
+        from sage.rings.complex_double import CDF, ComplexDoubleField
+        from sage.rings.complex_mpfr import ComplexField
+        from sage.rings.fast_arith import prime_range
+        from sage.rings.finite_rings.finite_field_constructor import FiniteField as GF
+        from sage.rings.imaginary_unit import I
+        from sage.rings.infinity import Infinity
+        from sage.rings.integer import Integer
+        from sage.rings.integer_ring import ZZ
+        from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing
+        from sage.rings.number_field.number_field import CyclotomicField, NumberField
+        from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+        from sage.rings.rational import Rational
+        from sage.rings.rational_field import QQ
+        from sage.rings.real_double import RealDoubleElement
+        from sage.rings.real_mpfi import RIF
+        from sage.rings.real_mpfr import RealField, RealNumber, RR
+
+    from sage.rings.complex_interval_field import ComplexIntervalField
+    from sage.rings.real_mpfi import is_RealIntervalFieldElement, RealIntervalField
+    from sage.rings.real_mpfr import RealNumber, RealField_class
+    from sage.structure.sage_object import SageObject
+
     try:  # Sage >= 9.3, see https://trac.sagemath.org/ticket/24483
         from sage.rings.complex_mpfr import (ComplexField,
                                              ComplexField_class,
                                              create_ComplexNumber)
-    except ModuleNotFoundError:
+    except ImportError:
         from sage.rings.complex_field import ComplexField, ComplexField_class
         from sage.rings.complex_number import create_ComplexNumber
 
 else:
+    import decorator
+
     def _sage_method(function, *args, **kw):
         raise SageNotAvailable('Sorry, this feature requires using SnapPy inside Sage.')
 
     def sage_method(function):
         return decorator.decorator(_sage_method, function)
 
-
 # Not currently used, but could be exploited by an interpreter to hide
 # sage_methods when in plain Python.
 
@@ -61,124 +115,3 @@ def sage_methods(obj):
         except AttributeError:
             pass
     return ans
-
-
-# Used for doctesting
-_gui_status = {}
-
-try:
-    from snappy.gui import Tk_
-    _gui_status['tk'] = True
-except ImportError:
-    _gui_status['tk'] = False
-if _gui_status['tk']:
-    try:
-        import snappy.CyOpenGL
-        _gui_status['cyopengl'] = True
-    except:
-        _gui_status['cyopengl'] = False
-else:
-    _gui_status['cyopengl'] = False
-_gui_status['fake_root'] = False
-
-
-def cyopengl_works():
-    if not _gui_status['cyopengl']:
-        return False
-    # if we are running the tests from the snappy app the default root will
-    # already exist -- it will be the tkterminal window.  Otherwise, we open
-    # a root window here to serve as the master of all of the GUI windows
-    # which get created during testing.
-    if _gui_status['tk'] and not Tk_._default_root:
-        try:
-            root = Tk_.Tk()
-            if sys.platform not in ('linux', 'linux2'):
-                root.withdraw()
-        except:
-            # tkinter loads OK but is not able to get a display.
-            _gui_status['tk'] = _gui_status['cyopengl'] = False
-    return _gui_status['cyopengl']
-
-
-def tk_root():
-    if _gui_status['tk']:
-        return Tk_._default_root
-    else:
-        return None
-
-
-def root_is_fake():
-    return _gui_status['fake_root']
-
-
-class DocTestParser(doctest.DocTestParser):
-    _use_cyopengl_initialized = False
-    _use_cyopengl = False
-    use_modernopengl = True
-    use_sage = False
-
-    def parse(self, string, name='<string>'):
-        string = re.subn(
-            r'#doctest: \+CYOPENGL',
-            '' if DocTestParser._use_cyopengl else '#doctest: +SKIP',
-            string)[0]
-
-        string = re.subn(
-            r'#doctest: \+CYMODERNOPENGL',
-            (''
-             if (DocTestParser._use_cyopengl and
-                 DocTestParser.use_modernopengl)
-             else '#doctest: +SKIP'),
-            string)[0]
-
-        if DocTestParser.use_sage:
-            string = re.subn(r'(\n\s*)sage:|(\A\s*)sage:',
-                             r'\g<1>>>>',
-                             string)[0]
-        return doctest.DocTestParser.parse(self, string, name)
-
-
-DocTestParser.use_sage = _within_sage
-
-if _within_sage:
-    globs = {'PSL': sage.all.PSL, 'BraidGroup': sage.all.BraidGroup}
-else:
-    globs = {}
-
-
-def print_results(module, results):
-    root = tk_root()
-    # Platform specific hacks to make running the tests work.
-    if root and not root_is_fake():
-        if sys.platform in ('linux', 'linux2'):
-            root.deiconify()
-            root.update_idletasks()
-        else:
-            root.update()
-    print(module.__name__ + ':')
-    print('   %s failures out of %s tests.' % (results.failed,
-                                               results.attempted))
-
-
-def doctest_modules(modules, verbose=False, print_info=True, extraglobs=dict()):
-    finder = doctest.DocTestFinder(parser=DocTestParser())
-    # full_extraglobals = dict(globs.items() + extraglobs.items())
-    full_extraglobals = globs.copy()
-    full_extraglobals.update(extraglobs)
-    failed, attempted = 0, 0
-    for module in modules:
-        if isinstance(module, types.ModuleType):
-            runner = doctest.DocTestRunner(checker=NumericOutputChecker(), verbose=verbose)
-            for test in finder.find(module, extraglobs=full_extraglobals):
-                runner.run(test)
-            result = runner.summarize()
-        else:
-            result = module(verbose=verbose)
-        failed += result.failed
-        attempted += result.attempted
-        if print_info:
-            print_results(module, result)
-
-    if print_info:
-        print('\nAll doctests:\n   %s failures out of %s tests.' % (failed, attempted))
-    return doctest.TestResults(failed, attempted)