best way to code

[eric]

hi,

I need to find a "good" design pattern to instanciate, and add
specific code all in one. Let me explain it :

I need to define "some" code, better be in a class, something like

class LinkA(object):
def mystuff(self):
<do something different>

class LinkB(object):
def mystuff(self):
<do something different again>

AND I need an instance of this class
{ "stuff A": LinkA()
"stuff B": LinkB()
}

This kind of code "would" be fine, I mean, the result effect in memory
is fine for me.
But I don't like the way I have to
1/ give a useless name to LinkA, linkB (there can be hundreds of names
like that)
2/ I have to write it down two times (and that's one time too much)

any ideas ?

something like
[
new object():
def mystuff(self):
<do something>
,
new object():
def mystuff(self):
<do something else>
]

would be really perfect (but I know it does not work, or at least, I
don't know how to make it work)

In fact, I would like to define a class, and an instance in a single
statement

thanks

--
Eric
http://codeslash.blogspot.com

[Peter Otten]

eric wrote:

>>> class Register:
... def __init__(self):
... self.items = []
... def __call__(self, method):
... class Link(object):
... mystuff = method
... self.items.append(Link())
...
>>> register = Register()
>>> @register
... def mystuff(self): print "first"
...
>>> @register
... def mystuff(self): print "second"
...
>>> for item in register.items:
... item.mystuff()
...
first
second

Peter

[eric]

hi,

I've tried something like this :

import inspect

class Test(object):
class Inner(object):
def mystuff(self):
print "hello stuff"

class InnerB(object):
def mystuff(self):
print "hello B"

def filter(member):
return inspect.isclass(member) and not member==Test.__class__
d = dict( (name, c()) for name, c in inspect.getmembers(Test,
filter ) )
print d

it works too, but I prefer your method

[eric]

Finally here is my 'final' shot:

context: when building a glade GUI I wanted to connect 'nicely'
signals (I hate coding the same info in several places)

here is my main :

if __name__=="__main__":
pathname = os.path.dirname(sys.argv[0])
startup = os.path.join(pathname, 'pyshow/pyshow.glade')
xml = gtk.glade.XML(startup) #'filename.glade')

#the stuff starts here
m = MainApp()
for widget_name, codget in m.items():
codget.set_widget( xml.get_widget(widget_name) )

gtk.main()

and here is the 'MainApp' code, based on the question, and finally I
get stuck to my second solution

import inspect
class Controller(dict):
def __init__(self):
dict.__init__(self)
self.update(

(name, c()) for name, c in inspect.getmembers

(self.__class__, lambda member: inspect.isclass(member) and not
member==self.__class__.__class__ )
)

class MainApp(Controller):
def __init__(self):
Controller.__init__(self)

class main_window(codget):
def on_destroy(self, widget, modget):
print "bye bye"

class play(codget):
def on_clicked(self, widget, modget):
print "you have clicked"

the business is hidden in codget ( as COntroller gaDGET), and what's
interesting for me, is that every signal handler has a 'modget' ( as
in model gadget) that it can use to do the job (part of the MVC
pattern)

thanks Peter anyway, I didn't use your solution in this specific case,
but I loved the solution anyway, and I'm sure that I'll use it one
day.

[miya]

Wow, loved this solution. Never thought about using decorators to
solve this kinda problems.

nice

-
Nicolás Miyasato (miya)
http://myPythonNotes.wordpress.com
http://nmiyasato.blogspot.com