best way to code

[eric]

On Dec 19, 6:36 pm, eric <e... at ericaro.net> wrote:
> On Dec 19, 5:35 pm, Peter Otten <__pete... at web.de> wrote:
>
>
>
> > eric wrote:
> > > 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
> > >>> 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
>
> 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
>
> thanks
>
> --
> Erichttp://codeslash.blogspot.com

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.