def test_display_select_setting_name_modify_attributes_should_update_attribute_for_level(self): sudoku_menu = Menu() sudoku_setting = Settings() old_value = sudoku_setting.get_attribute_value_for_setting("Level", "Easy","max") sudoku_menu.display_select_setting_name_to_modify_attributes("Level") new_value = sudoku_setting.get_attribute_value_for_setting("Level", "Easy","max") self.assertEqual(old_value, new_value)
def _getThemeFiles(self, directory, extensionOnly=False): # First read from the NFO file if it exists nfoRead = NfoReader(directory, self.debug_logging_enabled) themeFiles = nfoRead.getThemeFiles() # Get the theme directories that are referenced and process the data in them for nfoDir in nfoRead.getThemeDirs(): # Do not want the theme keyword if looking at an entire directory themeFiles = themeFiles + self._getThemeFiles(nfoDir, True) del nfoRead log("ThemeFiles: Searching %s for %s" % (directory, Settings.getThemeFileRegEx(directory, extensionOnly, self.audioOnly)), self.debug_logging_enabled) # check if the directory exists before searching if dir_exists(directory): dirs, files = list_dir(directory) for aFile in files: m = re.search(Settings.getThemeFileRegEx(directory, extensionOnly, self.audioOnly), aFile, re.IGNORECASE) if m: path = os_path_join(directory, aFile) log("ThemeFiles: Found match: %s" % path, self.debug_logging_enabled) # Add the theme file to the list themeFiles.append(path) return themeFiles
def test_basic(self): wSetting = Settings() wSetting['test0'] = 'hello' wSetting['test1'] = 10 wSetting['test2'] = [0, 2, 3] self.assertEqual(wSetting.get('test3', 3), 3) self.assertEqual(wSetting.save(), True)
def __init__(self,): self._running = False self._lock = None settings = Settings() self.logger = logger.Logger( debug=settings.get('WebDav', 'debug'))
def show(self): log("SonosArtistSlideshow: About to show window") # First show the window SonosControllerWindow.show(self) # Work out how many lines there are on the screen to show lyrics if Settings.isLyricsInfoLayout(): lyricControl = self.getControl(SonosArtistSlideshow.LYRICS) if lyricControl is not None: listitem = xbmcgui.ListItem() while xbmc.getInfoLabel('Container(%s).NumPages' % SonosArtistSlideshow.LYRICS) != '2': lyricControl.addItem(listitem) xbmc.sleep(10) self.lyricListLinesCount = lyricControl.size() - 1 lyricControl.reset() self.windowId = xbmcgui.getCurrentWindowId() log("SonosArtistSlideshow: After show window %s" % self.windowId) # Set the sonos icon if not Settings.hideSonosLogo(): xbmcgui.Window(self.windowId).setProperty('SonosAddonIcon', __icon__) # Set option to make the artist slideshow full screen if Settings.fullScreenArtistSlideshow(): xbmcgui.Window(self.windowId).setProperty('SonosAddonSlideshowFullscreen', "true") # Now make sure that Artist Slideshow is running self.athread = threading.Thread(target=self.runArtistSlideshow) self.athread.setDaemon(True) self.athread.start() log("SonosArtistSlideshow: ArtistSlideShow thread started")
def test_settings_load(self): self.assertFalse(os.path.exists(self.test_settings_path)) s = Settings() for key, value in s.default_settings.items(): self.assert_(s[key] == value) self.assert_(s.get(key) == value) self.assert_(os.path.exists(s.settings_path))
def check_rpmlint_errors(out, log): """ Check the rpmlint output, return(ok, errmsg) If ok, output is OK and there is 0 warnings/errors If not ok, and errmsg!= None there is system errors, reflected in errmsg. If not ok and msg == None parsing is ok but there are warnings/errors""" problems = re.compile('(\d+)\serrors\,\s(\d+)\swarnings') lines = out.split('\n')[:-1] err_lines = filter( lambda l: l.lower().find('error') != -1, lines) if len(err_lines) == 0: Settings.get_logger().debug('Cannot parse rpmlint output: ' + out) return False, 'Cannot parse rpmlint output:' res = problems.search(err_lines[-1]) if res and len(res.groups()) == 2: errors, warnings = res.groups() if errors == '0' and warnings == '0': return True, None else: return False, None else: log.debug('Cannot parse rpmlint output: ' + out ) return False, 'Cannot parse rpmlint output:'
def _generateThemeFilelist(self, rawPath): # Get the full path with any network alterations workingPath = self._getUsablePath(rawPath) themeList = self._getThemeFiles(workingPath) # If no themes have been found if len(themeList) < 1: # TV shows stored as ripped disc folders if ('VIDEO_TS' in workingPath) or ('BDMV' in workingPath): log("ThemeFiles: Found VIDEO_TS or BDMV in path: Correcting the path for DVDR tv shows", self.debug_logging_enabled) workingPath = os_path_split(workingPath)[0] themeList = self._getThemeFiles(workingPath) if len(themeList) < 1: workingPath = os_path_split(workingPath)[0] themeList = self._getThemeFiles(workingPath) else: # If no theme files were found in this path, look at the parent directory workingPath = os_path_split(workingPath)[0] # Check for the case where there is the theme forlder settings, we want to # check the parent folders themes directory if Settings.isThemeDirEnabled(): themeDir = os_path_join(workingPath, Settings.getThemeDirectory()) themeList = self._getThemeFiles(themeDir) # If there are still no themes, just check the parent directory if len(themeList) < 1: themeList = self._getThemeFiles(workingPath) log("ThemeFiles: Playlist size = %d" % len(themeList), self.debug_logging_enabled) log("ThemeFiles: Working Path = %s" % workingPath, self.debug_logging_enabled) return themeList
def check(self): # If we have found the correct user, then we need to ensure we are # in the valid time duration and have not exceeded the limit if not self.isEnabled: return True # Check for the case where we didn't get the user ID - this means we are # already shutting down if self.userId in [None, ""]: return False log("UserPinControl: Performing check for user %s" % self.userId) # First check that the current time is within the allowed boundaries localTime = time.localtime() currentTime = (localTime.tm_hour * 60) + localTime.tm_min if self.allowedStartTime > currentTime or self.allowedEndTime < currentTime: log("UserPinControl: User not allowed access until %d to %d currently %d" % (self.allowedStartTime, self.allowedEndTime, currentTime)) self.shutdown(32130) return False # Check if the screensaver is running, if so we need to make sure we do not # class that as time used by the user if xbmc.getCondVisibility("System.ScreenSaverActive"): if self.screensaverStart < 1: self.screensaverStart = currentTime else: # Not the screensaver, check to see if this is the first check # after the screensaver stopped if self.screensaverStart > 0: screensaverDuration = currentTime - self.screensaverStart self.screensaverStart = 0 log("UserPinControl: Updating duration for screensaver, %d minutes" % screensaverDuration) # Now we roll the time forward that we started viewing so that # we are not counting the screensaver self.startedViewing = self.startedViewing + screensaverDuration # Check to see if we need to update the record for how long the user has already been viewing viewingLimit = Settings.getUserViewingLimit(self.userId) self.usedViewingLimit = currentTime - self.startedViewing log("UserPinControl: Time used by user is %d" % self.usedViewingLimit) # Update the settings record for how much this user has viewed so far Settings.setUserViewingUsedTime(self.userId, self.usedViewingLimit) # Now check to see if the user has exceeded their limit if self.usedViewingLimit >= viewingLimit: self.shutdown(32133) return False # Check if we need to warn the user that the time is running out warningTime = Settings.getWarnExpiringTime() if (not self.warningDisplayed) and ((self.usedViewingLimit + warningTime) >= viewingLimit): self.warningDisplayed = True # Calculate the time left remainingTime = viewingLimit - self.usedViewingLimit msg = "%d %s" % (remainingTime, __addon__.getLocalizedString(32134)) xbmcgui.Dialog().notification(__addon__.getLocalizedString(32001).encode('utf-8'), msg, __icon__, 3000, False) return True
def setUserPin(pinId): # Prompt the user for the pin numberpad = NumberPad.createNumberPad(32106) numberpad.doModal() # Get the code that the user entered enteredPin = numberpad.getPin() del numberpad # Check to ensure the user has either set no password or one the correct length if (len(enteredPin) > 0) and (Settings.getPinLength() > len(enteredPin)): log("SetPin: Incorrect length pin entered, expecting %d digits" % Settings.getPinLength()) xbmcgui.Dialog().ok(__addon__.getLocalizedString(32001).encode('utf-8'), __addon__.getLocalizedString(32109).encode('utf-8')) elif Settings.checkUserPinClash(enteredPin, pinId): # This pin clashes with an existing pin log("SetPin: Entered pin clashes with an existing pin") xbmcgui.Dialog().ok(__addon__.getLocalizedString(32001).encode('utf-8'), __addon__.getLocalizedString(32112).encode('utf-8')) else: # Now double check the value the user entered numberpad = NumberPad.createNumberPad(32107) numberpad.doModal() # Get the code that the user entered enteredPin2 = numberpad.getPin() del numberpad if enteredPin == enteredPin2: Settings.setUserPinValue(enteredPin, pinId) else: log("SetPin: Pin entry different, first: %s, second %s" % (enteredPin, enteredPin2)) xbmcgui.Dialog().ok(__addon__.getLocalizedString(32001).encode('utf-8'), __addon__.getLocalizedString(32108).encode('utf-8'))
def listpaths(pkg_filename): ''' Return lists of files and dirs in local pkg. ''' cmd = ['rpm', '-ql', '--dump', '-p', pkg_filename] Settings.get_logger().debug("Running: " + ' '.join(cmd)) try: rpm = subprocess.Popen(cmd, stdout=subprocess.PIPE) except OSError: Settings.get_logger().warning("Cannot run " + " ".join(cmd)) return [] files = [] dirs = [] while True: try: line = rpm.stdout.next().strip() except StopIteration: return dirs, files try: path, mode = line.rsplit(None, 10)[0:5:4] except ValueError: # E. g., when given '(contains no files)' continue mode = int(mode, 8) if mode & 040000: dirs.append(path) else: files.append(path)
def _do_report(self, outfile=None): ''' Create a review report''' clock = time.time() self.log.info('Getting .spec and .srpm Urls from : ' + self.bug.get_location()) Settings.dump() if not self.bug.find_urls(): raise self.HelperError('Cannot find .spec or .srpm URL(s)') self.log.debug("find_urls completed: %.3f" % (time.time() - clock)) clock = time.time() if not ReviewDirs.is_inited: wd = self.bug.get_dirname() ReviewDirs.workdir_setup(wd) if Mock.is_available(): Mock.init() if not self.bug.download_files(): raise self.HelperError('Cannot download .spec and .srpm') self.log.debug("Url download completed: %.3f" % (time.time() - clock)) Settings.name = self.bug.get_name() self._run_checks(self.bug.spec_file, self.bug.srpm_file, outfile)
def main(): #Set this to true if you want to create a personal database testdatabase = False #Set this due to how large you want your testdatabase count = 10 #creating a settings to be used with run cuts = environment.generateCuts() settings = Settings(cuts) environment.setSettings(settings) settings.setMethod("expanded") globalSettings = GlobalSettings() environment.setGlobalSettings(globalSettings) db = Database(globalSettings) #making a testdatabase if the varible is set if testdatabase == True: currentDBCount= m.Painting.select().count() count = count - currentDBCount if count > 0: db.setCount(count) db.constructDatabase() else: db.constructDatabase() run = m.createNewRun(settings) paintings = m.Painting.select(m.Painting.q.form=="painting") for painting in paintings: if os.path.isfile(painting.filepath): try: paintingContainer = Painting(painting) print "working on" print painting.filepath paintingContainer.setResults(paintingAnalyzer.analyze(paintingContainer,settings)) m.saveResults(run.id,paintingContainer) except: pass
def updateVideoRefreshRate(self, themePlayList): # Check if the setting is enabled to switch the refresh rate if not Settings.blockRefreshRateChange(): self.original_refreshrate = 0 return log("ThemePlayer: Checking for update of refresh rate") try: # Check if we have any videos in the PlayList hasVideoFiles = True i = 0 while i < themePlayList.size(): if Settings.isVideoFile(themePlayList[i].getfilename()): hasVideoFiles = True break i = i + 1 if hasVideoFiles: # Save off the existing refresh setting jsonresponse = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Settings.GetSettingValue", "params": { "setting": "videoplayer.adjustrefreshrate" }, "id": 1}') data = simplejson.loads(jsonresponse) if 'result' in data: if 'value' in data['result']: self.original_refreshrate = data['result']['value'] # Check if the refresh rate is currently set log("ThemePlayer: Video refresh rate currently set to %d" % self.original_refreshrate) # Check if the refresh rate is currently set, if it is, then we need if self.original_refreshrate != 0: # Disable the refresh rate setting log("ThemePlayer: Disabling refresh rate") xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Settings.SetSettingValue", "params": { "setting": "videoplayer.adjustrefreshrate", "value": 0 }, "id": 1}') except: log("ThemePlayer: Failed to process video refresh")
def _do_run(self, outfile=None): ''' Initiate, download url:s, run checks a write report. ''' Settings.init() make_report = True if Settings.list_checks: self._list_checks() make_report = False elif Settings.list_flags: self._list_flags() make_report = False elif Settings.version: self._print_version() make_report = False elif Settings.list_plugins: self._list_plugins() make_report = False elif Settings.url: self.log.info("Processing bug on url: " + Settings.url) self.bug = UrlBug(Settings.url) elif Settings.bug: self.log.info("Processing bugzilla bug: " + Settings.bug) self.bug = BugzillaBug(Settings.bug) elif Settings.name: self.log.info("Processing local files: " + Settings.name) self.bug = NameBug(Settings.name) if make_report: if not Mock.is_available() and not Settings.prebuilt: raise ReviewError("Mock unavailable, --prebuilt must be used.") self._do_report(outfile)
def convert(self): if self.enabled(): settings = Settings(self.context) settings.last_updated = DateTime('1999/01/01').ISO8601() queue_job(self.context) self.request.response.redirect(self.context.absolute_url() + '/view')
def convert_all(self): confirm = self.request.get('confirm', 'no') if confirm != 'yes': return 'You must append "?confirm=yes"' else: ptool = getToolByName(object, 'portal_properties') site_props = getattr(ptool, 'site_properties', None) auto_layout = site_props.getProperty( 'page_turner_auto_select_layout', False) catalog = getToolByName(self.context, 'portal_catalog') files = catalog(object_provides=IFileContent.__identifier__) for brain in files: file = brain.getObject() if file.getContentType() not in ('application/pdf', 'application/x-pdf', 'image/pdf'): continue if auto_layout and file.getLayout() != 'page-turner': file.setLayout('page-turner') self.request.response.write( 'Converting %s to flex paper...\n' % file.absolute_url()) settings = Settings(file) settings.last_updated = DateTime('1999/01/01').ISO8601() queue_job(file)
def get_vk(): settings = Settings() users = settings.getUsers() selected_user = UserPrompt().prompt_user("Select user:", users) settings.setUser(selected_user) vk = vkutils.VK(settings) return vk
def _updatePlaylistForSettings(self, playlist): if playlist.size() < 1: return playlist filename = playlist[0].getfilename() duration = self._getVideoDuration(filename) log("Duration is %d for file %s" % (duration, filename)) startTime = 0 # Check if we have a random start time if Settings.isRandomStart(): startTime = random.randint(0, int(duration * 0.75)) clockStart = Settings.getTimeForClock(filename, duration) if clockStart > 0: startTime = clockStart # Set the random start if (startTime > 0) and (duration > 10): listitem = xbmcgui.ListItem() # Record if the theme should start playing part-way through listitem.setProperty('StartOffset', str(startTime)) log("Setting start of %d for %s" % (startTime, filename)) # Remove the old item from the playlist playlist.remove(filename) # Add the new item at the start of the list playlist.add(filename, listitem, 0) return playlist
def __init__(self, **args): """Create the default settings.""" Settings.__init__(self, 'StyleSheet', setnsmode='stylesheet', **args) self.pixmap = 'settings_stylesheet' for subset in self.registeredsettings: self.add( subset() )
class Context(object): def __init__(self, root_dir): self.bus = Bus() self.settings = Settings(root_dir=root_dir) def load_settings(self, config_path): self.settings.load(config_path)
def __init__(self, rawPath, pathList=None, videotitle=None, debug_logging_enabled=True, audioOnly=False): self.debug_logging_enabled = debug_logging_enabled self.forceShuffle = False self.doNotShuffle = False self.audioOnly = audioOnly self.rawPath = rawPath if rawPath in [None, ""]: self.clear() else: # Check for the case where there is a custom path set so we need to use # the custom location rather than the rawPath if Settings.isCustomPathEnabled() and (videotitle not in [None, ""]): customRoot = Settings.getCustomPath() # Make sure that the path passed in has not already been converted if customRoot not in self.rawPath: self.rawPath = os_path_join(customRoot, normalize_string(videotitle)) log("ThemeFiles: Setting custom path to %s" % self.rawPath, self.debug_logging_enabled) if (pathList is not None) and (len(pathList) > 0): self.themeFiles = [] for aPath in pathList: subThemeList = self._generateThemeFilelistWithDirs(aPath) # add these files to the existing list self.themeFiles = self._mergeThemeLists(self.themeFiles, subThemeList) # If we were given a list, then we should shuffle the themes # as we don't always want the first path playing first self.forceShuffle = True else: self.themeFiles = self._generateThemeFilelistWithDirs(self.rawPath) # Check if we need to handle the ordering for video themes if not audioOnly: self.doNotShuffle = self._filterForVideoThemesRule() self.forceShuffle = False
def get_db(): config = Settings() return pymysql.connect(host=config.setting("dbhost"), user=config.setting("dbuser"), passwd=config.setting("dbpassword"), db=config.setting("dbbase"), charset="utf8")
class InfoDialog(QDialog, Ui_Info): def __init__(self): QDialog.__init__(self) self.setupUi(self) self.settings = Settings() self.permit_close = False self.ok.clicked.connect(self.accepted) self.wait = 10 self.stimer = QTimer self.ok.setText(unicode(self.wait)) self.stimer.singleShot(1000, self.updateTimer) def updateTimer(self): self.wait -= 1 self.ok.setText(unicode(self.wait)) if self.wait > 0: self.stimer.singleShot(1000, self.updateTimer) else: self.ok.setEnabled(True) self.ok.setText("OK") def accepted(self): if self.understood.isChecked(): self.permit_close = True self.settings.setValue('info_accepted', True) self.close() def closeEvent(self, evnt): if self.permit_close: super(InfoDialog, self).closeEvent(evnt) else: evnt.ignore()
class MapFrame(wx.Frame): def __init__(self, parent, id=wx.ID_ANY, title="", pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE, name="MapFrame"): super(MapFrame, self).__init__(parent, id, title, pos, (MAX_COL*CELL_X, MAX_ROW*CELL_Y+20), style, name) self.SetIcon(wx.Icon("img/icon.png", wx.BITMAP_TYPE_PNG)) self.settings = Settings() global board, colors, player, tiled board = self.settings.load_map('config/map1.txt') colors = self.settings.load_colors() tiled = Tiled() player = Player() self.panel = MapPanel(self) self.InitUI() #~ ag = wx.animate.GIFAnimationCtrl(self.panel, -1, self.player.src, #~ pos=(10, 10)) #~ ag.GetPlayer().UseBackgroundColour(True) #~ ag.Play() self.Centre() self.Show(True) def InitUI(self): menubar = wx.MenuBar() fileMenu = wx.Menu() menubar.Append(fileMenu, '&File') self.SetMenuBar(menubar)
class StatusBar(): def __init__(self, window): self.window = window self.settings = Settings() def update(self): if ProcessCache.empty(): return self.erase() status_bar_tasks = self.settings.get('status_bar_tasks', False) if status_bar_tasks: task_names = set([process.get_task_name() for process in ProcessCache.get()]) if status_bar_tasks != True: if not isinstance(status_bar_tasks, list): status_bar_tasks = [status_bar_tasks] task_names = task_names.intersection(set(status_bar_tasks)) if task_names: defer_sync(lambda: self.set(', '.join(task_names))) def set(self, text): text_format = self.settings.get('status_bar_format', '{task_name}') status = text_format.format(task_name=text) self.window.active_view().set_status(Settings.PACKAGE_NAME, status) def erase(self): self.window.active_view().erase_status(Settings.PACKAGE_NAME)
def checkEnding(self): if self.isPlayingAudio() and (self.startTime > 0): # Get the current time currTime = int(time.time()) # Time in minutes to play for durationLimit = Settings.getPlayDurationLimit() if durationLimit > 0: expectedEndTime = self.startTime + (60 * durationLimit) if currTime > expectedEndTime: self.endPlaying(slowFade=True) return # Check for the case where only a given amount of time of the track will be played # Only skip forward if there is a track left to play - otherwise just keep # playing the last track if (self.playlistSize > 1) and (self.remainingTracks != 0): trackLimit = Settings.getTrackLengthLimit() if trackLimit > 0: if currTime > self.trackEndTime: log("Player: Skipping to next track after %s" % self.getPlayingFile()) self.playnext() if self.remainingTracks != -1: self.remainingTracks = self.remainingTracks - 1 self._setNextSkipTrackTime(currTime)
def _moveToThemeFolder(self, directory): log("moveToThemeFolder: path = %s" % directory) # Handle the case where we have a disk image if (os_path_split(directory)[1] == 'VIDEO_TS') or (os_path_split(directory)[1] == 'BDMV'): directory = os_path_split(directory)[0] dirs, files = list_dir(directory) for aFile in files: m = re.search(Settings.getThemeFileRegEx(directory), aFile, re.IGNORECASE) if m: srcpath = os_path_join(directory, aFile) log("fetchAllMissingThemes: Found match: %s" % srcpath) targetpath = os_path_join(directory, Settings.getThemeDirectory()) # Make sure the theme directory exists if not dir_exists(targetpath): try: xbmcvfs.mkdir(targetpath) except: log("fetchAllMissingThemes: Failed to create directory: %s" % targetpath, True, xbmc.LOGERROR) break else: log("moveToThemeFolder: directory already exists %s" % targetpath) # Add the filename to the path targetpath = os_path_join(targetpath, aFile) if not xbmcvfs.rename(srcpath, targetpath): log("moveToThemeFolder: Failed to move file from %s to %s" % (srcpath, targetpath))
def _doesThemeExist(self, directory): log("doesThemeExist: Checking directory: %s" % directory) # Check for custom theme directory if Settings.isThemeDirEnabled(): themeDir = os_path_join(directory, Settings.getThemeDirectory()) # Check if this directory exists if not dir_exists(themeDir): workingPath = directory # If the path currently ends in the directory separator # then we need to clear an extra one if (workingPath[-1] == os.sep) or (workingPath[-1] == os.altsep): workingPath = workingPath[:-1] # If not check to see if we have a DVD VOB if (os_path_split(workingPath)[1] == 'VIDEO_TS') or (os_path_split(workingPath)[1] == 'BDMV'): # Check the parent of the DVD Dir themeDir = os_path_split(workingPath)[0] themeDir = os_path_join(themeDir, Settings.getThemeDirectory()) directory = themeDir # check if the directory exists before searching if dir_exists(directory): # Generate the regex themeFileRegEx = Settings.getThemeFileRegEx(audioOnly=True) dirs, files = list_dir(directory) for aFile in files: m = re.search(themeFileRegEx, aFile, re.IGNORECASE) if m: log("doesThemeExist: Found match: " + aFile) return True return False
def main(): global screen print("Nerd Tabu") # Parse command line parser = argparse.ArgumentParser() parser.add_argument('quizfile', type=argparse.FileType('r'), help='Name of the quiz file') parser.add_argument('teamA', nargs='?', metavar='teamname_A', default='Team A', help='Name of team A') parser.add_argument('teamB', nargs='?', metavar='teamname_B', default='Team B', help='Name of team B') parser.add_argument('-d', '--datadir', default='.', help='Resource directory') parser.add_argument('-f', '--fullscreen', help='Run fullscreen', action='store_true') args = parser.parse_args() # Update settings settings = Settings(args.quizfile, args.datadir) settings.teams = [ args.teamA, args.teamB ] theme = Theme(args.datadir) # Initial game data cards = settings.get_random_cards() current_team = 0 # Main game loop pygame.init() if args.fullscreen: # screen = pygame.display.set_mode(theme.screen_size, pygame.FULLSCREEN) screen = pygame.display.set_mode(theme.screen_size, pygame.RESIZABLE | pygame.NOFRAME) else: screen = pygame.display.set_mode(theme.screen_size) theme.load_data() while len(cards)>0: team_get_ready(theme, settings, current_team) play_round(theme, settings, current_team, cards) current_team = (current_team + 1) % len(settings.teams) show_final_scores(theme, settings) pygame.quit()
import sys from timeit import default_timer as timer import subprocess # Hack to make this Python program executable from the utils subdirectory basepath, _ = os.path.split(os.path.realpath(__file__)) _UTILS = os.sep + "utils" if basepath.endswith(_UTILS): basepath = basepath[0:-len(_UTILS)] sys.path.append(basepath) from settings import Settings from db import SessionContext from treeutil import TreeUtility as tu Settings.read(os.path.join(basepath, "config", "Greynir.conf")) Settings.DEBUG = False TEXTI = 'þróunarsafn_texti.txt' SBR = 'þróunarsafn.txt' SKIPUN = './EVALB/evalb -p ./stillingar.prm' # Þróunarsafnið kemur fyrst, svo þáttun til að prófa class Comparison(): def start(self): # Sækja setningar úr þróunarmálheild print("Sæki setningar...\n") setningar = self.fá_setningar() print("Komið! Sæki þáttun... \n") # Fá þáttun frá Greyni á svigaformi sem búið er að hreinsa þáttun = self.fá_þáttun( setningar
import tensorflow as tf import numpy as np import cv2 import os import sys import time import matplotlib.pyplot as plt sys.path.append('./') import data_loader from settings import Settings CONFIG = Settings(required_args=["gpu", "config", "checkpoint"]) # Computes softmax def softmax(x): e_x = np.exp(x) return e_x / np.expand_dims(np.sum(e_x, axis=2), axis=2) # Erase line in stdout def erase_line(): sys.stdout.write("\033[F") # Compute scores for a single image def compute_iou_per_class(pred, label, mask, n_class): pred = np.argmax(pred[..., 0:n_class], axis=2) * mask
class MainWindow(QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.classic_settings = Settings() self.bfa_settings = Settings() with open('settings.txt', 'r', encoding='utf-8') as file: settings = json.loads(file.read()) if 'classic' in settings: self.classic_settings.__dict__ = settings['classic'] if 'bfa' in settings: self.bfa_settings.__dict__ = settings['bfa'] self.classic_settings_window = SettingsWindow(self.classic_settings) self.bfa_settings_window = SettingsWindow(self.bfa_settings) self.init_widgets() self.dispatcher = Dispatcher(self.classic_settings, self.bfa_settings) self.dispatcher.start() # it is paused now and ready to start def init_widgets(self): # Init settings windows open_classic_settings = QAction('Classic', self) open_bfa_settings = QAction('BFA', self) open_classic_settings.triggered.connect(self.open_classic_settings) open_bfa_settings.triggered.connect(self.open_bfa_settings) self.menuBar().addAction(open_classic_settings) self.menuBar().addAction(open_bfa_settings) self.open_classic_settings() # Init buttons self.toolbar = QToolBar() self.toolbar.setStyleSheet(''' font-family: Serif; font-size: 16px; font-weight: bold; ''') self.start_button = QAction('Start', self) self.start_button.triggered.connect(self.start_button_clicked) self.toolbar.addAction(self.start_button) self.update_from_excel_button = QAction('Add/Update from xls', self) self.update_from_excel_button.triggered.connect( self.update_from_excel_button_clicked) self.toolbar.addAction(self.update_from_excel_button) self.scan_now = QAction('Scan now', self) self.scan_now.triggered.connect(self.scan_now_clicked) self.toolbar.addAction(self.scan_now) self.activate_orders = QAction('Activate all orders', self) self.activate_orders.triggered.connect(self.activate_orders_clicked) self.toolbar.addAction(self.activate_orders) self.deactivate_orders = QAction('Deactivate all orders', self) self.deactivate_orders.triggered.connect( self.deactivate_orders_clicked) self.toolbar.addAction(self.deactivate_orders) self.set_delivery_time = QAction('Set delivery', self) self.set_delivery_time.triggered.connect(self.change_order_time) self.toolbar.addAction(self.set_delivery_time) self.save_settings_button = QAction('Save settings', self) self.save_settings_button.setToolTip( 'Save settings to use in the next run') self.save_settings_button.triggered.connect( self.save_settings_button_clicked) self.toolbar.addAction(self.save_settings_button) self.addToolBar(self.toolbar) self.setGeometry(200, 200, 900, 500) self.show() def start_button_clicked(self): if self.start_button.text() == 'Start': self.dispatcher.classic_settings = self.classic_settings self.dispatcher.bfa_settings = self.bfa_settings self.dispatcher.unpause() self.start_button.setText('Stop') else: self.dispatcher.pause() self.start_button.setText('Start') def update_from_excel_button_clicked(self): try: fd = QFileDialog.getOpenFileName(self, "Choose xls file", os.getcwd())[0] was_paused = self.dispatcher.paused self.dispatcher.pause() while not self.dispatcher.pause_accepted: time.sleep(0.5) self.dispatcher.add_orders_from_excel(fd) self.dispatcher.paused = was_paused except: QMessageBox.warning(self, 'Error', str(sys.exc_info()[0])) def scan_now_clicked(self): self.dispatcher.classic_last_update = 0 self.dispatcher.bfa_last_update = 0 def activate_orders_clicked(self): was_paused = self.dispatcher.paused self.dispatcher.pause() while not self.dispatcher.pause_accepted: time.sleep(1) self.dispatcher.activate_all_orders() self.dispatcher.paused = was_paused def deactivate_orders_clicked(self): was_paused = self.dispatcher.paused self.dispatcher.pause() while not self.dispatcher.pause_accepted: time.sleep(1) self.dispatcher.deactivate_all_orders() self.dispatcher.paused = was_paused def change_order_time(self): was_paused = self.dispatcher.paused self.dispatcher.pause() while not self.dispatcher.pause_accepted: time.sleep(1) orders = self.dispatcher.bot.active_orders('eu', active_status=False) + \ self.dispatcher.bot.active_orders('us', active_status=False) for order in orders: hrs = self.classic_settings.delivery_time if 'classic' in order.server.lower( ) else self.bfa_settings.delivery_time order.online_hrs = hrs self.dispatcher.bot.change_order(order) self.dispatcher.paused = was_paused def save_settings_button_clicked(self): self.classic_settings.save('classic') self.bfa_settings.save('bfa') def open_classic_settings(self): self.setWindowTitle('Classic settings') self.takeCentralWidget() self.setCentralWidget(self.classic_settings_window) def open_bfa_settings(self): self.setWindowTitle('BFA settings') self.takeCentralWidget() self.setCentralWidget(self.bfa_settings_window)
def draw(self, gc): size = self.client_size imgw = self.rawImgW imgh = self.rawImgH aspectRatio = imgw / imgh topMargin = 0 # Resize it, but keep the aspect ratio. Add 'margins' to ensure. height = size.height width = min(size.width, round(height * aspectRatio)) if width == size.width: height = round(width / aspectRatio) topMargin = round((size.height - height) / 2) leftMargin = round((size.width) - width) / 2 gc.DrawBitmap(self.bm, leftMargin, topMargin, width, height) refWidth = 314 refWidthContentSize = 10 multiplicator = width / refWidth if not self.connected: # Darken background and tell user what to do to connect. brush = wx.Brush(wx.Colour(0, 0, 0, 0xff * 0.8), wx.BRUSHSTYLE_SOLID) gc.SetBrush(brush) gc.DrawRectangle(leftMargin, topMargin, width, height) font = gc.CreateFont( wx.Font(refWidthContentSize * multiplicator, wx.SWISS, wx.NORMAL, wx.BOLD), wx.Colour(255, 255, 255)) gc.SetFont(font) text = "Not connected to Forza Horizon 4.\n\nPlease enter the following details at\nHome > Settings > Hud in the game:\n\nIP Address: " + ( str)(Settings.getLocalIp()) + "\nPort: " + (str)( Settings.getPort()) textSize = gc.GetTextExtent(text) textX = leftMargin + (width / 2) - (textSize[0] / 2) textY = topMargin + (height / 2) - (textSize[1] / 2) gc.DrawText(text, textX, textY) else: xp, yp = Settings.getPixelPos(self.x, self.z) # We know got the pixel location. But this is according to the source image, not to the current size which is displayed. # Calibration was very hard. This was supposed to be calculated against the image size, but I had to manually adjust them. Nothing to worry, just leave it like that. xp *= (width / 1461) yp *= (height / 1417) # Also consider the margin, if it has any. xp += leftMargin yp += topMargin refcw = 10 cw = refcw * multiplicator # draw a secondary circle that lights up the area, to make the users eye catch the position more early scs = cw * 15 brush = wx.Brush(wx.Colour(255, 255, 255, 0xff * 0.15)) gc.SetBrush(brush) gc.DrawEllipse(xp - scs / 2, yp - scs / 2, scs, scs) # draw main position circle brush = wx.Brush(wx.Colour(0, 0, 100, 0xff * 0.4)) gc.SetBrush(brush) pen = wx.Pen(wx.Colour(255, 0, 0), cw / 12) gc.SetPen(pen) gc.DrawEllipse(xp - cw / 2, yp - cw / 2, cw, cw) gc.SetPen(wx.Pen()) # inner dot ids = cw / 10 brush = wx.Brush(wx.Colour(255, 255, 0)) gc.SetBrush(brush) gc.DrawEllipse(xp - ids / 2, yp - ids / 2, ids, ids) # draw a car inside of it, Note: Commented it out. Looks ugly because bitmaps are always placed by full pixel for some reason, only drawables are smooth. # carCs = cw/1.5 # dc.DrawBitmap(self.carBm, xp- carCs/2,yp- carCs/2, carCs, carCs) # draw yaw angle graphic gc.SetBrush(wx.Brush()) gc.SetPen(wx.Pen(wx.Colour(100, 0, 255, 0xff * 0.7), cw / 8)) path = gc.CreatePath() distance = math.pi / 4 yaw = self.yaw - math.pi / 2 # default orientation is incorrect, so fixing it here. path.AddArc(xp, yp, (cw / 2) + cw / 6, yaw - distance, yaw + distance, True) gc.DrawPath(path)
from constants import * from display import Display from fever import Fever from game import Game from menu import GameMenu from settings import Settings # Set up myDisplay = Display() mySettings = Settings() myMenu = GameMenu(myDisplay, mySettings) # myPowerup = PowerUp(myDisplay.surface) myFever = Fever(myDisplay.surface, myDisplay, mySettings) # myPowerup.set_track(myFever.track) myGame = Game(myMenu, myDisplay, myFever, mySettings) running = True # Game loop while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False myGame.run() # Quit the game pygame.quit() quit()
class Game(GameBase, FSM): def __init__(self): GameBase.__init__(self, debug=True) FSM.__init__(self, "GUI FSM") base.disableMouse() self.menu = Menu() self.settings = Settings() self.missionScreen = MissionScreen() self.debrief = Debrief() self.hud = Hud() self.missionSelect = MissionSelect() base.camLens.setFov(90) self.setMusic("audio/music.mp3", volume=0.5) self.setMusic("audio/engine1.wav", volume=0.3) self.request("Menu") base.taskMgr.add(self.missionOverTask, "is mission over") def enterMenu(self): self.menu.show() self.accept("menu-start", self.request, ["MissionSelect"]) self.accept("menu-instructions", self.request, ["Instructions"]) self.accept("menu-quit", sys.exit) self.accept("menu-settings", self.request, ["Settings"]) def exitMenu(self): self.menu.hide() self.ignore("menu-start") self.ignore("menu-instructions") self.ignore("menu-quit") def enterSettings(self): self.settings.show() self.accept("settings-back", self.request, ["Menu"]) def exitSettings(self): self.settings.hide() self.ignore("settings-back") def enterMissionSelect(self): self.missionSelect.show() self.accept("missionselect-m1", self.setMission, ["m1"]) self.accept("missionselect-m2", self.setMission, ["m2"]) self.accept("missionselect-test", self.setMission, ["test"]) def exitMissionSelect(self): self.missionSelect.hide() self.ignore("missionselect-m1") self.ignore("missionselect-m2") def enterMissionScreen(self): self.missionScreen.showWithTitle(self.currentMission.objective) self.accept("mission-start", self.request, ["Game"]) def exitMissionScreen(self): self.missionScreen.hide() self.ignore("mission-start") def enterGame(self): self.world = World(self.currentMission.mapName) self.startTime = "Not yet set - not loaded" #set in self.missionOverTask self.player = Player(self.world) self.accept("player-into-Collision", self.player.reset) self.accept("game-quit", self.request, ["Menu"]) self.accept("game-finished", self.request, ["Debrief"]) def exitGame(self): self.world.destroy() self.player.model.removeNode() del self.player base.taskMgr.remove("hud update") self.hud.timer.setText("") self.hud.hide() base.taskMgr.remove("update player") self.ignore("game-quit") def enterDebrief(self): self.debrief.show() self.debrief.setTitle(self.currentMission.question, isAnswer=False) self.debrief.setButtons(self.currentMission) self.accept("debrief-correct", self.debrief.setTitle, ["Correct"]) self.accept("debrief-wrong", self.debrief.setTitle, ["Wrong"]) self.accept("debrief-back", self.request, ["Menu"]) self.accept("debrief-restart", self.request, ["Game"]) def exitDebrief(self): self.debrief.hide() self.ignore("debrief-correct") self.ignore("debrief-wrong") self.debrief.initialise( ) #clear all settings on it, ie title and buttons, as they are mission specific def setMission(self, name): self.currentMission = missions[name] self.request("MissionScreen") def missionOverTask(self, task): if self.state == "Game" and self.world.loaded and self.startTime == "Not yet set - not loaded": self.startTime = time.time() self.hud.show() self.hud.initialise(self.currentMission.objective, self.currentMission.timeAllowed) base.taskMgr.add(self.hud.hudTask, "hud update") if self.state == "Game" and self.world.loaded: if time.time() - self.startTime > self.currentMission.timeAllowed: self.request("Debrief") return task.cont
def run_game(): # Initialize game and create a screen object pygame.init() si_settings = Settings() screen = pygame.display.set_mode((si_settings.screen_width, si_settings.screen_height)) pygame.display.set_caption("Space Invaders") # Make the Menu and the Play Game and High Scores buttons. menu = Menu(si_settings, screen) play_button = Button(si_settings, screen, "PLAY GAME", (si_settings.screen_width * 2.75) / 7, (si_settings.screen_height * 5.25) / 7) high_scores_button = Button(si_settings, screen, "HIGH SCORES", (si_settings.screen_width * 2.65) / 7, (si_settings.screen_height * 6) / 7) # Create an instance to store game statistics and create a scoreboard. stats = GameStats(si_settings) sb = Scoreboard(si_settings, screen, stats) # Make a ship, a group of bullets, and a group of aliens ship = Ship(si_settings, screen) bullets = Group() alienBullets = Group() aliens = Group() images = ["images/alien1.png", "images/alien2.png", "images/alien3.png"] random = randint(0, 10) ufo_random = randint(0, 10) start_ticks = pygame.time.get_ticks() # Create the ufo ufo = None # Create the fleet of aliens. gf.create_fleet(si_settings, screen, ship, aliens, images) # Load the background music # bg_music = pygame.mixer.music("audio/background_music.mp3") # Start the main loop for the game while True: # Watch for keyboard and mouse events. gf.check_events(si_settings, screen, stats, sb, menu, play_button, high_scores_button, ship, aliens, bullets, alienBullets, images) if stats.game_active: seconds = int((pygame.time.get_ticks() - start_ticks) / 1000) if seconds - previous_time == random: gf.fire_back(si_settings, screen, aliens, alienBullets) previous_time = seconds random = randint(5, 10) if seconds - ufo_previous_time == ufo_random: ufo = gf.create_ufo(si_settings) ufo_previous_time = seconds ufo_random = randint(20, 30) print("UFO Random: " + str(ufo_random) + " Seconds: " + str(seconds) + " UFO Previous Time: " + str(ufo_previous_time)) ship.update() gf.update_bullets(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, images) gf.update_aliens(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, images, (seconds - previous_time), ufo) else: previous_time = int(pygame.time.get_ticks() / 1000) ufo_previous_time = int(pygame.time.get_ticks() / 1000) gf.update_screen(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, menu, play_button, high_scores_button)
import firebase_admin from firebase_admin import db from telegram.ext import BasePersistence from ast import literal_eval from collections import defaultdict from typing import Dict from settings import Settings cred = firebase_admin.credentials.Certificate(Settings.fb_creds()) firebase_admin.initialize_app(cred, {"databaseURL": Settings.db_url()}) class FirebasePersistence(BasePersistence): def __new__(cls): if not hasattr(cls, 'instance'): cls.instance = super(FirebasePersistence, cls).__new__(cls) return cls.instance def __init__(self): # cred = firebase_admin.credentials.Certificate(credentials) # self.app = app self.fb_user_data = db.reference("user_data") self.users = db.reference("users") self.purchases = db.reference("ticket_purchases") self.tickets = db.reference("tickets") self.merch_purchases = db.reference("merch_purchases") self.merch = db.reference("merch")
def open_settings(self): """ Obri la finestra dels settings on es canviaràn els temps màxims i mínims del segments i total. """ self.new_window = Settings()
def __init__(self): settings = Settings() self.trainingImageDir = dirname(settings.app_path + "\\nn_training_images\\" self.splitTrainingImageFolderName = 'split_training_images' self.splitTrainingImageDir = self.trainingImageDir + self.splitTrainingImageFolderName + "\\" self.checkAndMakeDir(self.trainingImageDir) self.checkAndMakeDir(self.splitTrainingImageDir) self.minSegmentArea = 600 self.maxSegmentWidth = 0 self.maxSegmentHeight = 0 def checkAndMakeDir(self, directory): if not os.path.exists(directory): os.makedirs(directory) def getImageList(self): #@TODO: store images already converted, and filter them from this list trainingImageNames = os.listdir(self.trainingImageDir) trainingImageNames.remove(self.splitTrainingImageFolderName) return map(lambda trainingImageNames: self.trainingImageDir + trainingImageNames, trainingImageNames) def processImages(self, imageFilePaths, objectColor, threshold): processedImages = [] for i, imageFilePath in zip(range(0, len(imageFilePaths) - 1), imageFilePaths): if i%100 == 0.0: print 'Chopped', i, 'images so far...' processedImages.append(self.processImage(imageFilePath, objectColor, threshold)) return processedImages def processImage(self, imageFilePath, objectColor, threshold): if type(imageFilePath) == list: return self.processImages(imageFilePath, objectColor, threshold) img = cv2.imread(imageFilePath) head, tail = ntpath.split(imageFilePath) value, rand = tail.split('_') res = [0, 0] # @TODO: return original source image resolution imgBig = self.scaleImageToHeight(img, 100) segments = self.segmentImage(imgBig, objectColor, threshold) for val, segment in zip(value, segments): #cv2.imshow('asd', numpy.asarray(segment[0])) #cv2.waitKey(0) #cv2.destroyAllWindows() cv2.imwrite(self.splitTrainingImageDir + val + '_' + rand + '.png', segment[0]) s = segment[0] h = len(s) w = len(s[0]) self.trackMaxSegmentSize(w, h) return [value, res, segments] def trackMaxSegmentSize(self, width, height): if width > self.maxSegmentWidth: self.maxSegmentWidth = width if height > self.maxSegmentHeight: self.maxSegmentHeight = height def segmentImage(self, img, objectColor, threshold): horizontalSlices = [] verticalSlices = self.segmentImageVertical(img, objectColor, threshold) #first we segment vertically for verticalSlice in verticalSlices: if len(verticalSlice): horizontalSlice = self.segmentImageHorizontal(verticalSlice, objectColor, threshold) #then we segment those segments horizontally if len(horizontalSlice): horizontalSlices.append(horizontalSlice) return horizontalSlices def scaleImageToHeight(self, img, newHeight): h = float(img.shape[0]) w = float(img.shape[1]) ratio = (newHeight / h) newWidth = int(round(w * ratio, 0)) return cv2.resize(img, (newWidth, newHeight)) def segmentImageHorizontal(self, img, objectColor, threshold): imgBig = img height = len(imgBig) width = len(imgBig[0]) horizontalBounds = [] topSide = -1 matched = False for y in range(0, height - 1): for x in range(0, width - 1): if self.colorMatch(imgBig[y][x], objectColor, threshold): #we found objectColor matched = True if matched: if topSide < 0: #we don't have a value for the topSide yet, so this must be the first horizontal topSide = max(y - 1, 0) #move one up (if we can) to capture any potential antialiasing we may have missed through threshold else: #we're off objectColor if topSide >= 0: #if we've already found the topSide, then this must be the bottom one horizontalBounds.append([topSide, y]) topSide = -1 matched = False #print 'image dimensions: ' + str(width) + 'x' + str(height), len(imgBig[0][0]) imageSlices = [] for horizontalBound in horizontalBounds: y = horizontalBound[0] h = horizontalBound[1] - y x = 0 w = width if w * h > self.minSegmentArea: #remove pesky commas/periods from the images imageSlices.append(numpy.array(imgBig[y:y + h, x:x + w])) #cv2.rectangle(imgBig, (x, y), (x + w, y + h), (0, 255, 0), 1) return numpy.array(imageSlices) def segmentImageVertical(self, img, objectColor, threshold): imgBig = img height = len(imgBig) width = len(imgBig[0]) verticalBounds = [] leftSide = -1 matched = False for x in range(0, width - 1): for y in range(0, height - 1): if self.colorMatch(imgBig[y][x], objectColor, threshold): #we found objectColor matched = True if matched: if leftSide < 0: #we don't have a value for the left side yet, so this must be the first vertical leftSide = max(x - 1, 0) #move one left (if we can) to capture any potential antialiasing we may have missed through threshold else: #we are off objectColor if leftSide >= 0: #if we've already found the left side, then this must be the right one verticalBounds.append([leftSide, x + 1]) leftSide = -1 matched = False #print 'image dimensions: ' + str(width) + 'x' + str(height), len(imgBig[0][0]) imageSlices = [] for verticalBound in verticalBounds: x = verticalBound[0] w = verticalBound[1] - x y = 0 h = height if w * h > self.minSegmentArea: #remove pesky commas/periods from the images imageSlices.append(numpy.array(imgBig[y:y + h, x:x + w])) #cv2.rectangle(imgBig, (x, y), (x + w, y + h), (0, 255, 0), 1) return imageSlices def colorMatch(self, color1, color2, threshold): dist = 0.0 for c1, c2 in zip(color1, numpy.asarray(color2)): dist += pow((c1 - c2), 2) return pow(dist, 0.5) <= threshold print 'Conversion of images beginning...' train = nnTraining() imgList = train.getImageList() imgPaths = imgList #[0:10] #imgPaths = './nn_training_images/1462_1417536191-38695.png' print 'Found', len(imgPaths), 'images to chop' print 'Chopping...' train.processImage(imgPaths, [0, 0, 0], 350) print 'Chopping completed.' print 'Max digit image dimensions:', train.maxSegmentWidth, train.maxSegmentHeight cv2.waitKey(0)
import os import pdb import sys import matplotlib as M M.use('gtkagg') import matplotlib.pyplot as plt import numpy as N sys.path.append('/home/jrlawson/gitprojects/') from WEM.postWRF import WRFEnviron from settings import Settings import WEM.utils as utils #from WEM.postWRF.postWRF.rucplot import RUCPlot config = Settings() p = WRFEnviron(config) skewT = 0 plot2D = 0 streamlines = 0 rucplot = 0 coldpoolstrength = 0 spaghetti = 0 std = 0 profiles = 0 frontogenesis = 1 upperlevel = 0 # enstype = 'STCH' # enstype = 'ICBC'
attack, counter.subtype.select(hold_expired, counter - 1, 0), hang - 1)) max_hold_new_val = audio.subtype.select( attack, max_hold.subtype.select(hold_expired, max_hold, decay_new_val), attack_new_val) max_hold.d(audio.subtype.select(reset, max_hold_new_val, 0)) #remove extra bits (except one to allow for addition) max_hold = (max_hold >> max_factor).resize(audio_bits) return max_hold if __name__ == "__main__" and "sim" in sys.argv: settings = Settings() settings.agc_frame_size = 100 settings.agc_frames = 4 clk = Clock("clk") data_in = Signed(16).input("data_in") stb_in = Boolean().input("stb_in") magnitude = measure_magnitude(clk, data_in, stb_in, 0, 0) stimulus = [] for i in range(1000): stimulus.append(100) for i in range(20000): stimulus.append(0) response = []
from tkinter import * from tkinter.ttk import Combobox from PIL import Image,ImageTk from password_encrypt import encrypt_pass from tkinter import messagebox from login_data import get_login_information from password_encrypt import check_password from settings import Settings se = Settings() def donoting(): pass class main_page(): def __init__(self, setting, user, data): self.sheet_information = data self.user_info = user self.set = setting self.root2 = Tk() resolution = self.set.main_menu_width +'x'+ self.set.main_menu_length self.root2.geometry(resolution) self.length = len(self.sheet_information) self.root2.title("Үндсэн хуудас") self.root2.resizable(0,0) print(self.user_info) self.menubar = Menu(self.root2) filemenu = Menu(self.menubar, tearoff=0) filemenu.add_command(label="Нууц үг солих", command = self.change_password) if(self.user_info[1] == 'admin'): filemenu.add_command(label="Шинээр эрх үүсгэх", command = self.new_member_create) filemenu.add_separator()
def __init__(self, *args, **kwargs): self.settings = Settings() self.btc_eth_candles = List("BTC_ETH") self.usdt_eth_candles = List("USDT_ETH") self.usdt_btc_candles = List("USDT_BTC")
def __init__(self, main: QMainWindow, settings: Settings): self.main = main if not main.objectName(): main.setObjectName('MainWindow') height = settings.int_value(default_settings.main_height) width = settings.int_value(default_settings.main_width) main.resize(width, height) self.central_widget = QWidget(main) self.vbox_central = QVBoxLayout() self.central_widget.setLayout(self.vbox_central) self.widget = QWidget(self.central_widget) self.vbox_widget = QVBoxLayout() self.widget.setLayout(self.vbox_widget) # Menu Bar # self.menu_bar = QMenuBar() # main.setMenuBar(self.menu_bar) # self.menu_file = self.menu_bar.addMenu('file') # self.action_open = self.menu_file.addAction('open') # Tool Bar self.tool_bar = main.addToolBar('tool bar') icon_open = QIcon(resource_path('images/open-line.png')) icon_setting = QIcon(resource_path('images/settings-line.png')) icon_analyze = QIcon(resource_path('images/cpu-line.png')) icon_export = QIcon(resource_path('images/content-save.png')) self.bt_open_file = QPushButton(icon_open, '', self.widget) self.bt_settings = QPushButton(icon_setting, '', self.widget) self.bt_load_file = QPushButton(icon_analyze, '', self.widget) self.bt_export = QPushButton(icon_export, '', self.widget) self.tool_bar.addWidget(self.bt_open_file) self.tool_bar.addWidget(self.bt_settings) self.tool_bar.addWidget(self.bt_load_file) self.tool_bar.addSeparator() self.tool_bar.addWidget(self.bt_export) # Top Layout self.vbox_top = QVBoxLayout() self.lb_file_path = QLabel(self.widget) self.lb_file_path.setText(main.tr(constant.msg_file_unselected)) self.vbox_top.addWidget(self.lb_file_path) self.vbox_widget.addLayout(self.vbox_top) # Middle Layout self.hbox_middle = QHBoxLayout() self.view = VideoView(main) self.scene = VideoScene(self.view, settings) self.view.setScene(self.scene) self._btg_view = ViewButtonGroup(settings, self.widget) self.hbox_middle.addWidget(self.view) self.view.add_fixed_widget(self._btg_view, Qt.AlignRight | Qt.AlignTop) self.vbox_widget.addLayout(self.hbox_middle) # Bottom Layout self.hbox_bottom = QHBoxLayout() self.lb_frames = QLabel(self.widget) self.sl_frames = QSlider(Qt.Horizontal, self.widget) self.sl_frames.setMinimum(1) self.sl_frames.setMaximum(1) self.sl_frames.setSingleStep(1) self.sl_frames.setPageStep(1) self.lcd_current_frame = QLCDNumber(self.widget) self.lcd_current_frame.setSegmentStyle(QLCDNumber.Flat) self.lcd_current_frame.setDigitCount(9) icon_play = QIcon(resource_path('images/play-circle-outline.png')) self.bt_play = QPushButton(icon_play, '', self.widget) self.le_filter = QLineEdit(self.widget) self.hbox_bottom.addWidget(self.lb_frames) self.hbox_bottom.addWidget(self.sl_frames) self.hbox_bottom.addWidget(self.lcd_current_frame) self.hbox_bottom.addWidget(self.bt_play) self.hbox_bottom.addWidget(self.le_filter) self.vbox_widget.addLayout(self.hbox_bottom) # Status Bar self.status_bar = QStatusBar(main) self.status_progress = QProgressBar(self.status_bar) self.status_progress.setRange(0, 100) self.status_progress.setValue(0) self.status_progress.setFixedWidth(200) self.status_bar.showMessage(main.tr(constant.status_ready)) self.status_bar.addPermanentWidget(self.status_progress) main.setStatusBar(self.status_bar) # Global self.vbox_central.addWidget(self.widget) self.main.setCentralWidget(self.central_widget) self.translate()
def run_game(): pygame.init() ai_settings = Settings() #pygame.display.set_mode返回一个surface对象 screen = pygame.display.set_mode( (ai_settings.screen_width, ai_settings.screen_height)) bullet_sound = pygame.mixer.Sound('sound/bullet.wav') bullet_sound.set_volume(0.3) pygame.mixer.music.load('sound/game_music.wav') pygame.mixer.music.play(-1, 0.0) pygame.mixer.music.set_volume(0.25) enemy1_down_sound = pygame.mixer.Sound("sound/enemy1_down.wav") enemy2_down_sound = pygame.mixer.Sound("sound/enemy2_down.wav") enemy3_down_sound = pygame.mixer.Sound("sound/enemy3_down.wav") game_over_sound = pygame.mixer.Sound('sound/game_over.wav') enemy1_down_sound.set_volume(0.3) enemy2_down_sound.set_volume(0.4) enemy3_down_sound.set_volume(0.5) game_over_sound.set_volume(0.3) shoot_frequency = 0 enemy_frequency = 0 background = pygame.image.load("images\\background_1.png").convert() _game_over = pygame.image.load('images/gameover.png') game_over = pygame.transform.scale(_game_over, (320, 568)) pygame.display.set_caption("plane_war") play_button = Button(ai_settings, screen, "play") stats = GameStats(ai_settings) s = Score(ai_settings, screen, stats) plane = Plane(ai_settings, screen) bullets = Group() framerate = pygame.time.Clock() Heroplane = Mysprite(screen) Heroplane.load("images//hero_plane_1.png", 66, 80, 2) group = pygame.sprite.Group() group.add(Heroplane) enemys = Group() middle = Group() middle_frequency = 0 enemies_down = pygame.sprite.Group() breakplane = Group() middle_down = pygame.sprite.Group() bosses = Group() break_boss = Group() delay = 0 delay_1 = 0 delay_2 = 0 delay_3 = 0 while True: framerate.tick(60) #blit用于在screen上绘制图像 screen.blit(background, (0, 0)) gf.check_events(ai_settings, screen, stats, play_button, plane, enemys, bullets, bullet_sound, s) if stats.game_active and not stats.boss_state: plane.update() middle.update() gf.update_bullets(ai_settings, screen, plane, enemys, bullets, stats, s, shoot_frequency, enemies_down, enemy1_down_sound, middle, middle_down, enemy2_down_sound, bosses, break_boss, enemy3_down_sound) gf.update_enemys(ai_settings, stats, screen, plane, enemys, bullets, s, play_button, breakplane, game_over_sound, enemies_down, middle, middle_down, bosses) if enemy_frequency % 60 == 0 and len( enemys) < ai_settings.min_enemy_number: gf.create_fleet(ai_settings, screen, plane, enemys) else: enemy_frequency += 1 if middle_frequency % 100 == 0 and len( middle) < ai_settings.min_middle_number: gf.create_middle_enemys(ai_settings, screen, middle) else: middle_frequency += 1 if stats.game_active and stats.boss_state: plane.update() gf.update_bullets(ai_settings, screen, plane, enemys, bullets, stats, s, shoot_frequency, enemies_down, enemy1_down_sound, middle, middle_down, enemy2_down_sound, bosses, break_boss, enemy3_down_sound) gf.update_bosses(ai_settings, plane, breakplane, stats, s, game_over_sound, play_button, bosses) if (len(bosses) <= 0): gf.create_boss(ai_settings, screen, bosses) bosses.update() if not stats.game_active and stats.game_state: enemys.empty() bullets.empty() screen.blit(game_over, (0, 0)) for planes in breakplane: if delay < 10: planes.image = pygame.image.load("images\\hero_break1.png") delay += 1 elif delay < 20: planes.image = pygame.image.load("images\\hero_break2.png") delay += 1 elif delay < 30: planes.image = pygame.image.load("images\\hero_break3.png") delay += 1 elif delay < 40: planes.image = pygame.image.load("images\\hero_break4.png") delay += 1 screen.blit(planes.image, plane.rect) if delay >= 40: delay = 0 breakplane.remove(plane) for enemy_down in enemies_down: if delay_1 < 10: enemy_down.image = pygame.image.load("images\\enemy1_1.png") delay_1 += 1 elif delay_1 < 20: enemy_down.image = pygame.image.load("images\\enemy1_2.png") delay_1 += 1 elif delay_1 < 30: enemy_down.image = pygame.image.load("images\\enemy1_3.png") delay_1 += 1 elif delay_1 < 40: enemy_down.image = pygame.image.load("images\\enemy1_4.png") delay_1 += 1 screen.blit(enemy_down.image, enemy_down.rect) if delay_1 >= 40: delay_1 = 0 enemies_down.remove(enemy_down) for mi_down in middle_down: if delay_2 < 10: mi_down.image = pygame.image.load("images\\middle_1.png") delay_2 += 1 elif delay_2 < 20: mi_down.image = pygame.image.load("images\\middle_2.png") delay_2 += 1 elif delay_2 < 30: mi_down.image = pygame.image.load("images\\middle_3.png") delay_2 += 1 elif delay_2 < 40: mi_down.image = pygame.image.load("images\\middle_4.png") delay_2 += 1 screen.blit(mi_down.image, mi_down.rect) if delay_2 >= 40: delay_2 = 0 middle_down.remove(mi_down) for boss_down in break_boss: if delay_3 < 10: boss_down.image = pygame.image.load("images\\boss_1.png") delay_3 += 1 elif delay_3 < 20: boss_down.image = pygame.image.load("images\\boss_2.png") delay_3 += 1 elif delay_3 < 30: boss_down.image = pygame.image.load("images\\boss_3.png") delay_3 += 1 elif delay_3 < 40: boss_down.image = pygame.image.load("images\\boss_4.png") delay_3 += 1 elif delay_3 < 50: boss_down.image = pygame.image.load("images\\boss_4.png") delay_3 += 1 elif delay_3 < 60: boss_down.image = pygame.image.load("images\\boss_4.png") delay_3 += 1 screen.blit(boss_down.image, boss_down.rect) if delay_3 >= 60: delay_3 = 0 break_boss.remove(boss_down) gf.update_screen(ai_settings, screen, stats, plane, enemys, bullets, play_button, s, middle, bosses) pygame.display.update()
class AlienInvasion: def __init__(self): pygame.init() self.settings = Settings() self.screen = pygame.display.set_mode( (self.settings.screen_width, self.settings.screen_height)) pygame.display.set_caption('Alien Invasion') self.stats = GameStats(self) self.sb = Scoreboard(self) self.ship = Ship(self) self.bullets = pygame.sprite.Group() self.aliens = pygame.sprite.Group() self._create_fleet() self.play_button = Button(self, "Play") def run_game(self): while True: self._check_events() if self.stats.game_active: self.ship.update() self._update_bullets() self._update_aliens() self._update_screen() def _check_events(self): for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.KEYDOWN: self._check_keydown_events(event) elif event.type == pygame.KEYUP: self._check_keyup_events(event) elif event.type == pygame.MOUSEBUTTONDOWN: mouse_pos = pygame.mouse.get_pos() self._check_play_button(mouse_pos) def _check_play_button(self, mouse_pos): button_clicked = self.play_button.rect.collidepoint(mouse_pos) if button_clicked and not self.stats.game_active: self.stats.reset_stats() self.stats.game_active = True self.sb.prep_score() self.sb.prep_level() self.sb.prep_ships() self.aliens.empty() self.bullets.empty() self._create_fleet() self.ship.center_ship() pygame.mouse.set_visible(False) self.settings.initialize_dynamic_settings() def _check_keydown_events(self, event): if event.key == pygame.K_RIGHT: self.ship.moving_right = True elif event.key == pygame.K_LEFT: self.ship.moving_left = True elif event.key == pygame.K_q: sys.exit() elif event.key == pygame.K_SPACE: self._fire_bullet() def _check_keyup_events(self, event): if event.key == pygame.K_RIGHT: self.ship.moving_right = False elif event.key == pygame.K_LEFT: self.ship.moving_left = False def _fire_bullet(self): if len(self.bullets) < self.settings.bullets_allowed: new_bullet = Bullet(self) self.bullets.add(new_bullet) def _update_bullets(self): self.bullets.update() for bullet in self.bullets.copy(): if bullet.rect.bottom <= 0: self.bullets.remove(bullet) self._check_bullet_alien_collisions() def _check_bullet_alien_collisions(self): collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, True) if collisions: for aliens in collisions.values(): self.stats.score += self.settings.alien_points * len(aliens) self.sb.prep_score() self.sb.check_high_score() if not self.aliens: self.bullets.empty() self._create_fleet() self.settings.increase_speed() self.stats.level += 1 self.sb.prep_level() def _create_fleet(self): alien = Alien(self) alien_width, alien_height = alien.rect.size available_space_x = self.settings.screen_width - (2 * alien_width) number_aliens_x = available_space_x // (2 * alien_width) ship_height = self.ship.rect.height available_space_y = (self.settings.screen_height - (5 * alien_height) - ship_height) number_rows = available_space_y // (2 * alien_height) for row_number in range(number_rows): for alien_number in range(number_aliens_x): self._create_alien(alien_number, row_number) def _create_alien(self, alien_number, row_number): alien = Alien(self) alien_width, alien_height = alien.rect.size alien.x = alien_width + 2 * alien_width * alien_number alien.rect.x = alien.x alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number self.aliens.add(alien) def _update_aliens(self): self._check_fleet_edges() self.aliens.update() if pygame.sprite.spritecollideany(self.ship, self.aliens): self._ship_hit() self._check_aliens_bottom() def _check_fleet_edges(self): for alien in self.aliens.sprites(): if alien.check_edges(): self._change_fleet_direction() break def _check_aliens_bottom(self): screen_rect = self.screen.get_rect() for alien in self.aliens.sprites(): if alien.rect.bottom >= screen_rect.bottom: self._ship_hit() break def _change_fleet_direction(self): for alien in self.aliens.sprites(): alien.rect.y += self.settings.fleet_drop_speed self.settings.fleet_direction *= -1 def _ship_hit(self): if self.stats.ships_left > 0: self.stats.ships_left -= 1 self.sb.prep_ships() self.aliens.empty() self.bullets.empty() self._create_fleet() self.ship.center_ship() sleep(0.5) else: self.stats.game_active = False pygame.mouse.set_visible(True) def _update_screen(self): self.screen.fill(self.settings.bg_color) self.ship.blitme() for bullet in self.bullets.sprites(): bullet.draw_bullet() self.aliens.draw(self.screen) if not self.stats.game_active: self.play_button.draw_button() self.sb.show_score() pygame.display.flip()
class Game(): def __init__(self): pygame.init() self.ai_settings = Settings() self.screen = pygame.display.set_mode( (self.ai_settings.screen_width, self.ai_settings.screen_height)) pygame.display.set_caption("Inwazja obcych") # Utworzenie przycisku Gra self.play_button = Button(self.ai_settings, self.screen, 'Gra') # Utworzenie egzemplarza przenaczonego do przechowywania danych # statystycznych gry oraz utworzenie egzemplarza klasy Scoreboard self.stats = GameStats(self.ai_settings) self.sb = Scoreboard(self.ai_settings, self.screen, self.stats) #Utworzenie statku kosmicznego, grupy pocisków oraz grupy obcych self.ship = Ship(self.ai_settings, self.screen) self.bullets = Group() self.aliens = Group() # Utworzenie floty obcych self.create_fleet() def run(self): while True: self.check_events() if self.stats.game_active: self.ship.update() self.update_bullets() self.update_aliens() self.update_screen() def create_fleet(self): '''Utworzenie pełnej floty obcych.''' alien = Alien(self.ai_settings, self.screen) number_aliens_x = self.get_number_aliens_x(alien.rect.width) number_rows = self.get_number_rows(alien.rect.height) for row_number in range(number_rows): for alien_number in range(number_aliens_x): self.create_alien(alien_number, row_number) def get_number_aliens_x(self, alien_width): '''Ustalenie liczby obcych, którzy zmieszczą się w rzędzie.''' available_space_x = self.ai_settings.screen_width - 2 * alien_width number_aliens_x = int(available_space_x / (2 * alien_width)) return number_aliens_x def get_number_rows(self, alien_height): '''Ustalenie ile rzędów obcych zmieści się na ekranie''' available_space_y = (self.ai_settings.screen_height - 3 * alien_height - self.ship.rect.height) number_rows = int(available_space_y / (2 * alien_height)) return number_rows def create_alien(self, alien_number, row_number): '''Utwórz nowego obcego.''' alien = Alien(self.ai_settings, self.screen) alien_width = alien.rect.width alien.x = alien_width + 2 * alien_width * alien_number alien.rect.x = alien.x alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number self.aliens.add(alien) def check_events(self): '''Reakcja na zdarzenia generowane przez klawiaturę i mysz.''' for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.KEYDOWN: self.check_keydown_events(event) elif event.type == pygame.KEYUP: self.check_keyup_events(event) elif event.type == pygame.MOUSEBUTTONDOWN: mouse_x, mouse_y = pygame.mouse.get_pos() self.check_play_button(mouse_x, mouse_y) def check_keydown_events(self, event): '''Reakcja na naciśnięcie klawisza.''' if event.key == pygame.K_RIGHT: self.ship.moving_right = True elif event.key == pygame.K_LEFT: self.ship.moving_left = True elif event.key == pygame.K_SPACE: self.fire_bullet() elif event.key == pygame.K_g: self.start_game() elif event.key == pygame.K_q: sys.exit() def fire_bullet(self): # Utworzenie nowego pocisku i dodanie go do grupy pocisków if len(self.bullets) < self.ai_settings.bullets_allowed: new_bullet = Bullet(self.ai_settings, self.screen, self.ship) self.bullets.add(new_bullet) def start_game(self): '''Rozpoczęcie gry poprzez wywołanie domyślnych ustawień.''' if not self.stats.game_active: # Wyzerowanie ustawień dotyczących gry. self.ai_settings.initialize_dynamic_settings() # Ukrycie kursora myszy pygame.mouse.set_visible(False) # Wyzerowanie danych statystycznych gry self.stats.reset_stats() self.stats.game_active = True # Wyzerowanie obrazów tablicy wyników. self.sb.prep_score() self.sb.prep_high_score() self.sb.prep_level() # Usunięcie zawartości list aliens i bullets self.aliens.empty() self.bullets.empty() # Utworzenie nowej floty i wyśrodkowanie statku self.create_fleet() self.ship.center_ship() def check_keyup_events(self, event): if event.key == pygame.K_RIGHT: self.ship.moving_right = False elif event.key == pygame.K_LEFT: self.ship.moving_left = False def check_play_button(self, mouse_x, mouse_y): '''Rozpoczęcie nowej gry po kliknięciu przycisku Gra przez użytkownika''' button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y) if button_clicked and not self.stats.game_active: self.start_game() def update_bullets(self): self.bullets.update() # Usunięcie pocisków, które znajdą się poza ekranem for bullet in self.bullets.copy(): if bullet.rect.bottom < 0: self.bullets.remove(bullet) self.check_bullet_alien_collisions() def check_bullet_alien_collisions(self): '''Reakcja na kolizję między pociskiem i obcym.''' collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, True) if collisions: for aliens in collisions.values(): self.stats.score += self.ai_settings.alien_points * len(aliens) self.sb.prep_score() self.check_high_score() if len(self.aliens) == 0: # Jeżeli cała flota została zniszczona, gracz przechodzi na kolejny poziom. self.bullets.empty() self.ai_settings.increase_speed() # Inkrementacja numeru poziomu. self.stats.level += 1 self.sb.prep_level() self.create_fleet() def check_high_score(self): '''Sprawdzenie, czy mamy nowy najlpeszy wynik osiągnięty dotąd w grze.''' if self.stats.score > self.stats.high_score: self.stats.high_score = self.stats.score self.sb.prep_high_score() def update_aliens(self): '''Uaktualnienie położenia wszystkich obcych we flocie''' self.check_fleet_edges() self.aliens.update() # Wykrywanie kolizji między obcym i statkiem if pygame.sprite.spritecollideany(self.ship, self.aliens): self.ship_hit() # Wyszukiwanie obcych docierających do dolnej krawędzi ekranu self.check_aliens_bottom() def check_fleet_edges(self): '''Odpowiednia reakcja, gdy obcy dotrze do krawędzi ekranu.''' for alien in self.aliens.sprites(): if alien.check_edges(): self.change_fleet_direction() break def change_fleet_direction(self): '''Przesunięcie całej floty w dół i zmiana kierunku, w którym się ona porusza.''' for alien in self.aliens.sprites(): alien.rect.y += self.ai_settings.fleet_drop_speed self.ai_settings.fleet_direction *= -1 def ship_hit(self): '''Reakcja na uderzenie obcego w statek.''' if self.stats.ships_left > 0: # Zmniejszenie wartości przechowywanej w ships_left self.stats.ships_left -= 1 # Uaktualnienie tablicy wyników. self.sb.prep_ships() # Usunięcie zawartości list aliens i bullets self.aliens.empty() self.bullets.empty() # Utworzenie nowej floty i wyśrodkowanie statku self.create_fleet() self.ship.center_ship() # Pauza sleep(0.5) else: self.stats.game_active = False pygame.mouse.set_visible(True) def check_aliens_bottom(self): '''Sprawdzenie, czy którykolwiek obcy dotarł do dolnej krawędzi ekranu''' screen_rect = self.screen.get_rect() for alien in self.aliens.sprites(): if alien.rect.bottom >= screen_rect.bottom: self.ship_hit() break def update_screen(self): '''Uaktualnienie obrazów na ekranie i przejście do nowego ekranu.''' self.screen.fill(self.ai_settings.bg_color) # Ponowne wyświetlenie wszystkich pocisków pod warstwami statku kosmicznego i obcych for bullet in self.bullets.sprites(): bullet.draw_bullet() self.ship.blitme() self.aliens.draw(self.screen) # Wyświetlenie informacji o punktacji. self.sb.show_score() # Wyświetlenie przycisku tylko wtedy, gdy gra jest nieaktywna if not self.stats.game_active: self.play_button.draw_button() pygame.display.flip()
def save_only(iface): import common.network as network from common import nailyfactersettings from settings import Settings import netifaces #Naily.facts translation map from astute.yaml format facter_translate = \ { "ADMIN_NETWORK/interface": "internal_interface", "ADMIN_NETWORK/ipaddress": "internal_ipaddress", "ADMIN_NETWORK/netmask": "internal_netmask", "ADMIN_NETWORK/dhcp_pool_start": "dhcp_pool_start", "ADMIN_NETWORK/dhcp_pool_end": "dhcp_pool_end", "ADMIN_NETWORK/static_pool_start": "static_pool_start", "ADMIN_NETWORK/static_pool_end": "static_pool_end", } #Calculate and set Static/DHCP pool fields #Max IPs = net size - 2 (master node + bcast) try: ip = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr'] netmask = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['netmask'] except: print "Interface %s does is missing either IP address or netmask" \ % (iface) sys.exit(1) net_ip_list = network.getNetwork(ip, netmask) try: half = int(len(net_ip_list) / 2) #In most cases, skip 10.XXX.0.1 static_pool = list(net_ip_list[1:half]) dhcp_pool = list(net_ip_list[half:]) static_start = str(static_pool[0]) static_end = str(static_pool[-1]) dynamic_start = str(dhcp_pool[0]) dynamic_end = str(dhcp_pool[-1]) except: print "Unable to define DHCP pools" sys.exit(1) settings = \ { "ADMIN_NETWORK/interface": iface, "ADMIN_NETWORK/ipaddress": ip, "ADMIN_NETWORK/netmask": netmask, "ADMIN_NETWORK/dhcp_pool_start": dynamic_start, "ADMIN_NETWORK/dhcp_pool_end": dynamic_end, "ADMIN_NETWORK/static_pool_start": static_start, "ADMIN_NETWORK/static_pool_end": static_end, } newsettings = dict() for setting in settings.keys(): if "/" in setting: part1, part2 = setting.split("/") if part1 not in newsettings.keys(): newsettings[part1] = {} newsettings[part1][part2] = settings[setting] else: newsettings[setting] = settings[setting] #Write astute.yaml Settings().write(newsettings, defaultsfile=None, outfn="/etc/astute.yaml") #Prepare naily.facts factsettings = dict() for key in facter_translate.keys(): factsettings[facter_translate[key]] = settings[key] n = nailyfactersettings.NailyFacterSettings() n.write(factsettings)
DELAY_BEFORE_QUITTING = 1000 N_PHYSICS_SUBSTEPS = 10 MAX_N_OBSTS = 10 BORDER_S_WIDTH = 1 / 4 CAM_DAMPING_FACTOR = 8 SCORE_ADD_FACTOR = 1.0 SCORE_EXPADD_FACTOR = 0.00002 N_PLAYERS = 1 SEED = 0 DIFFICULTY_PRESET = DifficultyPreset.der_2 SETTINGS = Settings(difficulty_preset=DIFFICULTY_PRESET, fps=FPS) LOAD = True SAVE = True if DIFFICULTY_PRESET == DifficultyPreset.test: LOAD = False SAVE = False SAVE_DIR = "saves" SAVE_PROFILES = [ f"p1_l{DIFFICULTY_PRESET.value}_s{SEED}", f"p2_l{DIFFICULTY_PRESET.value}_s{SEED}", f"p3_l{DIFFICULTY_PRESET.value}_s{SEED}", ] SAVE_PATHS = [
def run_pipeline(): """Initiate and run analysis on US wildfires.""" # initialize settings start_time = time.time() ml_settings = Settings() # Collect data data_collector.collate_data(ml_settings) # Separate data into training, validation, and test sets X_train, X_val, X_test, y_train, y_val, y_test = training.separate_time_data( ml_settings) prep_pipeline = training.prep_pipeline(ml_settings) X_train_prepared = prep_pipeline.fit_transform(X_train) X_val_prepared = prep_pipeline.transform(X_val) # Create a deep learning neural network then train the model on data print('WILL BELL Trains DEEP Neural Network:') tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR) dnn_clf = models.DNNClassifier( random_state=42, n_hidden_layers=ml_settings.n_hidden_layers, n_neurons=ml_settings.n_neurons, batch_size=ml_settings.batch_size, batch_norm_momentum=ml_settings.batch_norm_momentum, dropout_rate=ml_settings.dropout_rate, learning_rate=ml_settings.learning_rate, activation=ml_settings.activation) dnn_clf.fit(X_train_prepared, y_train, n_epochs=1000, X_valid=X_val_prepared, y_valid=y_val) # Perform a randomized hyperparameter search using a time series cross validation if ml_settings.hp_search: # Define time series cross validation and parameter distribution. ts_cv = TimeSeriesSplit(n_splits=3).split(X_train_prepared) param_distribs = { "n_neurons": [50, 100, 200, 300], "batch_size": [50, 100, 500], "learning_rate": [0.01, 0.02, 0.05, 0.1], "activation": [tf.nn.elu, tf.nn.leaky_relu], "n_hidden_layers": [1, 2, 3, 4, 5], "batch_norm_momentum": [0.9, 0.95, 0.99, 0.999], "dropout_rate": [0.2, 0.4, 0.6], } # Run randomized hyperparameter search. rnd_search = RandomizedSearchCV(models.DNNClassifier(random_state=42), param_distribs, n_iter=50, cv=ts_cv, random_state=42, verbose=1, n_jobs=-1) rnd_search.fit(X_train_prepared, y_train, n_epochs=1000, X_valid=X_val_prepared, y_valid=y_val) print(rnd_search.best_params_, '\n') # Measure trained model on test set. X_test_prepared = prep_pipeline.transform(X_test) if ml_settings.hp_search: testing.measure_performance(X_test_prepared, y_test, rnd_search, show_classification_report=True, show_confusion_matrix=True) else: testing.measure_performance(X_test_prepared, y_test, dnn_clf, show_classification_report=True, show_confusion_matrix=True) # Save trained neural network. if ml_settings.hp_search: rnd_search.best_estimator_.save(ml_settings.MODEL_PATH) else: dnn_clf.save(ml_settings.MODEL_PATH) # Report computational time. end_time = time.time() total_time = end_time - start_time print('Time: ', total_time)
class AlienInvasion: def __init__(self): """ИНИЦИАЛИЗАЦИЯ ИГРЫ""" pygame.init() #HERE IS EVERYTHING ALRIGHT self.settings = Settings() self.screen = pygame.display.set_mode( (self.settings.screen_width, self.settings.screen_height)) # 4 self.screen_rect = self.screen.get_rect() # ЕС ХОТИТЕ СДЕЛАТЬ НА ФУЛ ЭКРАН - УБИРАЙТЕ # В 1 , 2 , 3 ПУНКТЕ И ПОСТАВЬТЕ # В 4 ПУНКТЕ # self.screen=pygame.display.set_mode((0,0), pygame.FULLSCREEN) # 1 # self.settings.screen_width=self.screen.get_rect().width # 2 # self.settings.screen_height=self.screen.get_rect().height # 3 pygame.display.set_caption("ALIEN INVASION") self.ship = Ship(self) self.bullets = pygame.sprite.Group() self.stats = GameStats(self) self.sb = Scoreboard(self) self.aliens = pygame.sprite.Group() #объявление группы пришельцев #self.charecter=Character(self) # MB I WILL DO IT self._create_fleet() #при первом вызыове self.play_button = Button(self, "LETS START") self.filename = "saved_data.json" def run_game(self): """ЗАПУСК ИГРЫ""" while True: #ОТСЛЕЖИВАНИЕ ДЕЙСТВИЙ С КЛАВЫ self._check_events() if self.stats.game_active: self.ship.update() self._update_bullet() self._update_aliens() self._update_screen() def _update_screen(self): #отвечает за то, что вообще на экране творится self.screen.fill( self.settings.bg_colour) #Заполнить экран определенным цветом self.ship.blitme() # Использовать метод показа корабля #self.charecter.blitme() #MB I WILL DO IT for bullet in self.bullets.sprites(): bullet.draw_bullet() self.aliens.draw( self.screen) #показывает пришельцев на self.screen (общий экран) if not self.stats.game_active: self.play_button.draw_button() self.sb.show_score() #Метод показа очков pygame.display.flip() #обновление экрана def _check_events(self): #общая проверка ивентов for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.KEYDOWN: self._check_keyDOWN(event) elif event.type == pygame.KEYUP: self._check_keyUP(event) elif event.type == pygame.MOUSEBUTTONDOWN: mouse_pos = pygame.mouse.get_pos() self._check_play_button(mouse_pos) def _check_keyDOWN(self, event): #проверка нажатой клавиши if event.key == pygame.K_RIGHT: self.ship.moving_right = True elif event.key == pygame.K_LEFT: self.ship.moving_left = True if event.key == pygame.K_UP: self.ship.moving_up = True elif event.key == pygame.K_DOWN: self.ship.moving_down = True elif event.key == pygame.K_ESCAPE: #стоп слово some_score = self.stats.high_score with open(self.filename, "w") as f: #Открытие файла print("d") #Лоигрование, что запись в файл идет json.dump(some_score, f) #Сохранение результата sys.exit() elif event.key == pygame.K_SPACE: #Вызов метода стрельбы пули self._fire_bullet() def _check_keyUP( self, event): #проверка, какую клавишу отпустили (или отпущена) if event.key == pygame.K_RIGHT: self.ship.moving_right = False elif event.key == pygame.K_LEFT: self.ship.moving_left = False elif event.key == pygame.K_UP: self.ship.moving_up = False elif event.key == pygame.K_DOWN: self.ship.moving_down = False def _check_play_button(self, mouse_pos): button_clicked = self.play_button.rect.collidepoint( mouse_pos) #проверка нажатия кнопки if button_clicked and not self.stats.game_active: #если кнопка нажата и игра не запущена начинается игра self.settings.initialize_dynamic_settings() self.stats.reset_stats() self.stats.game_active = True self.sb.prep_score() self.sb.prep_level() self.sb.prep_ships() self.aliens.empty() self.bullets.empty() self._create_fleet() self.ship.center_ship() pygame.mouse.set_visible(False) #Метод, чтобы мышка исчезла def _fire_bullet(self): #отвечает за запуск пули if len( self.bullets ) < self.settings.bullet_allowed: #Если длина меньше кол-во разрешенных пуль new_bullet = Bullet(self) self.bullets.add(new_bullet) def _update_bullet( self ): #отвечает за устраниение пули, когда она достигнет определенной точки self.bullets.update() for bullet in self.bullets.copy(): if bullet.rect.bottom <= 0: self.bullets.remove(bullet) #print (len(self.bullets)) self._check_bullet() def _check_bullet(self): collisions = pygame.sprite.groupcollide( self.bullets, self.aliens, False, True) #Проверка взаимодействия группы пули и группы пришельцев if collisions: #Если есть коллизия for aliens in collisions.values(): self.stats.score += self.settings.alien_score * len(aliens) self.sb.prep_score() self.sb.check_high_score() if not self.aliens: #Если группа пришельцев пустая self.bullets.empty() self._create_fleet() self.settings.increase_speed() self.stats.level += 1 self.sb.prep_level() def _ship_hit(self): #Проверка был ли удра корабля if self.stats.ships_left >= 0: #Если кол-во кораблей больше или равно нулю - продолжать действие self.stats.ships_left -= 1 self.sb.prep_ships() self.aliens.empty() self.bullets.empty() self._create_fleet() self.ship.center_ship() sleep(0.5) #Остановить игру на 0.5 сек else: self.stats.game_active = False pygame.mouse.set_visible(True) def _create_fleet(self): #Создание флота пришельцев alien = Alien(self) alien_width, alien_height = alien.rect.size #метод alien.rect.size возвращает ширину и длину пришельца ship_height = self.ship.rect.height #высота корабля available_space_x = self.settings.screen_width - ( 2 * alien_width ) #настройки экрана - ширина пришельца * 2 (чтобы было место) available_space_y = self.settings.screen_height - ( 3 * alien_height ) - ship_height #получаем настройки, чтобы узнать кол-во рядов, мы можем сделать number_rows = available_space_y // ( 2 * alien_height ) #считаем точное кол-во, чтобы у игрока был шанс нормально играть без проблем number_aliends = available_space_x // (2 * alien_width ) #кол-во пришельцев в ряду for row in range((number_rows - 2) // 2): #допилить вариацию ряда for number in range( number_aliends): # вводим цикл для каждого пришельца self._create_alien( number, row ) #для каждого нового пришельца, мы вызываем метод создания пришельца (указываем кол-во в ряду и кол-во рядом) self._create_alien_1(number, row + 1) def _create_alien(self, alien_number, row): # создание пришельца alien = Alien(self) alien_width, alien_height = alien.rect.size #Сначала идет ширина потом длина пришельца alien.x = alien_width + 2 * alien_width * alien_number #определили расстояние между инепрешеленцами alien.rect.x = alien.x #Расположение пришельца alien.rect.y = alien_height + 2 * alien_height * row self.aliens.add(alien) #добавление пришельца в "список пришельцев" def _create_alien_1(self, alien_number, row): alien = Alien(self) alien_width, alien_height = alien.rect.size alien.x = alien_width + alien_width + 2 * alien_width * alien_number alien.rect.x = alien.x alien.rect.y = 2 * alien_height * row self.aliens.add(alien) def _update_aliens(self): self.aliens.update() if pygame.sprite.spritecollideany(self.ship, self.aliens): self._ship_hit() self._aliens_check_bottom() self._check_fleet() def _aliens_check_bottom(self): #Проверка достиг ли пришелец дна for alien in self.aliens.sprites(): if alien.rect.bottom >= self.screen_rect.bottom: self._ship_hit() break def _check_fleet(self): #Проверка дошел ли пришелец до края for alien in self.aliens.sprites(): if alien.check_edges(): self._change_direction() break def _change_direction(self): #Смена направления for alien in self.aliens.sprites( ): #меняем направление каждого пришельца с помощью группы спрайт alien.rect.y += self.settings.fleet_drop_speed self.settings.fleet_direction *= -1
class AutoCanaryGui(QtGui.QWidget): def __init__(self, app, gpg, headlines): super(AutoCanaryGui, self).__init__() self.app = app self.gpg = gpg self.headlines = headlines self.settings = Settings() self.setWindowTitle('AutoCanary') self.setWindowIcon(QtGui.QIcon(common.get_image_path('icon.png'))) # frequency, year self.date_col1_layout = QtGui.QVBoxLayout() self.frequency_layout = QtGui.QHBoxLayout() self.frequency_label = QtGui.QLabel('Frequency') self.frequency = QtGui.QComboBox() frequency_options = ["Weekly", "Monthly", "Quarterly", "Semiannually"] for option in frequency_options: self.frequency.addItem(option) option = self.settings.get_frequency() if option in frequency_options: self.frequency.setCurrentIndex(frequency_options.index(option)) self.frequency_layout.addWidget(self.frequency_label) self.frequency_layout.addWidget(self.frequency) self.frequency.activated.connect(self.update_date) self.year_layout = QtGui.QHBoxLayout() self.year_label = QtGui.QLabel('Year') self.year = QtGui.QComboBox() y = datetime.date.today().year year_options = [str(y - 1), str(y), str(y + 1)] for option in year_options: self.year.addItem(option) option = self.settings.get_year() if option in year_options: self.year.setCurrentIndex(year_options.index(option)) self.year_layout.addWidget(self.year_label) self.year_layout.addWidget(self.year) self.year.activated.connect(self.update_date) # weekly dropdown self.weekly_layout = QtGui.QHBoxLayout() self.weekly_label = QtGui.QLabel('Week') self.weekly_dropdown = QtGui.QComboBox() self.weekly_layout.addWidget(self.weekly_label) self.weekly_layout.addWidget(self.weekly_dropdown) # monthly dropdown self.monthly_layout = QtGui.QHBoxLayout() self.monthly_label = QtGui.QLabel('Month') self.monthly_dropdown = QtGui.QComboBox() monthly_options = [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ] for option in monthly_options: self.monthly_dropdown.addItem(option) self.monthly_layout.addWidget(self.monthly_label) self.monthly_layout.addWidget(self.monthly_dropdown) # quarterly radio buttons self.quarterly_layout = QtGui.QHBoxLayout() self.quarterly_label = QtGui.QLabel('Quarter') self.quarterly_q1 = QtGui.QRadioButton("") self.quarterly_q2 = QtGui.QRadioButton("") self.quarterly_q3 = QtGui.QRadioButton("") self.quarterly_q4 = QtGui.QRadioButton("") self.quarterly_layout.addWidget(self.quarterly_label) self.quarterly_layout.addWidget(self.quarterly_q1) self.quarterly_layout.addWidget(self.quarterly_q2) self.quarterly_layout.addWidget(self.quarterly_q3) self.quarterly_layout.addWidget(self.quarterly_q4) # semiannual radio buttons self.semiannually_layout = QtGui.QHBoxLayout() self.semiannually_label = QtGui.QLabel('Semester') self.semiannually_q12 = QtGui.QRadioButton("") self.semiannually_q34 = QtGui.QRadioButton("") self.semiannually_layout.addWidget(self.semiannually_label) self.semiannually_layout.addWidget(self.semiannually_q12) self.semiannually_layout.addWidget(self.semiannually_q34) # date layout self.date_layout = QtGui.QVBoxLayout() self.date_layout.addLayout(self.frequency_layout) self.date_layout.addLayout(self.year_layout) self.date_layout.addLayout(self.weekly_layout) self.date_layout.addLayout(self.monthly_layout) self.date_layout.addLayout(self.quarterly_layout) self.date_layout.addLayout(self.semiannually_layout) self.update_date() # status self.status_layout = QtGui.QHBoxLayout() self.status_label = QtGui.QLabel('Status') self.status = QtGui.QComboBox() status_options = ["All good", "It's complicated"] for option in status_options: self.status.addItem(option) option = self.settings.get_status() if option in status_options: self.status.setCurrentIndex(status_options.index(option)) self.status_layout.addWidget(self.status_label) self.status_layout.addWidget(self.status) # canary text box self.textbox = QtGui.QTextEdit() self.textbox.setText(self.settings.get_text()) # headlines controls: [checkbox, button, button]. self.headlines_controls = self.get_headlines_controls() # key selection seckeys = gpg.seckeys_list() self.key_selection = QtGui.QComboBox() for seckey in seckeys: uid = seckey['uid'] if len(uid) >= 53: uid = '{0}...'.format(uid[:50]) fp = seckey['fp'][-8:] text = '{0} [{1}]'.format(uid, fp) self.key_selection.addItem(text) fp = self.settings.get_fp() if fp: key_i = 0 for i, seckey in enumerate(seckeys): if seckey['fp'] == fp: key_i = i self.key_selection.setCurrentIndex(key_i) # buttons self.buttons_layout = QtGui.QHBoxLayout() self.sign_save_button = QtGui.QPushButton('Save and Sign') self.sign_save_button.clicked.connect(self.sign_save_clicked) self.sign_once = QtGui.QPushButton('One-Time Sign') self.sign_once.clicked.connect(self.sign_once_clicked) self.buttons_layout.addWidget(self.sign_save_button) self.buttons_layout.addWidget(self.sign_once) # headlines controls. self.headline_controls_layout = QtGui.QHBoxLayout() for hl_control in self.headlines_controls: self.headline_controls_layout.addWidget(hl_control) # layout self.layout = QtGui.QVBoxLayout() self.layout.addLayout(self.date_layout) self.layout.addLayout(self.status_layout) self.layout.addWidget(self.textbox) self.layout.addLayout(self.headline_controls_layout) self.layout.addWidget(self.key_selection) self.layout.addLayout(self.buttons_layout) self.setLayout(self.layout) self.show() def update_date(self): frequency = self.frequency.currentText() year = self.year.currentText() if frequency == 'Weekly': self.weekly_label.show() self.weekly_dropdown.show() # regenerate the weekly dropdown options based on the current year self.weekly_dropdown.clear() one_week = datetime.timedelta(7) cur_date = datetime.datetime(int(year), 1, 1) def get_monday_of_week(d): days_past = d.isoweekday() - 1 d = d - datetime.timedelta(days_past) return d def get_sunday_of_week(d): days_future = 7 - d.isoweekday() d = d + datetime.timedelta(days_future) return d while cur_date.year == int(year): date_str = '' # figure out the start and end dates of the week monday_date = get_monday_of_week(cur_date) sunday_date = get_sunday_of_week(cur_date) if sunday_date.year != int(year): break date_str += '{0} to {1}'.format(monday_date.strftime('%b %d'), sunday_date.strftime('%b %d')) self.weekly_dropdown.addItem(date_str) cur_date += one_week else: self.weekly_label.hide() self.weekly_dropdown.hide() if frequency == 'Monthly': self.monthly_label.show() self.monthly_dropdown.show() else: self.monthly_label.hide() self.monthly_dropdown.hide() if frequency == 'Quarterly': self.quarterly_label.show() self.quarterly_q1.show() self.quarterly_q2.show() self.quarterly_q3.show() self.quarterly_q4.show() # make sure a quarterly radio button is checked if not self.quarterly_q1.isChecked( ) and not self.quarterly_q2.isChecked( ) and not self.quarterly_q3.isChecked( ) and not self.quarterly_q4.isChecked(): self.quarterly_q1.setChecked(True) else: self.quarterly_label.hide() self.quarterly_q1.hide() self.quarterly_q2.hide() self.quarterly_q3.hide() self.quarterly_q4.hide() if frequency == 'Semiannually': self.semiannually_label.show() self.semiannually_q12.show() self.semiannually_q34.show() # make sure a semiannually radio button is checked if not self.semiannually_q12.isChecked( ) and not self.semiannually_q34.isChecked(): self.semiannually_q12.setChecked(True) else: self.semiannually_label.hide() self.semiannually_q12.hide() self.semiannually_q34.hide() # update freqency text # the QString objects which represent the widget state are unicode # strings, hence the u'...' self.quarterly_q1.setText(u'Q1 {}'.format(year)) self.quarterly_q2.setText(u'Q2 {}'.format(year)) self.quarterly_q3.setText(u'Q3 {}'.format(year)) self.quarterly_q4.setText(u'Q4 {}'.format(year)) self.semiannually_q12.setText(u'Q1 and Q2 {}'.format(year)) self.semiannually_q34.setText(u'Q3 and Q4 {}'.format(year)) def get_year_period(self): frequency = self.frequency.currentText() if frequency == 'Weekly': year_period = self.weekly_dropdown.currentText() elif frequency == 'Monthly': year_period = self.monthly_dropdown.currentText() elif frequency == 'Quarterly': if self.quarterly_q1.isChecked(): year_period = 'Q1' if self.quarterly_q2.isChecked(): year_period = 'Q2' if self.quarterly_q3.isChecked(): year_period = 'Q3' if self.quarterly_q4.isChecked(): year_period = 'Q4' elif frequency == 'Semiannually': if self.semiannually_q12.isChecked(): year_period = 'Q12' if self.semiannually_q34.isChecked(): year_period = 'Q34' return year_period def sign_save_clicked(self): self.save() self.sign() def sign_once_clicked(self): self.sign() def save(self): frequency = self.frequency.currentText() year = self.year.currentText() year_period = self.get_year_period() status = str(self.status.currentText()) text = self.textbox.toPlainText() self.settings.set_frequency(frequency) self.settings.set_year(year) self.settings.set_status(status) self.settings.set_text(text) key_i = self.key_selection.currentIndex() fp = self.gpg.seckeys_list()[key_i]['fp'] self.settings.set_fp(fp) self.settings.save() def sign(self): frequency = self.frequency.currentText() year = self.year.currentText() year_period = self.get_year_period() status = str(self.status.currentText()) text = str(self.textbox.toPlainText()) if self.headlines.enabled and self.headlines.have_headlines: text = '\n\n'.join([text, self.headlines.headlines_str, '']) # add headers period_date = year_period if frequency == 'Quarterly': if year_period == 'Q1': period_date = 'January 1 to March 31' elif year_period == 'Q2': period_date = 'April 1 to June 30' elif year_period == 'Q3': period_date = 'July 1 to September 30' elif year_period == 'Q4': period_date = 'October 1 to December 31' elif frequency == 'Semiannually': if year_period == 'Q12': period_date = 'January 1 to June 30' elif year_period == 'Q34': period_date = 'July 1 to December 31' # the QString objects which represent the widget state are unicode # strings, hence the u'...' message = u'Status: {}\nPeriod: {}, {}\n\n{}'.format( status, period_date, year, text) # sign the file key_i = self.key_selection.currentIndex() fp = self.gpg.seckeys_list()[key_i]['fp'] signed_message = self.gpg.sign(message, fp) if signed_message: # display signed message dialog = OutputDialog(self.app, signed_message) dialog.exec_() else: common.alert('Failed to sign message.') def get_headlines_controls(self): checkbox = QtGui.QCheckBox('Add Recent News Headlines') button_fetch = QtGui.QPushButton('Fetch Headlines') button_fetch.setDisabled(True) button_preview = QtGui.QPushButton('Preview Headlines') button_preview.setDisabled(True) def fetch_headlines(): # synchronous. self.headlines.fetch_headlines() button_fetch.setDisabled(False) self.setCursor(QtCore.Qt.ArrowCursor) if self.headlines.have_headlines: button_preview.setDisabled(False) def cb_clicked(): if checkbox.isChecked(): button_fetch.setDisabled(False) self.headlines.enabled = True if self.headlines.have_headlines: button_preview.setDisabled(False) else: button_preview.setDisabled(True) else: self.headlines.enabled = False button_fetch.setDisabled(True) button_preview.setDisabled(True) def fetch_clicked(): self.setCursor(QtCore.Qt.WaitCursor) button_fetch.setDisabled(True) # allow the widgets a chance to refresh (disabled/wait). QtCore.QTimer().singleShot(1, fetch_headlines) def preview_clicked(): dialog = QtGui.QDialog() dialog.setModal(True) dialog.setWindowFlags(QtCore.Qt.WindowCloseButtonHint) layout = QtGui.QVBoxLayout() text = QtGui.QTextEdit() text.setText(self.headlines.headlines_str) button_close = QtGui.QPushButton('Close') button_close.clicked.connect(dialog.close) layout.addWidget(text) layout.addWidget(button_close) dialog.setLayout(layout) dialog.exec_() button_fetch.clicked.connect(fetch_clicked) button_preview.clicked.connect(preview_clicked) checkbox.clicked.connect(cb_clicked) return [checkbox, button_fetch, button_preview]
def __init__(self, app, gpg, headlines): super(AutoCanaryGui, self).__init__() self.app = app self.gpg = gpg self.headlines = headlines self.settings = Settings() self.setWindowTitle('AutoCanary') self.setWindowIcon(QtGui.QIcon(common.get_image_path('icon.png'))) # frequency, year self.date_col1_layout = QtGui.QVBoxLayout() self.frequency_layout = QtGui.QHBoxLayout() self.frequency_label = QtGui.QLabel('Frequency') self.frequency = QtGui.QComboBox() frequency_options = ["Weekly", "Monthly", "Quarterly", "Semiannually"] for option in frequency_options: self.frequency.addItem(option) option = self.settings.get_frequency() if option in frequency_options: self.frequency.setCurrentIndex(frequency_options.index(option)) self.frequency_layout.addWidget(self.frequency_label) self.frequency_layout.addWidget(self.frequency) self.frequency.activated.connect(self.update_date) self.year_layout = QtGui.QHBoxLayout() self.year_label = QtGui.QLabel('Year') self.year = QtGui.QComboBox() y = datetime.date.today().year year_options = [str(y - 1), str(y), str(y + 1)] for option in year_options: self.year.addItem(option) option = self.settings.get_year() if option in year_options: self.year.setCurrentIndex(year_options.index(option)) self.year_layout.addWidget(self.year_label) self.year_layout.addWidget(self.year) self.year.activated.connect(self.update_date) # weekly dropdown self.weekly_layout = QtGui.QHBoxLayout() self.weekly_label = QtGui.QLabel('Week') self.weekly_dropdown = QtGui.QComboBox() self.weekly_layout.addWidget(self.weekly_label) self.weekly_layout.addWidget(self.weekly_dropdown) # monthly dropdown self.monthly_layout = QtGui.QHBoxLayout() self.monthly_label = QtGui.QLabel('Month') self.monthly_dropdown = QtGui.QComboBox() monthly_options = [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ] for option in monthly_options: self.monthly_dropdown.addItem(option) self.monthly_layout.addWidget(self.monthly_label) self.monthly_layout.addWidget(self.monthly_dropdown) # quarterly radio buttons self.quarterly_layout = QtGui.QHBoxLayout() self.quarterly_label = QtGui.QLabel('Quarter') self.quarterly_q1 = QtGui.QRadioButton("") self.quarterly_q2 = QtGui.QRadioButton("") self.quarterly_q3 = QtGui.QRadioButton("") self.quarterly_q4 = QtGui.QRadioButton("") self.quarterly_layout.addWidget(self.quarterly_label) self.quarterly_layout.addWidget(self.quarterly_q1) self.quarterly_layout.addWidget(self.quarterly_q2) self.quarterly_layout.addWidget(self.quarterly_q3) self.quarterly_layout.addWidget(self.quarterly_q4) # semiannual radio buttons self.semiannually_layout = QtGui.QHBoxLayout() self.semiannually_label = QtGui.QLabel('Semester') self.semiannually_q12 = QtGui.QRadioButton("") self.semiannually_q34 = QtGui.QRadioButton("") self.semiannually_layout.addWidget(self.semiannually_label) self.semiannually_layout.addWidget(self.semiannually_q12) self.semiannually_layout.addWidget(self.semiannually_q34) # date layout self.date_layout = QtGui.QVBoxLayout() self.date_layout.addLayout(self.frequency_layout) self.date_layout.addLayout(self.year_layout) self.date_layout.addLayout(self.weekly_layout) self.date_layout.addLayout(self.monthly_layout) self.date_layout.addLayout(self.quarterly_layout) self.date_layout.addLayout(self.semiannually_layout) self.update_date() # status self.status_layout = QtGui.QHBoxLayout() self.status_label = QtGui.QLabel('Status') self.status = QtGui.QComboBox() status_options = ["All good", "It's complicated"] for option in status_options: self.status.addItem(option) option = self.settings.get_status() if option in status_options: self.status.setCurrentIndex(status_options.index(option)) self.status_layout.addWidget(self.status_label) self.status_layout.addWidget(self.status) # canary text box self.textbox = QtGui.QTextEdit() self.textbox.setText(self.settings.get_text()) # headlines controls: [checkbox, button, button]. self.headlines_controls = self.get_headlines_controls() # key selection seckeys = gpg.seckeys_list() self.key_selection = QtGui.QComboBox() for seckey in seckeys: uid = seckey['uid'] if len(uid) >= 53: uid = '{0}...'.format(uid[:50]) fp = seckey['fp'][-8:] text = '{0} [{1}]'.format(uid, fp) self.key_selection.addItem(text) fp = self.settings.get_fp() if fp: key_i = 0 for i, seckey in enumerate(seckeys): if seckey['fp'] == fp: key_i = i self.key_selection.setCurrentIndex(key_i) # buttons self.buttons_layout = QtGui.QHBoxLayout() self.sign_save_button = QtGui.QPushButton('Save and Sign') self.sign_save_button.clicked.connect(self.sign_save_clicked) self.sign_once = QtGui.QPushButton('One-Time Sign') self.sign_once.clicked.connect(self.sign_once_clicked) self.buttons_layout.addWidget(self.sign_save_button) self.buttons_layout.addWidget(self.sign_once) # headlines controls. self.headline_controls_layout = QtGui.QHBoxLayout() for hl_control in self.headlines_controls: self.headline_controls_layout.addWidget(hl_control) # layout self.layout = QtGui.QVBoxLayout() self.layout.addLayout(self.date_layout) self.layout.addLayout(self.status_layout) self.layout.addWidget(self.textbox) self.layout.addLayout(self.headline_controls_layout) self.layout.addWidget(self.key_selection) self.layout.addLayout(self.buttons_layout) self.setLayout(self.layout) self.show()
class SettingsWindow(QWidget): def __init__(self, settings: Settings = None): super(SettingsWindow, self).__init__() if settings: self.settings = settings else: self.settings = Settings() self.init_widgets() def set_value(self, widget, param): try: value = type(self.settings.get_value(param))(widget.text( ) if type(widget) == QLineEdit else widget.toPlainText()) self.settings.set_val(param, value) widget.setStyleSheet('background: white') except ValueError: widget.setStyleSheet('background: pink') def set_list(self, widget, param): try: value = (widget.text() if type(widget) == QLineEdit else widget.toPlainText()).split('\n') self.settings.set_val(param, value) widget.setStyleSheet('background: white') except: widget.setStyleSheet('background: pink') def text_changed(self, *args): editor_iterator = iter(self.editor_widgets) for param, value in self.settings.__dict__.items(): if type(value) == list: self.set_list(editor_iterator.__next__(), param) else: self.set_value(editor_iterator.__next__(), param) def init_widgets(self): self.label_font = QFont('Arial', 12) self.label_font.setBold(True) self.editor_font = QFont('Arial', 12) self.grid = QGridLayout() self.editor_widgets = [] for param, value in self.settings.__dict__.items(): editor_name = param.replace('_', ' ').capitalize() label = QLabel(editor_name) label.setFont(self.label_font) if type(value) == list: editor = QTextEdit('\n'.join(self.settings.get_value(param))) editor.textChanged.connect(self.text_changed) else: editor = QLineEdit(str(self.settings.get_value(param))) editor.textChanged.connect(self.text_changed) editor.setFont(self.editor_font) self.grid.addWidget(label, len(self.editor_widgets), 0) self.grid.addWidget(editor, len(self.editor_widgets), 1) self.editor_widgets.append(editor) self.setLayout(self.grid)
def run_game(): radio = pygame.mixer radio.init() pygame.init() settings = Settings() screen = pygame.display.set_mode( (settings.screen_width, settings.screen_height)) pygame.display.set_caption("Mario") clips = [ radio.Sound('sounds/bg_music.wav'), radio.Sound('sounds/block_bump.wav'), radio.Sound('sounds/brick_break.wav'), radio.Sound('sounds/coin.wav'), radio.Sound('sounds/death.wav'), radio.Sound('sounds/extra_life.wav'), radio.Sound('sounds/fireball.wav'), radio.Sound('sounds/jump.wav'), radio.Sound('sounds/kill.wav'), radio.Sound('sounds/pipe.wav'), radio.Sound('sounds/power_spawn.wav'), radio.Sound('sounds/powerup.wav'), radio.Sound('sounds/stage_clear.wav'), radio.Sound('sounds/star.wav') ] pipes = Group() secret_pipes = Group() bricks = Group() secret_bricks = Group() upgrades = Group() enemies = Group() poles = Group() fireballs = Group() flags = Group() ground = Group() # + stats = Stats() for i in range(6, 8): pipe = Pipe(screen, settings, i) secret_pipes.add(pipe) # Create and initialize flag and pole before storing in group flag = Flag(screen, settings, stats) flags.add(flag) pole = Pole(screen, settings) poles.add(pole) mario = Mario(screen, settings, pipes, bricks, upgrades, stats, enemies, poles, radio, clips, fireballs, secret_bricks, secret_pipes, ground) lvl_map = None level = Level(screen, settings, pipes, lvl_map, bricks, upgrades, enemies, flags, poles) display = Display(screen, stats) clips[0].play(-1) while True: # Checks if Mario is in the main level and sets the map, generate the bricks, pipes, flags, and pole # Does this only once if stats.activate_main_lvl: lvl_map = Map(screen, settings, bricks, pipes, mario, enemies, ground, upgrades, stats, secret_bricks) lvl_map.build_brick() # generate pipes and flag/pole for i in range(0, 6): pipe = Pipe(screen, settings, i) pipes.add(pipe) flag = Flag(screen, settings, stats) flags.add(flag) pole = Pole(screen, settings) poles.add(pole) stats.activate_main_lvl = False # Checks if Mario has activated the secret level and sets the map, clears all of the main level # Does this only once if stats.activate_secret: # Clears everything belonging to main level to prevent lag pipes.empty() bricks.empty() enemies.empty() poles.empty() flags.empty() lvl_map = Map(screen, settings, bricks, pipes, mario, enemies, ground, upgrades, stats, secret_bricks) lvl_map.build_brick() stats.activate_secret = False stats.main_level = False if stats.game_active: gf.check_events(mario, stats, clips, fireballs) # If the player gets near the right side, shift the world left (-x) if mario.rect.right >= 600 and stats.main_level: diff = mario.rect.right - 600 mario.rect.right = 600 level.shifting_world(-diff) # If the player gets near the left side, shift the world right (+x) # if mario.rect.left <= 100: # diff = 100 - mario.rect.left # mario.rect.left = 100 # level.shifting_world(diff) gf.update_screen(screen, mario, settings, level, pipes, display, stats, bricks, upgrades, enemies, flags, poles, radio, clips, fireballs, secret_bricks, secret_pipes) pygame.display.flip()
def run_game(): # 初始化游戏并创建一个屏幕对象:初始化背景设置,让Pygame能够正确地工作 pygame.init() # 初始化全部音频,并加载爆炸声音乐 pygame.mixer.init() # 爆炸声 explode_sound = pygame.mixer.Sound("sound\EXPLO6.wav") # 子弹射击的声音 bullet_sound = pygame.mixer.Sound("sound\shot1.wav") pw_settings = Settings() """实参(1200, 800)是一个元组,指定了游戏窗口的尺寸。 通过将这些尺寸值传递给pygame.display.set_mode() 我们创建了一个宽1200像素、高800像素的游戏窗口""" """调用pygame.display.set_mode()来创建一个名为screen的显示窗口, 这个游戏的所有图形元素都将在其中绘制。每个元素(如外星人或飞船)都是一个surface对象""" screen = pygame.display.set_mode( (pw_settings.screen_width, pw_settings.screen_height)) # 窗口标题 pygame.display.set_caption('Plane War') # 创建Play按钮 play_button = Button(pw_settings, screen, "Play") # 创建一个用于存储游戏统计信息的实例,并创建记分牌 stats = GameStats(pw_settings) sb = Scoreboard(pw_settings, screen, stats) # 创建一艘飞船、一个子弹编组和一个外星人编组 # 创建一艘飞船 ship = Ship(pw_settings, screen) # 创建一个用于存储子弹的编组,添加进去实例后对bullets调用 就能对bullets里面的每个bullet调用 bullets = Group() # 创建一个外星人编组 aliens = Group() # 创建外星人群 gf.create_fleet(pw_settings, screen, aliens) timer = 1 # 开始游戏的主循环 while True: timer += 1 gf.check_events(pw_settings, screen, stats, sb, play_button, ship, aliens, bullets, bullet_sound) if stats.game_active: ship.update() gf.update_bullets(pw_settings, screen, stats, sb, ship, aliens, bullets, explode_sound) gf.update_aliens(pw_settings, screen, stats, sb, ship, aliens, bullets) gf.update_screen(pw_settings, screen, stats, sb, ship, aliens, bullets, play_button)
"""All the files are integrated here.""" # Local files import keyboard from settings import Settings from model import model, load_model, train_model from realtime import Realtime print('Everything is successfully imported') settings = Settings() print('Settings is done') model = load_model() print('Model is loaded') realtime = Realtime(settings) print('Realtime is done') print('start') while True: if keyboard.is_pressed('q'): break realtime.refresh_audio() y = model.predict(realtime.x) realtime.check_trigger(y) print('Done')
class AlienInvasion: """Overall class to manage game assets and behavior.""" def __init__(self): """Initialize the game, and create game resources.""" pygame.init() self.settings = Settings() self.screen = pygame.display.set_mode( (self.settings.screen_width, self.settings.screen_height)) # self.screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN) # self.settings.screen_width = self.screen.get_rect().width # self.settings.screen_height = self.screen.get_rect().height pygame.display.set_caption("Alien Invasion") # Create an instance to store game statistics self.stats = GameStats(self) self.sb = Scoreboard(self) self.ship = Ship(self) self.bullets = pygame.sprite.Group() self.aliens = pygame.sprite.Group() self._create_fleet() # Make the play button. self.play_button = Button(self, "Play") def run_game(self): """Start the main loop for the game.""" while True: self._check_envents() if self.stats.game_active: self.ship.update() self._update_bullets() self._update_aliens() self._update_screen() def _check_envents(self): """Respond to keypresses and mouse events.""" # Watch for keyboard and mouse events. for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.KEYDOWN: self._check_keydown_events(event) elif event.type == pygame.KEYUP: self._check_keyup_events(event) elif event.type == pygame.MOUSEBUTTONDOWN: mouse_pos = pygame.mouse.get_pos() self._check_play_button(mouse_pos) def _check_play_button(self, mouse_pos): """Start a new game when the player clicks Play""" button_clicked = self.play_button.rect.collidepoint(mouse_pos) if button_clicked and not self.stats.game_active: # Reset the game settings. self.settings.initialize_dynamic_settings() # Reset the game statistics. self.stats.reset_stats() self.stats.game_active = True self.sb.prep_score() self.sb.prep_level() self.sb.prep_ships() # Get rid of any remaining aliens and bullets self.aliens.empty() self.bullets.empty() # Create a new fleet and center the ship. self._create_fleet() self.ship.center_ship() # Hide the mouse cursor. pygame.mouse.set_visible(False) def _check_keydown_events(self, event): if event.key == pygame.K_RIGHT: self.ship.moving_right = True elif event.key == pygame.K_LEFT: self.ship.moving_left = True elif event.key == pygame.K_q: sys.exit() elif event.key == pygame.K_SPACE: self._fire_bullet() def _check_keyup_events(self, event): if event.key == pygame.K_RIGHT: self.ship.moving_right = False elif event.key == pygame.K_LEFT: self.ship.moving_left = False def _fire_bullet(self): """Create a new bullet and add it to the bullets group.""" if len(self.bullets) < self.settings.bullets_allowed: new_bullet = Bullet(self) self.bullets.add(new_bullet) def _update_bullets(self): """Update position of bullets and get rid of old bullets.""" # Update bullet positions. self.bullets.update() # Get rid of bullets that have disappeared. for bullet in self.bullets.copy(): if bullet.rect.bottom <= 0: self.bullets.remove(bullet) # Check for any bullets that have hit aliens. # If so, get rid of the bullet and the alien. self._check_bullet_alien_collisions() def _check_bullet_alien_collisions(self): """Respond to bullet-alien collisions.""" # Remove any bullets and aliens that have collided. collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, True) if collisions: for aliens in collisions.values(): self.stats.score += self.settings.alien_points * len(aliens) self.sb.prep_score() self.sb.check_high_score() if not self.aliens: # Destroy existing bullets and create new fleet. self.bullets.empty() self._create_fleet() self.settings.increase_speed() # Increase level. self.stats.level += 1 self.sb.prep_level() def _update_aliens(self): """update the positions of all aliens in the fleet.""" self._check_fleet_edges() self.aliens.update() # Look for alien-ship collisions. if pygame.sprite.spritecollideany(self.ship, self.aliens): self._ship_hit() # Look for aliens htting the bottom of the screen. self._check_aliens_bottom() def _create_fleet(self): """Create the fleet of aliens.""" # Make an alien. alien = Alien(self) alien_width, alien_height = alien.rect.size available_space_x = self.settings.screen_width - (2 * alien_width) number_aliens_x = available_space_x // (2 * alien_width) # Determine the number of rows of aliens that fit on the screen. ship_height = self.ship.rect.height available_space_y = (self.settings.screen_height - (3 * alien_height) - ship_height) number_rows = available_space_y // (2 * alien_height) # Create the full fleet of aliens. for row_number in range(number_rows): # Create the first row of aliens. for alien_number in range(number_aliens_x): self._create_alien(alien_number, row_number) def _create_alien(self, alien_number, row_number): """Create an alien and place it in the row.""" alien = Alien(self) alien_width, alien_height = alien.rect.size alien.x = alien_width + 2 * alien_width * alien_number alien.rect.x = alien.x alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number self.aliens.add(alien) def _check_fleet_edges(self): """Respond appropriately if any aliens have reched an edge.""" for alien in self.aliens.sprites(): if alien.check_edges(): self._change_fleet_direction() break def _change_fleet_direction(self): """Drop the entire fleet and change the fleet's direction.""" for alien in self.aliens.sprites(): alien.rect.y += self.settings.fleet_drop_speed self.settings.fleet_direction *= -1 def _check_aliens_bottom(self): """Check if any aliens have reached the bottom of the screen.""" screen_rect = self.screen.get_rect() for alien in self.aliens.sprites(): if alien.rect.bottom >= screen_rect.bottom: # Treat this the same as if the ship got hit. self._ship_hit() break def _ship_hit(self): """Respond to the ship being hit by an alien.""" if self.stats.ships_left > 0: # Decrement ship_left, and update scoreoard self.stats.ships_left -= 1 self.sb.prep_ships() # Get rif of any remaining aliens and bullets. self.aliens.empty() self.bullets.empty() # Create a new fleet and center the ship self._create_fleet() self.ship.center_ship() # Pause. sleep(1) else: self.stats.game_active = False pygame.mouse.set_visible(True) def _update_screen(self): """Update image on the screen, and flip to the new screen.""" # Redraw the screen during each pass through the loop. self.screen.fill(self.settings.bg_color) self.ship.blitme() for bullet in self.bullets.sprites(): bullet.draw_bullet() self.aliens.draw(self.screen) # Draw the score information. self.sb.show_score() #Draw the play button if the game is inactive. if not self.stats.game_active: self.play_button.draw_button() # Make the most recently drawn screen visible. pygame.display.flip()
import matplotlib.pyplot as plt # SQUEEZESEG DATASET # Channels description: # 0: X # 1: Y # 2: Z # 3: REFLECTANCE # 4: DEPTH # 5: LABEL # imports Settings manager sys.path.append('./') import data_loader from settings import Settings CONFIG = Settings(required_args=["config"]) # Generates tfrecords for training def make_tfrecord(): # Creates each tfrecord (train and val) list_subfolders_with_paths = [f[0] for f in os.walk(CONFIG.DATA_ROOT_PATH)] train_folder_name = open(CONFIG.DATA_ROOT_PATH + "train.txt", "r") val_folder_name = open(CONFIG.DATA_ROOT_PATH + "val.txt", "r") test_folder_name = open(CONFIG.DATA_ROOT_PATH + "test.txt", "r") train_image_idx = [] val_image_idx = [] test_image_idx = [] for subfolder in train_folder_name: