Programming Forums > Script Programming > Python

Sane · Feb 23rd, 2006, 5:31 PM

After noting the power of Arevos' cache function, I wanted to see how decorators worked.

I <3 Decorators, very handy for applying a common transformation easily to your functions. It's a useful thing to learn, and very easy to understand once you see its logic.

Here's one I made for my website

(Toggle Plain Text)

def serveError(func_name, func_code, func_error):
    return """<html>
<font face="courier new">
Server has encountered an error.<br />
<br />
      Error <i>%s</i><br />
In Function <b><i>%s</i></b><br />
         At <i>%s</i><br />
<br />
</font>
</html>"""%(func_error, func_name, func_code)



from sys import exc_info
def debug_wrapper(func):
    """If an error happens inside the function
    it will be caught and appropriately acted upon."""
    def new_func(*args):
        try:
            return func(*args)
        except:
            return serveError(func.func_name, func.func_code, exc_info()[0])
    return new_func




@debug_wrapper
def foo():
    raise KeyError


print foo()

Any function I put "@debug_wrapper" before, will now display something other then a CherryPy error.

Handy. Got any interesting ones?

Edit:

Here's Arevos' cache function:

(Toggle Plain Text)

def cached(func):
    """Creates a cached function.
    Cached function cannot handle keyword or mutable arguments."""
    store = {}
    def cached_func(*args):
        if not store.has_key(args):
            store[args] = func(*args)
        return store[args]
    return cached_func

@cached
def foo(x):
    return len(x)

print foo("Hello World!") # calculates and prints 12
print foo("Hello World!") # prints 12 without calculating

Jessehk · Feb 23rd, 2006, 5:35 PM

what does <3 mean? :p

OpenLoop · Feb 23rd, 2006, 5:42 PM

<3 = Love, notice the heart shape. That's one interpretation.

The Dark · Feb 23rd, 2006, 5:57 PM

<3 = dropped my double scoop icecream cone

Arevos · Feb 23rd, 2006, 5:59 PM

Multimethods spring to mind as one good use for decorators, and since a while ago we were talking about thread, here's a decorator that mimics the synchronized keyword in Java. I also find decorators quite useful for event based programming:

(Toggle Plain Text)

event_registry = {}

def listen_for(event_class):
    if event_registry.has_key(event_class):
        event_registry[event_class].append(func)
    else:
        event_registry[event_class] = [func]

    def decorator(func):
        def decorated(event):
            return func(event)
        return decorated
    return decorator

def send_event(event):
    if event_registry.has_key(event.__class__):
        for func in event_registry[event.__class__]:
            func(event)

class PokeEvent: pass

@listen_for(PokeEvent)
def poked(event):
    print "Ouch!"

send_event(PokeEvent())

Although I'd probably opt for an off-the-shelf dispatch system, rather than trying to reinvent the wheel, if I were programming a real application.

Sane · Feb 23rd, 2006, 7:01 PM

Wow, that's seriously confusing... >.>

Arevos · Feb 24th, 2006, 5:51 AM

It may look it, but the principle is really rather simple - honest!

Event based programming works by getting functions to "listen out" for events. It's common technique in GUIs and computer games. For example, if I clicked a button, a "ButtonClick" event might be sent out:

(Toggle Plain Text)

class Button:
    def click(self):
        send_event( ButtonClick(self) )

And I could have a number of functions listening for this ButtonClick:

(Toggle Plain Text)

@listen_for(ButtonClick):
def button_clicked(event):
    print "The button you pressed was called: " + event.button_name

The code itself is also simpler than it looks. All the listen_for decorator does, is to map an event class to one or more functions:

(Toggle Plain Text)

event_registry = { ButtonClick : [button_clicked] }

This tells the send_event function that when a ButtonClick event is sent, it should call the button_clicked function.

Dietrich · Feb 24th, 2006, 11:16 AM

Arevos,
could you please send a working example?

Cerulean · Feb 24th, 2006, 12:11 PM

That's pretty cool. I'm fonder of the maintenance free signal/slot implementation, however. Python cookbook at its best!

Arevos · Feb 24th, 2006, 2:16 PM

I prefer the dispatch method myself. It seems to me to be a more abstracted model, cleanly separating the concept of event handling and the events themselves.

As for a working example, I'll provide a simple one for demonstration purposes, though I'd advise using a library like pydispatcher instead.

(Toggle Plain Text)

event_registry = {}

def connect(event_class, function):
	"""Maps an event class to a function. Multiple functions can be mapped
	to the same event class."""
	try:
		event_registry[event_class].append(function)
	except KeyError:
		event_registry[event_class] = [function]

def listen_for(event_class):
	"""Decorator for the 'connect' function"""
	def decorator(function):
		connect(event_class, function)
		return function
	return decorator

