Merge lp:~frankban/juju-quickstart/unicode-all-the-things into lp:juju-quickstart

[Francesco Banconi]

Use unicode everywhere in the application.

My apologies for this branch, the diff is long
and the contents themself are boring: I am very
sorry. Anyway, I think this pushes quickstart
in a better place re: unicode/bytes handling.

Everything here is almost mechanical, including
the annoying problem of having to store encoded
strings in the exceptions: please let me know
if you have any suggestions, or if I am missing
something.

The serializers module is new stuff: it allows
for loading YAML strings as unicode and for
dumping dictionaries in the extended format
(used e.g. by juju-core in the envs.yaml file).

To QA this, just use quickstart as usual, deploying
a bundle or spinning up an environment.
Then try to break it passing exotic strings as
options, e.g.:
.venv/bin/python juju-quickstart --gui-charm-url ☢
(FWIW the above character is \xe2\x98\xa2).
This obviously fail, but the error should not
be unicode related.

Thank you and sorry again.

https://codereview.appspot.com/38500043/

[Francesco Banconi (frankban)]

Reviewers: mp+198112_code.launchpad.net,

Message:
Please take a look.

Description:
Use unicode everywhere in the application.

My apologies for this branch, the diff is long
and the contents themself are boring: I am very
sorry. Anyway, I think this pushes quickstart
in a better place re: unicode/bytes handling.

Everything here is almost mechanical, including
the annoying problem of having to store encoded
strings in the exceptions: please let me know
if you have any suggestions, or if I am missing
something.

The serializers module is new stuff: it allows
for loading YAML strings as unicode and for
dumping dictionaries in the extended format
(used e.g. by juju-core in the envs.yaml file).

To QA this, just use quickstart as usual, deploying
a bundle or spinning up an environment.
Then try to break it passing exotic strings as
options, e.g.:
.venv/bin/python juju-quickstart --gui-charm-url ☢
(FWIW the above character is \xe2\x98\xa2).
This obviously fail, but the error should not
be unicode related.

Thank you and sorry again.

https://code.launchpad.net/~frankban/juju-quickstart/unicode-all-the-things/+merge/198112

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/38500043/

Affected files (+372, -148 lines):
   A [revision details]
   M juju-quickstart
   M quickstart/__init__.py
   M quickstart/app.py
   M quickstart/juju.py
   M quickstart/manage.py
   M quickstart/models/charms.py
   M quickstart/models/envs.py
   A quickstart/serializers.py
   M quickstart/settings.py
   M quickstart/tests/helpers.py
   M quickstart/tests/models/__init__.py
   M quickstart/tests/models/test_charms.py
   M quickstart/tests/models/test_envs.py
   M quickstart/tests/test_app.py
   M quickstart/tests/test_juju.py
   M quickstart/tests/test_manage.py
   A quickstart/tests/test_serializers.py
   M quickstart/tests/test_utils.py
   M quickstart/utils.py

[Madison Scott-Clary (makyo)]

LGTM, QA okay. Thanks for the work!

https://codereview.appspot.com/38500043/

[Richard Harding (rharding)]

My tears run deep. I didn't realize it would be this messy supporting
both versions. Does it make any sense to create an alternate ValueError
that can be auto typed?

Yay for working on getting the ball rolling. LGTM with notes below.

https://codereview.appspot.com/38500043/diff/1/quickstart/__init__.py
File quickstart/__init__.py (right):

https://codereview.appspot.com/38500043/diff/1/quickstart/__init__.py#newcode30
quickstart/__init__.py:30: return '.'.join(map(unicode, VERSION))
How does this work with py3 when there is no unicode function? I'd seen
things like
https://github.com/bookieio/breadability/blob/master/breadability/_compat.py#L12

Which creates a unicode reference to str for py3 support.

https://codereview.appspot.com/38500043/diff/1/quickstart/tests/models/test_charms.py
File quickstart/tests/models/test_charms.py (right):

https://codereview.appspot.com/38500043/diff/1/quickstart/tests/models/test_charms.py#newcode33
quickstart/tests/models/test_charms.py:33:
charms.parse_url('precise/juju-gui')
I was expecting these to be u'' strings now.

https://codereview.appspot.com/38500043/

[Francesco Banconi (frankban)]

On 2013/12/06 19:17:34, rharding wrote:
> My tears run deep. I didn't realize it would be this messy supporting
both
> versions. Does it make any sense to create an alternate ValueError
that can be
> auto typed?

To be clear, with this branch we do not support both versions,
but just make the unicode handling more sane and nearer to
Python 3. Given this is not a library, I am not even sure we
will need to support both version: we can eventually just switch
to Python3 and drop support for previous versions.

An alternate ValueError could be a nice idea: on the
other hand I liked the way we reuse already existing exception
when possible, and IMHO the more I think about being explicit
when encoding exception messages, the more it does not seem
so bad to me. When we will make the effort to port everything
to Python3, we can remove all those unnecessary "msg.encode"
bits.

> Yay for working on getting the ball rolling. LGTM with notes below.

> https://codereview.appspot.com/38500043/diff/1/quickstart/__init__.py
> File quickstart/__init__.py (right):

https://codereview.appspot.com/38500043/diff/1/quickstart/__init__.py#newcode30
> quickstart/__init__.py:30: return '.'.join(map(unicode, VERSION))
> How does this work with py3 when there is no unicode function? I'd
seen things
> like

https://github.com/bookieio/breadability/blob/master/breadability/_compat.py#L12

> Which creates a unicode reference to str for py3 support.

As mentioned above, we are still not supporting Python3 (including
various __unicode__
and __str__ methods we still have in the code with Python2 semantics).
For this reason we can avoid introducing that kind of conditionals in
the code.

https://codereview.appspot.com/38500043/diff/1/quickstart/tests/models/test_charms.py
> File quickstart/tests/models/test_charms.py (right):

https://codereview.appspot.com/38500043/diff/1/quickstart/tests/models/test_charms.py#newcode33
> quickstart/tests/models/test_charms.py:33:
charms.parse_url('precise/juju-gui')
> I was expecting these to be u'' strings now.

Are you referring to:
expected = 'charm URL has no schema: precise/juju-gui'?

If so, it is still not clear if you expected 1) the whole
string to be u'...' or 2) just the final part, e.g.:
"charm URL has no schema: u'precise/juju-gui'"

Case 1) we use unicode_literals from __future__.
Case 2) we no longer print the repr of the value in the error,
but just the value itself.

Thank you both for the reviews!

