def better_repr(self, obj, context=None, html=True, level=1, full=False):
        """Repr with html decorations or indentation"""
        abbreviate = (lambda x, level, **kw: x) if full else cut_if_too_long

        def get_too_long_repr(ie):
            r = '[%d more…]' % ie.size
            if html:
                self.obj_cache[id(obj)] = obj
                return '<a href="dump/%d" class="inspect">%s</a>' % (
                    id(obj), r
                )
            return r

        if isinstance(obj, dict):
            if isinstance(obj, OrderedDict):
                dict_sorted = lambda it, f: it
            else:
                dict_sorted = sorted

            dict_repr = '  ' * (level - 1)
            if type(obj) != dict:
                dict_repr = type(obj).__name__ + '({'
                closer = '})'
            else:
                dict_repr = '{'
                closer = '}'
            if len(obj) > 2:
                dict_repr += '\n' + '  ' * level
                if html:
                    dict_repr += '''<table class="
                        mdl-data-table mdl-js-data-table
                        mdl-data-table--selectable mdl-shadow--2dp">'''
                    dict_repr += ''.join([
                        (
                            '<tr><td class="key">' + self.safe_repr(key) + ':'
                            + '</td>'
                            '<td class="val '
                            + 'mdl-data-table__cell--non-numeric">'
                            + self.safe_better_repr(
                                val, context, html, level, full
                            ) + '</td></tr>'
                        ) if not isinstance(key, IterableEllipsis) else (
                            '<tr><td colspan="2" class="ellipse">' +
                            get_too_long_repr(key) + '</td></tr>'
                        )
                        for key, val in abbreviate(
                            dict_sorted(obj.items(), key=lambda x: x[0]),
                            level,
                            tuple_=True
                        )
                    ])
                    dict_repr += '</table>'
                else:
                    dict_repr += ('\n' + '  ' * level).join([
                        self.safe_repr(key) + ': ' +
                        self.safe_better_repr(val, context, html, level, full)
                        if not isinstance(key, IterableEllipsis) else
                        get_too_long_repr(key)
                        for key, val in abbreviate(
                            dict_sorted(obj.items(), key=lambda x: x[0]),
                            level,
                            tuple_=True
                        )
                    ])
                closer = '\n' + '  ' * (level - 1) + closer
            else:
                dict_repr += ', '.join([
                    self.safe_repr(key) + ': ' +
                    self.safe_better_repr(val, context, html, level, full)
                    for key, val in
                    dict_sorted(obj.items(), key=lambda x: x[0])
                ])
            dict_repr += closer
            return dict_repr

        if any([isinstance(obj, list), isinstance(obj, set),
                isinstance(obj, tuple)]):
            iter_repr = '  ' * (level - 1)
            if type(obj) == list:
                iter_repr = '['
                closer = ']'
            elif type(obj) == set:
                iter_repr = '{'
                closer = '}'
            elif type(obj) == tuple:
                iter_repr = '('
                closer = ')'
            else:
                iter_repr = escape(obj.__class__.__name__) + '(['
                closer = '])'

            splitter = ', '
            if len(obj) > 2 and html:
                splitter += '\n' + '  ' * level
                iter_repr += '\n' + '  ' * level
                closer = '\n' + '  ' * (level - 1) + closer

            iter_repr += splitter.join([
                self.safe_better_repr(val, context, html, level, full)
                if not isinstance(val, IterableEllipsis) else
                get_too_long_repr(val) for val in abbreviate(obj, level)
            ])

            iter_repr += closer
            return iter_repr