Metadata-Version: 1.0
Name: Decorum
Version: 0.4
Summary: Tool for writing simple decorators
Home-page: UNKNOWN
Author: Zach Kelling
Author-email: zeekayy@gmail.com
License: LICENSE
Description: =======
        Decorum
        =======
        
        Decorum is a simple tool which aims to make it easier to write flexible
        and simple decorators. It can also act similarly to `functools.wraps`.
        
        Typical usage looks like this:
        
            from decorum import decorator
            
            @decorator
            class my_decorator:
                def wraps(self, f):
                    print "I'm returning the function! You can keep it!" 
                    return f
        
        Decorum makes lets you write decorators in a unified way. Your decorator can be
        used with or without arguments, called or not, and it will work the same way.
        
            @my_decorator
            def foo(x): print x
            
        Is identical to:
        
            @my_decorator()
            def foo(x): print x
        
        Writing decorators
        ==================
        
        Decorum provides two easy ways to write your own decorators. You can use `decorum.decorator` to
        decorate decorator classes, or you can directly subclass decorum.Decorum. There are only
        two methods to be aware of when writing your own decorators. Define a `wraps` method to handle
        the actual decoration and return the decorated function, and optionally define an `init` method
        to handle any arguments you want to accept, and handle basic setup (it's called before decoration
        by `__init__`, you can use it in a similar fashion to a real `__init__` method). By default
        decorum will try to keep assign certain attributes to the wrapped function for you, namely `__doc__`
        and `__name__`. You can set `keep_attrs` to None to turn this off, or provide it with a list of
        attributes you want applied to the returned decorated function.
        
        Here is a slightly fancier example:
        
        from decorum import decorator
        
        @decorator
        class fancy:
            def init(self, arg=None):
                self.arg = arg
        
            def wraps(self, f):
                if self.arg:
                    def newf():
                        print self.arg
                else:
                    def newf():
                        print 'wut'
                return newf
        
        @fancy
        def foo():
            pass
        foo()
        
        @fancy('woof')
        def foo():
            pass
        foo()
        
        # prints
        wut
        woof
        
Platform: UNKNOWN
