Merge lp:~jml/quickly/template-cleanup into lp:quickly

[Jonathan Lange]

[Jonathan Lange (jml)]

This branch changes the Ubuntu application templates to be a little nicer for the average Python programmer.

 - All excess whitespace is deleted
 - PEP 8 is followed where possible
 - Repeated code has been extracted into a 'helpers' module
 - Spelling mistakes have been corrected
 - Docstrings now conform to Python's docstring standards.
 - Comments are written as full sentences.
 - Double underscore prefixes are now single underscore prefixes

Hope this helps,
jml

[lp:~jml/quickly/template-cleanup]

408. By Jonathan Lange on 2009-12-31

Install the helpers file.

[Didier Roche-Tolomelli (didrocks)]

Hey Jonathan, thanks for your path.

I really have to find a vim script to format PEP8 compliant a python code (I know, you use emacs and don't care ;))

Thanks for this part:
647 - if __python_name_data_directory__.startswith('/'):
648 - pathname = __python_name_data_directory__
649 - else:
650 - pathname = os.path.dirname(__file__) + '/' + __python_name_data_directory__
651 + # Get pathname absolute or relative.
652 + path = os.path.join(
653 + os.path.dirname(__file__), __python_name_data_directory__)
I didn't know that joining two absolute path only take the second. Handy trick :)

Just a question, what is the __all__ in python_nameconfig.py is for? I only know this for autoimporting module in __init__.py, and you seem to still import function one by one:
from python_name.python_nameconfig import get_data_file
So, I don't really see its usefulness ;)

also, why importing multiple module in a same line is wrong?
(cf commit 404)

BTW, merged, thanks! I'll try to go file by file to include PEP8 compliance, but this is a long term work :)

review: Approve

[Jonathan Lange (jml)]

On Thu, Dec 31, 2009 at 7:53 PM, Didier Roche <email address hidden> wrote:
> Review: Approve
> Hey Jonathan, thanks for your path.
>
> I really have to find a vim script to format PEP8 compliant a python code (I know, you use emacs and don't care ;))
>

Heh heh.

> Thanks for this part:
> 647     - if __python_name_data_directory__.startswith('/'):
> 648     - pathname = __python_name_data_directory__
> 649     - else:
> 650     - pathname = os.path.dirname(__file__) + '/' + __python_name_data_directory__
> 651     + # Get pathname absolute or relative.
> 652     + path = os.path.join(
> 653     + os.path.dirname(__file__), __python_name_data_directory__)
> I didn't know that joining two absolute path only take the second. Handy trick :)
>
> Just a question, what is the __all__ in python_nameconfig.py is for? I only know this for autoimporting module in __init__.py, and you seem to still import function one by one:
> from python_name.python_nameconfig import get_data_file
> So, I don't really see its usefulness ;)
>

Ahh OK. It's there to indicate which names in the module are really
public. We don't have to have it if you don't want. Launchpad uses it
to check that people aren't using private stuff (we have a utility
called "importfascist" that does this).

> also, why importing multiple module in a same line is wrong?
> (cf commit 404)
>

PEP 8 says so.

> BTW, merged, thanks! I'll try to go file by file to include PEP8 compliance, but this is a long term work :)
>

Going file-by-file is the best approach. I changed all of these
because I wanted to start a Quickly project and not have a bunch of
red warnings on my screen. :)

jml

=== modified file 'data/templates/ubuntu-application/bin/project_name'
--- data/templates/ubuntu-application/bin/project_name	2009-12-26 14:40:43 +0000
+++ data/templates/ubuntu-application/bin/project_name	2009-12-31 02:05:23 +0000
@@ -8,104 +8,102 @@
 import os
 import gtk
 