https://codereview.appspot.com/38500043/

[Francesco Banconi (frankban)]

*** Submitted:

Use unicode everywhere in the application.

My apologies for this branch, the diff is long
and the contents themself are boring: I am very
sorry. Anyway, I think this pushes quickstart
in a better place re: unicode/bytes handling.

Everything here is almost mechanical, including
the annoying problem of having to store encoded
strings in the exceptions: please let me know
if you have any suggestions, or if I am missing
something.

The serializers module is new stuff: it allows
for loading YAML strings as unicode and for
dumping dictionaries in the extended format
(used e.g. by juju-core in the envs.yaml file).

To QA this, just use quickstart as usual, deploying
a bundle or spinning up an environment.
Then try to break it passing exotic strings as
options, e.g.:
.venv/bin/python juju-quickstart --gui-charm-url ☢
(FWIW the above character is \xe2\x98\xa2).
This obviously fail, but the error should not
be unicode related.

Thank you and sorry again.

R=matthew.scott, rharding
CC=
https://codereview.appspot.com/38500043

https://codereview.appspot.com/38500043/

=== modified file 'juju-quickstart'
--- juju-quickstart	2013-10-30 10:16:36 +0000
+++ juju-quickstart	2013-12-06 18:31:03 +0000
@@ -18,6 +18,8 @@
 
 """Juju Quickstart plugin entry point."""
 
+from __future__ import unicode_literals
+
 import sys
 
 from quickstart import (
@@ -31,4 +33,4 @@
     try:
         manage.run(options)
     except app.ProgramExit as err:
-        sys.exit(str(err))
+        sys.exit(bytes(err))

=== modified file 'quickstart/__init__.py'
--- quickstart/__init__.py	2013-12-05 08:49:12 +0000
+++ quickstart/__init__.py	2013-12-06 18:31:03 +0000
@@ -19,9 +19,12 @@
 that it can be managed using a Web interface (the Juju GUI).
 """
 
+from __future__ import unicode_literals
+
+
 VERSION = (0, 5, 0)
 
 
 def get_version():
     """Return the Juju Quickstart version as a string."""
-    return '.'.join(map(str, VERSION))
+    return '.'.join(map(unicode, VERSION))

=== modified file 'quickstart/app.py'
--- quickstart/app.py	2013-12-06 16:17:45 +0000
+++ quickstart/app.py	2013-12-06 18:31:03 +0000
@@ -16,7 +16,11 @@
 
 """Juju Quickstart base application functions."""
 
-from __future__ import print_function
+from __future__ import (
+    print_function,
+    unicode_literals,
+)
+
 import functools
 import json
 import logging
@@ -36,13 +40,17 @@
 
     Raise this exception if you want the program to exit gracefully printing
     the error message to stderr.
+
+    The error message can be either a unicode or a byte string.
     """
 
     def __init__(self, message):
+        if isinstance(message, unicode):
+            message = message.encode('utf-8')
         self.message = message
 
     def __str__(self):
-        return 'juju-quickstart: error: {}'.format(self.message)
+        return b'juju-quickstart: error: {}'.format(self.message)
 
 
 def ensure_dependencies():
@@ -69,7 +77,7 @@
         try:
             utils.add_apt_repository('ppa:juju/stable')
         except OSError as err:
-            raise ProgramExit(str(err))
+            raise ProgramExit(bytes(err))
         print('installing the following packages: {} '
               '(this can take a while)'.format(', '.join(required_packages)))
         print('sudo privileges will be used for package installation')
@@ -220,8 +228,8 @@
             env = juju.connect(api_url)
         except Exception as err:
             try_count += 1
-            msg = 'unable to connect to the Juju API server on {}: {}'.format(
-                api_url, err)
+            msg = b'unable to connect to the Juju API server on {}: {}'.format(
+                api_url.encode('utf-8'), err)
             if try_count >= 30:
                 raise ProgramExit(msg)
             else:

=== modified file 'quickstart/juju.py'
--- quickstart/juju.py	2013-11-27 15:58:06 +0000
+++ quickstart/juju.py	2013-12-06 18:31:03 +0000
@@ -16,13 +16,13 @@
 
 """Juju Quickstart API client."""
 
+from __future__ import unicode_literals
+
 import logging
 
 import jujuclient
 import websocket
 
-from quickstart import utils
-
 
 def connect(api_url):
     """Return an Environment instance connected to the given API URL."""
@@ -147,7 +147,7 @@
 
         Overridden to add logging.
         """
-        logging.debug('API message: --> {}'.format(utils.utf8(message)))
+        logging.debug('API message: --> {}'.format(message.decode('utf-8')))
         return super(WebSocketConnection, self).send(message)
 
     def recv(self):
@@ -156,5 +156,5 @@
         Overridden to add logging.
         """
         message = super(WebSocketConnection, self).recv()
-        logging.debug('API message: <-- {}'.format(utils.utf8(message)))
+        logging.debug('API message: <-- {}'.format(message.decode('utf-8')))
         return message

=== modified file 'quickstart/manage.py'
--- quickstart/manage.py	2013-12-05 19:54:20 +0000
+++ quickstart/manage.py	2013-12-06 18:31:03 +0000
@@ -16,10 +16,16 @@
 
 """Juju Quickstart application management."""
 
-from __future__ import print_function
+from __future__ import (
+    print_function,
+    unicode_literals,
+)
+
 import argparse
+import codecs
 import logging
 import os
+import sys
 import webbrowser
 
 import quickstart
@@ -76,7 +82,8 @@
         if os.path.isdir(bundle_file):
             bundle_file = os.path.join(bundle_file, 'bundles.yaml')
         try:
-            bundle_yaml = open(bundle_file).read()
+            bundle_yaml = codecs.open(
+                bundle_file.encode('utf-8'), encoding='utf-8').read()
         except IOError as err:
             return parser.error('unable to open bundle file: {}'.format(err))
     # Validate the bundle.
@@ -84,7 +91,7 @@
         bundle_name, bundle_services = utils.parse_bundle(
             bundle_yaml, options.bundle_name)
     except ValueError as err:
-        return parser.error(str(err))
+        return parser.error(bytes(err))
     # Update the options namespace with the new values.
     options.bundle_name = bundle_name
     options.bundle_services = bundle_services
@@ -107,12 +114,12 @@
     try:
         charm = charms.Charm.from_url(options.charm_url)
     except ValueError as err:
-        return parser.error(str(err))
+        return parser.error(bytes(err))
     if charm.is_local():
-        return parser.error('local charms are not allowed: {}'.format(charm))
+        return parser.error(b'local charms are not allowed: {}'.format(charm))
     if charm.series not in settings.JUJU_GUI_SUPPORTED_SERIES:
         return parser.error(
-            'unsupported charm series: {!r}'.format(charm.series))
+            'unsupported charm series: {}'.format(charm.series))
     if (
         # The user requested a bundle deployment.
         options.bundle and
@@ -150,7 +157,7 @@
         env_type, admin_secret, default_series = (
             envs.parse_env_file(env_file, env_name))
     except ValueError as err:
-        return parser.error(str(err))
+        return parser.error(bytes(err))
     # Update the options namespace with the new values.
     options.admin_secret = admin_secret
     options.env_file = env_file
@@ -175,6 +182,17 @@
     )
 
 
