creating method signals to automatically fire up on an event in python

Question

I don't honestly know if such thing exists or not, but I tried to do some research and ended up getting confused with something called d-Bus and not sure if that's what am looking for here,

class BigClass(Object):
  def Foo(self):
     print 'calling foo'

  def Logger(self):
     print 'foo has been called'

a = BigClass()
a.foo()

what am trying to do here is invoke Logger() method when foo() is being called. I want to create some sort of a event/signal where it will fire up logger() when specific methods are called in my class or all methods.

You probably want 'object' and 'foo', not 'Object' and 'Foo'. — Jonathan Eunice
– Jonathan Eunice, Commented Jun 20, 2012 at 12:46

warvariuc · Accepted Answer · 2012-06-20 12:36:42Z

2

I don't know your particular situation, but there is a good signal/callback lib called dispatch: http://pydispatcher.sourceforge.net/

But i prefer using Django dispatcher which was created based on PyDispatcher, but signal creation is more intuitive: https://github.com/django/django/blob/master/django/dispatch/dispatcher.py

what am trying to do here is invoke Logger() method when foo() is being called. I want to create some sort of a event/signal where it will fire up logger() when specific methods are called in my class or all methods.

Why don't you then call Logger method manually from foo method? Or better make a decorator to use it like:

class BigClass(Object):

  def Logger(self):
     print 'foo has been called'

  @log(Logger)
  def Foo(self):
     print 'calling foo'


a = BigClass()
a.foo()

answered Jun 20, 2012 at 12:36

warvariuc

60.1k45 gold badges183 silver badges234 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Jonathan Eunice · Accepted Answer · 2012-06-20 13:50:54Z

While an explicit logging call (or logging decorator, as warwaruk suggests) is the most straightforward approach, it is possible to automate logging, if you're willing to play a naming trick such as having the logical foo method be implemented by Foo. Python is case-sensitive, so those are separate and distinct. Then implement a __getattr__ method, like so:

class AutoLogger(object):

    def __getattr__(self, attr):
        try:
            return self.__class__.__dict__[attr]
        except KeyError:
            func = self.__class__.__dict__[attr.capitalize()]
            return lambda *args, **kwargs: self.log_call(attr, func, *args, **kwargs)

    def log_call(self, func_name, func, *args, **kwargs):
        func(self, *args, **kwargs)
        print func_name, 'has been called (handled by', func_name.capitalize() + ')'

class BigAutoLoggerClass(AutoLogger):
    def Foo(self):
        print 'calling Foo'


b = BigAutoLoggerClass()
b.Foo()
print "---"
b.foo()

This yields:

calling Foo
---
calling Foo
foo has been called (handled by Foo)

bar would similarly be implemented by Bar, and so on.

If you don't like this naming slight-of-hand, logging can also be automated via the sys.settrace() function. That, however, adds a lot of run-time overhead and is really only suited for debugging or situations where low(ish) performance is okay.

Collectives™ on Stack Overflow

creating method signals to automatically fire up on an event in python

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related