def main():
GPIO.cleanup()
settings.load_settings()
threads = [
Logic.Logic(),
Display.DisplayThread(),
threading.Thread(target=RestThread.run_server)
]
# threads.append(WatchdogThread.WatchdogThread())
# threads.append(ReminderThread.ReminderThread())
for th in threads:
th.start()
time.sleep(0.5)
while len(threads) > 0:
try:
temp_threads = []
for t in threads:
if t is not None and t.isAlive():
t.join(0.2)
temp_threads.append(t)
threads = temp_threads
time.sleep(0.1)
except (KeyboardInterrupt, SystemExit):
Register.EXIT_FLAG = True
Helpers.log("ZAPISYWANIE KONFIGURACJI")
settings.save_settings()
Helpers.log("ZAMYKANIE APLIKACJI")
def main():
GPIO.cleanup()
settings.load_settings()
threads = [Logic.Logic(), Display.DisplayThread(), threading.Thread(target=RestThread.run_server)]
# threads.append(WatchdogThread.WatchdogThread())
# threads.append(ReminderThread.ReminderThread())
for th in threads:
th.start()
time.sleep(0.5)
while len(threads) > 0:
try:
temp_threads = []
for t in threads:
if t is not None and t.isAlive():
t.join(0.2)
temp_threads.append(t)
threads = temp_threads
time.sleep(0.1)
except (KeyboardInterrupt, SystemExit):
Register.EXIT_FLAG = True
Helpers.log("ZAPISYWANIE KONFIGURACJI")
settings.save_settings()
Helpers.log("ZAMYKANIE APLIKACJI")
def save(self):
for bottle in self.bottles_names:
Register.BOTTLE_MOD[bottle]['ON'] = self.bottles[bottle]['ON']
Register.BOTTLE_MOD[bottle]['HOUR'] = self.bottles[bottle]['HOUR']
Register.BOTTLE_MOD[bottle]['MIN'] = self.bottles[bottle]['MIN']
Register.BOTTLE_MOD[bottle]['DOSE'] = self.bottles[bottle]['DOSE']
Register.BOTTLE_MOD[bottle]['SEC_PER_ML'] = self.bottles[bottle]['SEC_PER_ML']
settings.save_settings()
def save(self):
for bottle in self.bottles_names:
Register.BOTTLE_MOD[bottle]['ON'] = self.bottles[bottle]['ON']
Register.BOTTLE_MOD[bottle]['HOUR'] = self.bottles[bottle]['HOUR']
Register.BOTTLE_MOD[bottle]['MIN'] = self.bottles[bottle]['MIN']
Register.BOTTLE_MOD[bottle]['DOSE'] = self.bottles[bottle]['DOSE']
Register.BOTTLE_MOD[bottle]['SEC_PER_ML'] = self.bottles[bottle][
'SEC_PER_ML']
settings.save_settings()
def on_quit(self):
SETTINGS["GEOMETRY_MAIN"] = self.parent.geometry()
SETTINGS["GEOMETRY_IMAGEWINDOW"] = self.picpanel.geometry()
SETTINGS["GEOMETRY_HISTORY_WINDOW"] = self.history_window.geometry()
save_settings() # remember window geometries
self.db_manager.commit_changes()
self.parent.destroy()
def _add_settings(self, chat_id, category, tagList):
tl = map(lambda s: string.replace(s, "_", " "), tagList)
s = settings.load_settings(chat_id)
try:
s[category] |= set(tl)
except:
s[category] = set(tl)
settings.save_settings(chat_id, s)
def _add_settings(self, chat_id, category, tagList):
tl = map(lambda s : string.replace(s, "_", " "), tagList)
s = settings.load_settings(chat_id)
try:
s[category] |= set(tl)
except:
s[category] = set(tl)
settings.save_settings(chat_id, s)
def _save_settings(self, button):
dir_entry = self._builder.get_object('DirEntry')
handle_entry = self._builder.get_object('HandleEntry')
key_entry = self._builder.get_object('KeyEntry')
pid_entry = self._builder.get_object('PIDEntry')
git.set_api_key(dir_entry.get_text(), handle_entry.get_text(), key_entry.get_text())
git.set_pid(dir_entry.get_text(), pid_entry.get_text())
settings.save_settings(dir_entry.get_text(), handle_entry.get_text(),\
key_entry.get_text(), pid_entry.get_text())
def run(chunk_size, lazy_factor, alert_server_port, graphql_server_port,
graphql_server_host):
"""This script runs whole ecosystem of this scraper on different screens."""
# write settings to file
save_settings(chunk_size, lazy_factor, alert_server_port,
graphql_server_port, graphql_server_host)
# actually run the bash script
subprocess.call('./run.sh')
print(
'Scraper is running. Screen instances are up.\nYou can check them out with screen -ls'
)
def change_server_address(self):
address_input = input('Enter new remote server address: ')
if address_input:
# address:port
split_input = address_input.split(':')
if len(split_input) != 2 or '' in split_input:
print('invalid host:port combination')
else:
host, port = split_input
settings.settings['server_address'] = address_input
print(f'Saving new remote server address: {address_input}')
settings.save_settings(settings.settings)
return True
def open_settings(self, button):
builder = gtk.Builder()
builder.add_from_file( path.join(glade_dir, 'settings_dialog.glade') )
d = builder.get_object('settings_dialog')
builder.get_object('vcf_path_search_button').connect('clicked', self.search_export_path, builder.get_object('vcf_path_entry'))
d.set_transient_for(self)
my_settings = settings.get_settings()
for e in ['resource', 'user', 'passwd', 'vcf_path']: builder.get_object(e+'_entry').set_text(my_settings[e])
for e in ['verify', 'write_vcf']: builder.get_object(e+'_checkbutton').set_active(my_settings[e])
if d.run() == gtk.RESPONSE_ACCEPT:
new_settings = {}
for e in ['resource', 'user', 'passwd', 'vcf_path']: new_settings[e] = builder.get_object(e+'_entry').get_text()
for e in ['verify', 'write_vcf']: new_settings[e] = builder.get_object(e+'_checkbutton').get_active()
settings.save_settings(new_settings)
d.destroy()
self.syncerThreadQueue.put('full_sync')
def OnCloseWindow(self, event):
settings.log("SalesGraph starting exit")
from currency import ExchangeRate
ExchangeRate.save_currencies()
ExchangeRate.requestShutdown()
settings.save_settings()
self.sales_period.requestShutdown()
if not self.sales_downloader == None:
self.sales_downloader.requestShutdown()
if not self.updater == None:
self.updater.requestShutdown()
self.Destroy()
def closeEvent(self, event):
"""Save UI settings and stops the running thread gracefully, then exit the application.
Called when closing the application window.
"""
# Stop the running thread
if self.thread.isRunning():
self.thread.stop()
print("Thread stopped")
# Save UI settings
settings.save_settings(self.config, self.ui)
print("Settings saved")
# Hide tray icon
self.trayIcon.hide()
# Accept the closing event and close application
event.accept()
def save_settings():
print("Saving Settings:")
print(request)
req_data = request.get_json()
# print(request.data['maxTemp'])
print(req_data)
print(req_data['maxTemp'])
rawData = request.form
return settings.save_settings(req_data)
def _post_settings(writer, request):
global last_request_time
last_request_time = time.time()
try:
new_settings = ujson.loads(request.get('body'))
except Exception as e:
error.add_error(ujson.dumps({
'time': time.time(),
'error': str(e)
}))
return userv.json(writer,
{"message": "Request had no valid json body."},
status=406)
updated_settings = settings.save_settings(settings.get_settings(),
new_settings)
return userv.json(writer, updated_settings)
def save(self):
Register.WATER_TEMP_SET = self.temp_set
Register.WATER_TEMP_ALERT_DELTA = self.temp_alert_delta
Register.WATER_TEMP_ONOFF_DELTA = self.temp_on_off_delta
settings.save_settings()
def on_close(self):
settings.save_settings()
pyglet.app.exit()
def settings_edit():
global settings_mode, config
# list accounts
accounts = config['accounts']
max_acc = len(accounts)
# display accounts
i = 0
str_display = ''
for a in accounts:
str_display += '\nAcc: %s\nAPI KEY: %s\nAPI SECRET: %s\n'\
%(i, a['api']['key'], a['api']['secret'])
i += 1
print(str_display)
# wait for valid input (existing acc no) TODO: add new account
print('Type in account number, e.g. "0" or "new" to add a new one')
current_accs = []
for a in range(0, max_acc):
current_accs.append(str(a))
current_accs.append('new')
inp_acc = input_hook(current_accs)
# handle cancel command
if inp_acc == None:
settings_mode = False
print('Settings mode disabled.\n')
return
# handle new acc
if inp_acc == 'new':
new_acc = {
'api': {
'key': '',
'secret': ''
},
'sl': {
'dist': 0.02,
'trail': 0.005
},
'tp': {
'dist': 0.05
}
}
accounts.append(new_acc)
config['accounts'] = accounts
print('New account added.')
settings.save_settings(config)
settings_mode = False
print('Settings mode disabled.\n')
return
# show account settings
acc = int(inp_acc)
_acc = accounts[int(inp_acc)]
str_display = 'SELECTED ACC: %s\nAPI KEY: %s\nAPI SECRET: %s\n'\
%(acc, _acc['api']['key'], _acc['api']['secret'])
# add SL/TP settings to display
sl_dist = str(_acc['sl']['dist'] * 100) + '%'
sl_trail = str(_acc['sl']['trail'] * 100) + '%'
tp_dist = str(_acc['tp']['dist'] * 100) + '%'
str_display += 'SL Distance: %s\nSL Trail: %s\nTP Distance: %s\n'\
%(sl_dist, sl_trail, tp_dist)
print(str_display)
# choose setting to change
while True:
print(
'\nType "sl distance 1" to set a stop loss distance of 1%. Or type "help" for a list of available commands.'
)
_modif = input_hook({
'sl distance': '',
'sl trail': '',
'tp distance': '',
'api key': '',
'api secret': ''
})
if _modif == None:
break
if _modif['sl distance'] is not '':
# change SL Distance
_value = float(_modif['sl distance'])
config['accounts'][acc]['sl']['dist'] = _value / 100
elif _modif['sl trail'] is not '':
# change SL Trail
_value = float(_modif['sl trail'])
config['accounts'][acc]['sl']['trail'] = _value / 100
elif _modif['tp distance'] is not '':
# change TP Distance
_value = float(_modif['tp distance'])
config['accounts'][acc]['tp']['dist'] = _value / 100
elif _modif['api key'] is not '':
# change api key
_value = str(_modif['api key']).strip()
config['accounts'][acc]['api']['key'] = _value
elif _modif['api secret'] is not '':
# change api secret
_value = str(_modif['api secret']).strip()
config['accounts'][acc]['api']['secret'] = _value
# save settings prompt
while True:
save = input('Save changes? Y/N').lower().strip()
if save == 'y':
settings.save_settings(config)
break
elif save == 'n':
config = settings.get_settings() # reload settings
print('No changes were saved.')
break
settings_mode = False
print('Settings mode disabled.\n')
def save(self):
Register.WATER_TEMP_SET = self.temp_set
Register.WATER_TEMP_ALERT_DELTA = self.temp_alert_delta
Register.WATER_TEMP_ONOFF_DELTA = self.temp_on_off_delta
settings.save_settings()
def start():
currentCall = None
logging.basicConfig(
format='[%(levelname)s %(name)s] %(asctime)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
level=logging.DEBUG)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logger.debug('Loading blacklist...')
load_blacklist()
logger.debug('Loading whitelist...')
load_whitelist()
logger.debug('Restoring call history...')
restore_history()
logger.debug('Restoring wildcard rules...')
restore_wildcards()
logger.debug('Wildcard rule: ' + wildcard_rule)
logger.debug('Loading settings...')
settings.load_settings()
logger.debug('Establishing pub connection to NSQ...')
pub = gnsq.Nsqd(address='localhost', http_port=4151)
logging.getLogger('urllib3').setLevel(
logging.WARNING) # disable annoying urllib3 debugging
logger.debug('Spinning up NSQ handler thread...')
handler_pipe, handler_child_pipe = Pipe()
handler_proc = Process(target=handlers.handler_process,
args=(handler_child_pipe, ))
handler_proc.start()
logger.debug('Spinning up modem thread...')
modem_pipe, modem_child_pipe = Pipe()
modem_proc = Process(target=modem.modem_process, args=(modem_child_pipe, ))
modem_proc.start()
relay.init_relay_gpio()
pub.publish('heartbeat', 'no')
last_heartbeat_time = datetime.now()
while True:
# heartbeat
if (datetime.now() - last_heartbeat_time).total_seconds() > 60:
pub.publish('heartbeat', 'no')
last_heartbeat_time = datetime.now()
if handler_pipe.poll(): # message from NSQ
msg = handler_pipe.recv()
logger.debug('Message from NSQ: ' + str(msg))
if msg[0] == 'blacklist': # append number to blacklist
if msg[1] not in blacklist: # don't add duplicates
blacklist.add(msg[1])
if currentCall is not None: # blacklist currently incoming call
modem_pipe.send('hangup')
append_blacklist(msg[1])
elif msg[0] == 'blacklist_remove':
if msg[1] in blacklist: # don't do expensive file rewrite if number wasn't in blacklist
blacklist.remove(msg[1])
write_blacklist(
) # rewrite blacklist file to reflect removed number
elif msg[0] == 'whitelist': # append number to whitelist
whitelist.add(msg[1])
elif msg[0] == 'history':
resp = history_to_str(msg[1])
pub.publish('history_give', resp)
elif msg[0] == 'blacklist_get':
resp = blacklist_to_str(msg[1])
pub.publish('blacklist_give', resp)
elif msg[
0] == 'settings_request': # respond to all settings request
setList = sorted(settings.registry.keys())
pub.publish('settings_all', ':'.join(setList))
elif msg[0] == 'setting_get': # respond to single setting request
setObj = settings.registry[msg[1]] # single setting requested
allStates = ';'.join(
setObj['states']) # str for all possible states
respList = [
msg[1], setObj['help_text'], setObj['current_state'],
allStates
]
resp = ':'.join(respList)
pub.publish('setting_give', resp)
elif msg[0] == 'setting_set': # change the setting
# special treatment of off-device programming setting
if msg[1] == 'Off-device programming':
partition = off_device.mount_device()
if partition != None:
if msg[2] == 'Append':
off_device.append_lists(partition)
elif msg[2] == 'Replace':
off_device.replace_lists(partition)
elif msg[2] == 'Export':
off_device.copy_lists(partition)
# special treatment of filter and wildcard settings
elif msg[1] == 'Filter Disable':
settings.filter_disable = True if msg[
2] == 'Enabled' else False
elif msg[1] == 'Wildcards':
settings.wildcard_disable = True if msg[
2] == 'Enabled' else False
else:
settings.registry[msg[1]]['current_state'] = msg[2]
settings.save_settings()
if modem_pipe.poll(): # incoming call from modem
currentCall = modem_pipe.recv()
relay.set_ans_machine_relay_pin(False)
relay.set_telephone_out_relay_pin(False)
if settings.filter_disable:
append_history(currentCall)
pub.publish('call_received',
currentCall.number + ':' + currentCall.name)
modem_pipe.send('pass')
currentCall = None
else:
mode = settings.registry['Filtering mode']['current_state']
if (mode == 'Blacklist'):
if (currentCall.number in blacklist) or (
(not settings.wildcard_disable)
and matches_wildcard(currentCall.number)):
relay.set_telephone_out_relay_pin(True)
currentCall.wasBlocked = '1'
append_history(currentCall)
modem_pipe.send('hangup')
currentCall = None
else:
append_history(currentCall)
pub.publish(
'call_received',
currentCall.number + ':' + currentCall.name)
modem_pipe.send('pass')
currentCall = None
elif (mode == 'Whitelist'):
if (currentCall.number in whitelist):
append_history(currentCall)
pub.publish(
'call_received',
currentCall.number + ':' + currentCall.name)
modem_pipe.send('pass')
currentCall = None
else:
relay.set_telephone_out_relay_pin(True)
currentCall.wasBlocked = '1'
append_history(currentCall)
modem_pipe.send('hangup')
currentCall = None
else: # is in Greylist mode; can check, but just assuming for now
if (currentCall.number in blacklist):
relay.set_telephone_out_relay_pin(True)
currentCall.wasBlocked = '1'
append_history(currentCall)
modem_pipe.send('hangup')
currentCall = None
elif (currentCall.number in whitelist):
append_history(currentCall)
pub.publish(
'call_received',
currentCall.number + ':' + currentCall.name)
modem_pipe.send('pass')
currentCall = None
elif ((not settings.wildcard_disable)
and matches_wildcard(currentCall.number)):
relay.set_ans_machine_relay_pin(True)
relay.set_telephone_out_relay_pin(True)
append_history(currentCall)
modem_pipe.send('ans_machine')
currentCall = None
else:
append_history(currentCall)
pub.publish(
'call_received',
currentCall.number + ':' + currentCall.name)
modem_pipe.send('pass')
currentCall = None
pub.publish('history_give', history_to_str([10, 0]))
time.sleep(
0.05
) # keep from using all of the CPU handling messages from threads
