diff --git a/messaging/mms/message.py b/messaging/mms/message.py
index 6cff8a0..3a67699 100644
--- a/messaging/mms/message.py
+++ b/messaging/mms/message.py
@@ -201,9 +201,29 @@ def smil(self):
                     audio_node.setAttribute('begin', str(begin))
                     audio_node.setAttribute('end', str(end))
 
-                par_node.appendChild(text_node)
                 par_node.appendChild(audio_node)
 
+            if page.video is not None:
+                part, begin, end = page.video
+                if 'Content-Location' in part.headers:
+                    src = part.headers['Content-Location']
+                elif 'Content-ID' in part.headers:
+                    src = part.headers['Content-ID']
+                else:
+                    src = part.data
+
+                video_node = smil_doc.createElement('video')
+                video_node.setAttribute('src', src)
+                video_node.setAttribute('region', 'Image')
+                if begin > 0 or end > 0:
+                    if end > page.duration:
+                        end = page.duration
+
+                    video_node.setAttribute('begin', str(begin))
+                    video_node.setAttribute('end', str(end))
+
+                par_node.appendChild(video_node)
+
             body_node.appendChild(par_node)
 
         smil_doc.documentElement.appendChild(body_node)
@@ -282,11 +302,12 @@ def __init__(self):
         self.image = None
         self.audio = None
         self.text = None
+        self.video = None
 
     @property
     def data_parts(self):
         """Returns a list of the data parst in this slide"""
