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

snappy/{preferences.py → settings.py}

@@ -1,111 +1,122 @@
-import os, sys, re, time
-try:
-    import plistlib
-except ImportError:
-    from . import plistlib
+import os
+import sys
+import plistlib
 from .gui import *
-
-class Preferences:
-    def __init__(self, text_widget):
-        self.text_widget = text_widget
-        self.prefs_dict = {
+from .app_menus import ListedWindow
+from .tkterminal import FontChoice, default_terminal_font
+
+def clip_font_size(size):
+    try:
+        value = int(size)
+    except:
+        return 13 if sys.platform == 'darwin' else 11
+    if value < 10:
+        return 10
+    if value > 36:
+        return 36
+    return size
+
+class Settings:
+    def __init__(self):
+        self.setting_dict = {
             'autocall' : False,
-            'automagic' : False,
-            'font' : self.current_font_tuple(),
+            'font' : self.default_font(),
             'cusp_horoballs' : True,
             'cusp_triangulation' : True,
             'cusp_ford_domain' : True,
             'cusp_parallelogram' : True,
-            'cusp_labels' : True,
+            'cusp_labels' : False,
             'cusp_cutoff' : '0.1000',
             'keyboard' : 'QWERTY'}
         self.cache = {}
-        self.cache_prefs()
-        self.find_prefs()
-        self.read_prefs()
-        
+        self.cache_settings()
+        self.find_settings()
+        self.read_settings()
+
     def __getitem__(self, x):
-        return self.prefs_dict[x]
-    
+        return self.setting_dict[x]
+
     def __setitem__(self, x, y):
-        self.prefs_dict[x] = y
+        self.setting_dict[x] = y
 
     def __repr__(self):
-        return str(self.prefs_dict)
+        return str(self.setting_dict)
 
     def items(self):
-        return self.prefs_dict.items()
+        return self.setting_dict.items()
 
     def get(self, key, default):
-        return self.prefs_dict.get(key, default)
-
-    def current_font_dict(self):
-        font_string = self.text_widget.cget('font')
-        return Font(font=font_string).actual()
+        return self.setting_dict.get(key, default)
 
-    def current_font_tuple(self):
-        font = self.current_font_dict()
-        style = '%s %s'%(font['weight'], font['slant'])
-        return (font['family'], font['size'], style) 
+    def default_font(self):
+        return default_terminal_font()
 
-    def find_prefs(self):
+    def find_settings(self):
         if sys.platform == 'darwin':
             home = os.environ['HOME']
-            self.prefs_file = os.path.join(home, 'Library',
+            # File is 'Preferences' rather than 'Settings' for backwards
+            # compatibility.
+            self.setting_file = os.path.join(home, 'Library',
                                            'Preferences',
                                            'org.computop.SnapPy.plist')
         elif sys.platform == 'linux2' or sys.platform == 'linux':
             home = os.environ['HOME']
-            self.prefs_file = os.path.join(home, '.SnapPy.plist')
+            self.setting_file = os.path.join(home, '.SnapPy.plist')
         elif sys.platform == 'win32':
             home = os.environ['USERPROFILE']
-            self.prefs_file = os.path.join(home, '.SnapPy.plist')
+            self.setting_file = os.path.join(home, '.SnapPy.plist')
         else:
-            self.prefs_file = None
-
-    def read_prefs(self):
-        if self.prefs_file:
+            self.setting_file = None
+        
+    def read_settings(self):
+        if self.setting_file:
             try:
                 if hasattr(plistlib, 'load'):
-                    with open(self.prefs_file, 'rb') as prefs_file:
-                        self.prefs_dict.update(plistlib.load(prefs_file))
+                    with open(self.setting_file, 'rb') as setting_file:
+                        self.setting_dict.update(plistlib.load(setting_file))
                 else:
-                    self.prefs_dict.update(plistlib.readPlist(self.prefs_file))
-                # plistlib screws up tuples
-                self.prefs_dict['font'] = tuple(self.prefs_dict['font'])
-            except IOError:
+                    self.setting_dict.update(plistlib.readPlist(self.setting_file))
+                family, size, info = self.setting_dict['font']
+                # Guard against crazy values in the settings plist file.
+                size = clip_font_size(size)
+                weight, slant = info.split()
+                self.setting_dict['font'] = FontChoice(family, size, weight, slant)
+            except OSError:
                 pass
 
-    def write_prefs(self):
-        if self.prefs_file:
+    def write_settings(self):
+        if self.setting_file:
+            setting_dict = self.setting_dict.copy()
+            font = self.setting_dict['font']
+            setting_dict['font'] = (font.family, font.size, font.rest)
             if hasattr(plistlib, 'dump'):
-                with open(self.prefs_file, 'wb') as prefs_file:
-                    plistlib.dump(self.prefs_dict, prefs_file)
+                with open(self.setting_file, 'wb') as setting_file:
+                    plistlib.dump(setting_dict, setting_file)
             else:
-                plistlib.writePlist(self.prefs_dict, self.prefs_file)
+                plistlib.writePlist(setting_dict, self.setting_file)
 
-    def cache_prefs(self):
-        self.cache.update(self.prefs_dict)
+    def cache_settings(self):
+        self.cache.update(self.setting_dict)
 
-    def revert_prefs(self):
-        self.prefs_dict.update(self.cache)
-        self.apply_prefs()
+    def revert_settings(self):
+        self.setting_dict.update(self.cache)
+        self.apply_settings()
 
     def changed(self):
-        return [key for key in self.cache.keys() if 
-                self.cache[key] != self.prefs_dict[key]]
+        return [key for key in self.cache.keys() if
+                self.cache[key] != self.setting_dict[key]]
 
     # Override this in a subclass.
-    def apply_prefs(self):
-        self.text_widget.config(font=self.prefs_dict['font'])
-        print(self.prefs_dict)
+    def apply_settings(self):
+        print(self.setting_dict)
+
 
-class PreferenceDialog(Dialog):
-    def __init__(self, parent, prefs, title='SnapPy Preferences'):
+class SettingsDialog(Dialog):
+    def __init__(self, parent, settings, title='SnapPy Settings'):
         self.parent = parent
         self.style = SnapPyStyle()
-        self.prefs = prefs
-        self.prefs.cache_prefs()
+        self.settings = settings
+        self.settings.cache_settings()
         self.okay = False
         Tk_.Toplevel.__init__(self, master=parent, class_='snappy')
         frame = ttk.Frame(self, padding=(0, 10, 0, 0))
@@ -125,23 +136,26 @@ class PreferenceDialog(Dialog):
         frame.pack()
         self.button_frame.pack(fill=Tk_.X)
         self.protocol('WM_DELETE_WINDOW', self.cancel)
+        self.attributes('-topmost', True)
+
+    def run(self):
         self.wait_window(self)
 
     def validate(self):
         cutoff = self.cutoff.get()
         try:
             float(cutoff)
-            self.prefs['cusp_cutoff'] = cutoff 
+            self.settings['cusp_cutoff'] = cutoff
         except ValueError:
             showerror('Invalid input',
                       'Please enter a number for the cutoff.')
             return False
-        self.prefs.apply_prefs()
+        self.settings.apply_settings()
         self.okay = True
         return True
 
     def revert(self):
-        self.prefs.revert_prefs()
+        self.settings.revert_settings()
         self.cancel()
 
     def buttonbox(self):
@@ -152,7 +166,7 @@ class PreferenceDialog(Dialog):
                         default=Tk_.ACTIVE)
         OK.grid(row=0, column=0, sticky=Tk_.NE, padx=5)
         Apply = ttk.Button(box, text="Apply", width=10,
-                           command=self.prefs.apply_prefs)
+                           command=self.settings.apply_settings)
         Apply.grid(row=0, column=1, sticky=Tk_.N, padx=5)
         Cancel = ttk.Button(box, text="Cancel", width=10, command=self.revert)
         Cancel.grid(row=0, column=2, sticky=Tk_.NW, padx=5)
