class LabelWindow(QDialog):
def __init__(self, parent):
super(LabelWindow, self).__init__(parent)
self.test_layout = QGridLayout()
label = QLabel("Label")
self.test_layout.addWidget(label, 0, 0)
self.setLayout(self.test_layout)
self._destroyCalled = False
def replace(self, unit):
old_item = self.test_layout.itemAtPosition(0, 0)
old_label = old_item.widget()
ref = weakref.ref(old_item, self._destroyed)
self.test_layout.removeWidget(old_label)
unit.assertRaises(RuntimeError, old_item.widget)
del old_item
label = QLabel("Label New")
old_label.deleteLater()
label.setAlignment(Qt.AlignCenter)
self.test_layout.addWidget(label, 0, 0)
def _destroyed(self, obj):
self._destroyCalled = True
def preparePlots(self):
'''arange 2x8 plots for each channel and
set parameters
'''
if self.ui.frame.layout() is None:
layout = QGridLayout()
self.ui.frame.setLayout(layout)
else:
#########
# reset #
#########
layout = self.ui.frame.layout()
layout.removeWidget(self.plotWidget)
self.plotWidget = None
self.plots = []
self.plotWidget = pg.GraphicsLayoutWidget(border=(100,100,100))
layout.addWidget(self.plotWidget)
for i in range(8):
for k in range(2):
self.plots.append(self.plotWidget.addPlot(title="EMG " + str(k+2*i+1)))
self.plots[-1].plot(np.linspace(0,2,1000))
self.plots[-1].setYRange(-0.0002, 0.0002)
self.plotWidget.nextRow()
self.plotWidget.show()
class LabelWindow(QDialog):
def __init__(self, parent):
super(LabelWindow, self).__init__(parent)
self.test_layout = QGridLayout()
label = QLabel("Label")
self.test_layout.addWidget(label, 0, 0)
self.setLayout(self.test_layout)
self._destroyCalled = False
def replace(self, unit):
old_item = self.test_layout.itemAtPosition(0, 0)
old_label = old_item.widget()
ref = weakref.ref(old_item, self._destroyed)
self.test_layout.removeWidget(old_label)
unit.assertRaises(RuntimeError, old_item.widget)
del old_item
label = QLabel("Label New")
old_label.deleteLater()
label.setAlignment(Qt.AlignCenter)
self.test_layout.addWidget(label, 0, 0)
def _destroyed(self, obj):
self._destroyCalled = True
class MShape(QWidget, MAnimate):
def __init__(self):
QWidget.__init__(self)
self.__x = 0
self.__y = 0
self.__width = 0
self.__height = 0
self.__opacity = 1.0
self.__clip = None
self.__max_width = 0
self.__max_height = 0
self.__min_width = 0
self.__min_height = 0
self.__max_opacity = 1.0
self.__min_opacity = 0.0
self.__margin_left = 0
self.__margin_top = 0
self.__padding_x = 0
self.__padding_y = 0
# Defining the layout which will hold the child shapes of the widget
self.__layout = QGridLayout()
self.__layout.setVerticalSpacing(0)
self.__layout.setHorizontalSpacing(0)
self.__layout.setContentsMargins(QMargins(0, 0, 0, 0))
self.__children = []
def add_layout_item(self, shape, x, y):
self.__layout.addWidget(shape, x, y)
self.__children.append(shape)
self.update()
def remove_layout_item(self, shape):
self.__layout.removeWidget(shape)
self.__children.remove(shape)
shape.deleteLater()
self.update()
@property
def x(self):
return self.__x
@x.setter
def x(self, x):
self.__x = x
@property
def y(self):
return self.__y
@y.setter
def y(self, y):
self.__y = y
@property
def layout(self):
return self.__layout
@property
def width(self):
return self.__width
@width.setter
def width(self, width):
self.__width = width
if self.width < self.min_width:
self.__width = self.min_width
elif self.width > self.max_width:
self.__width = self.max_width
@property
def min_width(self):
return self.__min_width
@min_width.setter
def min_width(self, width):
self.__min_width = width
@property
def max_width(self):
return self.__max_width
@max_width.setter
def max_width(self, width):
self.__max_width = width
@property
def height(self):
return self.__height
@height.setter
def height(self, height):
self.__height = height
if self.height < self.min_height:
self.__height = self.min_height
elif self.height > self.max_height:
self.__height = self.max_height
@property
def min_height(self):
return self.__min_height
@min_height.setter
def min_height(self, height):
self.__min_height = height
@property
def max_height(self):
return self.__max_height
@max_height.setter
def max_height(self, height):
self.__max_height = height
@property
def opacity(self):
return self.__opacity
@opacity.setter
def opacity(self, opacity):
self.__opacity = opacity
if self.opacity < self.min_opacity:
self.opacity = self.min_opacity
@property
def min_opacity(self):
return self.__min_opacity
@min_opacity.setter
def min_opacity(self, opacity):
self.__min_opacity = opacity
@property
def max_opacity(self):
return self.__max_opacity
@max_opacity.setter
def max_opacity(self, opacity):
self.__max_opacity = opacity
@property
def margin_left(self):
return self.__margin_left
@margin_left.setter
def margin_left(self, margin):
self.__margin_left = margin
@property
def margin_top(self):
return self.__margin_top
@margin_top.setter
def margin_top(self, margin):
self.__margin_top = margin
@property
def clip(self):
return self.__clip
@clip.setter
def clip(self, value):
self.__clip = value
class Recorder(QMainWindow):
'''Main Window
- menu toolbar to load and save session, open plotter and set server
- dock widget holding session and run information
- grid plot to stream current emg data of 16 channels
- start, stop, progressbar and trigger for current run
'''
def __init__(self, parent=None):
super(Recorder, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.plotter = None
self.session = None
self.server = DelsysStation(parent=self)
self.ui.dockWidget.setWidget(QWidget())
self.dockLayout = QGridLayout(self.ui.dockWidget.widget())
self.showSessionMeta = None
self.showRunMeta = None
self.plotWidget = None
self.plots = []
self.startTime = datetime.now()
self.pinger = QTimer(self) # timer to read data from server whenever available
self.runPinger = QTimer(self) # timer to call stop when run duration times out
self.runPinger.setSingleShot(True)
self.runPinger.timeout.connect(self.stop)
self.pinger.timeout.connect(self.ping)
self.kinectRecorder=None
self.newpath=None
self.notSavedState = False
def clearDock(self):
''' clear session (dock widget elements)
- remove showSessionMeta
- remove showRunMeta
- kill kinectRecorder
- remove session
if changes are not saved, ask
'''
if self.showSessionMeta is not None:
reply = QMessageBox.question(self, 'QMessageBox.question()',
'Do you want to first save the current session?',
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.save()
elif reply == QMessageBox.Cancel:
return
self.session = None
self.dockLayout.removeWidget(self.showSessionMeta)
self.dockLayout.removeWidget(self.showRunMeta)
self.showSessionMeta.deleteLater()
self.showRunMeta.deleteLater()
self.showSessionMeta = None
self.showRunMeta = None
self.kinectRecorder.killRecorder()
def preparePlots(self):
'''arange 2x8 plots for each channel and
set parameters
'''
if self.ui.frame.layout() is None:
layout = QGridLayout()
self.ui.frame.setLayout(layout)
else:
#########
# reset #
#########
layout = self.ui.frame.layout()
layout.removeWidget(self.plotWidget)
self.plotWidget = None
self.plots = []
self.plotWidget = pg.GraphicsLayoutWidget(border=(100,100,100))
layout.addWidget(self.plotWidget)
for i in range(8):
for k in range(2):
self.plots.append(self.plotWidget.addPlot(title="EMG " + str(k+2*i+1)))
self.plots[-1].plot(np.linspace(0,2,1000))
self.plots[-1].setYRange(-0.0002, 0.0002)
self.plotWidget.nextRow()
self.plotWidget.show()
def setServer(self):
''' open dialog to set server address
e.g. localhost, 192.168.1.5
'''
text, ok = QInputDialog.getText(self, "Set server",
'Enter server adress')
if ok:
self.server.host = text
def newSession(self):
''' create new session:
- clear dock
- open dialog to set session parameters
- create showSessionMeta, showRunMeta, kinectRecorder
'''
self.clearDock()
sessionDialog = SessionDialog(self)
if sessionDialog.exec_():
newpath = os.path.join(sessionDialog.ui.leDir.text(), sessionDialog.ui.leName.text())
if not os.path.isdir(newpath):
os.makedirs(newpath)
else:
print('reusing folder')
QMessageBox.information(self, 'Warning!', '''You\'re reusing the subject folder''',
QMessageBox.Ok)
self.session = Session(sessionDialog.ui.leName.text(),
sessionDialog.ui.teBemerkung.toPlainText(),
newpath)
self.showSessionMeta = sessionView(self.session, self)
self.showRunMeta = RunWidget(self)
self.showRunMeta.ui.leCurrentRun.setText(str(len(self.session.runs)))
try:
self.kinectRecorder=KinectRecorder()
except:
print "no Kinect recording"
self.kinectRecorder = None
self.showSessionMeta.ui.showBemerkung.textChanged.connect(self.pendingSave)
self.showRunMeta.ui.lwRuns.itemDoubleClicked.connect(self.openPlotter)
self.dockLayout.addWidget(self.showSessionMeta)
self.dockLayout.addWidget(self.showRunMeta)
self.showRunMeta.show()
self.showSessionMeta.show()
self.preparePlots()
self.ui.tbStart.setEnabled(True)
def pendingSave(self):
self.notSavedState = True
self.setWindowTitle("PyTrigno(*)")
def save(self):
self.notSavedState = False
self.setWindowTitle("PyTrigno")
self.session.remarks = self.showSessionMeta.ui.showBemerkung.toPlainText()
self.session.dump("ReadMe.txt")
def startRun(self):
''' start a recording:
- setup server
- setup timer (if no eternity is toggled)
- setup progress bar
- setup buttons
- setup session
- start recorder
'''
#setup server
self.server.exitFlag = False
try:
self.startTime = datetime.now()
self.server.start()
except:
print("something went wrong")
self.server.exitFlag = True
raise socket.timeout("Could not connect to Delsys Station")
else:
if self.showRunMeta.ui.cbEternity.checkState() == 0:
duration = self.showRunMeta.ui.timeEdit.time()
d = duration.second() + duration.minute()*60
self.runPinger.start(d*1000)
self.ui.elapsedTime.setRange(0,d)
elif self.showRunMeta.ui.cbEternity.checkState() == 2:
self.ui.elapsedTime.setRange(0,0)
self.pinger.start()
self.ui.tbStop.setEnabled(True)
self.ui.tbTrigger.setEnabled(True)
self.ui.tbStart.setEnabled(False)
name = self.showRunMeta.ui.leCurrentRun.text()
self.session.addRun(name)
if self.kinectRecorder is not None:
self.kinectRecorder.startRecording(self.newpath+'\\'+name+'.oni')
self.ui.elapsedTime.setRange(0,d)
def stop(self):
''' stop recording due to button press or timeout
- setup buttons
- stop timers
- stop server
- kill kinectRecorder
- add item to list of runs
'''
self.ui.tbStop.setEnabled(False)
self.ui.tbTrigger.setEnabled(False)
self.ui.tbStart.setEnabled(True)
self.ui.elapsedTime.reset()
QListWidgetItem(self.showRunMeta.ui.leCurrentRun.text(),
self.showRunMeta.ui.lwRuns)
self.showRunMeta.ui.leCurrentRun.setText(str(len(self.session.runs)))
self.server.exitFlag = True
self.server.stop()
self.runPinger.stop()
self.pinger.stop()
self.session.stopRun(self.server.buffer)
self.server.buffer = None
if self.kinectRecorder is not None:
self.kinectRecorder.stopRecording()
self.server.flush()
def trigger(self):
''' add a trigger '''
print("trigger")
trigger = self.server.buffer[0].shape[1]
self.session.addTrigger(trigger)
def ping(self):
''' update progress bar and plots everytime
new data is available
'''
elapsed = int((datetime.now()-self.startTime).total_seconds())
self.ui.elapsedTime.setValue(elapsed)
for p in range(len(self.plots)):
if self.server.buffer[0].shape[1] < 5000:
self.plots[p].plot(self.server.buffer[0][p], clear=True)
else:
self.plots[p].plot(self.server.buffer[0][p,-5000:], clear=True)
def openPlotter(self, item=None):
if self.plotter is None:
self.plotter = Plotter()
if item is not None:
self.plotter.load([os.path.join(self.session.dir, item.text()) + ".pk"])
self.plotter.show()
def closeEvent(self, event):
if self.notSavedState:
reply = QMessageBox.question(self, 'QMessageBox.question()',
'Do you want to first save the current session?',
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
else:
reply = QMessageBox.No
if reply == QMessageBox.Yes:
self.save()
elif reply == QMessageBox.Cancel:
event.ignore()
return
if not self.server.exitFlag:
self.stop()
event.accept()
class MainWindow(QWidget):
def __init__(self, fixtures_folder, parent=None):
QWidget.__init__(self, parent)
self.current_fixture = None
self.fixtures_folder = fixtures_folder
self.setWindowTitle("Frangitron DMX program editor")
self.text = QPlainTextEdit()
font = QFont("Monospace")
font.setStyleHint(QFont.TypeWriter)
font.setPixelSize(16)
self.text.setFont(font)
self.text.setStyleSheet(
"color: white; background-color: rgb(30, 30, 30)")
self.combo_fixture = QComboBox()
self.frame_programs = QWidget()
self.checkboxes_programs = list()
self.layout_programs = QGridLayout(self.frame_programs)
self.spinner_offset = QSpinBox()
self.spinner_offset.setMinimum(1)
self.spinner_offset.setMaximum(512)
self.spinner_offset.setValue(1)
self.spinner_offset.valueChanged.connect(self.address_changed)
self.doc = QPlainTextEdit()
self.doc.setReadOnly(True)
self.doc.setFont(font)
self.status = QLabel()
layout = QGridLayout(self)
layout.addWidget(self.combo_fixture, 0, 1)
layout.addWidget(self.spinner_offset, 0, 2)
layout.addWidget(self.frame_programs, 1, 1)
layout.addWidget(self.text, 0, 0, 3, 1)
layout.addWidget(self.doc, 2, 1, 1, 2)
layout.addWidget(self.status, 3, 0, 1, 3)
layout.setColumnStretch(0, 60)
layout.setColumnStretch(1, 40)
self.resize(1280, 800)
self.streamer = Streamer(self.fixtures_folder)
self.combo_fixture.addItems(sorted(self.streamer.fixtures))
self.combo_fixture.currentIndexChanged.connect(self.fixture_changed)
self.timer = QTimer()
self.timer.timeout.connect(self.tick)
self.timer.start(500.0 / FRAMERATE)
self.should_reload = True
self.fixture_changed()
def selected_programs(self):
return [
chk.text() for chk in self.checkboxes_programs if chk.isChecked()
]
def update_programs(self):
selected_programs = self.selected_programs()
for checkbox_program in self.checkboxes_programs:
self.layout_programs.removeWidget(checkbox_program)
checkbox_program.deleteLater()
self.checkboxes_programs = list()
for i, program_name in enumerate(
sorted(self.current_fixture.programs.keys())):
column = i // 4
row = i % 4
new_checkbox = QCheckBox(program_name)
new_checkbox.setChecked(program_name in selected_programs)
self.layout_programs.addWidget(new_checkbox, row, column)
self.checkboxes_programs.append(new_checkbox)
def address_changed(self):
self.current_fixture.address = self.spinner_offset.value()
self.doc.setPlainText(self.current_fixture.doc())
self.update_programs()
def fixture_changed(self):
self.current_fixture = self.streamer.fixtures[
self.combo_fixture.currentText()]
self.address_changed()
self.streamer.reset_expressions()
with open(self.current_fixture.programs_filepath, 'r') as f_programs:
self.text.setPlainText(f_programs.read())
def tick(self):
if self.should_reload:
self.current_fixture.reload_programs()
self.update_programs()
self.streamer.reset_state()
program = PROGRAM.replace('__fixture__', self.current_fixture.name)
program = program.replace('__address__',
str(self.current_fixture.address))
program = program.replace(
'__programs__', ", ".join([
'"{}"'.format(prog) for prog in self.selected_programs()
]))
self.streamer.load(programs_source=program)
self.streamer.program_clicked("1")
else:
state = self.streamer.state
if state:
self.status.setStyleSheet(
"background-color: green; color: white; padding: 5px")
self.status.setText(state.context)
else:
self.status.setStyleSheet(
"background-color: red; color: white; padding: 5px")
self.status.setText("{} : {}".format(state.context,
state.exception))
if self.current_fixture is None: return
with open(self.current_fixture.programs_filepath,
'w') as f_programs:
f_programs.write(self.text.toPlainText())
self.should_reload = not self.should_reload
def closeEvent(self, event):
self.timer.stop()
self.streamer.load(programs_source="")
self.streamer.program_clicked("1")
sleep(2.0 / float(FRAMERATE))
self.streamer.stop()
event.accept()
class CombinoGUI(QtGui.QMainWindow):
stopGenSig = Signal()
def __init__(self, parent_l=None):
QtGui.QMainWindow.__init__(self, parent_l)
self.resize(width_g, height_g)
self.setFont(QtGui.QFont("Verdana"))
self.setWindowTitle("Combino GUI")
# ui
self.ui = Ui_MainWin()
self.ui.setupUi(self)
self.setWindowIcon(QtGui.QIcon("data/combinoGui.jpg"))
self.__dynamicDistribWidgets = []
self.__dynamicOddsWidgets = []
self.initDistribTab()
# self.initOddsTab()
self.ui.pbUpdate.clicked.connect(self.do_update)
self.ui.comboBookBox.activated[int].connect(self.do_changeBook)
self.ui.comboGridBox.activated[int].connect(self.do_changeGrid)
self.ui.pbGenerate.clicked.connect(self.do_generateInputGrid)
self.ui.pbGenerateGrid.clicked.connect(self.do_generateGrid)
self.ui.pbImport.clicked.connect(self.do_importGrid)
self.ui.pbExport.clicked.connect(self.do_exportGrid)
self.ui.pb1Browse.clicked.connect(self.do_browseDir)
self.ui.pbQuit.clicked.connect(self.do_quit)
self.ui.progressBar.hide()
self.ui.jackpotLine.editingFinished.connect(self.do_updateJackpot)
self.ui.nbPlayersLine.editingFinished.connect(self.do_updateNbPlayers)
self.__distribLayoutGridWidth = 0
self.__gridIndex = -1
self.__gridHandler = None
print "platform = %s" % platform
if platform == "linux" or platform == "linux2":
# linux
self.__gridRequestor = GridRequestor()
elif platform == "win32":
# Windows...
self.__gridRequestor = GridRequestorWin()
self.__gridRequestor.distribPageGenerated.sig.connect(self.do_handleDistribHtmlPage)
self.__nextAction = actions[0]
# other attribut
self.__gridHandlerFactory = ReadGridHandlerFactory()
self.__inputFileName = None
self.__outputDirName = ''.join((os.getcwd(), "/Output/"))
self.__buttonGenerate = None
self.__myBets = None
self.__teamDisplay = []
self.__progressionQueue = Queue()
self.__combinoEngine0 = None
self.__combinoEngine1 = None
self.__combinoEngine2 = None
self.ui.outputDirLine.setText(self.__outputDirName)
# fen_l = QtGui.QDesktopWidget().screenGeometry()
try:
self.setWindowIcon(QtGui.Icon("icon.jpg"))
except:
pass
# ################ Slots ######################
def do_receiveHtml3(self, reply):
print "do_receiveHtml3"
htmlPage = reply.readAll()
if self.__nextAction == 'CombinoGenOdds3':
print "handle odds ZUS"
self.__gridHandler.handleOddsHtmlPage(htmlPage, ReadGridHandler.ZULUBET_SOURCE)
self.ui.progressBar.hide()
self.updateDistribTab()
self.refreshJackpot()
self.refreshNbPlayers()
combinoManager = CombinoNetworkManager.Instance()
combinoManager.manager.finished[QNetworkReply].disconnect(self.do_receiveHtml3)
def do_receiveHtml2(self, reply):
print "do_receiveHtml2"
combinoManager = CombinoNetworkManager.Instance()
htmlPage = reply.readAll()
if self.__nextAction == 'CombinoGenOdds2':
print "handle odds ZUS"
self.__gridHandler.handleOddsHtmlPage(htmlPage, ReadGridHandler.ZULUBET_SOURCE)
self.__nextAction = 'CombinoGenOdds3'
combinoManager.setUrl(self.__gridHandler.oddsUrl2(1))
combinoManager.manager.finished[QNetworkReply].connect(self.do_receiveHtml3)
reponse = combinoManager.get() # send request
combinoManager.manager.finished[QNetworkReply].disconnect(self.do_receiveHtml2)
def do_receiveHtml(self, reply):
print "do_receiveHtml"
htmlPage = reply.readAll()
if self.__nextAction == 'CombinoGenBook':
self.__gridHandler.handleHtmlPage(htmlPage)
self.updateConfigTab()
elif self.__nextAction == 'CombinoGenOdds':
print "handle odds BES"
self.__gridHandler.handleOddsHtmlPage(htmlPage)
print "Generate Odds2"
self.__nextAction = 'CombinoGenOdds2'
combinoManager = CombinoNetworkManager.Instance()
combinoManager.setUrl(self.__gridHandler.oddsUrl2())
combinoManager.manager.finished[QNetworkReply].connect(self.do_receiveHtml2)
reponse = combinoManager.get() # send request
elif self.__nextAction == 'CombinoGenResult':
self.__gridHandler.handleHtmlPage(htmlPage)
self.updateConfigTab()
print "DISCONNECT"
combinoManager = CombinoNetworkManager.Instance()
combinoManager.manager.finished[QNetworkReply].disconnect(self.do_receiveHtml)
def do_exportGrid(self):
if self.__inputFileName == None:
inputDirName = ''.join((os.getcwd(), "/Input"))
outputFileName = ''.join((inputDirName, '/'))
list = (self.__gridHandler.gridList())
date = list[self.__gridIndex][0]
outputFileName = ''.join((outputFileName, self.__gridHandler.gridName()))
outputFileName = ''.join((outputFileName, "-"))
outputFileName = ''.join((outputFileName, str(date)))
outputFileName = ''.join((outputFileName, ".xls"))
self.__inputFileName = outputFileName
print "export file = %s" % self.__inputFileName
self.__gridHandler.grid().export(self.__inputFileName)
def do_importGrid(self):
print "input dir = %s" % ''.join((os.getcwd(), "/Input/"))
self.__inputFileName = \
QtGui.QFileDialog.getOpenFileName(self, "Open xls", ''.join((os.getcwd(), "/Input/")), "xls Files (*.xls)")[0]
print "Input file : %s" % self.__inputFileName
print "Lecture fichier Source"
self.__gridHandler = self.__gridHandlerFactory.createGridHandler(self.__inputFileName)
# mySource = CombinoSource(self.__inputFileName)
print "Read Grid = %s" % str(self.__gridHandler.grid())
mainWinText = self.__inputFileName
print "Import File =%s" % mainWinText
print "Import Title =%s" % mainWinText.split("/")[-1].split(".")[0]
self.setWindowTitle(mainWinText.split("/")[-1].split(".")[0])
self.updateDistribTab()
self.updateOddsTab()
self.refreshNbPlayers()
self.refreshJackpot()
def do_updateDataGrid(self):
print "do_updateDataGrid\n"
self.readDistribInput()
def do_changeGrid(self, index):
gridNumber = self.ui.comboGridBox.itemText(index)
mainWinText = self.__gridHandler.gridName() + " " + gridNumber
print "Title =%s" % mainWinText
self.setWindowTitle(mainWinText)
self.__gridHandler.changeGrid(index)
self.__gridIndex = index
def do_changeBook(self, index):
if index == 0:
self.__gridHandler = ReadWinamax7Handler()
elif index == 1:
self.__gridHandler = ReadWinamax12Handler()
print "Winamax 12"
elif index == 2:
print "LotoFoot 7"
self.__gridHandler = ReadLoto7Handler()
elif index == 3:
print "LotoFoot 15"
self.__gridHandler = ReadLoto15Handler()
elif index == 4:
print "Combino 5"
self.__gridHandler = ReadMini5Handler()
elif index == 5:
print "Euro 7"
self.__gridHandler = ReadEuro7Handler()
elif index == 6:
print "Betclic 5"
elif index == 7:
print "Betclic 8"
else:
print "index = %s" % index
# try :
combinoManager = CombinoNetworkManager.Instance()
combinoManager.setUrl(self.__gridHandler.bookUrl())
combinoManager.manager.finished[QNetworkReply].connect(self.do_receiveHtml)
# request.setAttribute(QNetworkRequest.RedirectionTargetAttribute, True)
reponse = combinoManager.get() # send request
def do_handleDistribHtmlPage(self, sourcePage):
# print(sourcePage)
self.ui.progressBar.hide()
self.__gridHandler.handleDistribHtmlPage(sourcePage.encode('utf-8'))
self.do_generateOdds()
def do_generateGrid(self):
outputFileName = self.__outputDirName
outputFileName1 = ""
outputFileName2 = ""
outputFileName0 = ""
try:
outputFileName = ''.join((self.__outputDirName, '/'))
list = (self.__gridHandler.gridList())
date = list[self.__gridIndex][0]
outputFileName = ''.join((outputFileName, self.__gridHandler.gridName()))
outputFileName = ''.join((outputFileName, "-"))
outputFileName = ''.join((outputFileName, str(date)))
outputFileName = ''.join((outputFileName, ".csv"))
except IndexError:
indexSlash = self.__inputFileName.rfind("/")
inputFileName = self.__inputFileName[indexSlash:]
outputFileName = ''.join((outputFileName, inputFileName[0:-3]))
outputFileName = ''.join((outputFileName, "csv"))
outputFileName1 = ''.join(( outputFileName, "_tmp1"))
outputFileName2 = ''.join(( outputFileName, "_tmp2"))
outputFileName0 = ''.join(( outputFileName, "_tmp0"))
print "tmpfiles = %s" % outputFileName0
print "tmpfiles = %s" % outputFileName1
print "tmpfiles = %s" % outputFileName2
self.__combinoEngine0 = CombinoEngine(self.__gridHandler.grid(), 1, outputFileName0, 0, self.__progressionQueue,
self)
self.__combinoEngine1 = CombinoEngine(self.__gridHandler.grid(), 1, outputFileName1, 1, self.__progressionQueue,
self)
self.__combinoEngine2 = CombinoEngine(self.__gridHandler.grid(), 1, outputFileName2, 2, self.__progressionQueue,
self)
# mainWindow_p.stopGenSig.connect(self.cancelGen)
print "Grid generation"
self.ui.progressBar.setMaximum(100)
self.ui.progressBar.setValue(0)
self.ui.progressBar.show()
self.__progressionQueue.put(0)
self.__combinoEngine0.start()
self.__combinoEngine1.start()
self.__combinoEngine2.start()
goOn = True
while goOn:
time.sleep(1)
self.on_progressed()
goOn = self.__combinoEngine0.is_alive()
goOn = goOn or self.__combinoEngine1.is_alive()
goOn = goOn or self.__combinoEngine2.is_alive()
self.ui.progressBar.hide()
# concat tmp files, and delete
filenames = [outputFileName0, outputFileName1, outputFileName2]
with open(outputFileName, 'w') as outfile:
for fname in filenames:
with open(fname) as infile:
for line in infile:
outfile.write(line)
os.remove(fname)
def do_generateOdds(self):
self.__nextAction = 'CombinoGenOdds'
print "Generate Odds"
print "requested url = %s" % self.__gridHandler.oddsUrl()
self.ui.progressBar.show()
combinoManager = CombinoNetworkManager.Instance()
combinoManager.setUrl(self.__gridHandler.oddsUrl())
combinoManager.manager.finished[QNetworkReply].connect(self.do_receiveHtml)
reponse = combinoManager.get() # send request
return
def do_generateInputGrid(self):
self.__nextAction = 'CombinoGenDistrib'
self.__gridRequestor.setUrl(self.__gridHandler.distribUrl())
print "requested url = %s" % self.__gridHandler.distribUrl()
self.ui.progressBar.show()
self.__gridRequestor.start()
return
def do_quit(self):
QtCore.QCoreApplication.instance().quit()
def do_updateNbPlayers(self):
print "do_updateNbPlayers slot"
if self.__gridHandler != None and self.__gridHandler.grid() != None:
try:
self.__gridHandler.grid().setNbPlayers(int(float(self.ui.nbPlayersLine.text())))
print "Nb Players modified : %2f" % self.__gridHandler.grid().nbPlayers()
except:
self.__gridHandler.grid().setNbPlayers(0)
def refreshNbPlayers(self):
self.ui.nbPlayersLine.setText("%.2f" % (self.__gridHandler.grid().nbPlayers()))
def do_updateJackpot(self):
print "do_updateJackpot slot"
if self.__gridHandler != None and self.__gridHandler.grid() != None:
try:
self.__gridHandler.grid().setJackpot(float(self.ui.jackpotLine.text()))
print "Jackpot modified : %2f" % self.__gridHandler.grid().jackpot()
except:
self.__gridHandler.grid().setJackpot(0)
def refreshJackpot(self):
self.ui.jackpotLine.setText("%.2f" % (self.__gridHandler.grid().jackpot()))
def do_update(self):
self.__nextAction = 'CombinoGenBook'
self.ui.comboBookBox.addItem("Winamax 7")
self.ui.comboBookBox.addItem("Winamax 12")
self.ui.comboBookBox.addItem("LotoFoot 7")
self.ui.comboBookBox.addItem("LotoFoot 15")
self.ui.comboBookBox.addItem("Mini 5")
self.ui.comboBookBox.addItem("Euro 7")
self.ui.comboBookBox.addItem("Betclic 5")
self.ui.comboBookBox.addItem("Betclic 8")
self.do_changeBook(0)
print "updated !"
def do_browseDir(self):
print "run dir = %s" % ''.join((os.getcwd(), "/Output/"))
outputDirName_l = QtGui.QFileDialog.getExistingDirectory(self, "Output directory",
''.join((os.getcwd(), "/Output/")),
QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontResolveSymlinks)
self.__outputDirName = outputDirName_l.replace("\\", "/")
self.ui.outputDirLine.setText(self.__outputDirName)
# self.ui.outputDirLine.adjustSize()
print "Output dir : %s" % self.__outputDirName
# ################ End Slots ######################
# def sendOddsRequest(self):
# for match in self.__grid:
def initDistribTab(self):
self.__gridDistribLayout = QGridLayout()
label1 = QLabel("Team1")
label2 = QLabel("Team2")
labelP1 = QLabel("1")
labelPN = QLabel("N")
labelP2 = QLabel("2")
labelPTot = QLabel("Total")
labelBarre = QLabel("|")
labelC1 = QLabel("1")
labelCN = QLabel("N")
labelC2 = QLabel("2")
labelCTot = QLabel("Total")
self.__gridDistribLayout.addWidget(label1, 0, 0)
self.__gridDistribLayout.addWidget(label2, 0, 1)
self.__gridDistribLayout.addWidget(labelP1, 0, 2)
self.__gridDistribLayout.addWidget(labelPN, 0, 4)
self.__gridDistribLayout.addWidget(labelP2, 0, 6)
self.__gridDistribLayout.addWidget(labelPTot, 0, 8)
self.__gridDistribLayout.addWidget(labelBarre, 0, 9)
self.__gridDistribLayout.addWidget(labelC1, 0, 10)
self.__gridDistribLayout.addWidget(labelCN, 0, 11)
self.__gridDistribLayout.addWidget(labelC2, 0, 12)
self.__gridDistribLayout.addWidget(labelCTot, 0, 13)
self.ui.DistribAndOdds.setLayout(self.__gridDistribLayout)
return
def cleanDistribTab(self):
for widget in self.__dynamicDistribWidgets:
self.__gridDistribLayout.removeWidget(widget)
widget.deleteLater()
self.__gridDistribLayout.removeWidget(self.ui.pbGenerateGrid)
def updateOddsTab(self):
return
def updateDistribTab(self):
self.cleanDistribTab()
size = int(self.__gridHandler.gridSize())
j = 0
for i in range(0, size):
self.__dynamicDistribWidgets.append(QLabel(self.__gridHandler.grid().getGame(i).team1()))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 0)
j += 1
self.__dynamicDistribWidgets.append(QLabel(self.__gridHandler.grid().getGame(i).team2()))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 1)
j += 1
self.__dynamicDistribWidgets.append(QLineEdit())
self.__dynamicDistribWidgets[j].setText(
"%.1f" % (self.__gridHandler.grid().getGame(i).getRepartition(0) * 100))
self.__dynamicDistribWidgets[j].editingFinished.connect(self.do_updateDataGrid)
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 2)
j += 1
self.__dynamicDistribWidgets.append(QLabel("%"))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 3)
j += 1
self.__dynamicDistribWidgets.append(QLineEdit())
self.__dynamicDistribWidgets[j].setText(
"%.1f" % (self.__gridHandler.grid().getGame(i).getRepartition(1) * 100))
self.__dynamicDistribWidgets[j].editingFinished.connect(self.do_updateDataGrid)
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 4)
j += 1
self.__dynamicDistribWidgets.append(QLabel("%"))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 5)
j += 1
self.__dynamicDistribWidgets.append(QLineEdit())
self.__dynamicDistribWidgets[j].setText(
"%.1f" % (self.__gridHandler.grid().getGame(i).getRepartition(2) * 100))
self.__dynamicDistribWidgets[j].editingFinished.connect(self.do_updateDataGrid)
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 6)
j += 1
self.__dynamicDistribWidgets.append(QLabel("%"))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 7)
j += 1
total = self.__gridHandler.grid().getGame(i).getRepartition(0)
total += self.__gridHandler.grid().getGame(i).getRepartition(1)
total += self.__gridHandler.grid().getGame(i).getRepartition(2)
self.__dynamicDistribWidgets.append(QLabel("%3.1f" % (total * 100)))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 8)
j += 1
self.__dynamicDistribWidgets.append(QLabel("|"))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 9)
j += 1
self.__dynamicDistribWidgets.append(QLineEdit())
self.__dynamicDistribWidgets[j].setText("%.2f" % (self.__gridHandler.grid().getGame(i).getCotes(0)))
self.__dynamicDistribWidgets[j].editingFinished.connect(self.do_updateDataGrid)
dispo = self.__gridHandler.grid().getGame(i).cotesDisponibles()
self.__dynamicDistribWidgets[j].setAutoFillBackground(not dispo)
palette = self.__dynamicDistribWidgets[j].palette()
palette.setColor(self.__dynamicDistribWidgets[j].backgroundRole(),
QColor(COLOR_COEF * (int(dispo) + 1) / 2, COLOR_COEF * (int(dispo) + 1) / 2,
COLOR_COEF * (int(dispo) + 1) / 2)) # red
self.__dynamicDistribWidgets[j].setPalette(palette)
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 10)
j += 1
self.__dynamicDistribWidgets.append(QLineEdit())
self.__dynamicDistribWidgets[j].setText("%.2f" % (self.__gridHandler.grid().getGame(i).getCotes(1)))
self.__dynamicDistribWidgets[j].editingFinished.connect(self.do_updateDataGrid)
dispo = self.__gridHandler.grid().getGame(i).cotesDisponibles()
self.__dynamicDistribWidgets[j].setAutoFillBackground(not dispo)
palette = self.__dynamicDistribWidgets[j].palette()
palette.setColor(self.__dynamicDistribWidgets[j].backgroundRole(),
QColor(COLOR_COEF * (int(dispo) + 1) / 2, COLOR_COEF * (int(dispo) + 1) / 2,
COLOR_COEF * (int(dispo) + 1) / 2)) # red
self.__dynamicDistribWidgets[j].setPalette(palette)
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 11)
j += 1
self.__dynamicDistribWidgets.append(QLineEdit())
self.__dynamicDistribWidgets[j].setText("%.2f" % (self.__gridHandler.grid().getGame(i).getCotes(2)))
self.__dynamicDistribWidgets[j].editingFinished.connect(self.do_updateDataGrid)
dispo = self.__gridHandler.grid().getGame(i).cotesDisponibles()
self.__dynamicDistribWidgets[j].setAutoFillBackground(not dispo)
palette = self.__dynamicDistribWidgets[j].palette()
palette.setColor(self.__dynamicDistribWidgets[j].backgroundRole(),
QColor(COLOR_COEF * (int(dispo) + 1) / 2, COLOR_COEF * (int(dispo) + 1) / 2,
COLOR_COEF * (int(dispo) + 1) / 2)) # red
self.__dynamicDistribWidgets[j].setPalette(palette)
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 12)
j += 1
try:
sigmaCotesMoinsUn = 1 / self.__gridHandler.grid().getGame(i).getCotes(
0) + 1 / self.__gridHandler.grid().getGame(i).getCotes(1) + 1 / self.__gridHandler.grid().getGame(
i).getCotes(2)
ret0 = 1 / (
self.__gridHandler.grid().getGame(i).getRepartition(0) * self.__gridHandler.grid().getGame(i).getCotes(
0) * sigmaCotesMoinsUn)
ret1 = 1 / (
self.__gridHandler.grid().getGame(i).getRepartition(1) * self.__gridHandler.grid().getGame(i).getCotes(
1) * sigmaCotesMoinsUn)
ret2 = 1 / (
self.__gridHandler.grid().getGame(i).getRepartition(2) * self.__gridHandler.grid().getGame(i).getCotes(
2) * sigmaCotesMoinsUn)
except ZeroDivisionError:
ret0 = 0
ret1 = 0
ret2 = 0
self.__dynamicDistribWidgets.append(QLabel("%1.2f" % sigmaCotesMoinsUn))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 13)
j += 1
self.__dynamicDistribWidgets.append(QLabel("|"))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 14)
j += 1
self.__dynamicDistribWidgets.append(QLabel("%2.2f" % ret0))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 15)
j += 1
self.__dynamicDistribWidgets.append(QLabel("%2.2f" % ret1))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 16)
j += 1
self.__dynamicDistribWidgets.append(QLabel("%2.2f" % ret2))
self.__gridDistribLayout.addWidget(self.__dynamicDistribWidgets[j], 1 + i, 17)
j += 1
self.__distribLayoutGridWidth = 18
self.__gridDistribLayout.addWidget(self.ui.pbGenerateGrid, size + 1, 0)
self.__gridDistribLayout.addWidget(self.ui.pbExport, size + 1, 17)
return
def readDistribInput(self):
size = int(self.__gridHandler.gridSize())
for i in range(0, size):
# try:
print "%s vs" % self.__gridHandler.grid().getGame(i).team1()
print "%s : " % self.__gridHandler.grid().getGame(i).team2()
distrib1 = float(self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 2].text())
print "%2.2f " % distrib1
distribN = float(self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 4].text())
print "%2.2f " % distribN
distrib2 = float(self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 6].text())
print "%2.2f | " % distrib2
self.__gridHandler.grid().getGame(i).setRepartition(distrib1, distribN, distrib2)
total = distrib1 + distrib2 + distribN
cote1 = float(self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 10].text())
print "%2.2f " % cote1
coteN = float(self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 11].text())
print "%2.2f " % coteN
cote2 = float(self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 12].text())
print "%2.2f " % cote2
self.__gridHandler.grid().getGame(i).setCotes(cote1, coteN, cote2)
sigmaCotesMoinsUn = 1 / cote1 + 1 / coteN + 1 / cote2
ret0 = 1 / (self.__gridHandler.grid().getGame(i).getRepartition(0) * cote1 * sigmaCotesMoinsUn)
ret1 = 1 / (self.__gridHandler.grid().getGame(i).getRepartition(1) * coteN * sigmaCotesMoinsUn)
ret2 = 1 / (self.__gridHandler.grid().getGame(i).getRepartition(2) * cote2 * sigmaCotesMoinsUn)
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 8].setText("%3.1f" % total)
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 8].repaint()
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 13].setText("%1.2f" % sigmaCotesMoinsUn)
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 13].repaint()
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 15].setText("%2.2f" % ret0)
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 15].repaint()
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 16].setText("%2.2f" % ret1)
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 16].repaint()
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 17].setText("%2.2f" % ret2)
self.__dynamicDistribWidgets[i * self.__distribLayoutGridWidth + 17].repaint()
# except:
# print "erreur de recup lors du %deme match" % i
def updateConfigTab(self):
# clean the comboGridBox
index = self.ui.comboGridBox.count()
while index != 0:
print "remove index %d" % index
self.ui.comboGridBox.removeItem(index - 1)
index = self.ui.comboGridBox.count()
# fill the comboGridBox with new values
index = 0
selected = False
now = QDateTime.currentMSecsSinceEpoch() / 1000 # in sec
print "now=%d" % now
for gridNumber in self.__gridHandler.gridList():
print "add grid n %s" % gridNumber[0]
try:
gridDateTime = QDateTime.fromMSecsSinceEpoch(int(gridNumber[1]) * 1000)
itemText = gridNumber[0]
itemText = ''.join((itemText, " "))
itemText = ''.join((itemText, gridDateTime.toString()))
except ValueError:
itemText = ''
# itemText = "{} {}".format(gridNumber[0], gridDateTime.toString())
# self.ui.comboGridBox.addItem(gridNumber[0])
self.ui.comboGridBox.addItem(itemText)
try:
if int(now) >= (int(gridNumber[1]) + (3600 * 24)):
print "disabled because date : %s" % gridNumber[1]
# self.ui.comboGridBox.model().item(index).setEnabled(False)
# self.ui.comboGridBox.model().item(index).setBackground(QBrush(Qt.grey))
elif not selected:
self.ui.comboGridBox.setCurrentIndex(index)
self.do_changeGrid(index)
selected = True
except ValueError:
pass
index += 1
def browseFile(self):
print "input dir = %s" % ''.join((os.getcwd(), "/Input/"))
self.__inputFileName = \
QtGui.QFileDialog.getOpenFileName(self, "Open xls", ''.join((os.getcwd(), "/Input/")), "xls Files (*.xls)")[
0]
# self.__inputFileName = QtGui.QFileDialog.getOpenFileName(self, "Open xls", os.getcwd(), "xls Files (*.xls)")
self.__labelInputFileName.setText(self.__inputFileName)
self.__labelInputFileName.adjustSize()
print "Input file : %s" % self.__inputFileName
if (self.__inputFileName != None) and (self.__outputDirName != None):
self.__buttonGenerate.setEnabled(True)
else:
self.__buttonGenerate.setEnabled(False)
def cancelGen(self):
self.stopGenSig.emit()
def on_progressed(self):
print "on_progressed"
if not self.__progressionQueue.empty():
progression = self.__progressionQueue.get()
self.__progressionQueue.put(progression)
# self.__progressionQueue.put(progression)
self.ui.progressBar.setValue(progression)
self.ui.progressBar.update()
print "%d pct" % progression
@Slot()
def on_finished(self):
self.__combinoEngine0.join()
self.__combinoEngine1.join()
self.__combinoEngine2.join()
self.ui.progressBar.hide()