-        return [part for part in (self.image, self.audio, self.text)
+        return [part for part in (self.image, self.audio, self.text, self.video)
                     if part is not None]
 
     def number_of_parts(self):
@@ -296,7 +317,7 @@ def number_of_parts(self):
         @rtype: int
         """
         num_parts = 0
-        for item in (self.image, self.audio, self.text):
+        for item in (self.image, self.audio, self.text, self.video):
             if item is not None:
                 num_parts += 1
 
@@ -376,6 +397,42 @@ def add_audio(self, filename, time_begin=0, time_end=0):
 
         self.audio = (DataPart(filename), time_begin, time_end)
 
+    def add_video(self, filename, time_begin=0, time_end=0):
+        """
+        Adds an video clip to this slide.
+
+        :param filename: The name of the video file to add. Currently the only
+                         supported format is AMR.
+        :type filename: str
+        :param time_begin: The time (in milliseconds) during the duration of
+                          this slide to begin playback of the video clip. If
+                          this is 0 or less, the video clip will be played the
+                          moment the slide is opened.
+        :type time_begin: int
+        :param time_end: The time (in milliseconds) during the duration of this
+                        slide at which to stop playing (i.e. mute) the video
+                        clip. If this is 0 or less, or if it is greater than
+                        the actual duration of this slide, the entire video
+                        clip will be played, or until the next slide is
+                        accessed.
+        :type time_end: int
+        :raise TypeError: An inappropriate variable type was passed in of the
+                          parameters
+        """
+        if not isinstance(filename, str):
+            raise TypeError("filename must be a string")
+
+        if not isinstance(time_begin, int) or not isinstance(time_end, int):
+            raise TypeError("time_begin and time_end must be ints")
+
+        if not os.path.isfile(filename):
+            raise OSError("filename must be a file")
+
+        if time_end > 0 and time_end < time_begin:
+            raise ValueError('time_end cannot be lower than time_begin')
+
+        self.video = (DataPart(filename), time_begin, time_end)
+
     def add_text(self, text, time_begin=0, time_end=0):
         """
         Adds a block of text to this slide.
@@ -430,7 +487,7 @@ def set_duration(self, duration):
         self.duration = duration
 
 
-class DataPart(object):
+class DataPart:
     """
     I am a data entry in the MMS body
 
@@ -544,11 +601,11 @@ def data(self):
         """A buffer containing the binary data of this part"""
         if self._data is not None:
             if type(self._data) == array.array:
-                self._data = self._data.tostring()
+                self._data = self._data.tobytes()
             return self._data
 
         elif self._filename is not None:
-            with open(self._filename, 'r') as f:
+            with open(self._filename, 'rb') as f:
                 self._data = f.read()
             return self._data
 
diff --git a/messaging/mms/mms_pdu.py b/messaging/mms/mms_pdu.py
index ed44c46..75bba44 100644
--- a/messaging/mms/mms_pdu.py
+++ b/messaging/mms/mms_pdu.py
@@ -15,8 +15,8 @@
 import array
 import os
 import random
+import logging
 
-from messaging.utils import debug
 from messaging.mms import message, wsp_pdu
 from messaging.mms.iterator import PreviewIterator
 
@@ -25,7 +25,7 @@ def flatten_list(x):
     """Flattens ``x`` into a single list"""
     result = []
     for el in x:
-        if hasattr(el, "__iter__") and not isinstance(el, basestring):
+        if hasattr(el, "__iter__") and not isinstance(el, str):
             result.extend(flatten_list(el))
         else:
             result.append(el)
@@ -167,7 +167,7 @@ def decode_message_body(self, data_iter):
         except StopIteration:
             return
 
-        #print 'Number of data entries (parts) in MMS body:', num_entries
+        logging.debug('Number of data entries (parts) in MMS body: %i' % num_entries)
 
         ########## MMS body: entries ##########
         # For every data "part", we have to read the following sequence:
@@ -175,15 +175,15 @@ def decode_message_body(self, data_iter):
         # <length of data>,
         # <content-type + other possible headers>,
         # <data>
-        for part_num in xrange(num_entries):
-            #print '\nPart %d:\n------' % part_num
+        for part_num in range(num_entries):
+            logging.debug('\nPart %d:\n------' % part_num)
             headers_len = self.decode_uint_var(data_iter)
             data_len = self.decode_uint_var(data_iter)
 
             # Prepare to read content-type + other possible headers
             ct_field_bytes = []
-            for i in xrange(headers_len):
-                ct_field_bytes.append(data_iter.next())
+            for i in range(headers_len):
+                ct_field_bytes.append(next(data_iter))
 
             ct_iter = PreviewIterator(ct_field_bytes)
             # Get content type
@@ -201,8 +201,8 @@ def decode_message_body(self, data_iter):
 
             # Data (note: this is not null-terminated)
             data = array.array('B')
-            for i in xrange(data_len):
-                data.append(data_iter.next())
+            for i in range(data_len):
+                data.append(next(data_iter))
 
             part = message.DataPart()
             part.set_data(data, ctype)
@@ -269,7 +269,7 @@ def decode_mms_header(byte_iter):
         byte = wsp_pdu.Decoder.decode_short_integer_from_byte(preview)
 
         if byte in mms_field_names:
-            byte_iter.next()
+            next(byte_iter)
             mms_field_name = mms_field_names[byte][0]
         else:
             byte_iter.reset_preview()
@@ -281,11 +281,11 @@ def decode_mms_header(byte_iter):
         try:
             name = mms_field_names[byte][1]
             mms_value = getattr(MMSDecoder, 'decode_%s' % name)(byte_iter)
-        except wsp_pdu.DecodeError, msg:
+        except wsp_pdu.DecodeError as e:
             raise wsp_pdu.DecodeError('Invalid MMS Header: Could '
-                                      'not decode MMS-value: %s' % msg)
+                                      'not decode MMS-value: %s' % e)
         except:
-            raise RuntimeError('A fatal error occurred, probably due to an '
+            print('A fatal error occurred, probably due to an '
                                'unimplemented decoding operation. Tried to '
                                'decode header: %s' % mms_field_name)
 
@@ -316,11 +316,11 @@ def decode_encoded_string_value(byte_iter):
             # TODO: add proper support for charsets...
             try:
                 charset = wsp_pdu.Decoder.decode_well_known_charset(byte_iter)
-            except wsp_pdu.DecodeError, msg:
+            except wsp_pdu.DecodeError as e:
                 raise Exception('encoded_string_value decoding error - '
-                                'Could not decode Charset value: %s' % msg)
+                                'Could not decode Charset value: %s' % e)
 
-            return wsp_pdu.Decoder.decode_text_string(byte_iter)
+            return wsp_pdu.Decoder.decode_text_string(byte_iter, charset)
         except wsp_pdu.DecodeError:
             # Fall back on just "Text-string"
             return wsp_pdu.Decoder.decode_text_string(byte_iter)
@@ -350,13 +350,13 @@ def decode_boolean_value(byte_iter):
             byte_iter.reset_preview()
             raise wsp_pdu.DecodeError('Error parsing boolean value '
                                       'for byte: %s' % hex(byte))
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         return byte == 128
 
     @staticmethod
     def decode_delivery_time_value(byte_iter):
         value_length = wsp_pdu.Decoder.decode_value_length(byte_iter)
-        token = byte_iter.next()
+        token = next(byte_iter)
         value = wsp_pdu.Decoder.decode_long_integer(byte_iter)
         if token == 128:
             token_type = 'absolute'
@@ -383,7 +383,7 @@ def decode_from_value(byte_iter):
         """
         value_length = wsp_pdu.Decoder.decode_value_length(byte_iter)
         # See what token we have
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         if byte == 129:  # Insert-address-token
             return '<not inserted>'
 
@@ -416,7 +416,7 @@ def decode_message_class_value(byte_iter):
         }
         byte = byte_iter.preview()
         if byte in class_identifiers:
