def run_worker(self):
"""
Executed the Worker in separate thread
"""
# exec(open('restarter.py').read())
# sys.exit()
self.update_session_state()
currentTime = QTime().currentTime()
fromTime = QTime(int(self.settings.TECHFROMHOUR),
int(self.settings.TECHFROMMIN))
toTime = QTime(int(self.settings.TECHTOHOUR),
int(self.settings.TECHTOMIN))
sessionState = self.lblMarket.text()
if fromTime < currentTime < toTime:
print("Worker skept-Technical break : ",
fromTime.toString("hh:mm"), " to ", toTime.toString("hh:mm"))
self.update_console("Technical break untill " +
toTime.toString("hh:mm"))
else:
self.update_console("Starting Worker- UI Paused")
self.uiTimer.stop(
) # to not cause an errors when lists will be resetted
worker = Worker(
self.ibkrworker.process_positions_candidates
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.update_ui)
worker.signals.status.connect(self.update_status)
worker.signals.notification.connect(self.update_console)
# Execute
self.threadpool.start(worker)
def run_worker(self):
"""
Executed the Worker in separate thread
"""
self.update_session_state()
currentTime = QTime().currentTime()
fromTime = QTime(int(self.settings.TECHFROMHOUR),
int(self.settings.TECHFROMMIN))
toTime = QTime(int(self.settings.TECHTOHOUR),
int(self.settings.TECHTOMIN))
sessionState = self.lblMarket.text()
if self.settings.USESERVER:
print("Reporting connection to the server...")
net_liquidation = self.ibkrworker.app.netLiquidation
if hasattr(self.ibkrworker.app, 'smaWithSafety'):
remaining_sma_with_safety = self.ibkrworker.app.smaWithSafety
else:
remaining_sma_with_safety = self.ibkrworker.app.sMa
remaining_trades = self.ibkrworker.app.tradesRemaining
all_positions_value = 0
open_positions = self.ibkrworker.app.openPositions
open_orders = self.ibkrworker.app.openOrders
dailyPnl = self.ibkrworker.app.dailyPnl
result = report_snapshot_to_server(
self.settings,
netLiquidation=net_liquidation,
smaWithSafety=remaining_sma_with_safety,
tradesRemaining=remaining_trades,
all_positions_values=all_positions_value,
openPositions=open_positions,
openOrders=open_orders,
dailyPnl=dailyPnl)
self.update_console(result)
if fromTime < currentTime < toTime:
print("Worker skept-Technical break : ",
fromTime.toString("hh:mm"), " to ", toTime.toString("hh:mm"))
self.update_console("Technical break untill " +
toTime.toString("hh:mm"))
else:
self.update_console("Starting Worker- UI Paused")
self.uiTimer.stop(
) # to not cause an errors when lists will be resetted
worker = Worker(
self.ibkrworker.process_positions_candidates
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.update_ui)
worker.signals.status.connect(self.update_status)
worker.signals.notification.connect(self.update_console)
# Execute
self.threadpool.start(worker)
def affTemp(self):
tempTotl = QTime(0, 0, 0)
tempTotl = tempTotl.addMSecs(self.mediaPlayer.duration() - self.mediaPlayer.position())
posTemp = QTime(0, 0, 0)
posTemp = posTemp.addMSecs((self.mediaPlayer.position()))
self.ui.tempRestant.setText("- {}".format(tempTotl.toString("HH:mm:ss")))
self.ui.tempLecture.setText(posTemp.toString("HH:mm:ss"))
self.ui.barreLect.setRange(0,self.mediaPlayer.duration())
def lectureEnCours(self):
mediaPosition = self.mediaPlayer.position()
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
mediaDuration = self.mediaPlayer.duration()
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(mediaDuration)
self.ui.ltemps.setText(currentTimeMedia.toString("HH:mm:ss"))
self.ui.lduree.setText(totalTimeMedia.toString("HH:mm:ss"))
self.ui.stpscourant.setRange(0, self.mediaPlayer.duration())
self.ui.stpscourant.setValue(self.mediaPlayer.position())
def add(self, url: QUrl, position: int = -1) -> bool:
if not url.isValid():
return False
media_info = MediaInfo.parse(url.toLocalFile())
track = media_info.tracks[0]
if track.title is None:
title = url.fileName()
else:
title = track.title
if track.duration is None:
duration_str = '--:--'
else:
duration = int(float(track.duration) / 1000)
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
(duration % 60), (duration * 1000) % 1000)
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
duration_str = totalTime.toString(format)
if position >= self.rowCount() or position < 0:
position = self.rowCount()
self.beginInsertRows(QModelIndex(), position, position + 1)
media_info = {'url': url, 'title': title, 'duration': duration_str}
self.item_list.insert(position, media_info)
self.endInsertRows()
self.rowCount_changed.emit(self.rowCount())
return True
class InUse(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = UiInUse()
self.ui.setupUi(self)
self.db = DataBase()
self.time = QTime(0, 0)
self.elapsed_timer = QElapsedTimer()
self.timer = QTimer(self)
self.info = {}
def update_time(self):
# TODO: Is there more clean way to show timer...?
self.ui.label_time.setText(
(self.time.addMSecs(self.elapsed_timer.elapsed())).toString("hh:mm:ss")
)
def set_page(self, contact):
self.info = self.db.get_info(contact)
self.elapsed_timer.start()
self.timer.timeout.connect(self.update_time)
self.timer.start(500)
self.ui.label_time.setText(self.time.toString("hh:mm:ss"))
self.ui.label_name.setText(self.info["name"] + " 님")
def clear_page(self):
self.timer.stop()
self.ui.label_time.setText("00:00:00")
self.ui.label_name.setText("???")
def avancee(self):
self.ui.sTpsCourant.valueChanged.disconnect(self.avanceSlider)
mediaPosition = self.mediaPlayer.position()
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.lAvanceeTps.setText(currentTimeMedia.toString("HH:mm:ss"))
self.ui.sTpsCourant.setValue(mediaPosition)
self.ui.sTpsCourant.valueChanged.connect(self.avanceSlider)
def mediaDurationChanged(self):
print("mediaLoaded")
self.ui.lTempsCourant.setText("00:00:00")
mediaDuration = self.mediaPlayer.duration()
self.ui.sTempsCourant.setRange(0, mediaDuration) ##########
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(mediaDuration)
self.ui.lTempsTotal.setText(totalTimeMedia.toString("HH:mm:ss"))
def mediapositionChange(self):
mediaPosition = self.mediaPlayer.position()
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.onceU.setText(currentTimeMedia.toString("HH:mm:ss"))
self.ui.slider.setRange(0, self.mediaPlayer.duration())
self.ui.slider.setValue(self.mediaPlayer.position())
def mediaPositionChanged(self):
self.ui.slTimeBarre.valueChanged.disconnect(self.timeBarreChanged)
mediaPosition = self.mediaPlayer.position()
self.ui.slTimeBarre.setValue(mediaPosition)
currentTime = QTime(0, 0, 0)
currentTime = currentTime.addMSecs(mediaPosition)
self.ui.lbTimeReal.setText(currentTime.toString("HH:mm:ss"))
self.ui.slTimeBarre.valueChanged.connect(self.timeBarreChanged)
def mediaPositionChanged(self):
self.ui.sTpsCourant.valueChanged.disconnect(self.sliderPositionChanged)
mediaPosition = self.mediaPlayer.position()
self.ui.sTpsCourant.setValue(mediaPosition) ##############
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.lTpsCourant.setText(currentTimeMedia.toString("HH:mm:ss"))
self.ui.sTpsCourant.valueChanged.connect(self.sliderPositionChanged)
def mediaDurationCnahged(self):
print("mediaLoaded")
self.ui.lTemps.setText("00:00:00") #12
mediaDuration = self.mediaPlayer.duration(
) #donne le temps en milisecondes
self.ui.sTimeLine.setRange(0, mediaDuration) #12
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(
mediaDuration) #convertir de milisecondes en H:m:s
self.ui.lTempsTotal.setText(totalTimeMedia.toString("HH:mm:ss"))
def mediaPositionChanged(self):
mediaPosition = self.mediaPlayer.position()
self.ui.timeline.setValue(mediaPosition)
currentTimeMedia = QTime(
0,
0,
0,
)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.debut.setText(currentTimeMedia.toString("HH:mm:ss"))
def mediaDurationChanged(self):
self.ui.debut.setText("00:00:00")
mediaDuration = self.mediaPlayer.duration(
) #recoit le temps total en Millisec
self.ui.timeline.setRange(
0, mediaDuration
) #découpe le timeline proportionnelement au temps en millisec
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(
mediaDuration) #convertit le temps total en h:m:s
self.ui.fin.setText(totalTimeMedia.toString("HH:mm:ss"))
def updateCurrentTime(self, currentInfo):
if currentInfo:
currentTime = QTime((currentInfo / 3600) % 60,
(currentInfo / 60) % 60, currentInfo % 60,
(currentInfo * 1000) % 1000)
format = 'hh:mm:ss' if self.duration > 3600 else 'mm:ss'
currentTimeStr = currentTime.toString(format)
else:
currentTimeStr = '00:00'
self.labelCurrentTime.setText(currentTimeStr)
def durationChanged(self, duration):
self.repeat_control.set_duration(duration)
duration /= 1000
self.duration = duration
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
(duration % 60), (duration * 1000) % 1000)
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
totalTimeStr = totalTime.toString(format)
self.labelTotalTime.setText(totalTimeStr)
self.seekBar.setMaximum(duration)
class InUse(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
# UI for the page
self.ui = Ui_InUse()
self.ui.setupUi(self)
# reader
self.reader = TestDatabaseReader()
self.userData = dict()
self.userTime = QTime(0, 0)
# Set timer
self.elapsedTimer = QElapsedTimer()
self.timer = QTimer(self)
self.ui.UsedTime.setText("00:00:00")
self.ui.UserName.setText("")
def updateTime(self):
self.ui.UsedTime.setText((self.userTime.addMSecs(
self.elapsedTimer.elapsed())).toString("hh:mm:ss"))
def setPage(self):
self.elapsedTimer.start()
self.timer.timeout.connect(self.updateTime)
self.timer.start(500)
self.userData = self.reader.getCurrentData()
self.userTime = QTime.fromString(self.userData["time_used"],
"hh:mm:ss")
self.ui.UsedTime.setText(self.userTime.toString("hh:mm:ss"))
self.ui.UserName.setText(self.userData["name"] + " 님")
def clearPage(self):
self.timer.stop()
self.ui.UsedTime.setText("00:00:00")
self.ui.UserName.setText("")
"""TODO: ADD CODES FOR WRITING CURRENT USERTIME TO DB HERE"""
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, settings):
# mandatory
QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.trading_session_state = "TBD"
self.est = timezone('US/Eastern')
self.settingsWindow = SettingsWindow()
self.setupUi(self)
self.settings = settings
self.ibkrworker = IBKRWorker(self.settings)
self.threadpool = QThreadPool()
self.setWindowTitle("Algo Traider v 2.0")
sys.stderr = open('LOG/errorLog.txt', 'w')
self.create_open_positions_grid()
# setting a timer for Worker
self.uiTimer = QTimer()
self.uiTimer.timeout.connect(self.update_ui)
self.workerTimer = QTimer()
self.workerTimer.timeout.connect(self.run_worker)
self.server_timer = QTimer()
self.server_timer.timeout.connect(self.report_to_server)
self.server_timer.start(int(self.settings.INTERVALSERVER) * 1000)
# connecting a buttons
self.chbxProcess.stateChanged.connect(self.process_checked)
self.btnSettings.pressed.connect(self.show_settings)
self.statusbar.showMessage("Ready")
stock_names = [o.ticker for o in self.settings.CANDIDATES]
self.ibkrworker.stocks_data_from_server = get_market_data_from_server(
self.settings, stock_names)
self.update_console("Market data for " + str(len(stock_names)) +
" Candidates received from Server")
self.start_updating_candidates_and_connect()
StyleSheet = '''
#lcdPNLgreen {
border: 3px solid green;
}
#lcdPNLred {
border: 3px solid red;
}
'''
self.setStyleSheet(StyleSheet)
def update_candidates_info(self, status_callback, notification_callback):
today_dt = date.today()
for c in self.ibkrworker.stocks_data_from_server:
updated_dt = c['tiprank_updated'].date()
if today_dt != updated_dt:
# yahoo
notification_callback.emit('Update for ' + c['ticker'] +
' needed:')
notification_callback.emit('Checking for Yahoo statisticks...')
drop, change = get_yahoo_stats_for_candidate(
c['ticker'], notification_callback)
c['yahoo_avdropP'] = drop
c['yahoo_avspreadP'] = change
notification_callback.emit('Got ' + str(drop) +
' average daily drop and ' +
str(change) +
' average daily change.')
# tipranks
notification_callback.emit('Checking for Tiprank...')
rank = get_tiprank_rating_for_ticker(
c['ticker'], self.settings.PATHTOWEBDRIVER)
notification_callback.emit('Got rank of :' + str(rank))
c['tipranks'] = rank
c['tiprank_updated'] = today_dt
else:
notification_callback.emit(
'Data for ' + c['ticker'] +
' is up to the date,no update needed')
report_market_data_to_server(self.settings,
self.ibkrworker.stocks_data_from_server)
return 'done'
def start_updating_candidates_and_connect(self):
cand = Worker(self.update_candidates_info)
cand.signals.result.connect(self.connect_to_ibkr)
# connector.signals.status.connect(self.update_status)
cand.signals.notification.connect(self.update_console)
# Execute
self.threadpool.start(cand)
def connect_to_ibkr(self):
"""
Starts the connection to the IBKR terminal in separate thread
"""
self.update_console("Reporting connection to the server...")
print("Reporting connection to the server...")
result = report_login_to_server(self.settings)
self.update_console(result)
connector = Worker(self.ibkrworker.prepare_and_connect)
connector.signals.result.connect(self.connection_done)
connector.signals.status.connect(self.update_status)
connector.signals.notification.connect(self.update_console)
# Execute
self.threadpool.start(connector)
def process_checked(self):
"""
Starts the Timer with interval from Config file
"""
if self.chbxProcess.isChecked():
self.run_worker()
self.workerTimer.start(int(self.settings.INTERVALWORKER) * 1000)
else:
self.workerTimer.stop()
# noinspection PyUnresolvedReferences
def run_worker(self):
"""
Executed the Worker in separate thread
"""
# exec(open('restarter.py').read())
# sys.exit()
self.update_session_state()
currentTime = QTime().currentTime()
fromTime = QTime(int(self.settings.TECHFROMHOUR),
int(self.settings.TECHFROMMIN))
toTime = QTime(int(self.settings.TECHTOHOUR),
int(self.settings.TECHTOMIN))
sessionState = self.lblMarket.text()
if fromTime < currentTime < toTime:
print("Worker skept-Technical break : ",
fromTime.toString("hh:mm"), " to ", toTime.toString("hh:mm"))
self.update_console("Technical break untill " +
toTime.toString("hh:mm"))
else:
self.update_console("Starting Worker- UI Paused")
self.uiTimer.stop(
) # to not cause an errors when lists will be resetted
worker = Worker(
self.ibkrworker.process_positions_candidates
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.update_ui)
worker.signals.status.connect(self.update_status)
worker.signals.notification.connect(self.update_console)
# Execute
self.threadpool.start(worker)
def connection_done(self):
# add processing
self.update_ui()
if self.settings.AUTOSTART:
self.chbxProcess.setChecked(True)
# # report market data to server
# if self.settings.USESERVER:
# print("Reporting market data to the server...")
# result = report_market_data_to_server(self.settings, self.ibkrworker.app.candidatesLive)
# self.update_console(result)
def report_to_server(self):
"""
reports to the server
"""
if self.settings.USESERVER:
net_liquidation = self.ibkrworker.app.netLiquidation
if hasattr(self.ibkrworker.app, 'smaWithSafety'):
remaining_sma_with_safety = self.ibkrworker.app.smaWithSafety
else:
remaining_sma_with_safety = self.ibkrworker.app.sMa
excess_liquidity = self.ibkrworker.app.excessLiquidity
remaining_trades = self.ibkrworker.app.tradesRemaining
all_positions_value = 0
open_positions = self.ibkrworker.app.openPositions
open_orders = self.ibkrworker.app.openOrders
dailyPnl = self.ibkrworker.app.dailyPnl
tradinng_session_state = self.trading_session_state
data_for_report = [
self.settings, net_liquidation, remaining_sma_with_safety,
remaining_trades, all_positions_value, open_positions,
open_orders, dailyPnl,
self.ibkrworker.last_worker_execution_time,
datetime.now(self.est), self.trading_session_state,
excess_liquidity
]
worker = Worker(report_snapshot_to_server, self.settings,
data_for_report)
worker.signals.result.connect(self.process_server_response)
# Execute
self.threadpool.start(worker)
def process_server_response(self, r):
# trying to restart
if '$restart$' in r:
restart()
self.update_console(r)
def update_ui(self):
"""
Updates UI after connection/worker execution
"""
# main data
self.lAcc.setText(self.settings.ACCOUNT)
# self.lExcessLiquidity.setText(str(self.ibkrworker.app.excessLiquidity))
# self.lSma.setText(str(self.ibkrworker.app.sMa))
if hasattr(self.ibkrworker.app, 'smaWithSafety'):
self.lSma.setText(str(round(self.ibkrworker.app.smaWithSafety, 1)))
else:
self.lSma.setText(str(round(self.ibkrworker.app.sMa, 1)))
self.lMarketValue.setText(str(self.ibkrworker.app.netLiquidation))
self.lblAvailTrades.setText(str(self.ibkrworker.app.tradesRemaining))
self.lcdPNL.display(self.ibkrworker.app.dailyPnl)
if self.ibkrworker.app.dailyPnl > 0:
palette = self.lcdPNL.palette()
palette.setColor(palette.WindowText, QtGui.QColor(51, 153, 51))
self.lcdPNL.setPalette(palette)
elif self.ibkrworker.app.dailyPnl < 0:
palette = self.lcdPNL.palette()
palette.setColor(palette.WindowText, QtGui.QColor(255, 0, 0))
self.lcdPNL.setPalette(palette)
total_positions_value = 0
for p in self.ibkrworker.app.openPositions.values():
if hasattr(p, 'Value'):
total_positions_value += p["Value"]
self.lPositionsTotalValue.setText(str(round(total_positions_value, 1)))
self.update_open_positions()
self.update_live_candidates()
self.update_open_orders()
# everything disabled for safety - is now enabled
self.chbxProcess.setEnabled(True)
self.btnSettings.setEnabled(True)
self.update_session_state()
if not self.uiTimer.isActive():
self.update_console("UI resumed.")
self.uiTimer.start(int(self.settings.INTERVALUI) *
1000) # reset the ui timer
def update_session_state(self):
fmt = '%Y-%m-%d %H:%M:%S'
self.est_dateTime = datetime.now(self.est)
self.est_current_time = QTime(self.est_dateTime.hour,
self.est_dateTime.minute,
self.est_dateTime.second)
self.lblTime.setText(self.est_current_time.toString())
dStart = QTime(4, 00)
dEnd = QTime(20, 00)
tStart = QTime(9, 30)
tEnd = QTime(16, 0)
self.ibkrworker.check_if_holiday()
if not self.ibkrworker.trading_session_holiday:
if self.est_current_time > dStart and self.est_current_time <= tStart:
self.ibkrworker.trading_session_state = "Pre Market"
self.lblMarket.setText("Pre Market")
elif self.est_current_time > tStart and self.est_current_time <= tEnd:
self.ibkrworker.trading_session_state = "Open"
self.lblMarket.setText("Open")
elif self.est_current_time > tEnd and self.est_current_time <= dEnd:
self.ibkrworker.trading_session_state = "After Market"
self.lblMarket.setText("After Market")
else:
self.ibkrworker.trading_session_state = "Closed"
self.lblMarket.setText("Closed")
else:
self.ibkrworker.trading_session_state = "Holiday"
self.lblMarket.setText("Holiday")
self.trading_session_state = self.ibkrworker.trading_session_state
def progress_fn(self, n):
msgBox = QMessageBox()
msgBox.setText(str(n))
retval = msgBox.exec_()
def update_status(self, s):
"""
Updates StatusBar on event of Status
:param s:
"""
self.statusbar.showMessage(s)
def update_console(self, n):
"""
Adds Message to console- upon event
:param n:
"""
self.consoleOut.append(n)
self.log_message(n)
def log_message(self, message):
"""
Adds message to the standard log
:param message:
"""
with open(LOGFILE, "a") as f:
currentDt = datetime.now().strftime("%d-%b-%Y (%H:%M:%S.%f)")
message = "\n" + currentDt + '---' + message
f.write(message)
def update_live_candidates(self):
"""
Updates Candidates table
"""
liveCandidates = self.ibkrworker.app.candidatesLive
try:
line = 0
self.tCandidates.setRowCount(len(liveCandidates))
for k, v in liveCandidates.items():
self.tCandidates.setItem(line, 0, QTableWidgetItem(v['Stock']))
self.tCandidates.setItem(line, 1,
QTableWidgetItem(str(v['Open'])))
self.tCandidates.setItem(line, 2,
QTableWidgetItem(str(v['Close'])))
self.tCandidates.setItem(line, 3,
QTableWidgetItem(str(v['Bid'])))
self.tCandidates.setItem(line, 4,
QTableWidgetItem(str(v['Ask'])))
if v['Ask'] < v['target_price'] and v['Ask'] != -1:
self.tCandidates.item(line, 4).setBackground(
QtGui.QColor(0, 255, 0))
if v['target_price'] is float:
self.tCandidates.setItem(
line, 5,
QTableWidgetItem(str(round(v['target_price'], 2))))
else:
self.tCandidates.setItem(
line, 5, QTableWidgetItem(str(v['target_price'])))
self.tCandidates.setItem(
line, 6,
QTableWidgetItem(str(round(v['averagePriceDropP'], 2))))
if v['tipranksRank'] == '':
v['tipranksRank'] = 0
self.tCandidates.setItem(
line, 7, QTableWidgetItem(str(v['tipranksRank'])))
if int(v['tipranksRank']) > 7:
self.tCandidates.item(line, 7).setBackground(
QtGui.QColor(0, 255, 0))
self.tCandidates.setItem(
line, 8, QTableWidgetItem(str(v['LastUpdate'])))
line += 1
except Exception as e:
if hasattr(e, 'message'):
self.update_console("Error in updating Candidates: " +
str(e.message))
else:
self.update_console("Error in updating Candidates: " + str(e))
def update_open_positions(self):
"""
Updates Positions grid
"""
open_positions = self.ibkrworker.app.openPositions
allKeys = [*open_positions]
lastUpdatedWidget = 0
try:
for i in range(len(open_positions)): # Update positions Panels
widget = self.gp.itemAt(i).widget()
key = allKeys[i]
values = open_positions[key]
if 'stocks' in values.keys():
if values['stocks'] != 0:
candidate = next((x for x in self.settings.CANDIDATES
if x.ticker == key), None)
reason_of_candidate = "Bought manually"
if candidate is not None:
reason_of_candidate = candidate.reason
widget.update_view(key, values, reason_of_candidate)
widget.show()
lastUpdatedWidget = i
else:
widgetToRemove = self.gp.itemAt(i).widget()
widgetToRemove.hide()
else:
print("value not yet received")
for i in range(self.gp.count()): # Hide the rest of the panels
if i > lastUpdatedWidget:
widgetToRemove = self.gp.itemAt(i).widget()
widgetToRemove.hide()
except Exception as e:
if hasattr(e, 'message'):
self.update_console("Error in refreshing Positions: " +
str(e.message))
else:
self.update_console("Error in refreshing Positions: " + str(e))
def create_open_positions_grid(self):
"""
Creates Open positions grid with 99 Positions widgets
"""
counter = 0
col = 0
row = 0
for i in range(0, 99):
if counter % 3 == 0:
col = 0
row += 1
self.gp.addWidget(PositionPanel(), row, col)
counter += 1
col += 1
def update_open_orders(self):
"""
Updates Positions table
"""
openOrders = self.ibkrworker.app.openOrders
try:
line = 0
self.tOrders.setRowCount(len(openOrders))
for k, v in openOrders.items():
self.tOrders.setItem(line, 0, QTableWidgetItem(k))
self.tOrders.setItem(line, 1, QTableWidgetItem(v['Action']))
self.tOrders.setItem(line, 2, QTableWidgetItem(v['Type']))
line += 1
except Exception as e:
if hasattr(e, 'message'):
self.update_console("Error in Updating open Orders : " +
str(e.message))
else:
self.update_console("Error in Updating open Orders : " +
str(e))
def thread_complete(self):
"""
After threaded task finished
"""
print("TREAD COMPLETE (good or bad)!")
def show_settings(self):
# self.settingsWindow = SettingsWindowO(self.settings)
# self.settingsWindow.show() # Показываем окно
# # maybe not needed
# self.settingsWindow.changedSettings = False
self.settingsWindow.existingSettings = copy.deepcopy(self.settings)
self.settingsWindow.changedSettings = False
self.settingsWindow.ibkrClient = self.ibkrworker
if self.settingsWindow.exec_():
self.settings = self.settingsWindow.existingSettings
self.settings.write_config()
self.restart_all()
else:
print("Settings window Canceled")
self.settingsWindow = SettingsWindow()
def restart_all(self):
"""
Restarts everything after Save
"""
self.threadpool.waitForDone()
self.update_console("UI paused- for restart")
self.uiTimer.stop()
self.workerTimer.stop()
self.update_console("Configuration changed - restarting everything")
self.chbxProcess.setEnabled(False)
self.chbxProcess.setChecked(False)
self.btnSettings.setEnabled(False)
self.ibkrworker.app.disconnect()
while self.ibkrworker.app.isConnected():
print("waiting for disconnect")
time.sleep(1)
self.ibkrworker = None
self.ibkrworker = IBKRWorker(self.settings)
self.connect_to_ibkr()
i = 4
def stopClicked(self):
print("Stop !")
self.mediaPlayer.stop()
totalTimeMedia = QTime(0, 0, 0)
self.ui.lTempsTotal.setText(totalTimeMedia.toString("HH:mm:ss"))
def positionChanged(self, position):
self.positionSlider.setValue(position)
mtime = QTime(0, 0, 0, 0)
mtime = mtime.addMSecs(self.mediaPlayer.position())
self.lbl.setText(mtime.toString())
def mediaDurationChanged(self):
mediaDuration = self.mediaPlayer.duration()
self.ui.slTimeBarre.setRange(0, mediaDuration)
totTime = QTime(0, 0, 0)
totTime = totTime.addMSecs(mediaDuration)
self.ui.lbTimeTot.setText(totTime.toString("HH:mm:ss"))
def mediaPositionCnahged(self):
mediaPosition = self.mediaPlayer.position()
self.ui.sTimeLine.setValue(mediaPosition) #12
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.lTemps.setText(currentTimeMedia.toString("HH:mm:ss"))
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
mtime = QTime(0, 0, 0, 0)
mtime = mtime.addMSecs(self.mediaPlayer.duration())
self.elbl.setText(mtime.toString())
def updateStopWatchLabel(self):
elapsed = QTime(0, 0).addMSecs(self.time.elapsed())
self.stopwatchLabel.setText(elapsed.toString())
def mediaDurationChange(self):
print("medialoaded")
mediaDuration = self.mediaPlayer.duration()
ttalTimeMedia = QTime(0, 0, 0)
ttalTimeMedia = ttalTimeMedia.addMSecs(mediaDuration)
self.ui.toBe.setText(ttalTimeMedia.toString("HH:mm:ss"))
def duree(self):
mediaDuration = self.mediaPlayer.duration()
self.ui.sTpsCourant.setRange(0, mediaDuration)
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(mediaDuration)
self.ui.lRestantTps.setText(totalTimeMedia.toString("HH:mm:ss"))
