"""
builtin max() being the converse of builtin min(), only requiring __lt__ operator
"""
from operator import attrgetter

if True:
    def max(iterable):
        """
        partial reimplementation of builtin max() using __lt__ for test purposes.
        """
        result = None
        it = iter(iterable)
        for i in it:
            if result is None or not (result < i):
                result = i
        return result


class Pair():
    def __init__(self, m0, m1):
        self.m0, self.m1 = m0, m1

    def __lt__(self, other):
        """weak comparison"""
        return self.m0 < other.m0
    def __eq__(self, other):
        """weak comparison"""
        return self.m0 == other.m0

    def __le__(self, other): raise NotImplementedError
    def __ne__(self, other): raise NotImplementedError
    def __gt__(self, other): raise NotImplementedError
    def __ge__(self, other): raise NotImplementedError

    def __repr__(self):
        return 'Pair({}, {})'.format(repr(self.m0), repr(self.m1))

    @property
    def total(self):
        """
        key for total ordering, eg.:

        sorted(iterable, key=attrgetter('total'))
        min(iterable, key=attrgetter('total'))
        max(iterable, key=attrgetter('total'))
        """
        return (self.m0, self.m1)

    @property
    def weak(self):
        """
        key for weak ordering, eg.:

        sorted(iterable, key=attrgetter('weak'))
        min(iterable, key=attrgetter('weak'))
        max(iterable, key=attrgetter('total'))
        """
        return self.m0


def test():
    a = Pair(0, 1)
    b = Pair(0, 2)

    # weak comparison
    assert a == b
    assert b == a
    assert a is not b
    assert repr([a, b]) == repr(sorted([a, b]))
    assert repr([a, b]) == repr(sorted([a, b], reverse=True))
    assert repr([b, a]) == repr(sorted([b, a]))
    assert repr([b, a]) == repr(sorted([b, a], reverse=True))

    assert min([a, b]) is a
    assert max([a, b]) is b

    assert min([b, a]) is b
    assert max([b, a]) is a

    assert min([a, b]) is max([b, a])
    assert min([a, b]) is not min([b, a])
    assert max([a, b]) is min([b, a])
    assert max([a, b]) is not max([b, a])

    c = Pair(1, 3)
    d = Pair(1, 4)

    r0 = [a, b]
    r1 = [c, d]
    assert len(set(map(id, r0+r1))) == len(r0+r1)
    assert repr(r0+r1) == repr(sorted(r0+r1))
    assert repr(r1+r0) == repr(sorted(r0+r1, reverse=True))

    # using key
    assert repr(sorted([a, b], key=attrgetter('weak'))) == repr([a, b])
    assert repr(sorted([b, a], key=attrgetter('weak'))) == repr([b, a])
    assert repr(sorted([a, b], key=attrgetter('total'))) == repr([a, b])
    assert repr(sorted([b, a], key=attrgetter('total'))) == repr([a, b])

    assert min([a, b], key=attrgetter('weak')) is a
    assert min([b, a], key=attrgetter('weak')) is b
    assert min([a, b], key=attrgetter('total')) is a
    assert min([b, a], key=attrgetter('total')) is a

    # max() not implemented correctly
    if False:
        assert max([a, b], key=attrgetter('weak')) is b
        assert max([b, a], key=attrgetter('weak')) is a
        assert max([a, b], key=attrgetter('total')) is b
        assert max([b, a], key=attrgetter('total')) is b

test()