-            byte_iter.next()
+            next(byte_iter)
             return class_identifiers[byte]
 
         byte_iter.reset_preview()
@@ -444,7 +444,7 @@ def decode_message_type_value(byte_iter):
 
         byte = byte_iter.preview()
         if byte in message_types:
-            byte_iter.next()
+            next(byte_iter)
             return message_types[byte]
 
         byte_iter.reset_preview()
@@ -467,7 +467,7 @@ def decode_priority_value(byte_iter):
 
         byte = byte_iter.preview()
         if byte in priorities:
-            byte = byte_iter.next()
+            byte = next(byte_iter)
             return priorities[byte]
 
         byte_iter.reset_preview()
@@ -498,7 +498,7 @@ def decode_sender_visibility_value(byte_iter):
             raise wsp_pdu.DecodeError('Error parsing sender visibility '
                                       'value for byte: %s' % hex(byte))
 
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         value = 'Hide' if byte == 128 else 'Show'
         return value
 
@@ -529,7 +529,7 @@ def decode_response_status_value(byte_iter):
             0x88: 'Error-unsupported-message',
         }
         byte = byte_iter.preview()
-        byte_iter.next()
+        next(byte_iter)
         # Return error unspecified if it couldn't be decoded
         return response_status_values.get(byte, 0x81)
 
@@ -555,7 +555,7 @@ def decode_status_value(byte_iter):
             0x84: 'Unrecognised',
         }
 
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         # Return an unrecognised state if it couldn't be decoded
         return status_values.get(byte, 0x84)
 
