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

    80

def unload (obj, *attrs) :

    81

    """

    82

        Un-load the named attributes from the given object.

    83

    """

    84

    85

    for attr in attrs :

    86

        if attr in obj.__dict__ :

    87

            # this will drop refcounts and free resources, so it may take some execution time

    88

            del obj.__dict__[attr]

    89

    90

def first (iterable) :

    91

    """

    92

        Returns the first item from the iterable that evaluates to True, otherwise None.

    93

    94

        >>> first((0, 1))

    95

        1

    96

        >>> first("abc")

    97

        'a'

    98

        >>> first(('', list(), (), False))

    99

    """

   100

   101

    for item in iterable :

   102

        if item :

   103

            return item

   104

   105

    else :

   106

        return None

   107

   108

   109

# testing

   110

if __name__ == '__main__' :

   111

    import doctest

   112

   113

    doctest.testmod()

   114