Metadata-Version: 1.0
Name: nmevent
Version: 0.1.1
Summary: A simple C#-like implementation of the Observer design pattern.
Home-page: http://pypi.python.org/pypi/nmevent
Author: Jan Milík
Author-email: milikjan@fit.cvut.cz
License: Lesser General Public License v3
Description: nmevent - C#-like implementation of the Observer pattern
        
        This is a Python module :mod:`nmevent`, simple C#-like implementation of
        the Observer pattern (http://en.wikipedia.org/wiki/Observer_pattern).
        It's main purpose and goal is to allow developers to use events
        with C#-like syntax in their Python classes.
        
        Usage example
        =============
        
        The most straightfoward way to use :mod:`nmevent` is this:
        
        >>> import nmevent
        >>> class ExampleClass(object):
        ...    def __init__(self):
        ...       self.event = nmevent.Event()
        ...
        ...    def _do_something(self):
        ...       self.event(self)
        ...
        >>> example = ExampleClass()
        >>> example.event += handler
        
        It should be noted, that event doesn't necessarily need to
        be an object attribute. :class:`Event` instance is basically
        just a callable object that works as a sort of "dispatch
        demultiplexer".
        
        This usage, however, isn't very C#-like. In C#, events are declared
        in class scope and that's where the :class:`EventSlot` comes in.
        Once you've created event using :class:`EventSlot`, you can
        use the same way you use :class:`Event`, only you don't need
        to specify the sender when raising the event. That's because
        the event is already bound to the instance of the class it has
        been declared in.
        
        >>> from nmevent import EventSlot
        >>> class ExampleClass(object):
        ...    event = EventSlot()
        ...
        ...    def _do_something(self):
        ...       self.event()
        ...
        >>> def handler(sender, **keywords):
        ...    pass
        ...
        >>> example = ExampleClass()
        >>> example.event += handler
        
        Perhaps this looks even more straightfoward than instantiating
        :class:`Event` in object's constructor, but there's actually
        lot more going on under hood this time.
        
        >>> import nmevent
        >>> @nmevent.with_events
        ... class ExampleClass(object):
        ...    @nmevent.nmproperty
        ...    def x(self):
        ...       return self._x
        ...
        >>> example = ExampleClass()
        >>> example.x_changed += handler
        >>> example.x = 10 # handler gets called
        
        License
        =======
        
        Copyright (c) 2010, Jan Milík.
        
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU Lesser General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.
        
        This program is distributed in the hope the it will be useful,
        but WITHOUT ANY WARRANTY; without event the implied warranty of
        MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU Lesser General Public License for more details.
        
        You should have received a copy of the GNU Lesser General Public License
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
        
Keywords: library event observer pattern
Platform: UNKNOWN
Classifier: Development Status :: 1 - Planning
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 2.6
