Merge lp:~dobey/ubuntu-sso-client/update-4-0 into lp:ubuntu-sso-client/stable-4-0

[dobey]

[Brian Curtin]

    - Prepare codebase for transition to Python 3 with respect to Unicode usage.
    - Switch to Python 2 and 3 safe usage of a metaclass for IPC.
    - Remove SyncTimestampChecker as it is no longer used.
    - Unpack tuple function arguments in a Python 2 and 3 friendly way.
    - The second of three changes to prepare SSO for Python 3 Unicode usage.
    - The first of several changes to prepare sso for Python 3 Unicode usage.

[Mike McCracken]

    - Fix hang on captcha generation due to PIL exception. (LP: #1031437)

[Eric Casteleijn (thisfred)]

review: Approve

[Roberto Alsina (ralsina)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntu-sso-client/update-4-0 into lp:ubuntu-sso-client/stable-4-0 failed. Below is the output from the failed tests.

*** Running QT test suite for ubuntu_sso ***
running build
Compiled data/qt/proxy_credentials_dialog.ui into ubuntu_sso/qt/ui/proxy_credentials_dialog_ui.py
Compiled data/qt/email_verification.ui into ubuntu_sso/qt/ui/email_verification_ui.py
Compiled data/qt/reset_password.ui into ubuntu_sso/qt/ui/reset_password_ui.py
Compiled data/qt/forgotten_password.ui into ubuntu_sso/qt/ui/forgotten_password_ui.py
Compiled data/qt/current_user_sign_in.ui into ubuntu_sso/qt/ui/current_user_sign_in_ui.py
Compiled data/qt/error_message.ui into ubuntu_sso/qt/ui/error_message_ui.py
Compiled data/qt/network_detection.ui into ubuntu_sso/qt/ui/network_detection_ui.py
Compiled data/qt/ssl_dialog.ui into ubuntu_sso/qt/ui/ssl_dialog_ui.py
Compiled data/qt/setup_account.ui into ubuntu_sso/qt/ui/setup_account_ui.py
Compiled data/qt/loadingoverlay.ui into ubuntu_sso/qt/ui/loadingoverlay_ui.py
compiled data/qt/resources.qrc into ubuntu_sso/qt/ui/resources_rc.py
Compiled data/qt/success_message.ui into ubuntu_sso/qt/ui/success_message_ui.py
running build_py
creating build
creating build/lib.linux-x86_64-2.7
creating build/lib.linux-x86_64-2.7/ubuntu_sso
copying ubuntu_sso/credentials.py -> build/lib.linux-x86_64-2.7/ubuntu_sso
copying ubuntu_sso/logger.py -> build/lib.linux-x86_64-2.7/ubuntu_sso
copying ubuntu_sso/__init__.py -> build/lib.linux-x86_64-2.7/ubuntu_sso
copying ubuntu_sso/account.py -> build/lib.linux-x86_64-2.7/ubuntu_sso
creating build/lib.linux-x86_64-2.7/ubuntu_sso/tests
copying ubuntu_sso/tests/test_credentials.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/tests
copying ubuntu_sso/tests/test_account.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/tests
copying ubuntu_sso/tests/__init__.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/tests
copying ubuntu_sso/tests/linux.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/tests
creating build/lib.linux-x86_64-2.7/ubuntu_sso/keyring
copying ubuntu_sso/keyring/pykeyring.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/keyring
copying ubuntu_sso/keyring/__init__.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/keyring
copying ubuntu_sso/keyring/linux.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/keyring
creating build/lib.linux-x86_64-2.7/ubuntu_sso/keyring/tests
copying ubuntu_sso/keyring/tests/test_linux.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/keyring/tests
copying ubuntu_sso/keyring/tests/test_common.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/keyring/tests
copying ubuntu_sso/keyring/tests/test_pykeyring.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/keyring/tests
copying ubuntu_sso/keyring/tests/__init__.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/keyring/tests
creating build/lib.linux-x86_64-2.7/ubuntu_sso/main
copying ubuntu_sso/main/qt.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/main
copying ubuntu_sso/main/darwin.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/main
copying ubuntu_sso/main/perspective_broker.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/main
copying ubuntu_sso/main/glib.py -> build/lib.linux-x86_64-2.7/ubuntu_sso/main
copying ubuntu_sso/main/__init__.py -> build/lib.linu...

[lp:~dobey/ubuntu-sso-client/update-4-0]

965. By Brian Curtin on 2012-08-21

[Brian Curtin]

    - Prepare codebase for transition to Python 3 with respect to Unicode usage.
    - Switch to Python 2 and 3 safe usage of a metaclass for IPC.
    - Remove SyncTimestampChecker as it is no longer used.
    - Unpack tuple function arguments in a Python 2 and 3 friendly way.
    - The second of three changes to prepare SSO for Python 3 Unicode usage.
    - The first of several changes to prepare sso for Python 3 Unicode usage.

[Mike McCracken]

    - Fix hang on captcha generation due to PIL exception. (LP: #1031437)

=== modified file 'ubuntu_sso/account.py'
--- ubuntu_sso/account.py	2012-06-22 21:04:49 +0000
+++ ubuntu_sso/account.py	2012-08-21 18:02:19 +0000
@@ -35,19 +35,21 @@
 
 """
 
+from __future__ import unicode_literals
+
 import os
 import re
 
 from twisted.internet import defer
 
 from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.utils import webclient
+from ubuntu_sso.utils import compat, webclient
 from ubuntu_sso.utils.webclient import restful
 from ubuntu_sso.utils.webclient.common import WebClientError
 
 
 logger = setup_logging("ubuntu_sso.account")
-SERVICE_URL = u"https://login.ubuntu.com/api/1.0/"
+SERVICE_URL = "https://login.ubuntu.com/api/1.0/"
 SSO_STATUS_OK = 'ok'
 SSO_STATUS_ERROR = 'error'
 
@@ -112,7 +114,7 @@
         result = {}
         for key, val in errdict.items():
             # workaround until bug #624955 is solved
-            if isinstance(val, basestring):
+            if isinstance(val, compat.basestring):
                 result[key] = val
             else:
                 result[key] = "\n".join(val)
@@ -125,7 +127,7 @@
                      filename)
         restful_client = restful.RestfulClient(self.service_url)
         try:
-            captcha = yield restful_client.restcall(u"captchas.new")
+            captcha = yield restful_client.restcall("captchas.new")
         finally:
             restful_client.shutdown()
 
@@ -162,7 +164,7 @@
                 logger.error('register_user: InvalidPasswordError')
                 raise InvalidPasswordError()
 
-            result = yield restful_client.restcall(u"registration.register",
+            result = yield restful_client.restcall("registration.register",
                         email=email, password=password,
                         displayname=displayname,
                         captcha_id=captcha_id,
@@ -189,7 +191,7 @@
                                                password=password)
         try:
             credentials = yield restful_client.restcall(
-                        u"authentications.authenticate",
+                        "authentications.authenticate",
                         token_name=token_name)
         except WebClientError:
             logger.exception('login failed with:')
@@ -208,7 +210,7 @@
         restful_client = restful.RestfulClient(self.service_url,
                                                oauth_credentials=token)
         try:
-            me_info = yield restful_client.restcall(u"accounts.me")
+            me_info = yield restful_client.restcall("accounts.me")
         finally:
             restful_client.shutdown()
         key = 'preferred_email'
@@ -229,7 +231,7 @@
         restful_client = restful.RestfulClient(self.service_url,
                                                oauth_credentials=credentials)
         try:
-            result = yield restful_client.restcall(u"accounts.validate_email",
+            result = yield restful_client.restcall("accounts.validate_email",
                                                    email_token=email_token)
         finally:
             restful_client.shutdown()
@@ -247,7 +249,7 @@
         """Request a token to reset the password for the account 'email'."""
         restful_client = restful.RestfulClient(self.service_url)
         try:
-            operation = u"registration.request_password_reset_token"
+            operation = "registration.request_password_reset_token"
             result = yield restful_client.restcall(operation, email=email)
         except WebClientError as e:
             logger.exception('request_password_reset_token failed with:')
@@ -272,7 +274,7 @@
         restful_client = restful.RestfulClient(self.service_url)
         try:
             result = yield restful_client.restcall(
-                                        u"registration.set_new_password",
+                                        "registration.set_new_password",
                                         email=email, token=token,
                                         new_password=new_password)
         except WebClientError as e:

=== modified file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	2012-07-13 21:07:38 +0000
+++ ubuntu_sso/credentials.py	2012-08-21 18:02:19 +0000
@@ -54,7 +54,7 @@
 )
 from ubuntu_sso.keyring import Keyring
 from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.utils import get_bin_cmd, runner
+from ubuntu_sso.utils import compat, get_bin_cmd, runner
 
 
 logger = setup_logging('ubuntu_sso.credentials')
@@ -189,8 +189,8 @@
             value = getattr(self, arg)
             if value:
                 args.append('--%s' % arg)
-                if not isinstance(value, basestring):
-                    value = str(value)
+                if not isinstance(value, compat.basestring):
+                    value = compat.text_type(value)
                 args.append(value)
 
         if login_only:

=== modified file 'ubuntu_sso/keyring/__init__.py'
--- ubuntu_sso/keyring/__init__.py	2012-06-27 20:41:19 +0000
+++ ubuntu_sso/keyring/__init__.py	2012-08-21 18:02:19 +0000
@@ -28,6 +28,8 @@
 # files in the program, then also delete it here.
 """Implementations of different keyrings."""
 
+from __future__ import unicode_literals
+
 import socket
 import sys
 
@@ -41,11 +43,12 @@
 from twisted.internet.defer import inlineCallbacks, returnValue
 
 from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils import compat
 
 logger = setup_logging("ubuntu_sso.keyring")
 
-TOKEN_SEPARATOR = u' @ '
-SEPARATOR_REPLACEMENT = u' AT '
+TOKEN_SEPARATOR = ' @ '
+SEPARATOR_REPLACEMENT = ' AT '
 
 U1_APP_NAME = "Ubuntu One"
 U1_KEY_NAME = "UbuntuOne token for https://ubuntuone.com"
@@ -58,7 +61,9 @@
 def gethostname():
     """Get the hostname, return the name as unicode."""
     sys_encoding = sys.getfilesystemencoding()
-    hostname = socket.gethostname().decode(sys_encoding)
+    hostname = socket.gethostname()
+    if isinstance(hostname, compat.binary_type):
+        return hostname.decode(sys_encoding)
     return hostname
 
 
@@ -68,10 +73,10 @@
     computer_name = gethostname()
     quoted_computer_name = quote(computer_name)
 
-    assert isinstance(computer_name, unicode)
-    assert isinstance(quoted_computer_name, unicode)
+    assert isinstance(computer_name, compat.text_type)
+    assert isinstance(quoted_computer_name, compat.text_type)
 
-    return u"%s - %s" % (quoted_app_name, quoted_computer_name)
+    return "%s - %s" % (quoted_app_name, quoted_computer_name)
 
 
 def get_token_name(app_name):
@@ -80,8 +85,8 @@
     computer_name = computer_name.replace(TOKEN_SEPARATOR,
                                           SEPARATOR_REPLACEMENT)
 
-    assert isinstance(computer_name, unicode)
-    assert isinstance(computer_name, unicode)
+    assert isinstance(computer_name, compat.text_type)
+    assert isinstance(computer_name, compat.text_type)
 
     return TOKEN_SEPARATOR.join((app_name, computer_name))
 

=== modified file 'ubuntu_sso/keyring/tests/test_common.py'
--- ubuntu_sso/keyring/tests/test_common.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/keyring/tests/test_common.py	2012-08-21 18:02:19 +0000
@@ -33,6 +33,8 @@
 # files in the program, then also delete it here.
 """Tests for the keyring common module."""
 
+from __future__ import unicode_literals
+
 from twisted.trial.unittest import TestCase
 
 from ubuntu_sso import keyring
@@ -49,7 +51,7 @@
 
     def test_get_hostname_uses_filesystem_encoding(self):
         """The fs encoding is used to decode the name returned by socket."""
-        fake_hostname = u"Привет-ПК"
+        fake_hostname = "Привет-ПК"
         hostname_koi8r = fake_hostname.encode("koi8-r")
         self.patch(keyring.socket, "gethostname", lambda: hostname_koi8r)
         self.patch(keyring.sys, "getfilesystemencoding", lambda: "koi8-r")
@@ -67,35 +69,35 @@
 
     def test_get_simple_token_name(self):
         """A simple token name is built right."""
-        sample_app_name = u"UbuntuTwo"
+        sample_app_name = "UbuntuTwo"
         sample_hostname = "Darkstar"
         expected_result = "UbuntuTwo @ Darkstar"
         self.check_build(sample_app_name, sample_hostname, expected_result)
 
     def test_get_complex_token_name_for_app_name(self):
         """A complex token name is built right too."""
-        sample_app_name = u"Ubuntu @ Eleven"
+        sample_app_name = "Ubuntu @ Eleven"
         sample_hostname = "Mate+Cocido"
         expected_result = "Ubuntu @ Eleven @ Mate+Cocido"
         self.check_build(sample_app_name, sample_hostname, expected_result)
 
     def test_get_complex_token_name_for_hostname(self):
         """A complex token name is built right too."""
-        sample_app_name = u"Ubuntu Eleven"
+        sample_app_name = "Ubuntu Eleven"
         sample_hostname = "Mate @ Cocido"
         expected_result = "Ubuntu Eleven @ Mate AT Cocido"
         self.check_build(sample_app_name, sample_hostname, expected_result)
 
     def test_get_unicode_appname_token_name(self):
         """A token name with unicode in the app name."""
-        sample_app_name = u"Ubuntu 四百六十九"
+        sample_app_name = "Ubuntu 四百六十九"
         sample_hostname = "Darkstar"
-        expected_result = u"Ubuntu 四百六十九 @ Darkstar"
+        expected_result = "Ubuntu 四百六十九 @ Darkstar"
         self.check_build(sample_app_name, sample_hostname, expected_result)
 
     def test_get_utf8_hostname_token_name(self):
         """A token name with utf8 in the host name."""
-        sample_app_name = u"Ubuntu Eleven"
-        sample_hostname = u"Привет-ПК"
-        expected_result = u"Ubuntu Eleven @ Привет-ПК"
+        sample_app_name = "Ubuntu Eleven"
+        sample_hostname = "Привет-ПК"
+        expected_result = "Ubuntu Eleven @ Привет-ПК"
         self.check_build(sample_app_name, sample_hostname, expected_result)

=== modified file 'ubuntu_sso/keyring/tests/test_linux.py'
--- ubuntu_sso/keyring/tests/test_linux.py	2012-06-22 16:55:35 +0000
+++ ubuntu_sso/keyring/tests/test_linux.py	2012-08-21 18:02:19 +0000
@@ -33,6 +33,8 @@
 # files in the program, then also delete it here.
 """Tests for the keyring.py module."""
 
+from __future__ import unicode_literals
+
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks
 from twisted.trial.unittest import TestCase
@@ -133,7 +135,7 @@
         self.mock_service = None
         self.service = self.patch(keyring, "SecretService",
                                   self.get_mock_service)
-        self.patch(common_keyring, "gethostname", lambda: u"darkstar")
+        self.patch(common_keyring, "gethostname", lambda: "darkstar")
 
     def get_mock_service(self):
         """Create only one instance of the mock service per test."""

=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2012-07-12 15:54:13 +0000
+++ ubuntu_sso/main/__init__.py	2012-08-21 18:02:19 +0000
@@ -52,6 +52,7 @@
 )
 from ubuntu_sso.keyring import get_token_name, Keyring
 from ubuntu_sso.logger import setup_logging, log_call
+from ubuntu_sso.utils import compat
 
 
 logger = setup_logging("ubuntu_sso.main")
@@ -109,7 +110,7 @@
         result["message"] = e.__class__.__doc__
     elif isinstance(e.args[0], dict):
         result.update(e.args[0])
-    elif isinstance(e.args[0], basestring):
+    elif isinstance(e.args[0], compat.basestring):
         result["message"] = e.args[0]
 
     return result

=== modified file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/main/tests/test_common.py	2012-08-21 18:02:19 +0000
@@ -28,6 +28,8 @@
 # files in the program, then also delete it here.
 """Tests for the main SSO client code."""
 
+from __future__ import unicode_literals
+
 import logging
 
 from functools import partial
@@ -137,7 +139,7 @@
         class MyException(Exception):
             """Custom Exception."""
 
-        message = u'My custom error for ♥ Ubuntu'
+        message = 'My custom error for ♥ Ubuntu'
         my_exc = MyException(message)
         result = except_to_errdict(my_exc)
         self.assertEqual(result["errtype"], my_exc.__class__.__name__)
@@ -145,7 +147,7 @@
 
     def test_first_arg_is_unicode(self):
         """If the first arg is a unicode, use it as the message."""
-        sample_string = u"a sample string"
+        sample_string = "a sample string"
         e = TestExceptToErrdictException(sample_string)
         result = except_to_errdict(e)
         self.assertEqual(result["errtype"], e.__class__.__name__)
@@ -160,7 +162,7 @@
 
     def test_some_other_thing_as_first_arg(self):
         """If first arg is not basestring nor dict, then repr all args."""
-        sample_args = (None, u"unicode2\ufffd", "errorcode3")
+        sample_args = (None, "unicode2\ufffd", "errorcode3")
         e = TestExceptToErrdictException(*sample_args)
         result = except_to_errdict(e)
         self.assertEqual(result["errtype"], e.__class__.__name__)

=== modified file 'ubuntu_sso/qt/__init__.py'
--- ubuntu_sso/qt/__init__.py	2012-06-27 19:03:44 +0000
+++ ubuntu_sso/qt/__init__.py	2012-08-21 18:02:19 +0000
@@ -28,6 +28,8 @@
 # files in the program, then also delete it here.
 """The Qt graphical interface for the Ubuntu Single Sign On Client."""
 
+from __future__ import unicode_literals
+
 import sys
 import collections
 
@@ -38,13 +40,13 @@
 
 logger = setup_gui_logging('ubuntu_sso.qt')
 
-LINK_STYLE = (u'<a href="{link_url}">'
+LINK_STYLE = ('<a href="{link_url}">'
               '<span style="color:#df2d1f;">{link_text}</span></a>')
 ERROR_ALL = '__all__'
-ERROR_STYLE = u'<font color="#df2d1f" style="font-size:small"><b>%s</b></font>'
+ERROR_STYLE = '<font color="#df2d1f" style="font-size:small"><b>%s</b></font>'
 ERROR_MESSAGE = 'message'
 PREFERED_UI_SIZE = {'width': 550, 'height': 525}
-TITLE_STYLE = u'<span style="font-size:xx-large;font-weight:bold;">%s</span>'
+TITLE_STYLE = '<span style="font-size:xx-large;font-weight:bold;">%s</span>'
 WINDOW_TITLE = 'Ubuntu Single Sign On'
 
 # TODO: There is a pixel discrepancy between Qt on Linux and Windows

=== modified file 'ubuntu_sso/qt/common.py'
--- ubuntu_sso/qt/common.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/common.py	2012-08-21 18:02:19 +0000
@@ -30,8 +30,11 @@
 # files in the program, then also delete it here.
 """Common functionality used by the UI modules."""
 
+from __future__ import unicode_literals
+
 import re
 
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     PASSWORD_DIGIT,
     PASSWORD_LENGTH,
@@ -41,14 +44,14 @@
 )
 
 # all the text + styles that are used in the gui
-BAD = u'<img src=":/password_hint_warning.png" /><small> %s </small>'
-GOOD = u'<img src=":/password_hint_ok.png" /><small> %s </small>'
-NORMAL = u'<small> %s </small>'
+BAD = '<img src=":/password_hint_warning.png" /><small> %s </small>'
+GOOD = '<img src=":/password_hint_ok.png" /><small> %s </small>'
+NORMAL = '<small> %s </small>'
 
 
 def password_assistance(line_edit, assistance, icon_type=BAD):
     """Show help for the password field."""
-    text1 = unicode(line_edit.text())
+    text1 = compat.text_type(line_edit.text())
     label_text = ["<b>%s</b>" % PASSWORD_MUST_CONTAIN, ]
 
     if len(text1) < 8:
@@ -75,9 +78,9 @@
 def password_check_match(line_edit, line_edit_confirm, assistance):
     """Check if passwords match, otherwise show a message."""
     password_assistance(line_edit, assistance)
-    label_text = unicode(assistance.text())
-    text1 = unicode(line_edit.text())
-    text2 = unicode(line_edit_confirm.text())
+    label_text = compat.text_type(assistance.text())
+    text1 = compat.text_type(line_edit.text())
+    text2 = compat.text_type(line_edit_confirm.text())
     if text1 != text2:
         label_text += "<br>" + BAD % PASSWORD_MATCH
     assistance.setText(label_text)

=== modified file 'ubuntu_sso/qt/current_user_sign_in_page.py'
--- ubuntu_sso/qt/current_user_sign_in_page.py	2012-06-08 13:33:39 +0000
+++ ubuntu_sso/qt/current_user_sign_in_page.py	2012-08-21 18:02:19 +0000
@@ -37,6 +37,7 @@
 from ubuntu_sso.qt import LINK_STYLE, build_general_error_message
 from ubuntu_sso.qt.sso_wizard_page import SSOWizardPage
 from ubuntu_sso.qt.ui.current_user_sign_in_ui import Ui_CurrentUserSignInPage
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     CANCEL_BUTTON,
     EMAIL_LABEL,
@@ -56,9 +57,9 @@
     """Wizard Page that lets a current user Sign into Ubuntu Single Sign On."""
 
     ui_class = Ui_CurrentUserSignInPage
-    userLoggedIn = QtCore.pyqtSignal(unicode)
+    userLoggedIn = QtCore.pyqtSignal(compat.text_type)
     passwordForgotten = QtCore.pyqtSignal()
-    userNotValidated = QtCore.pyqtSignal(unicode)
+    userNotValidated = QtCore.pyqtSignal(compat.text_type)
 
     @property
     def _signals(self):
@@ -76,12 +77,12 @@
     @property
     def password(self):
         """Return the content of the password edit."""
-        return unicode(self.ui.password_edit.text())
+        return compat.text_type(self.ui.password_edit.text())
 
     def on_user_not_validated(self, app_name, email):
         """Show the validate email page."""
         self.hide_overlay()
-        email = unicode(self.ui.email_edit.text())
+        email = compat.text_type(self.ui.email_edit.text())
         self.userNotValidated.emit(email)
 
     # Invalid names of Qt-inherited methods
@@ -129,17 +130,19 @@
 
     def _validate(self):
         """Perform input validation."""
-        correct_mail = is_correct_email(unicode(self.ui.email_edit.text()))
-        correct_password = len(unicode(self.ui.password_edit.text())) > 0
+        correct_mail = is_correct_email(
+                        compat.text_type(self.ui.email_edit.text()))
+        correct_password = len(
+                        compat.text_type(self.ui.password_edit.text())) > 0
         enabled = correct_mail and correct_password
         self.ui.sign_in_button.setEnabled(enabled)
 
     def login(self):
         """Perform the login using the self.backend."""
         # grab the data from the view and call the backend
-        email = unicode(self.ui.email_edit.text())
+        email = compat.text_type(self.ui.email_edit.text())
         logger.info('CurrentUserSignInPage.login for: %s', email)
-        password = unicode(self.ui.password_edit.text())
+        password = compat.text_type(self.ui.password_edit.text())
         args = (self.app_name, email, password)
         if self.ping_url:
             f = self.backend.login_and_ping
@@ -163,7 +166,7 @@
         """We managed to log in."""
         logger.info('Logged in for %s', app_name)
         self.hide_overlay()
-        email = unicode(self.ui.email_edit.text())
+        email = compat.text_type(self.ui.email_edit.text())
         logger.debug('About to emit userLoggedIn signal with: (%s).', email)
         self.userLoggedIn.emit(email)
 

=== modified file 'ubuntu_sso/qt/email_verification_page.py'
--- ubuntu_sso/qt/email_verification_page.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/email_verification_page.py	2012-08-21 18:02:19 +0000
@@ -37,6 +37,7 @@
 from ubuntu_sso.qt import build_general_error_message
 from ubuntu_sso.qt.sso_wizard_page import SSOWizardPage
 from ubuntu_sso.qt.ui.email_verification_ui import Ui_EmailVerificationPage
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     ERROR_EMAIL_TOKEN,
     NEXT,
@@ -53,7 +54,7 @@
     """Widget used to input the email verification code."""
 
     ui_class = Ui_EmailVerificationPage
-    registrationSuccess = QtCore.pyqtSignal(unicode)
+    registrationSuccess = QtCore.pyqtSignal(compat.text_type)
 
     def __init__(self, *args, **kwargs):
         self.email = ''
@@ -115,7 +116,7 @@
         """Call the next action."""
         logger.debug('EmailVerificationController.validate_email for: %s',
             self.email)
-        code = unicode(self.ui.verification_code_edit.text())
+        code = compat.text_type(self.ui.verification_code_edit.text())
         args = (self.app_name, self.email, self.password, code)
         self.hide_error()
         self.show_overlay()

=== modified file 'ubuntu_sso/qt/forgotten_password_page.py'
--- ubuntu_sso/qt/forgotten_password_page.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/forgotten_password_page.py	2012-08-21 18:02:19 +0000
@@ -36,6 +36,7 @@
 from ubuntu_sso.logger import setup_gui_logging, log_call
 from ubuntu_sso.qt.sso_wizard_page import SSOWizardEnhancedEditPage
 from ubuntu_sso.qt.ui.forgotten_password_ui import Ui_ForgottenPasswordPage
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     EMAIL_LABEL,
     FORGOTTEN_PASSWORD_TITLE,
@@ -53,7 +54,7 @@
     """Widget used to deal with users that forgot the password."""
 
     ui_class = Ui_ForgottenPasswordPage
-    passwordResetTokenSent = QtCore.pyqtSignal(unicode)
+    passwordResetTokenSent = QtCore.pyqtSignal(compat.text_type)
 
     @property
     def _signals(self):
@@ -69,7 +70,7 @@
     @property
     def email_address(self):
         """Return the email address provided by the user."""
-        return unicode(self.ui.email_line_edit.text())
+        return compat.text_type(self.ui.email_line_edit.text())
 
     #pylint: disable=C0103
 
@@ -122,7 +123,7 @@
 
     def _validate(self):
         """Validate that we have an email."""
-        email = unicode(self.ui.email_line_edit.text())
+        email = compat.text_type(self.ui.email_line_edit.text())
         self.ui.send_button.setEnabled(is_correct_email(email))
 
     def on_password_reset_token_sent(self, app_name, email):

=== modified file 'ubuntu_sso/qt/loadingoverlay.py'
--- ubuntu_sso/qt/loadingoverlay.py	2012-06-22 22:34:43 +0000
+++ ubuntu_sso/qt/loadingoverlay.py	2012-08-21 18:02:19 +0000
@@ -28,12 +28,14 @@
 # files in the program, then also delete it here.
 """Loading animation over a widget."""
 
+from __future__ import unicode_literals
+
 from PyQt4 import QtGui, QtCore
 
 from ubuntu_sso.qt.ui import loadingoverlay_ui
 from ubuntu_sso.utils.ui import LOADING_OVERLAY
 
-LOADING_STYLE = u'<span style="font-size:x-large;">{0}</span>'
+LOADING_STYLE = '<span style="font-size:x-large;">{0}</span>'
 
 
 class LoadingOverlay(QtGui.QFrame):

=== modified file 'ubuntu_sso/qt/main/__init__.py'
--- ubuntu_sso/qt/main/__init__.py	2012-06-13 21:26:02 +0000
+++ ubuntu_sso/qt/main/__init__.py	2012-08-21 18:02:19 +0000
@@ -38,7 +38,7 @@
 from ubuntu_sso.qt.ui import resources_rc
 # pylint: enable=W0611
 from ubuntu_sso.qt.ubuntu_sso_wizard import UbuntuSSOClientGUI
-from ubuntu_sso.utils import PLATFORM_QSS
+from ubuntu_sso.utils import compat, PLATFORM_QSS
 
 
 # Invalid name "source", pylint: disable=C0103
@@ -63,13 +63,13 @@
     data = []
     for qss_name in (PLATFORM_QSS, ":/stylesheet.qss"):
         qss = QtCore.QResource(qss_name)
-        data.append(unicode(qss.data()))
+        data.append(compat.text_type(qss.data()))
     app.setStyleSheet('\n'.join(data))
 
     # Fix the string that contains unicode chars.
     for key in kwargs:
         value = kwargs[key]
-        if isinstance(value, str):
+        if isinstance(value, compat.binary_type):
             kwargs[key] = value.decode('utf-8')
 
     # Unused variable 'ui', pylint: disable=W0612

=== modified file 'ubuntu_sso/qt/main/tests/test_main.py'
--- ubuntu_sso/qt/main/tests/test_main.py	2012-06-13 21:52:42 +0000
+++ ubuntu_sso/qt/main/tests/test_main.py	2012-08-21 18:02:19 +0000
@@ -37,6 +37,7 @@
 from twisted.trial.unittest import TestCase
 
 from ubuntu_sso.qt import main
+from ubuntu_sso.utils import compat
 from ubuntu_sso import tests
 
 
@@ -205,7 +206,7 @@
         data = []
         for qss_name in (main.PLATFORM_QSS, ":/stylesheet.qss"):
             qss = QtCore.QResource(qss_name)
-            data.append(unicode(qss.data()))
+            data.append(compat.text_type(qss.data()))
         self.assertEqual(
-        unicode(main.QtGui.QApplication.instance().styleSheet()),
+        compat.text_type(main.QtGui.QApplication.instance().styleSheet()),
             '\n'.join(data))

=== modified file 'ubuntu_sso/qt/proxy_dialog.py'
--- ubuntu_sso/qt/proxy_dialog.py	2012-06-22 16:12:03 +0000
+++ ubuntu_sso/qt/proxy_dialog.py	2012-08-21 18:02:19 +0000
@@ -38,6 +38,7 @@
 from ubuntu_sso.logger import setup_gui_logging
 from ubuntu_sso.keyring import Keyring
 from ubuntu_sso.qt.ui.proxy_credentials_dialog_ui import Ui_ProxyCredsDialog
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     CANCEL_BUTTON,
     PROXY_CREDS_DIALOG_TITLE,
@@ -109,8 +110,10 @@
     @defer.inlineCallbacks
     def _on_save_clicked(self, *args):
         """Save the new credentials."""
-        username = unicode(self.ui.username_entry.text()).encode('utf8')
-        password = unicode(self.ui.password_entry.text()).encode('utf8')
+        username = compat.text_type(
+                        self.ui.username_entry.text()).encode('utf8')
+        password = compat.text_type(
+                        self.ui.password_entry.text()).encode('utf8')
         creds = dict(username=username, password=password)
         # pylint: disable=W0703, W0612
         try:

=== modified file 'ubuntu_sso/qt/reset_password_page.py'
--- ubuntu_sso/qt/reset_password_page.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/reset_password_page.py	2012-08-21 18:02:19 +0000
@@ -38,6 +38,7 @@
 from ubuntu_sso.qt import build_general_error_message, common
 from ubuntu_sso.qt.sso_wizard_page import SSOWizardEnhancedEditPage
 from ubuntu_sso.qt.ui.reset_password_ui import Ui_ResetPasswordPage
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     is_min_required_password,
     PASSWORD1_ENTRY,
@@ -57,7 +58,7 @@
     """Widget used to allow the user change his password."""
 
     ui_class = Ui_ResetPasswordPage
-    passwordChanged = pyqtSignal(unicode)
+    passwordChanged = pyqtSignal(compat.text_type)
 
     @property
     def _signals(self):
@@ -146,9 +147,9 @@
     def _validate(self):
         """Enable the submit button if data is valid."""
         enabled = True
-        code = unicode(self.ui.reset_code_line_edit.text())
-        password = unicode(self.ui.password_line_edit.text())
-        confirm_password = unicode(
+        code = compat.text_type(self.ui.reset_code_line_edit.text())
+        password = compat.text_type(self.ui.password_line_edit.text())
+        confirm_password = compat.text_type(
             self.ui.confirm_password_line_edit.text())
         if not is_min_required_password(password):
             enabled = False
@@ -175,7 +176,8 @@
         logger.info('ResetPasswordPage.on_password_changed for %s, email: %s',
             app_name, email)
         self.hide_overlay()
-        email = unicode(self.wizard().forgotten.ui.email_line_edit.text())
+        email = compat.text_type(
+                    self.wizard().forgotten.ui.email_line_edit.text())
         self.passwordChanged.emit(email)
 
     def on_password_change_error(self, app_name, error):
@@ -187,9 +189,10 @@
     def set_new_password(self):
         """Request a new password to be set."""
         self.hide_error()
-        email = unicode(self.wizard().forgotten.ui.email_line_edit.text())
-        code = unicode(self.ui.reset_code_line_edit.text())
-        password = unicode(self.ui.password_line_edit.text())
+        email = compat.text_type(
+                    self.wizard().forgotten.ui.email_line_edit.text())
+        code = compat.text_type(self.ui.reset_code_line_edit.text())
+        password = compat.text_type(self.ui.password_line_edit.text())
         logger.info('Setting new password for %r and email %r with code %r',
                     self.app_name, email, code)
         args = (self.app_name, email, code, password)
@@ -201,4 +204,4 @@
 
     def is_correct_password_confirmation(self, password):
         """Return if the password is correct."""
-        return unicode(self.ui.password_line_edit.text()) == password
+        return compat.text_type(self.ui.password_line_edit.text()) == password

=== modified file 'ubuntu_sso/qt/setup_account_page.py'
--- ubuntu_sso/qt/setup_account_page.py	2012-07-03 21:30:33 +0000
+++ ubuntu_sso/qt/setup_account_page.py	2012-08-21 18:02:19 +0000
@@ -30,7 +30,7 @@
 
 import tempfile
 import os
-from io import StringIO
+from io import BytesIO
 from functools import partial
 
 # pylint: disable=F0401
@@ -53,6 +53,7 @@
 )
 from ubuntu_sso.qt.sso_wizard_page import SSOWizardEnhancedEditPage
 from ubuntu_sso.qt.ui.setup_account_ui import Ui_SetUpAccountPage
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     AGREE_TO_PRIVACY_POLICY,
     AGREE_TO_TERMS,
@@ -99,7 +100,7 @@
     """Customized Setup Account page for SSO."""
 
     ui_class = Ui_SetUpAccountPage
-    userRegistered = QtCore.pyqtSignal(unicode)
+    userRegistered = QtCore.pyqtSignal(compat.text_type)
 
     def __init__(self, *args, **kwargs):
         self.captcha_file = None
@@ -127,7 +128,7 @@
     @property
     def password(self):
         """Return the content of the password edit."""
-        return unicode(self.ui.password_edit.text())
+        return compat.text_type(self.ui.password_edit.text())
 
     # Invalid name "initializePage"
     # pylint: disable=C0103
@@ -263,12 +264,14 @@
 
     def _enable_setup_button(self):
         """Only enable the setup button if the form is valid."""
-        name = unicode(self.ui.name_edit.text()).strip()
-        email = unicode(self.ui.email_edit.text())
-        confirm_email = unicode(self.ui.confirm_email_edit.text())
-        password = unicode(self.ui.password_edit.text())
-        confirm_password = unicode(self.ui.confirm_password_edit.text())
-        captcha_solution = unicode(self.ui.captcha_solution_edit.text())
+        name = compat.text_type(self.ui.name_edit.text()).strip()
+        email = compat.text_type(self.ui.email_edit.text())
+        confirm_email = compat.text_type(self.ui.confirm_email_edit.text())
+        password = compat.text_type(self.ui.password_edit.text())
+        confirm_password = compat.text_type(
+                self.ui.confirm_password_edit.text())
+        captcha_solution = compat.text_type(
+                self.ui.captcha_solution_edit.text())
 
         # Check for len(name) > 0 to ensure that a bool is assigned to enabled
         if not self.terms_checkbox.isVisible():
@@ -326,10 +329,10 @@
         # done either by a setParent or something within the qtreactor, PIL
         # in this case does solve the issue. Sorry :(
         pil_image = Image.open(self.captcha_file)
-        string_io = StringIO()
-        pil_image.save(string_io, format='png')
+        bytes_io = BytesIO()
+        pil_image.save(bytes_io, format='png')
         pixmap_image = QtGui.QPixmap()
-        pixmap_image.loadFromData(string_io.getvalue())
+        pixmap_image.loadFromData(bytes_io.getvalue())
         self.captcha_image = pixmap_image
         self.on_captcha_refresh_complete()
 
@@ -355,18 +358,20 @@
     def on_user_registered(self, app_name, email):
         """Execute when the user did register."""
         self.hide_overlay()
-        email = unicode(self.ui.email_edit.text())
+        email = compat.text_type(self.ui.email_edit.text())
         self.userRegistered.emit(email)
 
     def validate_form(self):
         """Validate the info of the form and return an error."""
         logger.debug('SetUpAccountPage.validate_form')
-        name = unicode(self.ui.name_edit.text()).strip()
-        email = unicode(self.ui.email_edit.text())
-        confirm_email = unicode(self.ui.confirm_email_edit.text())
-        password = unicode(self.ui.password_edit.text())
-        confirm_password = unicode(self.ui.confirm_password_edit.text())
-        captcha_solution = unicode(self.ui.captcha_solution_edit.text())
+        name = compat.text_type(self.ui.name_edit.text()).strip()
+        email = compat.text_type(self.ui.email_edit.text())
+        confirm_email = compat.text_type(self.ui.confirm_email_edit.text())
+        password = compat.text_type(self.ui.password_edit.text())
+        confirm_password = compat.text_type(
+                self.ui.confirm_password_edit.text())
+        captcha_solution = compat.text_type(
+                self.ui.captcha_solution_edit.text())
         condition = True
         messages = []
         if not name:
@@ -395,11 +400,12 @@
     def set_next_validation(self):
         """Set the validation as the next page."""
         logger.debug('SetUpAccountPage.set_next_validation')
-        email = unicode(self.ui.email_edit.text())
-        password = unicode(self.ui.password_edit.text())
-        name = unicode(self.ui.name_edit.text())
+        email = compat.text_type(self.ui.email_edit.text())
+        password = compat.text_type(self.ui.password_edit.text())
+        name = compat.text_type(self.ui.name_edit.text())
         captcha_id = self.captcha_id
-        captcha_solution = unicode(self.ui.captcha_solution_edit.text())
+        captcha_solution = compat.text_type(
+                self.ui.captcha_solution_edit.text())
         # validate the current info of the form, try to perform the action
         # to register the user, and then move foward
         if self.validate_form():
@@ -418,11 +424,11 @@
 
     def is_correct_email_confirmation(self, email_address):
         """Return that the email is the same."""
-        return unicode(self.ui.email_edit.text()) == email_address
+        return compat.text_type(self.ui.email_edit.text()) == email_address
 
     def is_correct_password_confirmation(self, password):
         """Return that the passwords are correct."""
-        return unicode(self.ui.password_edit.text()) == password
+        return compat.text_type(self.ui.password_edit.text()) == password
 
     def focus_changed(self, old, now):
         """Check who has the focus to activate password popups if necessary."""
@@ -441,7 +447,7 @@
 
     def name_assistance(self):
         """Show help for the name field."""
-        text = unicode(self.ui.name_edit.text())
+        text = compat.text_type(self.ui.name_edit.text())
         if not text.strip():
             self.set_error_message(self.ui.name_assistance,
                 EMPTY_NAME)
@@ -452,7 +458,7 @@
 
     def email_assistance(self):
         """Show help for the email field."""
-        text = unicode(self.ui.email_edit.text())
+        text = compat.text_type(self.ui.email_edit.text())
         if not is_correct_email(text):
             self.set_error_message(self.ui.email_assistance,
                 INVALID_EMAIL)
@@ -463,8 +469,8 @@
 
     def confirm_email_assistance(self):
         """Show help for the confirm email field."""
-        text1 = unicode(self.ui.email_edit.text())
-        text2 = unicode(self.ui.confirm_email_edit.text())
+        text1 = compat.text_type(self.ui.email_edit.text())
+        text2 = compat.text_type(self.ui.confirm_email_edit.text())
         if text1 != text2:
             self.set_error_message(self.ui.confirm_email_assistance,
                 EMAIL_MATCH)

=== modified file 'ubuntu_sso/qt/tests/__init__.py'
--- ubuntu_sso/qt/tests/__init__.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/tests/__init__.py	2012-08-21 18:02:19 +0000
@@ -42,6 +42,7 @@
     TC_URL,
     WINDOW_ID,
 )
+from ubuntu_sso.utils import compat
 
 KWARGS = dict(app_name=APP_NAME, help_text=HELP_TEXT, ping_url=PING_URL,
               policy_url=POLICY_URL, tc_url=TC_URL, window_id=WINDOW_ID)
@@ -498,10 +499,10 @@
         label = QtGui.QLabel()
         maybe_elide_text(label, expected, max_width)
 
-        self.assertEqual(TITLE_STYLE % unicode(label.text()),
-                         unicode(title_label.text()))
-        self.assertEqual(unicode(label.toolTip()),
-                         unicode(title_label.toolTip()))
+        self.assertEqual(TITLE_STYLE % compat.text_type(label.text()),
+                         compat.text_type(title_label.text()))
+        self.assertEqual(compat.text_type(label.toolTip()),
+                         compat.text_type(title_label.toolTip()))
         self.assertTrue(title_label.isVisible())
 
     def assert_subtitle_correct(self, subtitle_label, expected, max_width):
@@ -509,9 +510,10 @@
         label = QtGui.QLabel()
         maybe_elide_text(label, expected, max_width)
 
-        self.assertEqual(unicode(label.text()), unicode(subtitle_label.text()))
-        self.assertEqual(unicode(label.toolTip()),
-                         unicode(subtitle_label.toolTip()))
+        self.assertEqual(compat.text_type(label.text()),
+                         compat.text_type(subtitle_label.text()))
+        self.assertEqual(compat.text_type(label.toolTip()),
+                         compat.text_type(subtitle_label.toolTip()))
         self.assertTrue(subtitle_label.isVisible())
 
     def assert_error_correct(self, error_label, expected, max_width):
@@ -519,10 +521,10 @@
         label = QtGui.QLabel()
         maybe_elide_text(label, expected, max_width)
 
-        self.assertEqual(ERROR_STYLE % unicode(label.text()),
-                         unicode(error_label.text()))
-        self.assertEqual(unicode(label.toolTip()),
-                         unicode(error_label.toolTip()))
+        self.assertEqual(ERROR_STYLE % compat.text_type(label.text()),
+                         compat.text_type(error_label.text()))
+        self.assertEqual(compat.text_type(label.toolTip()),
+                         compat.text_type(error_label.toolTip()))
         self.assertTrue(error_label.isVisible())
 
     def get_pixmap_data(self, pixmap):

=== modified file 'ubuntu_sso/qt/tests/show_gui.py'
--- ubuntu_sso/qt/tests/show_gui.py	2012-06-27 19:03:44 +0000
+++ ubuntu_sso/qt/tests/show_gui.py	2012-08-21 18:02:19 +0000
@@ -28,6 +28,8 @@
 # files in the program, then also delete it here.
 """Script that shows the qt gui."""
 
+from __future__ import unicode_literals
+
 import sys
 
 # pylint: disable=E1101,F0401,E0611
@@ -65,12 +67,12 @@
     client.cred_manager.connect_to_signal('AuthorizationDenied', found)
     client.cred_manager.connect_to_signal('CredentialsError', found)
 
-    yield client.cred_manager.login(u'Ubuntu Two',
+    yield client.cred_manager.login('Ubuntu Two',
         {
-            HELP_TEXT_KEY: u'This is a test help text.',
-            PING_URL_KEY: u'http://www.wikipedia.com/',
-            POLICY_URL_KEY: u'http://one.ubuntu.com/',
-            TC_URL_KEY: u'http://www.google.com/',
+            HELP_TEXT_KEY: 'This is a test help text.',
+            PING_URL_KEY: 'http://www.wikipedia.com/',
+            POLICY_URL_KEY: 'http://one.ubuntu.com/',
+            TC_URL_KEY: 'http://www.google.com/',
         })
     yield d
 

=== modified file 'ubuntu_sso/qt/tests/test_common.py'
--- ubuntu_sso/qt/tests/test_common.py	2012-06-22 20:52:26 +0000
+++ ubuntu_sso/qt/tests/test_common.py	2012-08-21 18:02:19 +0000
@@ -29,10 +29,13 @@
 # files in the program, then also delete it here.
 """Test the common functions."""
 
+from __future__ import unicode_literals
+
 from PyQt4 import QtGui
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
 
+from ubuntu_sso.utils import compat
 from ubuntu_sso.qt import (
     build_general_error_message,
     maybe_elide_text,
@@ -74,7 +77,7 @@
         password_assistance(self.line_edit, self.label_assistance)
         self.assertIn(
             BAD % PASSWORD_LENGTH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_long_password(self):
@@ -86,7 +89,7 @@
         password_assistance(self.line_edit, self.label_assistance)
         self.assertIn(
             GOOD % PASSWORD_LENGTH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_no_number_password(self):
@@ -98,7 +101,7 @@
         password_assistance(self.line_edit, self.label_assistance)
         self.assertIn(
             BAD % PASSWORD_DIGIT,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_number_password(self):
@@ -110,7 +113,7 @@
         password_assistance(self.line_edit, self.label_assistance)
         self.assertIn(
             GOOD % PASSWORD_DIGIT,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_no_uppercase_password(self):
@@ -122,7 +125,7 @@
         password_assistance(self.line_edit, self.label_assistance)
         self.assertIn(
             BAD % PASSWORD_UPPER,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_upper_password(self):
@@ -134,7 +137,7 @@
         password_assistance(self.line_edit, self.label_assistance)
         self.assertIn(
             GOOD % PASSWORD_UPPER,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_matching_passwords(self):
@@ -148,7 +151,7 @@
             self.line_edit_confirm, self.label_assistance)
         self.assertNotIn(
             BAD % PASSWORD_MATCH,
-            unicode(self.label_assistance.text()))
+            compat.text_type(self.label_assistance.text()))
 
     def test_not_matching_passwords(self):
         """Status when the passwords not match.
@@ -161,7 +164,7 @@
             self.line_edit_confirm, self.label_assistance)
         self.assertIn(
             BAD % PASSWORD_MATCH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_password_assistance_in_focus_length_correct(self):
@@ -171,15 +174,15 @@
         password_assistance(self.line_edit, self.label_assistance, NORMAL)
         self.assertIn(
             GOOD % PASSWORD_LENGTH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             NORMAL % PASSWORD_UPPER,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             NORMAL % PASSWORD_DIGIT,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_password_assistance_in_focus_with_upper(self):
@@ -189,15 +192,15 @@
         password_assistance(self.line_edit, self.label_assistance, NORMAL)
         self.assertIn(
             NORMAL % PASSWORD_LENGTH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             GOOD % PASSWORD_UPPER,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             NORMAL % PASSWORD_DIGIT,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_password_assistance_in_focus_with_number(self):
@@ -207,15 +210,15 @@
         password_assistance(self.line_edit, self.label_assistance, NORMAL)
         self.assertIn(
             NORMAL % PASSWORD_LENGTH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             NORMAL % PASSWORD_UPPER,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             GOOD % PASSWORD_DIGIT,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
     def test_password_assistance_in_focus_all_ok(self):
@@ -225,19 +228,19 @@
         password_assistance(self.line_edit, self.label_assistance, NORMAL)
         self.assertIn(
             GOOD % PASSWORD_LENGTH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             GOOD % PASSWORD_UPPER,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertIn(
             GOOD % PASSWORD_DIGIT,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
         self.assertNotIn(
             NORMAL % PASSWORD_MATCH,
-            unicode(self.label_assistance.text()),
+            compat.text_type(self.label_assistance.text()),
         )
 
 
@@ -276,7 +279,7 @@
 
         self.assertEqual(self.ui.toolTip(), '')
         self.assertEqual(self.ui.text(), text)
-        self.assertNotIn(u'\u2026', self.ui.text())
+        self.assertNotIn('\u2026', self.ui.text())
 
     def test_text_not_elided_if_equals_max_width(self):
         """If text is equal than max_width, do not elide."""
@@ -286,7 +289,7 @@
 
         self.assertEqual(self.ui.toolTip(), '')
         self.assertEqual(self.ui.text(), text)
-        self.assertNotIn(u'\u2026', self.ui.text())
+        self.assertNotIn('\u2026', self.ui.text())
 
     def test_text_elided_if_bigger_than_max_width(self):
         """If text is equal than max_width, do not elide."""
@@ -295,8 +298,8 @@
         maybe_elide_text(self.ui, text, self.max_width)
 
         self.assertEqual(self.ui.toolTip(), text)
-        expected = unicode(self.ui.text())
-        self.assertTrue(expected.endswith(u'\u2026'))
+        expected = compat.text_type(self.ui.text())
+        self.assertTrue(expected.endswith('\u2026'))
         self.assertTrue(text.startswith(expected[:-1]))
 
 

=== modified file 'ubuntu_sso/qt/tests/test_current_user_sign_in_page.py'
--- ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-06-08 15:10:34 +0000
+++ ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-08-21 18:02:19 +0000
@@ -28,8 +28,11 @@
 # files in the program, then also delete it here.
 """Tests for the Setup Account page Qt UI."""
 
+from __future__ import unicode_literals
+
 from PyQt4 import QtGui, QtCore
 
+from ubuntu_sso.utils import compat
 from ubuntu_sso.qt import current_user_sign_in_page as gui
 from ubuntu_sso.qt.tests import (
     PageBaseTestCase,
@@ -66,13 +69,14 @@
 
     def test_unicode_in_forgotten_password_link(self):
         """Ensure that this label supports unicode."""
-        forgot_fr = u"J'ai oublié mon mot de passe"
+        forgot_fr = "J'ai oublié mon mot de passe"
         self.patch(gui, "FORGOTTEN_PASSWORD_BUTTON", forgot_fr)
         forgotten_text = gui.LINK_STYLE.format(link_url='#',
                             link_text=forgot_fr)
         self.ui._set_translated_strings()
-        self.assertEqual(unicode(self.ui.ui.forgot_password_label.text()),
-            forgotten_text)
+        self.assertEqual(
+                compat.text_type(self.ui.ui.forgot_password_label.text()),
+                forgotten_text)
 
     def test_set_translated_strings(self):
         """Test the translated string method."""
@@ -80,16 +84,18 @@
         self.assert_title_correct(expected)
         expected = gui.LOGIN_SUBTITLE % dict(app_name=self.app_name)
         self.assert_subtitle_correct(expected)
-        self.assertEqual(unicode(self.ui.ui.email_label.text()),
+        self.assertEqual(compat.text_type(self.ui.ui.email_label.text()),
             gui.EMAIL_LABEL)
-        self.assertEqual(unicode(self.ui.ui.password_label.text()),
+        self.assertEqual(compat.text_type(self.ui.ui.password_label.text()),
             gui.LOGIN_PASSWORD_LABEL)
         text = gui.LINK_STYLE.format(link_url='#',
                                      link_text=gui.FORGOTTEN_PASSWORD_BUTTON)
-        self.assertEqual(unicode(self.ui.ui.forgot_password_label.text()),
-            text)
-        self.assertEqual(unicode(self.ui.ui.sign_in_button.text()),
-            gui.SIGN_IN_BUTTON)
+        self.assertEqual(
+                compat.text_type(self.ui.ui.forgot_password_label.text()),
+                text)
+        self.assertEqual(
+                compat.text_type(self.ui.ui.sign_in_button.text()),
+                gui.SIGN_IN_BUTTON)
 
     def test_connect_ui(self):
         """Test the connect ui method."""

=== modified file 'ubuntu_sso/qt/tests/test_forgotten_password.py'
--- ubuntu_sso/qt/tests/test_forgotten_password.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/tests/test_forgotten_password.py	2012-08-21 18:02:19 +0000
@@ -30,6 +30,7 @@
 
 from PyQt4 import QtCore
 
+from ubuntu_sso.utils import compat
 from ubuntu_sso.qt import forgotten_password_page as gui
 from ubuntu_sso.qt.tests import (
     PageBaseTestCase,
@@ -60,8 +61,9 @@
     def test_email_address(self):
         """Test the email_address property."""
         value = self.ui.email_address
-        self.assertEqual(value, unicode(self.ui.ui.email_line_edit.text()))
-        self.assertTrue(isinstance(value, unicode))
+        self.assertEqual(value,
+                         compat.text_type(self.ui.ui.email_line_edit.text()))
+        self.assertTrue(isinstance(value, compat.text_type))
 
     def test_send_button_clicked(self):
         """Test the send_button property."""
@@ -87,9 +89,10 @@
         subtitle = gui.FORGOTTEN_PASSWORD_SUBTITLE
         self.assert_subtitle_correct(subtitle.format(app_name=self.app_name))
 
-        self.assertEqual(unicode(self.ui.ui.email_address_label.text()),
-            gui.EMAIL_LABEL)
-        self.assertEqual(unicode(self.ui.ui.send_button.text()),
+        self.assertEqual(
+                compat.text_type(self.ui.ui.email_address_label.text()),
+                gui.EMAIL_LABEL)
+        self.assertEqual(compat.text_type(self.ui.ui.send_button.text()),
             gui.RESET_PASSWORD)
 
     def test_connect_ui(self):

=== modified file 'ubuntu_sso/qt/tests/test_reset_password.py'
--- ubuntu_sso/qt/tests/test_reset_password.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/tests/test_reset_password.py	2012-08-21 18:02:19 +0000
@@ -32,6 +32,7 @@
 
 from PyQt4 import QtGui, QtCore
 
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     PASSWORD1_ENTRY,
     PASSWORD2_ENTRY,
@@ -86,11 +87,12 @@
         self.ui.initializePage()
         self.assert_title_correct(RESET_TITLE)
         self.assert_subtitle_correct(RESET_SUBTITLE)
-        self.assertEqual(unicode(self.ui.ui.password_label.text()),
+        self.assertEqual(compat.text_type(self.ui.ui.password_label.text()),
             PASSWORD1_ENTRY)
-        self.assertEqual(unicode(self.ui.ui.confirm_password_label.text()),
-            PASSWORD2_ENTRY)
-        self.assertEqual(unicode(self.ui.ui.reset_code.text()),
+        self.assertEqual(
+                compat.text_type(self.ui.ui.confirm_password_label.text()),
+                PASSWORD2_ENTRY)
+        self.assertEqual(compat.text_type(self.ui.ui.reset_code.text()),
             RESET_CODE_ENTRY)
 
     def test_focus_changed_password_visibility(self):

=== modified file 'ubuntu_sso/qt/tests/test_setup_account.py'
--- ubuntu_sso/qt/tests/test_setup_account.py	2012-06-08 15:10:34 +0000
+++ ubuntu_sso/qt/tests/test_setup_account.py	2012-08-21 18:02:19 +0000
@@ -30,6 +30,9 @@
 
 from PyQt4 import QtGui, QtCore
 
+from ubuntu_sso.utils import compat
+from ubuntu_sso.tests import CAPTCHA_PATH
+
 from ubuntu_sso.qt import common, setup_account_page as gui
 from ubuntu_sso.qt.tests import PageBaseTestCase
 
@@ -67,7 +70,7 @@
 
         self.ui.ui.refresh_label.linkActivated.emit('error')
 
-        message = unicode(self.ui.form_errors_label.text())
+        message = compat.text_type(self.ui.form_errors_label.text())
         self.assertEqual(message, ' ')
 
     def test_enable_setup_button_with_visible_check(self):
@@ -116,15 +119,15 @@
         self.ui.focus_changed(None, self.ui.ui.password_edit)
         self.assertIn(
             common.NORMAL % common.PASSWORD_LENGTH,
-            unicode(self.ui.ui.password_assistance.text()),
+            compat.text_type(self.ui.ui.password_assistance.text()),
         )
         self.assertIn(
             common.NORMAL % common.PASSWORD_UPPER,
-            unicode(self.ui.ui.password_assistance.text()),
+            compat.text_type(self.ui.ui.password_assistance.text()),
         )
         self.assertIn(
             common.NORMAL % common.PASSWORD_DIGIT,
-            unicode(self.ui.ui.password_assistance.text()),
+            compat.text_type(self.ui.ui.password_assistance.text()),
         )
 
     def test_password_focus_gain(self):
@@ -219,16 +222,18 @@
         self.assertFalse(self.ui.captcha_received)
 
         # labels
-        self.assertEqual(unicode(self.ui.ui.name_label.text()),
+        self.assertEqual(compat.text_type(self.ui.ui.name_label.text()),
             gui.NAME_ENTRY)
-        self.assertEqual(unicode(self.ui.ui.email_label.text()),
+        self.assertEqual(compat.text_type(self.ui.ui.email_label.text()),
             gui.EMAIL)
-        self.assertEqual(unicode(self.ui.ui.confirm_email_label.text()),
-                         gui.RETYPE_EMAIL)
-        self.assertEqual(unicode(self.ui.ui.password_label.text()),
+        self.assertEqual(
+                compat.text_type(self.ui.ui.confirm_email_label.text()),
+                gui.RETYPE_EMAIL)
+        self.assertEqual(compat.text_type(self.ui.ui.password_label.text()),
             gui.PASSWORD)
-        self.assertEqual(unicode(self.ui.ui.confirm_password_label.text()),
-                         gui.RETYPE_PASSWORD)
+        self.assertEqual(
+                compat.text_type(self.ui.ui.confirm_password_label.text()),
+                gui.RETYPE_PASSWORD)
 
         # assistants
         self.assertFalse(self.ui.ui.name_assistance.isVisible())
@@ -337,6 +342,15 @@
         self.ui.showEvent(QtGui.QShowEvent())
         self.ui.hideEvent(QtGui.QHideEvent())
 
+    def test_on_captcha_generated(self):
+        """Check that the captcha image is handled correctly."""
+
+        self.ui.captcha_file = CAPTCHA_PATH
+        self.ui.on_captcha_generated(u"fake app name",
+                                     "fake id")
+        pixmap_empty = self.ui.captcha_image.size().isEmpty()
+        self.assertEqual(pixmap_empty, False)
+
     def test_on_captcha_refreshing_visible(self):
         """Check the state of the overlay on captcha refreshing."""
         self.ui.hide_overlay()

=== modified file 'ubuntu_sso/qt/tests/test_ssl_dialog.py'
--- ubuntu_sso/qt/tests/test_ssl_dialog.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/qt/tests/test_ssl_dialog.py	2012-08-21 18:02:19 +0000
@@ -34,6 +34,7 @@
 
 from ubuntu_sso import USER_CANCELLATION, USER_SUCCESS
 from ubuntu_sso.qt import ssl_dialog
+from ubuntu_sso.utils import compat
 from ubuntu_sso.utils.ui import (
     CANCEL_BUTTON,
     SSL_APPNAME_HELP,
@@ -94,17 +95,18 @@
     def test_set_labels(self):
         """Test that the labels contain the correct info."""
         self.assertEqual(SSL_HEADER,
-                         unicode(self.dialog.ui.title_label.text()))
+                         compat.text_type(self.dialog.ui.title_label.text()))
         explanation = SSL_EXPLANATION % dict(domain=self.domain)
         intro = ssl_dialog.REASONS_TEMPLATE % dict(explanation=explanation,
                                               first_reason=SSL_FIRST_REASON,
                                               second_reason=SSL_SECOND_REASON,
                                               third_reason=SSL_THIRD_REASON)
-        self.assertEqual(intro, unicode(self.dialog.ui.intro_label.text()))
+        self.assertEqual(intro,
+                         compat.text_type(self.dialog.ui.intro_label.text()))
         self.assertEqual(SSL_NOT_SURE % dict(app_name=self.appname),
-                unicode(self.dialog.ui.not_sure_label.text()))
+                compat.text_type(self.dialog.ui.not_sure_label.text()))
         self.assertEqual(SSL_REMEMBER_DECISION,
-                unicode(self.dialog.ui.remember_checkbox.text()))
+                compat.text_type(self.dialog.ui.remember_checkbox.text()))
 
     def test_on_cancel_clicked(self):
         """Test the cancelation action."""
@@ -146,16 +148,16 @@
         self.assertIn('_on_cancel_clicked', called)
 
         self.assertEqual(CANCEL_BUTTON,
-                unicode(dialog.ui.cancel_button.text()))
+                compat.text_type(dialog.ui.cancel_button.text()))
         self.assertEqual(SSL_CONNECT_BUTTON,
-                unicode(dialog.ui.connect_button.text()))
+                compat.text_type(dialog.ui.connect_button.text()))
         self.assertEqual(SSL_HELP_BUTTON,
-                unicode(dialog.ui.help_button.text()))
+                compat.text_type(dialog.ui.help_button.text()))
 
     def test_set_expander(self):
         """Test that the expander is correctly set."""
         self.assertEqual(SSL_CERT_DETAILS,
-            unicode(self.dialog.expander.text()))
+            compat.text_type(self.dialog.expander.text()))
         self.assertNotEqual(None, self.dialog.expander.content)
         self.assertEqual(2, self.dialog.ui.expander_layout.indexOf(
                                                         self.dialog.expander))

=== modified file 'ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-05-11 18:32:40 +0000
+++ ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-08-21 18:02:19 +0000
@@ -41,6 +41,7 @@
     BaseTestCase,
     FakeOverlay,
 )
+from ubuntu_sso.utils import compat
 
 
 # is ok to access private method/attrs in tests
@@ -107,7 +108,7 @@
 
     def test_window_title(self):
         """Check the window title for the application."""
-        title = unicode(self.ui.windowTitle())
+        title = compat.text_type(self.ui.windowTitle())
         self.assertEqual(title, ubuntu_sso_wizard.WINDOW_TITLE)
 
 

=== modified file 'ubuntu_sso/qt/ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/ubuntu_sso_wizard.py	2012-05-25 13:51:31 +0000
+++ ubuntu_sso/qt/ubuntu_sso_wizard.py	2012-08-21 18:02:19 +0000
@@ -44,6 +44,7 @@
     USER_SUCCESS,
 )
 from ubuntu_sso.logger import setup_gui_logging
+from ubuntu_sso.utils import compat
 from ubuntu_sso.qt import PREFERED_UI_SIZE, WINDOW_TITLE
 from ubuntu_sso.qt.current_user_sign_in_page import CurrentUserSignInPage
 from ubuntu_sso.qt.email_verification_page import EmailVerificationPage
@@ -203,7 +204,7 @@
         logger.debug('Moving to EmailVerificationPage from: %s',
             self.currentPage())
         self._next_id = self.email_verification_page_id
-        self.email_verification.email = unicode(email)
+        self.email_verification.email = compat.text_type(email)
         self.email_verification.password = self.currentPage().password
         self.next()
         self._next_id = -1

=== modified file 'ubuntu_sso/tests/__init__.py'
--- ubuntu_sso/tests/__init__.py	2012-06-27 19:03:44 +0000
+++ ubuntu_sso/tests/__init__.py	2012-08-21 18:02:19 +0000
@@ -28,6 +28,8 @@
 # files in the program, then also delete it here.
 """Tests for the Ubuntu SSO library."""
 
+from __future__ import unicode_literals
+
 import os
 
 from collections import defaultdict
@@ -38,30 +40,30 @@
 
 from ubuntu_sso.keyring import get_token_name
 
-APP_NAME = u'I ♥ Ubuntu'
-CAPTCHA_ID = u'test ñiña'
+APP_NAME = 'I ♥ Ubuntu'
+CAPTCHA_ID = 'test ñiña'
 CAPTCHA_PATH = os.path.abspath(os.path.join(os.curdir, 'ubuntu_sso', 'tests',
                                             'files', 'captcha.png'))
-CAPTCHA_SOLUTION = u'william Byrd ñandú'
-EMAIL = u'[e-mail]'
-EMAIL_TOKEN = u'B2P☺ gtf'
+CAPTCHA_SOLUTION = 'william Byrd ñandú'
+EMAIL = '[e-mail]'
+EMAIL_TOKEN = 'B2P☺ gtf'
 GUI_EXE = 'ubuntu-sso-login-qt'
-HELP_TEXT = u'☛ Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' \
+HELP_TEXT = '☛ Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' \
 'Nam sed lorem nibh. Suspendisse gravida nulla non nunc suscipit pulvinar ' \
 'tempus ut augue. Morbi consequat, ligula a elementum pretium, ' \
 'dolor nulla tempus metus, sed viverra nisi risus non velit.'
-NAME = u'Juanito ☀ Pérez'
-PASSWORD = u'h3lloWorld☑ '
-PING_URL = u'http://localhost/ping-me/'
-POLICY_URL = u'http://localhost/policy/'
-RESET_PASSWORD_TOKEN = u'8G5Wtq'
-TOKEN = {u'consumer_key': u'xQ7xDAz',
-         u'consumer_secret': u'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
-         u'token_name': u'test',
-         u'token': u'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
-         u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
+NAME = 'Juanito ☀ Pérez'
+PASSWORD = 'h3lloWorld☑ '
+PING_URL = 'http://localhost/ping-me/'
+POLICY_URL = 'http://localhost/policy/'
+RESET_PASSWORD_TOKEN = '8G5Wtq'
+TOKEN = {'consumer_key': 'xQ7xDAz',
+         'consumer_secret': 'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
+         'token_name': 'test',
+         'token': 'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
+         'token_secret': 'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
 TOKEN_NAME = get_token_name(APP_NAME)
-TC_URL = u'http://localhost/'
+TC_URL = 'http://localhost/'
 WINDOW_ID = 5
 
 

=== modified file 'ubuntu_sso/tests/test_account.py'
--- ubuntu_sso/tests/test_account.py	2012-07-03 21:04:09 +0000
+++ ubuntu_sso/tests/test_account.py	2012-08-21 18:02:19 +0000
@@ -31,13 +31,21 @@
 # files in the program, then also delete it here.
 """Tests for the SSO account code."""
 
+from __future__ import unicode_literals
+
 import os
 
+# pylint: disable=W0621,F0401,E0611
+try:
+    import urllib.request as url_lib
+except ImportError:
+    import urllib2 as url_lib
+# pylint: enable=W0621,F0401,E0611
+
 from twisted.trial.unittest import TestCase
 from twisted.internet import defer
 
 from ubuntu_sso import account
-from ubuntu_sso import utils
 from ubuntu_sso.account import (
     Account,
     AuthenticationError,
@@ -64,12 +72,13 @@
     TOKEN,
     TOKEN_NAME,
 )
+from ubuntu_sso.utils import compat
 
 
 CANT_RESET_PASSWORD_CONTENT = "CanNotResetPassowrdError: " \
                               "Can't reset password for this account"
 RESET_TOKEN_INVALID_CONTENT = "AuthToken matching query does not exist."
-EMAIL_ALREADY_REGISTERED = u'[e-mail]'
+EMAIL_ALREADY_REGISTERED = '[e-mail]'
 STATUS_UNKNOWN = {'status': 'yadda-yadda'}
 STATUS_ERROR = {'status': SSO_STATUS_ERROR,
                 'errors': {'something': ['Bla', 'Ble']}}
@@ -79,7 +88,7 @@
 STATUS_EMAIL_OK = {'email': EMAIL}
 
 FAKE_NEW_CAPTCHA = {
-    'image_url': "file://" + unicode(CAPTCHA_PATH),
+    'image_url': "file://" + compat.text_type(CAPTCHA_PATH),
     'captcha_id': CAPTCHA_ID,
 }
 
@@ -177,17 +186,17 @@
 
     def fake_accounts_me(self):
         """Fake the 'me' information."""
-        return {u'username': u'Wh46bKY',
-                u'preferred_email': self.preferred_email,
-                u'displayname': u'',
-                u'unverified_emails': [u'[e-mail]'],
-                u'verified_emails': [],
-                u'openid_identifier': u'Wh46bKY'}
+        return {'username': 'Wh46bKY',
+                'preferred_email': self.preferred_email,
+                'displayname': '',
+                'unverified_emails': ['[e-mail]'],
+                'verified_emails': [],
+                'openid_identifier': 'Wh46bKY'}
 
     def check_all_kwargs_unicode(self, **kwargs):
         """Check that the values of all keyword arguments are unicode."""
         for (key, value) in kwargs.items():
-            if isinstance(value, str):
+            if isinstance(value, compat.binary_type):
                 raise AssertionError("Error: kwarg '%s' is non-unicode." % key)
 
     def restcall(self, method_name, **kwargs):
@@ -215,7 +224,7 @@
             self.addCleanup(f.close)
             return f
 
-        self.patch(utils, 'urlopen', fake_urlopen)  # fd to the path
+        self.patch(url_lib, 'urlopen', fake_urlopen)  # fd to the path
         self.processor = Account()
         self.register_kwargs = dict(email=EMAIL, password=PASSWORD,
                                     displayname=NAME,
@@ -254,27 +263,27 @@
     @defer.inlineCallbacks
     def test_register_user_checks_valid_email(self):
         """Email is validated."""
-        self.register_kwargs['email'] = u'notavalidemail'
+        self.register_kwargs['email'] = 'notavalidemail'
         d = self.processor.register_user(**self.register_kwargs)
         yield self.assertFailure(d, InvalidEmailError)
 
     @defer.inlineCallbacks
     def test_register_user_checks_valid_password(self):
         """Password is validated."""
-        self.register_kwargs['password'] = u''
+        self.register_kwargs['password'] = ''
         d = self.processor.register_user(**self.register_kwargs)
         yield self.assertFailure(d, InvalidPasswordError)
 
         # 7 chars, one less than expected
-        self.register_kwargs['password'] = u'tesT3it'
-        d = self.processor.register_user(**self.register_kwargs)
-        yield self.assertFailure(d, InvalidPasswordError)
-
-        self.register_kwargs['password'] = u'test3it!'  # no upper case
-        d = self.processor.register_user(**self.register_kwargs)
-        yield self.assertFailure(d, InvalidPasswordError)
-
-        self.register_kwargs['password'] = u'testIt!!'  # no number
+        self.register_kwargs['password'] = 'tesT3it'
+        d = self.processor.register_user(**self.register_kwargs)
+        yield self.assertFailure(d, InvalidPasswordError)
+
+        self.register_kwargs['password'] = 'test3it!'  # no upper case
+        d = self.processor.register_user(**self.register_kwargs)
+        yield self.assertFailure(d, InvalidPasswordError)
+
+        self.register_kwargs['password'] = 'testIt!!'  # no number
         d = self.processor.register_user(**self.register_kwargs)
         yield self.assertFailure(d, InvalidPasswordError)
 

=== modified file 'ubuntu_sso/utils/__init__.py'
--- ubuntu_sso/utils/__init__.py	2012-07-13 20:45:14 +0000
+++ ubuntu_sso/utils/__init__.py	2012-08-21 18:02:19 +0000
@@ -28,22 +28,12 @@
 # files in the program, then also delete it here.
 """Utility modules that may find use outside ubuntu_sso."""
 
-import cgi
+from __future__ import unicode_literals
+
 import os
 import sys
-import time
 
 from dirspec.utils import get_program_path
-from oauth import oauth
-
-try:
-    # pylint: disable=E0611,F0401
-    from urllib.parse import urlparse
-    from urllib.request import Request, urlopen
-    # pylint: enable=E0611,F0401
-except ImportError:
-    from urlparse import urlparse
-    from urllib2 import Request, urlopen
 
 from twisted.internet import defer
 
@@ -52,7 +42,7 @@
                         UI_PROXY_CREDS_DIALOG,
                         UI_SSL_DIALOG)
 from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.utils import webclient
+from ubuntu_sso.utils import compat, webclient
 
 
 logger = setup_logging("ubuntu_sso.utils")
@@ -150,98 +140,6 @@
     return cmd_args
 
 
-class RequestHead(Request):
-    """A request with the method set to HEAD."""
-
-    _request_method = "HEAD"
-
-    def get_method(self):
-        """Return the desired method."""
-        return self._request_method
-
-
-class SyncTimestampChecker(object):
-    """A timestamp that's regularly checked with a server."""
-
-    CHECKING_INTERVAL = 60 * 60  # in seconds
-    ERROR_INTERVAL = 30  # in seconds
-    SERVER_URL = "http://one.ubuntu.com/api/time"
-
-    def __init__(self):
-        """Initialize this instance."""
-        self.next_check = time.time()
-        self.skew = 0
-
-    def get_server_time(self):
-        """Get the time at the server."""
-        headers = {"Cache-Control": "no-cache"}
-        request = RequestHead(self.SERVER_URL, headers=headers)
-        response = urlopen(request)
-        date_string = response.info()["Date"]
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import http
-        timestamp = http.stringToDatetime(date_string)
-        return timestamp
-
-    def get_faithful_time(self):
-        """Get an accurate timestamp."""
-        local_time = time.time()
-        if local_time >= self.next_check:
-            try:
-                server_time = self.get_server_time()
-                self.next_check = local_time + self.CHECKING_INTERVAL
-                self.skew = server_time - local_time
-                logger.debug("Calculated server-local time skew: %r",
-                             self.skew)
-            #pylint: disable=W0703
-            except Exception as server_error:
-                logger.debug("Error while verifying the server time skew: %r",
-                             server_error)
-                self.next_check = local_time + self.ERROR_INTERVAL
-
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import http
-        logger.debug("Using corrected timestamp: %r",
-                     http.datetimeToString(local_time + self.skew))
-        return int(local_time + self.skew)
-
-
-# pylint: disable=C0103
-timestamp_checker = SyncTimestampChecker()
-# pylint: enable=C0103
-
-
-def oauth_headers(url, credentials, http_method='GET'):
-    """Sign 'url' using 'credentials'.
-
-    * 'url' must be a valid unicode url.
-    * 'credentials' must be a valid OAuth token.
-
-    Return oauth headers that can be pass to any Request like object.
-
-    """
-    assert isinstance(url, unicode)
-    url = url.encode('utf-8')
-    _, _, _, _, query, _ = urlparse(url)
-    parameters = dict(cgi.parse_qsl(query))
-    parameters["oauth_timestamp"] = timestamp_checker.get_faithful_time()
-
-    consumer = oauth.OAuthConsumer(credentials['consumer_key'],
-                                   credentials['consumer_secret'])
-    token = oauth.OAuthToken(credentials['token'],
-                             credentials['token_secret'])
-    kwargs = dict(oauth_consumer=consumer, token=token,
-                  http_method=http_method, http_url=url,
-                  parameters=parameters)
-    get_request = oauth.OAuthRequest.from_consumer_and_token
-    oauth_req = get_request(**kwargs)
-    hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1()
-    oauth_req.sign_request(hmac_sha1, consumer, token)
-    headers = oauth_req.to_header()
-
-    return headers
-
-
 @defer.inlineCallbacks
 def ping_url(url, email, credentials):
     """Ping the 'url' with the 'email' attached to it.
@@ -251,7 +149,7 @@
     """
     logger.info('Pinging server using url: %r, email: %r.',
                 url, email)
-    assert isinstance(url, unicode), 'Url %r must be unicode' % url
+    assert isinstance(url, compat.text_type), 'Url %r must be unicode' % url
 
     target_url = url
     try:
@@ -262,7 +160,7 @@
     if target_url == url:
         logger.debug('Original url (%r) could not be formatted, '
                      'appending email (%r).', url, email)
-        assert url.endswith(u'/'), 'Url %r must end with /.' % url
+        assert url.endswith('/'), 'Url %r must end with /.' % url
         target_url = url + email
 
     wc = webclient.webclient_factory()

=== added file 'ubuntu_sso/utils/compat.py'
--- ubuntu_sso/utils/compat.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/compat.py	2012-08-21 18:02:19 +0000
@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Python 2 and 3 compatibility."""
+
+from __future__ import unicode_literals
+
+# The following approach was outlined in Lennart Regebro's
+# "Porting to Python 3" book.
+# http://python3porting.com/noconv.html#more-bytes-strings-and-unicode
+
+import sys
+
+# Disable redefined builtin, invalid name warning
+# pylint: disable=W0622,C0103
+
+if sys.version_info < (3,):
+    text_type = unicode
+    binary_type = str
+    basestring = basestring
+else:
+    text_type = str
+    binary_type = bytes
+    basestring = str

=== modified file 'ubuntu_sso/utils/ipc.py'
--- ubuntu_sso/utils/ipc.py	2012-06-22 16:51:06 +0000
+++ ubuntu_sso/utils/ipc.py	2012-08-21 18:02:19 +0000
@@ -172,10 +172,16 @@
         return super(RemoteMeta, mcs).__new__(mcs, name, bases, attrs)
 
 
-class RemoteService(Referenceable, SignalBroadcaster):
+def meta_base(meta):
+    """A function to return a metaclass which is called directly.
+    This is safe for both Python 2 and 3."""
+    return meta("MetaBase", (object,), {})
+
+
+class RemoteService(meta_base(RemoteMeta),
+                    Referenceable, SignalBroadcaster):
     """A remote service that provides the methods listed in remote_calls."""
 
-    __metaclass__ = RemoteMeta
     remote_calls = []
 
 

=== modified file 'ubuntu_sso/utils/runner/glib.py'
--- ubuntu_sso/utils/runner/glib.py	2012-06-22 16:12:03 +0000
+++ ubuntu_sso/utils/runner/glib.py	2012-08-21 18:02:19 +0000
@@ -35,6 +35,7 @@
 # pylint: enable=E0611,F0401
 
 from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils import compat
 
 logger = setup_logging("ubuntu_sso.utils.runner.glib")
 
@@ -81,10 +82,10 @@
 
     bytes_args = []
     for arg in args:
-        if isinstance(arg, unicode):
+        if isinstance(arg, compat.text_type):
             arg = arg.encode('utf-8')
-        if not isinstance(arg, basestring):
-            arg = str(arg)
+        if not isinstance(arg, compat.basestring):
+            arg = compat.binary_type(arg)
         bytes_args.append(arg)
 
     try:

=== modified file 'ubuntu_sso/utils/runner/tests/test_qt.py'
--- ubuntu_sso/utils/runner/tests/test_qt.py	2012-06-22 16:12:03 +0000
+++ ubuntu_sso/utils/runner/tests/test_qt.py	2012-08-21 18:02:19 +0000
@@ -33,7 +33,7 @@
 from PyQt4 import QtCore
 from twisted.internet import defer
 
-from ubuntu_sso.utils import runner
+from ubuntu_sso.utils import compat, runner
 from ubuntu_sso.utils.runner import qt
 from ubuntu_sso.utils.runner.tests.test_runner import SpawnProgramTestCase
 
@@ -80,7 +80,7 @@
             # subprocess expects bytes
             bytes_args = []
             for arg in args:
-                if isinstance(arg, unicode):
+                if isinstance(arg, compat.text_type):
                     arg = arg.encode('utf-8')
                 bytes_args.append(arg)
 

=== modified file 'ubuntu_sso/utils/runner/tests/test_runner.py'
--- ubuntu_sso/utils/runner/tests/test_runner.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/utils/runner/tests/test_runner.py	2012-08-21 18:02:19 +0000
@@ -28,6 +28,8 @@
 # files in the program, then also delete it here.
 """Tests for the runner helper module."""
 
+from __future__ import unicode_literals
+
 import os
 
 from twisted.internet import defer
@@ -36,15 +38,15 @@
 from ubuntu_sso.utils import runner
 
 
-TEST_ME_DIR = u'test-me-more-♥'
+TEST_ME_DIR = 'test-me-more-♥'
 TEST_ME_DIR_BYTES = TEST_ME_DIR.encode('utf-8')
 
 
 class SpawnProgramTestCase(TestCase):
     """The test suite for the spawn_program method."""
 
-    args = (u'python', u'-c',
-            u'import os; os.system("mkdir %s")' % TEST_ME_DIR)
+    args = ('python', '-c',
+            'import os; os.system("mkdir %s")' % TEST_ME_DIR)
     use_reactor = True
     timeout = 3
 

=== modified file 'ubuntu_sso/utils/runner/tx.py'
--- ubuntu_sso/utils/runner/tx.py	2012-06-22 16:12:03 +0000
+++ ubuntu_sso/utils/runner/tx.py	2012-08-21 18:02:19 +0000
@@ -34,6 +34,7 @@
 from twisted.internet import utils
 
 from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils import compat
 
 
 logger = setup_logging("ubuntu_sso.utils.runner.tx")
@@ -57,8 +58,9 @@
 
     """
 
-    def child_watch((stdout, stderr, exit_code)):
+    def child_watch(args):
         """Handle child termination."""
+        stdout, stderr, exit_code = args
         if stdout:
             logger.debug('Returned stdout is (exit code was %r): %r',
                          exit_code, stdout)
@@ -82,10 +84,10 @@
 
     bytes_args = []
     for arg in argv:
-        if isinstance(arg, unicode):
+        if isinstance(arg, compat.text_type):
             arg = arg.encode('utf-8')
-        if not isinstance(arg, basestring):
-            arg = str(arg)
+        if not isinstance(arg, compat.basestring):
+            arg = compat.binary_type(arg)
         bytes_args.append(arg)
 
     if program and not os.access(program, os.X_OK):

=== modified file 'ubuntu_sso/utils/tests/test_common.py'
--- ubuntu_sso/utils/tests/test_common.py	2012-07-12 15:54:13 +0000
+++ ubuntu_sso/utils/tests/test_common.py	2012-08-21 18:02:19 +0000
@@ -28,23 +28,18 @@
 # files in the program, then also delete it here.
 """Tests for the oauth_headers helper function."""
 
+from __future__ import unicode_literals
+
 import logging
 import sys
-import time
 
 from twisted.internet import defer
-from twisted.internet.threads import deferToThread
 from twisted.web import resource
 from ubuntuone.devtools.handlers import MementoHandler
 from ubuntuone.devtools.testing.txwebserver import HTTPWebServer
 
 from ubuntu_sso import utils
 from ubuntu_sso.tests import TestCase, EMAIL, TOKEN
-from ubuntu_sso.utils import (
-    oauth,
-    oauth_headers,
-    SyncTimestampChecker,
-)
 
 CONSTANTS_MODULE = 'ubuntu_sso.constants'
 NOT_DEFINED = object()
@@ -188,97 +183,6 @@
         self.assertEqual(expected, result)
 
 
-class SignWithCredentialsTestCase(TestCase):
-    """Test suite for the oauth_headers method."""
-
-    url = u'http://example.com'
-    fake_timestamp_value = 1
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this test suite."""
-        yield super(SignWithCredentialsTestCase, self).setUp()
-        self.timestamp_called = False
-
-        def fake_timestamp():
-            """A fake timestamp that records the call."""
-            self.timestamp_called = True
-            return self.fake_timestamp_value
-
-        self.patch(utils.timestamp_checker, "get_faithful_time",
-                   fake_timestamp)
-
-    def build_header(self, url, http_method='GET'):
-        """Build an Oauth header for comparison."""
-        consumer = oauth.OAuthConsumer(TOKEN['consumer_key'],
-                                       TOKEN['consumer_secret'])
-        token = oauth.OAuthToken(TOKEN['token'],
-                                 TOKEN['token_secret'])
-        get_request = oauth.OAuthRequest.from_consumer_and_token
-        oauth_req = get_request(oauth_consumer=consumer, token=token,
-                                http_method=http_method, http_url=url)
-        oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
-                               consumer, token)
-        return oauth_req.to_header()
-
-    def dictify_header(self, header):
-        """Convert an OAuth header into a dict."""
-        result = {}
-        fields = header.split(', ')
-        for field in fields:
-            key, value = field.split('=')
-            result[key] = value.strip('"')
-
-        return result
-
-    def assert_header_equal(self, expected, actual):
-        """Is 'expected' equals to 'actual'?"""
-        expected = self.dictify_header(expected['Authorization'])
-        actual = self.dictify_header(actual['Authorization'])
-        for header in (expected, actual):
-            header.pop('oauth_nonce')
-            header.pop('oauth_timestamp')
-            header.pop('oauth_signature')
-
-        self.assertEqual(expected, actual)
-
-    def assert_method_called(self, path, query_str='', http_method='GET'):
-        """Assert that the url build by joining 'paths' was called."""
-        expected = (self.url, path, query_str)
-        expected = ''.join(expected).encode('utf8')
-        expected = self.build_header(expected, http_method=http_method)
-        actual = oauth_headers(url=self.url + path, credentials=TOKEN)
-        self.assert_header_equal(expected, actual)
-
-    def test_call(self):
-        """Calling 'get' triggers an OAuth signed GET request."""
-        path = u'/test/'
-        self.assert_method_called(path)
-
-    def test_quotes_path(self):
-        """Calling 'get' quotes the path."""
-        path = u'/test me more, sí!/'
-        self.assert_method_called(path)
-
-    def test_adds_parameters_to_oauth_request(self):
-        """The query string from the path is used in the oauth request."""
-        self.patch(oauth, 'OAuthRequest', FakedOAuthRequest)
-
-        path = u'/test/something?foo=bar'
-        oauth_headers(url=self.url + path, credentials=TOKEN)
-
-        self.assertIn('parameters', FakedOAuthRequest.params)
-        params = FakedOAuthRequest.params['parameters']
-        del(params["oauth_timestamp"])
-        self.assertEqual(params, {'foo': 'bar'})
-
-    def test_oauth_headers_uses_timestamp_checker(self):
-        """The oauth_headers function uses the timestamp_checker."""
-        oauth_headers(u"http://protocultura.net", TOKEN)
-        self.assertTrue(self.timestamp_called,
-                        "the timestamp MUST be requested.")
-
-
 class RootResource(resource.Resource):
     """A root resource that logs the number of calls."""
 
@@ -312,86 +216,13 @@
     """A mock, test, sample, and fake exception."""
 
 
-class TimestampCheckerTestCase(TestCase):
-    """Tests for the timestamp checker."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize a fake webserver."""
-        yield super(TimestampCheckerTestCase, self).setUp()
-        self.ws = MockWebServer()
-        self.ws.start()
-        self.addCleanup(self.ws.stop)
-        self.patch(SyncTimestampChecker, "SERVER_URL", self.ws.get_iri())
-
-    @defer.inlineCallbacks
-    def test_returned_value_is_int(self):
-        """The returned value is an integer."""
-        checker = SyncTimestampChecker()
-        timestamp = yield deferToThread(checker.get_faithful_time)
-        self.assertEqual(type(timestamp), int)
-
-    @defer.inlineCallbacks
-    def test_first_call_does_head(self):
-        """The first call gets the clock from our web."""
-        checker = SyncTimestampChecker()
-        yield deferToThread(checker.get_faithful_time)
-        self.assertEqual(self.ws.root.count, 1)
-
-    @defer.inlineCallbacks
-    def test_second_call_is_cached(self):
-        """For the second call, the time is cached."""
-        checker = SyncTimestampChecker()
-        yield deferToThread(checker.get_faithful_time)
-        yield deferToThread(checker.get_faithful_time)
-        self.assertEqual(self.ws.root.count, 1)
-
-    @defer.inlineCallbacks
-    def test_after_timeout_cache_expires(self):
-        """After some time, the cache expires."""
-        fake_timestamp = 1
-        self.patch(time, "time", lambda: fake_timestamp)
-        checker = SyncTimestampChecker()
-        yield deferToThread(checker.get_faithful_time)
-        fake_timestamp += SyncTimestampChecker.CHECKING_INTERVAL
-        yield deferToThread(checker.get_faithful_time)
-        self.assertEqual(self.ws.root.count, 2)
-
-    @defer.inlineCallbacks
-    def test_server_date_sends_nocache_headers(self):
-        """Getting the server date sends the no-cache headers."""
-        checker = SyncTimestampChecker()
-        yield deferToThread(checker.get_server_time)
-        assert len(self.ws.root.request_headers) == 1
-        headers = self.ws.root.request_headers[0]
-        result = headers.getRawHeaders("Cache-Control")
-        self.assertEqual(result, ["no-cache"])
-
-    @defer.inlineCallbacks
-    def test_server_error_means_skew_not_updated(self):
-        """When server can't be reached, the skew is not updated."""
-        fake_timestamp = 1
-        self.patch(time, "time", lambda: fake_timestamp)
-        checker = SyncTimestampChecker()
-
-        def failing_get_server_time():
-            """Let's fail while retrieving the server time."""
-            raise FakedError()
-
-        self.patch(checker, "get_server_time", failing_get_server_time)
-        yield deferToThread(checker.get_faithful_time)
-        self.assertEqual(checker.skew, 0)
-        self.assertEqual(checker.next_check,
-                         fake_timestamp + SyncTimestampChecker.ERROR_INTERVAL)
-
-
 class PingUrlTestCase(TestCase):
     """Test suite for the URL pinging."""
 
     @defer.inlineCallbacks
     def setUp(self):
         yield super(PingUrlTestCase, self).setUp()
-        self.url = u'http://example.com/'
+        self.url = 'http://example.com/'
         self.wc = FakeWebclient()
         self.patch(utils.webclient, "webclient_factory",
                    lambda *args: self.wc)
@@ -422,7 +253,7 @@
     @defer.inlineCallbacks
     def test_ping_url_formatting(self):
         """The email is added as the first formatting argument."""
-        self.url = u'http://example.com/{email}/something/else'
+        self.url = 'http://example.com/{email}/something/else'
         yield utils.ping_url(url=self.url, email=EMAIL, credentials=TOKEN)
 
         expected = self.url.format(email=EMAIL)
@@ -433,7 +264,7 @@
     @defer.inlineCallbacks
     def test_ping_url_formatting_with_query_params(self):
         """The email is added as the first formatting argument."""
-        self.url = u'http://example.com/{email}?something=else'
+        self.url = 'http://example.com/{email}?something=else'
         yield utils.ping_url(url=self.url, email=EMAIL, credentials=TOKEN)
 
         expected = self.url.format(email=EMAIL)
@@ -444,7 +275,7 @@
     @defer.inlineCallbacks
     def test_ping_url_formatting_no_email_kwarg(self):
         """The email is added as the first formatting argument."""
-        self.url = u'http://example.com/{0}/yadda/?something=else'
+        self.url = 'http://example.com/{0}/yadda/?something=else'
         yield utils.ping_url(url=self.url, email=EMAIL, credentials=TOKEN)
 
         expected = self.url.format(EMAIL)
@@ -455,7 +286,7 @@
     @defer.inlineCallbacks
     def test_ping_url_formatting_no_format(self):
         """The email is appended if formatting could not be accomplished."""
-        self.url = u'http://example.com/yadda/'
+        self.url = 'http://example.com/yadda/'
         yield utils.ping_url(url=self.url, email=EMAIL, credentials=TOKEN)
 
         expected = self.url + EMAIL

=== modified file 'ubuntu_sso/utils/tests/test_ipc.py'
--- ubuntu_sso/utils/tests/test_ipc.py	2012-04-30 16:15:46 +0000
+++ ubuntu_sso/utils/tests/test_ipc.py	2012-08-21 18:02:19 +0000
@@ -505,16 +505,16 @@
         """The remote_calls are renamed."""
         test_token = object()
 
-        class TestClass(object):
+        # pylint: disable=W0232
+        class TestClass(ipc.meta_base(ipc.RemoteMeta)):
             """A class for testing."""
 
-            __metaclass__ = ipc.RemoteMeta
-
             remote_calls = ['test_method']
 
             def test_method(self):
                 """Fake call."""
                 return test_token
+        # pylint: enable=W0232
 
         tc = TestClass()
         self.assertEquals(tc.test_method(), test_token)

=== modified file 'ubuntu_sso/utils/ui.py'
--- ubuntu_sso/utils/ui.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/utils/ui.py	2012-08-21 18:02:19 +0000
@@ -31,11 +31,15 @@
 import argparse
 import re
 import gettext
+import sys
 
 from ubuntu_sso.logger import setup_logging
 
+INSTALL_KWARGS = {}
+if sys.version_info < (3,):
+    INSTALL_KWARGS["unicode"] = True
 
-gettext.install('ubuntu-sso-client', unicode=True)
+gettext.install('ubuntu-sso-client', **INSTALL_KWARGS)
 logger = setup_logging('ubuntu_sso.utils.ui')