+def _convert_options_to_unicode(options):
+    """Convert all byte string values in the options namespace to unicode.
+
+    Modify the options in place and return None.
+    """
+    encoding = sys.stdin.encoding or 'utf-8'
+    for key, value in options._get_kwargs():
+        if isinstance(value, bytes):
+            setattr(options, key, value.decode(encoding))
+
+
 def setup():
     """Set up the application options and logger.
 
@@ -253,6 +271,8 @@
         nargs=0, help="Show program's description and exit")
     # Parse the provided arguments.
     options = parser.parse_args()
+    # Convert the provided string arguments to unicode.
+    _convert_options_to_unicode(options)
     # Validate and process the provided arguments.
     _validate_env(options, parser)
     if options.bundle is not None:

=== modified file 'quickstart/models/charms.py'
--- quickstart/models/charms.py	2013-12-03 22:48:26 +0000
+++ quickstart/models/charms.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Juju Quickstart charms management."""
 
+from __future__ import unicode_literals
+
 import re
 
 
@@ -39,45 +41,50 @@
     try:
         schema, remaining = url.split(':', 1)
     except ValueError:
-        raise ValueError('charm URL has no schema: {!r}'.format(url))
+        msg = 'charm URL has no schema: {}'.format(url)
+        raise ValueError(msg.encode('utf-8'))
     if schema not in ('cs', 'local'):
-        raise ValueError('charm URL has invalid schema: {!r}'.format(schema))
+        msg = 'charm URL has invalid schema: {}'.format(schema)
+        raise ValueError(msg.encode('utf-8'))
     # Retrieve the optional user, the series, name and revision.
     parts = remaining.split('/')
     parts_length = len(parts)
     if parts_length == 3:
         user, series, name_revision = parts
         if not user.startswith('~'):
-            raise ValueError(
-                'charm URL has invalid user name form: {!r}'.format(user))
+            msg = 'charm URL has invalid user name form: {}'.format(user)
+            raise ValueError(msg.encode('utf-8'))
         user = user[1:]
         if not valid_user(user):
-            raise ValueError(
-                'charm URL has invalid user name: {!r}'.format(user))
+            msg = 'charm URL has invalid user name: {}'.format(user)
+            raise ValueError(msg.encode('utf-8'))
         if schema == 'local':
-            raise ValueError(
-                'local charm URL with user name: {!r}'.format(url))
+            msg = 'local charm URL with user name: {}'.format(url)
+            raise ValueError(msg.encode('utf-8'))
     elif parts_length == 2:
         user = ''
         series, name_revision = parts
     else:
-        raise ValueError('charm URL has invalid form: {!r}'.format(url))
+        msg = 'charm URL has invalid form: {}'.format(url)
+        raise ValueError(msg.encode('utf-8'))
     # Validate the series.
     if not valid_series(series):
-        raise ValueError('charm URL has invalid series: {!r}'.format(series))
+        msg = 'charm URL has invalid series: {}'.format(series)
+        raise ValueError(msg.encode('utf-8'))
     # Validate name and revision.
     try:
         name, revision = name_revision.rsplit('-', 1)
     except ValueError:
-        raise ValueError(
-            'charm URL has no revision: {!r}'.format(url))
+        msg = 'charm URL has no revision: {}'.format(url)
+        raise ValueError(msg.encode('utf-8'))
     if not valid_name(name):
-        raise ValueError('charm URL has invalid name: {!r}'.format(name))
+        msg = 'charm URL has invalid name: {}'.format(name)
+        raise ValueError(msg.encode('utf-8'))
     try:
         revision = int(revision)
     except ValueError:
-        raise ValueError(
-            'charm URL has invalid revision: {!r}'.format(revision))
+        msg = 'charm URL has invalid revision: {}'.format(revision)
+        raise ValueError(msg.encode('utf-8'))
     return schema, user, series, name, revision
 
 
@@ -102,10 +109,14 @@
 
     def __str__(self):
         """The string representation of a charm is its URL."""
+        return self.__unicode__().encode('utf-8')
+
+    def __unicode__(self):
+        """The unicode representation of a charm is its URL."""
         return self.url()
 
     def __repr__(self):
-        return '<Charm: {}>'.format(str(self))
+        return b'<Charm: {}>'.format(bytes(self))
 
     def url(self):
         """Return the charm URL."""

=== modified file 'quickstart/models/envs.py'
--- quickstart/models/envs.py	2013-12-04 18:46:32 +0000
+++ quickstart/models/envs.py	2013-12-06 18:31:03 +0000
@@ -16,12 +16,15 @@
 
 """Juju Quickstart environments management."""
 
+from __future__ import unicode_literals
+
 import os
 import re
 
-import yaml
-
-from quickstart import utils
+from quickstart import (
+    serializers,
+    utils
+)
 
 
 # Compile the regular expression used to parse the "juju switch" output.
