wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/py/crustslices.py

@@ -0,0 +1,403 @@
+"""PySlices combines the slices and filling into one control."""
+
+__author__ = "David N. Mashburn <david.n.mashburn@gmail.com> / "
+__author__ += "Patrick K. O'Brien <pobrien@orbtech.com>"
+
+import wx
+
+import os
+import pprint
+import re
+import sys
+
+from . import dispatcher
+from . import crust
+from . import document
+from . import editwindow
+from . import editor
+from .filling import Filling
+from . import frame
+from .sliceshell import SlicesShell
+from .version import VERSION
+
+
+class CrustSlices(crust.Crust):
+    """Slices based on SplitterWindow."""
+
+    name = 'Slices'
+    sashoffset = 300
+
+    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=wx.SP_3D|wx.SP_LIVE_UPDATE,
+                 name='Slices Window', rootObject=None, rootLabel=None,
+                 rootIsNamespace=True, intro='', locals=None,
+                 InterpClass=None,
+                 startupScript=None, execStartupScript=True,
+                 showPySlicesTutorial=True,
+                 enableShellMode=False, hideFoldingMargin=False,
+                 *args, **kwds):
+        """Create CrustSlices instance."""
+        wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
+
+        # Turn off the tab-traversal style that is automatically
+        # turned on by wx.SplitterWindow.  We do this because on
+        # Windows the event for Ctrl-Enter is stolen and used as a
+        # navigation key, but the SlicesShell window uses it to insert lines.
+        style = self.GetWindowStyle()
+        self.SetWindowStyle(style & ~wx.TAB_TRAVERSAL)
+
+        self.sliceshell = SlicesShell(parent=self, introText=intro,
+                                 locals=locals, InterpClass=InterpClass,
+                                 startupScript=startupScript,
+                                 execStartupScript=execStartupScript,
+                                 showPySlicesTutorial=showPySlicesTutorial,
+                                 enableShellMode=enableShellMode,
+                                 hideFoldingMargin=hideFoldingMargin,
+                                 *args, **kwds)
+
+        self.editor = self.sliceshell
+        self.shell = self.sliceshell
+        if rootObject is None:
+            rootObject = self.sliceshell.interp.locals
+        self.notebook = wx.Notebook(parent=self, id=-1)
+        self.sliceshell.interp.locals['notebook'] = self.notebook
+        self.filling = Filling(parent=self.notebook,
+                               rootObject=rootObject,
+                               rootLabel=rootLabel,
+                               rootIsNamespace=rootIsNamespace)
+        # Add 'filling' to the interpreter's locals.
+        self.sliceshell.interp.locals['filling'] = self.filling
+        self.notebook.AddPage(page=self.filling, text='Namespace', select=True)
+
+        self.display = crust.Display(parent=self.notebook)
+        self.notebook.AddPage(page=self.display, text='Display')
+        # Add 'pp' (pretty print) to the interpreter's locals.
+        self.sliceshell.interp.locals['pp'] = self.display.setItem
+        self.display.nbTab = self.notebook.GetPageCount()-1
+
+        self.calltip = crust.Calltip(parent=self.notebook,ShellClassName='SlicesShell')
+        self.notebook.AddPage(page=self.calltip, text='Calltip')
+
+        self.sessionlisting = crust.SessionListing(parent=self.notebook,ShellClassName='SlicesShell')
+        self.notebook.AddPage(page=self.sessionlisting, text='History')
+
+        self.dispatcherlisting = crust.DispatcherListing(parent=self.notebook)
+        self.notebook.AddPage(page=self.dispatcherlisting, text='Dispatcher')
+
+
+        # Initialize in an unsplit mode, and check later after loading
+        # settings if we should split or not.
+        self.sliceshell.Hide()
+        self.notebook.Hide()
+        self.Initialize(self.sliceshell)
+        self._shouldsplit = True
+        wx.CallAfter(self._CheckShouldSplit)
+        self.SetMinimumPaneSize(100)
+
+        self.Bind(wx.EVT_SIZE, self.SplitterOnSize)
+        self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED, self.OnChanged)
+        self.Bind(wx.EVT_SPLITTER_DCLICK, self.OnSashDClick)
+
+class CrustSlicesFrame(crust.CrustFrame):
+    """Frame containing all the PySlices components."""
+
+    name = 'SliceFrame'
+
+
+    def __init__(self, parent=None, id=-1, title='PySlices',
+                 pos=wx.DefaultPosition, size=wx.DefaultSize,
+                 style=wx.DEFAULT_FRAME_STYLE,
+                 rootObject=None, rootLabel=None, rootIsNamespace=True,
+                 locals=None, InterpClass=None,
+                 config=None, dataDir=None, filename=None,
+                 *args, **kwds):
+        """Create CrustFrame instance."""
+        frame.Frame.__init__(self, parent, id, title, pos, size, style,
+                             shellName='PySlices')
+        frame.ShellFrameMixin.__init__(self, config, dataDir)
+
+        if size == wx.DefaultSize:
+            self.SetSize((800, 600))
+
+        intro = 'PySlices %s - The Flakiest Python Shell... Cut up!' % VERSION
+
+        self.SetStatusText(intro.replace('\n', ', '))
+        self.crust = CrustSlices(parent=self, intro=intro,
+                                 rootObject=rootObject,
+                                 rootLabel=rootLabel,
+                                 rootIsNamespace=rootIsNamespace,
+                                 locals=locals,
+                                 InterpClass=InterpClass,
+                                 startupScript=self.startupScript,
+                                 execStartupScript=self.execStartupScript,
+                                 showPySlicesTutorial=self.showPySlicesTutorial,
+                                 enableShellMode=self.enableShellMode,
+                                 hideFoldingMargin=self.hideFoldingMargin,
+                                 *args, **kwds)
+        self.sliceshell = self.crust.sliceshell
+        self.shell = self.sliceshell
+        self.buffer = self.sliceshell.buffer
+        # Override the filling so that status messages go to the status bar.
+        self.crust.filling.tree.setStatusText = self.SetStatusText
+
+        # Override the shell so that status messages go to the status bar.
+        self.sliceshell.setStatusText = self.SetStatusText
+
+        self.sliceshell.SetFocus()
+        self.LoadSettings()
+
+        self.currentDirectory = os.path.expanduser('~')
+
+        if filename!=None:
+            self.bufferOpen(filename)
+
+        self.Bind(wx.EVT_IDLE, self.OnIdle)
+
+    def OnClose(self, event):
+        """Event handler for closing."""
+        self.bufferClose()
+
+    def OnAbout(self, event):
+        """Display an About window."""
+        title = 'About PySlices'
+        text = 'PySlices %s\n\n' % VERSION + \
+               'Yet another Python shell, only flakier.\n\n' + \
+               'Half-baked by Patrick K. O\'Brien,\n' + \
+               'the other half is still in the oven.\n\n' + \
+               'Platform: %s\n' % sys.platform + \
+               'Python Version: %s\n' % sys.version.split()[0] + \
+               'wxPython Version: %s\n' % wx.VERSION_STRING + \
+               ('\t(%s)\n' % ", ".join(wx.PlatformInfo[1:]))
+        dialog = wx.MessageDialog(self, text, title,
+                                  wx.OK | wx.ICON_INFORMATION)
+        dialog.ShowModal()
+        dialog.Destroy()
+
+    def OnEnableShellMode(self,event):
+        """Change between Slices Mode and Shell Mode"""
+        frame.Frame.OnEnableShellMode(self,event)
+        self.sliceshell.ToggleShellMode(self.enableShellMode)
+
+    def OnHideFoldingMargin(self,event):
+        """Change between Slices Mode and Shell Mode"""
+        frame.Frame.OnHideFoldingMargin(self,event)
+        self.sliceshell.ToggleFoldingMargin(self.hideFoldingMargin)
+
+    # Stolen Straight from editor.EditorFrame
+    # Modified a little... :)
+    # ||
+    # \/
+    def OnIdle(self, event):
+        """Event handler for idle time."""
+        self._updateTitle()
+        event.Skip()
+
+    def _updateTitle(self):
+        """Show current title information."""
+        title = self.GetTitle()
+        if self.bufferHasChanged():
+            if title.startswith('* '):
+                pass
+            else:
+                self.SetTitle('* ' + title)
+        else:
+            if title.startswith('* '):
+                self.SetTitle(title[2:])
+
+    def hasBuffer(self):
+        """Return True if there is a current buffer."""
+        if self.buffer:
+            return True
+        else:
+            return False
+
+    def bufferClose(self):
+        """Close buffer."""
+        if self.buffer.hasChanged():
+            cancel = self.bufferSuggestSave()
+            if cancel:
+                #event.Veto()
+                return cancel
+        self.SaveSettings()
+        self.crust.sliceshell.destroy()
+        self.bufferDestroy()
+        self.Destroy()
+
+        return False
+
+    def bufferCreate(self, filename=None):
+        """Create new buffer."""
+        self.bufferDestroy()
+        buffer = Buffer()
+        self.panel = panel = wx.Panel(parent=self, id=-1)
+        panel.Bind (wx.EVT_ERASE_BACKGROUND, lambda x: x)
+        editor = Editor(parent=panel)
+        panel.editor = editor
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(editor.window, 1, wx.EXPAND)
+        panel.SetSizer(sizer)
+        panel.SetAutoLayout(True)
+        sizer.Layout()
+        buffer.addEditor(editor)
+        buffer.open(filename)
+        self.setEditor(editor)
+        self.editor.setFocus()
+        self.SendSizeEvent()
+
+
+    def bufferDestroy(self):
+        """Destroy the current buffer."""
+        if self.buffer:
+            self.editor = None
+            self.buffer = None
+
+
+    def bufferHasChanged(self):
+        """Return True if buffer has changed since last save."""
+        if self.buffer:
+            return self.buffer.hasChanged()
+        else:
+            return False
+
+    def bufferNew(self):
+        """Create new buffer."""
+        cancel = self.bufferSuggestSave()
+        if cancel:
+            return cancel
+        self.sliceshell.clear()
+        self.SetTitle( 'PySlices')
+        self.sliceshell.NeedsCheckForSave=False
+        self.sliceshell.SetSavePoint()
+        self.buffer.doc = document.Document()
+        self.buffer.name = 'This shell'
+        self.buffer.modulename = self.buffer.doc.filebase
+        #self.bufferCreate()
+        cancel = False
+        return cancel
+
+    def bufferOpen(self,file=None):
+        """Open file in buffer."""
+        if self.bufferHasChanged():
+            cancel = self.bufferSuggestSave()
+            if cancel:
+                return cancel
+
+        if file==None:
+            file=wx.FileSelector('Open a PySlices File',
+                                 wildcard='*.pyslices',
+                                 default_path=self.currentDirectory)
+        if file!=None and file!=u'':
+            with open(file,'r') as fid:
+                self.sliceshell.LoadPySlicesFile(fid)
+            self.currentDirectory = os.path.split(file)[0]
+            self.SetTitle( os.path.split(file)[1] + ' - PySlices')
+            self.sliceshell.NeedsCheckForSave=False
+            self.sliceshell.SetSavePoint()
+            self.buffer.doc = document.Document(file)
+            self.buffer.name = self.buffer.doc.filename
+            self.buffer.modulename = self.buffer.doc.filebase
+            self.sliceshell.ScrollToLine(0)
+        return
+
+##     def bufferPrint(self):
+##         """Print buffer."""
+##         pass
+
+##     def bufferRevert(self):
+##         """Revert buffer to version of file on disk."""
+##         pass
+
+    # was self.buffer.save(self): # """Save buffer."""
+    def simpleSave(self,confirmed=False):
+        filepath = self.buffer.doc.filepath
+        self.buffer.confirmed = confirmed
+        if not filepath:
+            return  # XXX Get filename
+        if not os.path.exists(filepath):
+            self.buffer.confirmed = True
+        if not self.buffer.confirmed:
+            self.buffer.confirmed = self.buffer.overwriteConfirm(filepath)
+        if self.buffer.confirmed:
+            with open(filepath, 'wb') as fid:
+                self.sliceshell.SavePySlicesFile(fid)
+
+            self.sliceshell.SetSavePoint()
+            self.SetTitle( os.path.split(filepath)[1] + ' - PySlices')
+            self.sliceshell.NeedsCheckForSave=False
+
+    def bufferSave(self):
+        """Save buffer to its file."""
+        if self.buffer.doc.filepath:
+            # self.buffer.save()
+            self.simpleSave(confirmed=True)
+            cancel = False
+        else:
+            cancel = self.bufferSaveAs()
+        return cancel
+
+    def bufferSaveAs(self):
+        """Save buffer to a new filename."""
+        if self.bufferHasChanged() and self.buffer.doc.filepath:
+            cancel = self.bufferSuggestSave()
+            if cancel:
+                return cancel
+        filedir = ''
+        if self.buffer and self.buffer.doc.filedir:
+            filedir = self.buffer.doc.filedir
+        result = editor.saveSingle(title='Save PySlices File',directory=filedir,
+                                   wildcard='PySlices Files (*.pyslices)|*.pyslices')
+        if result.path not in ['',None]:
+            if result.path[-9:]!=".pyslices":
+                result.path+=".pyslices"
+
+            self.buffer.doc = document.Document(result.path)
+            self.buffer.name = self.buffer.doc.filename
+            self.buffer.modulename = self.buffer.doc.filebase
+            self.simpleSave(confirmed=True) # allow overwrite
+            cancel = False
+        else:
+            cancel = True
+        return cancel
+
+    def bufferSaveACopy(self):
+        """Save buffer to a new filename."""
+        filedir = ''
+        if self.buffer and self.buffer.doc.filedir:
+            filedir = self.buffer.doc.filedir
+        result = editor.saveSingle(title='Save a Copy of PySlices File',directory=filedir,
+                                   wildcard='PySlices Files (*.pyslices)|*.pyslices')
+
+        if result.path not in ['',None]:
+            if result.path[-9:]!=".pyslices":
+                result.path+=".pyslices"
+
+            # if not os.path.exists(result.path):
+            # Allow overwrite...
+            with open(result.path, 'wb') as fid:
+                self.sliceshell.SavePySlicesFile(fid)
+            cancel = False
+        else:
+            cancel = True
+        return cancel
+
+    def bufferSuggestSave(self):
+        """Suggest saving changes.  Return True if user selected Cancel."""
+        result = editor.messageDialog(parent=None,
+                               message='%s has changed.\n'
+                                       'Would you like to save it first'
+                                       '?' % self.buffer.name,
+                               title='Save current file?',
+                               style=wx.YES_NO | wx.CANCEL | wx.NO_DEFAULT |
+                                     wx.CENTRE | wx.ICON_QUESTION )
+        if result.positive:
+            cancel = self.bufferSave()
+        else:
+            cancel = result.text == 'Cancel'
+        return cancel
+
+    def updateNamespace(self):
+        """Update the buffer namespace for autocompletion and calltips."""
+        if self.buffer.updateNamespace():
+            self.SetStatusText('Namespace updated')
+        else:
+            self.SetStatusText('Error executing, unable to update namespace')