@@ -164,44 +178,50 @@ class PreferenceDialog(Dialog):
                              sticky=Tk_.N + Tk_.S + Tk_.W + Tk_.E)
         self.body_frame.focus_set()
 
-    def build_font_pane(self, master):
-        current_font = self.prefs.current_font_dict()
+    def build_font_pane(self, parent):
+        current_font = self.settings['font']
         groupBG = self.style.groupBG
-        self.font_frame = font_frame = ttk.Frame(master)
+        self.font_frame = font_frame = ttk.Frame(parent)
         font_frame.columnconfigure(2, weight=1)
         font_frame.columnconfigure(0, weight=1)
         self.list_frame = list_frame = ttk.Frame(font_frame)
         self.font_list = font_list = Tk_.Listbox(list_frame,
                                                  selectmode=Tk_.SINGLE)
-        self.families = families = [f for f in font_families()
-                                    if f[0] != '@'] # omit vertical fonts
-        families.sort()
-        for family in families:
-            font_list.insert(Tk_.END, family)
-        self.current_family = families.index(current_font['family'])
-        font_list.selection_set(self.current_family)
-        font_list.see(self.current_family)
         font_list.grid(row=0, column=0, pady=(20,30))
         font_scroller = ttk.Scrollbar(list_frame,
                                       command=font_list.yview)
         font_list.config(yscrollcommand=font_scroller.set)
         font_scroller.grid(row=0, column=1, sticky=Tk_.N + Tk_.S, pady=(20,30))
         list_frame.grid(rowspan=6, column=0)