-# add project root directory (enable symlink, and trunk execution)
-project_bin_directory = os.path.dirname(os.path.realpath(sys.argv[0]))
-project_root_directory_name = os.path.dirname(project_bin_directory)
-project_root_directory = os.path.abspath(project_root_directory_name)
-if os.path.exists(os.path.join(project_root_directory, 'python_name')) and project_root_directory not in sys.path:
-    sys.path.insert(0, project_root_directory)
-    os.putenv('PYTHONPATH', project_root_directory) # for subprocesses
-
-from python_name import Aboutcamel_case_nameDialog, Preferencescamel_case_nameDialog
-from python_name.python_nameconfig import getdatapath
+# Add project root directory (enable symlink, and trunk execution).
+PROJECT_ROOT_DIRECTORY = os.path.abspath(
+    os.path.dirname(os.path.dirname(os.path.realpath(sys.argv[0]))))
+
+if (os.path.exists(os.path.join(PROJECT_ROOT_DIRECTORY, 'python_name'))
+    and PROJECT_ROOT_DIRECTORY not in sys.path):
+    sys.path.insert(0, PROJECT_ROOT_DIRECTORY)
+    os.putenv('PYTHONPATH', PROJECT_ROOT_DIRECTORY) # for subprocesses
+
+from python_name import (
+    Aboutcamel_case_nameDialog, Preferencescamel_case_nameDialog)
+from python_name.helpers import make_window
+
 
 class camel_case_nameWindow(gtk.Window):
     __gtype_name__ = "camel_case_nameWindow"
 
     def __init__(self):
-        """__init__ - This function is typically not called directly.
-        Creation a camel_case_nameWindow requires redeading the associated ui
-        file and parsing the ui definition extrenally,
-        and then calling camel_case_nameWindow.finish_initializing().
+        """Construct a camel_case_nameWindow.
+
+        This function is typically not called directly. Creation a
+        camel_case_nameWindow requires rereading the associated ui file and
+        parsing the ui definition externally, and then calling
+        camel_case_nameWindow.finish_initializing().
 
         Use the convenience function Newcamel_case_nameWindow to create
         camel_case_nameWindow object.
-
         """
         pass
 
     def finish_initializing(self, builder):
-        """finish_initalizing should be called after parsing the ui definition
+        """Called after we've finished initializing.
+
+        finish_initalizing should be called after parsing the UI definition
         and creating a camel_case_nameWindow object with it in order to finish
         initializing the start of the new camel_case_nameWindow instance.
-
         """
-        #get a reference to the builder and set up the signals
+        # Get a reference to the builder and set up the signals.
         self.builder = builder
         self.builder.connect_signals(self)
 
-        #uncomment the following code to read in preferences at start up
+        # Uncomment the following code to read in preferences at start up.
         #dlg = Preferencescamel_case_nameDialog.NewPreferencescamel_case_nameDialog()
         #self.preferences = dlg.get_preferences()
 
-        #code for other initialization actions should be added here
+        # Code for other initialization actions should be added here.
 
     def about(self, widget, data=None):
-        """about - display the about box for project_name """
+        """Display the about box for project_name."""
         about = Aboutcamel_case_nameDialog.NewAboutcamel_case_nameDialog()
         response = about.run()
         about.destroy()
 
     def preferences(self, widget, data=None):
-        """preferences - display the preferences window for project_name """
+        """Display the preferences window for project_name."""
         prefs = Preferencescamel_case_nameDialog.NewPreferencescamel_case_nameDialog()
         response = prefs.run()
         if response == gtk.RESPONSE_OK:
-            #make any updates based on changed preferences here
+            # Make any updates based on changed preferences here.
             pass
         prefs.destroy()
 
     def quit(self, widget, data=None):
-        """quit - signal handler for closing the camel_case_nameWindow"""
+        """Signal handler for closing the camel_case_nameWindow."""
         self.destroy()
 
     def on_destroy(self, widget, data=None):
-        """on_destroy - called when the camel_case_nameWindow is close. """
-        #clean up code for saving application state should be added here
-
+        """Called when the camel_case_nameWindow is closed."""
+        # Clean up code for saving application state should be added here.
         gtk.main_quit()
 
+
 def Newcamel_case_nameWindow():
     """Newcamel_case_nameWindow - returns a fully instantiated
     camel_case_nameWindow object. Use this function rather than
     creating a camel_case_nameWindow directly.
     """
