def __launch(delegate): ''' Runs the given (no-argument) delegate method in a 'safe' script environment. This environment will take care of all error handling, logging/debug stream, and other standard initialization behaviour before delegate() is called, and it will take care of cleaning everything up afterwards. ''' try: # initialize the application resources (import directories, etc) Resources.initialize() # fire up the debug logging system log.install(ComicRack.MainWindow) # install a handler to catch uncaught Winforms exceptions def exception_handler(sender, event): log.handle_error(event.Exception) Application.ThreadException \ += ThreadExceptionEventHandler(exception_handler) # fire up the localization/internationalization system i18n.install(ComicRack) # see if we're in a valid environment if __validate_environment(): delegate() except Exception, ex: log.handle_error(ex)
def __init__(self): ''' Creates a _PictureBoxPanel. Call set_image after initialization. ''' # the left and right arrow Image objects self.__left_arrow = Resources.createArrowIcon(True, False) self.__full_left_arrow = Resources.createArrowIcon(True, True) self.__right_arrow = Resources.createArrowIcon(False, False) self.__full_right_arrow = Resources.createArrowIcon(False, True) # the vertical line boundary between the full_left and left arrow's # 'clickable columns' and the full_right and right arrow's. self.__left_bound = 0; self.__right_bound = 0; # the image attributes to use for drawing non-alpha blended images self.__hovered_image_atts = None # the image attributes to use for drawing alpha blended images self.__normal_image_atts = None # a string indicating whether the mouse is hovered over the full # left ('FL'), left ('L'), right ('R'), or full right ('FR') side of # this panel, or None if the mouse isn't over the panel at all. self.__mouse_hovered_state = None # our PictureBox object, which we center and stretch as needed self._picbox = None Panel.__init__(self) self.__build_gui()
def create_tribe(name, user, carte): """ Initialise une tribe (à utiliser après la création d'un compte) """ tribe = Tribe(name=name, leader=user) tribe.save() resources_initiales = Resources( wood=INIT_TRIBE_RESOURCES['wood'], food=INIT_TRIBE_RESOURCES['food'], silex=INIT_TRIBE_RESOURCES['silex'], skin=INIT_TRIBE_RESOURCES['skin'] ) resources_initiales.save() village = Village.create_village(tribe, first=True) inhabitants = Group.objects.create( position=village.position, village=village, ) village.inhabitants = inhabitants for key in INIT_TRIBE_UNITS: new_pile = UnitStack( unit_type=UnitType.objects.get(identifier__iexact=key), group=inhabitants, number=INIT_TRIBE_UNITS[key], ) new_pile.save() village.update_income() return tribe
def receive_resources(self, resources): """ add the resources to the village create a new object resources with this values and return it """ max_resources = self.max_resources_storage() transfered_resources = Resources( food=min( resources.food, max_resources.food - int(self.resources.food), ), wood=min( resources.wood, max_resources.wood - int(self.resources.wood), ), silex=min( resources.silex, max_resources.silex - int(self.resources.silex), ), skin=min( resources.skin, max_resources.skin - int(self.resources.skin), ), ) #need to create a new instance of resources to remember for the report transfered_resources.pk = None transfered_resources.save() self.resources += transfered_resources self.resources.save() self.plan_next_starvation() return transfered_resources
def select_oldest(cloud, args): if cloud and args is not None: resources = Resources(cloud) age_resources = SelectAgeRelatedResources(cloud) age_resources.select_old_instances( datetime.timedelta(hours=args.old_active), datetime.timedelta(hours=args.old_inactive), datetime.timedelta(days=args.old_permanent), datetime.timedelta(hours=args.old_inerrror) ) old_resources = age_resources.get_selection() new_search_prefix = None oldest = None if 'instances' in old_resources: for instance in old_resources['instances']: rec = old_resources['instances'][instance] if rec is None: continue if oldest is None or oldest > rec['created_on']: oldest = rec['created_on'] new_search_prefix = rec['name'] logging.info('Found Old instance [{}] created on [{}] age [{}]' .format(rec['name'], rec['created_on'], str(rec['age']))) if oldest is not None: substring = get_substr_from_name(new_search_prefix) resources.select_resources(substring) return resources return None
class PlannerFrame(wx.Frame): def __init__(self, parent, id=wx.ID_ANY, title="", pos = wx.DefaultPosition, size = wx.DefaultSize, style = wx.DEFAULT_FRAME_STYLE, name = "PlannerFrame"): super(PlannerFrame, self).__init__(parent, id, title, pos, size, style, name) self._parent = parent self._title = title self._resources = Resources(_plannerDataDir+_ResourcesFileName) self._fundingSources = FundingSources(_plannerDataDir+_FundingSourcesFileName) self._allocations = AllocationSet(_plannerDataDir+_Allocations) # Create MenuBar menuBar = wx.MenuBar() # Create File Menu fileMenu = wx.Menu() menuExit = fileMenu.Append(wx.ID_EXIT, "E&xit"," Terminate the program") menuSave = fileMenu.Append(wx.ID_SAVE, "&Save", "Save Resources and Funding Sources") fileMenu.AppendSeparator() # Create View Menu viewMenu = wx.Menu() PLN_RESOURCES = wx.NewId() PLN_FUNDINGSOURCES = wx.NewId() menuResources = viewMenu.Append(PLN_RESOURCES, "&Resources", "Bring up Resources Panel") menuFundingSources = viewMenu.Append(PLN_FUNDINGSOURCES, "F&unding Sources", "Bring up Funding Sources Panel") menuBar.Append(fileMenu, "&File") menuBar.Append(viewMenu, "&View") self.SetMenuBar(menuBar) self.CreateStatusBar() # File Menu Items self.Bind(wx.EVT_MENU, self.OnExit, menuExit) self.Bind(wx.EVT_MENU, self.OnSave, menuSave) # View Menu Items self.Bind(wx.EVT_MENU, self.OnResources, menuResources) self.Bind(wx.EVT_MENU, self.OnFundingSources, menuFundingSources) self.Show(True) def OnExit(self, e): sys.exit() def OnSave(self, e): self._resources.write() print "Resources Saved" self._fundingSources.write() print "Funding Sources Saved" def OnResources(self, e): self._resourcesWindow = SelectionListbox(self, self._resources) def OnFundingSources(self, e): self._fundingSourcesWindow = SelectionListbox(self, self._fundingSources)
def updateEncryptionLock(self, msgid, encryption=None): if encryption is None: return if encryption == '': lock_icon_path = Resources.get('unlocked-darkgray.png') else: lock_icon_path = Resources.get('locked-green.png' if encryption == 'verified' else 'locked-red.png') script = "updateEncryptionLock('%s','%s')" % (msgid, lock_icon_path) self.executeJavaScript(script)
def __init__(self, window): QWebView.__init__(self) self.window = window with open(Resources.get_path("leftpane.js"), "r") as f: self.js = f.read() self.setFixedWidth(0) self.setVisible(False) # We don't want plugins for this simple pane self.settings().setAttribute(QWebSettings.PluginsEnabled, False) self.setUrl(QUrl.fromLocalFile(Resources.get_path("leftpane.html"))) self.page().currentFrame().addToJavaScriptWindowObject("leftPane", self) self.page().currentFrame().evaluateJavaScript(self.js)
def word_sim(self, w1, w2, simtype): if (w1, w2) in AlignAndPenalize.word_cache: return AlignAndPenalize.word_cache[(w1, w2)] # context-free similarity if w1 == w2 or Resources.is_num_equivalent(w1, w2) or Resources.is_pronoun_equivalent(w1, w2): AlignAndPenalize.word_cache[(w1, w2)] = 1 AlignAndPenalize.word_cache[(w2, w1)] = 1 return 1 sim = self.similarities[simtype].word_sim(w1, w2) if sim is None and self.fallback_similarity: sim = self.fallback_similarity.word_sim(w1, w2) elif sim is None: sim = 0.0 return sim
def __init__(self, parent = None, settings_path = ""): super(ScudCloud, self).__init__(parent) self.setWindowTitle('ScudCloud') self.settings_path = settings_path self.notifier = Notifier(Resources.APP_NAME, Resources.get_path('scudcloud.png')) self.settings = QSettings(self.settings_path + '/scudcloud.cfg', QSettings.IniFormat) self.identifier = self.settings.value("Domain") if Unity is not None: self.launcher = Unity.LauncherEntry.get_for_desktop_id("scudcloud.desktop") else: self.launcher = DummyLauncher(self) self.webSettings() self.leftPane = LeftPane(self) self.stackedWidget = QtGui.QStackedWidget() centralWidget = QtGui.QWidget(self) layout = QtGui.QHBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.addWidget(self.leftPane) layout.addWidget(self.stackedWidget) centralWidget.setLayout(layout) self.setCentralWidget(centralWidget) self.startURL = Resources.SIGNIN_URL if self.identifier is not None: self.startURL = self.domain() self.addWrapper(self.startURL) self.addMenu() self.tray = Systray(self) self.systray(ScudCloud.minimized) self.installEventFilter(self) self.statusBar().showMessage('Loading Slack...')
def __init__(self, parent = None, settings_path = ""): super(zcswebapp, self).__init__(parent) self.setWindowTitle('zcswebapp') self.settings_path = settings_path self.notifier = Notifier(Resources.APP_NAME, Resources.get_path('zcswebapp.png')) self.settings = QSettings(self.settings_path + '/zcswebapp.cfg', QSettings.IniFormat) self.identifier = self.settings.value("Domain") if Unity is not None: self.launcher = Unity.LauncherEntry.get_for_desktop_id("zcswebapp.desktop") else: self.launcher = DummyLauncher(self) self.webSettings() self.leftPane = LeftPane(self) webView = Wrapper(self) webView.page().networkAccessManager().setCookieJar(self.cookiesjar) self.stackedWidget = QtGui.QStackedWidget() self.stackedWidget.addWidget(webView) centralWidget = QtGui.QWidget(self) layout = QtGui.QHBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.addWidget(self.leftPane) layout.addWidget(self.stackedWidget) centralWidget.setLayout(layout) self.setCentralWidget(centralWidget) self.addMenu() self.tray = Systray(self) self.systray(zcswebapp.minimized) self.installEventFilter(self) if self.identifier is None: webView.load(QtCore.QUrl(Resources.SIGNIN_URL)) else: webView.load(QtCore.QUrl(self.domain())) webView.show()
def set_image(self, image): ''' Sets a new image for this _PictureBoxPanel to display. If this image is None, a default logo will be displayed. Any previous image that was set will have its Dispose() method called before it is discarded. ''' if not image: image = Resources.createComicVineLogo() self._ratio = 0; if image and float(image.Height): self._ratio = float(image.Width) / float(image.Height) if not self._ratio: self._ratio =1.55 # dispose the old image, if need be if self._picbox.Image: self._picbox.Image.Dispose() self._picbox.Image = image self.OnResize(None) # update our mouse cursor comicform = self.Parent if comicform != None: self.Cursor = Cursors.Hand if comicform._can_change_page(True) or \ comicform._can_change_page(False) else None
def __init__(self, title, resources=None, other=None): self.title = title self.parent = None if resources is None: self.resources = Resources() else: self.resources = resources self.other = other self.wid_delete_btn = widgets.Button(description='Delete', margin="8px") self.wid_delete_btn._gem_ctx = self def yes_cb(model): parent = model.parent_get() parent.model_del(model) def no_cb(model): return def model_delete_cb(model_delete_cb): metys_confirm("Delete '%s' model, confirm it ?" % self.title, yes_cb, no_cb, self) return self.wid_delete_btn.on_click(model_delete_cb) wid_label = widgets.Label(value="Model:") self.widget = widgets.VBox(children=[ self.resources.widget_get(), wid_label, self.wid_delete_btn])
def achieve_mission_found(self): if not self.group.resources or\ self.group.position.village_set.count() >= NB_VILLAGES_PER_TILE\ or self.group.resources <\ Resources.dict_to_resources(VILLAGE_CREATION_NEEDED_RESOURCES): self.come_back() self.group.log_report( type=11, subject='Impossible de créer le village', body='Tous les emplacements de la case' ' sélectionnée sont occupés ou bien ' 'vous ne disposez pas de suffisamment de ressources', ) v = Village( name="New village", inhabitants=self.group, resources=Resources.objects.create(), tribe=self.group.village.tribe, position=self.group.position, ) v.resources.save() v.save() v.update_income() self.group.village = v self.group.save() update_resources = v.receive_resources(self.group.resources) update_resources.save() self.group.resources = update_resources self.group.resources -= v.receive_resources(self.group.ressources) self.group.resources.save()
def __init__(self, window): QWebView.__init__(self) self.window = window with open(Resources.get_path("leftpane.js"), "r") as f: self.js = f.read() # We don't want plugins for this simple pane self.settings().setAttribute(QWebSettings.PluginsEnabled, False) self.reset()
def calcadjvals(self): self.setadjpoints() adjvals = [] if self.scentview: for point in self.adjpoints: shortestdist = Resources.calcdistance(point, self.scentview[0].rect.center) normalizeddist = shortestdist/(self.current_scent_dist * math.sqrt(2)) adjvals.append(1 - normalizeddist) return adjvals
def __init__(self, window): self.configure_proxy() QWebView.__init__(self) self.window = window with open(Resources.get_path("scudcloud.js"), "r") as f: self.js = f.read() self.setZoomFactor(self.window.zoom) self.page().setLinkDelegationPolicy(QtWebKit.QWebPage.DelegateAllLinks) self.connect(self, SIGNAL("urlChanged(const QUrl&)"), self.urlChanged) self.connect(self, SIGNAL("linkClicked(const QUrl&)"), self.linkClicked) self.addActions()
def urlChanged(self, qUrl): url = qUrl.toString() # Some integrations/auth will get back to /services with no way to get back to chat if Resources.SERVICES_URL_RE.match(url): self.systemOpen(url) self.load(QUrl("https://"+qUrl.host()+"/messages/general")) else: self.settings().setUserStyleSheetUrl(QUrl.fromLocalFile(Resources.get_path("login.css"))) self.inject() # Save the loading team as default if url.endswith("/messages"): self.window.settings.setValue("Domain", 'https://'+qUrl.host())
def filter_tokens(self, tokens): new_tok = [] for token in tokens: word = token['token'] if self.conf.getboolean('global', 'remove_stopwords') and word in Resources.stopwords: continue if self.conf.getboolean('global', 'remove_punctuation') and word in Resources.punctuation: continue if self.conf.getboolean('global', 'filter_frequent_adverbs') and Resources.is_frequent_adverb(word, token['pos']): continue new_tok.append(token) return new_tok
def play_hangup(self): settings = SIPSimpleSettings() if settings.audio.silent: return if time.time() - self.last_hangup_tone_time > HANGUP_TONE_THROTLE_DELAY: hangup_tone = WavePlayer(SIPApplication.voice_audio_mixer, Resources.get('hangup_tone.wav'), volume=30) NotificationCenter().add_observer(self, sender=hangup_tone, name="WavePlayerDidEnd") SIPApplication.voice_audio_bridge.add(hangup_tone) hangup_tone.start() self.last_hangup_tone_time = time.time()
def showMessage(self, call_id, msgid, direction, sender, icon_path, text, timestamp, is_html=False, state='', recipient='', is_private=False, history_entry=False, media_type='chat', encryption=None): lock_icon_path = '' if encryption is not None: if encryption == '': lock_icon_path = Resources.get('unlocked-darkgray.png') else: lock_icon_path = Resources.get('locked-green.png' if encryption == 'verified' else 'locked-red.png') if not history_entry and not self.delegate.isOutputFrameVisible(): self.delegate.showChatViewWhileVideoActive() # keep track of rendered messages to toggle the smileys or search their content later rendered_message = ChatMessageObject(call_id, msgid, text, is_html, timestamp, media_type) self.rendered_messages.append(rendered_message) if timestamp.date() != datetime.date.today(): displayed_timestamp = time.strftime("%F %T", time.localtime(calendar.timegm(timestamp.utctimetuple()))) else: displayed_timestamp = time.strftime("%T", time.localtime(calendar.timegm(timestamp.utctimetuple()))) text = processHTMLText(text, self.expandSmileys, is_html) private = 1 if is_private else "null" if is_private and recipient: label = 'Private message to %s' % cgi.escape(recipient) if direction == 'outgoing' else 'Private message from %s' % cgi.escape(sender) else: if hasattr(self.delegate, "sessionController"): label = cgi.escape(self.delegate.sessionController.nickname or self.account.display_name or self.account.id) if sender is None else cgi.escape(sender) else: label = cgi.escape(self.account.display_name or self.account.id) if sender is None else cgi.escape(sender) script = """renderMessage('%s', '%s', '%s', '%s', "%s", '%s', '%s', %s, '%s')""" % (msgid, direction, label, icon_path, text, displayed_timestamp, state, private, lock_icon_path) if self.finishedLoading: self.executeJavaScript(script) else: self.messageQueue.append(script) if hasattr(self.delegate, "chatViewDidGetNewMessage_"): self.delegate.chatViewDidGetNewMessage_(self)
def init_configurations(self): account_manager = AccountManager() settings = SIPSimpleSettings() self.notification_center.add_observer(self, sender=settings) # fixup default account self._selected_account = account_manager.default_account if self._selected_account is None: self._selected_account = account_manager.get_accounts()[0] default_ca = open(Resources.get('ca.crt'), "r").read().strip() self.set_default_certificate_authority(default_ca)
def filter_tokens(self, tokens): new_tok = [] for token in tokens: word = token["token"] if self.conf.getboolean("global", "remove_stopwords") and word in Resources.stopwords: continue if self.conf.getboolean("global", "remove_punctuation") and word in Resources.punctuation: continue if self.conf.getboolean("global", "filter_frequent_adverbs") and Resources.is_frequent_adverb( word, token["pos"] ): continue new_tok.append(token) return new_tok
def __init__( self, name, parent ): StateNode.__init__( self, name, parent, initialState = System.STATE_STOPPED ) self.log = Logger().get_instance( self.__class__.__name__ ) self.config = Configuration( 'config', self ) self.config.addListener( self ) self.network = MessageAdapter( 'msg_net', self ) self.network.addListener( self ) self.resources = Resources( 'resources', self ) self.resources.addListener( self ) self.addListener( parent )
def __init__(self, window): self.configure_proxy() QWebView.__init__(self) self.window = window with open(Resources.get_path("scudcloud.js"), "r") as f: self.js = f.read() self.setZoomFactor(self.window.zoom) self.page().setLinkDelegationPolicy(QtWebKit.QWebPage.DelegateAllLinks) self.urlChanged.connect(self._urlChanged) self.loadStarted.connect(self._loadStarted) self.loadFinished.connect(self._loadFinished) self.linkClicked.connect(self._linkClicked) self.page().featurePermissionRequested.connect(self.permissionRequested) self.addActions()
def take_resources(self, village_or_group, resources_dict): """ Substract the max resources up to resources_dict content to the village_or_group’s resources and set it in a new resources object which is returned """ for key in resources_dict: resources_dict[key] = max(resources_dict[key], 0) available_resources = village_or_group.resources wanted_resources = Resources.dict_to_resources(resources_dict) if available_resources >= wanted_resources: available_resources -= wanted_resources available_resources.save() wanted_resources.save() return wanted_resources else: received_resources = Resources() for key in wanted_resources: amount = min(wanted_resources[key], available_resources[key]) received_resources[key] = amount available_resources -= amount available_resources.save() received_resources.save() return received_resources()
def main(): root = Tk() root.geometry("250x150+300+300") sl = Resources("/users/swiftb/dev/Planner/data/testresources.txt") res = Resource("{'UID': '1', 'First Name': 'Brian', 'Last Name': 'Swift', 'Location': 'CHI'}") sl.add(res) res = Resource("{'UID': '2', 'First Name': 'John', 'Last Name': 'DeValk', 'Location': 'CHI'}") sl.add(res) sl.write() print sl._resources mc = SelectionListbox(root, sl) root.mainloop()
def init_configurations(self): account_manager = AccountManager() settings = SIPSimpleSettings() # fixup default account self._selected_account = account_manager.default_account if self._selected_account is None: self._selected_account = account_manager.get_accounts()[0] # save default ca if needed ca = open(Resources.get('ca.crt'), "r").read().strip() try: X509Certificate(ca) except GNUTLSError, e: BlinkLogger().log_error(u"Invalid Certificate Authority: %s" % e) return
def main(): app = wx.App() ress = Resources("/users/swiftb/dev/Planner/data/testresources.txt") res = Resource("{'UID': '1', 'First Name': 'Brian', 'Last Name': 'Swift', 'Location': 'CHI'}") ress.add(res) res = Resource("{'UID': '2', 'First Name': 'John', 'Last Name': 'DeValk', 'Location': 'CHI'}") ress.add(res) ress.write() print ress._resources mc = SelectionFrame(None, ress) app.MainLoop()
def urlChanged(self, qUrl): url = qUrl.toString() # Some integrations/auth will get back to /services with no way to get back to chat if Resources.SERVICES_URL_RE.match(url): self.systemOpen(url) self.load(QUrl("https://"+qUrl.host()+"/messages/general")) else: self.settings().setUserStyleSheetUrl(QUrl.fromLocalFile(Resources.get_path("login.css"))) self.page().currentFrame().addToJavaScriptWindowObject("desktop", self) boot_data = self.page().currentFrame().evaluateJavaScript(self.js) self.window.quicklist(boot_data['channels']) self.window.teams(boot_data['teams']) self.window.enableMenus(self.isConnected()) # Save the loading team as default if url.endswith("/messages"): self.window.settings.setValue("Domain", 'https://'+qUrl.host())
class House(Building): cost = Resources({Wood: 100}) size = (2, 2) letter_abbreviation = 'H' kind = 'house' time_to_build = 30
cleanup_resources(cloud, cleanup, dry_run=False) if __name__ == '__main__': parser = create_parser() args = parser.parse_args() pp = pprint.PrettyPrinter(indent=4) now = datetime.datetime.now(pytz.utc) set_logging(args.debug) cloud = initialize_cloud(args.cloud) resources = Resources(cloud) if args.floatingips: resources.select_floatingips_unattached() cleanup = resources.get_selection() do_cleanup(cloud, cleanup, pp, args) resources = Resources(cloud) if args.old_instances: resources = select_oldest(cloud, args) cleanup = resources.get_selection() do_cleanup(cloud, cleanup, pp, args) resources = Resources(cloud) if args.unused: resources.select_resources('')
print(" " + str(mech)) mech_list.append(mech) # sort list alphabetically by name mech_list = sorted(mech_list, key=lambda x: x.name) # director must be initialized before any cocos elements can be created director.init(width=1024, height=768, resizable=True, autoscale=False) director.show_FPS = True # initialize the audio mixer pygame.mixer.init(44100, -16, 2, 2048) pygame.mixer.set_num_channels(32) # preload all sound and image resources Resources.preload() # setup custom mouse cursor cursor = pyglet.window.ImageMouseCursor(Resources.mouse_pointer, 1, 17) director.window.set_mouse_cursor(cursor) board = Board() battle = Battle() ui = Interface() battle.setBoard(board) key_events = events.KeyboardEvents(battle) mouse_events = events.MouseEvents(battle) # set up test players player = Player("Human", team=0)
class Area: def __init__(self): self.resources = Resources() self.number_of_tiles = 10 self.tile_size = self.resources.floor_size self.size = self.tile_size * self.number_of_tiles self.tiles = [] self.floors = [] self.walls = [] self.turn_count = 0 def create_map(self): self.random_map() self.tiles = [] for i in range(self.number_of_tiles): for j in range(self.number_of_tiles): tile = [] position = j * self.number_of_tiles + i if position in self.walls: tile.append(Wall()) else: tile.append(Floor()) tile.append(position) x = self.tile_size * j y = self.tile_size * i tile[0].x = x tile[0].y = y tile.append([x, y]) self.tiles.append(tile) def draw_map(self, canvas): self.create_map() for tile in self.tiles: if isinstance(tile[0], Floor): img = self.resources.get_image('floor') elif isinstance(tile[0], Wall): img = self.resources.get_image('wall') canvas.create_image(tile[2][1], tile[2][0], anchor=NW, image=img) def draw_character(self, canvas, character): if isinstance(character, Monster): img = self.resources.get_image(character.__class__.__name__) else: img = self.resources.get_image(character.direction) y = character.y x = character.x canvas.create_image(x, y, anchor=NW, image=img, tag=character.name) def increase_turn_count(self): self.turn_count += 1 def random_map(self): self.floors = [] self.walls = [] self.floors.append(0) for i in range(1, self.number_of_tiles**2): random = randrange(0, 10) if random < randrange(3, 7): # varying wall count self.walls.append(i) else: self.floors.append(i) self.connect_map() def connect_map(self): unseen = self.walls + self.floors seen = [0] been = [0] unseen.remove(0) self.see_neighbours(0, unseen, seen) self.check_seen(unseen, seen, been) while len(set(self.floors)) != len(set(been)): self.check_unseen(unseen, seen, been) self.check_seen(unseen, seen, been) if len(self.floors) < 6: # max characters self.random_map() def see_neighbours(self, tile, unseen, seen): if tile - 1 in unseen and tile % self.number_of_tiles != 0: self.see(tile - 1, unseen, seen) if tile + 1 in unseen and (tile + 1) % self.number_of_tiles != 0: self.see(tile + 1, unseen, seen) if tile - self.number_of_tiles in unseen: self.see(tile - self.number_of_tiles, unseen, seen) if tile + self.number_of_tiles in unseen: self.see(tile + self.number_of_tiles, unseen, seen) def see(self, tile, unseen, seen): seen.append(tile) unseen.remove(tile) def check_seen(self, unseen, seen, been): for tile in seen: if tile in self.floors and tile not in been: been.append(tile) self.see_neighbours(tile, unseen, seen) def check_unseen(self, unseen, seen, been): unseen_floors = list(set(unseen).intersection(set(self.floors))) counter = 1 for tile in unseen_floors: if (tile - 2 in been and tile - 1 in self.walls and tile - 1 in seen): self.break_wall(tile - 1) return elif (tile - (2 * self.number_of_tiles) in been and tile - self.number_of_tiles in self.walls and tile - self.number_of_tiles in seen): self.break_wall(tile - self.number_of_tiles) return elif (tile + 2 in been and tile + 1 in self.walls and tile + 1 in seen): self.break_wall(tile + 1) return elif (tile + (2 * self.number_of_tiles) in been and tile + self.number_of_tiles in self.walls and tile + self.number_of_tiles in seen): self.break_wall(tile + self.number_of_tiles) return elif (tile - 1 - self.number_of_tiles in been and tile - 1 in self.walls and tile - self.number_of_tiles in self.walls and tile - 1 in seen): self.break_wall(tile - 1) return elif (tile - 1 + self.number_of_tiles in been and tile - 1 in self.walls and tile + self.number_of_tiles in self.walls and tile - 1 in seen): self.break_wall(tile - 1) return elif (tile + 1 - self.number_of_tiles in been and tile + 1 in self.walls and tile - self.number_of_tiles in self.walls and tile + 1 in seen): self.break_wall(tile + 1) return elif (tile + 1 + self.number_of_tiles in been and tile + 1 in self.walls and tile + self.number_of_tiles in self.walls and tile + 1 in seen): self.break_wall(tile + 1) return else: if counter == len(unseen_floors): self.make_wall(tile) return else: counter += 1 continue def break_wall(self, tile_between): self.walls.remove(tile_between) self.floors.append(tile_between) def make_wall(self, tile): self.walls.append(tile) self.floors.remove(tile)
def start(self, screen): if not self.already_loaded: PenData.load_all_pens(Resources.get("all_pens")) width = screen.get_width() height = screen.get_height() self.back_btn = Button( pygame.Rect(10, 10, 60, 40), "Back", { Options.BORDER_WIDTH: 0, Options.BACKGROUND: (20, 61, 89), Options.FOREGROUND: (244, 180, 26), Options.HOVERED_BACKGROUND: (10, 30, 45), Options.FONT: pygame.font.SysFont("Comic Sans MS", 15) }) label_options = { Options.BACKGROUND: (20, 61, 89), Options.FOREGROUND: (244, 180, 26), Options.BORDER_WIDTH: 0, } self.header = Label(pygame.Rect(width / 2 - 200, 10, 400, 30), "Select your weapon!", label_options) self.coins_text = Label( pygame.Rect(width - 110, height - 55, 100, 40), "0", label_options) label_options = { Options.BACKGROUND: (82, 173, 200), Options.FOREGROUND: (20, 61, 89), Options.BORDER_WIDTH: 0, Options.FONT: pygame.font.SysFont("Comic Sans MS", 18) } self.density_text = Label(pygame.Rect(width / 5, 110, 100, 20), "Density: ", label_options) self.restitution_text = Label(pygame.Rect(width / 5, 130, 100, 20), "Restitution: ", label_options) self.name_text = Label( pygame.Rect(width / 2 - 45, height - 125, 90, 50), "", label_options) self.description_lines = [ Label(pygame.Rect(width * 2 / 3, 100 + i * 25, 100, 20), "", label_options) for i in range(0, 3) ] self.coins_image = Image( pygame.Rect(width - 175, height - 60, 50, 50), Resources.get("coin"), {Options.BACKGROUND: (82, 173, 200)}) btn_options = { Options.BORDER_WIDTH: 0, Options.BACKGROUND: (20, 61, 89), Options.FOREGROUND: (244, 180, 26), Options.HOVERED_BACKGROUND: (10, 30, 45), Options.FONT: pygame.font.SysFont("Comic Sans MS", 25) } self.left_btn = Button(pygame.Rect(10, height / 2 - 20, 20, 30), "<", btn_options) self.right_btn = Button( pygame.Rect(width - 30, height / 2 - 20, 20, 30), ">", btn_options) self.select_btn = Button( pygame.Rect(width / 2 - 45, height - 75, 90, 50), "Select", btn_options) self.purchase_btn = Button( pygame.Rect(width / 2 - 125, height - 75, 250, 40), "", btn_options) self.center_pos = pygame.Rect(width / 2 - 50, height / 2 - 50, 100, 100) for pen in PenData.all_pens: self.pen_images.append( Image(self.center_pos, Resources.get(pen.image_file), {Options.BACKGROUND: (82, 173, 200)})) self.already_loaded = True self.reposition_images() self.update_shop_data() self.reset_coin_text()
def showMessage(self, call_id, msgid, direction, sender, icon_path, content, timestamp, is_html=False, state='', recipient='', is_private=False, history_entry=False, media_type='chat', encryption=None): lock_icon_path = Resources.get('unlocked-darkgray.png') if encryption is not None: if encryption == '': lock_icon_path = Resources.get('unlocked-darkgray.png') else: lock_icon_path = Resources.get( 'locked-green.png' if encryption == 'verified' else 'locked-red.png') if self.last_sender == sender: icon_path = "null" else: icon_path = "'%s'" % icon_path self.last_sender = sender if not history_entry and not self.delegate.isOutputFrameVisible(): self.delegate.showChatViewWhileVideoActive() # keep track of rendered messages to toggle the smileys or search their content later rendered_message = ChatMessageObject(call_id, msgid, content, is_html, timestamp, media_type) self.rendered_messages.append(rendered_message) if timestamp.date() != datetime.date.today(): displayed_timestamp = time.strftime( "%F %H:%M", time.localtime(calendar.timegm(timestamp.utctimetuple()))) else: displayed_timestamp = time.strftime( "%H:%M", time.localtime(calendar.timegm(timestamp.utctimetuple()))) content = processHTMLText(content, self.expandSmileys, is_html) private = 1 if is_private else "null" if is_private and recipient: label = NSLocalizedString( "Private message to %s", "Label") % html.escape( recipient ) if direction == 'outgoing' else NSLocalizedString( "Private message from %s", "Label") % html.escape(sender) else: if hasattr(self.delegate, "sessionController"): label = html.escape( self.delegate.sessionController.nickname or self.account.display_name or self.account.id) if sender is None else html.escape(sender) else: label = html.escape( self.account.display_name or self.account.id) if sender is None else html.escape(sender) try: script = """renderMessage('%s', '%s', '%s', %s, "%s", '%s', '%s', %s, '%s', '%s')""" % ( msgid, direction, label, icon_path, content, displayed_timestamp, state, private, lock_icon_path, self.previous_msgid) except UnicodeDecodeError: script = """renderMessage('%s', '%s', '%s', %s, "%s", '%s', '%s', %s, '%s', '%s')""" % ( msgid, direction, label, icon_path, content.decode('utf-8'), displayed_timestamp, state, private, lock_icon_path, self.previous_msgid) except Exception as e: self.delegate.showSystemMessage( "Chat message id %s rendering error: %s" % (msgid, e), ISOTimestamp.now(), True) return if self.finishedLoading: self.executeJavaScript(script) else: self.messageQueue.append(script) if hasattr(self.delegate, "chatViewDidGetNewMessage_"): self.delegate.chatViewDidGetNewMessage_(self) self.previous_msgid = msgid
def __init__(self): QtGui.QMainWindow.__init__(self) Resources.load(os.getcwd(), ["icons", "xhtml"], icon_driver=QtGui.QIcon) self.tabs = dict() """:type: dict from str to QtGui.QWidget""" self.tabs_stack = None """:type: QStackedWidget""" self.window_layout = None """:type: QtGui.QLayout""" self.controls_view = None """:type: ControlsView""" self.about_window = None """:type: AboutWindow""" self.dbparser = None """:type: GenericParser""" self.appdb = None """:type: database.ApplicationDatabase""" self.plugins = None """:type: plugins.Container""" self.my_state = None self.my_geometry = None self.resize(1080, 760) self.center() try: config.openLayerMapConfig(config.Configuration.layer_map_path) except config.LayerMapConfig.ParseError: ErrorBox( self, "Can't parse '%s' GDSII layer mapping file!" % config.Configuration.layer_map_path) sys.exit(-1) self.configure_dbparser() self.configure_database() self.configure_plugins() self.configure_windows() self.appconfig = AppConfigurationView(self) # Create initial options object self.options = options.Options.default() self.core = core.Core(self.options) connect(self.options.changed, self.setApplicationTitle) self.setApplicationTitle() self.setWindowIcon(QtGui.QIcon("icons/Logo.png")) self.configure_controls() self.configure_window_state() logging.info("Configure status bar") self.status_bar = StatusBar(self) self.setStatusBar(self.status_bar) self.statusBar().showMessage("Ready") self.state_changed = False logging.info("Configuration done") logging.info("Loading options") if len(sys.argv) > 1: path = sys.argv[1] self._open_options(path) self.show()
# Generate a textual FST txt_fst = make_bigram_lm_fst(kaldi_seq, **kwargs) txt_fst_file = tempfile.NamedTemporaryFile(delete=False) txt_fst_file.write(txt_fst) txt_fst_file.close() hclg_filename = tempfile.mktemp(suffix='_HCLG.fst') try: devnull = open(os.devnull, 'wb') subprocess.check_output( [MKGRAPH_PATH, proto_langdir, txt_fst_file.name, hclg_filename], stderr=devnull) except Exception, e: try: os.unlink(hclg_filename) except: pass raise e finally: os.unlink(txt_fst_file.name) return hclg_filename if __name__ == '__main__': import sys make_bigram_language_model( open(sys.argv[1]).read(), Resources().proto_langdir)
from resources import Resources from activity.draw import DrawActivity from activity.wish import WishActivity from activity.consecrate import ConsecrateActivity from shop import Shop from common import * import numpy as np if __name__ == "__main__": res = Resources() res.whiteTadpole = 10000 res.drawVoucher = 350 res.wishCoin = 90 res.consecrateTime = time(6, 0, 0) res.consecrateTimeSpeedUpRatio = time(0, 6, 30) / time(0, 8, 0) shop = Shop() drawAct = DrawActivity() wishAct = WishActivity() consecrateAct = ConsecrateActivity() activities = [drawAct, wishAct, consecrateAct] # DP dp_dict = dict() # code -> (res, score) idx = 0 for act in activities: idx += 1 print("--------------------------", idx, "--------------------------")
async def consumer_handler(websocket, _path): async for message in websocket: try: data = json.loads(message, object_hook=lambda d: SimpleNamespace(**d)) if hasattr(data, "myColor"): global PLAYER_COLOR PLAYER_COLOR = data.myColor elif hasattr(data, "tileState"): # Board information global BOARD BOARD = Board(data) BOT = NaiveBot(BOARD, PLAYER_COLOR, QUEUE) elif hasattr(data, "currentTurnState"): # Game state information global GAME_STATE if data.currentTurnState == 1 and data.currentTurnPlayerColor != PLAYER_COLOR: GAME_STATE = GameState.OPPONENT_TURN if data.currentTurnPlayerColor == PLAYER_COLOR: # need to be outside the currentTurnState ifs, # because it can happen in both turnstate 1 and 2 if data.currentActionState == 23: BOT.move_robber() elif data.currentActionState == 27: asyncio.create_task(BOT.use_road_building()) # elif data.currentActionState == 28: # BOT.handle_event(ColEvents.ROAD_BUILDING) elif data.currentActionState == 29: asyncio.create_task(BOT.use_year_of_plenty()) elif data.currentActionState == 30: asyncio.create_task(BOT.use_monopoly()) if data.currentTurnState == 0: if data.currentActionState == 1 and \ GAME_STATE == GameState.SETUP_SETTLEMENT: BOT.build_setup_settlement() GAME_STATE = GameState.SETUP_ROAD if data.currentActionState == 3 and GAME_STATE == GameState.SETUP_ROAD: BOT.build_setup_road() if len(BOARD.own_settlements) < 2: GAME_STATE = GameState.SETUP_SETTLEMENT else: GAME_STATE = GameState.OPPONENT_TURN if data.currentTurnState == 1: if data.currentActionState == 0 and GAME_STATE == GameState.OPPONENT_TURN: GAME_STATE = GameState.START_TURN asyncio.create_task(BOT.start_turn()) if data.currentTurnState == 2: if GAME_STATE == GameState.START_TURN: GAME_STATE = GameState.PLAYER_TURN asyncio.create_task(BOT.play_turn()) # TODO: remember the player next to tile we place robber on # so we can do the logic on the turn logic package elif hasattr(data, "allowableActionState"): print("hasattr(data, \"allowableActionState\"") if data.allowableActionState == 24: print("data.allowableActionState == 24") BOT.rob(data.playersToSelect) elif hasattr(data, "selectCardFormat"): amount = data.selectCardFormat.amountOfCardsToSelect BOT.discard_cards(amount) elif hasattr(data, "givingPlayer"): # Trade information if data.givingPlayer == PLAYER_COLOR: for card in data.givingCards: BOARD.resources[Resources(card)] -= 1 for card in data.receivingCards: BOARD.resources[Resources(card)] += 1 if data.receivingPlayer == PLAYER_COLOR: for card in data.givingCards: if card >= 1 and card <= 5: BOARD.resources[Resources(card)] += 1 else: BOARD.own_dev_cards[DevCards(card)] += 1 for card in data.receivingCards: BOARD.resources[Resources(card)] -= 1 BOT.handle_event(ColEvents.RECEIVED_CARDS) elif hasattr(data, "offeredResources"): # Active trade offer # Check if we're allowed to take this trade and have to respond for player_actions in data.actions: if player_actions.player == PLAYER_COLOR: if len(player_actions.allowedTradeActions) > 1: # Respond to trade offer BOT.respond_to_trade(data) break elif hasattr(data, "resourceCards"): for resource in Resources: BOARD.bank_resources[resource] = data[ "resourceCards"].count(resource.value) # Settlement update (probably upgrading to a city works the same) elif isinstance(data, list) and hasattr(data[0], "hexCorner"): update_vertex(data[0]) BOT.handle_event(ColEvents.VERTEX_CHANGED) elif isinstance(data, list) and hasattr(data[0], "hexEdge"): update_edge(data[0]) BOT.handle_event(ColEvents.EDGE_CHANGED) # Cards being handed out elif isinstance(data, list) and hasattr(data[0], "owner"): for entry in data: if entry.owner == PLAYER_COLOR: # TODO: fix for cities, probably can just increment with distribitionType BOARD.resources[Resources(entry.card)] += 1 # Robber move information elif isinstance(data, list) and hasattr(data[0], "tilePieceTypes"): new_robber_tile = data[1] loc = new_robber_tile.hexFace BOARD.robber_tile = BOARD.find_tile_index_by_coordinates( loc.x, loc.y) print("New robber_tile: {0}".format(BOARD.robber_tile)) BOT.handle_event(ColEvents.ROBBER_MOVED) except: pass
def main(): Resources() game = Game((1280, 720), "Triggered") game.run()
def loadStarted(self): # Some custom CSS to clean/fix UX self.settings().setUserStyleSheetUrl( QUrl.fromLocalFile(Resources.get_path("resources.css")))
def load_assets(self): # Load the circle loading animation Resources.add("loading", pygame.image.load("assets/loading.png")) self.circle_image = Resources.get("loading") # Load the settings gear icon Resources.add("gear", pygame.image.load("assets/gear.png")) # Load the close icon Resources.add("close", pygame.image.load("assets/close.png")) # Load the coin image Resources.add("coin", pygame.image.load("assets/coin.png")) # Load the random pen image Resources.add("random_pen", pygame.image.load("assets/random_pen.png")) # Load the pen data and images Resources.add("all_pens", Resources.load_text("assets/pens.json")) Resources.add("pencil", pygame.image.load("assets/pencil.png")) Resources.add("ball_pen", pygame.image.load("assets/ball_pen.png")) Resources.add("blue_gel_pen", pygame.image.load("assets/blue_gel_pen.png")) Resources.add("black_gel_pen", pygame.image.load("assets/black_gel_pen.png")) Resources.add("mech_pencil", pygame.image.load("assets/mech_pencil.png")) Resources.add("marker", pygame.image.load("assets/marker.png")) self.loaded = True
#!/usr/bin/env python __author__ = 'SuturkinAA' import os import sys from resources import Resources from config import Config global res def setRestPort(resrPort): listener = '0.0.0.0:'+str(resrPort) if (len(sys.argv)==1): sys.argv.append("runserver") sys.argv.append(listener) config = Config(); config.load() res = Resources(config.resourcesMax); setRestPort(config.restPort) if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "rest.settings") from django.core.management import execute_from_command_line execute_from_command_line(sys.argv) print ("Started.")
if sib == action.argv[0]: reentr_dataset.write(str(1) + "\n") else: reentr_dataset.write(str(2) + "\n") if __name__ == "__main__": argparser = argparse.ArgumentParser() argparser.add_argument("-t", "--train", help="Training set", required=True) argparser.add_argument("-v", "--valid", help="Validation set", required=True) argparser.add_argument( "-m", "--modeldir", help="Directory used to save the model being trained", required=True) argparser.add_argument("-l", "--lang", help="Language", default="en") try: args = argparser.parse_args() except: argparser.error("Invalid arguments") sys.exit(0) Resources.init_table(args.modeldir, False) create(args.train, "train", args.lang, args.modeldir) create(args.valid, "valid", args.lang, args.modeldir) print "Done"
def configure_controls(self): logging.info("Configure window controls") controls_data = [ ControlsView.ControlData( name="File", text="&File", actions=[ ControlBar.ActionData(name="New", text="&New", icon=Resources("icons/NewFile"), callback=self.new_options, status_tip="Create a new document", shortcut="Ctrl+N"), ControlBar.ActionData( name="Open", text="&Open", icon=Resources("icons/Open"), callback=self.load_options, status_tip="Open an existing document", shortcut="Ctrl+O"), ControlBar.ActionData( name="Save", text="&Save", icon=Resources("icons/Save"), callback=self.save_options, status_tip="Save the active document"), ControlBar.ActionData( name="SaveAs", text="Save As ...", callback=self.save_options_as, status_tip="Save the active document with a new name"), None, ControlBar.ActionData( name="Preferences", text="&Preferences", callback=self.appconfig.exec_, icon=Resources("icons/Preferences"), status_tip="Edit preferences settings"), None, ControlBar.ActionData( name="Print", text="Print...", callback=self.onPrint, status_tip="Print the active document", shortcut="Ctrl+P"), ControlBar.ActionData( name="PrintPreview", text="Print Preview", callback=self.onPrintPreview, status_tip="Display a preview of the report"), ControlBar.ActionData( name="PrintSetup", text="Print Setup...", # callback=self.onPageSetup, status_tip="Change the printer and printing options"), None, ControlBar.ActionData( name="Exit", text="&Exit", icon=Resources("icons/Exit"), callback=self.close, status_tip= "Quit the application; prompts to save document", shortcut="Ctrl+Q") ]), ControlsView.ControlData( name="View", text="&View", actions=[ ControlBar.ActionData(name="Database", text="&Database", icon=Resources("icons/Database"), callback=self.changeStackView, status_tip="%s database storage" % config.APPLICATION_NAME), ControlBar.ActionData( name="Queue", text="&Queue", icon=Resources("icons/Queue"), status_tip="Show the sim_region queue window"), ControlBar.ActionData( name="Warnings", text="&Warnings", status_tip="Show the warning list window") ]), ControlsView.ControlData( name="Parameters", text="&Parameters", actions=[ ControlBar.ActionData(name="Numerics", text="&Numerics", icon=Resources("icons/Numerics"), callback=self.changeStackView, status_tip="Numerics"), ControlBar.ActionData(name="WaferProcesses", text="&Wafer Processes", icon=Resources("icons/WaferStack"), callback=self.changeStackView, status_tip="Wafer Processes"), ControlBar.ActionData(name="Resist", text="&Resist", icon=Resources("icons/Resist"), callback=self.changeStackView, status_tip="Resist"), ControlBar.ActionData(name="CoatAndPrebake", text="&Coat and prebake", callback=self.changeStackView, status_tip="Coat and prebake"), ControlBar.ActionData(name="Mask", text="&Mask", icon=Resources("icons/Mask"), callback=self.changeStackView, status_tip="Mask"), ControlBar.ActionData(name="ImagingTool", text="&Imaging Tool", icon=Resources("icons/ImagingTool"), callback=self.changeStackView, status_tip="Imaging Tool"), ControlBar.ActionData( name="ExposureAndFocus", text="&Exposure and Focus", icon=Resources("icons/ExposureAndFocus"), callback=self.changeStackView, status_tip="Exposure and Focus"), ControlBar.ActionData(name="PostExposureBake", text="&Post Exposure Bake", icon=Resources("icons/PEB"), callback=self.changeStackView, status_tip="Post Exposure Bake"), ControlBar.ActionData(name="Development", text="&Development", icon=Resources("icons/Development"), callback=self.changeStackView, status_tip="Development"), ControlBar.ActionData(name="Metrology", text="M&etrology", icon=Resources("icons/Metrology"), callback=self.changeStackView, status_tip="Metrology"), ControlBar.ActionData(name="Summary", text="&Summary", icon=Resources("icons/Summary"), callback=self.changeStackView, status_tip="Summary") ]), ControlsView.ControlData( name="Simulation", text="&Simulations", actions=[ ControlBar.ActionData( name="DiffractionPattern", text="&Diffraction Pattern", icon=Resources("icons/DiffractionPattern"), callback=self.changeStackView, status_tip="Diffraction Pattern"), ControlBar.ActionData(name="AerialImage", text="&Aerial Image", icon=Resources("icons/AerialImage"), callback=self.changeStackView, status_tip="Aerial Image"), ControlBar.ActionData( name="ImageInResist", text="&Image in Resist", icon=Resources("icons/ImageInResist"), callback=self.changeStackView, status_tip="Image in Resist"), ControlBar.ActionData(name="ExposedLatentImage", text="&Exposed Latent Image", icon=Resources("icons/LatentImage"), callback=self.changeStackView, status_tip="Exposed Latent Image"), ControlBar.ActionData( name="PEBLatentImage", text="&PEB Latent Image", icon=Resources("icons/PostBakeImage"), callback=self.changeStackView, status_tip="PEB Latent Image"), ControlBar.ActionData( name="DevelopTimeContours", text="&Develop Time Contours", icon=Resources("icons/DevelopTimeContours"), callback=self.changeStackView, status_tip="Develop Time Contours"), ControlBar.ActionData( name="ResistProfile", text="&Resist Profile", icon=Resources("icons/ResistProfile"), callback=self.changeStackView, status_tip="Resist Profile"), None, ControlBar.ActionData( name="SimulationSets", text="&Simulation Sets", icon=Resources("icons/SimulationSets"), callback=self.changeStackView, status_tip="Simulation Sets") ]), ControlsView.ControlData( name="Help", text="&Help", actions=[ ControlBar.ActionData( name="Manual", text="&Manual", icon=Resources("icons/Help"), status_tip="Application manual of %s" % config.APPLICATION_NAME), ControlBar.ActionData( name="About", text="&About %s" % config.APPLICATION_NAME, icon=Resources("icons/About"), callback=self.about_window.show, status_tip= "Display program information, version, copyright and etc" ), ControlBar.ActionData( name="Warnings", text="%s website" % config.APPLICATION_NAME, icon=Resources("icons/Website"), callback=self.onWebsiteOpen, status_tip="Launch browser to %s project website" % config.APPLICATION_NAME) ]), ] controls_group = [("View", "Parameters", "Simulation")] logging.info("Create controls view") self.controls_view = ControlsView(self, controls_data, controls_group) logging.info("Create database view") self.tabs["View.Database"] = DatabaseView(self, self.appdb) logging.info("Create numerics view") self.tabs["Parameters.Numerics"] = NumericsView(self, self.options) logging.info("Create wafer processes view") self.tabs["Parameters.WaferProcesses"] = WaferProcessView( self, self.options.wafer_process, self.appdb) logging.info("Create resist view") self.tabs["Parameters.Resist"] = ResistView(self, self.options.wafer_process, self.options.peb.temp, self.appdb) logging.info("Create mask view") self.tabs["Parameters.Mask"] = MaskView(self, self.options, self.appdb) logging.info("Create imaging tool view") self.tabs["Parameters.ImagingTool"] = ImagingView( self, self.options, self.appdb) logging.info("Create exposure and focus view") self.tabs["Parameters.ExposureAndFocus"] = ExposureFocusView( self, self.options.exposure_focus, self.options.wafer_process) logging.info("Create post exposure bake view") self.tabs["Parameters.PostExposureBake"] = PostExposureBakeView( self, self.options) logging.info("Create development view") self.tabs["Parameters.Development"] = DevelopmentView( self, self.options.development, self.options.wafer_process) logging.info("Create metrology view") self.tabs["Parameters.Metrology"] = MetrologyView(self, self.options) logging.info("Create summary view") self.tabs["Parameters.Summary"] = SummaryView(self, self.options) logging.info("Create diffraction pattern simulation view") self.tabs["Simulation.DiffractionPattern"] = DiffractionPatternView( self, self.core) logging.info("Create aerial image simulation view") self.tabs["Simulation.AerialImage"] = AerialImageView( self, self.core.aerial_image, self.options) logging.info("Create image in resist simulation view") self.tabs["Simulation.ImageInResist"] = ImageInResistView( self, self.core.image_in_resist, self.options) logging.info("Create exposed latent image simulation view") self.tabs["Simulation.ExposedLatentImage"] = LatentImageView( self, self.core.latent_image, self.options) logging.info("Create peb latent image simulation view") self.tabs["Simulation.PEBLatentImage"] = PebLatentImageView( self, self.core.peb_latent_image, self.options) logging.info("Create develop time contours simulation view") self.tabs["Simulation.DevelopTimeContours"] = \ DevelopContoursView(self, self.core.develop_contours, self.options) logging.info("Create resist profile simulation view") self.tabs["Simulation.ResistProfile"] = ResistProfileView( self, self.core.resist_profile, self.options) logging.info("Create simulation sets view") self.tabs["Simulation.SimulationSets"] = SimulationSets( self, self.core) logging.info("Configure stack widget") window = QtGui.QWidget() self.setCentralWidget(window) self.tabs_stack = QStackedWidget(window) self.window_layout = QtGui.QHBoxLayout(window) self.window_layout.addWidget(self.tabs_stack) # self.scroll_widget = QtGui.QScrollArea() # self.scroll_widget.setWidget(window) # self.scroll_widget.setWidgetResizable(True) for control in self.tabs.values(): self.tabs_stack.addWidget(control)
import flask from flask import Flask from flask import request from flask import render_template from flask import url_for from flask import redirect from resources import Resources app = Flask(__name__) resources = Resources() resources.init() @app.route("/about") def about(): # return render_template("about.html") post = resources.get_about() return render_template("post.html", post=post, title="about") @app.route("/archives/") def archives(): return render_template("archives.html", posts=resources.posts(), title="archives") @app.route("/archives/<string:archive_id>") def archive(archive_id): post = resources.get(archive_id) return render_template("post.html", post=post, title=post.title) @app.route("/construct") def construct(): return render_template("construct.html")
See the License for the specific language governing permissions and limitations under the License """ import json from locust import HttpLocust, TaskSet, task import uuid from resources import Resources # Inventory base url # [todo] This should be defined from environment properties global inventory_url inventory_url = 'http://localhost:8080/hawkular/inventory' # Resource types initialization should be independent of any client activity global resources resources = Resources() Resources.add_resource_types(inventory_url, Resources.create_resource_types()) global headers headers = {'Content-type': 'application/json', 'Accept': 'application/json'} class AgentLifeCycle(TaskSet): def on_start(self): self.feed_id = "feed-" + str(uuid.uuid4()) print "New Agent [%s]" % self.feed_id, # Simulating 1 server with 99 children resources each one with 20 metrics, so 100 resources per agent self.agent_resources = resources.create_large_inventory(self.feed_id, 1, 99, 20) self.client.post("/import", json.dumps(self.agent_resources), headers=headers) print "Agent [%s] - full auto-discovery" % self.feed_id, @task
def __init__(self, context, editor): PanelView.__init__(self, context) self._log.debug("init") self._editor = editor self._handlers = {} self._preferences = Preferences() self._preferences.connect("preferences-changed", self._on_preferences_changed) self._show_tasks = self._preferences.get("issues-show-tasks") self._show_warnings = self._preferences.get("issues-show-warnings") self._icons = { Issue.SEVERITY_WARNING : GdkPixbuf.Pixbuf.new_from_file(Resources().get_icon("warning.png")), Issue.SEVERITY_ERROR : GdkPixbuf.Pixbuf.new_from_file(Resources().get_icon("error.png")), Issue.SEVERITY_INFO : None, Issue.SEVERITY_TASK : GdkPixbuf.Pixbuf.new_from_file(Resources().get_icon("task.png")) } grid = Gtk.Grid() self.add(grid) self._store = Gtk.ListStore(GdkPixbuf.Pixbuf, str, str, object) self._view = Gtk.TreeView(model=self._store) column = Gtk.TreeViewColumn() column.set_title(_("Message")) pixbuf_renderer = Gtk.CellRendererPixbuf() column.pack_start(pixbuf_renderer, False) column.add_attribute(pixbuf_renderer, "pixbuf", 0) text_renderer = Gtk.CellRendererText() column.pack_start(text_renderer, True) column.add_attribute(text_renderer, "markup", 1) self._view.append_column(column) column = Gtk.TreeViewColumn() column.set_title(_("File")) text_renderer2 = Gtk.CellRendererText() column.pack_start(text_renderer2, True) column.add_attribute(text_renderer2, "markup", 2) self._view.insert_column(column, -1) self._handlers[self._view] = self._view.connect("row-activated", self._on_row_activated) self._scr = Gtk.ScrolledWindow() self._scr.add(self._view) self._scr.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self._scr.set_shadow_type(Gtk.ShadowType.IN) self._scr.set_hexpand(True) self._scr.set_vexpand(True) grid.add(self._scr) # toolbar self._button_warnings = Gtk.ToggleToolButton() self._button_warnings.set_tooltip_text(_("Show/Hide Warnings")) image = Gtk.Image() image.set_from_file(Resources().get_icon("warning.png")) self._button_warnings.set_icon_widget(image) self._button_warnings.set_active(self._show_warnings) self._handlers[self._button_warnings] = self._button_warnings.connect("toggled", self.__on_warnings_toggled) self._button_tasks = Gtk.ToggleToolButton() self._button_tasks.set_tooltip_text(_("Show/Hide Tasks")) imageTask = Gtk.Image() imageTask.set_from_file(Resources().get_icon("task.png")) self._button_tasks.set_icon_widget(imageTask) self._button_tasks.set_active(self._show_tasks) self._handlers[self._button_tasks] = self._button_tasks.connect("toggled", self.__on_tasks_toggled) toolbar = Gtk.Toolbar() toolbar.set_orientation(Gtk.Orientation.VERTICAL) toolbar.set_style(Gtk.ToolbarStyle.ICONS) toolbar.set_icon_size(Gtk.IconSize.MENU) toolbar.insert(self._button_warnings, -1) toolbar.insert(self._button_tasks, -1) toolbar.set_vexpand(True) grid.add(toolbar) # theme like gtk3 ctx = self._scr.get_style_context() ctx.set_junction_sides(Gtk.JunctionSides.RIGHT) ctx = toolbar.get_style_context() ctx.set_junction_sides(Gtk.JunctionSides.LEFT | Gtk.JunctionSides.RIGHT) ctx.add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR) self._issues = [] self.show_all() self._log.debug("init finished")
def deploy_app(self): self.client.post("/import", json.dumps(Resources.create_app_resource(self.feed_id, self.feed_id + "-NewApp.war")), headers=headers) print "Agent [%s] - deploys NewApp.war" % self.feed_id,
def update_ringtones(self, account=None): settings = SIPSimpleSettings() if account is None: account = AccountManager().default_account app = SIPApplication() def change_tone(name, new_tone): current = getattr(self, name) if current and current.is_active: current.stop() if new_tone: new_tone.start() setattr(self, name, new_tone) change_tone( "initial_hold_tone", WavePlayer(app.voice_audio_mixer, Resources.get('hold_tone.wav'), volume=10)) app.voice_audio_bridge.add(self.initial_hold_tone) change_tone( "secondary_hold_tone", WavePlayer(app.voice_audio_mixer, Resources.get('hold_tone.wav'), loop_count=0, pause_time=45, volume=10, initial_delay=45)) app.voice_audio_bridge.add(self.secondary_hold_tone) if account: audio_primary_ringtone = account.sounds.audio_inbound.sound_file if account.sounds.audio_inbound is not None else None else: audio_primary_ringtone = None if audio_primary_ringtone and not settings.audio.silent: # Workaround not to use same device from two bridges. -Saul if settings.audio.alert_device is not None and app.alert_audio_mixer.real_output_device == app.voice_audio_mixer.real_output_device: new_tone = WavePlayer(app.voice_audio_mixer, audio_primary_ringtone.path, loop_count=0, pause_time=6) app.voice_audio_bridge.add(new_tone) else: new_tone = WavePlayer(app.alert_audio_mixer, audio_primary_ringtone.path, loop_count=0, pause_time=6) app.alert_audio_bridge.add(new_tone) else: new_tone = None change_tone("audio_primary_ringtone", new_tone) if audio_primary_ringtone and not settings.audio.silent: new_tone = WavePlayer(app.voice_audio_mixer, Resources.get('ring_tone.wav'), loop_count=0, pause_time=6) app.voice_audio_bridge.add(new_tone) else: new_tone = None change_tone("audio_secondary_ringtone", new_tone) if audio_primary_ringtone and not settings.audio.silent: # Workaround not to use same device from two bridges. -Saul if settings.audio.alert_device is not None and app.alert_audio_mixer.real_output_device == app.voice_audio_mixer.real_output_device: new_tone = WavePlayer(app.voice_audio_mixer, Resources.get('ring_tone.wav'), loop_count=0, pause_time=6) app.voice_audio_bridge.add(new_tone) else: new_tone = WavePlayer(app.alert_audio_mixer, Resources.get('ring_tone.wav'), loop_count=0, pause_time=6) app.alert_audio_bridge.add(new_tone) else: new_tone = None change_tone("chat_primary_ringtone", new_tone) if audio_primary_ringtone and not settings.audio.silent: new_tone = WavePlayer(app.voice_audio_mixer, Resources.get('ring_tone.wav'), loop_count=0, pause_time=6) app.voice_audio_bridge.add(new_tone) else: new_tone = None change_tone("chat_secondary_ringtone", new_tone) chat_message_outgoing_sound = settings.sounds.message_sent if chat_message_outgoing_sound and not settings.audio.silent: new_tone = WavePlayer(app.voice_audio_mixer, chat_message_outgoing_sound.path, volume=chat_message_outgoing_sound.volume) app.voice_audio_bridge.add(new_tone) else: new_tone = None change_tone("chat_message_outgoing_sound", new_tone) chat_message_incoming_sound = settings.sounds.message_received if chat_message_incoming_sound and not settings.audio.silent: new_tone = WavePlayer(app.voice_audio_mixer, chat_message_incoming_sound.path, volume=chat_message_incoming_sound.volume) app.voice_audio_bridge.add(new_tone) else: new_tone = None change_tone("chat_message_incoming_sound", new_tone) file_transfer_outgoing_sound = settings.sounds.file_sent if file_transfer_outgoing_sound and not settings.audio.silent: new_tone = WavePlayer(app.voice_audio_mixer, file_transfer_outgoing_sound.path, volume=file_transfer_outgoing_sound.volume) app.voice_audio_bridge.add(new_tone) else: new_tone = None change_tone("file_transfer_outgoing_sound", new_tone) file_transfer_incoming_sound = settings.sounds.file_received if file_transfer_incoming_sound and not settings.audio.silent: new_tone = WavePlayer(app.voice_audio_mixer, file_transfer_incoming_sound.path, volume=file_transfer_incoming_sound.volume) app.voice_audio_bridge.add(new_tone) else: new_tone = None change_tone("file_transfer_incoming_sound", new_tone)
# -*- coding: utf-8 -*- import os import sys from flask import Flask, request, session, g, redirect, url_for, abort, render_template, Blueprint, jsonify from resources import Resources from settings import RESOURCES_PATH, SETTINGS_PATH blueprint_api = Blueprint('api', __name__) resource = Resources(RESOURCES_PATH, SETTINGS_PATH) @blueprint_api.route('/api') def home(): global resource lang = request.args.get('l') or 'bg' print resource.get_navigations(lang) content = { "navigation": resource.get_navigations(lang), "pages": resource.get_pages(lang) } return jsonify(content) @blueprint_api.route('/api/publish') def publish(): global resource resource.publish()
def start(self, screen): if not self.already_loaded: PenData.load_all_pens() width = screen.get_width() height = screen.get_height() self.back_btn = Button( pygame.Rect(10, 10, 60, 40), "Back", { Options.BORDER_WIDTH: 0, Options.BACKGROUND: (20, 61, 89), Options.FOREGROUND: (244, 180, 26), Options.HOVERED_BACKGROUND: (10, 30, 45), Options.FONT: pygame.font.SysFont("Comic Sans MS", 15) }) self.header = Label( pygame.Rect(width / 2 - 200, 10, 400, 30), "Choose your opponent!", { Options.BACKGROUND: (20, 61, 89), Options.FOREGROUND: (244, 180, 26), Options.BORDER_WIDTH: 0, }) self.name_text = Label( pygame.Rect(width / 2 - 45, height - 125, 90, 50), "", { Options.BACKGROUND: (82, 173, 200), Options.FOREGROUND: (20, 61, 89), Options.BORDER_WIDTH: 0, Options.FONT: pygame.font.SysFont("Comic Sans MS", 18) }) btn_options = { Options.BORDER_WIDTH: 0, Options.BACKGROUND: (20, 61, 89), Options.FOREGROUND: (244, 180, 26), Options.HOVERED_BACKGROUND: (10, 30, 45), Options.FONT: pygame.font.SysFont("Comic Sans MS", 25) } self.left_btn = Button(pygame.Rect(10, height / 2 - 20, 20, 30), "<", btn_options) self.right_btn = Button( pygame.Rect(width - 30, height / 2 - 20, 20, 30), ">", btn_options) self.select_btn = Button( pygame.Rect(width / 2 - 45, height - 75, 90, 50), "Select", btn_options) btn_options[Options.TOGGLED_BACKGROUND] = (5, 20, 30) self.random_diff_btn = ToggleButton( pygame.Rect(width * 1 / 5 - 50, 100, 100, 30), "Random", btn_options) self.easy_btn = ToggleButton( pygame.Rect(width * 2 / 5 - 50, 100, 100, 30), "Easy", btn_options) self.normal_btn = ToggleButton( pygame.Rect(width * 3 / 5 - 50, 100, 100, 30), "Normal", btn_options) self.hard_btn = ToggleButton( pygame.Rect(width * 4 / 5 - 50, 100, 100, 30), "Hard", btn_options) toggle_group = [ self.random_diff_btn, self.easy_btn, self.normal_btn, self.hard_btn ] for elt in toggle_group: elt.set_group(toggle_group) self.easy_btn.toggle() self.center_pos = pygame.Rect(width / 2 - 50, height / 2 - 50, 100, 100) self.random_pen_data = PenData.dict_to_pen({ "name": "Random", "image_file": "random_pen" }) for pen in [self.random_pen_data] + PenData.all_pens: self.pen_images.append( Image(self.center_pos, Resources.get(pen.image_file), {Options.BACKGROUND: (82, 173, 200)})) self.already_loaded = True self.reposition_images() self.update_enemy_data()
def reset(self): self.setFixedWidth(0) self.setVisible(False) self.setUrl(QUrl.fromLocalFile(Resources.get_path("leftpane.html"))) self.page().currentFrame().addToJavaScriptWindowObject("leftPane", self) self.page().currentFrame().evaluateJavaScript(self.js)
class Cities(object): ''' classdocs ''' def __init__(self, town_name="", wood=0, oil=0, water=0, discontent=100): ''' Constructor ''' self.__town_name = town_name self.town_resources = Resources(wood, oil, water) self.__discontent = discontent def __str__(self): data = "Wood: " + str(self.town_resources.getWood()) \ + "\n" \ + "Oil: " + str(self.town_resources.getOil()) \ + "\n" \ + "Water: " + str(self.town_resources.getWater()) \ + "\n" \ + "Discontent: " + str(self.__discontent) return data def setTownName(self, town_name): self.__town_name = town_name def getTownName(self): return self.__town_name def setDiscontent(self, discontent): self.__discontent = discontent def getDiscontent(self): return self.__discontent def consuming_resources(self): rate = random.randrange(10, 41) / 100.0 self.town_resources.setWood(self.town_resources.getWood() - rate) self.town_resources.setOil(self.town_resources.getOil() - rate) def discontent_modifier(self): if self.town_resources.getWood() <= 0 or self.town_resources.getOil( ) <= 0: self.__discontent -= 1 if self.__discontent < 1: return "gameover"
def main(): res = Resources() app = Application((800, 600), "Editor", resizable=True) app.process(Editor()) app.run()
def clear_pys(self): try: if os.path.exists(Resources.path('dist/log.txt')): os.remove(Resources.path('dist/log.txt')) except Exception: ...
if event.value == EncoderEvent.CW_ROTATION: self._owner.enter_choosing(True, self.track_nb + 1) elif event.value == EncoderEvent.CCW_ROTATION: self._owner.enter_choosing(True, self.track_nb - 1) return def cleanup(self): self.logger.debug("PlayingState cleaned up") self._random_msg_display.stop() self._name_display.stop() self._title_display.stop() if __name__ == "__main__": # Resourcecs initialization rsc = Resources("/home/pi/python/webradio/conf.txt") # lcd initialization lcd = CharLCD(i2c_expander='PCF8574', address=0x3f, port=1, cols=20, rows=4, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) lcd.backlight_enabled = True wifi = (0b00000, 0b11111, 0b00000, 0b01110, 0b00000, 0b00100, 0b00100, 0b00000) lcd.create_char(0, wifi)
def main(): user = Kozo() Resources.login(user) Resources.get_commands(user)
import random from worker import Worker from resources import Resources V_FACTOR = .2 if __name__ == "__main__": resources = Resources() trees = Worker("Forest", {}, {"Trees": 10}) stone = Worker("Mts", {}, {"Stone": 5}) lumberjack = Worker("Lumberjack", {"Trees": 1}, {"Wood": 10}) mason = Worker("Mason", {"Stone": 1}, {"Brick": 5}) axe_maker = Worker("Axe Maker", {"Wood": 1, "Stone": 1}, {"Axe": 1}) worker_list = [] worker_list.extend([trees, stone, lumberjack, mason, axe_maker]) for i in range(100): random.shuffle(worker_list) for worker in worker_list: resources = worker.make(resources) #print(resources) print(resources)