snappy 3.1.1__cp39-cp39-win_amd64.whl → 3.2__cp39-cp39-win_amd64.whl

snappy/app.py

@@ -22,7 +22,7 @@ from .settings import Settings, SettingsDialog
 from .phone_home import update_needed
 from .SnapPy import SnapPea_interrupt, msg_stream
 from .shell import SnapPyInteractiveShellEmbed
-from .tkterminal import TkTerm, snappy_path
+from .tkterminal import TkTerminalBase
 
 from plink import LinkEditor
 from plink.smooth import Smoother
@@ -34,7 +34,7 @@ if 'SNAPPYHOME' in os.environ:
         os.environ['HOME'] = os.environ['SNAPPYHOME']
 
 
-class SnapPyTerm(TkTerm, ListedWindow):
+class SnapPyTerm(TkTerminalBase, ListedWindow):
     """
     The main window of the SnapPy app, which runs an embedded IPython shell.
     """
@@ -47,9 +47,10 @@ class SnapPyTerm(TkTerm, ListedWindow):
         self.main_window = self
         self.menu_title = 'SnapPy Shell'
         self.register_window(self)
-        TkTerm.__init__(self, shell, name='SnapPy Command Shell')
+        TkTerminalBase.__init__(self, shell, name='SnapPy Command Shell')
         self.settings = SnapPySettings(self)
         self.start_interaction()
+        self.interact_prompt()
         if sys.platform == 'darwin':
             assert str(self.window) == "."
             # Under OS X, the main window shouldn't be closable.
@@ -61,6 +62,34 @@ class SnapPyTerm(TkTerm, ListedWindow):
             self.window.tk.call('set', '::tk::dialog::file::showHiddenVar', '0')
         self.encoding = None
 
+    def start_interaction(self):
+        """
+        Display a banner and prepare to begin interaction.
+        """
+        snappy_path = os.path.abspath(os.path.dirname(__file__))
+        icon_file = os.path.join(snappy_path, 'info_icon.gif')
+        # Keep a reference to the icon.
+        self.icon = Tk_.PhotoImage(file=icon_file)
+
+        self.text.image_create(Tk_.END, image=self.icon)
+        banner_label = Tk_.Label(self.text, text=self.banner,
+                                 background='#ec0fffec0',
+                                 foreground='DarkGreen',
+                                 anchor=Tk_.W,
+                                 justify=Tk_.LEFT,
+                                 font=self.settings['font'].as_tuple())
+        self.text.window_create(Tk_.END, window=banner_label)
+        self.text.insert(Tk_.END, '\n')
+        self.text.mark_set('output_end', '2.0')
+        # Set a reasonable default directory for files to be saved to.
+        try:
+            home = os.environ['HOME']
+        except KeyError:
+            home = os.path.expanduser("~")
+        desktop = os.path.join(home, "Desktop")
+        default_save_dir = desktop if os.path.exists(desktop) else home
+        self.IP.magics_manager.magics['line']['cd']("-q " + default_save_dir)
+
     def add_bindings(self):
         self.window.bind('<<Paste>>', self.edit_paste)
 
@@ -237,8 +266,10 @@ class SnapPyBrowser(Browser, ListedWindow):
         self.dirichlet_viewer.help_button.configure(command=self.dirichlet_help)
 
     def close(self, event=None):
+        terminal.window.focus_force()
         self.unregister_window(self)
-        self.destroy()
+        self.withdraw()
+        self.after(100, self.destroy)
 
     def apply_settings(self):
         if self.inside_view:
@@ -359,8 +390,9 @@ class SnapPyPolyhedronViewer(PolyhedronViewer):
     def help_window(self):
         window = self.parent
         if not hasattr(window, 'polyhedron_help'):
-            window.polyhedron_help = InfoWindow(window,  'Polyhedron Viewer Help',
-                                                self.widget.help_text, 'polyhedron_help')
+            window.polyhedron_help = InfoWindow(
+                window, 'Polyhedron Viewer Help',
+                self.widget.help_text, 'polyhedron_help')
         else:
             window.polyhedron_help.deiconify()
             window.polyhedron_help.lift()
@@ -394,7 +426,7 @@ class SnapPyInsideViewer(InsideViewer):
 class SnapPySettings(Settings, ListedWindow):
     def __init__(self, terminal):
         self.terminal = terminal
-        Settings.__init__(self, terminal.text)
+        Settings.__init__(self)
         self.apply_settings()
 
     def apply_settings(self):
