put octoprint api functions in own class

data/de.xythobuz.octotray.desktop

 [Desktop Entry]
 Type=Application
-Version=0.4
+Version=0.5
 Name=OctoTray
 Comment=Control OctoPrint instances from system tray
 Path=/usr/bin

dist/PKGBUILD

 # Maintainer: Thomas Buck <thomas@xythobuz.de>
 pkgname=OctoTray
-pkgver=0.4
+pkgver=0.5
 pkgrel=1
 pkgdesc="Control OctoPrint instances from system tray"
 arch=('any')
 license=('unknown')
 depends=('python-pyqt5')
-source=("octotray.py"
+source=("octotray"
         "octotray_icon.png"
         "de.xythobuz.octotray.desktop")
 md5sums=(SKIP

dist/setup_mac.py

 APP_NAME = "OctoTray"
 APP = [ 'main.py' ]
 DATA_FILES = [ 'octotray_icon.png' ]
-VERSION="0.4.0"
+VERSION="0.5.0"
 
 OPTIONS = {
     'argv_emulation': True,

src/APIOctoprint.py

+#!/usr/bin/env python3
+
+# OctoTray Linux Qt System Tray OctoPrint client
+#
+# APIOctoprint.py
+#
+# HTTP API for OctoPrint.
+
+import json
+import time
+import urllib.parse
+import urllib.request
+import operator
+import socket
+
+class APIOctoprint():
+    statesWithWarning = [
+        "printing", "pausing", "paused"
+    ]
+
+    def __init__(self, parent, host, key):
+        self.parent = parent
+        self.host = host
+        self.key = key
+
+    # return list of tuples ( "name", func(name) )
+    # with all available commands.
+    # call function in with name of action!
+    def getAvailableCommands(self):
+        self.method = self.getMethod()
+        print("Printer " + self.host + " has method " + self.method)
+
+        commands = []
+
+        if self.method == "unknown":
+            # nothing available
+            return commands
+
+        # always add available system commands
+        systemCommands = self.getSystemCommands()
+        for sc in systemCommands:
+            commands.append((sc, self.callSystemCommand))
+
+        if self.method == "psucontrol":
+            # support for psucontrol plugin
+            commands.append(("Turn On PSU", self.setPower))
+            commands.append(("Turn Off PSU", self.setPower))
+
+        return commands
+
+    ############
+    # HTTP API #
+    ############
+
+    def sendRequest(self, headers, path, content = None):
+        url = "http://" + self.host + "/api/" + path
+        if content == None:
+            request = urllib.request.Request(url, None, headers)
+        else:
+            data = content.encode('ascii')
+            request = urllib.request.Request(url, data, headers)
+
+        try:
+            with urllib.request.urlopen(request, None, self.parent.networkTimeout) as response:
+                text = response.read()
+                return text
+        except (urllib.error.URLError, urllib.error.HTTPError) as error:
+            print("Error requesting URL \"" + url + "\": \"" + str(error) + "\"")
+            return "error"
+        except socket.timeout:
+            print("Timeout waiting for response to \"" + url + "\"")
+            return "timeout"
+
+    def sendPostRequest(self, path, content):
+        headers = {
+            "Content-Type": "application/json",
+            "X-Api-Key": self.key
+        }
+        return self.sendRequest(headers, path, content)
+
+    def sendGetRequest(self, path):
+        headers = {
+            "X-Api-Key": self.key
+        }
+        return self.sendRequest(headers, path)
+
+    #####################
+    # Command discovery #
+    #####################
+
+    def getMethod(self):
+        r = self.sendGetRequest("plugin/psucontrol")
+        if r == "timeout":
+            return "unknown"
+
+        try:
+            rd = json.loads(r)
+            if "isPSUOn" in rd:
+                return "psucontrol"
+        except json.JSONDecodeError:
+            pass
+
+        r = self.sendGetRequest("system/commands/custom")
+        if r == "timeout":
+            return "unknown"
+
+        try:
+            rd = json.loads(r)
+            for c in rd:
+                if "action" in c:
+                    # we have some custom commands and no psucontrol
+                    # so lets try to use that instead of skipping
+                    # the printer completely with 'unknown'
+                    return "system"
+        except json.JSONDecodeError:
+            pass
+
+        return "unknown"
+
+    def getSystemCommands(self):
+        l = []
+        r = self.sendGetRequest("system/commands/custom")
+        try:
+            rd = json.loads(r)
+
+            if len(rd) > 0:
+                print("system commands available for " + self.host + ":")
+
+            for c in rd:
+                if "action" in c:
+                    print("  - " + c["action"])
+                    l.append(c["action"])
+        except json.JSONDecodeError:
+            pass
+        return l
+
+    #################
+    # Safety Checks #
+    #################
+
+    def stateSafetyCheck(self, actionString):
+        state = self.getState()
+        if state.lower() in self.statesWithWarning:
+            if self.parent.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to " + actionString + "?", True, True) == False:
+                return True
+        return False
+
+    def tempSafetyCheck(self, actionString):
+        if self.getTemperatureIsSafe() == False:
+            if self.parent.showDialog("OctoTray Warning", "The printer seems to still be hot!", "Do you really want to " + actionString + "?", True, True) == False:
+                return True
+        return False
+
+    def safetyCheck(self, actionString):
+        if self.stateSafetyCheck(actionString):
+            return True
+        if self.tempSafetyCheck(actionString):
+            return True
+        return False
+
+    ##################
+    # Power Toggling #
+    ##################
+
+    def callSystemCommand(self, name):
+        if "off" in name.lower():
+            if self.safetyCheck("run '" + name + "'"):
+                return
+
+        cmd = urllib.parse.quote(name)
+        self.sendPostRequest("system/commands/custom/" + cmd, '')
+
+    def setPower(self, name):
+        if "off" in name.lower():
+            if self.safetyCheck(name):
+                return
+
+        cmd = "turnPSUOff"
+        if "on" in name.lower():
+            cmd = "turnPSUOn"
+
+        return self.sendPostRequest("plugin/psucontrol", '{ "command":"' + cmd + '" }')
+
+    def turnOn(self):
+        if self.method == "psucontrol":
+            self.setPower("on")
+        elif self.method == "system":
+            cmds = self.getSystemCommands()
+            for cmd in cmds:
+                if "on" in cmd:
+                    self.callSystemCommand(cmd)
+                    break
+
+    def turnOff(self):
+        if self.method == "psucontrol":
+            self.setPower("off")
+        elif self.method == "system":
+            cmds = self.getSystemCommands()
+            for cmd in cmds:
+                if "off" in cmd:
+                    self.callSystemCommand(cmd)
+                    break
+
+    ######################
+    # Status Information #
+    ######################
+
+    def getTemperatureIsSafe(self, limit = 50.0):
+        r = self.sendGetRequest("printer")
+        try:
+            rd = json.loads(r)
+
+            if "temperature" in rd:
+                if ("tool0" in rd["temperature"]) and ("actual" in rd["temperature"]["tool0"]):
+                    if rd["temperature"]["tool0"]["actual"] > limit:
+                        return False
+
+                if ("tool1" in rd["temperature"]) and ("actual" in rd["temperature"]["tool1"]):
+                    if rd["temperature"]["tool1"]["actual"] > limit:
+                        return False
+        except json.JSONDecodeError:
+            pass
+        return True
+
+    def getTemperatureString(self):
+        r = self.sendGetRequest("printer")
+        s = ""
+        try:
+            rd = json.loads(r)
+        except json.JSONDecodeError:
+            return s
+
+        if ("state" in rd) and ("text" in rd["state"]):
+            s += rd["state"]["text"]
+            if "temperature" in rd:
+                s += " - "
+
+        if "temperature" in rd:
+            if ("bed" in rd["temperature"]) and ("actual" in rd["temperature"]["bed"]):
+                s += "B"
+                s += "%.1f" % rd["temperature"]["bed"]["actual"]
+                if "target" in rd["temperature"]["bed"]:
+                    s += "/"
+                    s += "%.1f" % rd["temperature"]["bed"]["target"]
+                s += " "
+
+            if ("tool0" in rd["temperature"]) and ("actual" in rd["temperature"]["tool0"]):
+                s += "T"
+                s += "%.1f" % rd["temperature"]["tool0"]["actual"]
+                if "target" in rd["temperature"]["tool0"]:
+                    s += "/"
+                    s += "%.1f" % rd["temperature"]["tool0"]["target"]
+                s += " "
+
+            if ("tool1" in rd["temperature"]) and ("actual" in rd["temperature"]["tool1"]):
+                s += "T"
+                s += "%.1f" % rd["temperature"]["tool1"]["actual"]
+                if "target" in rd["temperature"]["tool1"]:
+                    s += "/"
+                    s += "%.1f" % rd["temperature"]["tool1"]["target"]
+                s += " "
+        return s.strip()
+
+    def getState(self):
+        r = self.sendGetRequest("job")
+        try:
+            rd = json.loads(r)
+            if "state" in rd:
+                return rd["state"]
+        except json.JSONDecodeError:
+            pass
+        return "Unknown"
+
+    def getProgress(self):
+        r = self.sendGetRequest("job")
+        try:
+            rd = json.loads(r)
+            if "progress" in rd:
+                return rd["progress"]
+        except json.JSONDecodeError:
+            pass
+        return "Unknown"
+
+    def getName(self):
+        r = self.sendGetRequest("printerprofiles")
+        try:
+            rd = json.loads(r)
+            if "profiles" in rd:
+                p = next(iter(rd["profiles"]))
+                if "name" in rd["profiles"][p]:
+                    return rd["profiles"][p]["name"]
+        except json.JSONDecodeError:
+            pass
+        return self.host
+
+    def getProgressString(self):
+        s = ""
+        progress = self.getProgress()
+        if ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress) and (progress["completion"] != None) and (progress["printTime"] != None) and (progress["printTimeLeft"] != None):
+            s += "%.1f%%" % progress["completion"]
+            s += " - runtime "
+            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTime"]))
+            s += " - "
+            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTimeLeft"])) + " left"
+        return s
+
+    ###################
+    # Printer Actions #
+    ###################
+
+    def callHoming(self, axes = "xyz"):
+        if self.stateSafetyCheck("home it"):
+            return
+
+        axes_string = ''
+        for i in range(0, len(axes)):
+            axes_string += '"' + str(axes[i]) + '"'
+            if i < (len(axes) - 1):
+                axes_string += ', '
+
+        self.sendPostRequest("printer/printhead", '{ "command": "home", "axes": [' + axes_string + '] }')
+
+    def callMove(self, axis, dist, relative = True):
+        if self.stateSafetyCheck("move it"):
+            return
+
+        absolute = ''
+        if relative == False:
+            absolute = ', "absolute": true'
+
+        self.sendPostRequest("printer/printhead", '{ "command": "jog", "' + str(axis) + '": ' + str(dist) + ', "speed": ' + str(self.jogMoveSpeed) + absolute + ' }')
+
+    def callPauseResume(self):
+        if self.stateSafetyCheck("pause/resume"):
+            return
+        self.sendPostRequest("job", '{ "command": "pause", "action": "toggle" }')
+
+    def callJobCancel(self):
+        if self.stateSafetyCheck("cancel"):
+            return
+        self.sendPostRequest("job", '{ "command": "cancel" }')
+
+    def statusDialog(self):
+        progress = self.getProgress()
+        s = self.host + "\n"
+        warning = False
+        if ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress) and (progress["completion"] != None) and (progress["printTime"] != None) and (progress["printTimeLeft"] != None):
+            s += "%.1f%% Completion\n" % progress["completion"]
+            s += "Printing since " + time.strftime("%H:%M:%S", time.gmtime(progress["printTime"])) + "\n"
+            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTimeLeft"])) + " left"
+        elif ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress):
+            s += "No job is currently running"
+        else:
+            s += "Could not read printer status!"
+            warning = True
+        t = self.getTemperatureString()
+        if len(t) > 0:
+            s += "\n" + t
+        self.parent.showDialog("OctoTray Status", s, None, False, warning)
+
+    #################
+    # File Handling #
+    #################
+
+    def getRecentFiles(self, count):
+        r = self.sendGetRequest("files?recursive=true")
+        files = []
+        try:
+            rd = json.loads(r)
+            if "files" in rd:
+                t = [f for f in rd["files"] if "date" in f]
+                fs = sorted(t, key=operator.itemgetter("date"), reverse=True)
+                for f in fs[:count]:
+                    files.append((f["name"], f["origin"] + "/" + f["path"]))
+        except json.JSONDecodeError:
+            pass
+        return files
+
+    def printFile(self, path):
+        self.sendPostRequest("files/" + path, '{ "command": "select", "print": true }')
+
+    ###############
+    # Temperature #
+    ###############
+
+    def setTemperature(self, what, temp):
+        path = "printer/bed"
+        s = "{\"command\": \"target\", \"target\": " + temp + "}"
+
+        if "tool" in what:
+            path = "printer/tool"
+            s = "{\"command\": \"target\", \"targets\": {\"" + what + "\": " + temp + "}}"
+
+        if temp == None:
+            temp = 0
+
+        self.sendPostRequest(path, s)
+
+    def printerHeatTool(self, temp):
+        self.setTemperature("tool0", temp)
+
+    def printerHeatBed(self, temp):
+        self.setTemperature("bed", temp)
+
+    def printerCooldown(self):
+        if self.stateSafetyCheck("cool it down"):
+            return
+
+        self.setTemperature("tool0", 0)
+        self.setTemperature("bed", 0)