-
-    #look for the ui file that describes the ui
-    ui_filename = os.path.join(getdatapath(), 'ui', 'camel_case_nameWindow.ui')
-    if not os.path.exists(ui_filename):
-        ui_filename = None
-
-    builder = gtk.Builder()
-    builder.add_from_file(ui_filename)
-    window = builder.get_object("python_name_window")
-    window.finish_initializing(builder)
-    return window
+    return make_window('camel_case_nameWindow', "python_name_window")
+
 
 if __name__ == "__main__":
-    #support for command line options
-    import logging, optparse
+    # Support for command line options.
+    import logging
+    import optparse
     parser = optparse.OptionParser(version="%prog %ver")
-    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help="Show debug messages")
+    parser.add_option(
+        "-v", "--verbose", action="store_true", dest="verbose",
+        help="Show debug messages")
     (options, args) = parser.parse_args()
 
-    #set the logging level to show debug messages
+    # Set the logging level to show debug messages.
     if options.verbose:
         logging.basicConfig(level=logging.DEBUG)
         logging.debug('logging enabled')
 
-    #run the application
+    # Run the application.
     window = Newcamel_case_nameWindow()
     window.show()
     gtk.main()
-
 
=== modified file 'data/templates/ubuntu-application/create.py'
--- data/templates/ubuntu-application/create.py	2009-12-29 17:18:44 +0000
+++ data/templates/ubuntu-application/create.py	2009-12-31 02:05:23 +0000
@@ -120,6 +120,7 @@
 quicklyutils.file_from_template(template_python_dir, "Aboutcamel_case_nameDialog.py", target_python_dir, substitutions)
 quicklyutils.file_from_template(template_python_dir, "Preferencescamel_case_nameDialog.py", target_python_dir, substitutions)
 quicklyutils.file_from_template(template_python_dir, "python_nameconfig.py", target_python_dir, substitutions)
+quicklyutils.file_from_template(template_python_dir, 'helpers.py', target_python_dir, substitutions)
 
 # copy the files needed for packaging
 quicklyutils.file_from_template(abs_path, "project_root/setup.py", ".", substitutions)
 
=== modified file 'data/templates/ubuntu-application/python/Aboutcamel_case_nameDialog.py'
--- data/templates/ubuntu-application/python/Aboutcamel_case_nameDialog.py	2009-12-26 14:40:43 +0000
+++ data/templates/ubuntu-application/python/Aboutcamel_case_nameDialog.py	2009-12-31 02:05:23 +0000
@@ -3,59 +3,53 @@
 # This file is in the public domain
 ### END LICENSE
 
-import sys
-import os
 import gtk
 
-from python_name.python_nameconfig import getdatapath
+from python_name.helpers import make_window
+
 
 class Aboutcamel_case_nameDialog(gtk.AboutDialog):
     __gtype_name__ = "Aboutcamel_case_nameDialog"
 
     def __init__(self):
-        """__init__ - This function is typically not called directly.
-        Creation of a Aboutcamel_case_nameDialog requires redeading the associated ui
-        file and parsing the ui definition extrenally, 
-        and then calling Aboutcamel_case_nameDialog.finish_initializing().
-    
-        Use the convenience function NewAboutcamel_case_nameDialog to create 
+        """Construct an Aboutcamel_case_nameDialog.
+
+        This function is typically not called directly. Creation of an
+        Aboutcamel_case_nameDialog requires redeading the associated UI file
+        and parsing the UI definition externally, and then calling
+        Aboutcamel_case_nameDialog.finish_initializing().
+
+        Use the convenience function NewAboutcamel_case_nameDialog to create
         NewAboutcamel_case_nameDialog objects.
-    
         """
         pass
 
     def finish_initializing(self, builder):
-        """finish_initalizing should be called after parsing the ui definition
-        and creating a Aboutcamel_case_nameDialog object with it in order to finish
-        initializing the start of the new Aboutcamel_case_nameDialog instance.
-    
+        """Called after we've finished initializing.
+
+        finish_initalizing should be called after parsing the ui definition
+        and creating a Aboutcamel_case_nameDialog object with it in order to
+        finish initializing the start of the new Aboutcamel_case_nameDialog
+        instance.
         """