@@ -75,34 +78,34 @@
     """
     # Load the Juju environments file.
     try:
-        environments_file = open(env_file)
+        environments_file = open(env_file.encode('utf-8'))
     except IOError as err:
-        msg = 'unable to open environments file: {}'.format(err)
+        msg = b'unable to open environments file: {}'.format(err)
         raise ValueError(msg)
     # Parse the Juju environments file.
     try:
-        environments = yaml.safe_load(environments_file)
+        environments = serializers.yaml_load(environments_file)
     except Exception as err:
-        msg = 'unable to parse environments file {}: {}'.format(env_file, err)
-        raise ValueError(msg)
+        msg = b'unable to parse environments file {}: {}'
+        raise ValueError(msg.format(env_file.encode('utf-8'), err))
     # Retrieve the information about the current environment.
     try:
         environment = environments.get('environments', {}).get(env_name)
     except AttributeError as err:
         msg = 'invalid YAML contents in {}: {}'.format(env_file, environments)
-        raise ValueError(msg)
+        raise ValueError(msg.encode('utf-8'))
     if environment is None:
         msg = 'environment {} not found in {}'.format(env_name, env_file)
-        raise ValueError(msg)
+        raise ValueError(msg.encode('utf-8'))
     # Retrieve the provider type and the admin secret.
     env_type = environment.get('type')
     if env_type is None:
         msg = '{} provider type not found in {}'.format(env_name, env_file)
-        raise ValueError(msg)
+        raise ValueError(msg.encode('utf-8'))
     admin_secret = environment.get('admin-secret')
     if admin_secret is None:
         msg = '{} admin secret not found in {}'.format(env_name, env_file)
-        raise ValueError(msg)
+        raise ValueError(msg.encode('utf-8'))
     # The default-series is not required to be set so None is ok.
     default_series = environment.get('default-series')
     return env_type, admin_secret, default_series

=== added file 'quickstart/serializers.py'
--- quickstart/serializers.py	1970-01-01 00:00:00 +0000
+++ quickstart/serializers.py	2013-12-06 18:31:03 +0000
@@ -0,0 +1,47 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero 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
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Juju Quickstart functions for serializing data structures."""
+
+from __future__ import unicode_literals
+
+import yaml
+
+
+def yaml_load(stream):
+    """Parse the YAML document in stream.
+
+    The stream argument can be a file like object or a string content.
+
+    Produce and return the corresponding Python object, returning strings
+    as unicode objects.
+    """
+    # See <http://stackoverflow.com/questions/2890146/
+    # how-to-force-pyyaml-to-load-strings-as-unicode-objects>.
+    loader_class = type(b'UnicodeLoader', (yaml.SafeLoader,), {})
+    loader_class.add_constructor(
+        'tag:yaml.org,2002:str',
+        lambda loader, node: loader.construct_scalar(node))
+    return yaml.load(stream, Loader=loader_class)
+
+
+def yaml_dump(data, stream=None):
+    """Serialize a Python object into a YAML stream.
+
+    If stream is None, return the produced string instead.
+    Always serialize collections in the block style.
+    """
+    return yaml.safe_dump(data, stream, default_flow_style=False)

=== modified file 'quickstart/settings.py'
--- quickstart/settings.py	2013-12-04 14:47:58 +0000
+++ quickstart/settings.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Juju Quickstart settings."""
 
+from __future__ import unicode_literals
+
 import os
 
 

=== modified file 'quickstart/tests/helpers.py'
--- quickstart/tests/helpers.py	2013-12-04 14:47:58 +0000
+++ quickstart/tests/helpers.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Test helpers for the Juju Quickstart plugin."""
 
+from __future__ import unicode_literals
+
 from contextlib import contextmanager
 import os
 import shutil
@@ -156,7 +158,7 @@
         """
         with self.assertRaises(ValueError) as context_manager:
             yield
-        self.assertEqual(error, str(context_manager.exception))
+        self.assertEqual(error, bytes(context_manager.exception))
 
 
 class WatcherDataTestsMixin(object):

=== modified file 'quickstart/tests/models/__init__.py'
--- quickstart/tests/models/__init__.py	2013-12-03 22:48:26 +0000
+++ quickstart/tests/models/__init__.py	2013-12-06 18:31:03 +0000
@@ -0,0 +1,15 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero 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
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

=== modified file 'quickstart/tests/models/test_charms.py'
--- quickstart/tests/models/test_charms.py	2013-12-03 22:48:26 +0000
+++ quickstart/tests/models/test_charms.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Tests for the Juju Quickstart charms management."""
 
+from __future__ import unicode_literals
+
 import unittest
 
 from quickstart.models import charms
@@ -26,25 +28,25 @@
 
     def test_no_schema_error(self):
         # A ValueError is raised if the URL schema is missing.
-        expected = "charm URL has no schema: 'precise/juju-gui'"
+        expected = 'charm URL has no schema: precise/juju-gui'
         with self.assert_value_error(expected):
             charms.parse_url('precise/juju-gui')
 
     def test_invalid_schema_error(self):
         # A ValueError is raised if the URL schema is not valid.
-        expected = "charm URL has invalid schema: 'http'"
+        expected = 'charm URL has invalid schema: http'
         with self.assert_value_error(expected):
             charms.parse_url('http:precise/juju-gui')
 
     def test_invalid_user_form_error(self):
         # A ValueError is raised if the user form is not valid.
-        expected = "charm URL has invalid user name form: 'jean-luc'"
+        expected = 'charm URL has invalid user name form: jean-luc'
         with self.assert_value_error(expected):
             charms.parse_url('cs:jean-luc/precise/juju-gui')
 
     def test_invalid_user_name_error(self):
         # A ValueError is raised if the user name is not valid.
-        expected = "charm URL has invalid user name: 'jean:luc'"
+        expected = 'charm URL has invalid user name: jean:luc'
         with self.assert_value_error(expected):
             charms.parse_url('cs:~jean:luc/precise/juju-gui')
 
@@ -52,37 +54,37 @@
         # A ValueError is raised if a user is specified on a local charm.
         expected = (
             'local charm URL with user name: '
-            "'local:~jean-luc/precise/juju-gui'")
+            'local:~jean-luc/precise/juju-gui')
         with self.assert_value_error(expected):
             charms.parse_url('local:~jean-luc/precise/juju-gui')
 
     def test_invalid_form_error(self):
         # A ValueError is raised if the URL is not valid.
-        expected = "charm URL has invalid form: 'cs:~user/series/name/what-?'"
+        expected = 'charm URL has invalid form: cs:~user/series/name/what-?'
         with self.assert_value_error(expected):
             charms.parse_url('cs:~user/series/name/what-?')
 
     def test_invalid_series_error(self):
         # A ValueError is raised if the series is not valid.
-        expected = "charm URL has invalid series: 'boo!'"
+        expected = 'charm URL has invalid series: boo!'
         with self.assert_value_error(expected):
             charms.parse_url('cs:boo!/juju-gui-42')
 
     def test_no_revision_error(self):
         # A ValueError is raised if the charm revision is missing.
-        expected = "charm URL has no revision: 'cs:series/name'"
+        expected = 'charm URL has no revision: cs:series/name'
         with self.assert_value_error(expected):
             charms.parse_url('cs:series/name')
 
     def test_invalid_revision_error(self):
         # A ValueError is raised if the charm revision is not valid.