@@ -402,16 +434,10 @@ class SnapPySettings(Settings, ListedWindow):
         changed = self.changed()
         IP = self.terminal.IP
         self.terminal.quiet = True
-        if 'autocall' in changed:
-            if self.setting_dict['autocall']:
-                IP.magics_manager.magics['line']['autocall'](2)
-            else:
-                IP.magics_manager.magics['line']['autocall'](0)
-        if 'automagic' in changed:
-            if self.setting_dict['automagic']:
-                IP.magics_manager.magics['line']['automagic']('on')
-            else:
-                IP.magics_manager.magics['line']['automagic']('off')
+        if self.setting_dict['autocall']:
+            IP.magics_manager.magics['line']['autocall']('2')
+        else:
+            IP.magics_manager.magics['line']['autocall']('0')
         self.terminal.quiet = False
         for window in self.window_list:
             window.apply_settings()
@@ -477,18 +503,19 @@ def set_icon(window):
     if sys.platform == 'win32':
         try:
             import snappy
-            ico = os.path.join(os.path.dirname(snappy.__file__), 'SnapPy.ico')
+            ico = os.path.join(os.path.dirname(__file__), 'SnapPy.ico')
             window.iconbitmap(default=ico)
         except:
             pass
     if sys.platform == 'darwin':
         if not sys.executable.endswith('SnapPy.app/Contents/MacOS/python'):
+            snappy_path = os.path.abspath(os.path.dirname(__file__))
+            icon_file = os.path.join(snappy_path, 'info_icon.gif')
             image_file = os.path.join(snappy_path, 'SnapPy.png')
             if os.path.exists(image_file):
                 dock_icon = Tk_.PhotoImage(file=image_file)
                 window.eval('wm iconphoto . -default %s' % dock_icon)
 
