def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### specificConfig = self.config.get('SpecificConfig') if not specificConfig: recordDone = Record(None, message='Config missing') self.return_queue.put(recordDone) return filename = None output = None for attrs in specificConfig: if attrs['Name'] == 'Filename': filename = attrs['Data'] if self.inputData is None: recordDone = Record(None, message='No input provided') self.return_queue.put(recordDone) return con = sqlite3.connect(filename) if not con: raise Exception('Can not connect to database') cur = con.cursor() try: cur.execute(self.inputData) except Exception as e: recordDone = Record(PythonicError(e), 'Query failed') self.return_queue.put(recordDone) con.close() return output = cur.fetchall() con.commit() con.close() recordDone = Record(output, 'Query successful') self.return_queue.put(recordDone)
def intervalScheduler(self): countdown = self.interval / self.tick while True: bExit = self.blockAndWait() if bExit: return countdown -= 1 if countdown <= 0: countdown = self.interval / self.tick recordDone = Record( data=None, message='>Trigger< ProcHdl::{:04d}'.format( self.config['Identifier'])) self.return_queue.put(recordDone) else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext)
def execute(self): df_in = pd.DataFrame( self.inputData, columns=['close_time', 'open', 'high', 'low', 'close', 'volume']) df_in['close_time'] = df_in['close_time'].floordiv( 1000) # remove milliseconds from timestamp file_path = Path.home() / 'Pythonic' / 'executables' / 'ADAUSD_5m.df' try: # load existing dataframe df = pd.read_pickle(file_path) # count existing rows n_row_cnt = df.shape[0] # concat latest OHLCV data df = pd.concat([df, df_in], ignore_index=True).drop_duplicates(['close_time']) df.reset_index(drop=True, inplace=True) # calculate number of new rows n_new_rows = df.shape[0] - n_row_cnt log_txt = '{}: {} new rows written'.format(file_path, n_new_rows) except Exception as e: log_txt = 'File error - writing new one' df = df_in df.to_pickle(file_path) logInfo = Record(None, log_txt) self.return_queue.put(logInfo)
def atSpecificTime(self): ############################ # At specific time # ############################ if not self.activeDays: return nState = 0 while True: if nState == 0: # Init: Get the day offset dayOffset = self.getDayOffset(self.activeDays, self.specTime) nState = 1 continue elif nState == 1: # Init: Calculate timedelta delta_t = datetime.combine(date.today(), self.specTime) - datetime.now() delta_t = delta_t + timedelta(days=dayOffset) nState = 2 continue elif nState == 2: # Init: Prepare countdown and tick countdown = delta_t.seconds + (delta_t.days * 86400) self.tick = 1 nState = 3 continue elif nState == 3: # Wait for the start if countdown <= 0: recordDone = Record( data=None, message='>Trigger< ProcHdl::{:04d}'.format( self.config['Identifier'])) self.return_queue.put(recordDone) nState = 0 # Go to interval mode else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) countdown -= 1 bExit = self.blockAndWait() if bExit: return
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### recordDone = Record(ProcCMD(None, bStop=True), 'Sending Stop command') self.return_queue.put(recordDone)
def message(update, context): context.bot.send_message(chat_id=update.effective_chat.id, text='Message received') msg = update.message.text record = Record( update.message, 'Message received from: {}, MsgId.: {:d}'.format( update.message.from_user.first_name, update.message.message_id)) self.return_queue.put(record)
def pwmLedWorkerCtrl(self, cmd=None): if cmd is None: return try: self.gpio.value = cmd.data except Exception: self.gpio.close() raise self.return_queue.put( Record( None, 'PWMLED: Set brightness on GPIO{} to {:.2f}'.format( self.gpio.pin.number, cmd.data)))
def execute(self): # Raspberry Pi only #cpu_temp = os.popen("vcgencmd measure_temp").readline().replace("temp=", "").replace("'C\n", "") #cpu_temp = float(cpu_temp) # Generate random temperature cpu_temp = randrange(450, 500) cpu_temp = float(cpu_temp / 10) output = 'INSERT INTO my_table VALUES ({}, {})'.format( int(time.time()), cpu_temp) recordDone = Record(output) self.return_queue.put(recordDone)
def execute(self): output = None # only create a output if a report request was received # if a PythonicError type is received do nothing if self.inputData == '5m': t0 = int(time.time()) # get current unix time t1 = t0 - (60 * 5) # calculate unix stamp time 5 minutes ago output = 'SELECT * FROM my_table WHERE timestamp BETWEEN {} AND {}'.format( t1, t0) recordDone = Record(output) self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### cmd = None cnt = 0 ##################################### # # # Start of the infinite loop # # # ##################################### # The example executes an infinite loop till it's receives a stop command while(True): # Example code: Do something cnt+=1 try: # Block for 1 second and wait for incoming commands cmd = self.cmd_queue.get(block=True, timeout=1) except queue.Empty: pass if isinstance(cmd, ProcCMD) and cmd.bStop: # Stop command received, exit return # Example Code: Send status text to GUI every timeout interval guitext = GuiCMD('cnt: {}'.format(cnt)) self.return_queue.put(guitext) # Example code: Send data to element output every 5 x timeout if cnt % 5 == 0: # Recors(data, message) recordDone = Record(cnt, 'ID: 0x{:08x} - Sending value of cnt: {}'.format(self.id, cnt)) self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### cmd = None cnt = 0 ##################################### # # # Start of the infinite loop # # # ##################################### # The example executes an infinite loop till it's receives a stop command while (True): # Example code: Do something try: # Block for 1 second and wait for incoming commands cmd = self.cmd_queue.get(block=True, timeout=1) except queue.Empty: pass if isinstance(cmd, ProcCMD): if cmd.bStop: # Stop command received, exit return else: # Example Code: Send number of received data packets to GUI cnt += 1 guitext = GuiCMD('Data received: {}'.format(cnt)) self.return_queue.put(guitext) cmd.data += 1 # Example Code: Increment received data by one and forward it to subsequent elements recordDone = Record( cmd.data, 'Sending value of cnt: {}'.format(cmd.data)) self.return_queue.put(recordDone) cmd = None
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### output = "Hello" ######################################### # # # The execution exits immediately # # after providing output data # # # ######################################### recordDone = Record(output, 'Sending value of cnt: {}'.format(output)) self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### if self.inputData is None: output = 0 else: output = self.inputData + 1 ######################################### # # # The execution exits immediately # # after providing output data # # # ######################################### recordDone = Record(output, 'Sending value of cnt: {}'.format(output)) self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### # list all tables # SELECT name FROM sqlite_master WHERE type='table' # create table of not exist # CREATE TABLE IF NOT EXISTS my_table (timestamp INTEGER PRIMARY KEY NOT NULL, value UNSIGNED BIG INT); # insert into table # INSERT INTO my_table VALUES (?, ?) # # epoch in seconds: int(timer.time()) # random int: randrange(999) # Read from table several rows # SELECT * FROM my_table WHERE timestamp BETWEEN {} AND {}'.format( int(time.time())-12000, int(time.time()) ) # Sumup severals rows # SELECT SUM(value) FROM mytable WHERE timestamp BETWEEN {} AND {} output = 'SELECT SUM(value) FROM my_table WHERE timestamp BETWEEN {} AND {}'.format( int(time.time()) - 12000, int(time.time())) ######################################### # # # The execution exits immediately # # after providing output data # # # ######################################### recordDone = Record(output, 'Sending value of cnt: {}'.format(output)) self.return_queue.put(recordDone)
def singleFireDelayed(self): ############################ # Single fire, delayed # ############################ countdown = self.interval / self.tick while countdown > 0: guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) bExit = self.blockAndWait() if bExit: return countdown -= 1 recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### cmd = None specificConfig = self.config.get('SpecificConfig') chat_ids = SetPersist('chat_ids') def getTargetState(no: int, btn: bool): btnText = 'Switch GPIO {} {}'.format(no, GPIO_State(not btn).name) cbData = '{}{}'.format(no, GPIO_State(not btn).name) return btnText, cbData self.gpio4_state = GPIO_State.Off.value self.gpio5_state = GPIO_State.Off.value btnText, cbData = getTargetState(4, self.gpio4_state) self.gpio4_button = InlineKeyboardButton(text=btnText, callback_data=cbData) btnText, cbData = getTargetState(5, self.gpio5_state) self.gpio5_button = InlineKeyboardButton(text=btnText, callback_data=cbData) self.keyboard = InlineKeyboardMarkup.from_column( [self.gpio4_button, self.gpio5_button]) if not specificConfig: recordDone = Record(None, message='Config missing') self.return_queue.put(recordDone) return token = next(attr['Data'] for attr in specificConfig if attr['Name'] == 'Token') if not token: recordDone = Record(None, message='Token missing') self.return_queue.put(recordDone) return updater = Updater(token=self.config['SpecificConfig'][0]['Data'], use_context=True) dispatcher = updater.dispatcher def start(update: Update, context: CallbackContext): chat_ids.add(update.message.chat_id) context.bot.sendMessage(update.effective_chat.id, 'Start remote control GPIO', reply_markup=self.keyboard) def unknown(update, context): context.bot.send_message( chat_id=update.effective_chat.id, text='Sorry, I didn\'t understand that command.') def message(update, context): context.bot.send_message(chat_id=update.effective_chat.id, text='Message received') msg = update.message.text record = Record( update.message, 'Message received from: {}, MsgId.: {:d}'.format( update.message.from_user.first_name, update.message.message_id)) self.return_queue.put(record) def callback(update: Update, context: CallbackContext): gpio_number = int(update.callback_query.data[0]) gpio_state = update.callback_query.data[1:] gpio_state = GPIO_State[gpio_state].value btnText, cbData = getTargetState(gpio_number, gpio_state) if gpio_number == 4: self.gpio4_state = gpio_state self.gpio4_button = InlineKeyboardButton(text=btnText, callback_data=cbData) elif gpio_number == 5: self.gpio5_state = gpio_state self.gpio5_button = InlineKeyboardButton(text=btnText, callback_data=cbData) else: context.bot.sendMessage( update.effective_chat.id, 'Unknown GPIO type in callback - doing nothing') return txt = 'GPIO {} set to {}'.format(gpio_number, GPIO_State(gpio_state).name) self.keyboard = InlineKeyboardMarkup.from_column( [self.gpio4_button, self.gpio5_button]) context.bot.sendMessage(update.effective_chat.id, txt, reply_markup=self.keyboard) start_handler = CommandHandler('start', start) message_handler = MessageHandler(Filters.text & ~Filters.command, message) unknown_cmd_handler = MessageHandler(Filters.command, unknown) callback_handler = CallbackQueryHandler(callback) dispatcher.add_handler(start_handler) #dispatcher.add_handler(message_handler) # not necessary dispatcher.add_handler(unknown_cmd_handler) dispatcher.add_handler(callback_handler) updater.start_polling() while (updater.running): try: # Block for 1 second and wait for incoming commands cmd = self.cmd_queue.get(block=True, timeout=1) except queue.Empty: pass if isinstance(cmd, ProcCMD) and cmd.bStop: # Stop command received, exit updater.stop() elif isinstance(cmd, ProcCMD): guitext = GuiCMD("Sending data: " + str(cmd.data)) self.return_queue.put(guitext) for chat_id in chat_ids: try: dispatcher.bot.send_message(chat_id=chat_id, text=str(cmd.data)) except Exception as e: logging.error(e) chat_ids.discard(chat_id) logging.warning('ChatId removed') cmd = None
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### specificConfig = self.config.get('SpecificConfig') if not specificConfig: recordDone = Record(None, message='Trigger: {:04d}'.format( self.config['Identifier'])) self.return_queue.put(recordDone) return eId = None pubKey = None prvKey = None for attrs in specificConfig: if attrs['Name'] == 'ExchangeId': eId = attrs['Data'] if attrs['Name'] == 'PubKey': pubKey = attrs['Data'] elif attrs['Name'] == 'PrvKey': prvKey = attrs['Data'] exchangeClass = getattr(ccxt, eId) if pubKey and prvKey: exchange = exchangeClass({ 'apiKey': pubKey, 'secret': prvKey, 'enableRateLimit': True }) else: exchange = exchangeClass({'enableRateLimit': True}) method = getattr(exchange, self.inputData['method']) kwargs = None params = None if not 'kwargs' in self.inputData: data = method() elif not 'params' in self.inputData: kwargs = self.inputData['kwargs'] data = method(**kwargs) else: kwargs = self.inputData['kwargs'] params = self.inputData['params'] if params != '': data = method(**kwargs, params=params) else: data = method(**kwargs) recordDone = Record( data, '{}() successfull'.format(self.inputData['method'])) self.return_queue.put(recordDone)
def onEveryFullIntervalbetweenTimes(self): ######################################### # On every fullinterval between times # ######################################### if not self.activeDays: return if self.timebase == 'Seconds': self.tick = 0.2 countdown = self.interval / self.tick nState = 0 while True: time = datetime.now().time() if nState == 0: # Init: Get the day offset dayOffset = self.getDayOffset(self.activeDays, self.stopTime) if dayOffset == 0 and time >= self.startTime: nState = 2 # Go to interval mode else: nState = 1 continue elif nState == 1: # Init: Calculate timedelta delta_t = datetime.combine(date.today(), self.startTime) - datetime.now() delta_t = delta_t + timedelta(days=dayOffset) nState = 2 continue elif nState == 2: # Init: Prepare countdown and tick countdown = delta_t.seconds + (delta_t.days * 86400) self.tick = 1 nState = 3 continue elif nState == 3: # Wait for the start countdown -= 1 if countdown <= 0: nState = 4 # Go to interval mode else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) elif nState == 4: # Init Interval Mode if self.timebase == 'Seconds': nState = 50 # Helper value: Prevents that trigger is fired several times when # countdown in decrement and the modulo condition is still valid # Init with an 'invalid' value (according to the timebase) lastFired = 61 elif self.timebase == 'Minutes': nState = 60 elif self.timebase == 'Hours': nState = 70 continue elif nState == 50: # Every full second: Init countdown countdown -= (time.second % self.interval) / self.tick nState = 51 continue elif nState == 51: # Every full second countdown -= 1 if time.second % self.interval == 0 and lastFired != time.second: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) countdown = self.interval / self.tick lastFired = time.second else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) if time >= self.stopTime: nState = 0 continue elif nState == 60: # Every full minutes: Init countdown # Calculate minutes fullMinutesInterval = self.interval // 60 passedMinutes = time.minute % fullMinutesInterval countdown -= (passedMinutes * 60 ) / self.tick # Calculate seconds countdown -= time.second / self.tick nState = 61 continue elif nState == 61: # Every full minutes countdown -= 1 if time.minute % (self.interval / 60) == 0 and time.second == 0: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) countdown = self.interval / self.tick else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) if time >= self.stopTime: nState = 0 continue elif nState == 70: # Every full hours: Init countdown # Calculate hours fullHoursInterval = self.interval // 3600 passedHours = time.hour % fullHoursInterval countdown -= (passedHours * 3600 )/ self.tick # Calculate minutes fullMinutesInterval = self.interval // 60 passedMinutes = time.minute % fullMinutesInterval countdown -= (passedMinutes * 60 )/ self.tick # Calculate seconds countdown -= time.second / self.tick nState = 71 continue elif nState == 71: # Every full hours countdown -= 1 if time.minute % (self.interval / 60) == 0 and time.second == 0: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) countdown = self.interval / self.tick else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) if time >= self.stopTime: nState = 0 continue bExit = self.blockAndWait() if bExit: return
def onEveryFullInterval(self): ############################ # On every full interval # ############################ nState = 0 if self.timebase == 'Seconds': nState = 10 self.tick = 0.2 # Helper value: Prevents that trigger is fired several times when # countdown in decrement and the modulo condition is still valid # Init with an 'invalid' value (according to the timebase) lastFired = 61 elif self.timebase == 'Minutes': nState = 20 elif self.timebase == 'Hours': nState = 30 # Countdown muss korrekt initialisiert werden countdown = self.interval / self.tick while True: countdown -= 1 time = datetime.now().time() if nState == 10: # Every full second: Init countdown # passt #x = (self.interval / self.tick) #y = ((second % self.interval) / self.tick) countdown -= (time.second % self.interval) / self.tick nState = 11 continue elif nState == 11: # Every full second #countdown -= 1 if time.second % self.interval == 0 and lastFired != time.second: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) countdown = self.interval / self.tick lastFired = time.second else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) elif nState == 20: # Every full minutes: Init countdown # Calculate minutes fullMinutesInterval = self.interval // 60 passedMinutes = time.minute % fullMinutesInterval countdown -= (passedMinutes * 60 ) / self.tick # Calculate seconds countdown -= time.second / self.tick nState = 21 continue elif nState == 21: # Every full minutes if time.minute % (self.interval / 60) == 0 and time.second == 0: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) countdown = self.interval / self.tick else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) elif nState == 30: # Every full hours: Init countdown # Calculate hours fullHoursInterval = self.interval // 3600 passedHours = time.hour % fullHoursInterval countdown -= (passedHours * 3600 )/ self.tick # Calculate minutes fullMinutesInterval = self.interval // 60 passedMinutes = time.minute % fullMinutesInterval countdown -= (passedMinutes * 60 )/ self.tick # Calculate seconds countdown -= time.second / self.tick nState = 21 continue elif nState == 31: # Every full hours if time.minute % (self.interval / 60) == 0 and time.second == 0: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) countdown = self.interval / self.tick else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) bExit = self.blockAndWait() if bExit: return
def intervalBetweenTimes(self): ############################ # Interval between times # ############################ if not self.activeDays: return nState = 0 while True: if nState == 0: # Init: Get the day offset dayOffset = self.getDayOffset(self.activeDays, self.stopTime) if dayOffset == 0 and datetime.now().time() >= self.startTime: nState = 2 # Go to interval mode else: nState = 1 continue elif nState == 1: # Init: Calculate timedelta delta_t = datetime.combine(date.today(), self.startTime) - datetime.now() delta_t = delta_t + timedelta(days=dayOffset) nState = 2 continue elif nState == 2: # Init: Prepare countdown and tick countdown = delta_t.seconds + (delta_t.days * 86400) self.tick = 1 nState = 3 continue elif nState == 3: # Wait for the start countdown -= 1 if countdown <= 0: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) nState = 4 # Go to interval mode else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) elif nState == 4: # Init Interval Mode if self.timebase == 'Seconds': self.tick = 0.2 countdown = self.interval / self.tick nState = 5 continue elif nState == 5: # Interval Mode countdown -= 1 if countdown <= 0: countdown = self.interval / self.tick recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) else: # calculate remaining time guitext = GuiCMD(self.remainingTime(countdown=countdown)) self.return_queue.put(guitext) if datetime.now().time() >= self.stopTime: nState = 0 continue bExit = self.blockAndWait() if bExit: return
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### specificConfig = self.config.get('SpecificConfig') if not specificConfig: self.return_queue.put( Record(None, message='Trigger: {:04d}'.format( self.config['Identifier']))) return gpioName = None mainMode = None subModeLED = None subModePWMLED = None gpioWorker = None cmd = None self.gpio = None self.initFlag = False for attrs in specificConfig: if attrs['Name'] == 'GPIO': gpioName = attrs['Data'] if attrs['Name'] == 'MainMode': mainMode = attrs['Data'] elif attrs['Name'] == 'SubModeLED': subModeLED = attrs['Data'] elif attrs['Name'] == 'SubModePWMLED': subModePWMLED = attrs['Data'] if mainMode == 'LED': self.gpio = LED(gpioName, initial_value=False) if subModeLED == 'Toggle on input': gpioWorker = self.ledWorkerToggle self.gpio.toggle() self.logLEDstate() elif subModeLED == 'Control on Input': gpioWorker = self.ledWorkerCtrl # set initial state if self.inputData is not None: if self.inputData: self.gpio.on() else: self.gpio.off() self.logLEDstate() elif subModeLED == 'Blink': def a(cmd=None): pass gpioWorker = a # assign an empty function self.gpio.blink() self.return_queue.put( Record( None, 'Start LED Blink Mode on GPIO{}'.format( self.gpio.pin.number))) elif mainMode == 'PWMLED': self.gpio = PWMLED(gpioName, initial_value=False) if subModePWMLED == 'Control on Input': gpioWorker = self.pwmLedWorkerCtrl if self.inputData is not None: self.gpio.value = self.inputData self.return_queue.put( Record( None, 'PWMLED: Set brightness on GPIO{} to {:.2f}'. format(self.gpio.pin.number, self.inputData))) elif subModePWMLED == 'Pulse': def a(cmd=None): pass gpioWorker = a # assign an empty function self.gpio.pulse() self.return_queue.put( Record( None, 'Start PWMLED Pulse Mode on GPIO{}'.format( self.gpio.pin.number))) ##################################### # # # Start of the infinite loop # # # ##################################### while (True): # Example code: Do something try: # Block for 1 second and wait for incoming commands cmd = None cmd = self.cmd_queue.get(block=True, timeout=1) except queue.Empty: pass if isinstance(cmd, ProcCMD): if cmd.bStop: # Stop command received, exit self.return_queue.put( Record(None, 'GPIO{} closed'.format(self.gpio.pin.number))) self.gpio.close() return gpioWorker(cmd)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### specificConfig = self.config.get('SpecificConfig') if not specificConfig: recordDone = Record(None, message='Trigger: {:04d}'.format( self.config['Identifier'])) self.return_queue.put(recordDone) return baseAPI = None pubMethod = None prvMethod = None orderType = None side = None pubSymbol = None prvSymbol = None symbols = None timeframe = None limit = None amount = None price = None address = None params = None for attrs in specificConfig: if attrs['Name'] == 'BaseApi': baseAPI = attrs['Data'] elif attrs['Name'] == 'Public Methods': pubMethod = attrs['Data'] elif attrs['Name'] == 'Private Methods': prvMethod = attrs['Data'] elif attrs['Name'] == 'Order Types': orderType = attrs['Data'] elif attrs['Name'] == 'Side': side = attrs['Data'] elif attrs['Name'] == 'SymbolPublic': pubSymbol = attrs['Data'] elif attrs['Name'] == 'SymbolPrivate': prvSymbol = attrs['Data'] elif attrs['Name'] == 'Timeframe': timeframe = attrs['Data'] elif attrs['Name'] == 'LimitData': limit = attrs['Data'] elif attrs['Name'] == 'Tickers': symbols = attrs['Data'] elif attrs['Name'] == 'Amount': amount = attrs['Data'] elif attrs['Name'] == 'Price': price = attrs['Data'] elif attrs['Name'] == 'Address': address = attrs['Data'] elif attrs['Name'] == 'Parameter': params = attrs['Data'] ######################################### # # # The execution exits immediately # # after providing output data # # # ######################################### if baseAPI == 'Public': methodName = pubMethod symbol = pubSymbol else: methodName = prvMethod symbol = prvSymbol if methodName == 'create order' and orderType == 'Market': methodName = methodName.replace(" ", "_") apiCall = { 'method': methodName, 'kwargs': { 'symbol': symbol, 'type': orderType, 'side': side, 'amount': amount } } elif methodName == 'create order' and orderType == 'Limit': methodName = methodName.replace(" ", "_") apiCall = { 'method': methodName, 'kwargs': { 'symbol': symbol, 'type': orderType, 'side': side, 'amount': amount, 'price': price } } elif methodName == 'create order': methodName = methodName.replace(" ", "_") apiCall = { 'method': methodName, 'params': params, 'kwargs': { 'symbol': symbol, 'type': orderType, 'side': side, 'amount': amount, 'price': price } } elif methodName == 'fetch orders' or \ methodName == 'fetch open orders' or \ methodName == 'fetch closed orders' or \ methodName == 'fetch my trades' or \ methodName == 'fetch trades' or \ methodName == 'fetch order book' or \ methodName == 'fetch ticker': methodName = methodName.replace(" ", "_") apiCall = {'method': methodName, 'kwargs': {'symbol': symbol}} elif methodName == 'fetch tickers': methodName = methodName.replace(" ", "_") apiCall = {'method': methodName, 'kwargs': {'symbols': symbols}} elif methodName == 'withdraw': apiCall = { 'method': methodName, 'kwargs': { 'code': symbol, 'amount': amount, 'address': address } } elif methodName == 'fetch OHLCV': methodName = methodName.replace(" ", "_").lower() apiCall = { 'method': methodName, 'kwargs': { 'symbol': symbol, 'timeframe': timeframe, 'limit': int(limit) } } else: methodName = methodName.replace(" ", "_") apiCall = {'method': methodName} recordDone = Record(apiCall) self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### specificConfig = self.config.get('SpecificConfig') if not specificConfig: recordDone = Record(None, message='Config missing') self.return_queue.put(recordDone) return sender = None password = None url = None port = None recipients = None subject = None message = None attachments = None for attrs in specificConfig: if attrs['Name'] == 'Sender': sender = attrs['Data'] elif attrs['Name'] == 'Password': password = attrs['Data'] elif attrs['Name'] == 'URL': url = attrs['Data'] elif attrs['Name'] == 'Port': port = int(attrs['Data']) if not sender: raise Exception('Sender missing in configuration') if not password: raise Exception('Password missing in configuration') if not url: raise Exception('URL missing in configuration') if not port: raise Exception('Port missing in configuration') if isinstance(self.inputData, dict): if not 'recipient' in self.inputData or not isinstance( self.inputData['recipient'], str): recordDone = Record( PythonicError('Key error, see log for details'), message='Key "recipient" not found or not of type string') self.return_queue.put(recordDone) return if not 'subject' in self.inputData or not isinstance( self.inputData['subject'], str): recordDone = Record( PythonicError('Key error, see log for details'), message='Key "subject" not found or not of type string') self.return_queue.put(recordDone) return if not 'message' in self.inputData or not isinstance( self.inputData['message'], str): recordDone = Record( PythonicError('Key error, see log for details'), message='Key "subject" not found or not of type string') self.return_queue.put(recordDone) return recipients = self.inputData['recipient'] subject = self.inputData['subject'] message = self.inputData['message'] # optional: check for attachment(s) if 'attachment' in self.inputData and isinstance( self.inputData['attachment'], list): attachments = self.inputData['attachment'] else: recordDone = Record(PythonicError('Config missing'), message='Config missing') self.return_queue.put(recordDone) return msg = EmailMessage() msg['Subject'] = subject msg['From'] = sender msg['To'] = recipients msg.set_default_type('text/plain') msg.set_content(message) if attachments: for attachment in attachments: if not 'filename' in attachment: # and not isinstance(attachment['filename'], str): continue if not isinstance(attachment['filename'], str): continue if not 'data' in attachment: continue # attach data as text if isinstance(attachment['data'], str): msg.add_attachment(attachment['data'], 'text/plain', filename=attachment['filename']) else: # attach data is binary object msg.add_attachment(pickle.dumps(attachment['data']), maintype='application', subtype='octet-stream', filename=attachment['filename']) context = ssl.create_default_context() with smtplib.SMTP_SSL(url, port, context=context) as server: server.login(sender, password) server.send_message(msg)
def execute(self): ### Load data ### file_path = Path.home() / 'Pythonic' / 'executables' / 'ADAUSD_5m.df' # only the last 21 columsn are considered self.ohlcv = pd.read_pickle(file_path)[-21:] self.bBought = False self.lastPrice = 0.0 self.profit = 0.0 self.profitCumulative = 0.0 self.price = self.ohlcv['close'].iloc[-1] # switches for simulation self.bForceBuy = False self.bForceSell = False # load trade history from file self.trackRecord = ListPersist('track_record') try: lastOrder = self.trackRecord[-1] self.bBought = lastOrder.orderType self.lastPrice = lastOrder.price self.profitCumulative = lastOrder.profitCumulative except IndexError: pass ### Calculate indicators ### self.ohlcv['ema-10'] = self.ohlcv['close'].ewm(span=10, adjust=False).mean() self.ohlcv['ema-21'] = self.ohlcv['close'].ewm(span=21, adjust=False).mean() self.ohlcv['condition'] = self.ohlcv['ema-10'] > self.ohlcv['ema-21'] ### Check for Buy- / Sell-condition ### tradeCondition = self.ohlcv['condition'].iloc[-1] != self.ohlcv[ 'condition'].iloc[-2] if tradeCondition or self.bForceBuy or self.bForceSell: orderType = self.ohlcv['condition'].iloc[ -1] # True = BUY, False = SELL if orderType and not self.bBought or self.bForceBuy: # place a buy order msg = 'Placing a Buy-order' newOrder = self.createOrder(True) elif not orderType and self.bBought or self.bForceSell: # place a sell order msg = 'Placing a Sell-order' sellPrice = self.price buyPrice = self.lastPrice self.profit = (sellPrice * 100) / buyPrice - 100 self.profitCumulative += self.profit newOrder = self.createOrder(False) else: # Something went wrong msg = 'Warning: Condition for {}-order met but bBought is {}'.format( OrderType(orderType).name, self.bBought) newOrder = None recordDone = Record(newOrder, msg) self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REPORT GENERATOR # # # ##################################### path = Path.home( ) / 'Pythonic' / 'executables' / 'report_template.xlsx' try: wb = load_workbook(path) except FileNotFoundError as e: recordDone = Record(PythonicError(e), 'Template not found') self.return_queue.put(recordDone) con.close() return except Exception as e: recordDone = Record(PythonicError(e), 'Open log for details') self.return_queue.put(recordDone) con.close() return # Workbook https://openpyxl.readthedocs.io/en/stable/api/openpyxl.workbook.workbook.html # Cell https://openpyxl.readthedocs.io/en/stable/api/openpyxl.cell.cell.html sheets = wb.sheetnames datasheet = wb['Data'] # create an iterator over the rows in the datasheet rows = datasheet.iter_rows(min_row=2, max_row=999, min_col=0, max_col=2) # Convert unix time [s] back into a datetime object, returns an iterator reportdata_dt = map( lambda foo: (datetime.datetime.fromtimestamp(foo[0]), foo[1]), self.inputData) # iterate till the first iterator is exhausted for (dt, val), (row_dt, row_val) in zip(reportdata_dt, rows): row_dt.value = dt row_val.value = val # alternative approach (functional) # zip both iterators together # data_it = zip(reportdata_dt, rows) # def write_row(data): # (dt, val), (row_dt, row_val) = data # row_dt.value = dt # row_val.value = val # maker = map(write_row, data_it) # deque(maker, maxlen=0) reportDate = datetime.datetime.now().strftime('%d_%b_%Y_%H_%M_%S') filename = 'report_{}.xlsx'.format(reportDate) filepath = Path.home() / 'Pythonic' / 'log' / filename wb.save(filepath) wb.close() recordDone = Record(filepath, 'Report saved under: {}'.format(filename)) self.return_queue.put(recordDone)
def execute(self): output = 'CREATE TABLE IF NOT EXISTS my_table (timestamp INTEGER PRIMARY KEY NOT NULL, value REAL)' recordDone = Record(output, 'Creating table') self.return_queue.put(recordDone)
def execute(self): ##################################### # # # REFERENCE IMPLEMENTATION # # # ##################################### cmd = None specificConfig = self.config.get('SpecificConfig') chat_ids = ListPersist('chat_ids') if not specificConfig: recordDone = Record(None, message='Config missing') self.return_queue.put(recordDone) return token = next(attr['Data'] for attr in specificConfig if attr['Name'] == 'Token') if not token: recordDone = Record(None, message='Token missing') self.return_queue.put(recordDone) return updater = Updater(token=self.config['SpecificConfig'][0]['Data'], use_context=True) dispatcher = updater.dispatcher def start(update: Update, context: CallbackContext): chat_ids.append(update.message.chat_id) context.bot.send_message( chat_id=update.effective_chat.id, text="Hello, this chat ID is now registered for communication." ) def unknown(update, context): context.bot.send_message( chat_id=update.effective_chat.id, text='Sorry, I didn\'t understand that command.') def message(update, context): context.bot.send_message(chat_id=update.effective_chat.id, text='Message received') guitext = GuiCMD('Message received from: {}, MsgId.: {:d}'.format( update.message.from_user.first_name, update.message.message_id)) self.return_queue.put(guitext) record = Record( update.message, 'Message received from: {}, MsgId.: {:d}'.format( update.message.from_user.first_name, update.message.message_id)) self.return_queue.put(record) start_handler = CommandHandler('start', start) message_handler = MessageHandler(Filters.text & ~Filters.command, message) unknown_cmd_handler = MessageHandler(Filters.command, unknown) dispatcher.add_handler(start_handler) dispatcher.add_handler( message_handler) # muss als letztes hinzugefügt werden dispatcher.add_handler(unknown_cmd_handler) updater.start_polling() while (updater.running): try: # Block for 1 second and wait for incoming commands cmd = self.cmd_queue.get(block=True, timeout=1) except queue.Empty: pass if isinstance(cmd, ProcCMD) and cmd.bStop: # Stop command received, exit updater.stop() elif isinstance(cmd, ProcCMD): guitext = GuiCMD("Sending data: " + str(cmd.data)) self.return_queue.put(guitext) for chat_id in chat_ids: try: dispatcher.bot.send_message(chat_id=chat_id, text=str(cmd.data)) except Exception as e: logging.error(e) chat_ids.remove(chat_id) logging.warning('ChatId removed') cmd = None
def execute(self): #interval_str, interval_index, offset, log_state = self.config mode = '' self.timebase = '' self.startTime = '' self.endTime = '' self.interval = 0 self.tick = 1 # Threads wait full seconds self.activeDays = [] recordDone = Record(None, None) specificConfig = self.config.get('SpecificConfig') # Set default mode if SpecificConfig is not defined # This is the case if the element was created on the working area # but the configuration was never opened if not specificConfig: recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) return for attrs in self.config['SpecificConfig']: if attrs['Name'] == 'Mode': mode = attrs['Data'] elif attrs['Name'] == 'Timebase': self.timebase = attrs['Data'] elif attrs['Name'] == 'Intervalinput': self.interval = attrs['Data'] elif attrs['Name'] == 'StartTime': startTime = attrs['Data'] elif attrs['Name'] == 'EndTime': endTime = attrs['Data'] elif attrs['Name'] == 'SpecificTime': specTime = attrs['Data'] elif attrs['Name'] == 'Monday'and attrs['Data']: self.activeDays.append(0) elif attrs['Name'] == 'Tuesday'and attrs['Data']: self.activeDays.append(1) elif attrs['Name'] == 'Wednesday'and attrs['Data']: self.activeDays.append(2) elif attrs['Name'] == 'Thursday'and attrs['Data']: self.activeDays.append(3) elif attrs['Name'] == 'Friday' and attrs['Data']: self.activeDays.append(4) elif attrs['Name'] == 'Saturday' and attrs['Data']: self.activeDays.append(5) elif attrs['Name'] == 'Sunday' and attrs['Data']: self.activeDays.append(6) # Setup interval if self.timebase == 'Seconds': self.interval = int(self.interval) self.tick = 0.2 elif self.timebase == 'Minutes': self.interval = int(self.interval) * 60 elif self.timebase == 'Hours': self.interval = int(self.interval) * 3600 # Setup start- and endtime self.startTime = datetime.strptime(startTime, '%H:%M').time() self.stopTime = datetime.strptime(endTime, '%H:%M').time() self.specTime = datetime.strptime(specTime, '%H:%M').time() # Switch modes if mode == "Single fire": ############################ # None # ############################ recordDone = Record(data=None, message='>Trigger< ProcHdl::{:04d}'.format(self.config['Identifier'])) self.return_queue.put(recordDone) return elif mode == "Single fire, delayed": self.singleFireDelayed() return elif mode == "Interval": self.intervalScheduler() return elif mode == "Interval between times": ############################ # Interval between times # ############################ self.intervalBetweenTimes() return elif mode == "At specific time": ############################ # At specific time # ############################ self.atSpecificTime() return elif mode == "On every full interval": ############################ # On every full interval # ############################ self.onEveryFullInterval() return elif mode == "Full interval between times": ################################# # Full interval between times # ################################# self.onEveryFullIntervalbetweenTimes() return
def logLEDstate(self): self.return_queue.put( Record( None, 'Switch LED on GPIO{} to {}'.format(self.gpio.pin.number, self.gpio.is_active)))
def run(self): #logging.debug('ProcessHandler::run() -id: 0x{:08x}, ident: {:04d}'.format(self.element['Id'], self.identifier)) bMP = self.element['Config']['GeneralConfig']['MP'] if bMP: self.return_queue = mp.Queue() self.cmd_queue = mp.Queue() else: self.return_queue = queue.Queue() self.cmd_queue = queue.Queue() try: # This affects only first invocation module = __import__(self.element['Filename']) #logging.warning("Load module first time") # Reload to execute possible changes module = reload(module) elementCls = getattr(module, 'Element') except Exception as e: logging.warning( 'ProcessHandler::run() - Error loading file - id: 0x{:08x}, ident: {:04d} - {} Error: {}' .format(self.element['Id'], self.identifier, self.element['Filename'], e)) return self.instance = elementCls(self.element['Config'], self.inputData, self.return_queue, self.cmd_queue) result = None if bMP: ## attach Debugger if flag is set self.p_0 = mp.Process(target=self.instance.execute) self.p_0.start() self.pid = self.p_0.pid else: self.t_0 = mt.Thread(target=self.instance.execute) self.t_0.start() result = Record(None, None) ################################################################## # # # MULTITHREADING # # # ################################################################## # Check if it is an intemediate result (result.bComplete) # or if the execution was stopped by the user (self.element.bStop) while not bMP: try: # First: Check if there is somethin in the Queue result = self.return_queue.get(block=True, timeout=0.2) # Seconds: Forward the result (is present) self.execComplete.emit(self.element['Id'], result, self.identifier) except queue.Empty: #logging.debug('return_queue empty') pass # Thirs: Check if Thread is still alive if not self.t_0.is_alive(): break #logging.debug('ProcessHandler::run() - Multithreading: result received - id: 0x{:08x}, ident: {:04d}'.format(self.element['Id'], self.identifier)) ################################################################## # # # MULTIPROCESSING # # # ################################################################## while bMP: try: result = self.return_queue.get(block=True, timeout=0.2) self.execComplete.emit(self.element['Id'], result, self.identifier) #logging.debug('ProcessHandler::run() - Multiprocessing: execution completed - id: 0x{:08x}, ident: {:04d}, pid: {}'.format( # self.element['Id'], self.identifier, self.p_0.pid)) except queue.Empty: #logging.debug('return_queue empty') pass if not self.p_0.is_alive(): break