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