-        #get a reference to the builder and set up the signals
+        # Get a reference to the builder and set up the signals.
         self.builder = builder
         self.builder.connect_signals(self)
 
-        #code for other initialization actions should be added here
+        # Code for other initialization actions should be added here.
+
 
 def NewAboutcamel_case_nameDialog():
-    """NewAboutcamel_case_nameDialog - returns a fully instantiated
-    Aboutcamel_case_nameDialog object. Use this function rather than
-    creating a Aboutcamel_case_nameDialog instance directly.
-    
+    """Returns a fully instantiated Aboutcamel_case_nameDialog object.
+
+    Use this function rather than creating a Aboutcamel_case_nameDialog
+    instance directly.
     """
-
-    #look for the ui file that describes the ui
-    ui_filename = os.path.join(getdatapath(), 'ui', 'Aboutcamel_case_nameDialog.ui')
-    if not os.path.exists(ui_filename):
-        ui_filename = None
-
-    builder = gtk.Builder()
-    builder.add_from_file(ui_filename)    
-    dialog = builder.get_object("about_python_name_dialog")
-    dialog.finish_initializing(builder)
-    return dialog
+    return make_window(
+        'Aboutcamel_case_nameDialog', "about_python_name_dialog")
+
 
 if __name__ == "__main__":
     dialog = NewAboutcamel_case_nameDialog()
     dialog.show()
     gtk.main()
-
 
=== modified file 'data/templates/ubuntu-application/python/Preferencescamel_case_nameDialog.py'
--- data/templates/ubuntu-application/python/Preferencescamel_case_nameDialog.py	2009-12-26 14:40:43 +0000
+++ data/templates/ubuntu-application/python/Preferencescamel_case_nameDialog.py	2009-12-31 02:05:23 +0000
@@ -3,118 +3,118 @@
 # This file is in the public domain
 ### END LICENSE
 
-import sys
-import os
-import gtk
 from desktopcouch.records.server import CouchDatabase
 from desktopcouch.records.record import Record
-
-from python_name.python_nameconfig import getdatapath
+import gtk
+
+from python_name.helpers import make_window
+
 
 class Preferencescamel_case_nameDialog(gtk.Dialog):
     __gtype_name__ = "Preferencescamel_case_nameDialog"
-    prefernces = {}
+    preferences = {}
 
     def __init__(self):
-        """__init__ - This function is typically not called directly.
-        Creation of a Preferencescamel_case_nameDialog requires redeading the associated ui
-        file and parsing the ui definition extrenally,
-        and then calling Preferencescamel_case_nameDialog.finish_initializing().
-
-        Use the convenience function NewPreferencescamel_case_nameDialog to create
-        NewAboutcamel_case_nameDialog objects.
+        """Construct a Preferencescamel_case_nameDialog.
+
+        This function is typically not called directly. Creation of a
+        Preferencescamel_case_nameDialog requires rereading the associated UI
+        file and parsing the UI definition extrenally, and then calling
+        Preferencescamel_case_nameDialog.finish_initializing().
+
+        Use the convenience function NewPreferencescamel_case_nameDialog to
+        create NewAboutcamel_case_nameDialog objects.
         """
-
         pass
 
     def finish_initializing(self, builder):