-        expected = "charm URL has invalid revision: 'revision'"
+        expected = 'charm URL has invalid revision: revision'
         with self.assert_value_error(expected):
             charms.parse_url('cs:series/name-revision')
 
     def test_invalid_name_error(self):
         # A ValueError is raised if the charm name is not valid.
-        expected = "charm URL has invalid name: 'not:valid'"
+        expected = 'charm URL has invalid name: not:valid'
         with self.assert_value_error(expected):
             charms.parse_url('cs:precise/not:valid-42')
 
@@ -169,14 +171,14 @@
     def test_from_url_error(self):
         # A ValueError is raised by the from_url class method if the provided
         # URL is not a valid charm URL.
-        expected = "charm URL has invalid form: 'cs:not-a-charm-url'"
+        expected = 'charm URL has invalid form: cs:not-a-charm-url'
         with self.assert_value_error(expected):
             charms.Charm.from_url('cs:not-a-charm-url')
 
     def test_string(self):
         # The string representation of a charm instance is its URL.
         charm = self.make_charm()
-        self.assertEqual('cs:~myuser/precise/juju-gui-42', str(charm))
+        self.assertEqual('cs:~myuser/precise/juju-gui-42', bytes(charm))
 
     def test_repr(self):
         # A charm instance is correctly represented.

=== modified file 'quickstart/tests/models/test_envs.py'
--- quickstart/tests/models/test_envs.py	2013-12-04 18:55:28 +0000
+++ quickstart/tests/models/test_envs.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Tests for the Juju Quickstart environments management."""
 
+from __future__ import unicode_literals
+
 import unittest
 
 import mock
@@ -93,7 +95,7 @@
         with self.assertRaises(ValueError) as context_manager:
             envs.parse_env_file(env_file, 'ec2')
         expected = 'unable to parse environments file {}'.format(env_file)
-        self.assertIn(expected, str(context_manager.exception))
+        self.assertIn(expected, bytes(context_manager.exception))
 
     def test_invalid_yaml_contents(self):
         # A ValueError is raised if the environments file is not well formed.

=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2013-12-06 16:17:45 +0000
+++ quickstart/tests/test_app.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Tests for the Juju Quickstart base application functions."""
 
+from __future__ import unicode_literals
+
 from contextlib import contextmanager
 import json
 import unittest
@@ -36,7 +38,7 @@
     def test_string_representation(self):
         # The error is properly represented as a string.
         exception = app.ProgramExit('bad wolf')
-        self.assertEqual('juju-quickstart: error: bad wolf', str(exception))
+        self.assertEqual('juju-quickstart: error: bad wolf', bytes(exception))
 
 
 class ProgramExitTestsMixin(object):
@@ -51,7 +53,7 @@
         with self.assertRaises(app.ProgramExit) as context_manager:
             yield
         expected = 'juju-quickstart: error: {}'.format(error)
-        self.assertEqual(expected, str(context_manager.exception))
+        self.assertEqual(expected, bytes(context_manager.exception))
 
     def make_env_error(self, message):
         """Create and return a jujuclient.EnvError with the given message."""

