class TaggedJSONSerializer(object):
    """A customized JSON serializer that supports a few extra types that
    we take for granted when serializing (tuples, markup objects, datetime).
    """

    def dumps(self, value):
        return json.dumps(self._tag(value), separators=(',', ':'))

    def loads(self, value):
        def object_hook(obj):
            if len(obj) != 1:
                return obj
            the_key, the_value = next(iteritems(obj))
            rv = self._untag(the_key, the_value)
            return obj if rv is None else rv
        return json.loads(value, object_hook=object_hook)

    def _untag(self, key, value):
        if key == ' t':
            return tuple(value)
        elif key == ' u':
            return uuid.UUID(value)
        elif key == ' b':
            return b64decode(value)
        elif key == ' m':
            return Markup(value)
        elif key == ' d':
            return parse_date(value)
        return None

    def _tag(self, value):
        if isinstance(value, tuple):
            return {' t': [self._tag(x) for x in value]}
        elif isinstance(value, uuid.UUID):
            return {' u': value.hex}
        elif isinstance(value, bytes):
            return {' b': b64encode(value).decode('ascii')}
        elif callable(getattr(value, '__html__', None)):
            return {' m': text_type(value.__html__())}
        elif isinstance(value, list):
            return [self._tag(x) for x in value]
        elif isinstance(value, datetime):
            return {' d': http_date(value)}
        elif isinstance(value, dict):
            return dict((k, self._tag(v)) for k, v in iteritems(value))
        elif isinstance(value, str):
            try:
                return text_type(value)
            except UnicodeError:
                from flask.debughelpers import UnexpectedUnicodeError
                raise UnexpectedUnicodeError(u'A byte string with '
                    u'non-ASCII data was passed to the session system '
                    u'which can only store unicode strings.  Consider '
                    u'base64 encoding your string (String was %r)' % value)
        return value

conversions = {
    't': {'check': lambda value: isinstance(value, tuple),
          'tag': lambda value: [self._tag(x) for x in value]},
          'untag': lambda value: tuple(value)},
    ...
}

def __init__(self):
    super(TaggedJSONSerializer, self).__init__()
    self.conversions.append(...)

import cProfile
from datetime import datetime
import uuid

import flask
from flask.sessions import TaggedJSONSerializer


def test_session_performance():
    now = datetime.utcnow().replace(microsecond=0)
    the_uuid = uuid.uuid4()

    data = [
        (1, 2, 3),
        the_uuid,
        b'\xff',
        flask.Markup('Hello!'),
        now,
    ]

    cycles = 10000

    session = TaggedJSONSerializer()

    for d in data * cycles:
        dumped = session.dumps(d)
        session.loads(dumped)


if __name__ == '__main__':
    cProfile.run('test_session_performance()')

class TagOrderedDict(JSONTag):
    key = ' od'

    def check(self, value):
        return isinstance(value, OrderedDict)

    def to_json(self, value):
        return [(self.serializer.tag(k), self.serializer.tag(v)) for k, v in value]

    def to_python(self, value):
        return OrderedDict((self.serializer.untag(k), self.serializer.untag(v)) for k, v in value)

app.session_interface.serializer.register(TagOrderedDict)