@@ -576,7 +576,7 @@ def decode_expiry_value(byte_iter):
         :rtype: str or int
         """
         value_length = MMSDecoder.decode_value_length(byte_iter)
-        token = byte_iter.next()
+        token = next(byte_iter)
 
         if token == 0x80:    # Absolute-token
             return MMSDecoder.decode_date_value(byte_iter)
@@ -695,10 +695,11 @@ def encode_message_header(self):
                     MMSEncoder.encode_header(hdr, headers_to_encode[hdr]))
 
         # Ok, now only "Content-type" should be left
-        content_type, ct_parameters = headers_to_encode['Content-Type']
-        message_header.extend(MMSEncoder.encode_mms_field_name('Content-Type'))
-        ret = MMSEncoder.encode_content_type_value(content_type, ct_parameters)
-        message_header.extend(flatten_list(ret))
+        if 'Content-Type' in headers_to_encode:
+            content_type, ct_parameters = headers_to_encode['Content-Type']
+            message_header.extend(MMSEncoder.encode_mms_field_name('Content-Type'))
+            ret = MMSEncoder.encode_content_type_value(content_type, ct_parameters)
+            message_header.extend(flatten_list(ret))
 
         return message_header
 
@@ -749,12 +750,13 @@ def encode_message_body(self):
         #TODO: enable encoding of MMSs without SMIL file
         ########## MMS body: header ##########
         # Parts: SMIL file + <number of data elements in each slide>
+        if len(self._mms_message._pages) == 0:
+            return message_body
         num_entries = 1
         for page in self._mms_message._pages:
             num_entries += page.number_of_parts()
 
-        for data_part in self._mms_message._data_parts:
-            num_entries += 1
+        num_entries += len(self._mms_message._data_parts)
 
         message_body.extend(self.encode_uint_var(num_entries))
 
@@ -773,7 +775,7 @@ def encode_message_body(self):
         smil_part.headers['Content-ID'] = '<0000>'
         parts = [smil_part]
         for slide in self._mms_message._pages:
-            for part_tuple in (slide.image, slide.audio, slide.text):
+            for part_tuple in (slide.image, slide.audio, slide.text, slide.video):
                 if part_tuple is not None:
                     parts.append(part_tuple[0])
 
@@ -800,7 +802,10 @@ def encode_message_body(self):
             message_body.extend(encoded_part_headers)
             # Data (note: we do not null-terminate this)
             for char in part.data:
-                message_body.append(ord(char))
+                if isinstance(char, int):
+                    message_body.append(char)
+                else:
+                    message_body.append(ord(char))
 
         return message_body
 
@@ -844,11 +849,11 @@ def encode_header(header_field_name, header_value):
                     ret = getattr(MMSEncoder,
                                   'encode_%s' % expected_type)(header_value)
                     encoded_header.extend(ret)
-                except wsp_pdu.EncodeError, msg:
+                except wsp_pdu.EncodeError as e:
                     raise wsp_pdu.EncodeError('Error encoding parameter '
-                                              'value: %s' % msg)
+                                              'value: %s' % e)
                 except:
-                    debug('A fatal error occurred, probably due to an '
+                    logging.error('A fatal error occurred, probably due to an '
                           'unimplemented encoding operation')
                     raise
 
diff --git a/messaging/mms/wsp_pdu.py b/messaging/mms/wsp_pdu.py
index 7aa1eae..3100efe 100644
--- a/messaging/mms/wsp_pdu.py
+++ b/messaging/mms/wsp_pdu.py
@@ -44,11 +44,11 @@
 
 import array
 from datetime import datetime
+import logging
 
-from messaging.utils import debug
 from messaging.mms.iterator import PreviewIterator
 
-wsp_pdu_types = {
+WSP_PDU_TYPES = {
     0x01: 'Connect',
     0x02: 'ConnectReply',
     0x03: 'Redirect',
@@ -63,7 +63,7 @@
 }
 
 # Well-known parameter assignments ([5], table 38)
-well_known_parameters = {
+WELL_KNOWN_PARAMETERS = {
     0x00: ('Q', 'q_value'),
     0x01: ('Charset', 'well_known_charset'),
     0x02: ('Level', 'version_value'),
@@ -97,7 +97,7 @@
 
 
 # Content type assignments ([5], table 40)
-well_known_content_types = [
+WELL_KNOWN_CONTENT_TYPES = [
     '*/*', 'text/*', 'text/html', 'text/plain',
     'text/x-hdml', 'text/x-ttml', 'text/x-vCalendar',
     'text/x-vCard', 'text/vnd.wap.wml',
@@ -164,7 +164,7 @@
 # Note that the assigned number is the same as the IANA MIBEnum value
 # "gsm-default-alphabet" is not included, as it is not assigned any
 # value in [5]. Also note, this is by no means a complete list
-well_known_charsets = {
+WELL_KNOWN_CHARSETS = {
     0x07EA: 'big5',
     0x03E8: 'iso-10646-ucs-2',
     0x04: 'iso-8859-1',
@@ -182,7 +182,7 @@
 }
 
 # Header Field Name assignments ([5], table 39)
-header_field_names = [
+HEADER_FIELD_NAMES = [
     'Accept', 'Accept-Charset', 'Accept-Encoding',
     'Accept-Language', 'Accept-Ranges', 'Age',
     'Allow', 'Authorization', 'Cache-Control',
@@ -214,11 +214,11 @@
 ]
 
 
-# TODO: combine this dict with the header_field_names table (same as well
+# TODO: combine this dict with the HEADER_FIELD_NAMES table (same as well
 # known parameter assignments)
 # Temporary fix to allow different types of header field values to be
 # dynamically decoded
-header_field_encodings = {'Accept': 'accept_value', 'Pragma': 'pragma_value'}
+HEADER_FIELD_ENCODINGS = {'Accept': 'accept_value', 'Pragma': 'pragma_value'}
 
 
 def get_header_field_names(version='1.2'):
@@ -243,7 +243,7 @@ def get_header_field_names(version='1.2'):
 
     version = int(version.split('.')[1])
 
-    versioned_field_names = header_field_names[:]
+    versioned_field_names = HEADER_FIELD_NAMES[:]
     if version == 3:
         versioned_field_names = versioned_field_names[:0x44]
     elif version == 2:
@@ -281,7 +281,7 @@ def get_well_known_parameters(version='1.2'):
     else:
         version = int(version.split('.')[1])
 
-    versioned_params = well_known_parameters.copy()
+    versioned_params = WELL_KNOWN_PARAMETERS.copy()
     if version <= 3:
         for assigned_number in range(0x11, 0x1e):
             del versioned_params[assigned_number]
@@ -331,7 +331,7 @@ def decode_uint_8(byte_iter):
         :rtype: int
         """
         # Make the byte unsigned