-        """finish_initalizing should be called after parsing the ui definition
-        and creating a Aboutcamel_case_nameDialog object with it in order to finish
-        initializing the start of the new Aboutcamel_case_nameDialog instance.
+        """Called after we've finished initializing.
+
+        finish_initalizing should be called after parsing the ui definition
+        and creating a Aboutcamel_case_nameDialog object with it in order to
+        finish initializing the start of the new Aboutcamel_case_nameDialog
+        instance.
         """
 
-        #get a reference to the builder and set up the signals
+        # Get a reference to the builder and set up the signals.
         self.builder = builder
         self.builder.connect_signals(self)
 
-        #set up couchdb and the preference info
-        self.__db_name = "project_name"
-        self.__database = CouchDatabase(self.__db_name, create=True)
-        self.__preferences = None
-        self.__key = None
+        # Set up couchdb and the preference info.
+        self._db_name = "project_name"
+        self._database = CouchDatabase(self._db_name, create=True)
+        self._preferences = None
+        self._key = None
 
-        #set the record type and then initalize the preferences
-        self.__record_type = "http://wiki.ubuntu.com/Quickly/RecordTypes/camel_case_name/Preferences"
-        self.__preferences = self.get_preferences()
-        #TODO:code for other initialization actions should be added here
+        # Set the record type and then initalize the preferences.
+        self._record_type = (
+            "http://wiki.ubuntu.com/Quickly/RecordTypes/camel_case_name/"
+            "Preferences")
+        self._preferences = self.get_preferences()
+        # TODO: code for other initialization actions should be added here
 
     def get_preferences(self):
-        """get_preferences  -returns a dictionary object that contain
-        preferences for project_name. Creates a couchdb record if
-        necessary.
+        """Return a dict of preferences for project_name.
+
+        Creates a couchdb record if necessary.
         """
-
-        if self.__preferences == None: #the dialog is initializing
-            self.__load_preferences()
-            
-        #if there were no saved preference, this 
-        return self.__preferences
-
-    def __load_preferences(self):
-        #TODO: add prefernces to the self.__preferences dict
-        #default preferences that will be overwritten if some are saved
-        self.__preferences = {"record_type":self.__record_type}
-        
-        results = self.__database.get_records(record_type=self.__record_type, create_view=True)
-       
+        if self._preferences == None:
+            # The dialog is initializing.
+            self._load_preferences()
+
+        # If there were no saved preference, this.
+        return self._preferences
+
+    def _load_preferences(self):
+        # TODO: add preferences to the self._preferences dict default
+        # preferences that will be overwritten if some are saved
+        self._preferences = {"record_type": self._record_type}
+
+        results = self._database.get_records(
+            record_type=self._record_type, create_view=True)
+
         if len(results.rows) == 0:
-            #no preferences have ever been saved
-            #save them before returning
-            self.__key = self.__database.put_record(Record(self.__preferences))
+            # No preferences have ever been saved, save them before returning.
+            self._key = self._database.put_record(Record(self._preferences))
         else:
-            self.__preferences = results.rows[0].value
-            del self.__preferences['_rev']
-            self.__key = results.rows[0].value["_id"]
-        
-    def __save_preferences(self):
-        self.__database.update_fields(self.__key, self.__preferences)
+            self._preferences = results.rows[0].value
+            del self._preferences['_rev']
+            self._key = results.rows[0].value["_id"]
+
+    def _save_preferences(self):
+        self._database.update_fields(self._key, self._preferences)
 
     def ok(self, widget, data=None):
-        """ok - The user has elected to save the changes.
+        """The user has elected to save the changes.
+
         Called before the dialog returns gtk.RESONSE_OK from run().
         """
 
-        #make any updates to self.__preferences here
-        #self.__preferences["preference1"] = "value2"
-        self.__save_preferences()
+        # Make any updates to self._preferences here. e.g.
+        #self._preferences["preference1"] = "value2"
+        self._save_preferences()
 
     def cancel(self, widget, data=None):
-        """cancel - The user has elected cancel changes.
+        """The user has elected cancel changes.
+
         Called before the dialog returns gtk.RESPONSE_CANCEL for run()
         """
-
-        #restore any changes to self.__preferences here
+        # Restore any changes to self._preferences here.
         pass
 
+
 def NewPreferencescamel_case_nameDialog():
