snappy 3.1.1__cp38-cp38-win_amd64.whl → 3.2__cp38-cp38-win_amd64.whl

snappy/tiling/test.py

@@ -0,0 +1,23 @@
+from snappy import testing
+import snappy
+
+from snappy import tiling
+
+modules = [
+    tiling.floor,
+    tiling.real_hash_dict,
+    tiling.canonical_key_dict,
+    tiling.dict_based_set
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold': snappy.Manifold}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = tiling.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/tiling/tile.py

@@ -0,0 +1,215 @@
+from .lifted_tetrahedron import LiftedTetrahedron
+from .lifted_tetrahedron_set import (LiftedTetrahedronSet,
+                                     get_lifted_tetrahedron_set)
+
+from ..hyperboloid.distances import lower_bound_distance_to_r13_triangle
+from ..hyperboloid.triangle import R13IdealTriangle
+from ..hyperboloid import o13_inverse
+from ..snap.t3mlite import Mcomplex, Tetrahedron, simplex
+from ..math_basics import is_RealIntervalFieldElement, lower # type: ignore
+from ..sage_helper import _within_sage # type: ignore
+
+if _within_sage:
+    from ..sage_helper import Infinity
+
+import heapq
+    
+from typing import Sequence, Union
+
+class Tile:
+    def __init__(self,
+                 lower_bound_distance,
+                 inverse_lifted_geometric_object,
+                 lifted_tetrahedron : LiftedTetrahedron,
+                 object_index = None):
+        self.lower_bound_distance = lower_bound_distance
+        self.inverse_lifted_geometric_object = inverse_lifted_geometric_object
+        self.lifted_tetrahedron = lifted_tetrahedron
+        # Used in maximal_cusp_area_matrix
+        self.object_index = object_index
+
+def compute_tiles(*, # Everything is a keyword argument
+                  geometric_object,
+                  visited_lifted_tetrahedra : LiftedTetrahedronSet,
+                  initial_lifted_tetrahedra : Sequence[LiftedTetrahedron],
+                  replace_lifted_tetrahedron_function = None,
+                  verified : bool
+                  ) -> Sequence[Tile]:
+
+    """
+    Returns a stream of tiles where each tile is a tetrahedron lifted
+    to H^3 or a quotient of H^3.
+
+    That is, imagine a growing neighborhood about the given
+    geometric_object (such as an R13Point, R13Line or R13Horoball) in
+    H^3 or a quotient of H^3. The stream returns the tiles in the order
+    as they are intersected by the growing neighborhood.
+
+    Note that this is not precisely true since we only compute a lower
+    bound for the distance of the geometric object to the tetrahedra.
+
+    What is true is that tile.lower_bound_distance is (not strictly)
+    increasing in the stream and that if we look at all tiles up to
+    a certain point, then those tiles cover the neighborhood of radius
+    tile.lower_bound_distance about the geometric_object.
+
+    base_point is used to determine whether two lifted tetrahedra
+    are the same in H^3 or a quotient space of H^3.
+
+    visited_lifted_tetrahedra: data structure (passed in as empty) which
+    will be used here to record which lifted tetrahedra have already been
+    visited and been added to the result while tiling the quotient space.
+
+    An optional replace_lifted_tetrahedron_function callback can be
+    specified. This callback is invoked on any new lifted tetrahedron
+    and can return None or a list of lifted tetrahedra to replace the given
+    lifted tetrahedra. This is used when developing a geodesic (tube) to
+    skip over the pieces of a geodesic completely contained in a tube
+    about a core curve.
+    """
+
+    RF = visited_lifted_tetrahedra._base_point[0].parent()
+
+    if verified:
+        minus_infinity = RF(-Infinity)
+    else:
+        minus_infinity = RF(-1e20)
+
+    # The pending pieces as priority queue - that is, a python list
+    # but we use heapq to access it.
+    pending_lifted_tetrahedra : Sequence[_PendingLiftedTetrahedron] = []
+
+    # Start tiling the neighborhood about the geometric object using
+    # the given lifted tetrahedra.
+    #
+    # It is assumed that at least one of the given lifted tetraheedra
+    # intersects the given geometric object for the tiling to be correct.
+    #
+    # If this assumption is false, we could fail in the following way:
+    # assume that the given lifted tetrahedra are far away from the given
+    # object. Then the algorithm below thinks we are done, before we
+    # even started properly tiling - and we obviously get an incomplete
+    # result.
+    #
+    for lifted_tetrahedron in initial_lifted_tetrahedra:
+        heapq.heappush(
+            pending_lifted_tetrahedra,
+            _PendingLiftedTetrahedron(
+                lifted_tetrahedron, minus_infinity))
+
+    while True:
+        pending_lifted_tetrahedron : _PendingLiftedTetrahedron = (
+            heapq.heappop(pending_lifted_tetrahedra))
+
+        if not visited_lifted_tetrahedra.add(
+                pending_lifted_tetrahedron.lifted_tetrahedron):
+            continue
+
+        tet = pending_lifted_tetrahedron.lifted_tetrahedron.tet
+        m = pending_lifted_tetrahedron.lifted_tetrahedron.o13_matrix
+
+        # Imagine the fixed lift of the given geometric object and how it
+        # relates to the lifted tetrahedron which is the image of
+        # the tetrahedron in the fundamental domain under the matrix.
+        #
+        # Applying the inverse matrix moves the tetrahedron back into
+        # the fundamental domain and thus we obtain the (inverse) lift of
+        # the geometric object intresecting the fundamental domain.
+        #
+        inverse_lifted_geometric_object = (
+            geometric_object.transformed(o13_inverse(m)))
+
+        if replace_lifted_tetrahedron_function:
+            new_lifted_tetrahedra = replace_lifted_tetrahedron_function(
+                pending_lifted_tetrahedron.lifted_tetrahedron,
+                geometric_object,
+                inverse_lifted_geometric_object,
+                verified)
+            if new_lifted_tetrahedra is not None:
+                for lifted_tetrahedron in new_lifted_tetrahedra:
+                    heapq.heappush(
+                        pending_lifted_tetrahedra,
+                        _PendingLiftedTetrahedron(
+                            lifted_tetrahedron, minus_infinity))
+                continue
+
+        # Emit Tile
+        yield Tile(pending_lifted_tetrahedron.lower_bound_distance,
+                   inverse_lifted_geometric_object,
+                   pending_lifted_tetrahedron.lifted_tetrahedron)
+
+        # For all faces ...
+        for f, new_tet in tet.Neighbor.items():
+            # ... except the one that was used to reach this lifted tetrahedron
+            if f == pending_lifted_tetrahedron.entry_cell:
+                continue
+
+            entry_face = tet.Gluing[f].image(f)
+            heapq.heappush(
+                pending_lifted_tetrahedra,
+                _PendingLiftedTetrahedron(
+                    LiftedTetrahedron(
+                        new_tet,
+                        # Inverse of tet.O13_matrices[f]
+                        m * new_tet.O13_matrices[entry_face]),
+                    # Distance of this face to inverse lifted
+                    # geometric object
+                    # (equal to distance of face entry_face of
+                    # new_tet)
+                    lower_bound_distance_to_r13_triangle(
+                        inverse_lifted_geometric_object,
+                        tet.R13_triangles[f],
+                        verified),
+                    entry_cell=entry_face))
+
+class _PendingLiftedTetrahedron:
+    """
+    A lifted tetrahedron that still needs to be processed by by compute_tiles
+    together with the face through which this lifted tetrahedron was
+    reached.
+
+    The lifted tetrahedron lives in a (potentially trivial) quotient space of
+    the hyperboloid model.
+
+    The algorithm in compute_tile might add the same lifted tetrahedron
+    multiple times to the queue of pending pieces as there are four
+    neighboring lifted tetrahedra from which this lifted tetrahedron can
+    be reached.
+
+    Let L be the geometric object (in the quotient space) about which we
+    develop a neighborhood. lower_bound is a lower bound on the distance between
+    L and the face through which this lifted tetrahedron was reached.
+    Note that lower_bound might be larger than the distance between L and
+    this lifted tetrahedron (which is the minimum of all distances between
+    L and any of the faces of this lifted tetrahedron).
+
+    The < operator is overloaded so that the piece with the lowest
+    lower_bound will be picked up next by a priority queue.
+
+    If pieces are processed in this order, then the lower_bound of the
+    next piece will actually be a lower bound for the distance between L
+    and the lifted tetrahedron (with other pending pieces for the same
+    lifted tetrahedron having higher values for lower_bound and thus
+    being further down the queue).
+    """
+
+    def __init__(self,
+                 lifted_tetrahedron : LiftedTetrahedron,
+                 lower_bound_distance,
+                 entry_cell : int = simplex.T):
+        self.lifted_tetrahedron = lifted_tetrahedron
+        self.lower_bound_distance = lower_bound_distance
+
+        # Either element of simplex.ZeroSubsimplices (if piece was reached
+        # through another piece) or simplex.T (if this pending piece was
+        # used to start tiling).
+        self.entry_cell = entry_cell
+
+        # For convenience, lower_bound is an interval but it is only
+        # the left value of the interval that is relevant and that we
+        # should use: A < B can be False for two intervals even
+        # when A's left value is lower than B's left value.
+        self._key = lower(lower_bound_distance)
+
+    def __lt__(self, other):
+        return self._key < other._key

snappy/tiling/triangle.py

@@ -0,0 +1,33 @@
+from ..snap.t3mlite import Mcomplex, Tetrahedron, simplex
+
+from ..hyperboloid.line import R13Line
+from ..hyperboloid.triangle import R13IdealTriangle, triangle_bounding_plane
+
+__all__ = ['add_triangles_to_tetrahedra']
+
+def add_triangles_to_tetrahedra(mcomplex : Mcomplex) -> None:
+    for tet in mcomplex.Tetrahedra:
+        _add_triangles_to_tetrahedron(tet)
+
+def _add_triangles_to_tetrahedron(tet : Tetrahedron) -> None:
+    edges = {
+        e: R13Line([tet.R13_vertices[simplex.Head[e]],
+                    tet.R13_vertices[simplex.Tail[e]]])
+        for e in simplex.OneSubsimplices }
+
+    tet.R13_triangles = {
+        f : R13IdealTriangle(
+            tet.R13_planes[f],
+            [ _triangle_bounding_plane_for_face_edge(tet, f, f & other_f)
+              for other_f in simplex.TwoSubsimplices
+              if f != other_f ],
+            [ edges[f & other_f]
+              for other_f in simplex.TwoSubsimplices
+              if f != other_f ])
+        for f in simplex.TwoSubsimplices }
+
+def _triangle_bounding_plane_for_face_edge(tet, face, edge):
+    return triangle_bounding_plane(
+        tet.R13_vertices[face - edge],
+        tet.R13_vertices[simplex.Head[edge]],
+        tet.R13_vertices[simplex.Tail[edge]])

snappy/tkterminal.py

@@ -3,16 +3,13 @@ import os
 import sys
 import re
 from urllib.request import pathname2url
-
-from IPython.utils import io
-from IPython.core.autocall import IPyAutocall
-
-import snappy
-from .gui import *
+import tkinter as Tk_
+from tkinter import ttk
+from tkinter.font import Font
+from tkinter.font import families as font_families
 from tkinter.messagebox import askyesno
+from IPython.utils import io
 
-snappy_path = os.path.abspath(os.path.dirname(snappy.__file__))
-icon_file = os.path.join(snappy_path, 'info_icon.gif')
 debug_Tk = True
 ansi_seqs = re.compile(r'(?:\x01*\x1b\[((?:[0-9]*;)*[0-9]*.)\x02*)*([^\x01\x1b]*)',
                        re.MULTILINE)
@@ -35,6 +32,40 @@ ansi_colors = {'0;30m': 'Black',
 delims = re.compile(r'[\s\[\]\{\}\(\)\+\-\=\'`~!@#\$\^\&\*]+')
 
 
+class FontChoice:
+    def __init__(self, family, size, weight, slant):
+        self.family = family
+        self.size = size
+        self.weight = weight
+        self.slant = slant
+        self.rest = f'{self.weight} {self.slant}'
+
+    def as_tuple(self):
+        size = self.size
+        if sys.platform == 'darwin' and Tk_.TkVersion >= 9.0:
+            size = int(size/1.3)
+        return (self.family, size, self.rest)
+
+    def __repr__(self):
+        return 'FontChoice' + repr((self.family, self.size, self.weight, self.slant))
+
+    def bold(self):
+        return FontChoice(self.family, self.size, 'bold', self.slant)
+
+
+def default_terminal_font():
+    size = 13 if sys.platform == 'darwin' else 11
+    family = Font(font='TkFixedFont').actual()['family']
+    if sys.platform == 'win32':
+        # Default is Courier New which is ugly and appears blurry.
+        available = font_families()
+        for better in ['Consolas', 'Cascadia Mono SemiLight']:
+            if better in available:
+                family = better
+
+    return FontChoice(family, size, 'normal', 'roman')
+
+
 class Tk(Tk_.Tk):
     def __init__(self, error_handler=None):
         Tk_.Tk.__init__(self, className='snappy')
@@ -42,15 +73,9 @@ class Tk(Tk_.Tk):
         # calls this function to report their occurrence.
         if error_handler:
             self.report_callback_exception = error_handler
-        # In Python 2.7 the _default root does not get set correctly.
-        if not Tk_._default_root:
-            Tk_._default_root = self
 
-#  Some ideas for the TkTerm class were borrowed from code written by
-#  Eitan Isaacson, IBM Corp.
 
-
-class TkTerm:
+class TkTerminalBase:
     """
     A Tkinter terminal window that runs an IPython shell.  This class
     supports the IOStream interface, and can function as a replacement
@@ -62,8 +87,6 @@ class TkTerm:
             io.stdout = sys.stdout = self
         else:
             self.window = window = Tk(self.report_callback_exception)
-            # self.encoding = sys.stdout.encoding
-            # self.saved_io = (sys.stdout, sys.stderr)
             io.stdout = io.stderr = sys.stdout = sys.stderr = self
         self._input_buffer = ''
         self._current_indent = 0
@@ -71,7 +94,6 @@ class TkTerm:
         window.option_add('*Menu.tearOff', 0)
         window.title(name)
         window.protocol("WM_DELETE_WINDOW", self.close)
-        self.icon = Tk_.PhotoImage(file=icon_file)
         self.frame = frame = Tk_.Frame(window)
         self.text = text = Tk_.Text(frame,
                                     width=85,
@@ -83,7 +105,7 @@ class TkTerm:
                                     highlightthickness=0,
                                     relief=Tk_.FLAT
                                 )
-        self.set_font(Font(text, text.cget('font')))
+        self.set_font(default_terminal_font())
         self.scroller = scroller = Tk_.Scrollbar(frame, command=text.yview)
         text.config(yscrollcommand=scroller.set)
         scroller.pack(side=Tk_.RIGHT, fill=Tk_.Y, pady=10)
@@ -180,7 +202,7 @@ class TkTerm:
         self.blockers = {}
         self.can_quit = True
         self.close_callback = lambda :None
-        
+
     # Emulate a ListedWindow.  We are listed, even though we are unique.
     def bring_to_front(self):
         self.window.deiconify()
@@ -251,18 +273,18 @@ class TkTerm:
         sys.last_traceback = traceback
         self.IP.showtraceback()
 
-    def set_font(self, fontdesc):
-        self.text.config(font=fontdesc)
-        normal_font = Font(self.text, self.text.cget('font'))
-        self.bold_font = bold_font = Font(self.text, self.text.cget('font'))
-        self.bold_font.config(weight='bold')
+    def set_font(self, font_choice):
+        normal_tuple = font_choice.as_tuple()
+        bold_tuple = font_choice.bold().as_tuple()
+        normal_font = Font(font=font_choice.as_tuple())
         self.char_size = normal_font.measure('M')
+        self.text.config(font=normal_tuple)
         text = self.text
-        text.tag_config('output', font=normal_font)
-        text.tag_config('Prompt', foreground='#0000cc', font=normal_font)
-        text.tag_config('PromptNum', foreground='#0000bb', font=bold_font)
-        text.tag_config('OutPrompt', foreground='#cc0000', font=normal_font)
-        text.tag_config('OutPromptNum', foreground='#bb0000', font=bold_font)
+        text.tag_config('output', font=normal_tuple)
+        text.tag_config('Prompt', foreground='#0000cc', font=normal_tuple)
+        text.tag_config('PromptNum', foreground='#0000bb', font=bold_tuple)
+        text.tag_config('OutPrompt', foreground='#cc0000', font=normal_tuple)
+        text.tag_config('OutPromptNum', foreground='#bb0000', font=bold_tuple)
 
     def add_blocker(self, window, message):
         self.blockers[window] = message
@@ -365,29 +387,37 @@ class TkTerm:
             self.text.tag_add('history', 'output_end', Tk_.INSERT)
 
     def handle_return(self, event=None):
+        # If the input consists of one complete line of code we run it,
+        # regardless of where the insert cursor is located.  Otherwise we only
+        # run the code if the cursor is at the end of the input
         self.clear_completions()
+        if self.running_code:
+            return 'break'
+        cursor = int(self.text.index(Tk_.INSERT).split('.')[0])
+        last = int(self.text.index(Tk_.END).split('.')[0])
+        first = int(self.text.index('output_end').split('.')[0])
+        if cursor == first == last - 1:  # single line input
+            self.text.mark_set(Tk_.INSERT, Tk_.END)
         self.text.insert(Tk_.INSERT, '\n')
-        if not self.running_code:
-            cell = self.text.get('output_end', Tk_.INSERT)
-            self.process_return(cell)
-        return 'break'
-
-    def handle_shift_return(self, event):
-        self.text.mark_set(Tk_.INSERT, Tk_.END)
-        return self.handle_return()
-
-    def process_return(self, cell):
+        cell = self.text.get('output_end', Tk_.INSERT)
         try:
             self.interact_handle_input(cell)
         except KeyboardInterrupt:
             self.write('(IP) Keyboard Interrupt: ')
             self.reset()
+            self.hist_pointer = 0
+            self.hist_stem = ''
         self.interact_prompt()
         self.text.see(Tk_.INSERT)
         if self.IP.more:
             self.text.insert(Tk_.INSERT, ' '*self._current_indent, ())
         self.hist_pointer = 0
         self.hist_stem = ''
+        return 'break'
+
+    def handle_shift_return(self, event):
+        self.text.mark_set(Tk_.INSERT, Tk_.END)
+        return self.handle_return()
 
     def jump_up(self, event):
         return self.handle_up(event, jump=True)
@@ -463,25 +493,35 @@ class TkTerm:
         line = self.text.get('output_end', self.tab_index).strip('\n')
         word = delims.split(line)[-1]
         try:
-            completions = self.IP.complete(word)[1]
+            stem, completions = self.IP.complete(word)
         except TypeError:
             completions = []
         if word.find('_') == -1:
             completions = [x for x in completions
                            if x.find('__') == -1 and x.find('._') == -1]
-        if len(completions) == 0:
+        # No meaningful completions.  Ring the bell.
+        if len(completions) == 0 or len(completions) == 1 and completions[0] == stem:
             self.window.bell()
             self.tab_count = 0
             return 'break'
-        stem = self.stem(completions)
-        if len(stem) > len(word):
-            self.do_completion(word, stem)
-        elif len(completions) > 60 and self.tab_count == 1:
-            self.show_completions(
+        # Only one completion.  Use it.
+        if len(completions) == 1:
+            self.do_completion(stem, completions[0])
+            self.tab_count = 0
+            return 'break'
+        max_stem = self.max_stem(stem, completions)
+        # Add the maximal stem of all completions if it extends the word,
+        if len(max_stem) > len(word):
+            self.do_completion(stem, max_stem)
+            self.tab_count = 0
+            return 'break'
+        # Show the possible completions, with a warning if there are lots.
+        if len(completions) > 60 and self.tab_count == 1:
+            self.show_completions('', '',
                 ['%s possibilities -- hit tab again to view them all' %
-                     len(completions)])
+                len(completions)])
         else:
-            self.show_completions(completions)
+            self.show_completions(word, stem, completions)
             if len(completions) <= 60:
                 self.tab_count += 1
         return 'break'
@@ -490,20 +530,21 @@ class TkTerm:
         self.text.mark_set(Tk_.INSERT, 'output_end')
         return 'break'
 
-    def do_completion(self, word, completion):
-        tail = completion[len(word):]
+    def do_completion(self, stem, completion):
+        tail = completion[len(stem):]
         self.text.insert(self.tab_index, tail)
         self.tab_index = Tk_.END
         self.tab_count = 0
 
-    def show_completions(self, comps):
+    def show_completions(self, word, stem, comps):
+        n = len(stem)
+        comps = [word + c[n:] for c in comps]
         self.text.delete(self.tab_index, Tk_.END)
         width = self.text.winfo_width()
-        font = Font(self.text, self.text.cget('font'))
-        charwidth = width//self.char_size
+        charwidth = width // self.char_size
         biggest = 2 + max([len(x) for x in comps])
-        num_cols = charwidth//biggest
-        num_rows = (len(comps) + num_cols - 1)//num_cols
+        num_cols = max(charwidth // biggest, 1)
+        num_rows = (len(comps) + num_cols - 1) // num_cols
         rows = []
         format = '%%-%ds' % biggest
         for n in range(num_rows):
@@ -519,17 +560,17 @@ class TkTerm:
             self.tab_index = None
             self.tab_count = 0
 
-    def stem(self, wordlist):
-        if len(wordlist) == 1:
-            return wordlist[0]
-        result = ''
-        for n in range(1,100):
-            heads = set(w[:n] for w in wordlist)
+    def max_stem(self, stem, completions):
+        if len(completions) == 1:
+            return completions[0]
+        result = stem
+        for n in range(len(stem) + 1, 100):
+            heads = {w[:n] for w in completions}
             if len(heads) > 1:
                 return result
             elif len(heads) == 1:
                 result = heads.pop()
-        return wordlist[0][:100]
+        return result
 
     def write_continuation_prompt(self):
         prompt_tokens = self._continuation_prompt(self._prompt_size)
@@ -673,28 +714,16 @@ class TkTerm:
 
     def start_interaction(self):
         """
-        Print the banner and issue the first prompt.
+        Display a banner and prepare to begin interaction.
         """
-        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'])
+        # Subclasses should override this method
+        banner_label = Tk_.Label(self.text,
+            text="Please override the start_interaction method.",
+            anchor=Tk_.W,
+            justify=Tk_.LEFT)
         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)
-        # Create the prompt and go!
-        self.interact_prompt()
 
     def _input_prompt(self):
         result = [('Prompt', 'In['),
@@ -733,7 +762,7 @@ class TkTerm:
         """
         if not code.strip():
             return '\n'
-        lines = [line for line in code.split('\n')]
+        lines = list(code.split('\n'))
         clean_lines = [lines[0].lstrip()]
         for line in lines[1:]:
             try:
@@ -749,7 +778,6 @@ class TkTerm:
         prompt and set the 'more' flag.  If the code is valid and
         complete then run the code.
         """
-        transformer = self.IP.input_transformer_manager
         assert cell.endswith('\n')
         if not cell.strip():
             self._current_indent = 0
@@ -758,7 +786,8 @@ class TkTerm:
             self._input_buffer += cell
         else:
             self._input_buffer = self.clean_code(cell)
-        status, indent = transformer.check_complete(self._input_buffer)
+        transformed_cell = self.IP.transform_cell(self._input_buffer)
+        status, indent = self.IP.check_complete(transformed_cell)
         self._current_indent = indent or 0
         if status == 'incomplete':
             self.IP.more = True

snappy/twister/main.py

@@ -8,12 +8,6 @@ import snappy
 from plink import LinkManager
 from .twister_core import build_bundle, build_splitting, twister_version
 
-# Python 3 compatibility
-try:
-	basestring
-except NameError:  # Python 3
-	basestring = unicode = str
-
 surface_database_path = os.path.join(os.path.dirname(__file__), 'surfaces')
 surface_database = set(os.listdir(surface_database_path))
 version = twister_version()
@@ -22,7 +16,7 @@ def _get_surface(surface):
 	if isinstance(surface, tuple) and len(surface) == 2 and isinstance(surface[0], int) and isinstance(surface[1], int):
 		return LP_surface(surface[0], surface[1])
 	
-	if isinstance(surface, basestring):
+	if isinstance(surface, str):
 		# If surface is actually the contents of a surface file.
 		if surface.startswith('# A Twister surface file'):
 			return surface