=== modified file 'quickstart/tests/test_juju.py'
--- quickstart/tests/test_juju.py	2013-11-27 15:58:06 +0000
+++ quickstart/tests/test_juju.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Tests for the Juju Quickstart API client."""
 
+from __future__ import unicode_literals
+
 import unittest
 
 import mock
@@ -317,7 +319,7 @@
 
 class TestWebSocketConnection(unittest.TestCase):
 
-    snowman = u'Here is a snowman\u00a1: \u2603'
+    snowman = 'Here is a snowman\u00a1: \u2603'
 
     def setUp(self):
         with mock.patch('socket.socket') as mock_socket:
@@ -335,9 +337,9 @@
 
     def test_send_unicode(self):
         # Outgoing unicode messages are properly logged.
-        expected = 'API message: --> {}'.format(self.snowman.encode('utf-8'))
+        expected = 'API message: --> {}'.format(self.snowman)
         with helpers.assert_logs([expected], 'debug'):
-            self.conn.send(self.snowman)
+            self.conn.send(self.snowman.encode('utf-8'))
         self.assertTrue(self.mock_send.called)
 
     def test_recv(self):
@@ -349,8 +351,8 @@
 
     def test_recv_unicode(self):
         # Incoming unicode messages are properly logged.
-        self.mock_recv.return_value = (42, self.snowman)
-        expected = 'API message: <-- {}'.format(self.snowman.encode('utf-8'))
+        self.mock_recv.return_value = (42, self.snowman.encode('utf-8'))
+        expected = 'API message: <-- {}'.format(self.snowman)
         with helpers.assert_logs([expected], 'debug'):
             self.conn.recv()
         self.mock_recv.assert_called_once_with()

=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2013-12-05 19:54:20 +0000
+++ quickstart/tests/test_manage.py	2013-12-06 18:31:03 +0000
@@ -16,10 +16,13 @@
 
 """Tests for the Juju Quickstart management infrastructure."""
 
+from __future__ import unicode_literals
+
 import argparse
 import logging
 import os
 import shutil
+import StringIO as io
 import tempfile
 import unittest
 
@@ -166,7 +169,7 @@
         options = self.make_options(url)
         manage._validate_bundle(options, self.parser)
         self.parser.error.assert_called_once_with(
-            "unable to open the bundle: invalid bundle URL: 'bundle:'")
+            'unable to open the bundle: invalid bundle URL: bundle:')
 
     def test_error_parsing_bundle_contents(self):
         # A parser error is invoked if an error occurs parsing the bundle YAML.
@@ -194,7 +197,7 @@
         # A parser error is invoked if the charm URL is not valid.
         options = self.make_options('cs:invalid')
         manage._validate_charm_url(options, self.parser)
-        expected = "charm URL has invalid form: 'cs:invalid'"
+        expected = 'charm URL has invalid form: cs:invalid'
         self.parser.error.assert_called_once_with(expected)
 
     def test_local_charm_error(self):
@@ -208,7 +211,7 @@
         # A parser error is invoked if the charm series is not supported.
         options = self.make_options('cs:nosuch/juju-gui-100')
         manage._validate_charm_url(options, self.parser)
-        expected = "unsupported charm series: 'nosuch'"
+        expected = 'unsupported charm series: nosuch'
         self.parser.error.assert_called_once_with(expected)
 
     def test_outdated_charm_error(self):
@@ -307,6 +310,30 @@
         self.assertEqual('local', options.env_type)
 
 
+class TestConvertOptionsToUnicode(unittest.TestCase):
+
+    def test_bytes_options(self):
+        # Byte strings are correctly converted.
+        options = argparse.Namespace(opt1=b'val1', opt2=b'val2')
+        manage._convert_options_to_unicode(options)
+        self.assertEqual('val1', options.opt1)
+        self.assertIsInstance(options.opt1, unicode)
+        self.assertEqual('val2', options.opt2)
+        self.assertIsInstance(options.opt2, unicode)
+
+    def test_unicode_options(self):
+        # Unicode options are left untouched.
+        options = argparse.Namespace(myopt='myval')
+        self.assertEqual('myval', options.myopt)
+        self.assertIsInstance(options.myopt, unicode)
+
+    def test_other_types(self):
+        # Other non-string types are left untouched.
+        options = argparse.Namespace(opt1=42, opt2=None)
+        self.assertEqual(42, options.opt1)
+        self.assertIsNone(options.opt2)
+
+
 @mock.patch('quickstart.manage._validate_env', mock.Mock())
 class TestSetup(unittest.TestCase):
 
@@ -376,10 +403,10 @@
 
     def test_version(self):
         # The program version is properly printed to stderr.
-        with mock.patch('sys.stderr') as mock_stderr:
+        with mock.patch('sys.stderr', new_callable=io.StringIO) as mock_stderr:
             self.call_setup(['--version'])
         expected = 'juju-quickstart {}\n'.format(quickstart.get_version())
-        mock_stderr.write.assert_called_once_with(expected)
+        self.assertEqual(expected, mock_stderr.getvalue())
 
     @mock.patch('quickstart.manage._validate_bundle')
     def test_bundle(self, mock_validate_bundle):

=== added file 'quickstart/tests/test_serializers.py'
--- quickstart/tests/test_serializers.py	1970-01-01 00:00:00 +0000
+++ quickstart/tests/test_serializers.py	2013-12-06 18:31:03 +0000
@@ -0,0 +1,58 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero 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
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the Juju Quickstart serialization helpers."""
+
+from __future__ import unicode_literals
+
+import unittest
+
+import mock
+import yaml
+
+from quickstart import serializers
+
+
+class TestYamlLoad(unittest.TestCase):
+
+    contents = '{myint: 42, mystring: foo}'
+
+    def test_unicode_strings(self):
+        # Strings are returned as unicode objects.
+        decoded = serializers.yaml_load(self.contents)
+        self.assertEqual(42, decoded['myint'])
+        self.assertEqual('foo', decoded['mystring'])
+        self.assertIsInstance(decoded['mystring'], unicode)
+        for key in decoded:
+            self.assertIsInstance(key, unicode, key)
+
+    @mock.patch('quickstart.serializers.yaml.load')
+    def test_safe(self, mock_load):
+        # The YAML decoder uses a safe loader.
+        serializers.yaml_load(self.contents)
+        self.assertEqual(self.contents, mock_load.call_args[0][0])
+        loader_class = mock_load.call_args[1]['Loader']
+        self.assertTrue(issubclass(loader_class, yaml.SafeLoader))
+
+
+class TestYamlDump(unittest.TestCase):
+
+    data = {'myint': 42, 'mystring': 'foo'}
+
+    def test_block_style(self):
+        # Collections are serialized in the block style.
+        contents = serializers.yaml_dump(self.data)
+        self.assertEqual('myint: 42\nmystring: foo\n', contents)

=== modified file 'quickstart/tests/test_utils.py'
--- quickstart/tests/test_utils.py	2013-12-04 22:16:45 +0000
+++ quickstart/tests/test_utils.py	2013-12-06 18:31:03 +0000
@@ -16,6 +16,8 @@
 
 """Tests for the Juju Quickstart utility functions and classes."""
 
+from __future__ import unicode_literals
+
 import httplib
 import json
 import socket
@@ -101,7 +103,7 @@
             'sudo', self.apt_get, 'install', '-y',
             'software-properties-common')
         self.assertEqual(
-            'apt-get install error', str(context_manager.exception))
+            'apt-get install error', bytes(context_manager.exception))
 
 
 class TestCall(unittest.TestCase):
@@ -202,7 +204,7 @@
 
     def test_error(self):
         # A ValueError is raised if the given bundle URL is not valid.
-        with self.assert_value_error("invalid bundle URL: 'bundle:'"):
+        with self.assert_value_error('invalid bundle URL: bundle:'):
             utils.convert_bundle_url('bundle:')
 
 
@@ -222,7 +224,7 @@
             with self.assertRaises(IOError) as context_manager:
                 utils.get_charm_url()
         mock_urlread.assert_called_once_with(settings.CHARMWORLD_API)
-        self.assertEqual('bad wolf', str(context_manager.exception))
+        self.assertEqual('bad wolf', bytes(context_manager.exception))
 
     def test_value_error(self):
         # A ValueError is raised if the API response is not valid.
@@ -232,7 +234,7 @@
                 utils.get_charm_url()
         mock_urlread.assert_called_once_with(settings.CHARMWORLD_API)
         self.assertEqual(
-            'unable to find the charm URL', str(context_manager.exception))
+            'unable to find the charm URL', bytes(context_manager.exception))
 
 
 class TestGetServiceInfo(helpers.WatcherDataTestsMixin, unittest.TestCase):
@@ -322,7 +324,7 @@
         with self.patch_call(1, error='bad wolf') as mock_call:
             with self.assertRaises(OSError) as context_manager:
                 utils.get_ubuntu_codename()
-        self.assertEqual('bad wolf', str(context_manager.exception))
+        self.assertEqual('bad wolf', bytes(context_manager.exception))
         mock_call.assert_called_once_with('lsb_release', '-cs')
 
 
@@ -343,38 +345,38 @@
         with self.assertRaises(ValueError) as context_manager:
             utils.parse_bundle(':')
         expected = 'unable to parse the bundle'
-        self.assertIn(expected, str(context_manager.exception))
+        self.assertIn(expected, bytes(context_manager.exception))
 
     def test_yaml_invalid_type(self):
         # A ValueError is raised if the bundle contents are not well formed.
-        with self.assert_value_error("invalid YAML contents: 'a-string'"):
+        with self.assert_value_error('invalid YAML contents: a-string'):
             utils.parse_bundle('a-string')
 
     def test_yaml_invalid_bundle_data(self):
         # A ValueError is raised if bundles are not well formed.
         contents = yaml.safe_dump({'mybundle': 'not valid'})
