Make an object immutable without namedtuple.

immutable_metaclass.py

"""
# 概要

    immutable なオブジェクトを生成するメタクラス Immutable

    属性参照は速いけど
    namedtuple:      0.07781907100070384
    自作したクラス:  0.04243788100029633

    インスタンス化は遅い
    namedtuple:      0.5539945139989868
    自作したクラス:  0.9362985030002164

    インスタンス化が圧倒的に namedtuple よりも遅かったので、
    光の速さでお蔵入りになりました。

    1 回生成したオブジェクトにつき
    20 回以上属性参照をやるようなケースでは
    メタクラスで作った Immutable の方が速くはなります。

    しかし、１つのオブジェクトに対して 20 回以上も
    属性参照するようなことってないと思うので。


# 実装方針

    属性参照の速くなる __slots__ と メタクラスを組み合わせて、
    属性参照の速い immutable なクラスを作ると言うことしています。

    1) まず mutable なクラスからインスタンス化して、
    2) 次に immutable なクラスにキャストする

    ということをしています。



# 以下のコード

    大きく以下の３つのパートからなっています。

    1. 定義: メタクラス Immutable
    2. 動作確認: 簡単に動くかどうか
    3. 計測計測: 属性参照とインスタンス化


    スクリプトは、そのまま実行できます。
    計測した時間を出力します。

    $ python immutable_metaclass.py
    ### 時間計測
    # 属性参照
    普通のクラス                             0.07876141
    __slots__ を使ったクラス                 0.07551351699999999
    namedtuple を使ったクラス                0.10180483000000001
    Immutable メタクラスを使ったクラス       0.08366162300000002
    # インスタンス化
    普通のクラス                             0.48623005900000005
    __slots__ を使ったクラス                 0.41285596299999994
    namedtuple を使ったクラス                0.5147371169999999
    Immutable メタクラスを使ったクラス       0.9039751979999999
    $
"""
import collections
import os
import timeit


#
# 1. 定義
#
class Immutable(type):
    """Meta class to make object immutable."""

    def __init__(self, name, bases, name_space):
        # 1. Instantiate an object as mutable,
        #    then cast the object to immutable.
        if '__new__' not in name_space:
            self.__new__ = type(self).new

        # 2. Make class immutable.
        self.__setattr__ = self.setattr

        # 3. Define mutable class for each immutable class,
        #    because of the __slots__'s limitation.
        #    > __class__ assignment works
        #    > only if both classes have the same __slots__.
        #    > [3.3.2.4.1. Notes on using __slots__](http://bit.ly/2txVQ7i)
        exec(self.mutable_class_template())
        self.MutableClass = eval('MutableClass')

        #
        # １度文字列にした方が２倍近く速くなる。
        #
        # # 3-1) faster 1.0176027979996434
        # exec(cls.mutable_class_template())
        # cls.MutableClass = eval('MutableClass')
        #
        # # 3-2) slower 1.7439573310002743
        # class MutableClass(object):
        #     __slots__ = cls.__slots__
        #     def __init__(self, *args):
        #         for slot, arg in zip(cls.__slots__, args):
        #             setattr(self, slot, arg)
        # cls.MutableClass = MutableClass

    def new(self, *args):
        # 1. Instantiate the object as mutable object.
        instance = self.MutableClass(*args)
        # 2. Cast the object's class to immutable.
        instance.__class__ = self
        return instance

    def mutable_class_template(self):
        return os.linesep.join((
            'class MutableClass(object):',
            '    __slots__ = ' + repr(self.__slots__),
            '    def __init__(self, ' + ', '.join(self.__slots__) + '):',
            '',
        )) + os.linesep.join(
            '        self.' + slot + ' = ' + slot for slot in self.__slots__
        )

    @staticmethod
    def setattr(instance, key, value):
        raise TypeError

#
# 2. 動作確認
#    矩形を表現する Region を作成て
#    とりあえず動くか確認する。
#


