def download_data(self):
"""
Loads data from data object. If the data object is empty, it downloads it.
"""
self.backtestDownloadDataButton.setEnabled(False)
self.backtestImportDataButton.setEnabled(False)
self.backtestStopDownloadButton.setEnabled(True)
self.set_download_progress(progress=0,
message="Downloading data...",
caller=-1)
symbol = self.backtestTickerComboBox.currentText()
interval = helpers.convert_long_interval(
self.backtestIntervalComboBox.currentText())
thread = downloadThread.DownloadThread(symbol=symbol,
interval=interval)
thread.signals.progress.connect(self.set_download_progress)
thread.signals.finished.connect(self.set_downloaded_data)
thread.signals.error.connect(self.handle_download_failure)
thread.signals.restore.connect(self.restore_download_state)
thread.signals.locked.connect(
lambda: self.backtestStopDownloadButton.setEnabled(False))
self.downloadThread = thread
self.threadPool.start(thread)
def initiate_csv_generation(self):
"""
Starts download of data and CSV generation.
"""
symbol = self.csvGenerationTicker.text()
descending = self.descendingDateRadio.isChecked()
armyTime = self.armyDateRadio.isChecked()
interval = helpers.convert_long_interval(
self.csvGenerationDataInterval.currentText())
selectedDate = self.startDateCalendar.selectedDate().toPyDate()
startDate = None if selectedDate == self.currentDateList[
0] else selectedDate
self.csvGenerationStatus.setText("Downloading data...")
thread = DownloadThread(interval,
symbol,
descending,
armyTime,
startDate,
logger=self.parent.logger)
thread.signals.locked.connect(
lambda: self.stopButton.setEnabled(False))
thread.signals.csv_finished.connect(self.end_csv_generation)
thread.signals.error.connect(self.handle_csv_generation_error)
thread.signals.restore.connect(self.restore_csv_state)
thread.signals.progress.connect(self.progress_update)
thread.signals.started.connect(self.disable_csv_state)
self.csvThread = thread
self.threadPool.start(thread)
def test_convert_long_interval(interval: str, expected: str):
"""
Test conversions from big interval to small interval.
:param interval: Big interval.
:param expected: Converted small interval.
"""
assert convert_long_interval(
interval
) == expected, f"Expected converted interval to be: {expected}."
def create_trader(self, caller):
"""
Creates a trader based on caller specified.
:param caller: Caller that determines what type of trader will be created.
"""
gui = self.gui
configDict = gui.interfaceDictionary[caller]['configuration']
symbol = configDict['ticker'].currentText()
precision = configDict['precision'].value()
prettyInterval = configDict['interval'].currentText()
interval = helpers.convert_long_interval(prettyInterval)
if caller == SIMULATION:
startingBalance = gui.configuration.simulationStartingBalanceSpinBox.value()
self.signals.activity.emit(caller, f"Retrieving {symbol} data for {prettyInterval.lower()} intervals...")
gui.simulationTrader = SimulationTrader(startingBalance=startingBalance,
symbol=symbol,
interval=interval,
loadData=True,
updateData=False,
precision=precision)
gui.simulationTrader.dataView.custom_get_new_data(progress_callback=self.signals.progress, removeFirst=True,
caller=SIMULATION)
elif caller == LIVE:
apiSecret = gui.configuration.binanceApiSecret.text()
apiKey = gui.configuration.binanceApiKey.text()
tld = 'com' if gui.configuration.otherRegionRadio.isChecked() else 'us'
isIsolated = gui.configuration.isolatedMarginAccountRadio.isChecked()
self.check_api_credentials(apiKey=apiKey, apiSecret=apiSecret)
self.signals.activity.emit(caller, f"Retrieving {symbol} data for {prettyInterval.lower()} intervals...")
gui.trader = RealTrader(apiSecret=apiSecret,
apiKey=apiKey,
interval=interval,
symbol=symbol,
tld=tld,
isIsolated=isIsolated,
loadData=True,
updateData=False,
precision=precision)
gui.trader.dataView.custom_get_new_data(progress_callback=self.signals.progress, removeFirst=True,
caller=LIVE)
else:
raise ValueError("Invalid caller.")
self.trader: SimulationTrader = self.gui.get_trader(caller)
self.trader.addTradeCallback = self.signals.addTrade # Passing an add trade call black.
self.trader.dataView.callback = self.signals.activity # Passing activity signal to data object.
self.trader.dataView.caller = caller # Passing caller to data object.
if not self.trader.dataView.downloadCompleted:
raise RuntimeError("Download failed.")
self.signals.activity.emit(caller, "Retrieved data successfully.")
if configDict['lowerIntervalCheck'].isChecked():
self.initialize_lower_interval_trading(caller=caller, interval=interval)
def get_start_date_for_csv(self):
symbol = self.csvGenerationTicker.currentText()
interval = helpers.convert_long_interval(self.csvGenerationDataInterval.currentText())
ts = Data(loadData=False, log=False).binanceClient._get_earliest_valid_timestamp(symbol, interval)
startDate = datetime.fromtimestamp(int(ts) / 1000, tz=timezone.utc)
qStart = QDate(startDate.year, startDate.month, startDate.day)
endDate = datetime.now(tz=timezone.utc)
qEnd = QDate(endDate.year, endDate.month, endDate.day)
return [qStart, qEnd]
def get_start_date_for_csv(self) -> List[QDate]:
"""
Find start date by instantiating a Data object and fetching the Binance API.
"""
symbol = self.csvGenerationTicker.text()
interval = helpers.convert_long_interval(self.csvGenerationDataInterval.currentText())
ts = Data(loadData=False, log=False).binanceClient._get_earliest_valid_timestamp(symbol, interval)
startDate = datetime.fromtimestamp(int(ts) / 1000, tz=timezone.utc)
qStart = QDate(startDate.year, startDate.month, startDate.day)
endDate = datetime.now(tz=timezone.utc)
qEnd = QDate(endDate.year, endDate.month, endDate.day)
return [qStart, qEnd]
def get_start_date_for_csv(self) -> List[QDate]:
"""
Find start date by instantiating a Data object and fetching the Binance API.
"""
symbol = self.csvGenerationTicker.text()
interval = convert_long_interval(
self.csvGenerationDataInterval.currentText())
# pylint: disable=protected-access
ts = algobot.BINANCE_CLIENT._get_earliest_valid_timestamp(
symbol, interval)
startDate = datetime.fromtimestamp(int(ts) / 1000, tz=timezone.utc)
qStart = QDate(startDate.year, startDate.month, startDate.day)
endDate = datetime.now(tz=timezone.utc)
qEnd = QDate(endDate.year, endDate.month, endDate.day)
return [qStart, qEnd]
def __init__(self,
periods,
interval,
volatility,
tickers,
filter_word=None):
super(VolatilitySnooperThread, self).__init__()
self.periods = periods
self.long_interval = interval
self.short_interval = convert_long_interval(interval)
self.volatility = volatility
self.volatility_func = self.get_volatility_func()
self.filter_word = filter_word
self.tickers = self.get_filtered_tickers(tickers=tickers,
filter_word=filter_word)
self.binanceClient = algobot.BINANCE_CLIENT
self.running = True
self.signals = VolatilitySnooperSignals()
def download_data(config_obj, caller: int = BACKTEST):
"""
Loads data from data object. If the data object is empty, it downloads it.
:param config_obj: Configuration QDialog object (from configuration.py)
:param caller: Caller that'll determine who called this function -> OPTIMIZER or BACKTEST
"""
config_obj.optimizer_backtest_dict[caller]['downloadButton'].setEnabled(False)
config_obj.optimizer_backtest_dict[caller]['importButton'].setEnabled(False)
set_download_progress(config_obj, progress=0, message="Attempting to download...", caller=caller, enableStop=False)
symbol = config_obj.optimizer_backtest_dict[caller]['tickers'].text()
interval = helpers.convert_long_interval(config_obj.optimizer_backtest_dict[caller]['intervals'].currentText())
thread = downloadThread.DownloadThread(symbol=symbol, interval=interval, caller=caller, logger=config_obj.logger)
thread.signals.progress.connect(lambda progress, msg: set_download_progress(config_obj=config_obj, message=msg,
progress=progress, caller=caller))
thread.signals.finished.connect(lambda data, *_: set_downloaded_data(config_obj, data=data, caller=caller))
thread.signals.error.connect(lambda e, *_: handle_download_failure(config_obj=config_obj, caller=caller, e=e))
thread.signals.restore.connect(lambda: restore_download_state(config_obj=config_obj, caller=caller))
thread.signals.locked.connect(lambda:
config_obj.optimizer_backtest_dict[caller]['stopDownloadButton'].setEnabled(False))
config_obj.optimizer_backtest_dict[caller]['downloadThread'] = thread
config_obj.threadPool.start(thread)
def test_convert_long_interval(interval: str, expected: str):
assert convert_long_interval(
interval
) == expected, f"Expected converted interval to be: {expected}."