-    """NewPreferencescamel_case_nameDialog - returns a fully instantiated
-    Preferencescamel_case_nameDialog object. Use this function rather than
-    creating a Preferencescamel_case_nameDialog instance directly.
+    """Returns a fully instantiated Preferencescamel_case_nameDialog object.
+
+    Use this function rather than creating a Preferencescamel_case_nameDialog
+    instance directly.
     """
-
-    #look for the ui file that describes the ui
-    ui_filename = os.path.join(getdatapath(), 'ui', 'Preferencescamel_case_nameDialog.ui')
-    if not os.path.exists(ui_filename):
-        ui_filename = None
-
-    builder = gtk.Builder()
-    builder.add_from_file(ui_filename)
-    dialog = builder.get_object("preferences_python_name_dialog")
-    dialog.finish_initializing(builder)
-    return dialog
+    return make_window(
+        'Preferencescamel_case_nameDialog',
+        "preferences_python_name_dialog")
+
 
 if __name__ == "__main__":
     dialog = NewPreferencescamel_case_nameDialog()
     dialog.show()
     gtk.main()
-
 
=== modified file 'data/templates/ubuntu-application/python/dialog_camel_case_nameDialog.py'
--- data/templates/ubuntu-application/python/dialog_camel_case_nameDialog.py	2009-12-23 07:18:48 +0000
+++ data/templates/ubuntu-application/python/dialog_camel_case_nameDialog.py	2009-12-31 02:05:23 +0000
@@ -3,72 +3,65 @@
 # This file is in the public domain
 ### END LICENSE
 
-import sys
-import os
 import gtk
 
-from python_name.python_nameconfig import getdatapath
+from python_name.helpers import make_window
+
 
 class dialog_camel_case_nameDialog(gtk.Dialog):
     __gtype_name__ = "dialog_camel_case_nameDialog"
 
     def __init__(self):
-        """__init__ - This function is typically not called directly.
-        Creation of a dialog_camel_case_nameDialog requires redeading the associated ui
-        file and parsing the ui definition extrenally, 
-        and then calling dialog_camel_case_nameDialog.finish_initializing().
-    
-        Use the convenience function Newdialog_camel_case_nameDialog to create 
+        """Construct a dialog_camel_case_nameDialog.
+
+        This function is typically not called directly. Creation of a
+        dialog_camel_case_nameDialog requires rereading the associated UI file
+        and parsing the UI definition externally, and then calling
+        dialog_camel_case_nameDialog.finish_initializing().
+
+        Use the convenience function Newdialog_camel_case_nameDialog to create
         a dialog_camel_case_nameDialog object.
-    
         """
         pass
 
     def finish_initializing(self, builder):
-        """finish_initalizing should be called after parsing the ui definition
-        and creating a dialog_camel_case_nameDialog object with it in order to finish
-        initializing the start of the new dialog_camel_case_nameDialog instance.
-    
+        """Called when we're finished initializing.
+
+        finish_initalizing should be called after parsing the ui definition
+        and creating a dialog_camel_case_nameDialog object with it in order to
+        finish initializing the start of the new dialog_camel_case_nameDialog
+        instance.
         """
-        #get a reference to the builder and set up the signals
+        # Get a reference to the builder and set up the signals.
         self.builder = builder
         self.builder.connect_signals(self)
 
-
     def ok(self, widget, data=None):
-        """ok - The user has elected to save the changes.
+        """The user has elected to save the changes.
+
         Called before the dialog returns gtk.RESONSE_OK from run().
-
         """
         pass
 
     def cancel(self, widget, data=None):
-        """cancel - The user has elected cancel changes.
+        """The user has elected cancel changes.
+
         Called before the dialog returns gtk.RESPONSE_CANCEL for run()
-
-        """         
+        """
         pass
 
+
 def Newdialog_camel_case_nameDialog():