-        return byte_iter.next() & 0xf
+        return next(byte_iter) & 0xf
 
     @staticmethod
     def decode_uint_var(byte_iter):
@@ -353,11 +353,11 @@ def decode_uint_var(byte_iter):
         :rtype: int
         """
         uint = 0
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         while (byte >> 7) == 0x01:
             uint = uint << 7
             uint |= byte & 0x7f
-            byte = byte_iter.next()
+            byte = next(byte_iter)
 
         uint = uint << 7
         uint |= byte & 0x7f
@@ -388,7 +388,7 @@ def decode_short_integer(byte_iter):
             byte_iter.reset_preview()
             raise DecodeError('Not a valid short-integer: MSB not set')
 
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         return byte & 0x7f
 
     @staticmethod
@@ -447,14 +447,14 @@ def decode_long_integer(byte_iter):
 
         longInt = 0
         # Decode the Multi-octect-integer
-        for i in xrange(shortLength):
+        for i in range(shortLength):
             longInt = longInt << 8
-            longInt |= byte_iter.next()
+            longInt |= next(byte_iter)
 
         return longInt
 
     @staticmethod
-    def decode_text_string(byte_iter):
+    def decode_text_string(byte_iter, encoding = 'utf-8'):
         """
         Decodes the null-terminated, binary-encoded string value starting
         at the byte pointed to by ``byte_iter``.