-        
+
         label = ttk.Label(self.font_frame, text='Size: ')
         label.grid(row=0, column=1, sticky=Tk_.E, pady=(20,0))
         self.font_sizer = sizer = Spinbox(font_frame, from_=10, to_=36, width=4,
-                                             command=self.set_font_sample,
-                                             )
+                                          command=self.set_font_sample)
+        def check_font_size(size):
+            try:
+                value = int(size)
+            except:
+                sizer.set(13 if sys.platform == 'darwin' else 11)
+                return False
+            if value < 10:
+                sizer.set(10)
+                return False
+            if value > 36:
+                sizer.set(36)
+                return False
+            return True
+        validator = parent.register(check_font_size)
+        sizer.config(validate ="key", validatecommand =(validator, '%P'))
         sizer.delete(0,2)
-        sizer.insert(0, current_font['size'] )
+        sizer.insert(0, clip_font_size(current_font.size))
         sizer.bind('<Return>', self.set_font_sample)
         sizer.bind('<Tab>', self.set_font_sample)
-        self.current_size =  current_font['size']
+        self.current_size = current_font.size
         sizer.grid(row=0, column=2, sticky=Tk_.W, pady=(20,0))
         label = ttk.Label(font_frame, text='Weight: ')
         label.grid(row=1, column=1, sticky=Tk_.E)
-        self.font_weight = weight = Tk_.StringVar(value=current_font['weight'])
+        self.font_weight = weight = Tk_.StringVar(value=current_font.weight)
         radio = ttk.Radiobutton(font_frame, text='normal', variable=weight,
                                     value='normal', command=self.set_font_sample)
         radio.grid(row=1, column=2, sticky=Tk_.W)
@@ -210,25 +230,47 @@ class PreferenceDialog(Dialog):
         radio.grid(row=2, column=2, sticky=Tk_.W)
         label = ttk.Label(font_frame, text='Slant: ')
         label.grid(row=3, column=1, sticky=Tk_.E)
