Access to static members from inside a method decorator?

[glen.coates.bigworld at gmail.com]

Peter Otten wrote:
> glen.coates.bigworld at gmail.com wrote:
>
> You define one base type with a custom metaclass and inherit from that. Your
> example then becomes:
>
> import sys
>
> class ExposedType( type ):
>     def __init__( cls, *args, **kw ):
>         # Track marked exposed methods
>         cls.s_exposedMethods = []
>         for superclass in cls.__mro__:
>             for name, meth in superclass.__dict__.items():
>                 if hasattr( meth, "exposed" ):
>                     cls.s_exposedMethods.append( name )
>
> class Exposed:
>     __metaclass__ = ExposedType
>     def getExposedMethods(self):
>         return self.s_exposedMethods
>     def bar(self):
>         print "bar\n"
>     @staticmethod
>     def expose( f ):
>         f.exposed = True
>         return f
>
> class Process( Exposed):
>     @Exposed.expose
>     def foo( self ):
>         pass
>     def bar( self ):
>         print "BAR"
>
>
> class BotProcess( Process ):
>     @Exposed.expose
>     def addBots( self ):
>         pass
>
> p = Process()
> p.bar()
>
> This prints "BAR" as expected.
>
> Peter

Thanks Peter.  Yeah I had thought of that earlier, but wasn't sure if
this is a standard design pattern for what I'm trying to achieve.  It
seems ugly to me to use 2 classes when you are essentially describing a
single type.  Is the Splat/SplatType pairing really a common design
pattern when trying to use metaclasses in this way?

Also ... as for the 'inspect' based solution, yeah I can see that would
work, but it seems very hacky to me and my gut reaction is to avoid
that kind of thing ...

Cheers,
Glen