def initial_state(self, data, clientId, done): printer = printerManager() cm = cameraManager() softwareManager = swManager() state = { 'printing': printer.isPrinting() or printer.isPaused(), 'heatingUp': printer.isHeatingUp(), 'operational': printer.isOperational(), 'ready_to_print': printer.isReadyToPrint(), 'paused': printer.isPaused(), 'camera': printer.isCameraConnected(), 'filament' : printerProfileManager().data['filament'], 'printCapture': cm.timelapseInfo, 'profile': printerProfileManager().data, 'remotePrint': True, 'capabilities': softwareManager.capabilities() + cm.capabilities, 'tool': printer.getSelectedTool() if printer.isOperational() else None, 'printSpeed': printer.getPrintingSpeed(), 'printFlow': printer.getPrintingFlow() } if state['printing'] or state['paused']: #Let's add info about the ongoing print job state['job'] = printer._stateMonitor._jobData if state['job'] is not None: state['job'].update({ 'cloud_job_id': printer.currentPrintJobId }) state['progress'] = printer._stateMonitor._progress done(state)
def initial_state(self, data, clientId, done): printer = printerManager() cm = cameraManager() softwareManager = swManager() state = { 'printing': printer.isPrinting(), 'heatingUp': printer.isHeatingUp(), 'operational': printer.isOperational(), 'paused': printer.isPaused(), 'camera': printer.isCameraConnected(), 'filament' : printerProfileManager().data['filament'], 'printCapture': cm.timelapseInfo, 'profile': printerProfileManager().data, 'remotePrint': True, 'capabilities': softwareManager.capabilities() + cm.capabilities, 'tool': printer.getSelectedTool() if printer.isOperational() else None, 'printSpeed': printer.getPrintingSpeed(), 'printFlow': printer.getPrintingFlow() } if state['printing'] or state['paused']: #Let's add info about the ongoing print job state['job'] = printer._stateMonitor._jobData state['progress'] = printer._stateMonitor._progress done(state)
def processAuthenticate(self, data): if data: self._silentReconnect = False if 'error' in data: self._logger.warn(data['message'] if 'message' in data else 'Unkonwn authentication error') self.status = self.STATUS_ERROR self._eventManager.fire(Events.ASTROPRINT_STATUS, self.status) self.close() if 'should_retry' in data and data['should_retry']: self._doRetry() elif 'success' in data: self._logger.info("Connected to astroprint service") self.authenticated = True self._retries = 0 self._retryTimer = None self.status = self.STATUS_CONNECTED self._eventManager.fire(Events.ASTROPRINT_STATUS, self.status) return None else: from octoprint.server import VERSION from astroprint.printerprofile import printerProfileManager nm = networkManager() sm = softwareManager() ppm = printerProfileManager() authData = { 'silentReconnect': self._silentReconnect, 'boxId': self.boxId, 'variantId': sm.variant['id'], 'boxName': nm.getHostname(), 'swVersion': VERSION, 'platform': sm.platform, 'localIpAddress': nm.activeIpAddress, 'publicKey': self._publicKey, 'privateKey': self._privateKey, 'printerModel': ppm.data['printer_model'] if ppm.data['printer_model']['id'] else None } pkgId = sm.mfPackageId if pkgId: authData['mfPackageId'] = pkgId return {'type': 'auth', 'data': authData}
def __init__(self): self.broadcastTraffic = 0 #Number of clients that wish to receive serial link traffic self.doIdleTempReports = True #Let's the client know if periodic temperature reports should be queries to the printer self._comm = None self._selectedFile = None self._printAfterSelect = False self._currentZ = None self._progress = None self._printTime = None self._printTimeLeft = None self._currentLayer = None self._currentPrintJobId = None self._profileManager = printerProfileManager() self._fileManager= printFileManagerMap[self._fileManagerClass.name]() self._fileManager.registerCallback(self) self._state = self.STATE_NONE self._logger = logging.getLogger(__name__) self._temp = {} self._bedTemp = None self._temps = deque([], 300) self._shutdown = False self._messages = deque([], 300) # callbacks self._callbacks = [] #self._lastProgressReport = None self._stateMonitor = StateMonitor( ratelimit= 1.0, updateCallback= self._sendCurrentDataCallbacks, addTemperatureCallback= self._sendAddTemperatureCallbacks, addLogCallback= self._sendAddLogCallbacks, addMessageCallback= self._sendAddMessageCallbacks ) self._stateMonitor.reset( state={"text": self.getStateString(), "flags": self._getStateFlags()}, jobData={ "file": { "name": None, "size": None, "origin": None, "date": None }, "estimatedPrintTime": None, "filament": { "length": None, "volume": None } }, progress={"completion": None, "filepos": None, "printTime": None, "printTimeLeft": None}, currentZ=None ) eventManager().subscribe(Events.METADATA_ANALYSIS_FINISHED, self.onMetadataAnalysisFinished);
def printerProfile(self, data, sendMessage): ppm = printerProfileManager() pm = printerManager() if data: if 'driverChoices' in data: del data['driverChoices'] if 'allowTerminal' in data: del data['allowTerminal'] if 'check_clear_bed' in data and data['check_clear_bed'] is False: pm.set_bed_clear(True) ppm.set(data) ppm.save() sendMessage({'success': 'no_error'}) else: result = ppm.data.copy() result.update({"allowTerminal": pm.allowTerminal}) result.update({"driverChoices": ppm.driverChoices()}) sendMessage(result)
def printerConnectionDriver(self, data, sendMessage): s = settings() pm = printerManager() ppm = printerProfileManager() connectionOptions = pm.getConnectionOptions() if data and data['settings']: if "serial" in data.keys(): if "port" in data["serial"].keys(): s.set(["serial", "port"], data["serial"]["port"]) if "baudrate" in data["serial"].keys(): s.setInt(["serial", "baudrate"], data["serial"]["baudrate"]) s.save() driverName = ppm.data['driver'] driverInfo = ppm.driverChoices().get(driverName) if driverInfo: driverName = driverInfo['name'] sendMessage({ "driver": ppm.data['driver'], "driverName": driverName, "fileFormat": pm.fileManager.fileFormat, "serial": { "port": connectionOptions["portPreference"], "baudrate": connectionOptions["baudratePreference"], "portOptions": connectionOptions["ports"], "baudrateOptions": connectionOptions["baudrates"] } })
def __init__(self): self.systemPlugin = False self._logger = logging.getLogger('Plugin::%s' % self.__class__.__name__) self._definition = None self._settings = settings() self._pluginEventListeners = {} self._profileManager = printerProfileManager() #Read it's definition file - plugin.yaml - pluginPath = os.path.dirname(sys.modules[self.__module__].__file__) definitionFile = os.path.join(pluginPath, 'plugin.yaml') if os.path.exists(definitionFile): try: with open(definitionFile, "r") as f: self._definition = yaml.safe_load(f) except Exception as e: raise e #Raise parse exception here if all(key in self._definition for key in REQUIRED_PLUGIN_KEYS): min_api_version = int(self._definition['min_api_version']) if PLUGIN_API_VERSION >= min_api_version: self.initialize() else: raise Exception("AstroBox API version [%d] is lower than minimum required by %s [%d]" % (PLUGIN_API_VERSION, self._definition['id'], min_api_version)) else: raise Exception("Invalid plugin definition found in %s" % definitionFile) else: raise Exception("No plugin definition file exists in %s" % pluginPath)
def saveTempPreset(self, data, sendMessage): ppm = printerProfileManager() if data: id = ppm.createTempPreset(data['name'], data['nozzle_temp'], data['bed_temp']) sendMessage(id)
def saveConnectionSettings(self,data,sendResponse): port = data['port'] baudrate = data['baudrate'] driver = data['driver'] if port: s = settings() s.set(["serial", "port"], port) if baudrate: s.setInt(["serial", "baudrate"], baudrate) s.save() pp = printerProfileManager() pp.set({'driver': driver}) pp.save() printerManager().connect(port, baudrate) sendResponse({'success': 'no_error'}) return sendResponse('invalid_printer_connection_settings',True)
def connection_settings(): connectionOptions = printerManager().getConnectionOptions() if connectionOptions: plugins = pluginManager().getPluginsByProvider('printerComms') driverChoices = {("plugin:%s" % k): plugins[k].definition['name'] for k in plugins} driverChoices.update({ 'marlin': 'GCODE - Marlin / Repetier Firmware', 's3g': 'X3G - Sailfish / Makerbot Firmware' }) response = { "driver": printerProfileManager().data['driver'], "driverChoices": driverChoices, "port": connectionOptions["portPreference"], "baudrate": connectionOptions["baudratePreference"], "portOptions": connectionOptions["ports"].items(), "baudrateOptions": connectionOptions["baudrates"] } return jsonify(response) return make_response("Connection options not available", 400)
def initial_state(self, data, clientId, done): printer = printerManager() cm = cameraManager() softwareManager = swManager() state = { 'printing': printer.isPrinting(), 'heatingUp': printer.isHeatingUp(), 'operational': printer.isOperational(), 'paused': printer.isPaused(), 'camera': printer.isCameraConnected(), 'printCapture': cm.timelapseInfo, 'profile': printerProfileManager().data, 'remotePrint': True, 'capabilities': softwareManager.capabilities() + cm.capabilities, 'tool': printer.getSelectedTool() if printer.isOperational() else None } if state['printing'] or state['paused']: #Let's add info about the ongoing print job state['job'] = printer._stateMonitor._jobData state['progress'] = printer._stateMonitor._progress done(state)
def getStatus(): printer = printerManager() cm = cameraManager() softwareManager = swManager() ppm = printerProfileManager() fileName = None if printer.isPrinting(): currentJob = printer.getCurrentJob() fileName = currentJob["file"]["name"] return Response( json.dumps({ 'id': boxrouterManager().boxId, 'name': networkManager().getHostname(), 'printing': printer.isPrinting(), 'fileName': fileName, 'printerModel': ppm.data['printer_model'] if ppm.data['printer_model']['id'] else None, 'filament' : ppm.data['filament'], 'material': None, 'operational': printer.isOperational(), 'paused': printer.isPaused(), 'camera': cm.isCameraConnected(), #'printCapture': cm.timelapseInfo, 'remotePrint': True, 'capabilities': softwareManager.capabilities() + cm.capabilities }), mimetype= 'application/json', headers= { 'Access-Control-Allow-Origin': '*' } if settings().getBoolean(['api', 'allowCrossOrigin']) else None )
def getStatus(self): printer = printerManager() cm = cameraManager() ppm = printerProfileManager() fileName = None if printer.isPrinting(): currentJob = printer.getCurrentJob() fileName = currentJob["file"]["name"] return { 'id': boxrouterManager().boxId, 'name': networkManager().getHostname(), 'printing': printer.isPrinting(), 'fileName': fileName, 'printerModel': ppm.data['printer_model'] if ppm.data['printer_model']['id'] else None, 'filament' : ppm.data['filament'], 'material': None, 'operational': printer.isOperational(), 'paused': printer.isPaused(), 'camera': cm.isCameraConnected(), #'printCapture': cm.timelapseInfo, 'remotePrint': True, 'capabilities': ['remotePrint'] + cm.capabilities }
def handlePrinterSettings(): s = settings() pm = printerManager() ppm = printerProfileManager() connectionOptions = pm.getConnectionOptions() if request.method == "POST": if "application/json" in request.headers["Content-Type"]: data = request.json if "serial" in data.keys(): if "port" in data["serial"].keys(): s.set(["serial", "port"], data["serial"]["port"]) if "baudrate" in data["serial"].keys(): s.setInt(["serial", "baudrate"], data["serial"]["baudrate"]) s.save() driverName = ppm.data['driver'] driverInfo = ppm.driverChoices().get(driverName) if driverInfo: driverName = driverInfo['name'] return jsonify({ "driver": ppm.data['driver'], "driverName": driverName, "serial": { "port": connectionOptions["portPreference"], "baudrate": connectionOptions["baudratePreference"], "portOptions": connectionOptions["ports"].items(), "baudrateOptions": connectionOptions["baudrates"] } })
def index(): s = settings() loggedUsername = s.get(["cloudSlicer", "loggedUser"]) if (s.getBoolean(["server", "firstRun"])): # we need to get the user to sign into their AstroPrint account return render_template("setup.jinja2", debug=debug, uiApiKey=UI_API_KEY, version=VERSION, variantData=variantManager().data, astroboxName=networkManager().getHostname(), settings=s) elif softwareManager.updatingRelease or softwareManager.forceUpdateInfo: return render_template( "updating.jinja2", uiApiKey=UI_API_KEY, showForceUpdate=softwareManager.forceUpdateInfo != None, releaseInfo=softwareManager.updatingRelease or softwareManager.forceUpdateInfo, lastCompletionPercent=softwareManager.lastCompletionPercent, lastMessage=softwareManager.lastMessage, variantData=variantManager().data, astroboxName=networkManager().getHostname()) elif loggedUsername and (current_user is None or not current_user.is_authenticated() or current_user.get_id() != loggedUsername): if current_user.is_authenticated(): logout_user() return render_template("locked.jinja2", username=loggedUsername, uiApiKey=UI_API_KEY, astroboxName=networkManager().getHostname(), variantData=variantManager().data) else: pm = printerManager() nm = networkManager() paused = pm.isPaused() printing = pm.isPrinting() online = nm.isOnline() return render_template("app.jinja2", user_email=loggedUsername, version=VERSION, printing=printing, paused=paused, online=online, print_capture=cameraManager().timelapseInfo if printing or paused else None, printer_profile=printerProfileManager().data, uiApiKey=UI_API_KEY, astroboxName=nm.getHostname(), variantData=variantManager().data, serialLogActive=s.getBoolean(['serial', 'log']))
def temp_preset_create(): ppm = printerProfileManager() name = request.values.get('name', None) nozzle_temp = request.values.get('nozzle_temp', None) bed_temp = request.values.get('bed_temp', None) return jsonify( {'id' : ppm.createTempPreset(name, nozzle_temp, bed_temp)} )
def printer_profile_patch(): changes = request.json ppm = printerProfileManager() ppm.set(changes) ppm.save() return jsonify()
def getNumberOfExtruders(self,data,sendResponse=None): ppm = printerProfileManager() extruderCount = ppm.data.get('extruder_count') if sendResponse: sendResponse(extruderCount) return extruderCount
def getNumberOfExtruders(self, data, sendResponse=None): ppm = printerProfileManager() extruderCount = ppm.data.get('extruder_count') if sendResponse: sendResponse(extruderCount) return extruderCount
def index(): s = settings() loggedUsername = s.get(["cloudSlicer", "loggedUser"]) if (s.getBoolean(["server", "firstRun"])): # we need to get the user to sign into their AstroPrint account return render_template( "setup.jinja2", debug= debug, uiApiKey= UI_API_KEY, version= VERSION, variantData= variantManager().data, astroboxName= networkManager.getHostname(), settings=s ) elif softwareManager.updatingRelease or softwareManager.forceUpdateInfo: return render_template( "updating.jinja2", uiApiKey= UI_API_KEY, showForceUpdate= softwareManager.forceUpdateInfo != None, releaseInfo= softwareManager.updatingRelease or softwareManager.forceUpdateInfo, variantData= variantManager().data, astroboxName= networkManager.getHostname() ) elif loggedUsername and (current_user is None or not current_user.is_authenticated() or current_user.get_id() != loggedUsername): if current_user.is_authenticated(): logout_user() return render_template( "locked.jinja2", username= loggedUsername, uiApiKey= UI_API_KEY, astroboxName= networkManager.getHostname(), variantData= variantManager().data ) else: paused = printer.isPaused() printing = printer.isPrinting() online = networkManager.isOnline() return render_template( "app.jinja2", user_email= loggedUsername, version= VERSION, printing= printing, paused= paused, online= online, print_capture= cameraManager().timelapseInfo if printing or paused else None, printer_profile= printerProfileManager().data, uiApiKey= UI_API_KEY, astroboxName= networkManager.getHostname(), variantData= variantManager().data )
def capabilities(self): ppm = printerProfileManager() capabilities = ['remotePrint', # Indicates whether this device supports starting a print job remotely 'multiExtruders', # Support for multiple extruders 'allowPrintFile', # Support for printing a printfile not belonging to any design 'acceptPrintJobId' # Accept created print job from cloud, ] if ppm.data['check_clear_bed']: capabilities.append('cleanState') # Support bed not clean state return capabilities
def save_printer_profile_settings(): driver = request.values.get('driver', None) if driver: pp = printerProfileManager() pp.set({'driver': driver}) pp.save() return make_response("OK", 200) return make_response('Invalid Connection Settings', 400)
def printer_profile_patch(): changes = request.json if 'cancel_gcode' in changes: changes['cancel_gcode'] = changes['cancel_gcode'].strip().split('\n'); ppm = printerProfileManager() ppm.set(changes) ppm.save() return jsonify()
def printer_profile_patch(): changes = request.json if 'cancel_gcode' in changes: changes['cancel_gcode'] = changes['cancel_gcode'].strip().split('\n') ppm = printerProfileManager() ppm.set(changes) ppm.save() return jsonify()
def __init__(self): self._profileManager = printerProfileManager() self._fileManager = printFileManagerMap[self._fileManagerClass.name]() self._fileManager.registerCallback(self) self._state = self.STATE_NONE self._temp = {} self._bedTemp = None self._temps = deque([], 300) self._messages = deque([], 300) self._cameraManager = cameraManager() # callbacks self._callbacks = [] #self._lastProgressReport = None self._stateMonitor = StateMonitor( ratelimit=1.0, updateCallback=self._sendCurrentDataCallbacks, addTemperatureCallback=self._sendAddTemperatureCallbacks, addLogCallback=self._sendAddLogCallbacks, addMessageCallback=self._sendAddMessageCallbacks) self._stateMonitor.reset(state={ "text": self.getStateString(), "flags": self._getStateFlags() }, jobData={ "file": { "name": None, "size": None, "origin": None, "date": None }, "estimatedPrintTime": None, "filament": { "length": None, "volume": None } }, progress={ "completion": None, "filepos": None, "printTime": None, "printTimeLeft": None }, currentZ=None) eventManager().subscribe(Events.METADATA_ANALYSIS_FINISHED, self.onMetadataAnalysisFinished)
def __init__(self, hostname, router): self._weakRefRouter = weakref.ref(router) self._printerListener = None self._lastReceived = 0 self._subscribers = 0 self._silentReconnect = False self._profileManager = printerProfileManager() self._logger = logging.getLogger(__name__) self._lineCheck = None self._error = False self._condition = threading.Condition() super(AstroprintBoxRouterClient, self).__init__(hostname)
def doConnect(): if not self._shutdown: self._changeState(self.STATE_OPERATIONAL) self._temperatureChanger = TempsChanger(self) self._temperatureChanger.start() #set initial temps extruder_count = ( printerProfileManager().data.get('extruder_count')) for i in range(extruder_count): self.setTemperature('tool' + str(i), 25) self.setTemperature('bed', 25)
def printer_profile_patch(): ppm = printerProfileManager() if request.method == "PATCH": changes = request.json ppm.set(changes) ppm.save() return jsonify() else: return jsonify(ppm.data)
def initial_state(self, data, clientId, done): printer = printerManager() cm = cameraManager() done({ 'printing': printer.isPrinting(), 'operational': printer.isOperational(), 'paused': printer.isPaused(), 'camera': printer.isCameraConnected(), 'printCapture': cm.timelapseInfo, 'profile': printerProfileManager().data, 'remotePrint': True, 'capabilities': ['remotePrint'] + cm.capabilities })
def set_filament(self, data, clientId, done): filament = {} filament['filament'] = {} if data['filament'] and data['filament']['name'] and data['filament']['color']: filament['filament']['name'] = data['filament']['name'] #Better to make sure that are getting right color codes if re.search(r'^#(?:[0-9a-fA-F]{3}){1,2}$', data['filament']['color']): filament['filament']['color'] = data['filament']['color'] else: done({ 'error': True, 'message': 'Invalid color code' }) else: filament['filament']['name'] = None filament['filament']['color'] = None printerProfileManager().set(filament) printerProfileManager().save() done(None)
def save_printer_profile_settings(): driver = request.values.get('driver', None) if driver: pp = printerProfileManager() pp.data['driver'] = driver pp.save() #swap the printerManager here printerManager(driver) return make_response("OK", 200) return make_response('Invalid Connection Settings', 400)
def processAuthenticate(self, data): if data: self._silentReconnect = False if 'error' in data: self._logger.warn(data['message'] if 'message' in data else 'Unkonwn authentication error') self.status = self.STATUS_ERROR self._eventManager.fire(Events.ASTROPRINT_STATUS, self.status) self.close() elif 'success' in data: self._logger.info("Connected to astroprint service") self.authenticated = True self._retries = 0 self._retryTimer = None self.status = self.STATUS_CONNECTED self._eventManager.fire(Events.ASTROPRINT_STATUS, self.status) return None else: from octoprint.server import VERSION from astroprint.printerprofile import printerProfileManager nm = networkManager() sm = softwareManager() ppm = printerProfileManager() authData = { 'silentReconnect': self._silentReconnect, 'boxId': self.boxId, 'variantId': sm.variant['id'], 'boxName': nm.getHostname(), 'swVersion': VERSION, 'platform': sm.platform, 'localIpAddress': nm.activeIpAddress, 'publicKey': self._publicKey, 'privateKey': self._privateKey, 'printerModel': ppm.data['printer_model'] if ppm.data['printer_model']['id'] else None } pkgId = sm.mfPackageId if pkgId: authData['mfPackageId'] = pkgId return { 'type': 'auth', 'data': authData }
def connection_settings(): connectionOptions = printerManager().getConnectionOptions() if connectionOptions: response = { "driver": printerProfileManager().data['driver'], "port": connectionOptions["portPreference"], "baudrate": connectionOptions["baudratePreference"], "portOptions": connectionOptions["ports"].items(), "baudrateOptions": connectionOptions["baudrates"] } return jsonify(response) return make_response("Connection options not available", 400)
def __init__(self, hostname, router): #it needs to be imported here because on the main body 'printer' is None from octoprint.server import printer self._router = router self._printer = printer self._printerListener = None self._lastReceived = 0 self._subscribers = 0 self._silentReconnect = False self._cameraManager = cameraManager() self._profileManager = printerProfileManager() self._logger = logging.getLogger(__name__) self._lineCheck = None super(AstroprintBoxRouterClient, self).__init__(hostname)
def __init__(self): self._profileManager = printerProfileManager() self._fileManager= printFileManagerMap[self._fileManagerClass.name]() self._fileManager.registerCallback(self) self._state = self.STATE_NONE self._logger = logging.getLogger(__name__) self._temp = {} self._bedTemp = None self._temps = deque([], 300) self._messages = deque([], 300) self._cameraManager = cameraManager() # callbacks self._callbacks = [] #self._lastProgressReport = None self._stateMonitor = StateMonitor( ratelimit= 1.0, updateCallback= self._sendCurrentDataCallbacks, addTemperatureCallback= self._sendAddTemperatureCallbacks, addLogCallback= self._sendAddLogCallbacks, addMessageCallback= self._sendAddMessageCallbacks ) self._stateMonitor.reset( state={"text": self.getStateString(), "flags": self._getStateFlags()}, jobData={ "file": { "name": None, "size": None, "origin": None, "date": None }, "estimatedPrintTime": None, "filament": { "length": None, "volume": None } }, progress={"completion": None, "filepos": None, "printTime": None, "printTimeLeft": None}, currentZ=None ) eventManager().subscribe(Events.METADATA_ANALYSIS_FINISHED, self.onMetadataAnalysisFinished);
def printer_profile_patch(): ppm = printerProfileManager() if request.method == "PATCH": changes = request.json ppm.set(changes) ppm.save() return jsonify() else: result = ppm.data.copy() result.update( {"driverChoices": ppm.driverChoices()} ) return jsonify( result )
def printer_profile_patch(): ppm = printerProfileManager() if request.method == "PATCH": changes = request.json ppm.set(changes) ppm.save() return jsonify() else: result = ppm.data.copy() result.update({"driverChoices": ppm.driverChoices()}) return jsonify(result)
def run(self): self._pausedEvent.set() while not self._stopped and self._percentCompleted < 1: self._pausedEvent.wait() if self._stopped: break self._timeElapsed += 1 self._filePos += 1 self._currentLayer += 1 self._consumedFilament[0] += 10 self._percentCompleted = self._timeElapsed / self._jobLength self._pm.mcLayerChange(self._currentLayer) self._pm.mcProgress() time.sleep(1) self._pm._changeState(self._pm.STATE_OPERATIONAL) extruder_count = (printerProfileManager().data.get('extruder_count')) for i in range(extruder_count): self._pm.setTemperature('tool' + str(i), 0) self._pm.setTemperature('bed', 0) payload = { "file": self._file['filename'], "filename": os.path.basename(self._file['filename']), "origin": self._file['origin'], "time": self._timeElapsed, "layerCount": self._currentLayer } if self._percentCompleted >= 1: self._pm.mcPrintjobDone() self._pm._fileManager.printSucceeded(payload['filename'], payload['time'], payload['layerCount']) eventManager().fire(Events.PRINT_DONE, payload) else: self._pm.printJobCancelled() eventManager().fire(Events.PRINT_CANCELLED, payload) self._pm._fileManager.printFailed(payload['filename'], payload['time']) self._pm = None
def printer_profile_patch(): ppm = printerProfileManager() if request.method == "PATCH": changes = request.json if 'cancel_gcode' in changes: changes['cancel_gcode'] = changes['cancel_gcode'].strip().split( '\n') ppm.set(changes) ppm.save() return jsonify() else: return jsonify(ppm.data)
def index(): s = settings() if (s.getBoolean(["server", "firstRun"])): # we need to get the user to sign into their AstroPrint account return render_template( "setup.jinja2", debug= debug, uiApiKey= UI_API_KEY, version= VERSION, variantData= variantManager().data ) elif softwareManager.updatingRelease or softwareManager.forceUpdateInfo: return render_template( "updating.jinja2", uiApiKey= UI_API_KEY, showForceUpdate= softwareManager.forceUpdateInfo != None, releaseInfo= softwareManager.updatingRelease or softwareManager.forceUpdateInfo, variantData= variantManager().data ) else: paused = printer.isPaused() printing = printer.isPrinting() return render_template( "app.jinja2", user_email= s.get(["cloudSlicer", "email"]), version= VERSION, printing= printing, paused= paused, print_capture= cameraManager().timelapseInfo if printing or paused else None, printer_profile= printerProfileManager().data, uiApiKey= UI_API_KEY, astroboxName= networkManager.getHostname(), variantData= variantManager().data )
def printerManager(driver = None): global _instance if driver is not None and _instance is not None and _instance.driverName != driver: _instance.rampdown() _instance = None if _instance is None and driver: if driver.startswith('plugin:'): from astroprint.printer.plugin import PrinterWithPlugin, NoPluginException try: _instance = PrinterWithPlugin(driver[7:]) except NoPluginException: #The plugin is gone. Pick the default from astroprint.printerprofile import printerProfileManager ppm = printerProfileManager() ppm.set({'driver': DEFAULT_MANAGER}) ppm.save() else: import importlib try: # driver name to class map. format is (module, classname) classInfo = { 'marlin': ('.marlin', 'PrinterMarlin'), 's3g': ('.s3g', 'PrinterS3g') }[driver] except KeyError: classInfo = ('.marlin', 'PrinterMarlin') module = importlib.import_module(classInfo[0], 'astroprint.printer') _instance = getattr(module, classInfo[1])() return _instance
def save_connection_settings(): port = request.values.get('port', None) baudrate = request.values.get('baudrate', None) driver = request.values.get('driver', None) if port and ( baudrate or driver == 's3g'): s = settings() s.set(["serial", "port"], port) if baudrate: s.setInt(["serial", "baudrate"], baudrate) s.save() pp = printerProfileManager() pp.data['driver'] = driver pp.save() pm = printerManager(driver) pm.connect() return make_response("OK", 200) return make_response('Invalid Connection Settings', 400)
def index(): s = settings() loggedUsername = s.get(["cloudSlicer", "loggedUser"]) if (s.getBoolean(["server", "firstRun"])): swm = swManager() # we need to get the user to sign into their AstroPrint account return render_template( "setup.jinja2", debug= debug, uiApiKey= UI_API_KEY, version= VERSION, commit= swm.commit, variantData= variantManager().data, astroboxName= networkManager().getHostname(), checkSoftware= swm.shouldCheckForNew, settings=s ) elif softwareManager.updatingRelease or softwareManager.forceUpdateInfo: return render_template( "updating.jinja2", uiApiKey= UI_API_KEY, showForceUpdate= softwareManager.forceUpdateInfo != None, releaseInfo= softwareManager.updatingRelease or softwareManager.forceUpdateInfo, lastCompletionPercent= softwareManager.lastCompletionPercent, lastMessage= softwareManager.lastMessage, variantData= variantManager().data, astroboxName= networkManager().getHostname() ) elif loggedUsername and (current_user is None or not current_user.is_authenticated() or current_user.get_id() != loggedUsername): if current_user.is_authenticated(): logout_user() return render_template( "locked.jinja2", username= loggedUsername, uiApiKey= UI_API_KEY, astroboxName= networkManager().getHostname(), variantData= variantManager().data ) else: pm = printerManager() nm = networkManager() swm = swManager() cm = cameraManager() paused = pm.isPaused() printing = pm.isPrinting() online = nm.isOnline() return render_template( "app.jinja2", user_email= loggedUsername, version= VERSION, commit= swm.commit, printing= printing, paused= paused, online= online, print_capture= cm.timelapseInfo if printing or paused else None, printer_profile= printerProfileManager().data, uiApiKey= UI_API_KEY, astroboxName= nm.getHostname(), variantData= variantManager().data, checkSoftware= swm.shouldCheckForNew, serialLogActive= s.getBoolean(['serial', 'log']), cameraManager= cm.name )
def __init__(self, gcodeManager): from collections import deque self._gcodeManager = gcodeManager self._gcodeManager.registerCallback(self) self._cameraManager = cameraManager() self._profileManager = printerProfileManager() # state # TODO do we really need to hold the temperature here? self._temp = None self._bedTemp = None self._targetTemp = None self._targetBedTemp = None self._temps = deque([], 300) self._tempBacklog = [] self._latestMessage = None self._messages = deque([], 300) self._messageBacklog = [] self._latestLog = None self._log = deque([], 300) self._logBacklog = [] self._state = None self._currentZ = None self._progress = None self._printTime = None self._printTimeLeft = None self._currentLayer = None self._layerCount = None self._estimatedPrintTime = None self._printId = None self._printAfterSelect = False # sd handling self._sdPrinting = False self._sdStreaming = False self._sdFilelistAvailable = threading.Event() self._streamingFinishedCallback = None self._selectedFile = None # comm self._comm = None # callbacks self._callbacks = [] self._lastProgressReport = None self._stateMonitor = StateMonitor( ratelimit=1.0, updateCallback=self._sendCurrentDataCallbacks, addTemperatureCallback=self._sendAddTemperatureCallbacks, addLogCallback=self._sendAddLogCallbacks, addMessageCallback=self._sendAddMessageCallbacks ) self._stateMonitor.reset( state={"text": self.getStateString(), "flags": self._getStateFlags()}, jobData={ "file": { "name": None, "size": None, "origin": None, "date": None }, "estimatedPrintTime": None, "filament": { "length": None, "volume": None } }, progress={"completion": None, "filepos": None, "printTime": None, "printTimeLeft": None}, currentZ=None ) eventManager().subscribe(Events.METADATA_ANALYSIS_FINISHED, self.onMetadataAnalysisFinished);