def send_event(event):
	"""Send an event to all functions that are listening for events of
	that type."""
	try:
		functions = event_registry[event.__class__]
	except KeyError:
		return
	
	for function in functions:
		function(event)
		
		
def main():
	"""Demonstration of how these events are used."""	
	class PokeEvent:
		"""A generic event"""
		def __init__(self, name):
			self.name = name
	
	@listen_for(PokeEvent)
	def poked(event):
		"""A function to be activated by an event"""
		print "Ouch! I was poked by %s" % event.name
	
	# Send a new PokeEvent. Should be caught by the "poked" function
	send_event(PokeEvent("Fred"))

if __name__ == '__main__':
	main()

This is similar to the code I posted before, but better laid out, commented, and without the errors

Feb 23rd, 2006, 5:31 PM	#1
Sane Programming Guru Join Date: Apr 2005 Location: Waterloo, Ontario Posts: 1,888 Rep Power: 5	<3 Decorators After noting the power of Arevos' cache function, I wanted to see how decorators worked. I <3 Decorators, very handy for applying a common transformation easily to your functions. It's a useful thing to learn, and very easy to understand once you see its logic. Here's one I made for my website (Toggle Plain Text) def serveError(func_name, func_code, func_error): return """<html> <font face="courier new"> Server has encountered an error.<br /> <br /> Error <i>%s</i><br /> In Function <b><i>%s</i></b><br /> At <i>%s</i><br /> <br /> </font> </html>"""%(func_error, func_name, func_code) from sys import exc_info def debug_wrapper(func): """If an error happens inside the function it will be caught and appropriately acted upon.""" def new_func(args): try: return func(args) except: return serveError(func.func_name, func.func_code, exc_info()[0]) return new_func @debug_wrapper def foo(): raise KeyError print foo() def serveError(func_name, func_code, func_error): return """<html> <font face="courier new"> Server has encountered an error.<br /> <br /> Error <i>%s</i><br /> In Function <b><i>%s</i></b><br /> At <i>%s</i><br /> <br /> </font> </html>"""%(func_error, func_name, func_code) from sys import exc_info def debug_wrapper(func): """If an error happens inside the function it will be caught and appropriately acted upon.""" def new_func(args): try: return func(args) except: return serveError(func.func_name, func.func_code, exc_info()[0]) return new_func @debug_wrapper def foo(): raise KeyError print foo() Any function I put "@debug_wrapper" before, will now display something other then a CherryPy error. Handy. Got any interesting ones? Edit: Here's Arevos' cache function: (Toggle Plain Text) def cached(func): """Creates a cached function. Cached function cannot handle keyword or mutable arguments.""" store = {} def cached_func(args): if not store.has_key(args): store[args] = func(args) return store[args] return cached_func @cached def foo(x): return len(x) print foo("Hello World!") # calculates and prints 12 print foo("Hello World!") # prints 12 without calculating def cached(func): """Creates a cached function. Cached function cannot handle keyword or mutable arguments.""" store = {} def cached_func(args): if not store.has_key(args): store[args] = func(args) return store[args] return cached_func @cached def foo(x): return len(x) print foo("Hello World!") # calculates and prints 12 print foo("Hello World!") # prints 12 without calculating

Feb 23rd, 2006, 5:35 PM	#2
Jessehk The Oblivious One Join Date: May 2005 Location: Ontario, Canada Posts: 644 Rep Power: 4	what does <3 mean? :p __________________ Dr. Zoidberg: [ecstatic] I'm going to a movie... with FRIENDS!

Feb 23rd, 2006, 5:59 PM	#5
Arevos Programming Guru Join Date: Aug 2005 Location: England Posts: 1,499 Rep Power: 5	Multimethods spring to mind as one good use for decorators, and since a while ago we were talking about thread, here's a decorator that mimics the synchronized keyword in Java. I also find decorators quite useful for event based programming: (Toggle Plain Text) event_registry = {} def listen_for(event_class): if event_registry.has_key(event_class): event_registry[event_class].append(func) else: event_registry[event_class] = [func] def decorator(func): def decorated(event): return func(event) return decorated return decorator def send_event(event): if event_registry.has_key(event.__class__): for func in event_registry[event.__class__]: func(event) class PokeEvent: pass @listen_for(PokeEvent) def poked(event): print "Ouch!" send_event(PokeEvent()) event_registry = {} def listen_for(event_class): if event_registry.has_key(event_class): event_registry[event_class].append(func) else: event_registry[event_class] = [func] def decorator(func): def decorated(event): return func(event) return decorated return decorator def send_event(event): if event_registry.has_key(event.__class__): for func in event_registry[event.__class__]: func(event) class PokeEvent: pass @listen_for(PokeEvent) def poked(event): print "Ouch!" send_event(PokeEvent()) Although I'd probably opt for an off-the-shelf dispatch system, rather than trying to reinvent the wheel, if I were programming a real application.