@@ -473,17 +473,22 @@ def decode_text_string(byte_iter):
         :return: The decoded text string
         :rtype: str
         """
-        decoded_string = ''
-        byte = byte_iter.next()
+        b_decoded_string = b''
+        byte = next(byte_iter)
         # Remove Quote character (octet 127), if present
         if byte == 127:
-            byte = byte_iter.next()
+            byte = next(byte_iter)
 
         while byte != 0x00:
-            decoded_string += chr(byte)
-            byte = byte_iter.next()
+            b_decoded_string += bytes([byte])
+            byte = next(byte_iter)
 
-        return decoded_string
+        try:
+            # Lets try to decode it to the given encoding
+            # if that fails we probably have characters that need to be escaped
+            return b_decoded_string.decode(encoding)
+        except UnicodeError:
+            return b_decoded_string.decode("unicode_escape")
 
     @staticmethod
     def decode_quoted_string(byte_iter):
@@ -505,7 +510,7 @@ def decode_quoted_string(byte_iter):
             raise DecodeError('Invalid quoted string: must '
                               'start with <octect 34>')
 
-        byte_iter.next()
+        next(byte_iter)
         # CHECK: should the quotation chars be pre- and appended before
         # returning *technically* we should not check for quote characters.
         return Decoder.decode_text_string(byte_iter)
@@ -528,10 +533,10 @@ def decode_token_text(byte_iter):
             byte_iter.reset_preview()
             raise DecodeError('Invalid token')
 
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         while byte > 31 and byte not in separators:
             token += chr(byte)
-            byte = byte_iter.next()
+            byte = next(byte_iter)
 
         return token
 
@@ -561,10 +566,10 @@ def decode_extension_media(byte_iter):
             raise DecodeError('Invalid Extension-media: TEXT '
                               'starts with invalid character: %d' % byte)
 
-        byte = byte_iter.next()
+        byte = next(byte_iter)
         while byte != 0x00:
             media_value += chr(byte)
-            byte = byte_iter.next()
+            byte = next(byte_iter)
 
         return media_value
 
@@ -614,7 +619,7 @@ def decode_short_length(byte_iter):
             raise DecodeError('Not a valid short-length: '
                               'should be in octet range 0-30')
 
-        return byte_iter.next()
+        return next(byte_iter)
 
     @staticmethod
     def decode_value_length(byte_iter):
@@ -646,7 +651,7 @@ def decode_value_length(byte_iter):
             byte = byte_iter.preview()
             # CHECK: this strictness MAY cause issues, but it is correct
             if byte == 31:
-                byte_iter.next()  # skip past the length-quote
+                next(byte_iter)  # skip past the length-quote
                 length_value = Decoder.decode_uint_var(byte_iter)
             else:
                 byte_iter.reset_preview()
@@ -759,7 +764,7 @@ def decode_well_known_media(byte_iter):
                               'integer value representing it')
 
         try:
-            return well_known_content_types[value]
+            return WELL_KNOWN_CONTENT_TYPES[value]
         except IndexError:
             raise DecodeError('Invalid well-known media: could not '
                               'find content type in table of assigned values')
@@ -804,12 +809,12 @@ def decode_constrained_media(byte_iter):
         """
         try:
             media_value = Decoder.decode_constrained_encoding(byte_iter)
-        except DecodeError, msg:
-            raise DecodeError('Invalid Constrained-media: %s' % msg)
+        except DecodeError as e:
+            raise DecodeError('Invalid Constrained-media: %s' % e)
 
         if isinstance(media_value, int):
             try:
-                return well_known_content_types[media_value]
+                return WELL_KNOWN_CONTENT_TYPES[media_value]
             except IndexError:
                 raise DecodeError('Invalid constrained media: could not '
                                   'find well-known content type')
@@ -843,8 +848,8 @@ def decode_content_general_form(byte_iter):
 
         # Read parameters, etc, until <value_length> is reached
         ct_field_bytes = array.array('B')