-        expected = "invalid YAML contents: {'mybundle': 'not valid'}"
+        expected = 'invalid YAML contents: {mybundle: not valid}\n'
         with self.assert_value_error(expected):
             utils.parse_bundle(contents)
 
     def test_yaml_no_service(self):
         # A ValueError is raised if bundles do not include services.
         contents = yaml.safe_dump({'mybundle': {}})
-        expected = "invalid YAML contents: {'mybundle': {}}"
+        expected = 'invalid YAML contents: mybundle: {}\n'
         with self.assert_value_error(expected):
             utils.parse_bundle(contents)
 
     def test_yaml_none_bundle_services(self):
         # A ValueError is raised if services are None.
         contents = yaml.safe_dump({'mybundle': {'services': None}})
-        expected = "invalid YAML contents: {'mybundle': {'services': None}}"
+        expected = 'invalid YAML contents: mybundle: {services: null}\n'
         with self.assert_value_error(expected):
             utils.parse_bundle(contents)
 
     def test_yaml_invalid_bundle_services_type(self):
         # A ValueError is raised if services have an invalid type.
         contents = yaml.safe_dump({'mybundle': {'services': 42}})
-        expected = "invalid YAML contents: {'mybundle': {'services': 42}}"
+        expected = 'invalid YAML contents: mybundle: {services: 42}\n'
         with self.assert_value_error(expected):
             utils.parse_bundle(contents)
 
@@ -445,7 +447,7 @@
         with self.assertRaises(ValueError) as context_manager:
             utils.parse_status_output(':')
         expected = 'unable to parse the output'
-        self.assertIn(expected, str(context_manager.exception))
+        self.assertIn(expected, bytes(context_manager.exception))
 
     def test_invalid_yaml_contents(self):
         # A ValueError is raised if the output is not well formed.
@@ -459,7 +461,7 @@
                 '0': {'agent-version': '1.17.0.1'},
             },
         }
-        expected = 'machines:0:agent-state not found in {}'.format(str(data))
+        expected = 'machines:0:agent-state not found in {}'.format(bytes(data))
         with self.assert_value_error(expected):
             utils.get_agent_state(yaml.safe_dump(data))
 
@@ -480,7 +482,7 @@
                 '0': {'agent-version': '1.17.0.1'},
             },
         }
-        expected = 'machines:0:series not found in {}'.format(str(data))
+        expected = 'machines:0:series not found in {}'.format(bytes(data))
         with self.assert_value_error(expected):
             utils.get_bootstrap_node_series(yaml.safe_dump(data))
 
@@ -547,16 +549,19 @@
 
 class TestUrlread(unittest.TestCase):
 
-    def patch_urlopen(self, contents=None, error=None):
+    def patch_urlopen(self, contents=None, error=None, content_type=None):
         """Patch the urllib2.urlopen function.
 
         If contents is not None, the read() method of the returned mock object
         returns the given contents.
+        If content_type is provided, the response includes the content type.
         If an error is provided, the call raises the error.
         """
-        mock_urlopen = mock.Mock()
+        mock_urlopen = mock.MagicMock()
         if contents is not None:
             mock_urlopen().read.return_value = contents
+        if content_type is not None:
+            mock_urlopen().headers = {'content-type': content_type}
         if error is not None:
             mock_urlopen.side_effect = error
         mock_urlopen.reset_mock()
@@ -564,9 +569,32 @@
 
     def test_contents(self):
         # The URL contents are correctly returned.
-        with self.patch_urlopen(contents='URL contents') as mock_urlopen:
+        with self.patch_urlopen(contents=b'URL contents') as mock_urlopen:
             contents = utils.urlread('http://example.com/path/')
         self.assertEqual('URL contents', contents)
+        self.assertIsInstance(contents, unicode)
+        mock_urlopen.assert_called_once_with('http://example.com/path/')
+
+    def test_content_type(self):
+        # The URL contents are decoded using the site charset.
+        patch_urlopen = self.patch_urlopen(
+            contents=b'URL contents: \xf8',  # This is not a UTF-8 byte string.
+            content_type='text/html; charset=ISO-8859-1')
+        with patch_urlopen as mock_urlopen:
+            contents = utils.urlread('http://example.com/path/')
+        self.assertEqual('URL contents: \xf8', contents)
+        self.assertIsInstance(contents, unicode)
+        mock_urlopen.assert_called_once_with('http://example.com/path/')
+
+    def test_no_content_type(self):
+        # The URL contents are decoded with UTF-8 by default.
+        patch_urlopen = self.patch_urlopen(
+            contents=b'URL contents: \xf8',  # This is not a UTF-8 byte string.
+            content_type='text/html')
+        with patch_urlopen as mock_urlopen:
+            contents = utils.urlread('http://example.com/path/')
+        self.assertEqual('URL contents: ', contents)
+        self.assertIsInstance(contents, unicode)
         mock_urlopen.assert_called_once_with('http://example.com/path/')
 
     def test_errors(self):
@@ -582,24 +610,4 @@
                 with self.assertRaises(IOError) as context_manager:
                     utils.urlread('http://example.com/path/')
             mock_urlopen.assert_called_once_with('http://example.com/path/')
-            self.assertEqual(message, str(context_manager.exception))
-
-
-class TestUtf8(unittest.TestCase):
-
-    def test_unicode(self):
-        # A unicode value is correctly converted.
-        value = utils.utf8(u'foo')
-        self.assertIsInstance(value, str)
-        self.assertEqual('foo', value)
-
-    def test_bytes(self):
-        # A bytes value is left untouched.
-        original = 'foo'
-        value = utils.utf8(original)
-        self.assertIsInstance(value, str)
-        self.assertIs(original, value)
-
-    def test_none(self):
-        # The None value is returned as is.
-        self.assertIsNone(utils.utf8(None))
+            self.assertEqual(message, bytes(context_manager.exception))

=== modified file 'quickstart/utils.py'
--- quickstart/utils.py	2013-12-04 18:55:28 +0000
+++ quickstart/utils.py	2013-12-06 18:31:03 +0000
@@ -16,7 +16,11 @@
 
 """Juju Quickstart utility functions and classes."""
 
-from __future__ import print_function
+from __future__ import (
+    print_function,
+    unicode_literals,
+)
+
 import collections
 import httplib
 import json
@@ -26,9 +30,10 @@
 import subprocess
 import urllib2
 
