def testLoadSettings(self): settings = Settings() settings.load('testSettings.ini') notepads = settings.getNotepads() self.assertEqual(2, len(notepads)) self.assertEqual('SampleWiki', notepads[0]['name'])
def mark(cls, look, displayname=None): """ Create xplanet marker based on observation """ key1 = str(look.wave.time.tt) key2 = look.planet.origname if key2 in Settings().locationstorage: if key1 in Settings().locationstorage[key2]: l1 = Settings().locationstorage[key2][key1] # print("found") else: l1 = cls.calculate_lat_long(look.wave.time, look) tmp = Settings().locationstorage[key2] tmp.update({key1: l1}) Settings().locationstorage[key2] = tmp else: l1 = cls.calculate_lat_long(look.wave.time, look) Settings().locationstorage[key2] = {key1: l1} if displayname is None: displayname = look.planet.name return '{} {} "{}" {}'.format(str(l1[0]), str(l1[1]), displayname, look.planet.color)
def pole(cls, look): """ Create xplanet pole as arc based on observation """ key1 = str(look.wave.time.tt) key2 = look.planet.origname if key2 in Settings().locationstorage: if key1 in Settings().locationstorage[key2]: l1 = Settings().locationstorage[key2][key1] else: l1 = cls.calculate_lat_long(look.wave.time, look) tmp = Settings().locationstorage[key2] tmp.update({key1: l1}) Settings().locationstorage[key2] = tmp else: l1 = cls.calculate_lat_long(look.wave.time, look) Settings().locationstorage[key2] = {key1: l1} l2 = Settings().midpoint return '{} {} {} {} {}'.format(str(l1[0]), str(l1[1]), str(l2[0]), str(l2[1]), look.planet.color + " spacing=0.5")
def checkForUpdate(self): update = 0 settings = Settings(os.getcwd() + '/' +"wlc_load.db") # i coded myself into a corner while True: if update < settings.get("lastUpdate"): #send data to client self.broadCast_Msg("Hello....smells like success") time.sleep(2)
def uploadFile(file, resultCallbackFunction=printLink, progressCallbackFunction=printProgressToCLI, file_number = 0, semaphore = BoundedSemaphore(2), username="", password=""): rs = Rapidshare_com(file, resultCallbackFunction, progressCallbackFunction, file_number) from Settings import Settings set = Settings() if set.getUseRSPassword(): username,password = set.getRSCredentials() rs.upload(semaphore, username, password) del username del password
def getUploader(file): preferredUploaders = Settings().getPreferredUploaders() extension = file.split('.')[-1].lower() filetype = __getFiletype(extension) if filetype in preferredUploaders.keys(): prefferedUploader = preferredUploaders[filetype] else: prefferedUploader = preferredUploaders["*"] return getPluginByHostingName(prefferedUploader)
def test_phases(self): ''' python3 -m unittest TestRun.TestRun.test_phases ''' settings = Settings() settings.setValue('XOphases', True) rpt = ConsoleStreamReporter() ctx = RunnerContext.RunnerContext(rpt, X64CodeGenContext(), settings) ctx.run(self.cu)
def showNotification_(self, sender): result = bool(self.chbShowNotification.state()) Settings.set("showNotification", result) self.stprNotificationTime.setEnabled_(result) self.edtNotificationTime.setEnabled_(result) self.stprNotificationRepeatTime.setEnabled_(result) self.edtNotificationRepeatTime.setEnabled_(result) self.chbSoundOnNotification.setEnabled_(result) self.btnPreviewPopup.setEnabled_(result)
def testPageSequence(self): settings = Settings() settings.load('testSettings.ini') npDef = settings.getNotepads()[0] self.assertEqual('SampleWiki', npDef['name']) notepad = LocalNotepad(npDef) self.assertEqual('SampleWiki', notepad.getName()) pageId = notepad.getNextPageId()
def projectChange_(self, sender): """Project changed event""" if self.pbtnProject.titleOfSelectedItem(): self.cbxInput.removeAllItems() self.cbxInput.addItemsWithObjectValues_(Projects.getAutocomleteList( self.pbtnProject.titleOfSelectedItem(), SlackingAutocompletes.get())) if sender: Settings.set("selectedProject", unicode(self.pbtnProject.titleOfSelectedItem())) Settings.sync()
def start(self, tray): startDB = DB(); settings = Settings(startDB); settings = settings.currentSettings(); FeedBox.FeedBox.setTheme(settings['theme']); if(settings['startMinimalized']): tray.minimalization(); if(settings['startup']): self.updateAllFeeds();
def __init__(self) : self.videos = dict() self.services = dict() self.locSettings = Settings('location') self.storageSettings = Settings('storage') if not os.path.exists(self.thumbnailDir()) : os.mkdir(self.thumbnailDir()) if not os.path.exists(self.videoDir()) : os.mkdir(self.videoDir())
class GameState: #update game round i -> The number of the current round #update game this_piece_type s -> The type of the piece that has just spawned on the field #update game next_piece_type s -> The type of the piece that will spawn the next round #update game this_piece_position i,i -> The starting position in the field for the current piece (top left corner of the piece bounding box) def __init__(self): self.round = 0 self.this_piece_type = 'n' self.next_piece_type = 'n' self.this_piece_position = {"x":1 , "y":2} self.players = {"me":PlayerState(), "opponent":PlayerState()} self.settings = Settings() def parseSettingsMessage(self, parts): self.settings.parseSetting(parts) def parseGameMessage(self, parts): if parts[0] == "game": gameStateMessage = parts[1] if gameStateMessage== 'round': #update game round i self.round = int(parts[2]) elif gameStateMessage == 'this_piece_type': #update game this_piece_type s self.this_piece_type = parts[2] elif gameStateMessage == 'next_piece_type': #update game next_piece_type s self.next_piece_type = parts[2] elif gameStateMessage == 'this_piece_position': #update game this_piece_position i,i position = parts[2].split(',') self.this_piece_position["x"] = int(position[0]) self.this_piece_position["y"] = int(position[1]) else: stderr.write('Unknown gameStateMessage: %s\n' % (parts[1])) stderr.flush() elif parts[0] == self.settings.bots["me"]: self.players["me"].parsePlayerState(parts[1:]) elif parts[0] == self.settings.bots["opponent"]: self.players["opponent"].parsePlayerState(parts[1:]) else: stderr.write('Unknown gameStateMessage: %s\n' % (parts[0])) stderr.flush()
def showStartHelpMessage(self): """Show alert with help message""" alert = NSAlert.alloc().init() alert.addButtonWithTitle_('OK') alert.setMessageText_("Congrats, you started your working day!") alert.setInformativeText_("Now start doing your working activity (e.g reading mail). " "When you finish with your activity go back to MacTimeLog and type it in. " "If your activity is slacking, use 2 asterisks (**) at the end of the activity's name.") alert.setShowsSuppressionButton_(True) alert.runModal() if alert.suppressionButton().state() == NSOnState: Settings.set("showHelpMessageOnStart", False) Settings.sync()
def __init__(self): self.round = 0 self.this_piece_type = 'n' self.next_piece_type = 'n' self.this_piece_position = {"x":1 , "y":2} self.players = {"me":PlayerState(), "opponent":PlayerState()} self.settings = Settings()
def __init__(self): self._conn = Connection(FileStorage(Settings.get("projectsDataPath"))) self._data = self._conn.get_root() if not len(self._data.keys()): self._data["Default"] = PersistentDict(autocomplete=PersistentDict()) self.sync()
def leftSeconds(self): """Return time left to work""" res = Settings.get("workDayLength") - self.spentSeconds if res < 0: return 0 else: return res
def __init__(self, parent=None): super(MainApp, self).__init__(parent) self.setupUi(self) self.makeSysTrayActions() self.makeTrayIcon() self.systrayIcon.messageClicked.connect(self.messageClicked) self.systrayIcon.activated.connect(self.iconActivated) self.systray_text_list = [] self.setIcon() self.systrayIcon.show() self.feed_reader = FeedReader() self.active_filter = None self.exclusive_filters = None self.settings = Settings() self.settings.load_settings() self.statusbar.showMessage('Feeds tracked: ' + str(len(self.settings.uri_list))) self.actionQuit.triggered.connect(QtGui.qApp.quit) self.actionSettings.triggered.connect(self._slotSettings) self.actionFilters.triggered.connect(self._slotFilters) self.pushRefreshButton.clicked.connect(self._slotRefresh) self.listWidgetRss.itemClicked.connect(self._slotItemClicked) self.settings_dialogue = SettingsDialogue(self.settings, parent=self) self.filter_dialogue = FilterDialogue(self.settings, parent=self) self.refresh_timer = QTimer() self.refresh_timer.timeout.connect(self._slotRefresh) if self.settings.refresh_time != 0: self.refresh_timer.start(self.settings.refresh_time * 60 * 1000) self.alert_timer = QTimer() self.alert_timer.timeout.connect(self._slotAlert) if self.settings.alert_time != 0: self.alert_timer.start(self.settings.alert_time * 60 * 1000) self._slotRefresh()
def initControls(self): """Init basic controls""" self.outputArea.setString_("") self.tasks = Tasks() if Settings.get("showWorkTill"): self.workTillBox.setHidden_(False) else: self.workTillBox.setHidden_(True) self.pbtnProject.removeAllItems() self.pbtnProject.addItemsWithTitles_(Projects.get()) self.pbtnProject.selectItemWithTitle_(Settings.get("selectedProject")) self.projectChange_(None) self.fillTasks() self.scrollToEnd()
def __init__(self, reporter, codeGenContext, settings = None): self.expSymbolTable = expressionActionSymbolTable self.expSymbolTable.clear() self.kindSymbolTable = kindSymbolTable self.kindSymbolTable.clear() self.settings = Settings() if not settings else settings self.codeGenContext = codeGenContext self.architectureContext = codeGenContext.architectureContext self.reporter = reporter # init self.phases = PhaseList(self._internalPhases())
def markPosition(self, event): wFactor, hFactor = Settings.getOutputLabelFactors() if self.drawState == WorkingWindow.STATE_NONE: self.clickedPos = (int(event.x * wFactor), int(event.y * hFactor)) self.drawState = WorkingWindow.STATE_CLICK self.stateLabel.configure(text=("Frame {} / {} - Wfsp!".format(self.currentFrame, len(self.frames)))) elif self.drawState == WorkingWindow.STATE_CLICK: cv2.rectangle(self.labels[self.currentFrame], self.clickedPos, (int(event.x * wFactor), int(event.y * hFactor)), (255,255,255), -1) self.drawState = WorkingWindow.STATE_NONE self.showNext()
def formatTaskString(date, task, projectName, spentSeconds, taskType): """Format task string""" if taskType == "work": color = NSColor.blackColor() elif taskType == "slack": color = NSColor.grayColor() else: color = NSColor.colorWithCalibratedRed_green_blue_alpha_(.72,.72,.72, 1) if spentSeconds is None: # Start of the day taskString = "Your working day started on %s \n" % date.strftime("%c") return taskString, color else: dtStr = "" if Settings.get("showDateTime"): dtStr = " " + date.strftime(str(Settings.get("logDateTimeFormat"))) project = "" if projectName != "" and projectName != "Default" and taskType == "work": project = "%s %s " % (projectName, Settings.get("projectSeparator")) return "%s%s >> %s%s \n" % (secToTimeStr(spentSeconds), dtStr, project, task), color
class SettingsDialog(QDialog) : def __init__(self, parent = None) : QDialog.__init__(self, parent) layout = QVBoxLayout() self.settings = Settings() self.edits = dict() for key in Settings.values.keys(): layout.addLayout(self.createSettingField(key)) buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) buttons.accepted.connect(self.accept) buttons.rejected.connect(self.reject) layout.addWidget(buttons) self.setLayout(layout) def createSettingField(self, key) : layout = QHBoxLayout() layout.addWidget(QLabel(key)) value = Settings.values[key] edit = QLineEdit(str(value)) if value == True or value == False : edit = QCheckBox() if value : edit.setCheckState(Qt.Checked) elif isinstance(value, int) : edit.setValidator(QIntValidator()) elif isinstance(value, float) : edit.setValidator(QDoubleValidator()) self.edits[key] = edit layout.addWidget(edit) return layout def accept(self) : value = Settings.values[key] for key in self.keys : if isinstance(value, int) : self.settings.set(key, int(edit.text())) elif isinstance(value, float) : self.settings.set(key, float(edit.text())) elif isinstance(value, bool) : self.settings.set(key, edit.checkState() == Qt.Checked) else : self.settings.set(key, edit.text()) self.setVisible(False) def reject(self) : self.setVisible(False)
def btnDonePress_(self, sender): """On done button press""" if self.tasks.dayStarted(): if self.cbxInput.stringValue().strip(): taskName = self.cbxInput.stringValue() self.appendTask(*fh.formatTaskString(*self.tasks.add(taskName, self.pbtnProject.titleOfSelectedItem()))) self.readCounters() self.cbxInput.setStringValue_("") self.scrollToEnd() if Tasks.taskType(taskName) == "work": Projects.addAutocomplete(self.pbtnProject.titleOfSelectedItem(), taskName) else: SlackingAutocompletes.add(taskName) self.cbxInput.addItemWithObjectValue_(taskName) else: if Settings.get("showHelpMessageOnStart"): self.showStartHelpMessage() taskName = Settings.get("startPlaceholder") self.appendTask(*fh.formatTaskString(*self.tasks.add(taskName))) self.initDoneButton()
def __init__(self, app): QMainWindow.__init__(self, None) self.l.debug('Initializing MainWindow ...') self.setWindowTitle('MynPad') app.setWindowIcon(QIcon(':/icons/mynpad.png')) if os.name == 'nt': # On Windows, make sure to use a unique Application User Model Id, otherwise # Windows shows the default python icon in the taskbar # see http://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7 myappid = 'afester.mynpad' import ctypes; ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid) self.theApplication = app app.aboutToQuit.connect(self.saveState) # read the local configuration file iniPath = 'mynpad.ini' if not os.path.exists(iniPath): iniPath = os.path.join(expanduser("~"), iniPath) self.settings = Settings(iniPath) self.settings.load() # Set up the menu bar menuBar = QMenuBar(self) exitAction = QAction("Exit", self, triggered=self.theApplication.exit) fileMenu = menuBar.addMenu("&File") fileMenu.addAction(exitAction) aboutAction = QAction("About ...", self, triggered = self.handleAbout) helpMenu = menuBar.addMenu("&Help") helpMenu.addAction(aboutAction) self.setMenuBar(menuBar) # Setup the status bar self.statusBar = QStatusBar() self.statusBar.showMessage("Ready.") self.setStatusBar(self.statusBar) self.mainWidget = CentralWidget(self, self.settings) self.mainWidget.updateWindowTitle.connect(self.updateWindowTitle) self.setCentralWidget(self.mainWidget) # Reset main window size and position pos = self.settings.getMainWindowPos() self.move(pos.x(), pos.y()) size = self.settings.getMainWindowSize() self.resize(size) # initialize the browser tree (add the top nodes and expand the saved path) self.mainWidget.browserWidget.initialize()
def __init__(self, caller=None): self._settings_class = Settings() self._settings_dict = self._settings_class.getSettings() self.__parent = caller gtk.glade.bindtextdomain(translationsDomainName, translationsDirName) gtk.glade.textdomain(translationsDomainName) gladefile = "settings.glade" self.__wTree = gtk.glade.XML(gladefile) self.__window = self.__wTree.get_widget("Settings") self.__optipngBox = self.__wTree.get_widget("hboxOptipng") self.__comboboxFileType = self.__wTree.get_widget("comboboxFileType") self.__hscaleCompression = self.__wTree.get_widget("hscaleCompression") self.__labelScaleMax = self.__wTree.get_widget("labelScaleMax") self.__window.connect("destroy", self._destroy) dic = { "on_buttonOK_clicked": self.__buttonOKClicked, "on_buttonReset_clicked": self.__buttonResetClicked, "on_hscaleCompression_value_changed": self.__scaleCompressionValueChanged, "on_comboboxFileType_changed": self.__comboboxFileTypeChanged, "on_buttonInstallOptipng_clicked": self.__buttonInstallOptipng, "on_buttonGetCurrentHeight_clicked": self.__buttonGetCurrentHeightClicked, "on_spinbuttonNumberOfConnections_value_changed":self.__spinbuttonNumberOfConnections_value_changed, "on_comboboxClipboard_changed":self.__comboboxClipboard_changed, "on_checkbuttonOneInstance_toggled":self.__checkbuttonOneInstance_toggled, "on_spinbuttonHeight_value_changed":self.__spinbuttonHeight_value_changed, "on_spinbuttonThumb_value_changed":self.__spinbuttonThumb_value_changed, "on_checkbuttonNotification_toggled":self.__checkbuttonNotification_toggled, "on_checkbuttonIcon_toggled":self.__checkbuttonIcon_toggled, "on_checkbuttonBlink_toggled":self.__checkbuttonBlink_toggled, "on_checkbuttonUseProxy_toggled":self.__on_checkbuttonUseProxy_toggled, "on_entryProxyAddress_changed":self.__on_entryProxyAddress_changed, "on_entryProxyPort_changed":self.__on_entryProxyPort_changed, # "on_entryProxyUserName_changed":self.__on_entryProxyUserName_changed, # "on_entryProxyPassword_changed":self.__on_entryProxyPassword_changed, "on_comboboxProxyAuthentication_changed":self.__on_comboboxProxyAuthentication_changed } self.__wTree.signal_autoconnect(dic) self.__checkInstalledComponents() self.__initUploaderTabs() self.__loadSettings() self.__window.show() #hide not yet implemented elements self.__wTree.get_widget("buttonInstallOptipng").hide()
def testAddNotepad(self): settings = Settings() settings.load('testSettings.ini') notepads = settings.getNotepads() self.assertEqual(2, len(notepads)) settings.addNotepad({'type' : 'local', 'name' : 'Sample2', 'path' : 'C:/temp'}) notepads = settings.getNotepads() self.assertEqual(3, len(notepads)) self.assertEqual('Sample2', notepads[2]['name'])
def __init__(self, parent = None) : QDialog.__init__(self, parent) layout = QVBoxLayout() self.settings = Settings() self.edits = dict() for key in Settings.values.keys(): layout.addLayout(self.createSettingField(key)) buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) buttons.accepted.connect(self.accept) buttons.rejected.connect(self.reject) layout.addWidget(buttons) self.setLayout(layout)
def initVlaues(self): self.stprWorkHours.setIntValue_(fh.secToHours(Settings.get("workDayLength"))) self.edtWorkHours.setIntValue_(self.stprWorkHours.intValue()) self.stprNotificationTime.setIntValue_(Settings.get("notificationTime")) self.edtNotificationTime.setIntValue_(self.stprNotificationTime.intValue()) self.stprNotificationRepeatTime.setIntValue_(Settings.get("notificationRepeatTime")) self.edtNotificationRepeatTime.setIntValue_(self.stprNotificationRepeatTime.intValue()) workEndTime = datetime.datetime.strptime(Settings.get("workEndTime"), "%H:%M").time() someDate = datetime.datetime.combine(datetime.datetime.now(), workEndTime) self.dpkrWorkStarts.setDateValue_(fh.datetimeToNSDate(someDate)) self.edtLogEditCommand.setStringValue_(Settings.get("logEditCommand")) self.chbShowWorkTill.setState_(1 if Settings.get("showWorkTill") else 0) self.chbShowDateTime.setState_(1 if Settings.get("showDateTime") else 0) self.chbShowNotification.setState_(1 if Settings.get("showNotification") else 0) self.chbSoundOnNotification.setState_(1 if Settings.get("soundOnNotification") else 0) self.edtDateTimeFormat.setStringValue_(Settings.get("logDateTimeFormat")) self.edtDateTimeFormat.setEnabled_(self.chbShowDateTime.state()) self.showNotification_(self)
def __init__(self, aArgv): self.mSettings = Settings(aArgv[3] + aArgv[4] + ":" + aArgv[5], aArgv[6] + aArgv[7] + ":" + aArgv[8]) # Configuring the logger. self.mLogger = logging.getLogger(aArgv[1]) self.mLogger.propagate = False handler = logging.FileHandler("/tmp/" + aArgv[1] + ".log") formatter = logging.Formatter("[%(asctime)s][%(threadName)28s][%(levelname)8s] - %(message)s") handler.setFormatter(formatter) self.mLogger.addHandler(handler) self.mLogger.setLevel(self.mSettings.get("logging", "level")) self.mCrittnick = aArgv[1] # TODO: Implement sequential starting (in order of dependencies). # This is a matter of performing full startup procedure properly. self.mRites = {} self.mLogger.debug("Initializing the post office.") self.mPostOffice = PostOffice(self) self.mGracefulShutdown = False # FIXME: Rites should be started in appropriate sequence, according to dependencies. # TODO: Remove the hardcoded number of services. rites = [Rites.RiteCommon.REGISTRY, Rites.RiteCommon.HEARTBEAT] + [aArgv[9]] for rite in rites: self.mLogger.info("Spawning the %s rite." % rite) if rite in self.mRites: # TODO: For now this is ok. If e.g. rites are started recursively, then this will not work! self.mLogger.critical("Rite %s has been already started." % rite) sys.exit(1) else: self.mRites[rite] = createRite(self, rite) for rite in rites: self.mLogger.info("Starting the %s rite." % rite) self.mRites[rite].start() # Spawning the behavior. self.mLogger.debug("Spawning the behavior.") self.mBehavior = CritterBehavior(self) self.mBehavior.setDaemon(True) self.mBehavior.start() self.mLogger.debug("Starting the post office.") self.mPostOffice.start()
class MainWindow(QMainWindow): l = logging.getLogger('MainWindow') def __init__(self, app): QMainWindow.__init__(self, None) self.l.debug('Initializing MainWindow ...') self.setWindowTitle('MynPad') app.setWindowIcon(QIcon(':/icons/mynpad.png')) if os.name == 'nt': # On Windows, make sure to use a unique Application User Model Id, otherwise # Windows shows the default python icon in the taskbar # see http://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7 myappid = 'afester.mynpad' import ctypes ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID( myappid) self.theApplication = app app.aboutToQuit.connect(self.saveState) # read the local configuration file iniPath = 'mynpad.ini' if not os.path.exists(iniPath): iniPath = os.path.join(expanduser("~"), iniPath) self.settings = Settings(iniPath) self.settings.load() # Set up the menu bar menuBar = QMenuBar(self) exitAction = QAction("Exit", self, triggered=self.theApplication.exit) fileMenu = menuBar.addMenu("&File") fileMenu.addAction(exitAction) aboutAction = QAction("About ...", self, triggered=self.handleAbout) helpMenu = menuBar.addMenu("&Help") helpMenu.addAction(aboutAction) self.setMenuBar(menuBar) # Setup the status bar self.statusBar = QStatusBar() self.statusBar.showMessage("Ready.") self.setStatusBar(self.statusBar) self.mainWidget = CentralWidget(self, self.settings) self.mainWidget.updateWindowTitle.connect(self.updateWindowTitle) self.setCentralWidget(self.mainWidget) # Reset main window size and position pos = self.settings.getMainWindowPos() self.move(pos.x(), pos.y()) size = self.settings.getMainWindowSize() self.resize(size) # initialize the browser tree (add the top nodes and expand the saved path) self.mainWidget.browserWidget.initialize() def updateWindowTitle(self, title): self.setWindowTitle('{} - MynPad'.format(title)) def saveState(self): # Make sure that the current notepad page is saved self.mainWidget.editorWidget.save() # Note: there is no way to have eclipse shutdown the application faithfully, # see also http://stackoverflow.com/questions/677531/is-it-possible-for-eclipse-to-terminate-gently-instead-of-using-sigkill path = self.mainWidget.browserWidget.getCurrentPath() self.settings.setBrowserPath(path) self.settings.setMainWindowPos(self.pos()) self.settings.setMainWindowSize(self.size()) self.settings.save() # Close all notepads - TODO (HACK) for x in range( 0, self.mainWidget.browserWidget.browserView.topLevelItemCount()): notepad = self.mainWidget.browserWidget.browserView.topLevelItem( x).getNotepad() notepad.close() def handleAbout(self): appVersion = "Development version" pythonVersion = "%s.%s.%s (%s)" % ( sys.version_info[0], sys.version_info[1], sys.version_info[2], sys.version_info[3]) pyQtVersion = PYQT_VERSION_STR pyQtQtVersion = QT_VERSION_STR qtRuntimeVersion = qVersion() platformSystem = platform.system() platformRelease = platform.release() QMessageBox.about( self, "About MynPad", "Copyright \u00a9 2015 by Andreas Fester<br/>" + "<table>" + "<tr><th align=\"right\">Application version:</th><td>{}</td></tr>" .format(appVersion) + "<tr><th align=\"right\">Python version:</th><td>{}</td></tr>". format(pythonVersion) + "<tr><th align=\"right\">PyQt version:</th><td>{} for Qt {}</td></tr>" .format(pyQtVersion, pyQtQtVersion) + "<tr><th align=\"right\">Qt runtime version:</th><td>{}</td></tr>". format(qtRuntimeVersion) + "<tr><th align=\"right\">Operating System:</th><td>{} {}</td></tr>" .format(platformSystem, platformRelease) + "<tr><th align=\"right\">sqlite version:</th><td>{}</td></tr>". format(sqlite3.version) + "<tr><th align=\"right\">sqlite runtime version:</th><td>{}</td></tr>" .format(sqlite3.sqlite_version) + "</table>")
class Main(): def __init__(self, selected_vol, selected_music): self.selected_vol = selected_vol self.selected_music = selected_music def game_intro(self): self.about = About.About() self.func = Functions.Functions() self.high = Highscore() self.intro = True self.sett = Settings(self.selected_vol, self.selected_music) bg_y = 0 while (self.intro): py.display.set_caption("Main") rel_y = bg_y % bg.get_rect().height display_screen.blit(bg, (0, rel_y - bg.get_rect().height)) if rel_y < display_height: display_screen.blit(bg, (0, rel_y)) bg_y += 0.1 # BUTTONS mg_menu_button = self.func.button( "Mini Games", WHITE, display_width / 2 - main_menu_buttonx / 2, 225, main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR) highscores_button = self.func.button( "Highscores", WHITE, display_width / 2 - main_menu_buttonx / 2, 300, main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR) settings_button = self.func.button( "Settings", WHITE, display_width / 2 - main_menu_buttonx / 2, 375, main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR) instr_menu_button = self.func.button( "About", WHITE, display_width / 2 - main_menu_buttonx / 2, 450, main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR) exit_button = self.func.button("Exit", WHITE, 20, display_height - instr_buttony - 20, instr_buttonx, instr_buttony, IACOLOR, ACOLOR) # TEXT text_surface, text_rect = self.func.text_objects( "MAIN MENU", large_text, WHITE) text_rect.center = (display_width / 2, 150) display_screen.blit(text_surface, text_rect) for event in py.event.get(): if event.type == py.QUIT: py.quit() quit() if event.type == py.MOUSEBUTTONDOWN: mouse_pos = py.mouse.get_pos() if mg_menu_button.collidepoint(mouse_pos): self.value = 'mini' self.intro = False if highscores_button.collidepoint(mouse_pos): self.high.loop() if instr_menu_button.collidepoint(mouse_pos): self.about.loop() if settings_button.collidepoint(mouse_pos): self.selected_vol, self.selected_music = self.sett.loop( ) if exit_button.collidepoint(mouse_pos): py.quit() quit() py.display.update() return self.selected_vol, self.selected_music, self.value
import requests from Settings import Settings from ApiResponse import ApiResponse from Profile import Profile from ObjectBuilder import ObjectBuilder # Initialize the setings settings = Settings() # Build the request to get the token request = requests.post(settings.settings_data["Urls"]["AuthLoginUrl"], json=settings.get_api_auth_data()) # Token request response response = request.json() # Object to represent the API response api_response = ApiResponse() api_response.process_object(response) if api_response.success: # Build bearer token value headers = {"Authorization": "Bearer " + api_response.data["Token"]} # Used to mock some data builder = ObjectBuilder() # Get single poly ID poly_id_request = requests.put( settings.settings_data["Urls"]["GetPolyIdUrl"], json=builder.profile_0.get_json_object(),
""" Copyright 2019 Akvelon Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ from RPCHost import RPCHost from SQSQueue import SQSQueue from tx import Transaction from Settings import Settings import time, boto3 app_settings = Settings() sqs = boto3.client('sqs') bitcoind_url = 'http://' + app_settings['rpc-user'] + ':' + app_settings[ 'rpc-password'] + '@' + app_settings['rpc-url'] host = RPCHost(bitcoind_url) incoming_tx_queue = SQSQueue(url=app_settings['prepared-transaction-sqs-url']) def loop(): try: print('Round start') incoming_tx = incoming_tx_queue.get_message() if incoming_tx: print('Got tx, working on it')
def WhichTable(NameTable: str): if NameTable == Settings.Var_PR(): return SQLPR elif NameTable == Settings.Var_MR(): return SQLMR
def setUpClass(self): Settings.loadSettings(self.SETTINGS_PATH) self.settings = Settings("test")
class SettingsTest(unittest.TestCase): SETTINGS_PATH = os.path.expanduser('settingstest.xml') @classmethod def setUpClass(self): Settings.loadSettings(self.SETTINGS_PATH) self.settings = Settings("test") def test_string(self): defaulttest = self.settings.get('defaulttest', 'defaulttest') self.settings.set('gettest', 'gettest') gettest2 = self.settings.get('gettest', 'defaulttest') self.assertEquals(defaulttest, 'defaulttest') self.assertEquals(gettest2, 'gettest') def test_int(self): gettest1 = self.settings.get('gettest', 4) self.settings.set('gettest', 1) gettest2 = self.settings.get('gettest', 4) self.assertEquals(gettest1, 4) self.assertEquals(gettest2, 1) def test_bool(self): gettest1 = self.settings.get('gettest', False) self.settings.set('gettest2', True) self.settings.set('gettest3', False) gettest2 = self.settings.get('gettest2', False) gettest3 = self.settings.get('gettest3', False) self.assertEquals(gettest1, False) self.assertEquals(gettest2, True) self.assertEquals(gettest3, False) def test_write(self): self.settings.write() self.assertTrue(os.path.exists(self.SETTINGS_PATH)) @classmethod def tearDownClass(self): os.remove(self.SETTINGS_PATH)
def __init__(self, argv): self.loaded = False self.config = wx.Config("OSW-IDE", style=wx.CONFIG_USE_LOCAL_FILE) self.path = os.getcwd() # All functions here will be called upon exit self.onExit = [Settings.saveConfig] Settings() # All defined platforms self.platforms = self.getPlatformsFromMakefile() self.platformOnly = None self.excludedPlatforms = list() self.activePlatform = self.platforms.index("telosb") # Flag indicates that next thread's output shouldn't trigger # force switching to info area tab. self.supressTabSwitching = False self.targets = [None] self.targetType = "USB" self.activeThreads = {} self.onExit.append(self.killAllThreads) if LOG_TO_FILE: path = os.getcwd() os.chdir(self.path) self.logFile = open(LOG_FILE_NAME, "a") os.chdir(path) self.onExit.append(self.logFile.close) # this is path from /osw/tools/IDE self.pathToMansos = os.path.join(self.path, "../..") # Try to get system default font #font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT) #self.fontName = font.GetFaceName() #if self.fontName != "": # print "Using system default font: {}".format(self.fontName) #else: self.fontName = "Courier New" # print "Can't find system default font, defaulting to {}".\ # format(self.fontName) self.listenModules = list() self.editors = list() icon = os.path.normpath('../../doc/osw-32x32.ico') ### Module initializations # Visual objects here can be used in forms only after they have been re-parented # using their Reparent() function, else they won't be visible! self.emptyFrame = wx.Frame(None) # Defines seal syntax self.sealSyntax = SealSyntax(self) # Init translation module Translater(self) # Init output_tools #self.outputTools = OutputTools(self.emptyFrame, self) # Init outputArea for info, 1st tab self.infoArea = OutputArea(self.emptyFrame, self, 0) self.printInfo = self.infoArea.printLine self.clearInfoArea = self.infoArea.clear # Init blockly handler if os.path.exists( os.path.join(self.path, Settings.get("blockly_location"))): self.blockly = Blockly(self.emptyFrame, self) self.foundBlockly = True else: print "Warning: No SEAL-Blockly found!" self.foundBlockly = False # Init seal parser self.sealParser = seal_parser.SealParser("msp430", self.printInfo, False, True) # Init tab manager self.tabManager = TabManager(self.emptyFrame, self) # Init listenModule self.listenModules.append(ListenModule(self.emptyFrame, self)) self.editPanel = ScrolledPanel(self.emptyFrame) self.editWindow = EditStatement(self.editPanel, self) self.frame = Frame(None, "OSW IDE", (0, 0), (0, 0), self) #self.outputTools.addTools() self.compiler = DoCompile(self) self.uploader = DoUpload(self) ### Shortcuts # This allows modules to be disabled and dummy functions attached, so other # modules can keep saving the day... Each module updates his functions at # startup and restores them at termination. All function calls between modules # should go through here, but this ain't perfect world :( self.getKeywords = self.sealSyntax.getKeywords #self.printInfo = self.dummyPrint self.printOutput = self.dummyPrint # Check if icon can be found if os.path.exists(icon): self.frame.SetIcon(wx.Icon(icon, wx.BITMAP_TYPE_ICO, 32, 32)) else: self.logMsg(LOG_WARNING, "Icon not found in '{}'!".format(icon)) # Check that everything is OK assert len(self.emptyFrame.GetChildren()) == 0, \ "There are parentless objects after API initialization.\n{}".format(\ self.emptyFrame.GetChildren()) self.syncModuleCheckboxes() # Initialize upload targets self.uploadTargets = ([], localize('the default device')) # Load last used tabs self.tabManager.loadRememberedTabs() for x in argv: self.tabManager.addPage(x) self.frame.auiManager.Update() self.loaded = True self.frame.checkToggleState() Motelist.startPeriodicUpdate() self.onExit.append(Motelist.stopPeriodicUpdate) self.loadUserMotes()
def setupSettings(self): builtins.settings = Settings(f'{userfiles}/config.ott') if 'panda-path' not in settings: settings['panda-path'] = 'None'
def __init__(self, settings_bin_path='', channel_num=0, device='dut', show_progressbar=False): print 'Creating PedestalCalculations instance' self.show_pb = show_progressbar self.settings = Settings() self.ch = channel_num self.device = device self.LoadSettingsBinary(settings_bin_path) self.out_dir = self.settings.output_dir self.sub_dir = self.settings.sub_dir self.file_name = self.settings.file_name self.tree_name = self.settings.tree_name self.slide_leng = self.settings.sliding_length self.run = self.settings.run self.ana_events = self.settings.ana_events self.ped_branches = [ 'diaPed', 'diaPedSigma', 'cm', 'diaPedCmc', 'diaPedSigmaCmc', 'diaSignal', 'diaSignalCmc' ] self.raw_tel_branches_dic = { 0: 'D0X_ADC', 1: 'D0Y_ADC', 2: 'D1X_ADC', 3: 'D1Y_ADC', 4: 'D2X_ADC', 5: 'D2Y_ADC', 6: 'D3X_ADC', 7: 'D3Y_ADC' } self.raw_dut_branch = 'DiaADC' self.rootFile = None self.rootTree = None self.utils = Utils() self.read_branch = self.raw_tel_branches_dic[ 0] if self.device == 'telx0' else self.raw_tel_branches_dic[ 1] if self.device == 'tely0' else self.raw_tel_branches_dic[ 2] if self.device == 'telx1' else self.raw_tel_branches_dic[ 3] if self.device == 'tely1' else self.raw_tel_branches_dic[ 4] if self.device == 'telx2' else self.raw_tel_branches_dic[ 5] if self.device == 'tely2' else self.raw_tel_branches_dic[ 6] if self.device == 'telx3' else self.raw_tel_branches_dic[ 7] if self.device == 'tely3' else self.raw_dut_branch self.hit_factor = self.settings.clust_hit[ 0] if self.device == 'telx0' else self.settings.clust_hit[ 1] if self.device == 'tely0' else self.settings.clust_hit[ 2] if self.device == 'telx1' else self.settings.clust_hit[ 3] if self.device == 'tely1' else self.settings.clust_hit[ 4] if self.device == 'telx2' else self.settings.clust_hit[ 5] if self.device == 'tely2' else self.settings.clust_hit[ 6] if self.device == 'telx3' else self.settings.clust_hit[ 7] if self.device == 'tely3' else self.settings.clust_hit[ 8] self.seed_factor = self.settings.clust_seed[ 0] if self.device == 'telx0' else self.settings.clust_seed[ 1] if self.device == 'tely0' else self.settings.clust_seed[ 2] if self.device == 'telx1' else self.settings.clust_seed[ 3] if self.device == 'tely1' else self.settings.clust_seed[ 4] if self.device == 'telx2' else self.settings.clust_seed[ 5] if self.device == 'tely2' else self.settings.clust_seed[ 6] if self.device == 'telx3' else self.settings.clust_seed[ 7] if self.device == 'tely3' else self.settings.clust_seed[ 8] self.read_branch += '[{c}]'.format(c=self.ch) self.np_type = self.settings.dut_np_data_type if self.device == 'dut' else self.settings.tel_np_data_type # self.hit_factor = self.settings.dut_hit_factor if self.device == 'dut' else self.settings.tel_hit_factor self.device_ADC = np.zeros(self.slide_leng, dtype=self.np_type) self.device_ped = np.zeros(self.slide_leng, dtype='float32') self.device_sigma = np.zeros(self.slide_leng, dtype='float32') self.device_signal = np.zeros(self.slide_leng, dtype='float32') self.device_ADC_mean = np.zeros(self.ana_events, dtype='float32') self.device_ADC_sigma = np.zeros(self.ana_events, dtype='float32') self.device_ADC_is_ped = np.zeros(self.ana_events, dtype='?') self.device_ADC_is_hit = np.zeros(self.ana_events, dtype='?') self.device_ADC_is_seed = np.zeros(self.ana_events, dtype='?') self.adc = 0 self.mean = 0.0 self.sigma = 0.0 self.mean_sq = 0.0 self.elem = 0 self.device_ADC_all = np.zeros(self.ana_events, dtype=self.np_type) self.CalculatePedestals()
def main(): settings = Settings() analytics = Analytics() novelty = Novelty() cmd_line_args_success = settings.update_command_line_args() if not cmd_line_args_success: return print("Settings:" + "\n".join([f"{i} : {j}" for i, j in vars(settings).items()])) hws = [ Hardware(None, i, settings.min_program_length, settings.max_program_length) for i in range(settings.pop_size) ] game = FlappyDarwin( hws, settings.ticks_per_update, settings.num_tests if settings.selection == "lexicase" else 1, (lambda: 0) if settings.fitness == "novelty" else (lambda: time())) inst_lib = generate_inst_lib(game) for hw in hws: hw.inst_lib = inst_lib [hw.generate_program() for hw in hws] best_fitness = [0] fitness_data = [] gen = 1 if settings.save_file: print(F"LOADING FROM EXISTING SAVED GP FILE: {settings.save_file}") hws, gen, gen_finished_test = load_programs(inst_lib, settings) game.generation = gen game.gen_finished_test = gen_finished_test if settings.fitness == "novelty": load_novelty_archive(novelty) while not game.QUIT_SIGNAL: print(F"Generation: {gen}") game.set_hardware(hws) game.start() for i, hw in enumerate(hws): hw.cache_fitness(game.birds[i].fitness) local_best = max(hws, key=lambda hw: min(hw.fitness)) fitness_data.append(sum(local_best.fitness) / len(local_best.fitness)) if min(local_best.fitness) > min(best_fitness): best_fitness = local_best.fitness print(local_best) print("Finished with fitness", local_best.fitness) print("____________________________") if settings.fitness == "novelty": assert settings.selection != "lexicase", "Lexicase is not compatible with Novelty." dists = novelty.select([(bird.rect.x + bird.last_frame_alive, clamp(bird.rect.y, 0, game.HEIGHT)) for bird in game.birds]) for i, hw in enumerate(hws): hw.cache_fitness(dists[i]) copy_best = local_best.copy() copy_best.traits = 0 if settings.selection == "tournament": hws = tournament(hws) elif settings.selection == "elite": hws = elite(hws, len(hws) // 2) elif settings.selection == "lexicase": hws = lexicase(hws) elif settings.selection == "roulette": hws = roulette(hws) else: raise NotImplementedError( F"Invalid Selection Scheme: {settings.selection}") [mutate(hw) for hw in hws] recombination(hws) for i, hw in enumerate(hws): hw.traits = i # Keep around the best performing from the previous generation & reset its hardware hws[0] = copy_best hws[0].traits = 0 gen += 1 if gen in {10, 50, 100, 250, 500, 1500, 2500} or not gen % 1000: save_programs(gen, hws, game.gen_finished_test) analytics.save(gen, fitness_data) fitness_data.clear() if settings.fitness == "novelty": save_novelty_archive(novelty)
def processCommand(self, nick, msg, channelUsers): self.init = Settings().keywords self.gameTitle = self.init["Titles"]["game-hotpotato"] output = [] msg = msg.strip() cmd = msg.split(" ")[0] args = [] if len(msg.split(" ")) > 1: args = msg.split(" ") args.remove(args[0]) if self.init["GameCommands"]["addPlayer"].lower() == cmd.lower(): if args: for arg in args: if "alreadyin" == self.addPlayer(HotPotatoPlayer(arg, ), channelUsers): output.append( (self.init["Inform"] ["hijack-playeralreadyin"].replace( self.init["Substitutions"]["sendnick"], name), 1)) elif "nonexistent" == self.addPlayer( HijackPlayer(name, health), channelUsers): nopeMsg = self.init["Inform"][ "hotpotato-nonexistentplayer"] nopeMsg = nopeMsg.replace( self.init["Substitutions"]["sendnick"], name) output.append((nopeMsg, 1)) else: output.append( ("{nick} joined the game.".format(nick=name, ), 1)) elif self.init["GameCommands"]["leave"].lower() == cmd.lower(): who = [] hasLeft = False if args: who = args else: who = [nick] for w in who: if self.removePlayer(w): leftMsg = random.choice( self.init["Choices"]["hijack-leavegame"].split( self.init["Splitters"]["choices-hijack"])) leftMsg = leftMsg.replace( self.init["Substitutions"]["sendnick"], w) output.append((leftMsg, 1)) hasLeft = True if hasLeft: output.append(("Number of people playing {g}: {num}".format( g=self.gameTitle, num=str(len(self.players))), 0)) elif self.init["Commands"]["startplaying"].lower() == cmd.lower(): if self.started: pass elif self.players: self.started = True self.currentHolder = random.choice(list(self.players.values())) output.append( (self.init["Inform"]["hotpotato-startplaying"], 1)) output.append( (self.init["Choices"]["hotpotato-startpass"].replace( self.init["Substitutions"]["sendNick"], self.currentHolder.name), 0)) else: ## No one's playing. pass elif self.init["GameCommands"]["hotpotato-pass"].lower() == cmd.lower( ): if 1 <= len(args): if args[0].lower() in self.players: self.currentHolder = self.players[args[0].lower()]
def __init__(self): Game.__init__(self, Settings().keywords["Titles"]["game-hijack"])
bottom_right = (min_loc[0] + w, min_loc[1] + h) cv2.rectangle(frame, min_loc, bottom_right, (0, 0, 255), 3) cv2.imshow('this', matches[0]) ph = min_loc[1] pw = math.ceil((min_loc[0] + h) / 2) return True, min_loc, bottom_right, ph, pw return False, None, None, None, None if __name__ == '__main__': nwt_s = Settings('./nwt_settings.txt', True) nwt = nwtConnection(nwt_s.dict['roboRioAddress'], nwt_s.dict['sdTableName'], nwt_s.dict['cpTableName']) gt = GearTracker('./templates/') nwt.find_stream() cap = cv2.VideoCapture(nwt.streamURL) while True: ret, frame = cap.read() if ret: tracking, topLeft, bottomRight, ph, pw = gt.track(frame)
def login(self): self.userInfo[ 'loginUser.loginName'] = self.login_widget.usernameLineEdit.text() self.userInfo[ 'loginUser.loginPassword'] = self.login_widget.passwordLineEdit.text( ) self.login_widget.setDisabled(True) worker = LoginWorker(self) worker.start() @Slot(str) def handleLoginStatus(self, status): print(status) @Slot(bool) def handleLoginResponse(self, response): print(response) if response == 'successful': self.loginStatus = True self.close() else: QMessageBox.critical(self, 'Error', response) self.login_widget.setDisabled(False) if __name__ == '__main__': app = QApplication(sys.argv) settings = Settings('./temp/settings.json') login = UserLoginDialog(settings) login.exec_()
from Settings import Settings ''' Start the game by running this script ''' if __name__ == '__main__': Settings() # Calls the Settings Class
def FindAllItemMP(Table: str, ItemToFind: str): if Table == Settings.Var_Process1(): Type = Settings.Dir_BD() else: Type = Settings.Dir_PBD() Refs, Workers, Providers, References, Presentations, NumRems, NumPres, TotalWeight, InitialDate, FinalDate, CodeBr, NumCoils = \ SQLMP.FindALLMP(Type) if ItemToFind == Settings.Var_Comp26(): return Refs elif ItemToFind == Settings.Var_Comp15(): return Workers elif ItemToFind == Settings.Var_Comp14(): return Providers elif ItemToFind == Settings.Var_Comp13(): return References elif ItemToFind == Settings.Var_Comp12(): return Presentations elif ItemToFind == Settings.Var_Comp9(): return NumRems elif ItemToFind == Settings.Var_Comp3(): return NumPres elif ItemToFind == Settings.Var_Comp6(): return NumCoils elif ItemToFind == Settings.Var_Comp4(): return TotalWeight elif ItemToFind == Settings.Var_Comp19(): return InitialDate elif ItemToFind == Settings.Var_Comp20(): return FinalDate elif ItemToFind == Settings.Var_Comp1(): return CodeBr
def load_from_cpu(settings, model_emb, model_class): state_dict_emb = torch.load(settings.checkpointroot_load_emb, map_location=torch.device('cpu'))["state_dict"] state_dict_class = torch.load( settings.checkpointroot_load_class, map_location=torch.device('cpu'))["state_dict"] params_emb = get_state_dict(state_dict_emb) params_class = get_state_dict(state_dict_class) model_emb.load_state_dict(params_emb) model_class.load_state_dict(params_class) return model_emb, model_class if __name__ == '__main__': settings = Settings().parse_arguments() settings.dataroot = "small_test_mnist.npz" settings.stage = "Test" dataloader = Dataset(settings).create_dataset(do_transform=False, type_dataloader="Single") model_emb, model_class = load_models(settings) batchsize = settings.batch_size n_batches = len(dataloader.dataset.data[0]) // batchsize accuracy = 0.0 with torch.no_grad(): for i, data in enumerate( tqdm(dataloader, total=n_batches, desc="Batch: ", leave=False)): embedding = model_emb.predict(data["images"]) model_class.predict(embedding) model_class.set_ground_truth(data["labels"])
def Check_And_Add_ListMP(): Ref, Worker, Provider, Reference, Presentation, NumRem, NumPre, WeightT, InitialD, FinalD, CodeB, Num_Coils = SQLMP.FindALLMP( Settings.Dir_BD()) Ref2, Worker2, Provider2, Reference2, Presentation2, NumRem2, NumPre2, WeightT2, InitialD2, FinalD2, CodeB2, Num_Coils2 = SQLMP.FindALLMP( Settings.Dir_CBD()) New_ID = [] New_Refs = [] New_Workers = [] New_Providers = [] New_References = [] New_Presentation = [] New_NumRem = [] New_NumPre = [] New_TotalW = [] New_Initial = [] New_Final = [] New_CodeB = [] New_NumCoils = [] for x in range(len(Ref)): if Ref[x] not in New_Refs: New_Refs.append(Ref[x]) New_Workers.append(Worker[x]) New_Providers.append(Provider[x]) New_References.append(Reference[x]) New_Presentation.append(Presentation[x]) New_NumRem.append(NumRem[x]) New_NumPre.append(NumPre[x]) New_TotalW.append(WeightT[x]) New_Initial.append(InitialD[x]) New_Final.append(FinalD[x]) New_CodeB.append(CodeB[x]) New_NumCoils.append(Num_Coils[x]) for x in range(len(Ref2)): if Ref2[x] not in New_Refs: New_Refs.append(Ref2[x]) New_Workers.append(Worker2[x]) New_Providers.append(Provider2[x]) New_References.append(Reference2[x]) New_Presentation.append(Presentation2[x]) New_NumRem.append(NumRem2[x]) New_NumPre.append(NumPre2[x]) New_TotalW.append(WeightT2[x]) New_Initial.append(InitialD2[x]) New_Final.append(FinalD2[x]) New_CodeB.append(CodeB2[x]) New_NumCoils.append(Num_Coils2[x]) for x in range(len(Num_Coils)): New_ID.append(x + 1) SQLMP.DeleteALLMP(Settings.Dir_CBD()) SQLMP.DeleteALLMP(Settings.Dir_BD()) for x in range(len(New_Refs)): SQLMP.AddMP(Settings.Dir_CBD(), New_ID[x], New_Refs[x], New_Workers[x], New_Providers[x], New_References[x], New_Presentation[x], New_NumRem[x], New_NumPre[x], New_TotalW[x], New_Initial[x], New_Final[x], New_CodeB[x], New_NumCoils[x]) SQLMP.AddMP(Settings.Dir_BD(), New_ID[x], New_Refs[x], New_Workers[x], New_Providers[x], New_References[x], New_Presentation[x], New_NumRem[x], New_NumPre[x], New_TotalW[x], New_Initial[x], New_Final[x], New_CodeB[x], New_NumCoils[x])
def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self._ui = uic.loadUi("mainwindow.ui", self) self.setAttribute(Qt.WA_QuitOnClose) self.setAttribute(Qt.WA_DeleteOnClose) # - private void MainForm_Load(object sender, EventArgs e) self.recipe = Recipe() # - recipies self.settings = Settings() # - settings # self.settings.initialize() # - ModbusClient PLC Connect self.modbusClient = ModbusClient('192.168.0.10', 502) self.modbusClient.parity = Parity.even self.modbusClient.unitidentifier = 2 self.modbusClient.baudrate = 9600 self.modbusClient.stopbits = Stopbits.one self.modbusClient.connect() self.gas_out_valve = Valve(self.settings.gas_out_valve, False, modbus_client=self.modbusClient) self.ar_valve = GasValve(self.settings.ar_valve, False, 0, self.settings.ar_mfc, self.settings.ar_sccm) self.o2_valve = GasValve(self.settings.o2_valve, False, 0, self.settings.o2_mfc, self.settings.o2_sccm) self.cf4_valve = GasValve(self.settings.cf4_valve, False, 0, self.settings.cf4_mfc, self.settings.cf4_sccm) self.n2_valve = GasValve(self.settings.n2_valve, False, 0, self.settings.n2_mfc, self.settings.n2_sccm) self.vent_valve = Valve(self.settings.vent_valve, False, modbus_client=self.modbusClient) self.pump_valve = Valve(self.settings.pump_valve, False, modbus_client=self.modbusClient) # - public partial class MainForm : Form self.discreteInputs = self.modbusClient.read_discreteinputs(0, 8) self.holdingRegisters = convert_registers_to_float( self.modbusClient.read_holdingregisters(0, 2)) print(self.holdingRegisters) self.inputRegisters = self.modbusClient.read_inputregisters(0, 8) print(self.inputRegisters) self.coils = self.modbusClient.read_coils(0, 8) print(self.coils) self.modbusClient.write_single_coil(0, True) self.modbusClient.write_single_register(0, 777) self.modbusClient.write_multiple_coils( 0, [True, True, True, True, True, False, True, True]) self.modbusClient.write_multiple_registers( 0, convert_float_to_two_registers(3.141517)) self.modbusClient.close() self.recipe_part = os.path.abspath('./recipies') self.throttle_valve_angle = 0.0 self.timer_pump_for_vent = QTimer() # - pre_vent timer self.valve_port = serial.Serial( port=self.settings.comport_name, baudrate=self.settings.comport_baudrate, timeout=500, write_timeout=500, ) # - com port variable # todo comport checking initialization # - private static Valve VentValve; self.timer_send_receive_modbus = QTimer() # - plc call timer self.timer_check_trhrottle = QTimer() self.timer_pressure_read = QTimer() # - pressure call timer self.timer_for_vent = QTimer() # - vent timer self.timer_process = QTimer() # - process timer self.timer_ignition = QTimer() # - ignition process timer self.process_time_start = 0 # - starting process time self.process_time_end = 0 # - ending process time self.process_time = 0 # - process time self.last_time = 0 # process remain time # - private static string SerialMessage self.pressure_read = 0.0 # - baratron pressure self.pressure_angle = False # - pressure and status of the drosel valve's call self.process_started = False # process status self.pre_pump_process_started = False # pre pump process status self.pressure_input = 0 # reading value from the recipe self.throttle_valve = False # throttle valve variable self.pump_for_vent = False # venting self.vent_for_vent = False self.lid_up_button = False self.lid_down_button = False self.vent_button = False self.pump_button = False self.ignition_start = False self.start_button = False self.stop_button = False self.safe_button = False self.chiller_ok = False self.lid_down_bit = False # lid's bit status self.process_end = False self.venting = False self.lid_closing = False self.mfc_read = [] self.ar_mfc_read = [] self.o2_mfc_read = [] self.cf4_mfc_read = [] self.n2_mfc_read = [] self.sccm_ar = 0 self.sccm_o2 = 0 self.sccm_cf4 = 0 self.sccm_n2 = 0 self.mw_power = 0 self.generator_hb = [] self.read_recipes_from_folder() self.timer_send_receive_modbus.start(300)
#Option 2 - generate images # ═══════════════════════════════════════════ elif userinput == "2": SaveImages() userinput = menu() # Option 3 - Send images # ═══════════════════════════════════════════ elif userinput == "3": SendImages() userinput = menu() # Option 4 - Settings # ═══════════════════════════════════════════ elif userinput == "4": Settings() userinput = menu() # Option 5 - Mark rendered image complete # ═══════════════════════════════════════════ elif userinput == "5": ViewRenderedImages() userinput = menu() # Option 6 - Mark rendered image complete # ═══════════════════════════════════════════ elif userinput == "6": ArchiveRenderedImage() userinput = menu() # All other options - Repeat menu
class App(QWidget): cleanupEvent = pyqtSignal() def __init__(self, resources): super().__init__() self.versionNumber = '1.2.7' self.title = 'Monkey See Monkey Do v'+self.versionNumber self.left = 10 self.top = 80 self.width = 640 self.height = 100 self.folderName = '' self.imageList = [] self.numImages = 0 self.currentImageNumber = 0 self.currentTotalImageNumber = 0 self.hotSpotFilename = 'hotspots.json' self.hotSpotFile = None self.hotSpotSize = 50 self.currentHotSpot = None self.startTime = None self.endTime = None self.robot = [] self.screen = QDesktopWidget().availableGeometry() self.platform = platform.name() self.resources = resources print(self.screen) print('Operating System: ', self.platform) print('Screen: width:', self.screen.width(), 'height:', self.screen.height()) self.initUI() def initUI(self): self.readConfig() self.portLabel = QLabel('Port(s): ', self) self.portDisplay = QLineEdit(self) self.portDisplay.setEnabled(False) self.portRefreshButton = QPushButton(self) self.portRefreshButton.setToolTip('Press to detect port of connected base station') self.portRefreshButton.clicked.connect(self.refreshPorts) self.portRefreshButton.setIcon(QIcon(self.resources['imgRefresh'])) self.portRefreshButton.setFixedWidth(24) self.settingsButton = QPushButton() self.settingsButton.setToolTip('Open the Settings Dialog') self.settingsButton.setIcon(QIcon(self.resources['imgSettings'])) self.settingsButton.setMaximumWidth(24) self.settingsButton.clicked.connect(self.openSettings) self.connected = False self.refreshPorts() if self.showReferenceCreator: self.referenceCreator = QPushButton('Create Reference', self) self.referenceCreator.setToolTip('Create a reference file from the selected image set') self.referenceCreator.clicked.connect(self.createReferenceFile) self.referenceCreator.setEnabled(False) self.folderButton = QPushButton('Select Folder', self) self.folderButton.setToolTip('Select the folder that contains the content you would like to play') self.folderButton.clicked.connect(self.folderButtonClicked) self.folderLabel = QLabel('Selected Folder:', self) self.selectedFolder = QLineEdit(self) self.selectedFolder.setEnabled(False) self.numLevelsLabel = QLabel('Number of Levels:', self) self.numLevelsDisplay = QLineEdit(self) self.numLevelsDisplay.setEnabled(False) self.numImagesLabel = QLabel('Number of Images:', self) self.numImagesDisplay = QLineEdit(self) self.numImagesDisplay.setEnabled(False) self.startLabel = QLabel('Press "Start" to begin game', self) self.startButton = QPushButton('Start', self) self.startButton.setToolTip('Start Game') self.startButton.clicked.connect(self.startButtonClicked) self.startButton.setEnabled(False) self.hboxPort = QHBoxLayout() self.hboxPort.addWidget(self.portLabel) self.hboxPort.addWidget(self.portDisplay) self.hboxPort.addWidget(self.portRefreshButton) self.hboxPort.addWidget(self.settingsButton) self.hbox = QHBoxLayout() self.hbox.addWidget(self.folderLabel) self.hbox.addWidget(self.selectedFolder) self.hboxNumLevels = QHBoxLayout() self.hboxNumLevels.addWidget(self.numLevelsLabel) self.hboxNumLevels.addWidget(self.numLevelsDisplay) self.hboxNumImages = QHBoxLayout() self.hboxNumImages.addWidget(self.numImagesLabel) self.hboxNumImages.addWidget(self.numImagesDisplay) self.vbox = QVBoxLayout() self.vbox.addLayout(self.hboxPort) self.vbox.addWidget(self.folderButton) self.vbox.addLayout(self.hbox) self.vbox.addLayout(self.hboxNumLevels) self.vbox.addLayout(self.hboxNumImages) if self.showReferenceCreator: self.vbox.addWidget(self.referenceCreator) self.vbox.addWidget(self.startLabel) self.vbox.addWidget(self.startButton) self.vbox.addStretch(4) self.startPage = QWidget() self.startPage.setLayout(self.vbox) self.scene = QGraphicsScene() self.graphicsView = GraphicsView(self.scene) self.graphicsView.itemClickedEvent.connect(self.hotSpotClickedHandler) self.graphicsView.keyPressed.connect(self.keyPressedHandler) self.graphicsLayout = QVBoxLayout() self.graphicsLayout.addWidget(self.graphicsView) self.graphicsLayout.setContentsMargins(0, 0, 0, 0) self.gamePage = QWidget() self.gamePage.setLayout(self.graphicsLayout) self.stackedLayout = QStackedLayout() self.stackedLayout.addWidget(self.startPage) self.stackedLayout.addWidget(self.gamePage) self.stackedLayout.setCurrentIndex(0) self.setLayout(self.stackedLayout) self.setWindowTitle(self.title) self.setGeometry(self.left, self.top, self.width, self.height) self.setWindowIcon(QIcon(self.resources['icoMSMD'])) self.cleanupEvent.connect(self.cleanupStuff) self.show() self.bringToFront() def readConfig(self): self.config = configparser.ConfigParser() fileCheck = self.config.read(self.resources['fileConfig']) if(fileCheck == []): QMessageBox.critical(self, 'Config Error!', 'config.ini was not found', QMessageBox.Ok) self.robotSettings = self.config['robot'] self.appSettings = self.config['app'] # robot settings self.upgradeTrigger = self.robotSettings['upgradeTrigger'] self.upgradeMode = self.robotSettings['upgradeMode'] self.minPowerToMove = self.robotSettings['minPowerToMove'] self.maxPowerToMove = self.robotSettings['maxPowerToMove'] # app settings self.showReferenceCreator = int(self.appSettings.get('showReferenceCreator', '1')) self.timeLimitMultiplier = float(self.appSettings.get('time_limit_multiplier', '1')) self.levelToUnlock = int(self.appSettings.get('level_to_unlock', '0')) def writeConfig(self): self.robotSettings['upgradeTrigger'] = self.upgradeTrigger self.robotSettings['upgradeMode'] = self.upgradeMode self.robotSettings['minPowerToMove'] = self.minPowerToMove self.robotSettings['maxPowerToMove'] = self.maxPowerToMove self.appSettings['level_to_unlock'] = str(self.levelToUnlock) with open(self.resources['fileConfig'], 'w') as configFile: self.config.write(configFile) def openSettings(self): try: SettingsIn = { 'upgradeTrigger': 'hotspot', 'upgradeMode': 'left', 'minPowerToMove': '80'} self.settingsWindow = Settings(self.robotSettings) self.settingsWindow.Closing.connect(self.settingsClosed) self.settingsWindow.show() self.setDisabled(True) except: print('ERROR - Setting.py Load Failed!') def settingsClosed(self, message): if(message == 'Abort'): print('Settigns Aborted!') elif(message == 'Closed'): print('Settings Closed!') # Set New Settings newSettings = self.settingsWindow.getSettings() self.upgradeTrigger = newSettings['upgradeTrigger'] self.upgradeMode = newSettings['upgradeMode'] self.minPowerToMove = newSettings['minPowerToMove'] self.maxPowerToMove = newSettings['maxPowerToMove'] self.writeConfig() else: print('ERROR - Unknown message returned from Settings.py Window!') self.setDisabled(False) def bringToFront(self): self.setWindowState(self.windowState() & ~Qt.WindowMinimized | Qt.WindowActive) self.activateWindow() def refreshPorts(self): if(self.connected): for baseStation in self.robot: baseStation.close() comPorts = self.findPorts() if(comPorts): self.robot = [] self.portDisplayText = '' for i, port in enumerate(comPorts): self.robot.append(serial.Serial(port)) self.robot[i].baudrate = 115200 self.robot[i].timeout = 0.05 self.portDisplayText += (port + ' ') self.portDisplay.setText(self.portDisplayText) self.connected = True else: self.robot = [] self.connected = False def folderButtonClicked(self): # get folder with content in it from user self.folderName = QFileDialog.getExistingDirectory(self, "Select Folder Location for Recorded Content") print(self.folderName) if os.path.isdir(self.folderName): # If it is a valid folder self.numLevels = 0 self.numTotalImages = 0 self.listOfFilesInSelectedFolder = os.listdir(self.folderName) self.folderList = [] self.folderListNameOnly = [] for name in self.listOfFilesInSelectedFolder: fullFileName = os.path.join(self.folderName, name) if os.path.isdir(fullFileName): result = self.loadLevel(fullFileName) # load each level to make sure it is valid if(result < 0): # if the folder is not a valid level, quit this function return self.folderList.append(fullFileName) self.folderListNameOnly.append(name) self.numLevels += 1 self.numTotalImages += result self.folderListNameOnly = sorted(self.folderListNameOnly) # sort the resulting list of level folders (they should be named in order they will be played in) if(self.numLevels > 0): # multiLevel game selected self.loadLevel(self.folderList[0]) # load the first level self.numLevelsDisplay.setText(str(self.numLevels)) # display the number of levels in the selected folder else: # single level selected result = self.loadLevel(self.folderName) # try to load the single level selected if(result < 0): # if level is invalid, quit this function return self.numTotalImages = result self.numLevelsDisplay.setText('1') if(self.levelToUnlock>self.numLevels): if(self.numLevels == 0): self.levelToUnlock = 0 else: self.levelToUnlock = self.numLevels-1 self.currentLevel = 0 self.numImagesDisplay.setText(str(self.numTotalImages)) self.startButton.setEnabled(True) if self.showReferenceCreator: self.referenceCreator.setEnabled(True) self.selectedFolder.setText(self.folderName) else: QMessageBox.warning(self, 'Folder Error!', 'The folder does not exist!\nPlease select a valid folder', QMessageBox.Ok) def loadLevel(self, levelToLoad): try: print('Trying to load '+levelToLoad) self.hotSpotFile = open(levelToLoad+os.path.sep+self.hotSpotFilename, 'r') self.hotSpotDict = json.load(self.hotSpotFile) self.numHotSpotRecords = len(self.hotSpotDict) # self.hotSpotCsv = csv.reader(self.hotSpotFile) # next(self.hotSpotCsv) # self.numHotSpotRecords = sum(1 for row in self.hotSpotCsv) # self.hotSpotFile.seek(0) # next(self.hotSpotCsv) #skip column labels on first line self.hotSpotFile.close() buildScanCodeTranslationTable(self.hotSpotDict) except IOError: QMessageBox.critical(self, 'Error: No hotspots.json', 'hotspots.json does not exist\nA Hot Spot file is required to play the game. Please select a complete and valid content folder', QMessageBox.Ok) self.selectedFolder.setText('Error: No hotspots.json') return -1 self.imageList = [] try: for imageFile in sorted((imfile for imfile in os.listdir(levelToLoad) if imfile.endswith('.png'))): self.imageList.append(QImage(levelToLoad+os.path.sep+imageFile)) except IOError: QMessageBox.critical(self, 'Error: images reading', 'Images could not be read\nPlease select a complete and valid content folder', QMessageBox.Ok) return -1 self.numImages = len(self.imageList)-1 if(self.numImages != self.numHotSpotRecords): QMessageBox.critical(self, 'Error: Image Hotspot Mismatch', 'Error: number of images in level "'+str(levelToLoad)+'" do not match the number of hot spot records', QMessageBox.Ok) return -1 return self.numImages def startButtonClicked(self): print('start') self.stackedLayout.setCurrentIndex(1) self.paintImageIndex(0) self.showMaximized() if(self.upgradeTrigger == 'level'): self.setPower((int(self.minPowerToMove)*100)//255) self.startTime = time.time() def paintImageIndex(self, imageNumber): if(self.upgradeTrigger == 'hotspot'): powerLevel = (self.currentTotalImageNumber/(self.numTotalImages-1))*100 print('power:', powerLevel, ' currentTotalImageNum:', self.currentTotalImageNumber, ' numTotalImages:', self.numTotalImages) self.setPower(powerLevel) self.scene.clear() print('current image number:', imageNumber) self.nextHotSpotInput = self.hotSpotDict[str(self.currentImageNumber).zfill(6)] print('nextHotSpotInput', self.nextHotSpotInput) self.currentPixmap = QPixmap.fromImage(self.imageList[imageNumber]).copy(QRect(0, 0, 1920, 1020)).scaled(self.screen.width(), self.screen.height(), aspectRatioMode=Qt.IgnoreAspectRatio) self.scene.addPixmap(self.currentPixmap) self.currentInputModifiers = self.simplifyModifierList(self.nextHotSpotInput['modifiers']) if(self.nextHotSpotInput['type'] == 'mouse'): commandString = '' if self.currentInputModifiers != []: commandString += 'Press ' for mod in self.currentInputModifiers: commandString += mod + ' + ' commandString += 'Click ' self.currentMouseButton = self.nextHotSpotInput['button'] if(self.currentMouseButton == 'right'): pen = QPen(QColor(0, 0, 255, 128)) commandString += 'right mouse button' elif(self.currentMouseButton == 'left'): pen = QPen(QColor(255, 0, 0, 128)) commandString += 'left mouse button' elif(self.currentMouseButton == 'middle'): pen = QPen(QColor(0, 255, 0, 128)) commandString += 'scroll wheel (middle mouse button)' else: pen = QPen(QColor(0, 0, 0, 128)) xScale = self.screen.width()/1920 yScale = self.screen.height()/1020 if(xScale > yScale): minScale = yScale else: minScale = xScale scaledHotSpotSize = self.hotSpotSize*minScale xPosition = self.nextHotSpotInput['position'][0]*xScale yPosition = self.nextHotSpotInput['position'][1]*yScale # adjust yPosition yPosition += 30 print('next hotspot pos x %s y %s' % (xPosition, yPosition)) brush = QBrush(QColor(180, 180, 180, 100)) self.currentHotSpot = QGraphicsEllipseItem() self.currentHotSpot.setRect(xPosition-scaledHotSpotSize/2, yPosition-scaledHotSpotSize/2, scaledHotSpotSize, scaledHotSpotSize) self.currentHotSpot.setBrush(brush) self.currentHotSpot.setPen(pen) self.scene.addItem(self.currentHotSpot) self.currentInputKey = -1 elif(self.nextHotSpotInput['type'] == 'key'): # print('key') self.currentInputKey = self.nextHotSpotInput['scancode'] commandString = 'Press ' for mod in self.currentInputModifiers: commandString += mod commandString += ' + ' commandString += self.nextHotSpotInput['name'] self.currentHotSpot = 'not a hotspot' else: QMessageBox.critical(self, 'Error: hotSpotInput type is incorrect. got: "'+self.nextHotSpotInput['type']+'" expected: "key" or "mouse"', QMessageBox.Ok) self.setWindowTitle(self.title + ' ' + commandString) def playSound(self): class SoundThread(QThread): signal = pyqtSignal('PyQt_PyObject') def __init__(self, soundFilename): super().__init__() self.soundFilename = soundFilename def run(self): # define stream chunk chunk = 1024 # open a wav format music f = wave.open(self.soundFilename, "rb") # instantiate PyAudio p = pyaudio.PyAudio() # open stream stream = p.open(format=p.get_format_from_width(f.getsampwidth()), channels=f.getnchannels(), rate=f.getframerate(), output=True) # read data data = f.readframes(chunk) # play stream while data: stream.write(data) data = f.readframes(chunk) # stop stream stream.stop_stream() stream.close() # close PyAudio p.terminate() self.signal.emit(soundFilename) subFolder = '' if self.folderListNameOnly: subFolder = '%s%s' % (self.folderListNameOnly[self.currentLevel], os. path.sep) soundFilename = '%s%s%ssound%s.wav'% (self.folderName, os.path.sep, subFolder, self.currentImageNumber) if not os.path.isfile(soundFilename): return try: self.soundThread = SoundThread(soundFilename) self.soundThread.signal.connect(self.soundFinished) self.soundThread.start() except: print('something when wrong with the sound thread') def soundFinished(self, soundFile): print('finished playing %s' % soundFile) def hotSpotClickedHandler(self, itemClicked, modifiers, mouseButton): print('itemClicked %s, self.currentHotSpot %s, mouseButton %s' % (itemClicked, self.currentHotSpot, mouseButton)) if itemClicked is self.currentHotSpot: if self.checkModifierMatch(modifiers): if self.checkButtonMatch(mouseButton): # print('clicked on hot spot!') self.playSound() self.currentImageNumber += 1 self.currentTotalImageNumber += 1 if self.currentImageNumber >= self.numImages: self.levelCompleted() else: self.paintImageIndex(self.currentImageNumber) else: # print('wrong mouse button clicked') pass else: # print("modifiers don't match") pass else: # print('wrong spot clicked') pass def checkButtonMatch(self, pressedMouseButton): if pressedMouseButton == Qt.LeftButton: pressedMouseButtonString = 'left' if pressedMouseButton == Qt.RightButton: pressedMouseButtonString = 'right' if pressedMouseButton == Qt.MiddleButton: pressedMouseButtonString = 'middle' return self.currentMouseButton == pressedMouseButtonString def keyPressedHandler(self, nativeScanCode, keyText, modifiers): print('scanCode %s, currentInputKey %s' % (nativeScanCode, self.currentInputKey)) if (nativeScanCode == self.currentInputKey) and self.checkModifierMatch(modifiers): # print('pressed correct key (or key combination)') self.playSound() self.currentImageNumber += 1 self.currentTotalImageNumber += 1 if self.currentImageNumber >= self.numImages: self.levelCompleted() else: self.paintImageIndex(self.currentImageNumber) else: # print('wrong key or key combination pressed') pass def checkModifierMatch(self, pressedModifiers): modifierTextList = [] if(pressedModifiers & Qt.ShiftModifier): modifierTextList.append('shift') if(pressedModifiers & Qt.AltModifier): modifierTextList.append('alt') # handle key differences for mac if(self.platform in ['Windows', 'Linux']): if(pressedModifiers & Qt.ControlModifier): modifierTextList.append('ctrl') if(pressedModifiers & Qt.MetaModifier): modifierTextList.append('win') else: if(pressedModifiers & Qt.ControlModifier): modifierTextList.append('cmd') # on the mac this is the command key if(pressedModifiers & Qt.MetaModifier): modifierTextList.append('ctrl') # on the mac this is the control key return set(modifierTextList) == set(self.currentInputModifiers) def simplifyModifierList(self, modifierList): tempSet = set() for item in modifierList: if item == 'left shift': tempSet.add('shift') elif item == 'right shift': tempSet.add('shift') elif item == 'left ctrl': tempSet.add('ctrl') elif item == 'right ctrl': tempSet.add('ctrl') elif item == 'left alt': tempSet.add('alt') elif item == 'right alt': tempSet.add('alt') else: tempSet.add(item) return list(tempSet) def levelCompleted(self): self.levelTime = time.time()-self.startTime print('completed level: ', self.currentLevel+1) if(self.upgradeTrigger == 'level'): powerLevel = (self.currentLevel/(self.numLevels-1))*100 self.setPower(powerLevel) timeToBeat = (self.currentTotalImageNumber)*self.timeLimitMultiplier if(self.currentLevel == self.levelToUnlock): print('unlockLevel?') # if the level was completed fast enough to move on if(self.levelTime <= timeToBeat): print('levelUnlocked') # (next level is all levels compounded...) # if the level completed was the last level if(self.currentLevel >= self.numLevels-1): self.gameCompleted() else: # move level to unlock up to next level self.levelToUnlock += 1 # otherwise ask the user if they want to play the next # level or quit buttonReply = QMessageBox.question( self, 'You Beat Level ' + str(self.currentLevel+1), 'You Beat the level!\nYou completed the level in ' + "%.2f" % self.levelTime + ' seconds out of ' + "%.2f" % timeToBeat + '\nPlay next level?', QMessageBox.Yes | QMessageBox.Cancel) if(buttonReply == QMessageBox.Cancel): # quit game and go back to home screen self.returnToHomeScreen() else: # restart (but with next level unlocked) self.currentLevel = 0 self.currentImageNumber = 0 self.currentTotalImageNumber = 0 self.loadLevel(self.folderList[self.currentLevel]) self.paintImageIndex(0) else: print('levelFailed') # display dialog; complete in X time to advance to next level. Replay? Quit? buttonReply = QMessageBox.information(self, 'Too Slow...', 'You were not fast enough.\nYou completed the level in ' + "%.2f" % (self.levelTime) + ' seconds\nFinish in ' + "%.2f" % timeToBeat + ' seconds or less to move on.', QMessageBox.Ok | QMessageBox.Cancel) if(buttonReply == QMessageBox.Cancel): # quit game and go back to home screen self.returnToHomeScreen() else: # restart self.currentLevel = 0 self.currentImageNumber = 0 self.currentTotalImageNumber = 0 self.loadLevel(self.folderList[self.currentLevel]) self.paintImageIndex(0) self.startTime = time.time() else: # play next level self.currentLevel += 1 self.currentImageNumber = 0 self.loadLevel(self.folderList[self.currentLevel]) self.paintImageIndex(0) def returnToHomeScreen(self): print('returning to home screen') self.setWindowTitle(self.title) self.scene.clear() self.currentHotSpot = None self.currentImageNumber = 0 self.currentTotalImageNumber = 0 self.stackedLayout.setCurrentIndex(0) self.showNormal() if(self.numLevels > 0): self.loadLevel(self.folderList[0]) else: self.loadLevel(self.folderName) self.currentLevel = 0 def gameCompleted(self): self.endTime = time.time() timeToBeat = (self.currentTotalImageNumber)*self.timeLimitMultiplier self.scene.clear() self.currentHotSpot = None self.currentImageNumber = 0 self.currentTotalImageNumber = 0 self.currentPixmap = None self.currentPixmap = QPixmap.fromImage(self.imageList[self.numImages]).copy(QRect(0, 0, 1920, 1020)).scaled(self.screen.width(), self.screen.height(), aspectRatioMode=Qt.IgnoreAspectRatio) self.scene.addPixmap(self.currentPixmap) buttonReply = QMessageBox.information(self, 'You Win!', 'Congradulations, You Won!\nYou completed the game in ' + "%.2f" % (self.endTime-self.startTime) + ' seconds out of ' "%.2f" % timeToBeat, QMessageBox.Ok) if buttonReply == QMessageBox.Ok: self.setWindowTitle(self.title) self.stackedLayout.setCurrentIndex(0) self.showNormal() if(self.numLevels > 0): self.loadLevel(self.folderList[0]) else: self.loadLevel(self.folderName) self.currentLevel = 0 def findPorts(self): ports = list(serial.tools.list_ports.comports()) comPortsList = [] # microcontrollerPort = None for port in ports: if 'Silicon Labs' in str(port[1]): comPortsList.append(port[0]) return comPortsList def setPower(self, powerLevel): if(powerLevel > 100): raise ValueError('powerLevel cannot be set above 100') if(powerLevel < 0): raise ValueError('powerLevel cannot be set below 0') minPower = int(self.minPowerToMove) mode = self.upgradeMode leftPower = minPower rightPower = minPower maxPower = int(self.maxPowerToMove) if(mode == "left"): if(powerLevel <= 50): leftPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower) rightPower = self.interpolate(powerLevel, 0, 50, minPower, maxPower) else: leftPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower) rightPower = self.interpolate(powerLevel, 50, 100, minPower, maxPower) elif(mode == "right"): if(powerLevel <= 50): rightPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower) leftPower = self.interpolate(powerLevel, 0, 50, minPower, maxPower) else: rightPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower) leftPower = self.interpolate(powerLevel, 50, 100, minPower, maxPower) elif(mode == "both"): leftPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower) rightPower = leftPower elif(mode == "distance"): # add fuel to the robot "tank" pass else: raise ValueError('upgradeMode in config.ini does not match any accepted value') iLP = int(leftPower) iRP = int(rightPower) # desiredPowerLevel -= 45 if self.robot: print('connected to BaseStation, attempting to set power to', powerLevel, ' L:', leftPower, 'R:', rightPower) for baseStation in self.robot: baseStation.write(bytes([0, 0, iLP, iRP])+b'\n') baseStation.write(bytes([0, 0, iLP, iRP])+b'\n') else: print('BaseStation not connected, cannot change power level') def interpolate(self, inputValue, inputMin, inputMax, outputMin, outputMax): ratio = (inputValue - inputMin)/(inputMax - inputMin) outputValue = (outputMax - outputMin) * ratio + outputMin return outputValue def closeEvent(self, event): print('emitting cleanup event') try: self.settingsWindow.Abort() except: print('ERROR - Could not properly close settings window!') self.cleanupEvent.emit() def cleanupStuff(self): if self.robot: for baseStation in self.robot: baseStation.close() print('closing') def createReferenceFile(self): referenceFolder = QFileDialog.getExistingDirectory(self, "Select Folder Location for Reference") self.startTime = time.time() if os.path.isdir(referenceFolder): if(self.numLevels > 0): # multiLevel game selected print('multiLevelGame Reference started') for i in range(0, self.numLevels): # create folder to hold level in reference file levelFolderName = referenceFolder+os.path.sep+self.folderListNameOnly[i] os.mkdir(levelFolderName) self.loadLevel(self.folderList[i]) # start msmd level self.stackedLayout.setCurrentIndex(1) self.showMaximized() time.sleep(0.2) for j in range(0, self.numImages): print('next image: '+str(j)) self.paintImageIndex(j) QApplication.processEvents() time.sleep(0.05) imageName = str(self.currentImageNumber).zfill(6) pyautogui.screenshot(levelFolderName+os.path.sep+imageName+'.png') self.currentImageNumber += 1 self.currentTotalImageNumber += 1 self.currentImageNumber = 0 else: print('singleLevelGame Reference Started') self.loadLevel(self.folderName) self.stackedLayout.setCurrentIndex(1) self.showMaximized() for j in range(0, self.numImages): print('next image: '+str(j)) self.paintImageIndex(j) QApplication.processEvents() time.sleep(0.05) imageName = str(self.currentImageNumber).zfill(6) pyautogui.screenshot(levelFolderName+os.path.sep+imageName+'.png') self.currentImageNumber += 1 self.currentTotalImageNumber += 1 self.currentImageNumber = 0 self.gameCompleted()
from Calculation import Calculation from SourceData import SourceData from OpticalElementData import OpticalElementData from Settings import Settings sd = SourceData() sd.source_samplingarea = [400e-9, 720e-9] #400 to 720 nm oe = OpticalElementData() se = Settings() calc = Calculation(sd, oe, se) calc.Calculation() calc.Plot_All_SaveAll()
def __init__(self): Game.__init__(self, Settings().keywords["Titles"]["game-hotpotato"]) self.currentHolder = None self.stopTimer = {"master": False, "single": False}
def write(self, file=''): if not file: file = self.settings.OutputFolder + '/' + self.settings.tersehtml try: f = open(file, 'w') except IOError: log.critical('Cannot open %s for writing' % (file)) return f.write(self.insert_HTML_fields()) f.close() log.debug('Web page %s was updated' % (file)) def insert_HTML_fields(self): d = { 'JSMolPath': self.settings.JSMolLocation, 'timestamp': self.settings.timestamp, 'JMolPath': self.settings.JmolPath, 'TableBody': self.tableBody, 'JMolWinX': self.settings.JmolWinX, 'JMolWinY': self.settings.JmolWinY, 'jmoloptions': self.settings.JavaOptions, } return self.s % d if __name__ == "__main__": h = HTML() from Settings import Settings h.settings = Settings() tr = tag('abcd', 'tr')
class Main: def __init__(self): self.top = Tk() self.settings = Settings() self.server_var = None self.username_var = None self.password_var = None self.connect_window = None self.text_output = None self.__logs__ = [] def __confirm_save__(self): if askyesno(title="Confirm Settings", message="Would you like to save these changes?"): self.settings.set_login_info(self.username_var.get(), self.password_var.get()) self.settings.set_server_address(self.server_var.get()) self.connect_window.destroy() def __load_connect_widgets__(self): frame_top = Frame(self.connect_window) frame_mid = Frame(self.connect_window) frame_bot = Frame(self.connect_window) lbl_server = Label(frame_top, text="Server Address") lbl_username = Label(frame_mid, text='Username') lbl_password = Label(frame_bot, text='Password') entry_server = Entry(frame_top, textvariable=self.server_var, width=50) entry_username = Entry(frame_mid, textvariable=self.username_var, width=50) entry_password = Entry(frame_bot, textvariable=self.password_var, exportselection=0, show='*', width=50) btn_save = Button(self.connect_window, text='Save', command=self.__confirm_save__, width=25, height=5) btn_cancel = Button(self.connect_window, text='Cancel', command=self.connect_window.destroy, width=25, height=5) frame_top.pack(side=TOP) frame_mid.pack(side=TOP) frame_bot.pack(side=TOP) lbl_server.pack(side=LEFT) lbl_username.pack(side=LEFT) lbl_password.pack(side=LEFT) entry_server.pack(side=RIGHT, expand=TRUE) entry_username.pack(side=RIGHT, expand=TRUE) entry_password.pack(side=RIGHT, expand=TRUE) btn_save.pack(side=RIGHT) btn_cancel.pack(side=LEFT) def __get_log_files__(self): self.text_output.delete(0.0, 255.255) self.text_output.insert(INSERT, "Scanning folder for files...\n") path = self.settings.get_log_path() logs = [a for a in listdir(path) if isfile(join(path, a))] self.text_output.insert(INSERT, str(len(logs)) + " files retrieved\n") self.text_output.insert(INSERT, "Press Upload File(s) to continue\n") self.__set_logs__(logs) return logs def __set_logs__(self, logs): for i in logs: self.__logs__.append(self.settings.get_log_path() + "/" + i) print(self.__logs__) def __check_settings__(self): if self.settings.get_log_path() is sys.path[0]: return "Warning! Log folder path has not been set up. Please change the folder path in settings." return "Press \"Prepare Files\" to begin" def __upload_files__(self): if len(self.__logs__) > 0: serve = self.settings.get_server_address() user = self.settings.get_username() passwo = self.settings.get_password() upload = FTPConnect(serve, user, passwo) self.text_output.insert(INSERT, "Attempting to connect...\n") result = upload.connect() if result: self.text_output.insert(INSERT, "Connection Successful!\n") for log in self.__logs__: upload.upload_file(log) self.text_output.insert(INSERT, "Log successfully uploaded.\n") self.__move_files(upload.new_names) upload.ftps.close() else: self.text_output.insert(INSERT, "Connection has failed!\n") self.text_output.insert(INSERT, "Check connection settings!\n") else: self.text_output.insert(INSERT, "There are no files ready to be uploaded!\n Either press \"Prepare Files\" or check the log folder path settings") def __move_files(self, new_names): for i in range(len(self.__logs__)): os.rename(self.__logs__[i], self.settings.get_processed_folder()+ "/" + new_names[i].replace(" ", "", 1).replace(":", "-")) self.__logs__.clear() def run(self): """Main Loop""" frame = Frame(self.top) bottom_frame = Frame(frame, bg='darkgrey') settingsbutton = Button(bottom_frame, text='Settings', width=25, height=5, command=self.settings.launch) connection_button = Button(bottom_frame,text="Connection Settings", width=25, height=5, command=self.connect_settings) btn_get_files = Button(bottom_frame, text='Prepare Files', width=25, height=5, command=self.__get_log_files__) uploadbutton = Button(bottom_frame, text='Upload File(s)', width=25, height=5, command=self.__upload_files__) self.text_output = Text(frame) self.text_output.insert(0.0, self.__check_settings__()) frame.pack() bottom_frame.pack(side=BOTTOM, fill=X) settingsbutton.pack(side=LEFT) connection_button.pack(side=LEFT) btn_get_files.pack(side=LEFT) uploadbutton.pack(side=RIGHT) self.text_output.pack(side=TOP) self.top.mainloop() def connect_settings(self): """Loads the connection settings window""" self.connect_window = Toplevel() self.connect_window.minsize(500, 100) self.server_var = StringVar() self.username_var = StringVar() self.password_var = StringVar() self.__load_connect_widgets__() self.connect_window.grab_set() self.server_var.set(self.settings.get_server_address()) self.username_var.set(self.settings.get_username()) self.password_var.set(self.settings.get_password())
def UpdateMP(TABLA: str, REMISION: str, DATO_MOD, Value): engine = create_engine(TABLA, echo=True) Base.metadata.create_all(bind=engine) Session = sessionmaker(bind=engine) session = Session() valueRef2, ValueWork, ValueProv, ValueReference, ValuePres, ValueRem, ValueNunPre, ValueTotalW, ValueInDate, ValueFinalDate, ValueCode, ValueCoils = SQLMP.FindMP( TABLA, REMISION) if DATO_MOD == Settings.Var_Comp26(): session.query(SQLMP).filter_by(Ref2=valueRef2).update( {SQLMP.Ref2: Value}) elif DATO_MOD == Settings.Var_Comp15(): session.query(SQLMP).filter_by(Worker=ValueWork).update( {SQLMP.Worker: Value}) elif DATO_MOD == Settings.Var_Comp14(): session.query(SQLMP).filter_by(Provider=ValueProv).update( {SQLMP.Provider: Value}) elif DATO_MOD == Settings.Var_Comp13(): session.query(SQLMP).filter_by(Reference=ValueReference).update( {SQLMP.Reference: Value}) elif DATO_MOD == Settings.Var_Comp12(): session.query(SQLMP).filter_by(Presentation=ValuePres).update( {SQLMP.Presentation: Value}) elif DATO_MOD == Settings.Var_Comp2(): session.query(SQLMP).filter_by(Num_Rem=ValueRem).update( {SQLMP.Num_Rem: Value}) elif DATO_MOD == Settings.Var_Comp3(): session.query(SQLMP).filter_by(Num_Pre=ValueNunPre).update( {SQLMP.Num_Pre: Value}) elif DATO_MOD == Settings.Var_Comp4(): session.query(SQLMP).filter_by(Total_Weight=ValueTotalW).update( {SQLMP.Total_Weight: Value}) elif DATO_MOD == Settings.Var_Comp19(): session.query(SQLMP).filter_by(Initial_Date=ValueInDate).update( {SQLMP.Initial_Date: Value}) elif DATO_MOD == Settings.Var_Comp20(): session.query(SQLMP).filter_by(Final_Date=ValueFinalDate).update( {SQLMP.Final_Date: Value}) elif DATO_MOD == Settings.Var_Comp1(): session.query(SQLMP).filter_by(Code=ValueCode).update( {SQLMP.Code: Value}) elif DATO_MOD == Settings.Var_Comp6(): session.query(SQLMP).filter_by(Num_Coils=ValueCoils).update( {SQLMP.Num_Coils: Value}) session.commit() session.close()
class CNN_Vis_Demo_Model(QObject): # These indices are used to notify the view about the changes data_idx_model_names = 0 data_idx_layer_names = 1 data_idx_layer_output_sizes = 2 data_idx_layer_activation = 3 data_idx_probs = 4 data_idx_input_image_names = 5 data_idx_input_image = 6 data_idx_labels = 7 data_idx_new_input = 128 data_idx_input_image_path = 8 dataChanged = pyqtSignal(int) settings = None class BackpropModeOption(Enum): GRADIENT = 'Gradient' ZF = 'ZF Deconv' GUIDED = 'Guided Backprop' def __init__(self): super(QObject, self).__init__() self.settings = Settings() # Read settings from files self.caffevis_caffe_root = self.settings.caffevis_caffe_root sys.path.insert(0, os.path.join(self.caffevis_caffe_root, 'python')) import caffe if self.settings.use_GPU: caffe.set_mode_gpu() caffe.set_device(self.settings.gpu_id) print('Loaded caffe in GPU mode, using device', self.settings.gpu_id) else: caffe.set_mode_cpu() print('Loaded caffe in CPU mode') self.camera_id = self.settings.camera_id self.cap = cv2.VideoCapture(self.camera_id) self._layer_list = [] # to be read from prototxt self._layer_output_sizes = {} # to be read from prototxt self.online = False # indicates if the network has finished classifying an image def set_model(self, model_name): """ set the network model :param model_name: :return: """ if self.settings.model_names.__contains__(model_name): self.settings.load_settings(model_name) self.online = False self.load_net(model_name) def load_net(self, model_name): sys.path.insert(0, os.path.join(self.caffevis_caffe_root, 'python')) import caffe self._model_name = model_name self._model_def = self.settings.prototxt self._model_weights = self.settings.network_weights self._labels = np.loadtxt(self.settings.label_file, str, delimiter='\n') processed_prototxt = self._process_network_proto(self._model_def) # enable deconvolution self._net = caffe.Classifier(processed_prototxt, self._model_weights, mean=self.settings.mean, raw_scale=255.0, channel_swap=self.settings.channel_swap) current_input_shape = self._net.blobs[self._net.inputs[0]].shape current_input_shape[0] = 1 self._net.blobs[self._net.inputs[0]].reshape(*current_input_shape) self._net.reshape() self._get_layers_info() self.dataChanged.emit(self.data_idx_layer_names) # get the names of demo-images self._input_image_names = [image_name for image_name in os.listdir(self.settings.input_image_path)] self.dataChanged.emit(self.data_idx_input_image_names) self._transformer = caffe.io.Transformer( {self._data_blob_name: self._net.blobs[self._data_blob_name].data.shape}) self._transformer.set_transpose(self._data_blob_name, (2, 0, 1)) # move image channels to outermost dimension self._transformer.set_mean(self._data_blob_name, self.settings.mean) # subtract the dataset-mean value in each channel self._transformer.set_raw_scale(self._data_blob_name, 255) # rescale from [0, 1] to [0, 255] self._transformer.set_channel_swap(self._data_blob_name, self.settings.channel_swap) def set_input_and_forward(self, input_image_name, video=False): """ use static image file or camera as input to forward the network. View will be informed to resfresh the content. If video is set, input_image_name will be ignored. :param input_image_name: The file name of the local image file :param video: set True to use camera as input """ sys.path.insert(0, os.path.join(self.caffevis_caffe_root, 'python')) import caffe def _forward_image(_image): input_image = caffe.io.resize(_image, self._input_dims, mode='constant', cval=0) self._input_image = (input_image * 255).astype(np.uint8) transformed_image = self._transformer.preprocess(self._data_blob_name, input_image) self._net.blobs[self._data_blob_name].data[...] = transformed_image self._net.forward() self.online = True self.dataChanged.emit(self.data_idx_new_input) def _square(_image): """ adjust image dimensions so that the image will be expanded to the largest side padding order: top, bottom, left, right :param _image: image to be processed :return: processed image """ [height, width, _] = _image.shape # icon portrait mode if width < height: pad_size = height - width if pad_size % 2 == 0: icon_squared = cv2.copyMakeBorder(_image, 0, 0, pad_size / 2, pad_size / 2, cv2.BORDER_CONSTANT, value=[0, 0, 0]) else: icon_squared = cv2.copyMakeBorder(_image, 0, 0, pad_size / 2 + 1, pad_size / 2, cv2.BORDER_CONSTANT, value=[0, 0, 0]) return icon_squared # icon landscape mode elif height < width: pad_size = width - height if pad_size % 2 == 0: # top, bottom, left, right icon_squared = cv2.copyMakeBorder(_image, pad_size / 2, pad_size / 2, 0, 0, cv2.BORDER_CONSTANT, value=[0, 0, 0]) else: icon_squared = cv2.copyMakeBorder(_image, pad_size / 2 + 1, pad_size / 2, 0, 0, cv2.BORDER_CONSTANT, value=[0, 0, 0]) return icon_squared elif height == width: return _image def _crop_max_square(_image): """ crop the biggest square at the center of a image :param _image: image to be processed :return: processed image """ h, w, c = _image.shape l = min(h, w) if (h + l) % 2 != 0: _image = _image[(h - l + 1) / 2:(h + l + 1) / 2, :, :] elif (w + l) % 2 != 0: _image = _image[:, (w - l + 1) / 2:(w + l + 1) / 2, :] else: _image = _image[(h - l) / 2:(h + l) / 2, (w - l) / 2:(w + l) / 2, :] return _image if video: ret, frame = self.cap.read() squared_image = _crop_max_square(frame) _forward_image(cv2.flip(squared_image[:, :, (2, 1, 0)], 1)) # RGB else: if self._input_image_names.__contains__(input_image_name): self._input_image_path = os.path.join(self.settings.input_image_path, input_image_name) image = caffe.io.load_image(self._input_image_path) # RGB image = _square(image) _forward_image(image) def get_data(self, data_idx): """ Use the data index to get the data. The intend was to add control logic in access. But, this seems to be useless. :param data_idx: :return: Desired data """ if data_idx == self.data_idx_model_names: return self.settings.model_names elif data_idx == self.data_idx_layer_names: return self._layer_list elif data_idx == self.data_idx_layer_output_sizes: return self._layer_output_sizes elif data_idx == self.data_idx_probs: return self._net.blobs[self._props_blob_name].data.flatten() elif data_idx == self.data_idx_input_image_names: return self._input_image_names elif data_idx == self.data_idx_labels: return self._labels elif data_idx == self.data_idx_input_image_path: return self._input_image_path elif data_idx == self.data_idx_input_image: return self._input_image def get_activations(self, layer_name): """ Get all the activations of one layer :param layer_name: :return: activations (N, H, W) """ if self.online and self._layer_list.__contains__(layer_name): activations = self._net.blobs[layer_name].data[0] return activations def get_activation(self, layer_name, unit_index): """ Get the activation of a neuron :param layer_name: :return: activations (H, W) """ if self.online and self._layer_list.__contains__(layer_name) and unit_index < \ self._layer_output_sizes[layer_name][0]: activation = self._net.blobs[layer_name].data[0][unit_index] return activation def get_top_k_images_of_unit(self, layer_name, unit_index, k, get_deconv): """ Get k images with highest acivation to one certain neuron. :param layer_name: :param unit_index: :param k: :param get_deconv: Get the deconv results of the top images :return: Desired top k images """ if self.online and self.settings.deepvis_outputs_path and self._layer_list.__contains__(layer_name) \ and unit_index < self._layer_output_sizes[layer_name][0]: unit_dir = os.path.join(self.settings.deepvis_outputs_path, layer_name, 'unit_%04d' % unit_index) assert k <= 9 if get_deconv: type = 'deconvnorm' else: type = 'maxim' pixmaps = [] for i in range(k): file_name = '%s_%03d.png' % (type, i) file_path = os.path.join(unit_dir, file_name) if os.path.exists(file_path): pixmaps.append(QPixmap(file_path)) else: print(file_path + " not exists.") return pixmaps def get_top_1_images_of_layer(self, layer_name): """ Get the top 1 images of all units in one layers :param layer_name: :return: The images with highest activations to the units """ if self.online and self.settings.deepvis_outputs_path and self._layer_list.__contains__(layer_name): channel_number = self._layer_output_sizes[layer_name][0] pixmaps = [] for unit_index in range(channel_number): unit_dir = os.path.join(self.settings.deepvis_outputs_path, layer_name, 'unit_%04d' % unit_index) file_name = 'maxim_000.png' file_path = os.path.join(unit_dir, file_name) pixmaps.append(QPixmap(file_path)) return pixmaps def get_deconv(self, layer_name, unit_index, backprop_mode): """ Compute the backprop/deconv of one unit :param layer_name: :param unit_index: :param backprop_mode: Avaliable options: self.BackpropModeOption :return: result """ diffs = self._net.blobs[layer_name].diff[0] diffs = diffs * 0 data = self._net.blobs[layer_name].data[0] diffs[unit_index] = data[unit_index] diffs = np.expand_dims(diffs, 0) # add batch dimension layer_name = str(layer_name) if backprop_mode == self.BackpropModeOption.GRADIENT.value: result = self._net.backward_from_layer(layer_name, diffs, zero_higher=True) elif backprop_mode == self.BackpropModeOption.ZF.value: result = self._net.deconv_from_layer(layer_name, diffs, zero_higher=True, deconv_type='Zeiler & Fergus') elif backprop_mode == self.BackpropModeOption.GUIDED.value: result = self._net.deconv_from_layer(layer_name, diffs, zero_higher=True, deconv_type='Guided Backprop') else: result = None if result is not None: result = np.transpose(result[self._net.inputs[0]][0], (1, 2, 0)) return result def _process_network_proto(self, prototxt): processed_prototxt = prototxt + ".processed_by_deepvis" # check if force_backwards is missing found_force_backwards = False with open(prototxt, 'r') as proto_file: for line in proto_file: fields = line.strip().split() if len(fields) == 2 and fields[0] == 'force_backward:' and fields[1] == 'true': found_force_backwards = True break # write file, adding force_backward if needed with open(prototxt, 'r') as proto_file: with open(processed_prototxt, 'w') as new_proto_file: if not found_force_backwards: new_proto_file.write('force_backward: true\n') for line in proto_file: new_proto_file.write(line) # run upgrade tool on new file name (same output file) upgrade_tool_command_line = self.caffevis_caffe_root + '/build/tools/upgrade_net_proto_text.bin ' + processed_prototxt + ' ' + processed_prototxt os.system(upgrade_tool_command_line) return processed_prototxt def switch_camera(self, on): if on: self.cap.open(self.camera_id) else: self.cap.release() def _get_layers_info(self): """ Get the layer names / output sizes / 'data' blob name / input dimension :return: """ self._layer_list = [] self._layer_output_sizes = {} # go over layers all_layer_list = list(self._net._layer_names) total_layer_number = len(all_layer_list) for idx in range(total_layer_number): layer_name = all_layer_list[idx] # skip input, output and inplace layers. eg. relu if idx == 0 or idx == total_layer_number - 1 or ( len(self._net.top_names[layer_name]) == 1 and len(self._net.bottom_names[layer_name]) == 1 and self._net.top_names[layer_name][0] == self._net.bottom_names[layer_name][0]): continue self._layer_list.append(layer_name) # get layer output size top_shape = self._net.blobs[layer_name].data[0].shape self._layer_output_sizes.update({layer_name: top_shape}) # get data blob name self._data_blob_name = self._net.top_names[all_layer_list[0]][0] # get input dims self._input_dims = self._net.blobs[self._data_blob_name].data.shape[2:4] # get prob blob name self._props_blob_name = self._net.top_names[all_layer_list[-1]][0]
PB = E.CyPitboss() gc = E.CyGlobalContext() LT = E.CyTranslator() # Add Altroot python folder as import path pythonDir = os.path.join(gc.getAltrootDir(), '..', 'Python', 'v8') if pythonDir not in sys.path: sys.path.append(pythonDir) from Settings import Settings import FindHash from WebserverActions import Action_Handlers, createGameData \ , gen_answer \ #, getListOfSaves, getSaveFolder PbSettings = Settings() #.instance() class HTTPRequestHandler(BaseHTTPRequestHandler): """The do_POST method of this class handle the control commands of the webinterface """ def log_message(self, _format, *args): "Redefine is ness. to omit python error popups!!" return def check_password(self, input_pw): if input_pw == PbSettings['webserver']['password']: return True
def __init__(self, settings_bin_path, device, show_progressbar, input_adc_array, out_array_mean, out_array_sigma, out_array_is_ped, out_array_is_hit, out_array_is_seed, out_array_chs_cm, out_array_cm, out_array_mean_cmc, out_array_sigma_cmc, out_array_is_ped_cmc, out_array_is_hit_cmc, out_array_is_seed_cmc, det_index): mp.Process.__init__(self) print 'Creating PedestalCalculations instance' self.show_pb = show_progressbar self.settings = Settings() self.device = device self.do_cmc = self.settings.do_cmc and (self.device == 'dut') self.LoadSettingsBinary(settings_bin_path) self.out_dir = self.settings.output_dir self.sub_dir = self.settings.sub_dir self.file_name = self.settings.file_name self.tree_name = self.settings.tree_name self.slide_leng = self.settings.sliding_length self.run_no = self.settings.run self.ana_events = self.settings.ana_events self.ped_branches = [ 'diaPed', 'diaPedSigma', 'cm', 'diaPedCmc', 'diaPedSigmaCmc', 'diaSignal', 'diaSignalCmc' ] self.raw_tel_branches_dic = { 0: 'D0X_ADC', 1: 'D0Y_ADC', 2: 'D1X_ADC', 3: 'D1Y_ADC', 4: 'D2X_ADC', 5: 'D2Y_ADC', 6: 'D3X_ADC', 7: 'D3Y_ADC' } self.device_to_position = { 'telx0': 0, 'tely0': 1, 'telx1': 2, 'tely1': 3, 'telx2': 4, 'tely2': 5, 'telx3': 6, 'tely3': 7 } self.raw_dut_branch = 'DiaADC' self.rootFile = ro.TFile() self.rootTree = ro.TTree() self.utils = Utils() self.dest_path_stem = self.out_dir + '/' + self.sub_dir + '/' + str( self.run_no) + '/' + self.device self.read_branch = self.raw_tel_branches_dic[ 0] if self.device == 'telx0' else self.raw_tel_branches_dic[ 1] if self.device == 'tely0' else self.raw_tel_branches_dic[ 2] if self.device == 'telx1' else self.raw_tel_branches_dic[ 3] if self.device == 'tely1' else self.raw_tel_branches_dic[ 4] if self.device == 'telx2' else self.raw_tel_branches_dic[ 5] if self.device == 'tely2' else self.raw_tel_branches_dic[ 6] if self.device == 'telx3' else self.raw_tel_branches_dic[ 7] if self.device == 'tely3' else self.raw_dut_branch self.hit_factor = self.settings.clust_hit[ 0] if self.device == 'telx0' else self.settings.clust_hit[ 1] if self.device == 'tely0' else self.settings.clust_hit[ 2] if self.device == 'telx1' else self.settings.clust_hit[ 3] if self.device == 'tely1' else self.settings.clust_hit[ 4] if self.device == 'telx2' else self.settings.clust_hit[ 5] if self.device == 'tely2' else self.settings.clust_hit[ 6] if self.device == 'telx3' else self.settings.clust_hit[ 7] if self.device == 'tely3' else self.settings.clust_hit[ 8] self.seed_factor = self.settings.clust_seed[ 0] if self.device == 'telx0' else self.settings.clust_seed[ 1] if self.device == 'tely0' else self.settings.clust_seed[ 2] if self.device == 'telx1' else self.settings.clust_seed[ 3] if self.device == 'tely1' else self.settings.clust_seed[ 4] if self.device == 'telx2' else self.settings.clust_seed[ 5] if self.device == 'tely2' else self.settings.clust_seed[ 6] if self.device == 'telx3' else self.settings.clust_seed[ 7] if self.device == 'tely3' else self.settings.clust_seed[ 8] self.np_type = self.settings.dut_np_data_type if self.device == 'dut' else self.settings.tel_np_data_type self.chs = self.settings.dutDetChs if self.device == 'dut' else self.settings.telDetChs # Numpy arrays for the calculations self.device_ADC_mean = np.zeros((self.chs, self.ana_events), dtype='float32') self.device_ADC_sigma = np.zeros((self.chs, self.ana_events), dtype='float32') self.device_ADC_is_ped = np.zeros((self.chs, self.ana_events), dtype='?') self.device_ADC_is_hit = np.zeros((self.chs, self.ana_events), dtype='?') self.device_ADC_is_seed = np.zeros((self.chs, self.ana_events), dtype='?') if self.do_cmc: self.device_channels_cm = np.zeros((self.chs, self.ana_events), dtype='?') self.device_cm = np.zeros(self.ana_events, dtype='float32') self.device_ADC_mean_cmc = np.zeros((self.chs, self.ana_events), dtype='float32') self.device_ADC_sigma_cmc = np.zeros((self.chs, self.ana_events), dtype='float32') self.device_is_cm = np.zeros((self.chs, self.ana_events), dtype='?') self.device_is_ped_cmc = np.zeros((self.chs, self.ana_events), dtype='?') self.device_is_hit_cmc = np.zeros((self.chs, self.ana_events), dtype='?') self.device_is_seed_cmc = np.zeros((self.chs, self.ana_events), dtype='?') # Numpy arrays for event based calculations self.adc = np.zeros(self.chs, dtype=self.np_type) self.mean = np.zeros(self.chs, dtype='float32') self.sigma = np.zeros(self.chs, dtype='float32') self.mean_sq = np.zeros(self.chs, dtype='float32') self.elem = np.zeros(self.chs, dtype='uint16') if self.do_cmc: self.cm = np.zeros(1, dtype='float32') self.adc_cmc = np.zeros(self.chs, dtype='float32') self.mean_cmc = np.zeros(self.chs, dtype='float32') self.sigma_cmc = np.zeros(self.chs, dtype='float32') self.mean_sq_cmc = np.zeros(self.chs, dtype='float32') self.elem_cmc = np.zeros(self.chs, dtype='uint16') # channels that are masked for common mode calculation because they are screened or noisy self.is_not_masked = np.ones( self.chs, '?') if self.device.startswith('tel') else np.array([ ch not in set(self.settings.noisy) | set(self.settings.screened) for ch in xrange(self.chs) ], '?') # global variables passed as reference for shared memory ctype vectors global in_adc_array, out_array_m, out_array_s, out_array_is_p, out_array_is_h, out_array_is_s in_adc_array = input_adc_array out_array_m = out_array_mean out_array_s = out_array_sigma out_array_is_h = out_array_is_hit out_array_is_s = out_array_is_seed out_array_is_p = out_array_is_ped self.det_index = det_index if self.do_cmc: global out_array_chs_c, out_array_c, out_array_mean_cm, out_array_sigma_cm, out_array_is_ped_cm, out_array_is_hit_cm, out_array_is_seed_cm out_array_chs_c = out_array_chs_cm out_array_c = out_array_cm out_array_mean_cm = out_array_mean_cmc out_array_sigma_cm = out_array_sigma_cmc out_array_is_ped_cm = out_array_is_ped_cmc out_array_is_hit_cm = out_array_is_hit_cmc out_array_is_seed_cm = out_array_is_seed_cmc if self.device.startswith('tel'): self.device_ADC_all = np.ctypeslib.as_array( in_adc_array.get_obj())[self.det_index] else: self.device_ADC_all = np.ctypeslib.as_array(in_adc_array.get_obj())