wx/py/dispatcher.py

@@ -0,0 +1,259 @@
+"""Provides global signal dispatching services."""
+
+__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
+
+import types
+import weakref
+
+
+class DispatcherError(Exception):
+    def __init__(self, args=None):
+        self.args = args
+
+
+class Parameter:
+    """Used to represent default parameter values."""
+    def __repr__(self):
+        return self.__class__.__name__
+
+class Any(Parameter): pass
+Any = Any()
+
+class Anonymous(Parameter): pass
+Anonymous = Anonymous()
+
+
+connections = {}
+senders = {}
+_boundMethods = weakref.WeakKeyDictionary()
+
+
+def connect(receiver, signal=Any, sender=Any, weak=True):
+    """
+    Connect receiver to sender for signal.
+
+    * If sender is Any, receiver will receive signal from any sender.
+    * If signal is Any, receiver will receive any signal from sender.
+    * If sender is None, receiver will receive signal from Anonymous.
+    * If signal is Any and sender is None, receiver will receive any
+      signal from Anonymous.
+    * If signal is Any and sender is Any, receiver will receive any
+      signal from any sender.
+    * If weak is true, weak references will be used.
+    """
+    if signal is None:
+        raise DispatcherError('signal cannot be None')
+    if weak:
+        receiver = safeRef(receiver)
+    senderkey = id(sender)
+    signals = {}
+    if senderkey in connections:
+        signals = connections[senderkey]
+    else:
+        connections[senderkey] = signals
+        # Keep track of senders for cleanup.
+        if sender not in (None, Any):
+            def remove(object, senderkey=senderkey):
+                _removeSender(senderkey=senderkey)
+            # Skip objects that can not be weakly referenced, which means
+            # they won't be automatically cleaned up, but that's too bad.
+            try:
+                weakSender = weakref.ref(sender, remove)
+                senders[senderkey] = weakSender
+            except:
+                pass
+    receivers = []
+    if signal in signals:
+        receivers = signals[signal]
+    else:
+        signals[signal] = receivers
+    try:
+        receivers.remove(receiver)
+    except ValueError:
+        pass
+    receivers.append(receiver)
+
+def disconnect(receiver, signal=Any, sender=Any, weak=True):
+    """Disconnect receiver from sender for signal.
+
+    Disconnecting is not required. The use of disconnect is the same as for
+    connect, only in reverse. Think of it as undoing a previous connection."""
+    if signal is None:
+        raise DispatcherError('signal cannot be None')
+    if weak:
+        receiver = safeRef(receiver)
+    senderkey = id(sender)
+    try:
+        receivers = connections[senderkey][signal]
+    except KeyError:
+        raise DispatcherError('No receivers for signal %r from sender %s' % (signal, sender))
+    try:
+        receivers.remove(receiver)
+    except ValueError:
+        raise DispatcherError('No connection to receiver %s for signal %r from sender %s' % (receiver, signal, sender))
+    _cleanupConnections(senderkey, signal)
+
+def send(signal, sender=Anonymous, **kwds):
+    """Send signal from sender to all connected receivers.
+
+    Return a list of tuple pairs [(receiver, response), ... ].
+    If sender is not specified, signal is sent anonymously."""
+    senderkey = id(sender)
+    anykey = id(Any)
+    # Get receivers that receive *this* signal from *this* sender.
+    receivers = []
+    try:
+        receivers.extend(connections[senderkey][signal])
+    except KeyError:
+        pass
+    # Add receivers that receive *any* signal from *this* sender.
+    anyreceivers = []
+    try:
+        anyreceivers = connections[senderkey][Any]
+    except KeyError:
+        pass
+    for receiver in anyreceivers:
+        if receivers.count(receiver) == 0:
+            receivers.append(receiver)
+    # Add receivers that receive *this* signal from *any* sender.
+    anyreceivers = []
+    try:
+        anyreceivers = connections[anykey][signal]
+    except KeyError:
+        pass
+    for receiver in anyreceivers:
+        if receivers.count(receiver) == 0:
+            receivers.append(receiver)
+    # Add receivers that receive *any* signal from *any* sender.
+    anyreceivers = []
+    try:
+        anyreceivers = connections[anykey][Any]
+    except KeyError:
+        pass
+    for receiver in anyreceivers:
+        if receivers.count(receiver) == 0:
+            receivers.append(receiver)
+    # Call each receiver with whatever arguments it can accept.
+    # Return a list of tuple pairs [(receiver, response), ... ].
+    responses = []
+    for receiver in receivers:
+        if type(receiver) is weakref.ReferenceType \
+        or isinstance(receiver, BoundMethodWeakref):
+            # Dereference the weak reference.
+            receiver = receiver()
+            if receiver is None:
+                # This receiver is dead, so skip it.
+                continue
+        response = _call(receiver, signal=signal, sender=sender, **kwds)
+        responses += [(receiver, response)]
+    return responses
+
+def _call(receiver, **kwds):
+    """Call receiver with only arguments it can accept."""
+##    if type(receiver) is types.InstanceType:
+    if hasattr(receiver, '__call__') and \
+       (hasattr(receiver.__call__, '__func__') or hasattr(receiver.__call__, '__code__')):
+        # receiver is a class instance; assume it is callable.
+        # Reassign receiver to the actual method that will be called.
+        receiver = receiver.__call__
+    if hasattr(receiver, '__func__'):
+        # receiver is a method. Drop the first argument, usually 'self'.
+        fc = receiver.__func__.__code__
+        acceptable = fc.co_varnames[1:fc.co_argcount]
+    elif hasattr(receiver, '__code__'):
+        # receiver is a function.
+        fc = receiver.__code__
+        acceptable = fc.co_varnames[0:fc.co_argcount]
+    else:
+        raise DispatcherError('Unknown receiver %s of type %s' % (receiver, type(receiver)))
+    if not (fc.co_flags & 8):
+        # fc does not have a **kwds type parameter, therefore
+        # remove unacceptable arguments.
+
+        for arg in list(kwds):
+            if arg not in acceptable:
+                del kwds[arg]
+    return receiver(**kwds)
+
+
+def safeRef(object):
+    """Return a *safe* weak reference to a callable object."""
+    if hasattr(object, '__self__'):
+        if object.__self__ is not None:
+            # Turn a bound method into a BoundMethodWeakref instance.
+            # Keep track of these instances for lookup by disconnect().
+            selfkey = object.__self__
+            funckey = object.__func__
+            if selfkey not in _boundMethods:
+                _boundMethods[selfkey] = weakref.WeakKeyDictionary()
+            if funckey not in _boundMethods[selfkey]:
+                _boundMethods[selfkey][funckey] = \
+                BoundMethodWeakref(boundMethod=object)
+            return _boundMethods[selfkey][funckey]
+    return weakref.ref(object, _removeReceiver)
+
+
+class BoundMethodWeakref:
+    """BoundMethodWeakref class."""
+
+    def __init__(self, boundMethod):
+        """Return a weak-reference-like instance for a bound method."""
+        self.isDead = 0
+        def remove(object, self=self):
+            """Set self.isDead to true when method or instance is destroyed."""
+            self.isDead = 1
+            _removeReceiver(receiver=self)
+        self.weakSelf = weakref.ref(boundMethod.__self__, remove)
+        self.weakFunc = weakref.ref(boundMethod.__func__, remove)
+
+    def __repr__(self):
+        """Return the closest representation."""
+        return '<bound method weakref for %s.%s>' % (self.weakSelf, self.weakFunc)
+
+    def __call__(self):
+        """Return a strong reference to the bound method."""
+        if self.isDead:
+            return None
+        else:
+            object = self.weakSelf()
+            method = self.weakFunc().__name__
+            try:  # wxPython hack to handle wxDead objects.
+                return getattr(object, method)
+            except AttributeError:
+##                 _removeReceiver(receiver=self)
+                return None
+
+
+def _removeReceiver(receiver):
+    """Remove receiver from connections."""
+    list_keys = [(senderkey, signal)
+                 for senderkey in connections
+                 for signal in connections[senderkey]]
+
+    for senderkey, signal in list_keys:
+        try:
+            connections[senderkey][signal].remove(receiver)
+        except:
+            pass
+        _cleanupConnections(senderkey, signal)
+
+def _cleanupConnections(senderkey, signal):
+    """Delete any empty signals for senderkey. Delete senderkey if empty."""
+    receivers = connections[senderkey][signal]
+    if not receivers:
+        # No more connected receivers. Therefore, remove the signal.
+        signals = connections[senderkey]
+        del signals[signal]
+        if not signals:
+            # No more signal connections. Therefore, remove the sender.
+            _removeSender(senderkey)
+
+def _removeSender(senderkey):
+    """Remove senderkey from connections."""
+    del connections[senderkey]
+    # Senderkey will only be in senders dictionary if sender
+    # could be weakly referenced.
+    try:
+        del senders[senderkey]
+    except:
+        pass

wx/py/document.py

@@ -0,0 +1,37 @@
+"""Document class."""
+
+__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
+
+import os
+
+
+class Document:
+    """Document class."""
+
+    def __init__(self, filename=None):
+        """Create a Document instance."""
+        self.filename = filename
+        self.filepath = None
+        self.filedir = None
+        self.filebase = None
+        self.fileext = None
+        if self.filename:
+            self.filepath = os.path.realpath(self.filename)
+            self.filedir, self.filename = os.path.split(self.filepath)
+            self.filebase, self.fileext = os.path.splitext(self.filename)
+
+    def read(self):
+        """Return contents of file."""
+        if self.filepath and os.path.exists(self.filepath):
+            with open(self.filepath, 'rb') as f:
+                return f.read().decode('utf-8')
+        return ''
+
+    def write(self, text):
+        """Write text to file."""
+        with open(self.filepath, 'wb') as f:
+            try:  # Convert from unicode to bytes
+                text = text.encode('utf-8')
+                f.write(text)
+            except AttributeError:
+                pass