-import yaml
-
-from quickstart import settings
+from quickstart import (
+    serializers,
+    settings,
+)
 from quickstart.models import charms
 
 
@@ -55,7 +60,7 @@
     for command in commands:
         retcode, _, error = call('sudo', *command)
         if retcode:
-            raise OSError(error)
+            raise OSError(error.encode('utf-8'))
 
 
 def call(command, *args):
@@ -79,7 +84,7 @@
     retcode = process.poll()
     logging.debug('retcode: {} | output: {!r} | error: {!r}'.format(
         retcode, output, error))
-    return retcode, output, error
+    return retcode, output.decode('utf-8'), error.decode('utf-8')
 
 
 def check_gui_charm_url(charm_url):
@@ -103,13 +108,14 @@
 
 
 def convert_bundle_url(bundle_url):
-    """Return the equivalent YAML HTTPS location for the fiven bundle URL.
+    """Return the equivalent YAML HTTPS location for the given bundle URL.
 
     Raise a ValueError if the given URL is not a valid bundle URL.
     """
     bundle_id = bundle_url.split(':', 1)[1].rstrip('/')
     if not bundle_id:
-        raise ValueError('invalid bundle URL: {!r}'.format(bundle_url))
+        msg = 'invalid bundle URL: {}'.format(bundle_url)
+        raise ValueError(msg.encode('utf-8'))
     return ('https://manage.jujucharms.com/bundle/{}/json'.format(bundle_id),
             bundle_id)
 
@@ -123,7 +129,7 @@
     charm_info = json.loads(urlread(settings.CHARMWORLD_API))
     charm_url = charm_info.get('charm', {}).get('url')
     if charm_url is None:
-        raise ValueError('unable to find the charm URL')
+        raise ValueError(b'unable to find the charm URL')
     return charm_url
 
 
@@ -159,7 +165,7 @@
     """
     retcode, output, error = call('lsb_release', '-cs')
     if retcode:
-        raise OSError(error)
+        raise OSError(error.encode('utf-8'))
     return output.strip()
 
 
@@ -182,43 +188,46 @@
     """
     # Parse the bundle file.
     try:
-        bundles = yaml.safe_load(bundle_yaml)
+        bundles = serializers.yaml_load(bundle_yaml)
     except Exception as err:
-        msg = 'unable to parse the bundle: {}'.format(err)
+        msg = b'unable to parse the bundle: {}'.format(err)
         raise ValueError(msg)
     # Ensure the bundle file is well formed and contains at least one bundle.
     if not isinstance(bundles, collections.Mapping):
-        raise ValueError('invalid YAML contents: {!r}'.format(bundles))
+        msg = 'invalid YAML contents: {}'.format(bundle_yaml)
+        raise ValueError(msg.encode('utf-8'))
     try:
         name_services_map = dict(
             (key, value['services'].keys())
             for key, value in bundles.items()
         )
     except (AttributeError, KeyError, TypeError):
-        raise ValueError('invalid YAML contents: {!r}'.format(bundles))
+        msg = 'invalid YAML contents: {}'.format(bundle_yaml)
+        raise ValueError(msg.encode('utf-8'))
     if not name_services_map:
-        raise ValueError('no bundles found')
+        raise ValueError(b'no bundles found')
     # Retrieve the bundle name and services.
     if bundle_name is None:
         if len(name_services_map) > 1:
             msg = 'multiple bundles found ({}) but no bundle name specified'
             bundle_names = ', '.join(sorted(name_services_map.keys()))
-            raise ValueError(msg.format(bundle_names))
+            raise ValueError(msg.format(bundle_names).encode('utf-8'))
         bundle_name, bundle_services = name_services_map.items()[0]
     else:
         bundle_services = name_services_map.get(bundle_name)
         if bundle_services is None:
             msg = 'bundle {} not found in the provided list of bundles ({})'
             bundle_names = ', '.join(sorted(name_services_map.keys()))
-            raise ValueError(msg.format(bundle_name, bundle_names))
+            raise ValueError(
+                msg.format(bundle_name, bundle_names).encode('utf-8'))
     if not bundle_services:
         msg = 'bundle {} does not include any services'.format(bundle_name)
-        raise ValueError(msg)
+        raise ValueError(msg.encode('utf-8'))
     if settings.JUJU_GUI_SERVICE_NAME in bundle_services:
-        raise ValueError('bundle {} contains an instance of juju-gui. '
-                         'quickstart will install the latest version of the '
-                         'Juju GUI automatically, please remove juju-gui from '
-                         'the bundle.'.format(bundle_name))
+        msg = ('bundle {} contains an instance of juju-gui. quickstart will '
+               'install the latest version of the Juju GUI automatically, '
+               'please remove juju-gui from the bundle.'.format(bundle_name))
+        raise ValueError(msg.encode('utf-8'))
     return bundle_name, bundle_services
 
 
@@ -231,18 +240,20 @@
     if keys is None:
         keys = ['dummy']
     try:
-        status = yaml.safe_load(output)
+        status = serializers.yaml_load(output)
     except Exception as err:
-        raise ValueError('unable to parse the output: {}'.format(err))
+        raise ValueError(b'unable to parse the output: {}'.format(err))
 
     selection = status
     for key in keys:
         try:
             selection = selection.get(key, {})
         except AttributeError as err:
-            raise ValueError('invalid YAML contents: {}'.format(status))
+            msg = 'invalid YAML contents: {}'.format(status)
+            raise ValueError(msg.encode('utf-8'))
     if selection == {}:
-        raise ValueError('{} not found in {}'.format(':'.join(keys), status))
+        msg = '{} not found in {}'.format(':'.join(keys), status)
+        raise ValueError(msg.encode('utf-8'))
     return selection
 
 
@@ -286,15 +297,12 @@
     except urllib2.URLError as err:
         raise IOError(err.reason)
     except (httplib.HTTPException, socket.error, urllib2.HTTPError) as err:
-        raise IOError(str(err))
-    return response.read()
-
-
-def utf8(value):
-    """Return the utf8 encoded version of the given value.
-
-    The given value is returned as is if already encoded or not a string.
-    """
-    if isinstance(value, unicode):
-        return value.encode('utf-8')
-    return value
+        raise IOError(bytes(err))
+    contents = response.read()
+    content_type = response.headers['content-type']
+    charset = 'utf-8'
+    if 'charset=' in content_type:
+        sent_charset = content_type.split('charset=')[-1].strip()
+        if sent_charset:
+            charset = sent_charset
+    return contents.decode(charset, 'ignore')