Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
Cet exemple ne correspond pas à la description que tu fais plus haut. Le
seul attribut propre de la *classe* MonServeur est la fonction __init__
- qui n'est pas une classe. Et les attributs *d'instance* ne sont pas
des classes, mais une instance de dict et une instance de HttpServer. Ne
va pas croire que les problèmes de terminologie sont sans importance, on
ne peut pas raisonner clairement dans ce domaine si on se mélange dans
les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type builtin
avec une notation littérale ou une instance d'une classe que tu a défini
toi-même n'y change rien.
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):
def __init__(self):
self.params = {}
self.http_server = HttpServer()
Cet exemple ne correspond pas à la description que tu fais plus haut. Le
seul attribut propre de la *classe* MonServeur est la fonction __init__
- qui n'est pas une classe. Et les attributs *d'instance* ne sont pas
des classes, mais une instance de dict et une instance de HttpServer. Ne
va pas croire que les problèmes de terminologie sont sans importance, on
ne peut pas raisonner clairement dans ce domaine si on se mélange dans
les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type builtin
avec une notation littérale ou une instance d'une classe que tu a défini
toi-même n'y change rien.
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
Cet exemple ne correspond pas à la description que tu fais plus haut. Le
seul attribut propre de la *classe* MonServeur est la fonction __init__
- qui n'est pas une classe. Et les attributs *d'instance* ne sont pas
des classes, mais une instance de dict et une instance de HttpServer. Ne
va pas croire que les problèmes de terminologie sont sans importance, on
ne peut pas raisonner clairement dans ce domaine si on se mélange dans
les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type builtin
avec une notation littérale ou une instance d'une classe que tu a défini
toi-même n'y change rien.
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
"certains de ces attributs sont d'autres classes"
=> d'autres instances de classes j'imagine ? Si oui c'est un peu le
cas de tous les attributs dans un langage objet.
Oui, bien dit, surtout en python ;)Ta classe principale est MonServeur c'est ça ?
Je dirais naïvement au vu de ces informations qu'il est possible que
ton serveur soit une spécialisation d'un serveur Http auquel cas tu
peux définir un vrai lien d'héritage
class MonServeur(HttpServer):
Sinon, à la création de l'instance self.http_server, tu peux passer au
constructeur les paramètres dont tu auras besoin pour configurer ton
serveur Http.
self.http_server = HttpServer(self.params.port, self.params.host)
Beh en fait MonServeur fait serveur HTTP mais aussi plusieurs autres
choses dont un client Jabber et d'autres classes donc je voudrai créer
une classe principale qui regroupe toutes les fonctions (gérées par
d'autres classes) mais qui regroupe les infos utiles, par exemple un
dico de configuration qui pourrait etre partagé entre les différentes
classes
"certains de ces attributs sont d'autres classes"
=> d'autres instances de classes j'imagine ? Si oui c'est un peu le
cas de tous les attributs dans un langage objet.
Oui, bien dit, surtout en python ;)
Ta classe principale est MonServeur c'est ça ?
Je dirais naïvement au vu de ces informations qu'il est possible que
ton serveur soit une spécialisation d'un serveur Http auquel cas tu
peux définir un vrai lien d'héritage
class MonServeur(HttpServer):
Sinon, à la création de l'instance self.http_server, tu peux passer au
constructeur les paramètres dont tu auras besoin pour configurer ton
serveur Http.
self.http_server = HttpServer(self.params.port, self.params.host)
Beh en fait MonServeur fait serveur HTTP mais aussi plusieurs autres
choses dont un client Jabber et d'autres classes donc je voudrai créer
une classe principale qui regroupe toutes les fonctions (gérées par
d'autres classes) mais qui regroupe les infos utiles, par exemple un
dico de configuration qui pourrait etre partagé entre les différentes
classes
"certains de ces attributs sont d'autres classes"
=> d'autres instances de classes j'imagine ? Si oui c'est un peu le
cas de tous les attributs dans un langage objet.
Oui, bien dit, surtout en python ;)Ta classe principale est MonServeur c'est ça ?
Je dirais naïvement au vu de ces informations qu'il est possible que
ton serveur soit une spécialisation d'un serveur Http auquel cas tu
peux définir un vrai lien d'héritage
class MonServeur(HttpServer):
Sinon, à la création de l'instance self.http_server, tu peux passer au
constructeur les paramètres dont tu auras besoin pour configurer ton
serveur Http.
self.http_server = HttpServer(self.params.port, self.params.host)
Beh en fait MonServeur fait serveur HTTP mais aussi plusieurs autres
choses dont un client Jabber et d'autres classes donc je voudrai créer
une classe principale qui regroupe toutes les fonctions (gérées par
d'autres classes) mais qui regroupe les infos utiles, par exemple un
dico de configuration qui pourrait etre partagé entre les différentes
classes
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ? il y
a une PEP, un guide pour ca ?
Cet exemple ne correspond pas à la description que tu fais plus haut.
Le seul attribut propre de la *classe* MonServeur est la fonction
__init__ - qui n'est pas une classe. Et les attributs *d'instance* ne
sont pas des classes, mais une instance de dict et une instance de
HttpServer. Ne va pas croire que les problèmes de terminologie sont
sans importance, on ne peut pas raisonner clairement dans ce domaine
si on se mélange dans les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type
builtin avec une notation littérale ou une instance d'une classe que
tu a défini toi-même n'y change rien.
c'est marrant coder en python me parait plus naturel et facile que de
l'expliquer !!
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
Je me disais qu'il y avait peut etre mieux que de passer le dico config
a chaque instance
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
HttpServer ce serait du ThreadedHttpServer, mais je pourrai aussi avoir
du JabberClient et d'autres classes diverses et variées qui auraient
besoin de partager les memes infos avec la classes 'mere'
Je crois que je m'exprime tres mal donc je reviens vers vous avec un
message mieux pensé. Merci en tous cas pour les precisions
terminologiques et pythonesques c'est plus clair pour moi.
bonne journée a tous ;)
Julien
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):
def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ? il y
a une PEP, un guide pour ca ?
Cet exemple ne correspond pas à la description que tu fais plus haut.
Le seul attribut propre de la *classe* MonServeur est la fonction
__init__ - qui n'est pas une classe. Et les attributs *d'instance* ne
sont pas des classes, mais une instance de dict et une instance de
HttpServer. Ne va pas croire que les problèmes de terminologie sont
sans importance, on ne peut pas raisonner clairement dans ce domaine
si on se mélange dans les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type
builtin avec une notation littérale ou une instance d'une classe que
tu a défini toi-même n'y change rien.
c'est marrant coder en python me parait plus naturel et facile que de
l'expliquer !!
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
Je me disais qu'il y avait peut etre mieux que de passer le dico config
a chaque instance
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
HttpServer ce serait du ThreadedHttpServer, mais je pourrai aussi avoir
du JabberClient et d'autres classes diverses et variées qui auraient
besoin de partager les memes infos avec la classes 'mere'
Je crois que je m'exprime tres mal donc je reviens vers vous avec un
message mieux pensé. Merci en tous cas pour les precisions
terminologiques et pythonesques c'est plus clair pour moi.
bonne journée a tous ;)
Julien
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ? il y
a une PEP, un guide pour ca ?
Cet exemple ne correspond pas à la description que tu fais plus haut.
Le seul attribut propre de la *classe* MonServeur est la fonction
__init__ - qui n'est pas une classe. Et les attributs *d'instance* ne
sont pas des classes, mais une instance de dict et une instance de
HttpServer. Ne va pas croire que les problèmes de terminologie sont
sans importance, on ne peut pas raisonner clairement dans ce domaine
si on se mélange dans les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type
builtin avec une notation littérale ou une instance d'une classe que
tu a défini toi-même n'y change rien.
c'est marrant coder en python me parait plus naturel et facile que de
l'expliquer !!
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
Je me disais qu'il y avait peut etre mieux que de passer le dico config
a chaque instance
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
HttpServer ce serait du ThreadedHttpServer, mais je pourrai aussi avoir
du JabberClient et d'autres classes diverses et variées qui auraient
besoin de partager les memes infos avec la classes 'mere'
Je crois que je m'exprime tres mal donc je reviens vers vous avec un
message mieux pensé. Merci en tous cas pour les precisions
terminologiques et pythonesques c'est plus clair pour moi.
bonne journée a tous ;)
Julien
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ? il
y a une PEP, un guide pour ca ?
C'est arrivé avec la version 2.2. C'est une amélioration du modèle objet
de python.
http://www.python.org/doc/2.2.3/whatsnew/sect-rellinks.html
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):
def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ? il
y a une PEP, un guide pour ca ?
C'est arrivé avec la version 2.2. C'est une amélioration du modèle objet
de python.
http://www.python.org/doc/2.2.3/whatsnew/sect-rellinks.html
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ? il
y a une PEP, un guide pour ca ?
C'est arrivé avec la version 2.2. C'est une amélioration du modèle objet
de python.
http://www.python.org/doc/2.2.3/whatsnew/sect-rellinks.html
Après si tu veux vraiment passer ton dictionnaire de configuration à
chaque instance rien ne t'en empèche. Il faut juste se rendre compte que
tu ne dupliques pas ton dictionnaire de configuration mais que tu passes
la référence du dictionnaire.
Tu peux faire quelquechose comme :
class Appli(object):
def __init__(self):
self.config = Config()
self.http_server = HttpServer(self.config)
class Config(object):
def __init__(self):
self.port = 20
class HttpServer(object):
def __init__(self, cfg):
self.port = cfg.port
Après si tu veux vraiment passer ton dictionnaire de configuration à
chaque instance rien ne t'en empèche. Il faut juste se rendre compte que
tu ne dupliques pas ton dictionnaire de configuration mais que tu passes
la référence du dictionnaire.
Tu peux faire quelquechose comme :
class Appli(object):
def __init__(self):
self.config = Config()
self.http_server = HttpServer(self.config)
class Config(object):
def __init__(self):
self.port = 20
class HttpServer(object):
def __init__(self, cfg):
self.port = cfg.port
Après si tu veux vraiment passer ton dictionnaire de configuration à
chaque instance rien ne t'en empèche. Il faut juste se rendre compte que
tu ne dupliques pas ton dictionnaire de configuration mais que tu passes
la référence du dictionnaire.
Tu peux faire quelquechose comme :
class Appli(object):
def __init__(self):
self.config = Config()
self.http_server = HttpServer(self.config)
class Config(object):
def __init__(self):
self.port = 20
class HttpServer(object):
def __init__(self, cfg):
self.port = cfg.port
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ?
il y
a une PEP, un guide pour ca ?
Cet exemple ne correspond pas à la description que tu fais plus haut.
Le seul attribut propre de la *classe* MonServeur est la fonction
__init__ - qui n'est pas une classe. Et les attributs *d'instance* ne
sont pas des classes, mais une instance de dict et une instance de
HttpServer. Ne va pas croire que les problèmes de terminologie sont
sans importance, on ne peut pas raisonner clairement dans ce domaine
si on se mélange dans les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type
builtin avec une notation littérale ou une instance d'une classe que
tu a défini toi-même n'y change rien.
c'est marrant coder en python me parait plus naturel et facile que de
l'expliquer !!
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
Je me disais qu'il y avait peut etre mieux que de passer le dico config
a chaque instance
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
HttpServer ce serait du ThreadedHttpServer, mais je pourrai aussi avoir
du JabberClient et d'autres classes diverses et variées qui auraient
besoin de partager les memes infos avec la classes 'mere'
Je crois que je m'exprime tres mal donc je reviens vers vous avec un
message mieux pensé.
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):
def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ?
il y
a une PEP, un guide pour ca ?
Cet exemple ne correspond pas à la description que tu fais plus haut.
Le seul attribut propre de la *classe* MonServeur est la fonction
__init__ - qui n'est pas une classe. Et les attributs *d'instance* ne
sont pas des classes, mais une instance de dict et une instance de
HttpServer. Ne va pas croire que les problèmes de terminologie sont
sans importance, on ne peut pas raisonner clairement dans ce domaine
si on se mélange dans les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type
builtin avec une notation littérale ou une instance d'une classe que
tu a défini toi-même n'y change rien.
c'est marrant coder en python me parait plus naturel et facile que de
l'expliquer !!
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
Je me disais qu'il y avait peut etre mieux que de passer le dico config
a chaque instance
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
HttpServer ce serait du ThreadedHttpServer, mais je pourrai aussi avoir
du JabberClient et d'autres classes diverses et variées qui auraient
besoin de partager les memes infos avec la classes 'mere'
Je crois que je m'exprime tres mal donc je reviens vers vous avec un
message mieux pensé.
Sauf raison majeure, utilise de préférence le "nouveau" (si l'on peut
dire - il date de la 2.3 SJMSB) modèle objet:
class MonServeur(object):def __init__(self):
self.params = {}
self.http_server = HttpServer()
quelle est la difference ? le (object) apres le nom de la classe ?
il y
a une PEP, un guide pour ca ?
Cet exemple ne correspond pas à la description que tu fais plus haut.
Le seul attribut propre de la *classe* MonServeur est la fonction
__init__ - qui n'est pas une classe. Et les attributs *d'instance* ne
sont pas des classes, mais une instance de dict et une instance de
HttpServer. Ne va pas croire que les problèmes de terminologie sont
sans importance, on ne peut pas raisonner clairement dans ce domaine
si on se mélange dans les concepts.
Accessoirement, je te rappelle qu'en Python *tout* est objet (même les
fonctions, les classes et les modules). Que l'objet soit un type
builtin avec une notation littérale ou une instance d'une classe que
tu a défini toi-même n'y change rien.
c'est marrant coder en python me parait plus naturel et facile que de
l'expliquer !!
comment faire pour que http_server puisse utiliser des parametres
définis par ma classe 'principale' ?
En les lui passant ?
Je me disais qu'il y avait peut etre mieux que de passer le dico config
a chaque instance
sinon comment faire autrement ?
Impossible de répondre utilement sans connaissance de la classe
HttpServer, dont tu ne précises ni la provenance ni l'API.
HttpServer ce serait du ThreadedHttpServer, mais je pourrai aussi avoir
du JabberClient et d'autres classes diverses et variées qui auraient
besoin de partager les memes infos avec la classes 'mere'
Je crois que je m'exprime tres mal donc je reviens vers vous avec un
message mieux pensé.
Bonjour a tous...
Peut etre une question de newbie mais je n'ai pas reussi à trouver de
réponse, surement que j'utilise les mauvais termes...
Voila j'ai une classe A qui a comme attribut une classe B
class A:
def __init__(self):
self.valeur="test A"
self.b=B()
class B:
def __init__(self):
self.valeur="test B"
comment faire pour récupérer A.valeur directement depuis B ?
faut il forcement, lors de l'instanciation de B, indiquer un lien vers A
? (self.B.A = self par exemple)
ou y a t il un moyen plus classe de trouver la classe 'parente' de B
directement?
voila, je suis sur que Python propose une solution pythonesque pour ca ;)
merci a tous
a+
Julien
Bonjour a tous...
Peut etre une question de newbie mais je n'ai pas reussi à trouver de
réponse, surement que j'utilise les mauvais termes...
Voila j'ai une classe A qui a comme attribut une classe B
class A:
def __init__(self):
self.valeur="test A"
self.b=B()
class B:
def __init__(self):
self.valeur="test B"
comment faire pour récupérer A.valeur directement depuis B ?
faut il forcement, lors de l'instanciation de B, indiquer un lien vers A
? (self.B.A = self par exemple)
ou y a t il un moyen plus classe de trouver la classe 'parente' de B
directement?
voila, je suis sur que Python propose une solution pythonesque pour ca ;)
merci a tous
a+
Julien
Bonjour a tous...
Peut etre une question de newbie mais je n'ai pas reussi à trouver de
réponse, surement que j'utilise les mauvais termes...
Voila j'ai une classe A qui a comme attribut une classe B
class A:
def __init__(self):
self.valeur="test A"
self.b=B()
class B:
def __init__(self):
self.valeur="test B"
comment faire pour récupérer A.valeur directement depuis B ?
faut il forcement, lors de l'instanciation de B, indiquer un lien vers A
? (self.B.A = self par exemple)
ou y a t il un moyen plus classe de trouver la classe 'parente' de B
directement?
voila, je suis sur que Python propose une solution pythonesque pour ca ;)
merci a tous
a+
Julien
Bon, comme d'autres l'ont fait remarquer ta question ne distingue pas
proprement (a) classes et instances, (b) sous-classes et membres. Comme
ils ont rectifié dans le sens où ton intention porte sur les instances,
je voudrais juste te faire observer à toutes fins utiles qu'on peut
aussi écrire
class B :
valeur = 'test B'
class A :
valeur = 'test A'
b = B
et accéder de n'importe où à A.valeur, B.valeur, A.b et A.b.valeur
Bon, comme d'autres l'ont fait remarquer ta question ne distingue pas
proprement (a) classes et instances, (b) sous-classes et membres. Comme
ils ont rectifié dans le sens où ton intention porte sur les instances,
je voudrais juste te faire observer à toutes fins utiles qu'on peut
aussi écrire
class B :
valeur = 'test B'
class A :
valeur = 'test A'
b = B
et accéder de n'importe où à A.valeur, B.valeur, A.b et A.b.valeur
Bon, comme d'autres l'ont fait remarquer ta question ne distingue pas
proprement (a) classes et instances, (b) sous-classes et membres. Comme
ils ont rectifié dans le sens où ton intention porte sur les instances,
je voudrais juste te faire observer à toutes fins utiles qu'on peut
aussi écrire
class B :
valeur = 'test B'
class A :
valeur = 'test A'
b = B
et accéder de n'importe où à A.valeur, B.valeur, A.b et A.b.valeur
Si j'ai bien compris, ta classe MonServeur sert de facade à plusieurs
services... Qui est client de MonServeur ? Et - hormis les histoires de
config - comment se passe la communication entre MonServeur et les
services qu'il "héberge" ?
Si j'ai bien compris, ta classe MonServeur sert de facade à plusieurs
services... Qui est client de MonServeur ? Et - hormis les histoires de
config - comment se passe la communication entre MonServeur et les
services qu'il "héberge" ?
Si j'ai bien compris, ta classe MonServeur sert de facade à plusieurs
services... Qui est client de MonServeur ? Et - hormis les histoires de
config - comment se passe la communication entre MonServeur et les
services qu'il "héberge" ?
Si j'ai bien compris, ta classe MonServeur sert de facade à plusieurs
services... Qui est client de MonServeur ? Et - hormis les histoires
de config - comment se passe la communication entre MonServeur et les
services qu'il "héberge" ?
MonServeur gere un serveur HTTP, un client jabber et une lib pour gérer
des process (lancement, kill, surveillance...)
Ce script est executé sur une machine et je me connecte à distance sur
le http pour faire mes actions
La communication ? Justement, actuellement je passe au client jabber par
exemple une reference à MonServeur, donc dans JabberClient par exemple :
# (je suis en train de lire la PEP pour les new class styles)
class MonServeur:
def __init__(self):
self.http = HttpServer(self)
self.jabber = JabberClient(self)
def messageRecu(self):
print "io"
class JabberClient:
def __init__(self, MonServeur):
self.srv = MonServeur
def message(self):
self.srv.messageRecu()
ca me parait pas tres propre car JabberClient et HttpServer ont du coup
acces a tout MonServeur
mais c'est le plus simple que j'ai trouvé pour
le moment...
Si j'ai bien compris, ta classe MonServeur sert de facade à plusieurs
services... Qui est client de MonServeur ? Et - hormis les histoires
de config - comment se passe la communication entre MonServeur et les
services qu'il "héberge" ?
MonServeur gere un serveur HTTP, un client jabber et une lib pour gérer
des process (lancement, kill, surveillance...)
Ce script est executé sur une machine et je me connecte à distance sur
le http pour faire mes actions
La communication ? Justement, actuellement je passe au client jabber par
exemple une reference à MonServeur, donc dans JabberClient par exemple :
# (je suis en train de lire la PEP pour les new class styles)
class MonServeur:
def __init__(self):
self.http = HttpServer(self)
self.jabber = JabberClient(self)
def messageRecu(self):
print "io"
class JabberClient:
def __init__(self, MonServeur):
self.srv = MonServeur
def message(self):
self.srv.messageRecu()
ca me parait pas tres propre car JabberClient et HttpServer ont du coup
acces a tout MonServeur
mais c'est le plus simple que j'ai trouvé pour
le moment...
Si j'ai bien compris, ta classe MonServeur sert de facade à plusieurs
services... Qui est client de MonServeur ? Et - hormis les histoires
de config - comment se passe la communication entre MonServeur et les
services qu'il "héberge" ?
MonServeur gere un serveur HTTP, un client jabber et une lib pour gérer
des process (lancement, kill, surveillance...)
Ce script est executé sur une machine et je me connecte à distance sur
le http pour faire mes actions
La communication ? Justement, actuellement je passe au client jabber par
exemple une reference à MonServeur, donc dans JabberClient par exemple :
# (je suis en train de lire la PEP pour les new class styles)
class MonServeur:
def __init__(self):
self.http = HttpServer(self)
self.jabber = JabberClient(self)
def messageRecu(self):
print "io"
class JabberClient:
def __init__(self, MonServeur):
self.srv = MonServeur
def message(self):
self.srv.messageRecu()
ca me parait pas tres propre car JabberClient et HttpServer ont du coup
acces a tout MonServeur
mais c'est le plus simple que j'ai trouvé pour
le moment...