/
MarcheConcurrenceRemote.py
147 lines (129 loc) · 4.87 KB
/
MarcheConcurrenceRemote.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# -*- coding: utf-8 -*-
import logging
import random
from twisted.internet import defer
from twisted.spread import pb
from client.cltremote import IRemote
from client.cltgui.cltguidialogs import GuiRecapitulatif
import MarcheConcurrenceParams as pms
from MarcheConcurrenceGui import GuiDecision
import MarcheConcurrenceTexts as texts_MC
logger = logging.getLogger("le2m")
class RemoteMC(IRemote):
"""
Class remote, remote_ methods can be called by the server
"""
def __init__(self, le2mclt):
IRemote.__init__(self, le2mclt)
self._role = None
self._value_or_cost = None
@property
def role(self):
return self._role
@property
def value_or_cost(self):
return self._value_or_cost
def remote_configure(self, params, server_part):
"""
Set the same parameters as in the server side
:param params:
:return:
"""
logger.info(u"{} configure".format(self._le2mclt.uid))
for k, v in params.viewitems():
setattr(pms, k, v)
self._server_part = server_part
def remote_newperiod(self, period):
"""
Set the current period and delete the history
:param period: the current period
:return:
"""
logger.info(u"{} Period {}".format(self._le2mclt.uid, period))
self.currentperiod = period
if self.currentperiod <= 1:
del self.histo[:]
self.histo.append(texts_MC.get_histo_head(self.role))
self._histo_vars = texts_MC.get_histo_vars(self.role)
def remote_display_decision(self, value_or_cost):
"""
Display the decision screen
:return: deferred
"""
logger.info(u"{} Decision".format(self._le2mclt.uid))
self._value_or_cost = value_or_cost
if self._le2mclt.simulation: # de pas simulation possible
self.le2mclt.automatique = True
defered = defer.Deferred()
self._ecran_decision = GuiDecision(
defered, self._le2mclt.automatique,
self._le2mclt.screen, self.currentperiod, self.histo, self)
self._ecran_decision.show()
return defered
def remote_display_summary(self, period_content):
"""
Display the summary screen
:param period_content: dictionary with the content of the current period
:return: deferred
"""
logger.info(u"{} Summary".format(self._le2mclt.uid))
self.histo.append([period_content.get(k) for k in self._histo_vars])
if self._le2mclt.simulation:
return 1
else:
defered = defer.Deferred()
ecran_recap = GuiRecapitulatif(
defered, self._le2mclt.automatique, self._le2mclt.screen,
self.currentperiod, self.histo,
texts_MC.get_text_summary(period_content), size_histo=(600, 100))
ecran_recap.show()
return defered
@defer.inlineCallbacks
def send_offer(self, offer):
"""
Lorsque le sujet fait une offre depuis son écran
:param offer:
:return:
"""
yield (self._server_part.callRemote("set_offer", offer))
@defer.inlineCallbacks
def send_transaction(self, existing_offer):
"""
Lorsque le sujet accepte la meilleure offre en cours ou fait une offre
égale à la meilleure offre en cours
:param existing_offer:
:return:
"""
yield (self._server_part.callRemote("set_transaction", existing_offer))
def remote_add_offer(self, offer_dict):
"""
Lorsque un des sujets du groupe (le sujet "sender" compris) a fait
une offre
:param offer_dict: un dictionnaire avec les propriétés de l'offre
:return:
"""
self._ecran_decision.add_offer(offer_dict,
self.le2mclt.uid == offer_dict["MC_sender"])
def remote_add_transaction(self, sell_offer, buy_offer):
"""
Lorsque un des sujets du groupe (le sujet "sender" compris) a fait une
transaction.
:param sell_offer:
:param buy_offer:
:return:
"""
concerned = self.le2mclt.uid in [sell_offer["MC_sender"],
buy_offer["MC_sender"]]
self._ecran_decision.add_transaction(sell_offer, buy_offer, concerned)
def remote_display_role(self, role):
self._role = role
if self.le2mclt.simulation:
return 1
else:
return self.le2mclt.get_remote("base").remote_display_information(
texts_MC.get_text_role(self._role))
def remote_display_payoffs(self, payoff_infos):
logger.debug(u"{} display_payoffs".format(self.le2mclt.uid))
txt_payoff = texts_MC.get_text_payoff(payoff_infos)
return self.le2mclt.get_remote("base").remote_display_information(
txt_payoff)