-        self.font_slant = slant = Tk_.StringVar(value=current_font['slant'])
+        self.font_slant = slant = Tk_.StringVar(value=current_font.slant)
         radio = ttk.Radiobutton(font_frame, text='roman', variable=slant,
                                  value='roman', command=self.set_font_sample)
         radio.grid(row=3, column=2, sticky=Tk_.W)
         radio = ttk.Radiobutton(font_frame, text='italic', variable=slant,
                                     value='italic', command=self.set_font_sample)
         radio.grid(row=4, column=2, sticky=Tk_.W)
-        self.sample = sample = Tk_.Text(self.font_frame,
+
+        self.fixed_only =  Tk_.BooleanVar(value=True)
+        self.check_fixed = ttk.Checkbutton(font_frame, variable=self.fixed_only,
+                                           text='Fixed-width fonts only',
+                                           command=self.set_font_families)
+        self.check_fixed.grid(row=6, column=0, pady=(0, 10), sticky=Tk_.N)
+        self.sample = sample = Tk_.Text(font_frame,
                                         width=40, height=6,
                                         highlightthickness=0,
                                         relief=Tk_.FLAT,
-                                        font=self.prefs['font'])
+                                        font=self.settings['font'].as_tuple())
         self.sample.bind('<Button-1>', lambda event: 'break')
         self.sample.insert(Tk_.INSERT, '\nABCDEFGHIJKLMNOPQRSTUVWXYZ\n'
                            'abcdefghijklmnopqrstuvwxyz')
         sample.tag_add('all', '1.0', Tk_.END)
-        self.set_font_sample()
         font_list.bind('<ButtonRelease-1>', self.set_font_sample)
-        self.sample.grid(row=6, columnspan=4, padx=10, pady=10, sticky=Tk_.E+Tk_.W)
+        self.sample.grid(row=7, columnspan=4, padx=10, pady=10, sticky=Tk_.E+Tk_.W)
+        self.set_font_families()
+        self.set_font_sample()
+
+    def set_font_families(self):
+        families = {f for f in font_families()
+                    if f[0] != '@' and f.lower().find('emoji') < 0} # omit vertical fonts, emojis
+        if self.fixed_only.get():
+            families = {f for f in families if Font(family=f).metrics('fixed')}
+        families.add(self.settings['font'].family)
+        self.families = families = sorted(families)
+        if self.font_list.size() > 0:
+            self.font_list.delete(0, self.font_list.size() - 1)
+        for family in families:
+            self.font_list.insert(Tk_.END, family)
+        self.current_family = families.index(self.settings['font'].family)
+        self.font_list.selection_set(self.current_family)
+        self.font_list.see(self.current_family)
 
     def get_font(self):
         selection = self.font_list.curselection()
@@ -245,21 +287,20 @@ class PreferenceDialog(Dialog):
             self.font_sizer.delete(0, Tk_.END)
             self.font_sizer.insert(0, str(size))
         self.font_list.selection_set(self.current_family)
-        style = '%s %s'%(self.font_weight.get(), self.font_slant.get())
-        return (family, size, style.strip()) 
+        return FontChoice(family, size,
+                          self.font_weight.get(), self.font_slant.get())
 
     def set_font_sample(self, event=None):
         new_font = self.get_font()
-        self.prefs['font'] = new_font
+        self.settings['font'] = new_font
         self.sample.tag_config('all', justify=Tk_.CENTER,
-                               font=new_font) 
+                               font=new_font.as_tuple())
 
-    def build_shell_pane(self, master):
+    def build_shell_pane(self, parent):
         groupBG = self.style.groupBG
-        self.autocall = Tk_.BooleanVar(value=self.prefs['autocall'])
-        self.automagic = Tk_.BooleanVar(value=self.prefs['automagic'])
+        self.autocall = Tk_.BooleanVar(value=self.settings['autocall'])
         self.update_idletasks()
-        self.shell_frame = shell_frame = ttk.Frame(master)
+        self.shell_frame = shell_frame = ttk.Frame(parent)
         shell_frame.rowconfigure(3, weight=1)
         shell_frame.columnconfigure(0, weight=1)
         shell_frame.columnconfigure(3, weight=1)
