def main():
global settings, hmqtt, log, imageHub, imageQ
# process args - port number,
ap = argparse.ArgumentParser()
ap.add_argument("-c",
"--conf",
required=True,
type=str,
help="path and name of the json configuration file")
args = vars(ap.parse_args())
# logging setup
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s')
log = logging.getLogger('ML_Tracker')
settings = Settings(log, (args["conf"]))
hmqtt = Homie_MQTT(settings, ctrlCB)
settings.print()
# load the pre-computed models...
init_models()
log.info(f'listen on {settings.our_IP}:{settings.image_port}')
imageHub = imagezmq.ImageHub(open_port=f'tcp://*:{settings.image_port}')
imageQ = Queue.Queue(maxsize=60)
log.info('tracker running')
server = HTTPServer(('', 5000), CamHandler)
log.info("http server started")
server.serve_forever()
def __init__(self, usersProvider=None):
self.logger = Logger(__name__)
self.userProvider = usersProvider or UsersProvider()
self.settings = Settings().getSettings()
self.mysql = MySQLUserCreator()
self.fs = FileSystem()
self.mongoForgotPass = MongoForgotPassword()
def __init__(self, name):
if 'UNITTESTING' in os.environ:
self.logging = NullLogger()
else:
settings = Settings().getSettings()
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=settings["logs"]["level"])
self.logging = logging.getLogger(name)
def __init__(self):
self._console = Console()
self._console.printLogo()
self._exceptionStack = list()
self._fileManager = FileManager()
self._logger = Logger()
self._settingsFile = Settings()
self._dialog = Dialog('en') if self._settingsFile.getLanguage(
) == '-' else Dialog(self._settingsFile.getLanguage())
#---------------------------------------------------------------------------------------------------------------#
# FILLING THE SETTINGS FILE WITH USER INPUT #
settingsMethods = self._settingsFile.getMethodsToResolveErrors()
for methodname, method in settingsMethods.items():
if methodname == "lang": # print a list of supporting languages and get user input for language setting
self._console.write(self._dialog.getMessageFor("chooseLang"))
langs = self._settingsFile.getSupportingLangs()
for key, value in langs.items():
self._console.write('[' + str(key) + ']')
self._console.write(value.upper() + ' ')
self._console.write('\n')
while (True):
langInput = int(self._console.readLine("\n--> "))
if langInput in langs.keys():
method(langs[langInput])
break
else:
self._console.writeLine(
self._dialog.getMessageFor("wrongInput"))
self._dialog.changeLanguage(self._settingsFile.getLanguage())
elif methodname == "username": # just get username fron input
while (True):
self._console.writeLine(
self._dialog.getMessageFor("getName"))
usernameInput = (self._console.readLine("\n--> "))
# checking the spelling of the username
if len(sub('[\t, \n, \r \s]', '', usernameInput)) >= 2:
method(usernameInput)
break
else:
continue
#---------------------------------------------------------------------------------------------------------------#
self._amelie = Amelie(self._settingsFile.getLanguage())
return
def __init__(self):
self.settings = Settings().getSettings()
self.user = None
self.firstname = None
self.surname = None
self.password = None
self.repassword = None
self.domain = None
self.email = None
def main():
global isDarwin, settings, hmqtt, applog, audiodev
# process cmdline arguments
loglevels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
ap = argparse.ArgumentParser()
ap.add_argument("-c",
"--conf",
required=True,
type=str,
help="path and name of the json configuration file")
ap.add_argument("-s",
"--syslog",
action='store_true',
default=False,
help="use syslog")
ap.add_argument("-d",
"--debug",
action='store',
type=int,
default='3',
nargs='?',
help="debug level, default is 3")
args = vars(ap.parse_args())
# logging setup
applog = logging.getLogger('mqttalarm')
#applog.setLevel(args['log'])
if args['syslog']:
applog.setLevel(logging.DEBUG)
handler = logging.handlers.SysLogHandler(address='/dev/log')
# formatter for syslog (no date/time or appname. Just msg.
formatter = logging.Formatter(
'%(name)s-%(levelname)-5s: %(message)-40s')
handler.setFormatter(formatter)
applog.addHandler(handler)
else:
logging.basicConfig(
level=logging.DEBUG,
datefmt="%H:%M:%S",
format='%(asctime)s %(levelname)-5s %(message)-40s')
audiodev = AudioDev()
isDarwin = audiodev.isDarwin
settings = Settings(args["conf"], audiodev, applog)
hmqtt = Homie_MQTT(settings, playUrl, chimeCb, sirenCb, strobeCb)
settings.print()
# fix debug levels
if args['debug'] == None:
debug_level = 3
else:
debug_level = args['debug']
# All we do now is loop over a 5 minute delay
while True:
time.sleep(5 * 60)
def __init__(self):
# Initialize the game and settings from Settings class
pygame.init()
# Initialize the game screen in fullscreen mode
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
# Creates instances of te other classes
self.settings = Settings(self)
self.playerscreen = Cards(self, "Player")
self.computerscreen = Cards(self, "Dealer")
self.pictures = Pictures(self)
# Deal first hand to each player
self.computerscreen.dealHand()
self.playerscreen.dealHand()
def __init__(self,
injected_open=None,
injected_eyeos_apps_storage=None,
injected_json=None,
injected_eyeos_apps_validator=None,
injected_application_api=None,
injected_principals_api=None,
injected_base_group=None,
injected_login_api=None):
self.eyeos_apps_storage = injected_eyeos_apps_storage or EyeosAppsStorage(
)
self.open = injected_open or open
self.json = injected_json or json
self.logger = Logger(__name__)
self.eyeos_apps_validator = injected_eyeos_apps_validator or EyeosAppsJsonValidator(
)
self.application_api = injected_application_api or Application()
self.principals_api = injected_principals_api or Principals()
self.principal_base_group = injected_base_group or Settings(
).getSettings()['principalservice']['base_group']
self.login_api = injected_login_api or Login()
def __init__(self, parent=None):
title = _("Preferences")
gtk.Dialog.__init__(self,
title=title,
parent=parent,
flags=gtk.DIALOG_MODAL
| gtk.DIALOG_DESTROY_WITH_PARENT
| gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_ACCEPT))
self.set_position(gtk.WIN_POS_CENTER)
self.set_border_width(6)
self.set_resizable(False)
self.set_icon_from_file(common.APP_ICON)
self.props.skip_taskbar_hint = True
self.gconf_client = Settings()
self._initialize_dialog_widgets()
self._populate_fields()
self._connect_fields()
self.connect("response", lambda self, *args: self.destroy())
def __init__(self):
self.logger = Logger(__name__)
self.settings = Settings().getSettings()
def __init__(self):
self.settings = Settings().getSettings()
self.key_manager = KeyManager(paths.keys_path)
def __init__(self, eyeos_apps=None):
self.eyeos_apps = eyeos_apps or EyeosApps()
self.settings = Settings().getSettings()
self.admin_username = self.settings['general']['administrator_username']
self.admin_domain = self.settings['general']['default_domain']
def __init__(self, proxy_ip=None, injected_eyeos_api_call=None):
self.proxy_ip = proxy_ip or Settings().getServiceIp('proxy')
self.systemgroups_url = 'https://{0}/systemgroups/v1/systemgroups'.format(
self.proxy_ip)
self.logger = Logger(__name__)
self.eyeos_api_call = injected_eyeos_api_call or EyeosApiCall()
def __init__(self, injected_mongo_client=None):
self.settings = Settings().getSettings()
self.forgot_password = injected_mongo_client or MongoClient(
Settings().getServiceIp('mongo')).eyeos.forgotpassword
def __init__(self, settings=None):
self.settings = settings or Settings()
self.logger = Logger(__name__)
def __init__(self, injected_proxy_ip=None, injected_api_call=None):
self.proxy_ip = injected_proxy_ip or Settings().getServiceIp('proxy')
self.api_call = injected_api_call or EyeosApiCall()
self.logger = Logger(__name__)
def __init__(self, injected_applications=None):
self.controlpanel_applications = injected_applications or MongoClient(
Settings().getServiceIp('mongo')).eyeos.controlpanelapplications
def main(args=None):
global logwriter, csvfile, ml_dict, applog, cur_state, dimcap, video_dev
global settings, hmqtt, show_windows, read_cam, read_local_resize, remote_cam
global camera_spin, camera_capture_to_file
global cap_prefix, backup_ml, have_cuda, use_three_arg
# process cmdline arguments
ap = argparse.ArgumentParser()
loglevels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
ap.add_argument("-c", "--conf", required=True, type=str,
help="path and name of the json configuration file")
ap.add_argument("-d", "--debug", action='store', type=bool, default=False,
nargs='?', help="show rectangles - no remote ml")
ap.add_argument("-s", "--syslog", action = 'store_true',
default=False, help="use syslog")
ap.add_argument("-a", "--algorithm", required=False, type=str, default=None,
help="detection algorithm override")
ap.add_argument("-m", "--movement", required=False, type=str,
help="movement algorithm override")
ap.add_argument("-e", "--events", required=False, action = "store_true", default=False,
help="log events to events.csv file")
ap.add_argument("-r", "--remote", required=False, action = "store_true", default=False,
help="log events to file")
ap.add_argument("-p", "--port", action='store', type=int, default='4466',
nargs='?', help="server port number, 4466 is default")
ap.add_argument('-l', '--log', default='DEBUG', choices=loglevels)
#ap.add_argument("-f", "--capture", required=False, type=str,
# help="path and name for image captures")
ap.add_argument('-3', "--three_arg", action = 'store_true',
default=False, help="findContours has 3 return values")
args = vars(ap.parse_args())
# frame capture setup
#if args['capture']:
# cap_prefix = args['capture']
#else:
# cap_prefix = None
# logging setup
applog = logging.getLogger('mqttcamera')
#applog.setLevel(args['log'])
if args['syslog']:
applog.setLevel(logging.DEBUG)
handler = logging.handlers.SysLogHandler(address = '/dev/log')
# formatter for syslog (no date/time or appname. Just msg, lux, luxavg
formatter = logging.Formatter('%(name)s-%(levelname)-5s: %(message)-30s %(lux)s %(sum)s')
handler.setFormatter(formatter)
f = LuxLogFilter()
applog.addFilter(f)
applog.addHandler(handler)
else:
logging.basicConfig(level=logging.DEBUG,datefmt="%H:%M:%S",format='%(asctime)s %(message)-40s %(lux)s %(sum)s')
f = LuxLogFilter()
applog.addFilter(f)
show_windows = False;
# state_machine log file
logwriter = None
csvfile = None
if args['events']:
csvfile = open('events.csv', 'w', newline='')
logwriter = csv.writer(csvfile, delimiter=',', quotechar='|')
print("logging...")
# Lets spin it up.
settings = Settings(args["conf"],
"/var/local/etc/mqtt-camera.json",
applog,
next_state)
# cmd line args override settings file.
if args['algorithm']:
settings.ml_algo = args['algorithm']
applog.debug("cmd line algo override: %s", settings.ml_algo)
if args['movement']:
settings.mv_algo = args['movement']
applog.debug("cmd line movement override: %s", settings.mv_algo)
if args['remote']:
settings.use_ml = 'remote'
'''
if args['port']:
print('override port')
settings.ml_port = args['port']
'''
if args['debug']:
show_windows = True
settings.use_ml = 'local'
if args['three_arg']:
# yet another damn global for a bug
use_three_arg = True
hmqtt = Homie_MQTT(settings,
settings.get_active_hold,
settings.set_active_hold)
settings.display()
settings.log = applog
if logwriter:
logwriter.writerow([settings.settings_serialize])
# setup ml_dict. Dealing with the backup is a bit hackish.
# Rpc proxy's are setup the first time they are needed.
have_cuda = is_cuda_cv()
applog.info(f"Have CUDA: {check_cuda()}")
if settings.use_ml == 'local':
applog.info(f"Will use CUDA: {have_cuda}")
ml_dict = build_ml_dict(False, None, None, applog)
cur_state = State.motion_wait
dimcap = (settings.camera_width, settings.camera_height)
# Almost Done with setup. Maybe.
if settings.camera_type == 'capture':
video_dev = cv2.VideoCapture(settings.camera_number)
read_cam = capture_read_cam
read_local_resize = capture_read_local_resize
remote_cam = capture_remote_cam
camera_spin = capture_camera_spin
camera_capture_to_file = capture_camera_capture_to_file
elif settings.camera_type == 'nvidia-rtsp':
video_dev = nvidia_cam_rtsp(settings.camera_number, settings.camera_width,
settings.camera_height, 0)
read_cam = stream_read_cam
read_local_resize = stream_read_local_resize
remote_cam = stream_remote_cam
camera_spin = stream_camera_spin
camera_capture_to_file = stream_camera_capture_to_file
elif settings.camera_type == 'ffmpeg-rtsp':
os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = "rtsp_transpo rt;udp"
video_dev = cv2.VideoCapture(settings.camera_number,cv2.CAP_FFMPEG)
read_cam = stream_read_cam
read_local_resize = stream_read_local_resize
remote_cam = stream_remote_cam
camera_spin = stream_camera_spin
camera_capture_to_file = stream_camera_capture_to_file
elif settings.camera_type == 'gst':
video_dev = cv2.VideoCapture(settings.camera_prep,cv2.CAP_GSTREAMER)
read_cam = stream_read_cam
read_local_resize = stream_read_local_resize
remote_cam = stream_remote_cam
camera_spin = stream_camera_spin
camera_capture_to_file = stream_camera_capture_to_file
elif settings.camera_type == 'stream':
video_dev = VideoStream(src=settings.camera_number, resolution = dimcap).start()
read_cam = imstream_read_cam
read_local_resize = imstream_read_local_resize
remote_cam = imstream_remote_cam
camera_spin = imstream_camera_spin
camera_capture_to_file = imstream_camera_capture_to_file
else:
log('bad camera_type in settings file')
exit()
# a cross coupling hack?
hmqtt.capture = camera_capture_to_file
init_timers(settings)
atexit.register(cleanup)
# now we pick between movement detectors and start the choosen one
if settings.mv_algo == 'adrian_1':
while True:
adrian_1_init()
while True:
adrian_1_movement(show_windows)
if cur_state == State.restart:
#log("restarting adrian_1 loop")
break
if show_windows and cv2.waitKey(40) == 27:
break
elif settings.mv_algo == 'intel':
while True:
intel_init()
while True:
intel_movement(show_windows, read_local_resize)
if cur_state == State.restart:
log("restarting intel loop")
breakl
else:
print("No Movement Algorithm chosen")
cleanup()
def __init__(self, injected_proxy_ip=None, injected_eyeos_api_call=None):
self.settings = Settings().getSettings()
self.proxy_ip = injected_proxy_ip or self.settings['general']['public_hostname']
self.logger = Logger(__name__)
self.eyeos_api_call = injected_eyeos_api_call or EyeosApiCall()
def __init__(self, screen):
'''
This class loads the pictures, buttonts and text messages that will
show up in the different stages of the game
'''
# Initialize the game screen and load dependent classes
self.screen = screen.screen
self.settings = Settings(self)
# Get coordinates of screen size and center points
self.screen_rect = self.screen.get_rect()
self.screen_rect_center = self.screen_rect.center
self.screen_x = self.screen_rect[2]
self.screen_y = self.screen_rect[3]
self.screen_center_x = self.screen_rect_center[0]
self.screen_center_y = self.screen_rect_center[1]
# Initalize flags and other variables
self.intro = True
self.player_has_hit = self.play_stage = self.end_stage = False
self.bet_stage = self.over_21 = self.player_hit = self.update = False
self.bankroll = 1000
self.current_bet = 0
'''Load up the pictures'''
# Load INTRO menu pictures
self.intro_text_1 = pygame.image.load("assets/intro_text_1.png")
self.intro_text_2 = pygame.image.load("assets/intro_text_2.png")
self.intro_cards = pygame.image.load("assets/intro_cards.png")
self.intro_quit = pygame.image.load("assets/Quit.png")
self.intro_play = pygame.image.load("assets/Play.png")
# Load BET STAGE menu pictures
self.bet_100 = pygame.image.load("assets/100.png")
self.bet_200 = pygame.image.load("assets/200.png")
self.bet_500 = pygame.image.load("assets/500.png")
self.bet_done = pygame.image.load("assets/submit.png")
self.bet_reset = pygame.image.load("assets/reset.png")
# Load ACTUAL GAME STAGE menu pictures
self.play_hit = pygame.image.load("assets/Hit.png")
self.play_double = pygame.image.load("assets/Double.png")
self.play_stand = pygame.image.load("assets/Stand.png")
''' Initialise onscreen text objects'''
# Load BET STAGE text objects
self.bet_text = self.settings.font.render("Please make your bets!",
True,
self.settings.textColor)
''' Set up the coordinates of each picture/text object'''
# set up INTRO stage elements' coordinates
self.intro_play_x = int(self.screen_x / 5 -
self.intro_play.get_rect()[2] / 2)
self.intro_play_y = int(self.screen_center_y -
self.intro_play.get_rect()[3] / 2)
self.intro_quit_x = int(self.screen_x * 4 / 5 -
self.intro_quit.get_rect()[2] / 2)
self.intro_quit_y = int(self.screen_center_y -
self.intro_quit.get_rect()[3] / 2)
self.intro_cards_x = int(self.screen_center_x -
self.intro_cards.get_rect()[2] / 2)
self.intro_cards_y = int(self.screen_center_y -
self.intro_cards.get_rect()[3] / 2)
self.intro_text_1_x = int(self.screen_center_x -
self.intro_text_1.get_rect()[2] / 2)
self.intro_text_1_y = int(self.screen_center_y / 3 -
self.intro_text_1.get_rect()[3] / 2)
self.intro_text_2_x = int(self.screen_center_x -
self.intro_text_2.get_rect()[2] / 2)
self.intro_text_2_y = int(self.screen_y -
self.screen_center_y * 1 / 3 -
self.intro_text_2.get_rect()[3] / 2)
# Set up BET STAGE elements' coordinates
self.bet_done_x = int(self.screen_x // 8 -
self.bet_done.get_rect()[2] // 2)
self.bet_done_y = int(self.screen_y * 3 // 5)
self.bet_100_x = int(self.screen_x * 2 // 8 -
self.bet_100.get_rect()[2] // 2)
self.bet_100_y = int(self.screen_y * 3 // 5 +
self.bet_100.get_rect()[3] // 4)
self.bet_200_x = int(self.screen_x * 4 // 8 -
self.bet_200.get_rect()[2] // 2)
self.bet_200_y = int(self.screen_y * 3 // 5 -
self.bet_200.get_rect()[3] // 4)
self.bet_500_x = int(self.screen_x * 6 // 8 -
self.bet_500.get_rect()[2] // 2)
self.bet_500_y = int(self.screen_y * 3 // 5 +
self.bet_500.get_rect()[3] // 4)
self.bet_reset_x = int(self.screen_x * 7 // 8 -
self.bet_reset.get_rect()[2] // 2)
self.bet_reset_y = int(self.screen_y * 3 // 5)
''' Card Game elements'''
# Set up ACTUAL GAME stage elements' coordinates
self.play_hit_x = int(self.screen_center_x // 2 -
self.play_hit.get_rect()[2] // 2)
self.play_hit_y = int(self.screen_center_y * 1.5)
self.play_double_x = int(self.screen_center_x -
self.play_double.get_rect()[2] // 2)
self.play_double_y = int(self.screen_center_y * 1.6)
self.play_stand_x = int(self.screen_center_x * 1.5 -
self.play_stand.get_rect()[2] // 2)
self.play_stand_y = int(self.screen_center_y * 1.5)
def main():
global settings, hmqtt, applog, turrets, tur_locks
# process cmdline arguments
loglevels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
ap = argparse.ArgumentParser()
ap.add_argument("-c", "--conf", required=True, type=str,
help="path and name of the json configuration file")
ap.add_argument("-s", "--syslog", action = 'store_true',
default=False, help="use syslog")
ap.add_argument("-d", "--debug", action='store', type=int, default='3',
nargs='?', help="debug level, default is 3")
args = vars(ap.parse_args())
# logging setup
applog = logging.getLogger('mqttlaser')
#applog.setLevel(args['log'])
if args['syslog']:
applog.setLevel(logging.DEBUG)
handler = logging.handlers.SysLogHandler(address = '/dev/log')
# formatter for syslog (no date/time or appname. Just msg.
formatter = logging.Formatter('%(name)s-%(levelname)-5s: %(message)-40s')
handler.setFormatter(formatter)
applog.addHandler(handler)
else:
logging.basicConfig(level=logging.DEBUG,datefmt="%H:%M:%S",format='%(asctime)s %(levelname)-5s %(message)-40s')
#GPIO.setmode(GPIO.BOARD)
settings = Settings(args["conf"],
applog)
# init turrets from settings. Do any of the turret
# use PCA9685, if so, we init that device here.
init_pca = False
kit = None
for t in settings.turrets:
if t.get('laser_pin', False):
init_pca = True
if init_pca:
applog.info('initializing PCA9685')
kit = ServoKit(channels=16)
# init mqtt server connection
hmqtt = Homie_MQTT(settings, turretCB)
for i in range(0, len(settings.turrets)):
turrets.append(Turret(settings.turrets[i], kit, applog))
tur_locks.append(Lock())
settings.print()
# fix debug levels
if args['debug'] == None:
debug_level = 3
else:
debug_level = args['debug']
atexit.register(cleanup)
# All we do now is loop over a 5 minute delay
# and let the threads work.
while True:
time.sleep(5 * 60)
def __init__(self):
self.settings = Settings()
self.logger = Logger(__name__)
self.entrypoint = "proxy"
def configure(self, *, settings=None):
action = (settings
or Settings().getSettings())['logs']['warning_action']
self.warnings.filterwarnings(action)
self.warnings.formatwarning = self._format_warning
def main():
global settings, hmqtt, log, env_home, mq_thr
global mainwin,menu_fr,alarm_btn,voice_btn,laser_btn,login_btn,logoff_btn
global menu_fr, panel_fr, center_img, pnl_middle, message
global pnl_hdr, status_hdr, msg_hdr, content
global device,saver_cvs,stroke_fill, screen_height, screen_width
global font1,font2,font3,devFnt
env_home = os.getenv('HOME')
if sys.platform == 'darwin':
isOSX = True
print('Darwin not really supported')
ap = argparse.ArgumentParser()
ap.add_argument("-c", "--conf", required=True, type=str,
help="path and name of the json configuration file")
ap.add_argument("-s", "--syslog", action = 'store_true',
default=False, help="use syslog")
args = vars(ap.parse_args())
# logging setup
log = logging.getLogger('testbear')
#applog.setLevel(args['log'])
if args['syslog']:
log.setLevel(logging.DEBUG)
handler = logging.handlers.SysLogHandler(address = '/dev/log')
# formatter for syslog (no date/time or appname. Just msg, lux, luxavg
formatter = logging.Formatter('%(name)s-%(levelname)-5s: %(message)-30s')
handler.setFormatter(formatter)
log.addHandler(handler)
else:
logging.basicConfig(level=logging.DEBUG,datefmt="%H:%M:%S",format='%(asctime)s %(levelname)-5s %(message)-40s')
settings = Settings(args["conf"],
log)
settings.print()
try:
hmqtt = Homie_MQTT(settings, on_mqtt_msg)
except:
log.fail('failed mqtt setup')
exit()
tkroot = Tk()
mainwin = Toplevel(tkroot)
# new:
#root.wait_visibility(saver_cvs)
mainwin.wm_attributes("-topmost", True)
mainwin.attributes('-fullscreen', True) # required, else ghost window on top
# old:
#root.geometry('900x580')
mainwin.protocol("WM_DELETE_WINDOW", do_quit)
st = ttk.Style()
st.theme_use('alt') # better than 'default', IMO
st.configure("Menlo.TButton", font = ('Menlo', 16, 'bold'),
height=20, width=10)
st = ttk.Style()
st.configure("Menlo.TRadiobutton", font = ('Menlo', 12))
st = ttk.Style()
st.configure("MenloSm.TLabel", font = ('Menlo', 14))
st = ttk.Style()
st.configure("MenloMd.TLabel", font = ('Menlo', 16))
st = ttk.Style()
st.configure("MenloMd.TLabel", font = ('Menlo', 18))
st = ttk.Style()
st.configure("Menlo.TCheckbutton", font = ('Menlo', 16),
height=10, width=10)
st = ttk.Style()
st.configure("Menlo.TCombobox", font = ('Menlo', 16),
height=16, width=10)
content = ttk.Frame(mainwin)
menu_fr = ttk.Frame(content, width=100, height=580, borderwidth=5)
menu_fr.pack(side=LEFT, expand=True)
st_p = 4
alarm_btn = ttk.Button(menu_fr, text ="Alarm", style='Menlo.TButton',
command=alarm_panel)
alarm_btn['state'] = 'disabled'
alarm_btn.grid(row=st_p + 2)
voice_btn = ttk.Button(menu_fr, text = "Voice", style='Menlo.TButton',
command=mycroft_panel)
voice_btn.grid(row=st_p + 3)
voice_btn['state'] = 'disabled'
laser_btn = ttk.Button(menu_fr, text = "Lasers", style='Menlo.TButton',
command=laser_panel)
laser_btn.grid(row=st_p + 4)
laser_btn['state'] = 'disabled'
login_btn = ttk.Button(menu_fr, text = "Login", style='Menlo.TButton',
command = on_login)
login_btn.grid(row=st_p + 5)
logoff_btn = ttk.Button(menu_fr, text = "Logoff", style='Menlo.TButton',
command = on_logoff)
logoff_btn.grid(row=st_p + 6)
logoff_btn['state'] = 'disabled'
start_panel(True)
# fill in the right side panel.
content.pack()
# ----- Now the screen saver panel ---
device= Toplevel(tkroot)
# Tkinter Window Configurations
#device.wait_visibility(saver_cvs)
device.wm_attributes('-alpha',1)
device.wm_attributes("-topmost", False)
#device.overrideredirect(1)
device.attributes('-fullscreen', True)
device.attributes("-zoomed", True)
#device.attributes("-toolwindow", 1)
screen_width = device.winfo_screenwidth()
screen_height = device.winfo_screenheight()
# create canvas
saver_cvs = Canvas(device, background='black', borderwidth = 0)
saver_cvs.create_rectangle(0, 0, screen_width, screen_height, fill = 'black')
saver_cvs.pack(expand="yes",fill="both")
font1 = font.Font(family=settings.font1, size=settings.font1sz[0])
font2 = font.Font(family=settings.font2, size=settings.font2sz[0])
font3 = font.Font(family=settings.font3, size=settings.font3sz[0])
fnt = settings.deflt_font
set_font(fnt)
stroke_fill = settings.stroke_fill
for seq in ['<Any-KeyPress>', '<Any-Button> ', '<Any-Motion>']:
device.bind_all(seq, saver_closing)
# arrange toplevel windows
saver_running = False
device.withdraw()
mainwin.state('normal')
log.info(f'starting mainloop fg: {mainwin.state()}, bg: {device.state()}')
# set screensaver timer
screen_timer_reset()
# NOTE: mqtt messages seem to arrive just fine. Even though we
# don't seem to accomodate them
mainwin.mainloop()
while True:
time.sleep(10)
help="path and name of the json configuration file")
ap.add_argument("-d",
"--debug",
action='store',
type=int,
default='3',
nargs='?',
help="debug level, default is 3")
args = vars(ap.parse_args())
# fix debug levels
if args['debug'] == None:
debug_level = 3
else:
debug_level = args['debug']
settings = Settings(args["conf"], None, log)
hmqtt = Homie_MQTT(settings)
settings.print()
# Now we loop forever
unresp = 0
while True:
# get the ups data
status = {}
try:
with PyNUTClient() as s:
status = s.list_vars(settings.nut_ups)
except:
pass
# did we get good values?
def __init__(self, settings=None):
self.settings = settings or Settings()
def __init__(self):
self.logger = Logger(__name__)
self.userManagement = UsersManagement()
self.settings = Settings().getSettings()
self.domain = Domain()
def __init__(self, injectedSettings=None, injectedSubprocess=None):
self.logger = Logger(__name__)
self.settings = injectedSettings or Settings().getSettings()
self.subprocess = injectedSubprocess or subprocess
