klassen variable "beobachten"

[Costi]

hmm ich kriegs irgendwie nicht hinn

folgendes:
immer wenn eine bestimmte klassen variable beantragt wird, muss automatisch woher ein andere funktion aufgerufen werden

irgendwelche ideen?

Code: Alles auswählen

pseudo code
class Test:
    x = 8
   def wenn_x_gegetet_wird(self):
      print "halo welt"

t = Test()
t.x  #gibt aus: `halo welt`

[gerold]

immer wenn eine bestimmte klassen variable beantragt wird, muss automatisch woher ein andere funktion aufgerufen werden

Hallo Costi!

Code: Alles auswählen

class Test(object):
    _x = 8
   
    def get_x(self):
        print "Hallo Welt"
        # Klassenvariable zurück geben...
        return Test._x
        # ...oder doch lieber die Instanzvariable???
        #return self._x
    
    x = property(get_x)

t = Test()
print t.x

mfg
Gerold

[nkoehring]

Hallo, dazu hab ich auch mal ne Frage...

Ich will ueber Pyro (unter anderem) die Kommunikation zwischen Server und Client ermoeglichen.
Da dachte ich, mache ich folgendes:

Code: Alles auswählen

class KlasseDiePyroAnDenClientSendet:
    msg_queue = Queue.Queue()
    ...
    def setMsg(self, msg):
        """ schreibt `msg` in die msg_queue """
        KlasseDiePyroAnDenClientSendet.msg_queue.put(msg)

    def getMsg(self):
        """ nimmt ``msg`` aus der queue und gibt sie zurueck """
        return KlasseDiePyroAnDenClientSendet.msg_queue.get()

Wenn ich nun eine Instanz im Hauptprogramm bilde und mit setMsg eine Nachricht in die Queue schiebe, waerend das Programm auf der anderen Seite mit Hilfe von getMsg die ganze Zeit auf einen Queue-Eintrag wartet, sollte das doch gehen... tut es aber nicht.

Die Methoden werden korrekt aufgerufen, aber die Queue scheint nicht abrufbar zu sein. Dabei ist es egal, ob ich getMsg vor oder nach setMsg ausfuehren lasse (dabei ist stehts zu beachten, dass getMsg immer von einem anderen Thread als setMsg ausgefuehrt wird, jeder mit eigener Instanz, die einmal normal und einmal per Pyro gebildet wird).

Woran kanns liegen?

[BlackJack]

Ohne mehr Code zu sehen ist das nur geraten, aber nimm doch mal eine Instanz und keine Klasse zur Kommunikation.

[nkoehring]

Hi BlackJack...

wenn ich dich richtig verstehe, dann nehm ich bereits eine Klasseninstanz zur Kommunikation.

Das ganze schaut im groben wie folgt aus:

Code: Alles auswählen

## das ist der Teil vom Hauptprogramm,
## der die Nachrichten an die Klasse sendet
class Plugin:
    """ dieses Plugin erzeugt ein Panel, was dann vom Hauptprogramm
         in ein 'Notebook' integriert wird. """

    def __init__(self):
        #...
        self.klasse_die_pyro_an_den_client_sendet = KlasseDiePyroAnDenClientSendet()
        #...

    def onTextEnter(self, evt):
        msg = self.inputfield.GetValue()
        self.klasse_die_pyro_an_den_client_sendet.setMsg(msg)

Code: Alles auswählen

class Client(threading.Thread):
    """ The client class... currently in conceptional state """

    def __init__(self, servername, whoami, username):
        threading.Thread.__init__(self, name=username)
        self.setDaemon(True)
        self.uri = servername
        self.whoami = whoami
        self.connected = False
        #...

    def connect(self):
        Pyro.core.initClient()
        print "Trying to connect to", self.uri
        try:
            srv = Pyro.core.getProxyForURI(self.uri)
            srv._setNewConnectionValidator( connvalidator.UserLoginConnValidator() )
            srv._setIdentification(("guest","guest"))
            self._srv = srv
            hello = srv.sayhello(self.whoami)
            print "Result from server call:", hello
            self.connected = srv.connected()
        except Pyro.core.ProtocolError, e:
            self.connected = str(e)
            print self.whoami+': error with connection to', str(self.uri)+':', e

    def run(self):
        #...
        while 1:
            print "client (%s) is waiting for messages..." %name,
            msg = self._srv.getMsg() # hier wird nun auf die Queue gewartet
        #...

Ja, wie gesagt bleibt es bei dem Versuch die Queue auszulesen haengen.