def SetupClientConnection():
client = ClientConnection()
EggClient = PLCClient()
EggClient.ClientName = 'SenorEgg'
EggClient.ClientID = 10245
EggControlz = ControlValue()
EggControlz.ControlValueType = EggControlz.Range
EggControlz.ControlName = 'Yolk'
EggClient.ControlList.append(EggControlz)
client.SetClientData(EggClient)
return client
def SetupClientConnection():
client = ClientConnection()
CuckooClient = PLCClient()
CuckooClient.ClientName = 'CuckooConductor'
CuckooClient.ClientID = 1175278
CuckooClient.IconName = 'cuckoo-clock'
tock = ControlValue()
tock.ControlName = 'Tock'
tock.ControlDirection = tock.Output
tock.ControlValueType = tock.OnOff
CuckooClient.ControlList.append(tock)
client.SetClientData(CuckooClient)
return client
def __init__(self, master, selectionGet):
self.swb = ScrolledWB(1120,6000, self) # Tamaño del board.
#self.swb.wb.client = self
self.cc = ClientConnection(master, self.swb)
self.root = None
self.name = None
self.selectionGet = selectionGet
def __init__(self, master=None, path_list=None, cnf={}, **kw):
if not path_list:
path_list = [self.ROOT_PATH]
ClientConnection.__init__(self, path_list)
tk.Label.__init__(self, master, cnf, **kw)
self.configure(
text=self.name,
height=1,
width=self.master["width"],
font=("", 9),
bg=self.BACK_GROUND_COLOR,
bd=0,
fg="black",
)
self.configure(**kw)
self.set_event()
def __init__(self, nets=[]):
super().__init__()
self.imgToPredict = None
self.imgToPredictClass = None
self.imgPredictedClass = None
self.imgTrueClassLabel = QLabel()
self.imgPredictedClassLabel = QLabel()
self.model = convModel()
self.nets = nets
host = 'localhost'
serverPort = getServerPort()
self.clientsInNet = getClientsNumber()
self.firstPort = getTesterPort()
self.serverConnection = ServerConnection(host, serverPort, serverPort + 1)
self.clients = []
self.accBtns = []
for i in range(self.clientsInNet):
self.clients.append(ClientConnection('client-' + str(i), self.firstPort + (i * 2),
self.firstPort + (i * 2) + 1, self))
for client in self.clients:
client.start()
self.setWindowTitle('Federated learning controller')
self.mainWidget = QWidget()
self.setCentralWidget(self.mainWidget)
qss_file = open('style.qss').read()
self.centralWidget().setStyleSheet(qss_file)
self.layout = QGridLayout()
self.layout.setAlignment(Qt.AlignTop)
self.mainWidget.setLayout(self.layout)
self.__addDropdown(nets)
self.addClientInfo()
self.__addImageFrame()
self.addTrainButton()
self.addPredictImage()
self.serverConnection.addQtControls(self.preTrainVal, self.postTrainVal, self.trainBtn, self.netBtn,
self.accBtns, self.downloadBtn, self.currentModel, self.modelDownloadedAcc)
self.serverConnection.addModelRef(self.model)
self.serverConnection.setCallbacks(self.imageIsSet, lambda: self.predictChangeState(True))
self.serverConnection.start()
self.disableButtons()
self.show()
def SetupClientConnection():
client = ClientConnection()
BlinkyLEDClient = PLCClient()
BlinkyLEDClient.ClientName = 'HueBulbs'
BlinkyLEDClient.ClientID = 5123085
BlinkyLEDClient.IconName = 'light-bulb'
Hue1OnOff = ControlValue()
Hue1OnOff.ControlName = 'HueLight1'
Hue1OnOff.ControlValueType = Hue1OnOff.OnOff
BlinkyLEDClient.ControlList.append(Hue1OnOff)
Hue2OnOff = ControlValue()
Hue2OnOff.ControlName = 'HueLight2'
Hue2OnOff.ControlValueType = Hue2OnOff.OnOff
BlinkyLEDClient.ControlList.append(Hue2OnOff)
client.SetClientData(BlinkyLEDClient)
return client
def start(self):
self._db_cursor.execute(self.DB_INIT)
self.__socket.bind(self._address)
self.__socket.listen(5)
while True:
(destination_socket, destination_address) = self.__socket.accept()
print(
f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} - {destination_address[0]}'
)
thread_session = ClientSession()
t = ClientConnection(destination_socket, self, thread_session)
t.start()
print(f'Currently logged: {len(self._sessions)}')
def __init__(self, **kwargs):
super(ScreenManager, self).__init__(**kwargs)
global init
if init == 0:
try:
self.clientConnection = ClientConnection()
self.connected = self.clientConnection.connect_to_server(HOST, PORT)
except socket.error as e:
self.connected = None
self.db = MySQLdb.connect(host="localhost", user="******", passwd="bastard11", db="pwd_manager")
self.cursor = self.db.cursor()
init = init + 1
def connect(self, IP, PORT):
connection = ClientConnection()
connection.connect_to_server(IP, PORT)
return connection
import sys
if __name__ == '__main__':
#Get a new Configuration instance
config = Configuration('../em_interface.cfg');
#Load parameters from the config file
config.load()
#Setup logging for the application
numeric_log_level = getattr(logging, config.loglevel.upper(), None)
logging.basicConfig(filename=config.logfile,level=numeric_log_level, format='%(asctime)s - %(levelname)s - %(message)s')
#Get a new client instance
client = ClientConnection(config)
#Initiate a connection between the client and the event manager.
success, err_msg = client.connect()
if not success:
sys.stderr.write('Error connecting to event manager: ' + err_msg + '\n')
sys.exit(1)
#Write 5 messages
for i in range(5):
msg = raw_input("Enter a message to send: ")
builder = EventMessageBuilder()
builder.event_type = EventType.EVENT
builder.event_name = EventList.TEXT_MESSAGE
builder.client_name = config.client_name
builder.event_destination = 'client1'
class Client:
def __init__(self, master, selectionGet):
self.swb = ScrolledWB(1120,6000, self) # Tamaño del board.
#self.swb.wb.client = self
self.cc = ClientConnection(master, self.swb)
self.root = None
self.name = None
self.selectionGet = selectionGet
def setName(self, name):
self.name = name
def setRoot(self, root):
self.root = root
def setAvatar(self, avatar):
self.avatar = avatar
self.cc.avatar = avatar
def pack(self):
self.swb.pack()
def getSystemClipboard(self):
try:
ret = self.selectionGet(selection="CLIPBOARD")
except:
ret = ""
return ret
def showSubjects(self):
self.cc.subjectAdminCreate(self.avatar)
def showPost(self):
self.cc.postAdminCreate(self.avatar)
def showQuestions(self):
self.cc.questionAdminCreate(self.avatar)
def showRooms(self):
self.cc.roomAdminCreate(self.avatar)
def disconnect(self):
return self.root.callRemote("removeClient")
def broadcast_copyItems(self, items):
deferred = self.root.callRemote("copyItems", items)
deferred.addErrback(self.check_everything, "Error in broadcast_copyItems")
return deferred
def broadcast_paste(self):
deferred = self.root.callRemote("paste")
deferred.addErrback(self.check_everything, "Error in broadcast_paste")
return deferred
def broadcast_addItem(self, itemId, kind, points, outline, fill, width, graph=None):
deferred = self.root.callRemote("addItem", itemId, kind, points, outline, fill, width, graph=graph)
deferred.addErrback(self.check_everything, "Error in broadcast_addItem")
return deferred
def broadcast_moveItems(self, items, dx, dy):
deferred = self.root.callRemote("moveItems", items, dx, dy)
deferred.addErrback(self.check_everything, "Error in broadcast_moveItems")
return deferred
def broadcast_eraseItem(self, items):
deferred = self.root.callRemote("eraseItem", items)
deferred.addErrback(self.check_everything, "Error in broadcast_eraseItem")
return deferred
def broadcast_fillItem(self, item, color):
deferred = self.root.callRemote("fillItem", item, color)
deferred.addErrback(self.check_everything, "Error in broadcast_fillItem")
return deferred
def broadcast_addTextBox(self, textbox, points, color):
if self.root is None:
return defer.succeed(None)
deferred = self.root.callRemote("addTextBox", textbox, points, color)
deferred.addErrback(self.check_everything, "Error in broadcast_addTextBox")
return deferred
def broadcast_insertChars(self, textbox, index, string):
string = string.encode('utf-8')
deferred = self.root.callRemote("insertChars", textbox, index, string)
deferred.addErrback(self.check_everything, "Error in broadcast_insertChars")
return deferred
def broadcast_deleteChars(self, textbox, startIndex, endIndex):
deferred = self.root.callRemote("deleteChars", textbox, startIndex, endIndex)
deferred.addErrback(self.check_everything, "Error in broadcast_deleteChars")
return deferred
def broadcast_sendMsg(self, string):
string = string.encode('utf-8')
deferred = self.root.callRemote("sendMsg", string)
deferred.addErrback(self.check_everything, "Error in broadcast_sendMsg")
return deferred
def check_everything(self, failure, msg):
print msg
log.err(failure)
return None
def createConnection(self, ip, port, sock):
service = ClientConnection(ip, port, sock, self.din, self.dout, self.lock)
service.start()
def connect(self, IP, PORT):
connection = ClientConnection()
connection.connect_to_server(IP, PORT)
return connection