-        for i in xrange(value_length):
-            ct_field_bytes.append(byte_iter.next())
+        for i in range(value_length):
+            ct_field_bytes.append(next(byte_iter))
 
         ct_iter = PreviewIterator(ct_field_bytes)
         # Now, decode all the bytes read
@@ -898,10 +903,10 @@ def decode_typed_parameter(byte_iter):
         typed_value = ''
         try:
             typed_value = getattr(Decoder, 'decode_%s' % value_type)(byte_iter)
-        except DecodeError, msg:
-            raise DecodeError('Could not decode Typed-parameter: %s' % msg)
+        except DecodeError as e:
+            raise DecodeError('Could not decode Typed-parameter: %s' % e)
         except:
-            debug('A fatal error occurred, probably due to an '
+            logging.error('A fatal error occurred, probably due to an '
                   'unimplemented decoding operation')
             raise
 
@@ -1186,11 +1191,11 @@ def decode_no_value(byte_iter):
         :return: No-value, which is 0x00
         :rtype: int
         """
-        byte_iter, local_iter = byte_iter.next()
-        if local_iter.next() != 0x00:
+        byte_iter, local_iter = next(byte_iter)
+        if next(local_iter) != 0x00:
             raise DecodeError('Expected No-value')
 
-        byte_iter.next()
+        next(byte_iter)
         return 0x00
 
     @staticmethod
@@ -1226,7 +1231,7 @@ def decode_accept_value(byte_iter):
 
             # Check for the Q-Token (to see if there are Accept-parameters)
             if byte_iter.preview() == 128:
-                byte_iter.next()
+                next(byte_iter)
                 q_value = Decoder.decode_q_value(byte_iter)
                 try:
                     accept_extension = Decoder.decode_parameter(byte_iter)
@@ -1260,7 +1265,7 @@ def decode_pragma_value(byte_iter):
         """
         byte = byte_iter.preview()
         if byte == 0x80:  # No-cache
-            byte_iter.next()
+            next(byte_iter)
             # TODO: Not sure if this parameter name (or even usage) is correct
             name, value = 'Cache-control', 'No-cache'
         else:
@@ -1286,12 +1291,12 @@ def decode_well_known_charset(byte_iter):
         byte = byte_iter.preview()
         byte_iter.reset_preview()
         if byte == 127:
-            byte_iter.next()
+            next(byte_iter)
             decoded_charset = '*'
         else:
             charset_value = Decoder.decode_integer_value(byte_iter)
-            if charset_value in well_known_charsets:
-                decoded_charset = well_known_charsets[charset_value]
+            if charset_value in WELL_KNOWN_CHARSETS:
+                decoded_charset = WELL_KNOWN_CHARSETS[charset_value]
             else:
                 # This charset is not in our table... so just use the
                 # value (at least for now)
@@ -1319,7 +1324,7 @@ def decode_well_known_header(byte_iter):
         hdr_fields = get_header_field_names()
         # TODO: *technically* this can fail, but then we have already
         # read a byte... should fix?
-        if field_value not in xrange(len(hdr_fields)):
+        if field_value not in list(range(len(hdr_fields))):
             raise DecodeError('Invalid Header Field value: %d' % field_value)
 
         field_name = hdr_fields[field_value]
@@ -1328,15 +1333,15 @@ def decode_well_known_header(byte_iter):
         # decode_application_header also
         # Currently we decode most headers as text_strings, except
         # where we have a specific decoding algorithm implemented
-        if field_name in header_field_encodings:
-            wap_value_type = header_field_encodings[field_name]
+        if field_name in HEADER_FIELD_ENCODINGS:
+            wap_value_type = HEADER_FIELD_ENCODINGS[field_name]
             try:
                 decoded_value = getattr(Decoder,
                                        'decode_%s' % wap_value_type)(byte_iter)
-            except DecodeError, msg:
-                raise DecodeError('Could not decode Wap-value: %s' % msg)
+            except DecodeError as e:
+                raise DecodeError('Could not decode Wap-value: %s' % e)
             except:
-                debug('An error occurred, probably due to an '
+                logging.error('An error occurred, probably due to an '
                       'unimplemented decoding operation. Tried to '
                       'decode header: %s' % field_name)
                 raise
@@ -1372,6 +1377,7 @@ def decode_application_header(byte_iter):
             app_header = Decoder.decode_text_string(byte_iter)
 
         app_specific_value = Decoder.decode_text_string(byte_iter)
+
         return app_header, app_specific_value
 
     @staticmethod
@@ -1606,10 +1612,10 @@ def encode_media_type(content_type):
                  values
         :rtype: list
         """
-        if content_type in well_known_content_types:
+        if content_type in WELL_KNOWN_CONTENT_TYPES:
             # Short-integer encoding
             val = Encoder.encode_short_integer(
-                    well_known_content_types.index(content_type))
+                    WELL_KNOWN_CONTENT_TYPES.index(content_type))
         else:
             val = Encoder.encode_text_string(content_type)
 
@@ -1664,10 +1670,10 @@ def encode_parameter(parameter_name, parameter_value, version='1.2'):
                     ret = getattr(Encoder,
                                   'encode_%s' % expected_type)(parameter_value)
                     encoded_parameter.extend(ret)
-                except EncodeError, msg:
-                    raise EncodeError('Error encoding param value: %s' % msg)
+                except EncodeError as e:
+                    raise EncodeError('Error encoding param value: %s' % e)
                 except:
-                    debug('A fatal error occurred, probably due to an '
+                    logging.error('A fatal error occurred, probably due to an '
                           'unimplemented encoding operation')
                     raise
                 break
@@ -1794,15 +1800,15 @@ def encode_header(field_name, value):
         # TODO: make this flow better (see also Decoder.decode_header)
         # most header values are encoded as text_strings, except where we
         # have a specific Wap-value encoding implementation
-        if field_name in header_field_encodings:
-            wap_value_type = header_field_encodings[field_name]
+        if field_name in HEADER_FIELD_ENCODINGS:
+            wap_value_type = HEADER_FIELD_ENCODINGS[field_name]
             try:
                 ret = getattr(Encoder, 'encode_%s' % wap_value_type)(value)
                 encoded_header.extend(ret)
-            except EncodeError, msg:
-                raise EncodeError('Error encoding Wap-value: %s' % msg)
+            except EncodeError as e:
+                raise EncodeError('Error encoding Wap-value: %s' % e)
             except:
-                debug('A fatal error occurred, probably due to an '
+                logging.error('A fatal error occurred, probably due to an '
                       'unimplemented encoding operation')
                 raise
         else:
@@ -1858,8 +1864,8 @@ def encode_constrained_media(media_type):
         :rtype: list
         """
         # See if this value is in the table of well-known content types
-        if media_type in well_known_content_types:
-            value = well_known_content_types.index(media_type)
+        if media_type in WELL_KNOWN_CONTENT_TYPES:
+            value = WELL_KNOWN_CONTENT_TYPES.index(media_type)
         else:
             value = media_type
 
@@ -1920,7 +1926,7 @@ def encode_extension_media(media_value):
         :return: The encoded media type value, as a sequence of bytes
         :rtype: str
         """
-        if not isinstance(media_value, basestring):
+        if not isinstance(media_value, str):
             try:
                 media_value = str(media_value)
             except:
@@ -2045,8 +2051,8 @@ def encode_accept_value(accept_value):
             # ...now try Accept-general-form
             try:
                 encoded_media_range = Encoder.encode_media_type(accept_value)
-            except EncodeError, msg:
-                raise EncodeError('Cannot encode Accept-value: %s' % msg)
+            except EncodeError as e:
+                raise EncodeError('Cannot encode Accept-value: %s' % e)
 
             value_length = Encoder.encode_value_length(len(encoded_media_range))
             encoded_accept_value = value_length