Feb 24th, 2006, 5:51 AM	#7
Arevos Programming Guru Join Date: Aug 2005 Location: England Posts: 1,499 Rep Power: 5	It may look it, but the principle is really rather simple - honest! Event based programming works by getting functions to "listen out" for events. It's common technique in GUIs and computer games. For example, if I clicked a button, a "ButtonClick" event might be sent out: (Toggle Plain Text) class Button: def click(self): send_event( ButtonClick(self) ) class Button: def click(self): send_event( ButtonClick(self) ) And I could have a number of functions listening for this ButtonClick: (Toggle Plain Text) @listen_for(ButtonClick): def button_clicked(event): print "The button you pressed was called: " + event.button_name @listen_for(ButtonClick): def button_clicked(event): print "The button you pressed was called: " + event.button_name The code itself is also simpler than it looks. All the listen_for decorator does, is to map an event class to one or more functions: (Toggle Plain Text) event_registry = { ButtonClick : [button_clicked] } event_registry = { ButtonClick : [button_clicked] } This tells the send_event function that when a ButtonClick event is sent, it should call the button_clicked function.

Feb 24th, 2006, 11:16 AM	#8
Dietrich Professional Programmer Join Date: Feb 2005 Posts: 434 Rep Power: 4	Arevos, could you please send a working example? __________________ I looked it up on the Intergnats!

Feb 23rd, 2006, 5:42 PM	#3
OpenLoop Expert Programmer Join Date: May 2005 Location: East Lansing, MI Posts: 663 Rep Power: 4	<3 = Love, notice the heart shape. That's one interpretation.

Feb 23rd, 2006, 5:57 PM	#4
The Dark Expert Programmer Join Date: Jun 2005 Posts: 852 Rep Power: 4	<3 = dropped my double scoop icecream cone

Feb 23rd, 2006, 7:01 PM	#6
Sane Programming Guru Join Date: Apr 2005 Location: Waterloo, Ontario Posts: 1,888 Rep Power: 5	Wow, that's seriously confusing... >.>

Feb 24th, 2006, 12:11 PM	#9
Cerulean Professional Programmer Join Date: Apr 2005 Location: London, England Posts: 459 Rep Power: 4	That's pretty cool. I'm fonder of the maintenance free signal/slot implementation, however. Python cookbook at its best!

Feb 24th, 2006, 2:16 PM	#10
Arevos Programming Guru Join Date: Aug 2005 Location: England Posts: 1,499 Rep Power: 5	I prefer the dispatch method myself. It seems to me to be a more abstracted model, cleanly separating the concept of event handling and the events themselves. As for a working example, I'll provide a simple one for demonstration purposes, though I'd advise using a library like pydispatcher instead. (Toggle Plain Text) event_registry = {} def connect(event_class, function): """Maps an event class to a function. Multiple functions can be mapped to the same event class.""" try: event_registry[event_class].append(function) except KeyError: event_registry[event_class] = [function] def listen_for(event_class): """Decorator for the 'connect' function""" def decorator(function): connect(event_class, function) return function return decorator def send_event(event): """Send an event to all functions that are listening for events of that type.""" try: functions = event_registry[event.__class__] except KeyError: return for function in functions: function(event) def main(): """Demonstration of how these events are used.""" class PokeEvent: """A generic event""" def __init__(self, name): self.name = name @listen_for(PokeEvent) def poked(event): """A function to be activated by an event""" print "Ouch! I was poked by %s" % event.name # Send a new PokeEvent. Should be caught by the "poked" function send_event(PokeEvent("Fred")) if __name__ == '__main__': main() event_registry = {} def connect(event_class, function): """Maps an event class to a function. Multiple functions can be mapped to the same event class.""" try: event_registry[event_class].append(function) except KeyError: event_registry[event_class] = [function] def listen_for(event_class): """Decorator for the 'connect' function""" def decorator(function): connect(event_class, function) return function return decorator def send_event(event): """Send an event to all functions that are listening for events of that type.""" try: functions = event_registry[event.__class__] except KeyError: return for function in functions: function(event) def main(): """Demonstration of how these events are used.""" class PokeEvent: """A generic event""" def __init__(self, name): self.name = name @listen_for(PokeEvent) def poked(event): """A function to be activated by an event""" print "Ouch! I was poked by %s" % event.name # Send a new PokeEvent. Should be caught by the "poked" function send_event(PokeEvent("Fred")) if __name__ == '__main__': main() This is similar to the code I posted before, but better laid out, commented, and without the errors

Currently Active Users Viewing This Thread: 1 (0 members and 1 guests)

Thread Tools
Show Printable Version Email this Page
Display Modes
Switch to Linear Mode Hybrid Mode Switch to Threaded Mode