1

"""

     2

    Miscellaneous utilities

     3

"""

     4

     5

import functools

     6

     7

class LazyProperty (object) :

     8

    """

     9

        Lazy-loaded cached properties.

    10

    11

        This functions by overriding the class's property attribute with the actual value attribute in the instance's

    12

        dict, causing all future attribute lookups to return that directly.

    13

    14

        >>> class Foo (object) :

    15

        ...     counter = 0

    16

        ...     @lazy_load

    17

        ...     def foo (self) :

    18

        ...             self.counter += 1

    19

        ...             return self.counter

    20

        ... 

    21

        >>> foo = Foo(); foo.foo, foo.foo, foo.counter

    22

        (1, 1, 1)

    23

    24

    """

    25

    26

    def __init__ (self, func) :

    27

        """

    28

            Initialize with no value

    29

        """

    30

    31

        # the getter function

    32

        self.func = func

    33

    34

        # the attribute name

    35

        self.name = func.__name__

    36

    37

    def run (self, obj) :

    38

        """

    39

            Run the background func and return the to-be-cached value.

    40

    41

            `obj` is the object instance

    42

        """

    43

    44

        return self.func(obj)

    45

    46

    def store (self, obj, value) :

    47

        """

    48

            Store the cached value, overring ourself

    49

        """

    50

    51

#        print "[%x] %r.__dict__[%r] = %r" % (id(obj), obj, self.name, value)

    52

    53

        obj.__dict__[self.name] = value

    54

    55

    def __get__ (self, obj, owner) :

    56

        """

    57

            Generate the value, store it as the attribute and return it.

    58

        """

    59

    60

        # compute value

    61

        value = self.run(obj)

    62

    63

        # store it

    64

        self.store(obj, value)

    65

    66

        # return it

    67

        return value

    68

    69

class LazyIteratorProperty (LazyProperty) :

    70

    """

    71

        A lazy-loaded property that automatically converts an iterator/genexp into a non-mutable tuple.

    72

    """

    73

    74

    def run (self, obj) :

    75

        return tuple(self.func(obj))

    76

    77

lazy_load = LazyProperty

    78

lazy_load_iter = LazyIteratorProperty

    79

   100

# testing

   101

if __name__ == '__main__' :

   102

    import doctest

   103

   104

    doctest.testmod()

   105