-
 # from multiprocessing import Process
 class SnapPyKernelServer():
     """
@@ -521,7 +548,9 @@ def main():
     terminal = SnapPyTerm()
     sys.stdout = terminal
     set_icon(terminal.window)
-    SnapPy_ns = dict([(x, getattr(snappy, x)) for x in snappy.__all__])
+    terminal.window.call('bind', 'TNotebook', '<Right>', '')
+    terminal.window.call('bind', 'TNotebook', '<Left>', '')
+    SnapPy_ns = {x: getattr(snappy, x) for x in snappy.__all__}
     # SnapPy_ns['kernel_server'] = kernel_server
     SnapPy_ns['exit'] = SnapPy_ns['quit'] = SnapPyExit()
     SnapPy_ns['pager'] = None
@@ -546,6 +575,27 @@ def main():
     LP.UI_callback = HP.UI_callback = terminal.SnapPea_callback
     # if not snappy.SnapPy._within_sage:
     #    snappy.pari.UI_callback = terminal.PARI_callback
+
+    """
+    Experimental optional Tk themes on linux.  You need to install
+    tksvg from source for Python 3.10 or newer like so::
+
+      sudo apt install cmake build-essential tcl-dev tk-dev python3-tk
+      python -m pip install scikit-build
+      git clone --recursive https://github.com/TkinterEP/python-tksvg.git
+      cd python-tksvg
+      python -m pip install .
+
+    then you can do::
+
+      python -m pip install python-awthemes
+
+    and uncomment the next four lines.
+    """
+    # terminal.window.call('tk', 'scaling', 2.0)  # Not sure this actually does anything
+    # import awthemes
+    # style = awthemes.AwthemesStyle(terminal.window)
+    # style.theme_use('awbreeze')
     terminal.window.lift()
     terminal.window.mainloop()
     # kernel_server.stop()

snappy/browser.py

@@ -190,9 +190,8 @@ class Browser(Tk_.Toplevel):
         self.protocol("WM_DELETE_WINDOW", self.close)
         if sys.platform == 'darwin':
             self.bind_all('<Command-Key-w>', self.close)
-        elif sys.platform == 'linux2' or sys.platform == 'linux':
+        elif sys.platform == 'linux':
             self.bind_all('<Alt-Key-F4>', self.close)
-
         self.side_panel = side_panel = self.build_side_panel()
 
         self.notebook = notebook = ttk.Notebook(self)
@@ -224,7 +223,7 @@ class Browser(Tk_.Toplevel):
         notebook.add(invariants_tab, text='Invariants', padding=[0])
         notebook.add(self.dirichlet_viewer, text='Dirichlet')
         notebook.add(self.horoball_viewer, text='Cusp Nbhds')
-        notebook.add(self.build_inside_view(), text='Inside view')
+        notebook.add(self.build_inside_view(), text='Inside View')
         notebook.add(symmetry_tab, text='Symmetry', padding=[0])
         if link_tab:
             notebook.add(link_tab.canvas, text='Link')
@@ -240,6 +239,9 @@ class Browser(Tk_.Toplevel):
         self.modeline.pack(fill=Tk_.BOTH, expand=True, padx=30)
         self.update_modeline()
         self.update_idletasks()
+        self.wm_geometry(self.wm_geometry())
+        # Make sure the invariants get computed, even on Windows.
+        self.after_idle(self.update_current_tab)
 
     def __repr__(self):
         return 'Browser window for %s\n' % self.manifold
@@ -345,7 +347,7 @@ class Browser(Tk_.Toplevel):
         self.aka_viewer = aka_viewer = ttk.Treeview(
             self.aka,
             selectmode='none',
-            height=4,
+            height=2 if sys.platform == 'linux' else 4,
             columns=['manifold', 'as_link'],
             show='headings')
         aka_viewer.heading('manifold', text='Manifold')
@@ -505,6 +507,8 @@ class Browser(Tk_.Toplevel):
         elif tab_name == 'Link':
             self.update_menus(self.menubar)
             self.link_tab.draw()
+        elif tab_name == 'Inside View':
+            self.inside_view.widget.focus_set()
         elif tab_name == 'Symmetry':
             self.update_menus(self.menubar)
             self.update_symmetry()
@@ -538,8 +542,8 @@ class Browser(Tk_.Toplevel):
         except ValueError:
             self.homology.set('')
         self.compute_pi_one()
-        self.update_length_spectrum()
         self.update_dirichlet()
+        self.update_length_spectrum()
         self.update_aka()
         self.recompute_invariants = False
 
@@ -752,12 +756,13 @@ class Browser(Tk_.Toplevel):
     def horoball_help(self):
         self.horoball_viewer.widget.help()
 
-    def test(self):
+    def test(self, use_modernopengl=True):
         self.update_idletasks()
         print('Testing browser')
         self.after(1000, self.notebook.select, self.dirichlet_viewer)
         self.after(2500, self.notebook.select, self.horoball_viewer)
-        self.after(4000, self.notebook.select, self.inside_view)
+        if use_modernopengl:
+            self.after(4000, self.notebook.select, self.inside_view)
         if self.link_tab:
             self.after(5500, self.notebook.select, self.link_tab.canvas)
             self.after(7000, self.close)
@@ -781,7 +786,7 @@ class Driller(SimpleDialog):
         top_frame = ttk.Frame(self.root)
         top_frame.grid_columnconfigure(0, weight=1)
         top_frame.grid_rowconfigure(2, weight=1)
-        msg_font = Font(family=style.font_info['family'],
+        msg_font = dict(family=style.font_info['family'],
                         weight='bold',
                         size=int(style.font_info['size']*1.2))
         msg = ttk.Label(top_frame, font=msg_font,
@@ -877,16 +882,15 @@ class Coverer(SimpleDialog):
         top_frame.grid_rowconfigure(2, weight=1)
         top_frame.grid_columnconfigure(0, weight=1)
         top_frame.grid_columnconfigure(1, weight=1)
-        msg_font = Font(family=style.font_info['family'],
+        msg_font = dict(family=style.font_info['family'],
                         weight='bold',
                         size=int(style.font_info['size']*1.2))
         msg = ttk.Label(top_frame, font=msg_font,
                         text='Choose covering spaces to browse:')
         msg.grid(row=0, column=0, columnspan=3, pady=10)
         degree_frame = ttk.Frame(top_frame)
-        degree_frame.grid_columnconfigure(1, weight=1)
+        degree_frame.grid_columnconfigure(2, weight=1)
         self.degree_var = degree_var = Tk_.StringVar()
-        degree_var.trace('w', self.show_covers)
         ttk.Label(degree_frame, text='Degree: ').grid(
             row=0, column=0, sticky=Tk_.E)
         self.degree_option = degree_option = ttk.OptionMenu(
@@ -897,15 +901,11 @@ class Coverer(SimpleDialog):
             )
         degree_option.grid(row=0, column=1)
         self.cyclic_var = cyclic_var = Tk_.BooleanVar()
-        cyclic_var.trace('w', self.show_covers)
         cyclic_or_not = ttk.Checkbutton(degree_frame,
                                         variable=cyclic_var,
                                         text='cyclic covers only',
                                        )
         cyclic_or_not.grid(row=0, column=2, padx=6, sticky=Tk_.W)
-        self.action = action = ttk.Button(degree_frame, text='Recompute',
-                                          command=self.show_covers)
-        action.grid(row=0, column=3, padx=8, sticky=Tk_.W)
         degree_frame.grid(row=1, column=0, pady=2, padx=6, sticky=Tk_.EW)
         self.covers = covers = ttk.Treeview(
             top_frame,
@@ -941,17 +941,18 @@ class Coverer(SimpleDialog):
         degree_var.set('2')
         cyclic_var.set(True)
         self.show_covers()
+        degree_var.trace_add('write', self.show_covers)
+        cyclic_var.trace_add('write', self.show_covers)
+
 
     def clear_list(self, *args):
         self.covers.delete(*self.covers.get_children())
         self.browse.config(default='normal')
-        self.action.config(default='active')
         self.state = 'not ready'
 
     def show_covers(self, *args):
         self.state = 'ready'
         self.browse.config(default='active')
-        self.action.config(default='normal')
         self.covers.delete(*self.covers.get_children())
         degree = int(self.degree_var.get())
         if self.cyclic_var.get():

snappy/canonical.py

@@ -0,0 +1,249 @@
+from . import verify
+from . import Triangulation, TriangulationHP, Manifold, ManifoldHP
+
+from typing import Optional, Union, Sequence, Tuple
+
+__all__ = ['canonical_retriangulation', 'canonical_retriangulation_hp']
+
+def _canonical_retriangulation(
+        manifold : Union[Manifold, ManifoldHP],
+        verified : bool,
+        interval_bits_precs : Sequence[int],
+        exact_bits_prec_and_degrees : Sequence[Tuple[int, int]],
+        verbose : bool) -> Union[Triangulation, TriangulationHP,
+                                 Manifold, ManifoldHP]:
+    """
+    Returns a triangulation canonically associated to the hyperbolic manifold.
+    That is, the triangulation is (up to combinatorial isomorphism relabeling
+    the tetrahedra and vertices) completely determined by the isometry type of
+    the hyperbolic manifold.
+
+    Manifolds with incomplete cusps are rejected (unlike in the case of
+    :meth:`isometry_signature <snappy.Manifold.isometry_signature>`).
+
+    We now describe the canonical retriangulation. If all cells of
+    the canonical cell decomposition (defined by `Epstein and Penner '88
+    <https://projecteuclid.org/euclid.jdg/1214441650>`_) are tetrahedral,
+    :meth:`canonical_retriangulation <Manifold.canonical_retriangulation>`
+    simply returns that ideal triangulation as a
+    :class:`Manifold <snappy.Manifold>`. Here is an example::
+
+       >>> M = Manifold("m015")
+       >>> K = M.canonical_retriangulation()
+       >>> K.has_finite_vertices()
+       False
+       >>> K.solution_type()
+       'all tetrahedra positively oriented'
+
+    If there are non-tetrahedral cells,
+    :meth:`canonical_retriangulation <Manifold.canonical_retriangulation>`
+    subdivides the canonical cell decomposition. It introduces a finite vertex
+    for each canonical cell resulting in a
+    :class:`Triangulation <snappy.Triangulation>`. Here is an example where the
+    canonical cell is a cube::
+
+       >>> M = Manifold("m412")
+       >>> K = M.canonical_retriangulation()
+       >>> K.has_finite_vertices()
+       True
+
+    The canonical retriangulation can be used to find the symmetries of a
+    single manifold. It also can compute the isometries between two
+    manifolds. We do this using
+    :meth:`isomorphisms_to <snappy.Triangulation.isomorphisms_to>`::
+
+       >>> M = Manifold("5_2").canonical_retriangulation()
+       >>> N = Manifold("m015").canonical_retriangulation()
+       >>> M.isomorphisms_to(M) #doctest: +ELLIPSIS
+       [0 -> 0
+       [1 0]
+       [0 1]
+       ...
+       >>> M.isomorphisms_to(N) #doctest: +ELLIPSIS
+       [0 -> 0
+       [-1  2]
+       [ 0 -1]
+       ...
+
+    The canonical retriangulation is also the basis for the
+    :meth:`isometry_signature <snappy.Manifold.isometry_signature>`.
+
+    **Subdivision**
+
+    If the canonical cell decomposition has a non-tetrahedral cell, the method
+    subdivides. You can think of the subdivision in either of the following
+    (equivalent) ways:
+
+    - A coarsening of the barycentric subdivision with only a quarter of the
+      number of tetrahedra. That is, take the barycentric subdivision and
+      merge the four tetrahedra adjacent to a barycentric edge connecting
+      an edge midpoint to a face midpoint.
+    - Taking the double suspension of each face (which is an ideal n-gon)
+      about the centers of the two neighboring 3-cells. Then split each
+      such topological "lens" into n tetrahedra along its central axis.
+
+    **Verified computations**
+
+    While the canonical retriangulation is combinatorial, some intermediate
+    computations are numerical. Thus, if :attr:`verified = False`,
+    floating-point issues can arise.
+    (Arguably this gave rise to a mistake in the
+    non-orientable census. ``x101`` and ``x103`` were later identified as
+    the same by `Burton '14 <http://arxiv.org/abs/1311.7615>`_.)
+
+    The method can be made :ref:`verified <verify-primer>` by passing
+    :attr:`verified = True`::
+
+      sage: M = Manifold("v2986")
+      sage: K = M.canonical_retriangulation(verified = True)
+      sage: K.has_finite_vertices() # Cell decomposition verified to be tetrahedral
+      False
+      sage: K.triangulation_isosig(decorated=False) # Verified isometry signature.
+      'jvLALQQdeefgihihiokcmmwwswg'
+      sage: len(K.isomorphisms_to(K)) # Verified to have no (non-trivial) symmetries.
+      1
+
+    Interval arithmetic can only be used to verify the canonical cell decomposition
+    if all cells are tetrahedral. For non-tetrahedral cells, the method
+    automatically switches to
+    exact methods to verify the canonical cell decomposition. That is, it uses
+    snap-like methods
+    (`LLL-algorithm <http://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm>`_)
+    to guess a representation of the
+    shapes in the shape field. It then uses exact arithmetic to verify the
+    shapes form a valid geometric structure and compute the necessary tilts
+    to verify the canonical cell decomposition. Note that this can take a
+    long time!
+
+    Here is an example where exact methods are used::
+
+      sage: M = Manifold("m412")
+      sage: K = M.canonical_retriangulation(verified = True)
+      sage: K.has_finite_vertices() # Has non-tetrahedral cell
+      True
+
+    If the canonical retriangulation cannot be verified, an exception will be
+    raised. (Note that this is new (and safer) in Version 3.2. Prior to that
+    version, :meth:`Manifold.canonical_retriangulation` could return ``None``
+    instead.)
+
+    Here is an example where we skip the (potentially lengthy) exact methods
+    needed to verify a non-tetrahedral cell. The method fails (early
+    and with an exception) since the cells are actually tetrahedral::
+
+      sage: M = Manifold("m412")
+      sage: K = M.canonical_retriangulation(verified = True, exact_bits_prec_and_degrees = []) # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
+      Traceback (most recent call last):
+      ...
+      snappy.verify.exceptions.TiltInequalityNumericalVerifyError: Numerical verification that tilt is negative has failed: ... < 0
+
+    :param verified:
+            Use :ref:`verified computation <verify-primer>`.
+    :param interval_bits_precs:
+            Only relevant if :attr:`verified = True`.
+            A list of (increasing) precisions used to try to
+            certify the canonical cell decomposition using intervals. Each
+            precision is tried until we succeed. If none succeeded, we move on
+            to exact methods.
+    :param exact_bits_prec_and_degrees:
+            Only relevant if :attr:`verified = True`.
+            A list of pairs (precision, max degree) used when the
+            LLL-algorithm is trying to find the defining
+            polynomial of the shape field with
+            ``ListOfApproximateAlgebraicNumbers.find_field``.
+            Each pair is tried until we succeed.
+    :param verbose:
+            Print information about the methods tried to compute and verify the
+            canonical retriangulation.
+    :return:
+            If the canonical cell decomposition exists entirely of
+            (hyperbolic ideal) tetrahedra, a :class:`Manifold` with those
+            tetrahedra.
+            Otherwise, a :class:`Triangulation` that is a subdivision of the
+            canonical cell decomposition.
+    """
+
+    # More information on the canonical retriangulation can be found in the
+    # SnapPea kernel ``canonize_part_2.c`` and in Section 3.1 of
+    # `Fominykh, Garoufalidis, Goerner, Tarkaev, Vesnin <http://arxiv.org/abs/1502.00383>`_.
+
+    if not all(manifold.cusp_info('complete?')):
+        # It is unclear what to do when there are filling coefficients.
+        # The SnapPea kernel ignores them and uses the complete structure
+        # to compute the canonical retriangulation.
+        #
+        # That makes sense to, e.g., compute a canonical representation
+        # of a surgery diagram.
+        #
+        # In other situations, it makes perfectly sense to fill the cusps
+        # instead. That is, e.g., what the isometry_signature does.
+        #
+        # Since it is ambiguous, I decided to simply reject it here.
+        #
+        # It is easy enough for a user to either call fill_triangulation
+        # or to save the coefficients and unfill all cusps.
+        #
+        raise ValueError(
+            'Canonical retriangulation needs all cusps to be complete.')
+
+    if verified:
+        # verified_canonical_retriangulation has code to check
+        # for incomplete cusps and fill them that never gets
+        # executed because of the above "if"
+        return verify.verified_canonical_retriangulation(
+            manifold,
+            interval_bits_precs=interval_bits_precs,
+            exact_bits_prec_and_degrees=exact_bits_prec_and_degrees,
+            verbose=verbose)
+    else:
+        # Note that the SnapPea kernel actually ignores Dehn-fillings
+        # when computing the canonical retriangulation.
+        if not all(manifold.cusp_info('complete?')):
+            # Never executed because of above "if".
+            manifold = manifold.filled_triangulation()
+            if not all(manifold.cusp_info('complete?')):
+                raise ValueError(
+                    'Could not compute filled triangulation. '
+                    'Are the filling coefficients co-prime integers?')
+
+        K = manifold._canonical_retriangulation()
+        if K.has_finite_vertices():
+            return K
+        else:
+            if isinstance(manifold, ManifoldHP):
+                return ManifoldHP(K)
+            else:
+                return Manifold(K)
+
+# Wraps _canonical_retriangulation to have the correct return type
+def canonical_retriangulation(
+        manifold : Manifold,
+        verified : bool = False,
+        interval_bits_precs : Sequence[int] = verify.default_interval_bits_precs,
+        exact_bits_prec_and_degrees : Sequence[Tuple[int, int]] = verify.default_exact_bits_prec_and_degrees,
+        verbose : bool = False) -> Union[Triangulation, Manifold]:
+    return _canonical_retriangulation(
+        manifold,
+        verified = verified,
+        interval_bits_precs = interval_bits_precs,
+        exact_bits_prec_and_degrees = exact_bits_prec_and_degrees,
+        verbose = verbose)
+canonical_retriangulation.__doc__ = _canonical_retriangulation.__doc__
+            
+# Wraps _canonical_retriangulation to have the correct return type
+def canonical_retriangulation_hp(
+        manifold : ManifoldHP,
+        verified : bool = False,
+        interval_bits_precs : Sequence[int] = verify.default_interval_bits_precs,
+        exact_bits_prec_and_degrees : Sequence[Tuple[int, int]] = verify.default_exact_bits_prec_and_degrees,
+        verbose : bool = False) -> Union[TriangulationHP, ManifoldHP]:
+    return _canonical_retriangulation(
+        manifold,
+        verified = verified,
+        interval_bits_precs = interval_bits_precs,
+        exact_bits_prec_and_degrees = exact_bits_prec_and_degrees,
+        verbose = verbose)
+canonical_retriangulation_hp.__doc__ = _canonical_retriangulation.__doc__
+
+
+

snappy/{verify/cusp_shapes.py → cusps/__init__.py}

@@ -1,25 +1,15 @@
-from .cuspCrossSection import ComplexCuspCrossSection
-from .shapes import compute_hyperbolic_shapes
-
-__all__ = ['NonorientableManifoldError', 'compute_cusp_shapes']
-
-
-class NonorientableManifoldError(RuntimeError):
-    """
-    Exception raised when trying to compute cusp shapes for a non-orientable
-    manifold.
-    """
-    def __init__(self, manifold):
-        self.manifold = manifold
-
-    def __str__(self):
-        return (('Cannot compute cusp shapes for non-orientable '
-                 'manifold %s') % self.manifold)
+"""
+Computing data about cusps such as cusp matrix, shape, translations
+and exceptional slopes.
+"""
 
+from ..geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
+from ..verify.shapes import compute_hyperbolic_shapes
+from ..exceptions import NonorientableManifoldError
 
 def compute_cusp_shapes(manifold, verified, bits_prec=None):
     """
-    Compute verified cusp shapes (following the SnapPea kernel convention,
+    Compute cusp shapes. Following the SnapPea kernel convention,
     it returns the conjugate of the quotient of the translations
     corresponding to the longitude and meridian for each cusp.