@@ -269,30 +310,24 @@ class PreferenceDialog(Dialog):
         next_label = ttk.Label(shell_frame, anchor=Tk_.W,
             text='Which IPython features would you like to enable?')
         next_label.grid(row=0, column=1, columnspan=2, sticky=Tk_.W, pady=(20,0))
-        next_check = ttk.Checkbutton(shell_frame, variable = self.autocall,
+        next_check = ttk.Checkbutton(shell_frame, variable=self.autocall,
                                     text='IPython autocall',
                                     command=self.set_autocall)
         next_check.grid(row=1, column=1, sticky=Tk_.W, pady=(10,0))
-        next_check = ttk.Checkbutton(shell_frame, variable = self.automagic,
-                                    text='IPython automagic',
-                                    command=self.set_automagic)
         next_check.grid(row=2, column=1, sticky=Tk_.W, pady=(5,0))
 
     def set_autocall(self):
-        self.prefs['autocall'] = self.autocall.get()
+        self.settings['autocall'] = self.autocall.get()
 
-    def set_automagic(self):
-        self.prefs['automagic'] = self.automagic.get()
-
-    def build_cusp_pane(self, master):
+    def build_cusp_pane(self, parent):
         groupBG = self.style.groupBG
-        self.cusp_frame = cusp_frame = ttk.Frame(master)
-        self.horoballs = Tk_.BooleanVar(value=self.prefs['cusp_horoballs'])
-        self.triangulation = Tk_.BooleanVar(value=self.prefs['cusp_triangulation'])
-        self.ford = Tk_.BooleanVar(value=self.prefs['cusp_ford_domain'])
-        self.labels = Tk_.BooleanVar(value=self.prefs['cusp_labels'])
-        self.parallelogram = Tk_.BooleanVar(value=self.prefs['cusp_parallelogram'])
-        self.cutoff = Tk_.StringVar(value=self.prefs['cusp_cutoff'])
+        self.cusp_frame = cusp_frame = ttk.Frame(parent)
+        self.horoballs = Tk_.BooleanVar(value=self.settings['cusp_horoballs'])
+        self.triangulation = Tk_.BooleanVar(value=self.settings['cusp_triangulation'])
+        self.ford = Tk_.BooleanVar(value=self.settings['cusp_ford_domain'])
+        self.labels = Tk_.BooleanVar(value=self.settings['cusp_labels'])
+        self.parallelogram = Tk_.BooleanVar(value=self.settings['cusp_parallelogram'])
+        self.cutoff = Tk_.StringVar(value=self.settings['cusp_cutoff'])
         self.update_idletasks()
         cusp_frame.rowconfigure(8, weight=1)
         cusp_frame.columnconfigure(0, weight=1)
@@ -303,23 +338,23 @@ class PreferenceDialog(Dialog):
                                text='Which elements should be visible when you first '
                                'view the cusp neighborhood?')
         next_label.grid(row=0, column=1, columnspan=2, sticky=Tk_.W, pady=(20,10))