-    """Newdialog_camel_case_nameDialog - returns a fully instantiated
-    dialog-camel_case_nameDialog object. Use this function rather than
-    creating dialog_camel_case_nameDialog instance directly.
-    
+    """Return a fully instantiated dialog-camel_case_nameDialog object.
+
+    Use this function rather than creating dialog_camel_case_nameDialog
+    instance directly.
     """
-
-    #look for the ui file that describes the ui
-    ui_filename = os.path.join(getdatapath(), 'ui', 'dialog_camel_case_nameDialog.ui')
-    if not os.path.exists(ui_filename):
-        ui_filename = None
-
-    builder = gtk.Builder()
-    builder.add_from_file(ui_filename)    
-    dialog = builder.get_object("dialog_name_dialog")
-    dialog.finish_initializing(builder)
-    return dialog
+    return make_window(
+        'dialog_camel_case_nameDialog', "dialog_name_dialog")
+
 
 if __name__ == "__main__":
     dialog = Newdialog_camel_case_nameDialog()
     dialog.show()
     gtk.main()
-
 
=== added file 'data/templates/ubuntu-application/python/helpers.py'
--- data/templates/ubuntu-application/python/helpers.py	1970-01-01 00:00:00 +0000
+++ data/templates/ubuntu-application/python/helpers.py	2009-12-31 02:05:23 +0000
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+### BEGIN LICENSE
+# This file is in the public domain
+### END LICENSE
+
+"""Helpers for an Ubuntu application."""
+
+__all__ = [
+    'make_window',
+    ]
+
+import os
+import gtk
+
+from python_name.python_nameconfig import get_data_file
+
+
+def make_window(builder_file_name, window_name):
+    """Return a fully-instantiated window or dialog.
+
+    :param builder_file_name: The name of the builder file, without extension.
+        Assumed to be in the 'ui' directory under the data path.
+    :param window_name: The name of the window or dialog in the builder file.
+    """
+    # Look for the ui file that describes the user interface.
+    ui_filename = get_data_file('ui', '%s.ui' % (builder_file_name,))
+    if not os.path.exists(ui_filename):
+        ui_filename = None
+
+    builder = gtk.Builder()
+    builder.add_from_file(ui_filename)
+    dialog = builder.get_object(window_name)
+    dialog.finish_initializing(builder)
+    return dialog
 
=== modified file 'data/templates/ubuntu-application/python/python_nameconfig.py'
--- data/templates/ubuntu-application/python/python_nameconfig.py	2009-12-29 17:31:56 +0000
+++ data/templates/ubuntu-application/python/python_nameconfig.py	2009-12-31 02:05:23 +0000
@@ -8,17 +8,35 @@
 # Do not touch unless you know what you're doing.
 # you're warned :)
 
-# where your project will head for your data (for instance, images and ui files)
-# by default, this is ../data, relative your trunk layout
+__all__ = [
+    'project_path_not_found',
+    'get_data_file',
+    'get_data_path',
+    ]
+
+# Where your project will look for your data (for instance, images and ui
+# files). By default, this is ../data, relative your trunk layout
 __python_name_data_directory__ = '../data/'
 __license__ = ''
 
 import os
 
+
 class project_path_not_found(Exception):
-    pass
-
-def getdatapath():
+    """Raised when we can't find the project directory."""
+
+
+def get_data_file(*path_segments):
+    """Get the full path to a data file.
+
+    Returns the path to a file underneath the data directory (as defined by
+    `get_data_path`). Equivalent to os.path.join(get_data_path(),
+    *path_segments).
+    """
+    return os.path.join(get_data_path(), *path_segments)
+
+
+def get_data_path():
     """Retrieve project_name data path
 
     This path is by default <python_name_lib_path>/../data/ in trunk
@@ -26,15 +44,12 @@
     is specified at installation time.
     """
 
-    # get pathname absolute or relative
-    if __python_name_data_directory__.startswith('/'):
-        pathname = __python_name_data_directory__
-    else:
-        pathname = os.path.dirname(__file__) + '/' + __python_name_data_directory__
+    # Get pathname absolute or relative.
+    path = os.path.join(
+        os.path.dirname(__file__), __python_name_data_directory__)
 
-    abs_data_path = os.path.abspath(pathname)
-    if os.path.exists(abs_data_path):
-        return abs_data_path
-    else:
+    abs_data_path = os.path.abspath(path)
+    if not os.path.exists(abs_data_path):
         raise project_path_not_found
 
+    return abs_data_path