src/CamWindow.py

         self.manager.finished.connect(self.handleResponse)
         self.parent = parent
         self.printer = printer
-        self.host = self.printer[0]
-        self.url = "http://" + self.host + ":8080/?action=snapshot"
+        self.url = "http://" + self.printer.host + ":8080/?action=snapshot"
 
         self.setWindowTitle(parent.name + " Webcam Stream")
         self.setWindowIcon(parent.icon)
         box.addWidget(self.statusLabel, 0)
         box.setAlignment(self.statusLabel, Qt.AlignHCenter)
 
-        self.method = self.parent.getMethod(self.printer[0], self.printer[1])
+        self.method = self.printer.api.getMethod()
         if self.method != "unknown":
             controls_power = QHBoxLayout()
             box.addLayout(controls_power, 0)
         self.loadStatus()
 
     def pauseResume(self):
-        self.parent.printerPauseResume(self.printer)
+        self.printer.api.callPauseResume()
 
     def cancelJob(self):
-        self.parent.printerJobCancel(self.printer)
+        self.printer.api.callJobCancel()
 
     def moveXP(self):
-        self.parent.printerMoveAction(self.printer, "x", int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("x", int(self.parent.jogMoveLength), True)
 
     def moveXM(self):
-        self.parent.printerMoveAction(self.printer, "x", -1 * int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("x", -1 * int(self.parent.jogMoveLength), True)
 
     def moveYP(self):
-        self.parent.printerMoveAction(self.printer, "y", int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("y", int(self.parent.jogMoveLength), True)
 
     def moveYM(self):
-        self.parent.printerMoveAction(self.printer, "y", -1 * int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("y", -1 * int(self.parent.jogMoveLength), True)
 
     def moveZP(self):
-        self.parent.printerMoveAction(self.printer, "z", int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("z", int(self.parent.jogMoveLength), True)
 
     def moveZM(self):
-        self.parent.printerMoveAction(self.printer, "z", -1 * int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("z", -1 * int(self.parent.jogMoveLength), True)
 
     def homeX(self):
-        self.parent.printerHomingAction(self.printer, "x")
+        self.printer.api.callHoming("x")
 
     def homeY(self):
-        self.parent.printerHomingAction(self.printer, "y")
+        self.printer.api.callHoming("y")
 
     def homeZ(self):
-        self.parent.printerHomingAction(self.printer, "z")
+        self.printer.api.callHoming("z")
 
     def homeAll(self):
-        self.parent.printerHomingAction(self.printer, "xyz")
+        self.printer.api.callHoming("xyz")
 
     def turnOn(self):
-        if self.method == "psucontrol":
-            self.parent.printerOnAction(self.printer)
-        elif self.method == "system":
-            cmds = self.parent.getSystemCommands(self.printer[0], self.printer[1])
-            for cmd in cmds:
-                if "on" in cmd:
-                    self.parent.setSystemCommand(self.printer[0], self.printer[1], cmd)
-                    break
+        self.printer.api.turnOn()
 
     def turnOff(self):
-        if self.method == "psucontrol":
-            self.parent.printerOffAction(self.printer)
-        elif self.method == "system":
-            cmds = self.parent.getSystemCommands(self.printer[0], self.printer[1])
-            for cmd in cmds:
-                if "off" in cmd:
-                    self.parent.setSystemCommand(self.printer[0], self.printer[1], cmd)
-                    break
+        self.printer.api.turnOff()
 
     def cooldown(self):
-        self.parent.printerCooldown(self.printer)
+        self.printer.api.printerCooldown(self.printer)
 
     def preheatTool(self):
-        self.parent.printerHeatTool(self.printer)
+        self.printer.api.printerHeatTool(self.printer.tempTool)
 
     def preheatBed(self):
-        self.parent.printerHeatBed(self.printer)
+        self.printer.api.printerHeatBed(self.printer.tempBed)
 
     def getHost(self):
-        return self.host
+        return self.printer.host
 
     def sliderChanged(self):
         self.slideLabel.setText(str(self.slider.value() * self.sliderFactor) + "ms")
 
     def loadStatus(self):
         s = "Status: "
-        t = self.parent.getTemperatureString(self.host, self.printer[1])
+        t = self.printer.api.getTemperatureString()
         if len(t) > 0:
             s += t
         else:
             s += "Unknown"
 
-        progress = self.parent.getProgress(self.host, self.printer[1])
-        if ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress) and (progress["completion"] != None) and (progress["printTime"] != None) and (progress["printTimeLeft"] != None):
-            s += " - %.1f%%" % progress["completion"]
-            s += " - runtime "
-            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTime"]))
-            s += " - "
-            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTimeLeft"])) + " left"
+        s += " - "
+
+        p = self.printer.api.getProgressString()
+        if len(p) > 0:
+            s += p
+        else:
+            s += "Unknown"
 
         self.statusLabel.setText(s)
         self.scheduleLoadStatus()

src/OctoTray.py

 #
 # Main application logic.
 
-import json
 import sys
-import time
-import urllib.parse
-import urllib.request
-import operator
-import socket
 from os import path
 from PyQt5 import QtNetwork
 from PyQt5.QtWidgets import QSystemTrayIcon, QAction, QMenu, QMessageBox, QDesktopWidget
 from CamWindow import CamWindow
 from SettingsWindow import SettingsWindow
 from MainWindow import MainWindow
+from APIOctoprint import APIOctoprint
+
+class Printer(object):
+    # field 'api' for actual I/O
+    # field 'host' and 'key' for credentials
+    pass
 
 class OctoTray():
     name = "OctoTray"
     vendor = "xythobuz"
-    version = "0.4"
+    version = "0.5"
 
     iconName = "octotray_icon.png"
     iconPaths = [
 
     networkTimeout = 2.0 # in s
 
-    # list of lists, inner lists contain printer data:
-    # first elements as in SettingsWindow.columns
-    # 0=host 1=key 2=tool-preheat 3=bed-preheat
-    # rest used for system-commands, menu, actions
+    # list of Printer objects
     printers = []
 
-    statesWithWarning = [
-        "Printing", "Pausing", "Paused"
-    ]
-
     camWindows = []
     settingsWindow = None
 
 
         unknownCount = 0
         for p in self.printers:
-            method = self.getMethod(p[0], p[1])
-            print("Printer " + p[0] + " has method " + method)
-            if method == "unknown":
-                unknownCount += 1
+            p.api = APIOctoprint(self, p.host, p.key)
+            p.menus = []
+
+            commands = p.api.getAvailableCommands()
 
-                action = QAction(p[0])
+            # don't populate menu when no methods are available
+            if len(commands) == 0:
+                unknownCount += 1
+                action = QAction(p.host)
                 action.setEnabled(False)
-                p.append(action)
+                p.menus.append(action)
                 self.menu.addAction(action)
-
                 continue
 
-            commands = self.getSystemCommands(p[0], p[1])
-            p.append(commands)
-
-            menu = QMenu(self.getName(p[0], p[1]))
-            p.append(menu)
+            # top level menu for this printer
+            menu = QMenu(p.api.getName())
+            p.menus.append(menu)
             self.menu.addMenu(menu)
 
-            if method == "psucontrol":
-                action = QAction("Turn On PSU")
-                action.triggered.connect(lambda chk, x=p: self.printerOnAction(x))
-                p.append(action)
-                menu.addAction(action)
-
-                action = QAction("Turn Off PSU")
-                action.triggered.connect(lambda chk, x=p: self.printerOffAction(x))
-                p.append(action)
-                menu.addAction(action)
-
-            for i in range(0, len(commands)):
-                action = QAction(commands[i].title())
-                action.triggered.connect(lambda chk, x=p, y=i: self.printerSystemCommandAction(x, y))
-                p.append(action)
+            # create action for all available commands
+            for cmd in commands:
+                name, func = cmd
+                action = QAction(name)
+                action.triggered.connect(lambda chk, p=p, n=name, f=func: p.api.f(n))
+                p.menus.append(action)
                 menu.addAction(action)
 
-            if (p[2] != None) or (p[3] != None):
+            if (p.tempTool != None) or (p.tempBed != None):
                 menu.addSeparator()
 
-            if p[2] != None:
+            if p.tempTool != None:
                 action = QAction("Preheat Tool")
-                action.triggered.connect(lambda chk, x=p: self.printerHeatTool(x))
-                p.append(action)
+                action.triggered.connect(lambda chk, p=p: p.api.printerHeatTool(p.tempTool))
+                p.menus.append(action)
                 menu.addAction(action)
 
-            if p[3] != None:
+            if p.tempBed != None:
                 action = QAction("Preheat Bed")
-                action.triggered.connect(lambda chk, x=p: self.printerHeatBed(x))
-                p.append(action)
+                action.triggered.connect(lambda chk, p=p: p.api.printerHeatBed(p.tempBed))
+                p.menus.append(action)
                 menu.addAction(action)
 
-            if (p[2] != None) or (p[3] != None):
+            if (p.tempTool != None) or (p.tempBed != None):
                 action = QAction("Cooldown")
-                action.triggered.connect(lambda chk, x=p: self.printerCooldown(x))
-                p.append(action)
+                action.triggered.connect(lambda chk, p=p: p.api.printerCooldown())
+                p.menus.append(action)
                 menu.addAction(action)
 
             menu.addSeparator()
 
             fileMenu = QMenu("Recent Files")
-            p.append(fileMenu)
+            p.menus.append(fileMenu)
             menu.addMenu(fileMenu)
 
-            files = self.getRecentFiles(p[0], p[1], 10)
+            files = p.api.getRecentFiles(10)
             for f in files:
                 fileName, filePath = f
                 action = QAction(fileName)
-                action.triggered.connect(lambda chk, x=p, y=filePath: self.printerFilePrint(x, y))
-                p.append(action)
+                action.triggered.connect(lambda chk, p=p, f=filePath: p.api.printFile(f))
+                p.menus.append(action)
                 fileMenu.addAction(action)
 
             action = QAction("Get Status")
-            action.triggered.connect(lambda chk, x=p: self.printerStatusAction(x))
-            p.append(action)
+            action.triggered.connect(lambda chk, p=p: p.api.statusDialog())
+            p.menus.append(action)
             menu.addAction(action)
 
             action = QAction("Show Webcam")
             action.triggered.connect(lambda chk, x=p: self.printerWebcamAction(x))
-            p.append(action)
+            p.menus.append(action)
             menu.addAction(action)
 
             action = QAction("Open Web UI")
             action.triggered.connect(lambda chk, x=p: self.printerWebAction(x))
-            p.append(action)
+            p.menus.append(action)
             menu.addAction(action)
 
         self.menu.addSeparator()
         l = settings.beginReadArray("printers")
         for i in range(0, l):
             settings.setArrayIndex(i)
-            p = []
-            p.append(settings.value("host"))
-            p.append(settings.value("key"))
-            p.append(settings.value("tool_preheat"))
-            p.append(settings.value("bed_preheat"))
+            p = Printer()
+            p.host = settings.value("host")
+            p.key = settings.value("key")
+            p.tempTool = settings.value("tool_preheat")
+            p.tempBed = settings.value("bed_preheat")
             printers.append(p)
         settings.endArray()
         return printers
         for i in range(0, len(printers)):
             p = printers[i]
             settings.setArrayIndex(i)
-            settings.setValue("host", p[0])
-            settings.setValue("key", p[1])
-            settings.setValue("tool_preheat", p[2])
-            settings.setValue("bed_preheat", p[3])
+            settings.setValue("host", p.host)
+            settings.setValue("key", p.key)
+            settings.setValue("tool_preheat", p.tempTool)
+            settings.setValue("bed_preheat", p.tempBed)
         settings.endArray()
         del settings
 
         else:
             return False
 
-    def sendRequest(self, host, headers, path, content = None):
-        url = "http://" + host + "/api/" + path
-        if content == None:
-            request = urllib.request.Request(url, None, headers)
-        else:
-            data = content.encode('ascii')
-            request = urllib.request.Request(url, data, headers)
-
-        try:
-            with urllib.request.urlopen(request, None, self.networkTimeout) as response:
-                text = response.read()
-                return text
-        except (urllib.error.URLError, urllib.error.HTTPError) as error:
-            print("Error requesting URL \"" + url + "\": \"" + str(error) + "\"")
-            return "error"
-        except socket.timeout:
-            print("Timeout waiting for response to \"" + url + "\"")
-            return "timeout"
-
-    def sendPostRequest(self, host, key, path, content):
-        headers = {
-            "Content-Type": "application/json",
-            "X-Api-Key": key
-        }
-        return self.sendRequest(host, headers, path, content)
-
-    def sendGetRequest(self, host, key, path):
-        headers = {
-            "X-Api-Key": key
-        }
-        return self.sendRequest(host, headers, path)
-
-    def getTemperatureIsSafe(self, host, key):
-        r = self.sendGetRequest(host, key, "printer")
-        try:
-            rd = json.loads(r)
-
-            if "temperature" in rd:
-                if ("tool0" in rd["temperature"]) and ("actual" in rd["temperature"]["tool0"]):
-                    if rd["temperature"]["tool0"]["actual"] > 50.0:
-                        return False
-
-                if ("tool1" in rd["temperature"]) and ("actual" in rd["temperature"]["tool1"]):
-                    if rd["temperature"]["tool1"]["actual"] > 50.0:
-                        return False
-        except json.JSONDecodeError:
-            pass
-        return True
-
-    def getTemperatureString(self, host, key):
-        r = self.sendGetRequest(host, key, "printer")
-        s = ""
-        try:
-            rd = json.loads(r)
-
-            if ("state" in rd) and ("text" in rd["state"]):
-                s += rd["state"]["text"]
-                if "temperature" in rd:
-                    s += " - "
-
-            if "temperature" in rd:
-                if "bed" in rd["temperature"]:
-                    if "actual" in rd["temperature"]["bed"]:
-                        s += "B"
-                        s += "%.1f" % rd["temperature"]["bed"]["actual"]
-                        if "target" in rd["temperature"]["bed"]:
-                            s += "/"
-                            s += "%.1f" % rd["temperature"]["bed"]["target"]
-                        s += " "
-
-                if "tool0" in rd["temperature"]:
-                    if "actual" in rd["temperature"]["tool0"]:
-                        s += "T"
-                        s += "%.1f" % rd["temperature"]["tool0"]["actual"]
-                        if "target" in rd["temperature"]["tool0"]:
-                            s += "/"
-                            s += "%.1f" % rd["temperature"]["tool0"]["target"]
-                        s += " "
-
-                if "tool1" in rd["temperature"]:
-                    if "actual" in rd["temperature"]["tool1"]:
-                        s += "T"
-                        s += "%.1f" % rd["temperature"]["tool1"]["actual"]
-                        if "target" in rd["temperature"]["tool1"]:
-                            s += "/"
-                            s += "%.1f" % rd["temperature"]["tool1"]["target"]
-                        s += " "
-        except json.JSONDecodeError:
-            pass
-        return s.strip()
-
-    def getState(self, host, key):
-        r = self.sendGetRequest(host, key, "job")
-        try:
-            rd = json.loads(r)
-            if "state" in rd:
-                return rd["state"]
-        except json.JSONDecodeError:
-            pass
-        return "Unknown"
-
-    def getProgress(self, host, key):
-        r = self.sendGetRequest(host, key, "job")
-        try:
-            rd = json.loads(r)
-            if "progress" in rd:
-                return rd["progress"]
-        except json.JSONDecodeError:
-            pass
-        return "Unknown"
-
-    def getName(self, host, key):
-        r = self.sendGetRequest(host, key, "printerprofiles")
-        try:
-            rd = json.loads(r)
-            if "profiles" in rd:
-                p = next(iter(rd["profiles"]))
-                if "name" in rd["profiles"][p]:
-                    return rd["profiles"][p]["name"]
-        except json.JSONDecodeError:
-            pass
-        return host
-
-    def getRecentFiles(self, host, key, count):
-        r = self.sendGetRequest(host, key, "files?recursive=true")
-        files = []
-        try:
-            rd = json.loads(r)
-            if "files" in rd:
-                t = [f for f in rd["files"] if "date" in f]
-                fs = sorted(t, key=operator.itemgetter("date"), reverse=True)
-                for f in fs[:count]:
-                    files.append((f["name"], f["origin"] + "/" + f["path"]))
-        except json.JSONDecodeError:
-            pass
-        return files
-
-    def getMethod(self, host, key):
-        r = self.sendGetRequest(host, key, "plugin/psucontrol")
-        if r == "timeout":
-            return "unknown"
-
-        try:
-            rd = json.loads(r)
-            if "isPSUOn" in rd:
-                return "psucontrol"
-        except json.JSONDecodeError:
-            pass
-
-        r = self.sendGetRequest(host, key, "system/commands/custom")
-        if r == "timeout":
-            return "unknown"
-
-        try:
-            rd = json.loads(r)
-            for c in rd:
-                if "action" in c:
-                    # we have some custom commands and no psucontrol
-                    # so lets try to use that instead of skipping
-                    # the printer completely with 'unknown'
-                    return "system"
-        except json.JSONDecodeError:
-            pass
-
-        return "unknown"
-
-    def getSystemCommands(self, host, key):
-        l = []
-        r = self.sendGetRequest(host, key, "system/commands/custom")
-        try:
-            rd = json.loads(r)
-
-            if len(rd) > 0:
-                print("system commands available for " + host + ":")
-
-            for c in rd:
-                if "action" in c:
-                    print("  - " + c["action"])
-                    l.append(c["action"])
-        except json.JSONDecodeError:
-            pass
-        return l
-
-    def setPSUControl(self, host, key, state):
-        cmd = "turnPSUOff"
-        if state:
-            cmd = "turnPSUOn"
-        return self.sendPostRequest(host, key, "plugin/psucontrol", '{ "command":"' + cmd + '" }')
-
-    def setSystemCommand(self, host, key, cmd):
-        cmd = urllib.parse.quote(cmd)
-        return self.sendPostRequest(host, key, "system/commands/custom/" + cmd, '')
-
     def exit(self):
         QCoreApplication.quit()
 
-    def printerSystemCommandAction(self, item, index):
-        if "off" in item[2][index].lower():
-            state = self.getState(item[0], item[1])
-            if state in self.statesWithWarning:
-                if self.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to run '" + item[2][index] + "'?", True, True) == False:
-                    return
-
-            safe = self.getTemperatureIsSafe(item[0], item[1])
-            if safe == False:
-                if self.showDialog("OctoTray Warning", "The printer seems to still be hot!", "Do you really want to turn it off?", True, True) == False:
-                    return
-
-        self.setSystemCommand(item[0], item[1], item[2][index])
-
-    def printerOnAction(self, item):
-        self.setPSUControl(item[0], item[1], True)
-
-    def printerOffAction(self, item):
-        state = self.getState(item[0], item[1])
-        if state in self.statesWithWarning:
-            if self.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to turn it off?", True, True) == False:
-                return
-
-        safe = self.getTemperatureIsSafe(item[0], item[1])
-        if safe == False:
-            if self.showDialog("OctoTray Warning", "The printer seems to still be hot!", "Do you really want to turn it off?", True, True) == False:
-                return
-
-        self.setPSUControl(item[0], item[1], False)
-
-    def printerHomingAction(self, item, axes = "xyz"):
-        state = self.getState(item[0], item[1])
-        if state in self.statesWithWarning:
-            if self.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to home it?", True, True) == False:
-                return
-
-        axes_string = ''
-        for i in range(0, len(axes)):
-            axes_string += '"' + str(axes[i]) + '"'
-            if i < (len(axes) - 1):
-                axes_string += ', '
-
-        self.sendPostRequest(item[0], item[1], "printer/printhead", '{ "command": "home", "axes": [' + axes_string + '] }')
-
-    def printerMoveAction(self, printer, axis, dist, relative = True):
-        state = self.getState(printer[0], printer[1])
-        if state in self.statesWithWarning:
-            if self.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to move it?", True, True) == False:
-                return
-
-        absolute = ''
-        if relative == False:
-            absolute = ', "absolute": true'
-
-        self.sendPostRequest(printer[0], printer[1], "printer/printhead", '{ "command": "jog", "' + str(axis) + '": ' + str(dist) + ', "speed": ' + str(self.jogMoveSpeed) + absolute + ' }')
-
-    def printerPauseResume(self, printer):
-        state = self.getState(printer[0], printer[1])
-        if state in self.statesWithWarning:
-            if self.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to pause/resume?", True, True) == False:
-                return
-        self.sendPostRequest(printer[0], printer[1], "job", '{ "command": "pause", "action": "toggle" }')
-
-    def printerJobCancel(self, printer):
-        state = self.getState(printer[0], printer[1])
-        if state in self.statesWithWarning:
-            if self.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to cancel?", True, True) == False:
-                return
-        self.sendPostRequest(printer[0], printer[1], "job", '{ "command": "cancel" }')
-
     def printerWebAction(self, item):
-        self.openBrowser(item[0])
-
-    def printerStatusAction(self, item):
-        progress = self.getProgress(item[0], item[1])
-        s = item[0] + "\n"
-        warning = False
-        if ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress) and (progress["completion"] != None) and (progress["printTime"] != None) and (progress["printTimeLeft"] != None):
-            s += "%.1f%% Completion\n" % progress["completion"]
-            s += "Printing since " + time.strftime("%H:%M:%S", time.gmtime(progress["printTime"])) + "\n"
-            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTimeLeft"])) + " left"
-        elif ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress):
-            s += "No job is currently running"
-        else:
-            s += "Could not read printer status!"
-            warning = True
-        t = self.getTemperatureString(item[0], item[1])
-        if len(t) > 0:
-            s += "\n" + t
-        self.showDialog("OctoTray Status", s, None, False, warning)
-
-    def printerFilePrint(self, item, path):
-        self.sendPostRequest(item[0], item[1], "files/" + path, '{ "command": "select", "print": true }')
-
-    def setTemperature(self, host, key, what, temp):
-        path = "printer/bed"
-        s = "{\"command\": \"target\", \"target\": " + temp + "}"
-
-        if "tool" in what:
-            path = "printer/tool"
-            s = "{\"command\": \"target\", \"targets\": {\"" + what + "\": " + temp + "}}"
-
-        if temp == None:
-            temp = 0
-
-        self.sendPostRequest(host, key, path, s)
-
-    def printerHeatTool(self, p):
-        self.setTemperature(p[0], p[1], "tool0", p[2])
-
-    def printerHeatBed(self, p):
-        self.setTemperature(p[0], p[1], "bed", p[3])
-
-    def printerCooldown(self, p):
-        state = self.getState(p[0], p[1])
-        if state in self.statesWithWarning:
-            if self.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to turn it off?", True, True) == False:
-                return
-
-        self.setTemperature(p[0], p[1], "tool0", 0)
-        self.setTemperature(p[0], p[1], "bed", 0)
+        self.openBrowser(item.host)
 
     def printerWebcamAction(self, item):
         for cw in self.camWindows:
-            if cw.getHost() == item[0]:
+            if cw.getHost() == item.host:
                 cw.show()
                 cw.activateWindow()
                 return

src/SettingsWindow.py

 from PyQt5.QtGui import QFontDatabase, QIntValidator
 from PyQt5.QtCore import Qt
 
+class Printer(object):
+    pass
+
 class SettingsWindow(QWidget):
     columns = [ "Hostname", "API Key", "Tool Preheat", "Bed Preheat" ]
     presets = [ "octopi.local", "000000000_API_KEY_HERE_000000000", "0", "0" ]
 
         for i in range(0, self.rows):
             p = printers[i]
-            for j in range(0, len(self.columns)):
-                text = p[j]
-                if (j >= 2) and (j <= 3) and (text == None):
-                    text = "0"
-                item = QTableWidgetItem(text)
-                self.table.setItem(i, j, item)
-                if j == 1:
-                    font = item.font()
-                    font.setFamily(QFontDatabase.systemFont(QFontDatabase.FixedFont).family())
-                    item.setFont(font)
+
+            item = QTableWidgetItem(p.host)
+            self.table.setItem(i, 0, item)
+
+            item = QTableWidgetItem(p.key)
+            self.table.setItem(i, 1, item)
+            font = item.font()
+            font.setFamily(QFontDatabase.systemFont(QFontDatabase.FixedFont).family())
+            item.setFont(font)
+
+            if p.tempTool == None:
+                item = QTableWidgetItem("0")
+            else:
+                item = QTableWidgetItem(p.tempTool)
+            self.table.setItem(i, 2, item)
+
+            if p.tempBed == None:
+                item = QTableWidgetItem("0")
+            else:
+                item = QTableWidgetItem(p.tempBed)
+            self.table.setItem(i, 3, item)
 
         buttons2 = QHBoxLayout()
         box.addLayout(buttons2, 0)
     def tableToList(self):
         printers = []
         for i in range(0, self.rows):
-            p = []
-            for j in range(0, len(self.columns)):
-                text = self.table.item(i, j).text()
-                if (j >= 2) and (j <= 3) and (text == "0"):
-                    text = None
-                p.append(text)
+            p = Printer()
+
+            p.host = self.table.item(i, 0).text()
+            p.key = self.table.item(i, 1).text()
+            p.tempTool = self.table.item(i, 2).text()
+            p.tempBed = self.table.item(i, 3).text()
+
+            if p.tempTool == "0":
+                p.tempTool = None
+
+            if p.tempBed == "0":
+                p.tempBed = None
+
             printers.append(p)
         return printers
 
     def settingsValid(self, printers):
         for p in printers:
-            # p[0] needs to be valid hostname or IP
+            # p.host needs to be valid hostname or IP
             # TODO
 
-            # p[1] needs to be valid API key (hexadecimal, 32 chars)
-            if (len(p[1]) != 32) or not all(c in string.hexdigits for c in p[1]):
+            # p.key needs to be valid API key (hexadecimal, 32 chars)
+            if (len(p.key) != 32) or not all(c in string.hexdigits for c in p.key):
                 return (False, "API Key not 32-digit hexadecimal")
 
-            # p[2] and p[3] need to be integer temperatures (0...999)
-            for s in [ p[2], p[3] ]:
+            # p.tempTool and p.tempBed need to be integer temperatures (0...999)
+            for s in [ p.tempTool, p.tempBed ]:
                 if s == None:
                     s = "0"
                 if (len(s) < 1) or (len(s) > 3) or not all(c in string.digits for c in s):
 
         return (True, "")
 
+    def printerDiffers(self, a, b):
+        if (a.host != b.host) or (a.key != b.key) or (a.tempTool != b.tempTool) or (a.tempBed != b.tempBed):
+            return True
+        return False
+
+    def printersDiffer(self, a, b):
+        if (len(a) != len(b)):
+            return True
+
+        for i in range(0, len(a)):
+            if self.printerDiffers(a[i], b[i]):
+                return True
+
+        return False
+
     def closeEvent(self, event):
-        oldPrinters = [item[0:len(self.columns)] for item in self.parent.printers]
+        oldPrinters = self.parent.printers
         newPrinters = self.tableToList()
 
         valid, errorText = self.settingsValid(newPrinters)
         js = int(self.jogSpeed.text())
         jl = int(self.jogLength.text())
 
-        if (oldPrinters != newPrinters) or (js != self.parent.jogMoveSpeed) or (jl != self.parent.jogMoveLength):
+        if self.printersDiffer(oldPrinters, newPrinters) or (js != self.parent.jogMoveSpeed) or (jl != self.parent.jogMoveLength):
             r = self.parent.showDialog(self.parent.name + " Settings Changed", "Do you want to save the new configuration?", "This will restart the application!", True, False, False)
             if r == True:
                 self.parent.jogMoveSpeed = js