# 1. Assing Immutable to metaclass.
class Region(metaclass=Immutable):
    # 2. Set attribute names in __slots__.
    __slots__ = (
        'x1', 'y1', 'x2', 'y2',
        'is_rectangle', 'is_line', 'is_dot')

    # 3. If you override __new__
    def __new__(cls, x1, y1, x2, y2):
        width_0 = (x1 - x2 == 0)
        height_0 = (y1 - y2 == 0)
        is_rectangle = (not width_0 and not height_0)  # 0 0
        is_line = (width_0 != height_0)  # 0 1 or 1 0; xor
        is_dot = (width_0 and height_0)  # 1 1
        args = (x1, y1, x2, y2, is_rectangle, is_line, is_dot)

        # 4. call "cls.new(*args) method"
        #    to instantiate immutable object and return it.
        self = cls.new(*args)
        return self

    def __eq__(self, other):
        return all((self.x1 == other.x1,
                    self.y1 == other.y1,
                    self.x2 == other.x2,
                    self.y2 == other.y2))

    def __repr__(self):
        x1, y1, x2, y2 = self.x1, self.y2, self.x2, self.y2
        return type(self).__name__ + f'({x1}, {y1}, {x2}, {y2})'


# 1. We can use __new__ inststead of __init__.
#    we cannot use __init__ beacause an instance of Region is immutable.
region = Region(0, 0, 1, 1)

# 2. An assignment raises an error.
try:
    region.x1 = 100
except TypeError:
    pass
else:
    raise

# 3. We can use methods properly.
region1 = Region(0, 0, 1, 1)
assert str(region1) == 'Region(0, 1, 1, 1)'
assert region1.is_rectangle
assert not region1.is_line
assert not region1.is_dot

region2 = Region(0, 0, 0, 0)
assert str(region2) == 'Region(0, 0, 0, 0)'
assert not region2.is_rectangle
assert not region2.is_line
assert region2.is_dot

assert region1 != region2

# 4. instantiation
# type -> Immutable -> Region -> region
assert type(region) is Region
assert type(Region) is Immutable
assert type(Immutable) is type
assert type(type) is type

# 5. inheritance
assert Region.__bases__ == (object,)
assert Region.__bases__ != (Immutable,)


#
# 3. 時間計測
#

# 1. 普通のクラス
class Point1(object):
    def __init__(self, x, y):
        self.x, self.y = x, y


point1 = Point1(1, 1)


# 2. __slots__ を使ったクラス
class Point2(object):
    __slots__ = ('x', 'y')

    def __init__(self, x, y):
        self.x, self.y = x, y


point2 = Point2(2, 2)


# 3. collections.namedtuple から生成したクラス
Point3 = collections.namedtuple('Point1', ('x', 'y'))
point3 = Point3(3, 3)


# 4. Immutable メタクラスから生成したクラス
class Point4(metaclass=Immutable):
    __slots__ = ('x', 'y')


point4 = Point4(4, 4)


print('### 時間計測')


def print_result(label, stmt):
    print(ljust(label, 40), str(measure(stmt)))


def measure(stmt):
    return timeit.timeit(stmt, number=1_000_000, globals=globals())


def ljust(str_, len_):
    count = 0
    for char in str_:
        if ord(char) <= 255:
            count += 1
        else:
            count += 2
    return str_ + (len_ - count) * ' '


print('# 属性参照')
print_result('普通のクラス', 'point1.x')
print_result('__slots__ を使ったクラス', 'point2.x')
print_result('namedtuple を使ったクラス', 'point3.x')
print_result('Immutable メタクラスを使ったクラス', 'point4.x')

print('# インスタンス化')
print_result('普通のクラス', 'Point1(0, 0)')
print_result('__slots__ を使ったクラス', 'Point2(0, 0)')
print_result('namedtuple を使ったクラス', 'Point3(0, 0)')
print_result('Immutable メタクラスを使ったクラス', 'Point4(0, 0)')