def from_urlsafe_base64(cls, value):
        #FIXME: Find out why we need to do this.
        if isinstance(value, six.text_type):
            value = value.encode('utf8')
        try:
            return (urlsafe_b64decode(_bytes_join(value)),)

        except TypeError as e:
            logger.exception(e)

            if len(value) > 100:
                raise ValidationError(value)
            else:
                raise ValidationError(value[:100] + "(...)")

    def create_in_document(self, ctx, charset=None):
        """Uses the iterable of string fragments in ``ctx.in_string`` to set
        ``ctx.in_document``."""

        string = _bytes_join(ctx.in_string)
        try:
            try:
                ctx.in_document = etree.fromstring(string,
                                        parser=XMLParser(**self.parser_kwargs))

            except ValueError:
                logger.debug('ValueError: Deserializing from unicode strings '
                             'with encoding declaration is not supported by '
                             'lxml.')
                ctx.in_document = etree.fromstring(string.decode(charset),
                                                                    self.parser)
        except XMLSyntaxError, e:
            logger_invalid.error(string)
            raise Fault('Client.XMLSyntaxError', str(e))

    def create_in_document(self, ctx, charset=None):
        """Uses the iterable of string fragments in ``ctx.in_string`` to set
        ``ctx.in_document``."""

        string = _bytes_join(ctx.in_string)
        try:
            try:
                ctx.in_document = etree.fromstring(string, self.parser)

            except XMLSyntaxError, e:
                logger.error(string)
                raise Fault("Client.XMLSyntaxError", str(e))

        except ValueError:
            try:
                ctx.in_document = etree.fromstring(string.decode(charset), self.parser)
            except XMLSyntaxError, e:
                logger.error(string)
                raise Fault("Client.XMLSyntaxError", str(e))

 def from_base64(cls, value):
     try:
         return [b64decode(_bytes_join(value))]
     except TypeError as e:
         raise ValidationError(value)

 def to_base64(cls, value):
     return b64encode(_bytes_join(value))

 def from_hex(cls, value):
     return [unhexlify(_bytes_join(value))]

 def to_hex(cls, value):
     return hexlify(_bytes_join(value))

 def from_urlsafe_base64(cls, value):
     #FIXME: Find out why we need to do this.
     if isinstance(value, unicode):
         value = value.encode('utf8')
     return [urlsafe_b64decode(_bytes_join(value))]

 def to_urlsafe_base64(cls, value):
     return urlsafe_b64encode(_bytes_join(value))

 def from_urlsafe_base64(cls, value):
     return [urlsafe_b64decode(_bytes_join(value))]

 def from_base64(cls, value):
     return [base64.b64decode(_bytes_join(value))]

 def set_response(self, retval, response):
     retval.content = _bytes_join(response, b"")