-        next_check = ttk.Checkbutton(cusp_frame, variable = self.horoballs,
+        next_check = ttk.Checkbutton(cusp_frame, variable=self.horoballs,
                                      text='Horoballs',
                                      command=self.set_horoballs)
         next_check.grid(row=1, column=1, sticky=Tk_.W, padx=(30, 0))
-        next_check = ttk.Checkbutton(cusp_frame, variable = self.triangulation,
+        next_check = ttk.Checkbutton(cusp_frame, variable=self.triangulation,
                                      text='Triangulation',
                                      command=self.set_triangulation)
         next_check.grid(row=2, column=1, sticky=Tk_.W, padx=(30, 0))
-        next_check = ttk.Checkbutton(cusp_frame, variable = self.ford,
+        next_check = ttk.Checkbutton(cusp_frame, variable=self.ford,
                                      text='Ford domain',
                                      command=self.set_ford)
         next_check.grid(row=3, column=1, sticky=Tk_.W, padx=(30, 0))
-        next_check = ttk.Checkbutton(cusp_frame, variable = self.labels,
+        next_check = ttk.Checkbutton(cusp_frame, variable=self.labels,
                                      text='Labels',
                                      command=self.set_labels)
         next_check.grid(row=4, column=1, sticky=Tk_.W, padx=(30, 0))
-        next_check = ttk.Checkbutton(cusp_frame, variable = self.parallelogram,
+        next_check = ttk.Checkbutton(cusp_frame, variable=self.parallelogram,
                                      text='Parallelogram',
                                      command=self.set_parallelogram)
         next_check.grid(row=5, column=1, sticky=Tk_.W, padx=(30, 0))
@@ -331,24 +366,24 @@ class PreferenceDialog(Dialog):
                           pady=(0,10), padx=(30,0))
 
     def set_horoballs(self):
-        self.prefs['cusp_horoballs'] = self.horoballs.get()
+        self.settings['cusp_horoballs'] = self.horoballs.get()
 
     def set_triangulation(self):
-        self.prefs['cusp_triangulation'] = self.triangulation.get()
+        self.settings['cusp_triangulation'] = self.triangulation.get()
 
     def set_ford(self):
-        self.prefs['cusp_ford_domain'] = self.ford.get()
+        self.settings['cusp_ford_domain'] = self.ford.get()
 
     def set_labels(self):
-        self.prefs['cusp_labels'] = self.labels.get()
+        self.settings['cusp_labels'] = self.labels.get()
 
     def set_parallelogram(self):
-        self.prefs['cusp_parallelogram'] = self.parallelogram.get()
+        self.settings['cusp_parallelogram'] = self.parallelogram.get()
 
-    def build_inside_pane(self, master):
+    def build_inside_pane(self, parent):
         groupBG = self.style.groupBG
-        self.keyboard = Tk_.Variable(value=self.prefs['keyboard'])
-        self.inside_frame = frame = ttk.Frame(master)
+        self.keyboard = Tk_.Variable(value=self.settings['keyboard'])
+        self.inside_frame = frame = ttk.Frame(parent)
         frame.rowconfigure(3, weight=1)
         frame.columnconfigure(0, weight=1)
         frame.columnconfigure(3, weight=1)
@@ -363,25 +398,12 @@ class PreferenceDialog(Dialog):
         keyboard_button.grid(row=1, column=1, columnspan=2, sticky=Tk_.W, pady=(10, 0))
 
     def set_keyboard(self, value):
-        self.prefs['keyboard'] = value
+        self.settings['keyboard'] = value
+
 
 if __name__ == '__main__':
     parent = Tk_.Tk(className='snappy')
-    text_widget = Tk_.Text(parent)
-    text_widget.insert(Tk_.INSERT, """
-Lorem ipsum dolor sit amet, consectetur adipisicing
-elit, sed do eiusmod tempor incididunt ut labore et
-dolore magna aliqua. Ut enim ad minim veniam, quis
-nostrud exercitation ullamco laboris nisi ut aliquip
-ex ea commodo consequat. Duis aute irure dolor in
-reprehenderit in voluptate velit esse cillum dolore
-eu fugiat nulla pariatur. Excepteur sint occaecat
-cupidatat non proident, sunt in culpa qui officia
-deserunt mollit anim id est laborum.""")
-    text_widget.tag_add('all', '1.0', Tk_.END)
-    text_widget.tag_config('all', lmargin1=20, lmargin2=20)
-    text_widget.pack()
-    prefs = Preferences(text_widget)
-    prefs.apply_prefs()
-    PreferenceDialog(parent, prefs)
+    settings = Settings()
+    settings.apply_settings()
+    SettingsDialog(parent, settings)
     parent.mainloop()

snappy/shell.py

@@ -6,6 +6,7 @@ try:
 except ImportError:
     from IPython.frontend.terminal.embed import InteractiveShellEmbed
 
+
 class SnapPyPromptDisplayHook(DisplayHook):
     """
     A DisplayHook used when displaying SnapPy's output prompts.  This
@@ -28,6 +29,7 @@ class SnapPyPromptDisplayHook(DisplayHook):
             for token, text in tokens:
                 output.write(text, style=(token[0],))
 
+
 class SnapPyInteractiveShellEmbed(InteractiveShellEmbed):
     """
     An embedded IPython shell which can use a TkTerm for all of its
@@ -38,6 +40,8 @@ class SnapPyInteractiveShellEmbed(InteractiveShellEmbed):
     colors_force = True
     separate_out = '\n'
     separate_in = ''
+    show_rewritten_input = False
+    pt_app = None
 
     def __init__(self, *args, **kwargs):
         super(InteractiveShellEmbed, self).__init__(*args, **kwargs)

snappy/snap/__init__.py

@@ -2,11 +2,12 @@ from .shapes import polished_tetrahedra_shapes
 from ..sage_helper import _within_sage, sage_method
 from .polished_reps import polished_holonomy
 from . import nsagetools, interval_reps, slice_obs_HKL
-from .character_varieties import  character_variety, character_variety_ideal
+from .character_varieties import character_variety, character_variety_ideal
 
 if _within_sage:
     from .find_field import ListOfApproximateAlgebraicNumbers
 
+
 @sage_method
 def tetrahedra_field_gens(manifold):
     """
@@ -26,12 +27,14 @@ def tetrahedra_field_gens(manifold):
             return polished_tetrahedra_shapes(manifold, bits_prec=prec)
     else:
         double_cover = manifold.orientation_cover()
+
         def func(prec):
             return polished_tetrahedra_shapes(double_cover, bits_prec=prec)[::2]
     return ListOfApproximateAlgebraicNumbers(func)
 
+
 @sage_method
-def trace_field_gens(manifold, fundamental_group_args = []):
+def trace_field_gens(manifold, fundamental_group_args=[]):
     """
     The generators of the trace field as ApproximateAlgebraicNumbers. Can be
     used to compute the tetrahedra field, where the first two parameters
@@ -49,8 +52,9 @@ def trace_field_gens(manifold, fundamental_group_args = []):
                                  fundamental_group_args).trace_field_generators()
     return ListOfApproximateAlgebraicNumbers(func)
 
+
 @sage_method
-def invariant_trace_field_gens(manifold, fundamental_group_args = []):
+def invariant_trace_field_gens(manifold, fundamental_group_args=[]):
     """
     The generators of the trace field as ApproximateAlgebraicNumbers. Can be
     used to compute the tetrahedra field, where the first two parameters
@@ -67,11 +71,11 @@ def invariant_trace_field_gens(manifold, fundamental_group_args = []):
                                  fundamental_group_args).invariant_trace_field_generators()
     return ListOfApproximateAlgebraicNumbers(func)
 
+
 @sage_method
 def holonomy_matrix_entries(manifold,
-                            fundamental_group_args = [],
-                            match_kernel = True):
-
+                            fundamental_group_args=[],
+                            match_kernel=True):
     """
     The entries of the matrices of the holonomy as list of ApproximateAlgebraicNumbers
     (four consecutive numbers per matrix). The numbers are guaranteed to lie in the
@@ -89,8 +93,8 @@ def holonomy_matrix_entries(manifold,
     def func(prec):
         G = polished_holonomy(manifold,
                               prec,
-                              fundamental_group_args = fundamental_group_args,
-                              match_kernel = match_kernel)
+                              fundamental_group_args=fundamental_group_args,
+                              match_kernel=match_kernel)
         return sum( [G.SL2C(g).list() for g in G.generators()], [])
     return ListOfApproximateAlgebraicNumbers(func)