def main(args): print(c.GROUP_NAME, "Attendance Tracker Version", c.VERSION) # Init textMode textMode = 1 #1 for text, 0 for UI # Process the arguments if len(args) > 1: arg = args[1].lower() if arg == "--help": showHelp() sys.exit(0) elif arg == "--version": showVersion() sys.exit(0) elif arg == "--nogui": textMode = 1 else: print("Invalid argument:", args[1]) sys.exit(0) # Start the program into either textmode or GUI mode if textMode == 0: global app app = UI(args) app.exec_() else: TextUI().start() # Exit normally sys.exit(0)
def filter(self): """ Filter the list of apartments on specific criteria """ self._validate_parsed_command(["greater", "type"]) # filter by type if self._parsed_command["type"]: expense_type = self._parsed_command["type"] filtered_bloc_dict = {} for apartment_id in self._bloc_dict.keys(): if self._bloc_dict[apartment_id].expenses[expense_type]: filtered_bloc_dict[apartment_id] = self._bloc_dict[apartment_id] self._bloc_dict = filtered_bloc_dict # filter by total greater than if self._parsed_command["greater"]: amount_greater = float(self._parsed_command["greater"]) filtered_bloc_dict = {} for apartment_id in self._bloc_dict.keys(): if self._bloc_dict[apartment_id].get_total_expenses() > amount_greater: filtered_bloc_dict[apartment_id] = self._bloc_dict[apartment_id] self._bloc_dict = filtered_bloc_dict # print(filtered_bloc_dict) if not filtered_bloc_dict: UI.set_message("No apartment fits the criteria") else: UI.set_message("Apartments filtered successfully")
class DandelionApp: def __init__(self, config_file=None): self._config_manager = ConfigurationManager(config_file) def start_server(self): self._server = Server( self._config_manager.local_address, self._config_manager.local_port, self._config_manager.server, # info_dict self._config_manager.content_db, ) self._server.start() def start_content_synchronizer(self): self._synchronizer = Synchronizer( self._config_manager.local_address, self._config_manager.local_port, self._config_manager.type, self._config_manager.content_db, ) self._synchronizer.start() def run_ui(self): self._ui = UI( self._config_manager.ui, self._config_manager.content_db, self._server, self._synchronizer # dict ) self._ui.run() def exit(self): self._synchronizer.stop() self._server.stop()
def reset(keep_player=False): global SCREEN_SIZE, RANDOM_SEED, MAP, PLAYER RANDOM_SEED += 1 UI.clear_all() TurnTaker.clear_all() if keep_player: PLAYER.refresh_turntaker() PLAYER.levels_seen += 1 else: if not PLAYER is None: print("Game Over") print("%d evidence in %d turns; %d levels seen" %(len(PLAYER.evidence),PLAYER.turns,PLAYER.levels_seen)) PLAYER = Player() if not MAP is None: MAP.close() del MAP MAP = Map.random(RANDOM_SEED,SCREEN_SIZE-(0,4),PLAYER) MAP.generate()
def SvcStop(self): self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) win32event.SetEvent(self.stop_event) logging.info('Stopping ShakeCast Server...') self.stop_requested = True ui = UI() ui.send('shutdown')
def list_total_apartment(self): """ Displays the total expenses for an apartment """ self._validate_parsed_command(["id"]) apartment_id = self._parsed_command["id"] UI.set_message("Total expenses = " + str(self._bloc_dict[apartment_id].get_total_expenses()))
def start(self): while True: command = UI.get_input("> ") if command == 'start': self.ask() elif command == 'highscores': UI.display(self.show_highscores()) elif command == 'help': UI.display(self.__HELP_MESSAGE) elif command == 'exit': return
def stat_total_type(self): """ Displays the total for an expense type """ self._validate_parsed_command(["expense_type"]) sum_type = self._parsed_command["expense_type"] total = sum([self._bloc_dict[i].expenses[sum_type] for i in self._bloc_dict]) # for apartment_id in self._bloc_dict: # total += self._bloc_dict[apartment_id].expenses[sum_type] UI.set_message("Total expenses for " + sum_type + " = " + str(total))
def stat_max_apartment(self): """ Displays the biggest expense in an apartment """ self._validate_parsed_command(["id"]) apartment_id = self._parsed_command["id"] biggest_types = self._bloc_dict[apartment_id].get_max_expenses_type() if biggest_types: UI.set_message("Biggest expense is " + biggest_types.__str__() + " = " + str( self._bloc_dict[apartment_id].expenses[biggest_types[0]])) else: UI.set_message("Apartment has all expenses = 0")
def redraw_screen(self,t=0): # draw and flush screen if not UI.need_update(t): # clearly one of the libtcod functions here causes the wait for the next frame sleep(1.0/Player.LIMIT_FPS) return self.map.draw() self.draw_ui(Position(0,Player.SCREEN_SIZE.y-3)) UI.draw_all(t) libtcod.console_flush() # clear screen libtcod.console_clear(0)
def __init__(self): reload(sys) sys.setdefaultencoding('UTF-8') self.title = 'Nada' self.model = ['最新期刊', '分类期刊', '搜索期刊', '收藏夹', '关于'] self.view = 'menu' self.ctrl = 'menu' self.offset = 0 self.index = 0 self.step = 10 self.play_id = -1 self.play_vol = -1 self.present = [] self.stack = [] self.player = Player() self.ui = UI() self.luoo = Luoo() self.downloader = Downloader() self.database = Database() self.database.load() self.collections = self.database.data['collections'][0] self.screen = curses.initscr() self.screen.keypad(1)
def __init__(self, config_file_path): config = ConfigParser.RawConfigParser() config.read(config_file_path) self._logger = logging.getLogger(__name__) self._ui = UI("lazzormanagement\nbooting...") user_config_file_path = os.path.dirname(config_file_path) + \ os.path.sep + config.get('Users', 'users_file') self._user_manager = UserManager(user_config_file_path) self._lazzor = Lazzor() while True: try: self._upay_session_manager = nupay.SessionManager(config) break except nupay.SessionConnectionError as e: self._logger.warning("Can not reach the database") self._ui.warning_database_connection(timeout = 5) except nupay.TimeoutError as e: self._logger.warning("Timeout while connection to the database") self._ui.warning_database_connection(timeout = 5) self._ui.notify_try_again() self._token_reader = nupay.USBTokenReader()
def list_by_type(self): """ Displays only the apartments having a specific expense type """ self._validate_parsed_command(["expense_type"]) expense_type = self._parsed_command["expense_type"] filtered_bloc_dict = {} for apartment_id in self._bloc_dict.keys(): if self._bloc_dict[apartment_id].expenses[expense_type] != 0: filtered_bloc_dict[apartment_id] = self._bloc_dict[apartment_id] if filtered_bloc_dict: UI.set_message(UI.get_bloc_table(filtered_bloc_dict)) else: UI.set_message("There are no apartments with " + expense_type)
def ui ( self, context, parent = None, kind = None, view_elements = None, handler = None ): """ Creates a UI user interface object. """ if type( context ) is not dict: context = { 'object': context } ui = UI( view = self, context = context, handler = handler or self.handler or default_handler(), view_elements = view_elements ) if kind is None: kind = self.kind ui.ui( parent, kind ) return ui
def __init__(self, current=0): State.__init__(self) self.ui = UI(self, Jules_UIContext) self.nextState = GameStart logo_duration = 20 * 1000 scores_duration = 5 * 1000 self.displays = [(logo_duration, self.draw_logo), (scores_duration, self.draw_high_scores)] self.eventid = TimerEvents.SplashScreen self.current = current self.draw = self.displays[self.current][1] self.instructions = ['Can you think fast and react faster?', 'This game will test both.', 'Your job is to destroy the bonus blocks.', 'Sounds easy, right?... Wrong!', 'There are several problems.', 'If you destroy a penalty block you lose 200 pts.', 'If you get 3 penalties, you lose a life.', 'If you lose 3 lives, the game is over.', 'The bonus and penalty blocks', 'change colors every 5 seconds.', 'And on top of that, if you do not destroy a', 'random non-bonus, non-penalty block every', 'couple of seconds, that will give you a', 'penalty too. Think you got all that?']
def _initme(self, userdata=None): #the main classes self.m = Model(self) self.capture = Capture(self) self.ui = UI(self) return False
def run(self): self.player = Monster(name='Player') self._load_history(self.player) monster = random.choice(list(monsters.viewkeys())) self.monster = Monster(monsters[monster][0], monster, description=monsters[monster][1]) self.ui = UI(self.player) self.ui.monster = self.monster self.ui.welcome() a = 1 while a != 0: self._load_history(self.monster) a = self.run_loop() if a != 0: self.ui.update_display() self._save_history(self.player) self._save_history(self.monster) monster = random.choice(list(monsters.viewkeys())) self.monster = Monster(monsters[monster][0], monster, description=monsters[monster][1]) self.ui.monster = self.monster
class Cuadraditos(activity.Activity): log = logging.getLogger('cuadraditos-activity') def __init__(self, handle): activity.Activity.__init__(self, handle) #flags for controlling the writing to the datastore self.I_AM_CLOSING = False self.I_AM_SAVED = False self.props.enable_fullscreen_mode = False self.ui = None Constants(self) #self.modify_bg(gtk.STATE_NORMAL, Constants.color_black.gColor) #wait a moment so that our debug console capture mistakes gobject.idle_add(self._initme, None) def _initme(self, userdata=None): #the main classes self.m = Model(self) self.capture = Capture(self) self.ui = UI(self) return False def stop_pipes(self): self.capture.stop() def restart_pipes(self): self.capture.stop() self.capture.play() def close(self): self.I_AM_CLOSING = True self.m.UPDATING = False if (self.ui != None): self.ui.hide_all_windows() if (self.capture != None): self.capture.stop() #this calls write_file activity.Activity.close(self) def destroy(self): if self.I_AM_SAVED: activity.Activity.destroy(self)
def list_greater_than(self): """ Displays only the apartments with an overall expense greater than the given amount """ self._validate_parsed_command(["greater"]) greater_than = float(self._parsed_command["greater"]) filtered_bloc_dict = {} for apartment_id in self._bloc_dict.keys(): if self._bloc_dict[apartment_id].get_total_expenses() > greater_than: filtered_bloc_dict[apartment_id] = self._bloc_dict[apartment_id] # check if empty if filtered_bloc_dict: UI.set_message(UI.get_bloc_table(filtered_bloc_dict)) else: UI.set_message("There are no apartments with overall expenses greater than " + str(greater_than))
def main(): """ The main method of the nuncium application will initialize the execution of the program. Threads will be used to query for user input. Each window has its own thread to manage the update of its own interface. """ # UI object: The user interface of the nuncium application. ui = UI() # Integer: The height will consist of the entire screen and the width will # consist of approximately 1/5 of the screen's width. height = curses.LINES width = int(curses.COLS / 5) # String: The default news category that is displayed on startup. category = "Top Stories" # Window object: The window that will render the menu interface. menu_window = ui.window(height, width) ui.display_menu(menu_window, category, color=curses.COLOR_BLUE) # Integer: The starting position in the x-coordinate of the news window will # be rendered where the last window left off. The width of the news # window will consist of the remaining free space. x = width width = curses.COLS - width # Window object: The window that will render the news content. news_window = ui.window(height, width, x, y=0) # News object: The news aggregator of the nunicum application. news = News() news.fetch_news(ui, news_window) ui.cursor(menu_window, x=1, y=1, y2=1, current="Top Stories") # Thread object: A thread used for updating the menu and news content. menu_thread = Thread(target=update, args=(menu_window,), daemon=True) news_thread = Thread(target=update, args=(news_window,), daemon=True) menu_thread.start() news_thread.start() # Wait for the threads to finish working. while running: pass ui.cleanup()
def __init__(self): self.ui = UI() self.popen_handler = None self.play = False self.pause = False self.songs = [] self.play_vol = -1 self.play_id = -1 self.view = 'songs'
def list_greater_than_parse(self, command): """ Parses and validates the 'list greater than' command Input: command - the user command Return: True on valid and False otherwise """ # list greater than <amount> self.set_command(command) pattern_greater = self._regex_search(self._PATTERN_LIST_GREATER) if pattern_greater: greater = pattern_greater.group(1) self._parsed_command = {"greater": greater} return True UI.set_message(UI.get_error("list greater than <amount>")) return False
def main(name="", levelName=None): """Create and run the UI.""" ui = UI() if levelName is None: ui.pushState(WelcomeScreen(ui)) else: print "Directly loading %s" % levelName ui.pushState(LevelSplashScreen(ui, levelName)) ui.run()
def start(self): self.s_termin_io.bind(('localhost', self.io_port)) self.s_termin_io.listen(1) self.client_socket.connect(("localhost", self.port)) self.interrupt_socket.bind('client_interrupt.sock') self.interrupt_socket.listen(1) self.ui = UI(self.c_termin_io, self.io_port, True) client_run = self.run ui_run = self.ui.run threading.Thread(target=ui_run).start() client_run()
def __init__(self, lives=3, score=0): State.__init__(self) self.ui = UI(self, Jules_UIContext) self.lives = lives self.score = score self.nextState = lambda: Playing(self.lives, self.score) self.prompt = "Ready?" self.countdown_step = 500 self.count = 3 self.text = self.prompt self.eventid = TimerEvents.GameStart
def list_less_than(self): """ Displays only the apartments with an overall expense less than the given amount """ self._validate_parsed_command(["less"]) less_than = float(self._parsed_command["less"]) upper_id_limit = self._parsed_command["upper_id_limit"] filtered_bloc_dict = {} for apartment_id in range(1, int(upper_id_limit) + 1): apartment_id = str(apartment_id) if self.is_apartment(apartment_id): if self._bloc_dict[apartment_id].get_total_expenses() < less_than: filtered_bloc_dict[apartment_id] = self._bloc_dict[apartment_id] # check if empty if filtered_bloc_dict: UI.set_message(UI.get_bloc_table(filtered_bloc_dict)) else: UI.set_message("There are no apartments with overall expenses less than " + str(less_than))
def list_less_than_parse(self, command): """ Parses and validates the 'list less than' command Input: command - the user command Return: True on valid and False otherwise """ # less than <amount> before <id> self.set_command(command) pattern_less = self._regex_search(self._PATTERN_LIST_LESS) if pattern_less: less = pattern_less.group(1) upper_id_limit = pattern_less.group(2) self._parsed_command = {"less": less, "upper_id_limit": upper_id_limit} return True UI.set_message(UI.get_error("list less than <amount> before <apartment_id>")) return False
def main(): setproctitle('desktop-security-assistant') args = parse_args() setup_logging(args.debug) conf = load_configuration_files() checks_to_be_displayed = [] for c in scan_and_run_config_blocks(conf): if c.status != 'disabled' and not c.hidden: checks_to_be_displayed.append(c) if args.cli: print_out_checks(checks_to_be_displayed) return ui = UI() for c in checks_to_be_displayed: ui.add_check_tab(c) ui.main()
def filter_parse(self, command): """ Parses and validates the filter command Input: command - the user command Return: True on valid and False otherwise """ self.set_command(command) # filter by total amount greater than pattern_total_greater = self._regex_search(self._PATTERN_FILTER_GREATER_THAN_TOTAL) if pattern_total_greater: greater = pattern_total_greater.group(1) self._parsed_command = {"greater": greater, "type": None} return True # filter by only apartments having that type pattern_by_type = self._regex_search(self._PATTERN_FILTER_BY_TYPE) if pattern_by_type: expense_type = pattern_by_type.group(1) if not Apartment.is_expense_type(expense_type): UI.set_message(UI.get_error_types()) return False self._parsed_command = {"greater": None, "type": expense_type} return True UI.set_message(UI.get_error_filter()) return False
def sort_parse(self, command, reverse=False): """ Parses and validates the sort command Input: command - the user command reverse - the order of the sort Return: True on valid and False otherwise """ self.set_command(command) # simple sort no type use total expense pattern_sort = self._regex_search(self._PATTERN_SORT) if pattern_sort: self._parsed_command = {"type": None, "reverse": reverse} return True # use an expense type for the sort pattern_sort_by_type = self._regex_search(self._PATTERN_SORT_BY_TYPE) if pattern_sort_by_type: expense_type = pattern_sort_by_type.group(1) if not Apartment.is_expense_type(expense_type): UI.set_message(UI.get_error_types()) return False self._parsed_command = {"type": expense_type, "reverse": reverse} return True UI.set_message(UI.get_error_sort()) return False
import wx from ui import UI import logging logging.basicConfig(filename="app.log", filemode="w", level=logging.INFO, format='%(asctime)s - %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p') logging.info("Running: ") try: if __name__ == "__main__": app = wx.App() frm = UI() frm.Show() app.MainLoop() except Exception as e: logging.error(f"main_ui, {e}")
def lc(image_path): ui = UI() ui.load_img(image_path) ui.create_lumi_scale() ui.create_cont_scale() ui.start()
def __init__(self): """Create a reference to the UI, and establish the default nextState.""" self.ui = UI(self) self.nextState = None
def main(): ui = UI(_callback, UISpecs()) # show(ui.layout) curdoc().add_root(ui.layout)
def main(stdscr): test = UI(stdscr, Config()) test.start()
def switch_to_scene(self): self.root.add_widget(self.context.scene) self.root.add_widget(UI()) self.root.remove_widget(self.context.loader) self.context.game.start_round()
from tkinter import * from gui import GUI from ui import UI name = input("Enter your name here: ") uiTYPE = input("Which type of UI would you like(c -> console; g -> gui): ") if uiTYPE == "c": ui = UI(name) elif uiTYPE == "g": root = Tk() my_gui = GUI(root, name) root.mainloop() else: print("If you can't even choose between c and g, I feel bad for you ;)")
def get_random_persons_uids(): person_uids = [] length = random.randrange(1, len(persons)) for i in range(length): person = persons[random.randrange(0, len(persons))] person_uids.append(person.uid) return person_uids activities_len = 10 count = 0 while count < activities_len: try: activity_service.add_activity( Activity(activity_repo.generate_uid(), get_random_persons_uids(), get_random_date(), get_random_time(), get_random_description())) count += 1 except ActivityServiceError: continue ui = UI(person_service, activity_service) ui.run() person_repo.save_data(file=settings.persons) activity_repo.save_data(file=settings.activities)
def stop(): ui = UI() ui.send('shutdown')
def main(): ui = UI() ui.run()
class Game(DirectObject): def __init__(self, app): self.app = app builtins.get_local_file = get_local_file #insert the game into buildins for easy gui callback builtins.game = self #stats self.stats = Stats() builtins.stats = self.stats with loading(): #database self.db = Database('save.db') #init the gui system self.gui = UI() self.gui.software_cursor() #make the main menu self.gui.load_from_file(get_local_file('ui/layout.json')) self.gui.show_hide([ 'special_frame', 'trait_frame', 'perk_frame', 'skill_frame', 'stats_frame', 'level_up', 'level_down', 'level_node', 'items', 'paypal', 'shader', 'save', 'exit' ]) self.stats.update_ui() def toggle_shader(self): if getattr(self, "shader_quad", None) is None: winprops = WindowProperties() winprops.set_size(1024, 600) props = FrameBufferProperties() props.set_rgb_color(True) props.set_rgba_bits(8, 8, 8, 8) props.set_depth_bits(0) props.set_aux_rgba(False) props.set_srgb_color(False) self.fbo = base.graphicsEngine.make_output( base.pipe, 'fbo', -2, props, winprops, GraphicsPipe.BFSizeTrackHost | GraphicsPipe.BFCanBindEvery | GraphicsPipe.BFRttCumulative | GraphicsPipe.BFRefuseWindow, base.win.get_gsg(), base.win) self.fbo.set_clear_color((0, 0, 0, 0)) self.color = Texture() self.color.set_wrap_u(Texture.WM_clamp) self.color.set_wrap_v(Texture.WM_clamp) self.fbo.add_render_texture(tex=self.color, mode=GraphicsOutput.RTMBindOrCopy, bitplane=GraphicsOutput.RTPColor) self.fbo_cam = base.makeCamera2d(self.fbo) cm = CardMaker("quad") cm.set_frame_fullscreen_quad() self.shader_quad = NodePath(cm.generate()) self.shader_quad.set_shader( Shader.load(Shader.SLGLSL, "shaders/crt_v.glsl", "shaders/crt_f.glsl"), 1) self.shader_quad.set_shader_input('color_tex', self.color) self.shader_quad.reparent_to(render2dp) else: if self.shader_quad.is_hidden(): self.shader_quad.show() self.fbo.set_active(True) else: self.shader_quad.hide() self.fbo.set_active(False) def show_preview(self, name): txt = self.db.get_preview(name) self.gui['load_preview'].set_text(txt) self.gui.show_hide('preview_frame') self.last_name = name def load_from_db(self): self.db.load(self.last_name, self.stats) self.toggle_database() self.gui['feedback'].set_text('Character loaded!') self.gui['feedback_node'].show() def save_to_db(self): name = self.gui['name_input'].get() keys = self.gui['tag_input'].get() self.db.save(name, keys, self.stats) self.search(True) def search(self, show_all=False): #remove old buttons names_to_remove = [] for name, element in self.gui.elements.items(): if name.startswith('charater_load_'): names_to_remove.append(name) for name in names_to_remove: self.gui.remove_button(name) #find characters if show_all: records = self.db.search() else: records = self.db.search(self.gui['search_input'].get()) #create buttons for name, keys, s, p, e, c, i, a, l in records: txt = '{name:<38}{keys:<59}{s:<8}{p:<8}{e:<8}{c:<8}{i:<8}{a:<8}{l:<8}'.format( name=name, keys=keys, s=s, p=p, e=e, c=c, i=i, a=a, l=l) self.gui.button(txt=txt, sort_dict={ "name": name, "tag": keys, "s": s, "p": p, "e": e, "c": c, "i": i, "a": a, "l": l }, cmd="game.show_preview('" + name + "')", parent="database_frame_canvas", width=1000, pos=[3, i * 32], mono_font=1, center=0, name='charater_load_' + name.lower().replace(' ', '_')) self.gui.sort_buttons('database_frame_canvas', 'name') def toggle_database(self): if self.gui['trait_frame'].is_hidden(): self.toggle_inventory() popup = ['database_frame', 'save_frame'] editor = [ 'special_frame', 'trait_frame', 'perk_frame', 'skill_frame', 'stats_frame', 'level_up', 'level_down', 'items', 'paypal', 'shader', 'save', 'exit', 'level_node' ] if self.gui['database_frame'].is_hidden(): self.gui.show_hide(popup, editor) self.search(True) else: self.gui.show_hide(editor, popup) self.gui.show_hide(None, 'preview_frame') def toggle_inventory(self): if self.gui['trait_frame'].is_hidden(): self.gui.show_hide( ['trait_frame', 'perk_frame', 'skill_frame'], ['bonus_frame', 'weapon_frame', 'target_frame', 'hit_frame']) self.gui['items']['text'] = 'INVENTORY' else: if self.stats.level == 1: self.gui['feedback'].set_text('Level up first!') return self.gui.show_hide( ['bonus_frame', 'weapon_frame', 'target_frame', 'hit_frame'], ['trait_frame', 'perk_frame', 'skill_frame']) self.gui['items']['text'] = 'CHARACTER' def support(self, hide=False): popup = 'support_frame' editor = [ 'special_frame', 'trait_frame', 'perk_frame', 'skill_frame', 'stats_frame', 'level_up', 'level_down', 'items', 'paypal', 'shader', 'save', 'exit', 'level_node' ] if hide: self.gui.show_hide(editor, popup) self.gui['items']['text'] = 'INVENTORY' else: self.gui.show_hide(popup, editor) self.gui.show_hide( [], ['bonus_frame', 'weapon_frame', 'target_frame', 'hit_frame']) def do_nill(self): pass def save_screen(self): base.screenshot('character') def exit_game(self): with open('config.ini', 'w') as config_filename: Config.write(config_filename) self.app.final_exit()
""" __Author__: Romain Maillard __Date__: 27.09.2017 __Name__: startLiveDisplay.py __Description__: Load configuration, start UI """ import config import time from ui import UI print("Start LiveDisplay") #create and start the usre interface userInterface = UI() userInterface.start() print("Stop LiveDisplay")
def runWizard(self): print('Ports.runWizard()') #myself = Ports() self.print_map() return UI.ask_integer('What port would you like to assign to this domain?')
from board import Board from ui import UI board = Board() ui = UI(board) ui.read()
def __init__(self): self.ui = UI(DataManager())
def register(): UI.register()
def unregister(): UI.unregister()
def __init__(self): question_bank = QuestionBank(DataManager(), Question).generate() quiz = Quiz(question_bank) self.ui = UI(quiz)
arena_size = 10 game_count = 10 try: if (len(sys.argv) == 4): gladiator_count = int(sys.argv[1]) arena_size = int(sys.argv[2]) game_count = int(sys.argv[3]) except Exception as e: print(e) print("Invalied arguments. Default parameters will be set.") sleep(2) ui = UI(space_length) for i in range(game_count): battleground = Battleground(arena_size, arena_size) gladiators = [] for i in range(gladiator_count): gladiators.append(Gladiator(battleground,ascii_uppercase[i],random.randint(1,3),random.randint(1,5),100)) while True: os.system("cls") for gladiator in gladiators: if gladiator in battleground.gladiators: if len(battleground.gladiators) > 1:
from sys import exit, argv from PyQt5.QtWidgets import QApplication from ui import UI from pack import Pack pack = Pack(512, 512, False) pack.insert(256, 256) pack.insert(128, 128) pack.insert(64, 64) pack.insert(32, 32) pack.insert(16, 16) pack.insert(8, 8) pack.insert(4, 4) pack.insert(2, 2) pack.insert(100, 100) pack.insert(200, 50) pack.insert(400, 25) pack.insert(50, 200) pack.insert(25, 400) pack.insert(100, 100) pack.insert(200, 50) pack.insert(400, 25) pack.insert(50, 200) pack.insert(25, 400) app = QApplication(argv) ui = UI(pack) ui.show() exit(app.exec_())
class KVStore: def __init__(self, evloop, nodeslist): self.evloop = evloop self.network = AsyncNetwork(self.evloop, nodeslist) self.ui = UI(self.evloop) self.ui.output('=============================') self.ui.output('==== Distributed KVStore ====') self.ui.output('=============================') self.ui.output(f'ID: {AsyncNetwork.OWN_ID + 1:02d}') self.ui.output(f'IP ADDR: {AsyncNetwork.OWN_IP}') async def main(self): await self.network.create_server() await self.network.connect_to_peers() try: while True: command = await self.ui.input() if command == '': continue cmd = command.split()[0] data = command.split()[1:] cmd_handler = getattr(self, f'cmd_{cmd.lower()}', None) if cmd_handler is None: self.ui.output(f'Unknown command "{cmd}"...') else: await cmd_handler(data) except asyncio.CancelledError: self.network.close() self.ui.output('\nBYE!') async def cmd_set(self, data): if len(data) < 2: self.ui.output(f'Invalid! Usage: SET <key> <value>') return key = data[0] value = ' '.join(data[1:]) hashed_key = Store.hash(key) logging.info(f'Key {key} hashed to {hashed_key}') dest = AsyncNetwork.placement(hashed_key) msg = SetMsg(key, value) if dest is None: logging.info('Storing in self!') self.network.handle_SetMsg(msg) self.ui.output('SET OK') else: # dest is a Peer object event = asyncio.Event() AsyncNetwork.requests[msg.uid] = (event, None) try: await asyncio.wait_for(dest.send(msg), 2, loop=self.evloop) await asyncio.wait_for(event.wait(), 3, loop=self.evloop) except asyncio.TimeoutError: # TODO: try sending to another peer logging.error('Failed to send SetMsg!') self.ui.output('SET FAILED') else: self.ui.output('SET OK') finally: del AsyncNetwork.requests[msg.uid] # sendlist = [] # reqlist = [] # for node, peer in AsyncNetwork.nodes.items(): # if peer is not None: # msg = SetMsg(key, value) # event = asyncio.Event() # # sendlist.append(peer.send(msg)) # AsyncNetwork.requests[msg.uid] = (event, None) # reqlist.append(msg.uid) # # await asyncio.wait(sendlist, loop=self.evloop, timeout=3) # done, pending = await asyncio.wait( # [AsyncNetwork.requests[uid][0].wait() for uid in reqlist], # loop=self.evloop, timeout=3 # ) # # if len(done) >= 1: # self.ui.output('SET OK') # else: # self.ui.output('SET FAILED') # # clean up the requests # for uid in reqlist: # del AsyncNetwork.requests[uid] async def cmd_get(self, data): if len(data) != 1: self.ui.output(f'Invalid! Usage: GET <key>') return key = data[0] curr_id = AsyncNetwork.placement(key, return_id=True) succ_id = (curr_id + 1) % 10 pred_id = 9 if curr_id == 0 else (curr_id - 1) # get successor ID while True: if succ_id == AsyncNetwork.OWN_ID: break if AsyncNetwork.nodes[AsyncNetwork.ids[succ_id]] is not None: break succ_id = (succ_id + 1) % 10 # get predecessor ID while True: if pred_id == AsyncNetwork.OWN_ID: break if AsyncNetwork.nodes[AsyncNetwork.ids[pred_id]] is not None: break pred_id = 9 if pred_id == 0 else (pred_id - 1) try_ids = [curr_id, succ_id, pred_id] msg = GetMsg(key) for tryid in try_ids: logging.info(f'Trying to GetMsg from ID: {tryid+1}') if tryid == AsyncNetwork.OWN_ID: # get key from self value = self.network.handle_GetMsg(msg, ret=True) if value is not None: self.ui.output(f'Found: {value}') return else: dest = AsyncNetwork.nodes[AsyncNetwork.ids[tryid]] if dest is None: # succ or pred is not alive continue event = asyncio.Event() AsyncNetwork.requests[msg.uid] = (event, None) try: await asyncio.wait_for(dest.send(msg), 2, loop=self.evloop) await asyncio.wait_for(event.wait(), 3, loop=self.evloop) except asyncio.TimeoutError: logging.error('Failed to send GetMsg!') else: value = AsyncNetwork.requests[msg.uid][1].value if value is not None: self.ui.output(f'Found: {value}') del AsyncNetwork.requests[msg.uid] return finally: if msg.uid in AsyncNetwork.requests: del AsyncNetwork.requests[msg.uid] # none of the try_ids worked self.ui.output('Not found') # sendlist = [] # reqlist = [] # for node, peer in AsyncNetwork.nodes.items(): # if peer is not None: # msg = GetMsg(key) # event = asyncio.Event() # # sendlist.append(peer.send(msg)) # AsyncNetwork.requests[msg.uid] = (event, None) # reqlist.append(msg.uid) # # # TODO: add check for empty sendlist # await asyncio.wait(sendlist, loop=self.evloop, timeout=3) # done, pending = await asyncio.wait( # [AsyncNetwork.requests[uid][0].wait() for uid in reqlist], # loop=self.evloop, timeout=3 # ) # # if len(done) >= 1: # values = [AsyncNetwork.requests[uid][1].value for uid in reqlist] # for val in values: # if val is not None: # self.ui.output(f'Found: {val}') # # clean up the requests # for uid in reqlist: # del AsyncNetwork.requests[uid] # return # # if we reach here, we could not find the key # self.ui.output('Not found') # # clean up the requests # for uid in reqlist: # del AsyncNetwork.requests[uid] async def cmd_owners(self, data): if len(data) != 1: self.ui.output(f'Invalid! Usage: OWNERS <key>') return key = data[0] curr_id = AsyncNetwork.placement(key, return_id=True) succ_id = (curr_id + 1) % 10 pred_id = 9 if curr_id == 0 else (curr_id - 1) # get successor ID while True: if succ_id == AsyncNetwork.OWN_ID: break if AsyncNetwork.nodes[AsyncNetwork.ids[succ_id]] is not None: break succ_id = (succ_id + 1) % 10 # get predecessor ID while True: if pred_id == AsyncNetwork.OWN_ID: break if AsyncNetwork.nodes[AsyncNetwork.ids[pred_id]] is not None: break pred_id = 9 if pred_id == 0 else (pred_id - 1) try_ids = [curr_id, succ_id, pred_id] msg = GetOwners(key) owners = [] for tryid in try_ids: logging.info(f'Trying to GetOwners from ID: {tryid+1}') if tryid == AsyncNetwork.OWN_ID: # get key from self is_owner = self.network.handle_GetOwners(msg, ret=True) if is_owner: owners.append(tryid) else: dest = AsyncNetwork.nodes[AsyncNetwork.ids[tryid]] if dest is None: # succ or pred is not alive continue event = asyncio.Event() AsyncNetwork.requests[msg.uid] = (event, None) try: await asyncio.wait_for(dest.send(msg), 2, loop=self.evloop) await asyncio.wait_for(event.wait(), 3, loop=self.evloop) except asyncio.TimeoutError: logging.error('Failed to send GetOwners!') else: is_owner = AsyncNetwork.requests[msg.uid][1].is_owner if is_owner: owners.append(tryid) del AsyncNetwork.requests[msg.uid] finally: if msg.uid in AsyncNetwork.requests: del AsyncNetwork.requests[msg.uid] outstr = ['{:02d}'.format(owner + 1) for owner in owners] self.ui.output(' '.join(outstr)) async def cmd_list_local(self, data): if len(data) != 0: self.ui.output(f'Invalid! Usage: LIST_LOCAL') return keys = [] keys.extend(Store.hash_table.keys()) for replica in Store.replicas.keys(): keys.extend(Store.replicas[replica].keys()) for key in sorted(keys): self.ui.output(f'{key}') self.ui.output('END LIST') async def cmd_batch(self, data): if len(data) != 2: self.ui.output(f'Invalid! Usage: BATCH <file1> <file2>') return infile = open(data[0], 'r') outfile = open(data[1], 'w') self.ui.set_output_to_return(True, outfile=outfile) for line in infile: if line.strip() == '': continue cmd = line.split()[0] data = line.split()[1:] cmd_handler = getattr(self, f'cmd_{cmd.lower()}', None) if cmd_handler is None: self.ui.output(f'Unknown command "{cmd}"...') else: await cmd_handler(data) await asyncio.sleep(0.2, loop=self.evloop) infile.close() outfile.close() self.ui.set_output_to_return(False) ####### CUSTOM COMMANDS ####### async def cmd_connected(self, data): connected = [ ip for ip, peer in AsyncNetwork.nodes.items() if peer != None ] self.ui.output('\n'.join(connected)) async def cmd_pending(self, data): pending = len(AsyncNetwork.requests.keys()) self.ui.output(f'{pending} pending requests...') async def cmd_time(self, data): self.ui.output(str(time.time()))
''' Created on Nov 7, 2015 @author: aflorea ''' from ui.UI import * from repository.repo import * from controller.controller import * pRepository = PersonsRepository() aRepository = ActivityRepository() mRepository = mapRepository() pController = PersonController(pRepository, mRepository) aController = ActivityController(aRepository) aUI = UI(pController, aController) aUI.mainMenu()
from repository import Repository from service import Service from ui import UI path = r"C:\Users\Andreea\Desktop\Facultate\Anul_II\Sem2\AI\GA_TSP\data\berlin.in" repo = Repository(path) service = Service(repo) ui = UI(service) ui.main()
from get_char import Switch from rockdb import RockDB from check import Check from ui import UI from random_fill import RandomFillDB from pprint import pprint db = RockDB() ui = UI() def add_entity(name): if name == "band": band = ui.band_input() db.insert_band(band) elif name == "album": db.insert_album(ui.album_input()) elif name == "song": db.insert_song(ui.song_input()) def update_entity(name): if name == "band": band_entity = ui.band_update() if band_entity is not None: db.update_band(band_entity) return True elif name == "album":
def play_game(self): table = Table() game = Game(table, self.player, lives=self.max_lives) ui = UI(game) ui.start()
def wait_for_menu_input(self): return UI.menu_input()
def hm(image_path_1, image_path_2): if (image_path_2 == ''): ui = UI() ui.load_img(image_path_1, label="source", row=1, col=0) ui.create_hm_single_buttons(row=4, col=1) ui.load_img(image_path_1, label="result", row=4, col=0) ui.start() else: ui = UI() ui.load_img(image_path_1, label="source", row=1, col=0) ui.load_img(image_path_2, label="target", row=1, col=1) ui.create_hm_buttons(row=4, col=1) ui.load_img(image_path_1, label="result", row=4, col=0) ui.start()
def display_menu(self): UI.display_menu(self.menu.make_menu_text())
#!/usr/bin/env python3 from ui import UI import argparse if __name__ == "__main__": parser = argparse.ArgumentParser( description="Run an infection simulation.") parser.add_argument('-v', '--verbose', help='Be verbose', action='store_true') parser.add_argument('-s', '--seed', help='Set seed for the random generator', type=int) args = vars(parser.parse_args()) ui = UI(args['verbose'], args['seed']) ui.initSimulation() input("Press Enter to start simulation") ui.startSimulation()
#!/usr/bin/env python # -*- coding:utf-8 -*- from ui import UI from sys import argv if __name__ == '__main__': testmode = len(argv) > 1 and argv[1] == 'test' UI(testmode).start()