def main(): BorrowRepo = BorrowRepository("borrow.txt") DvdRepo = DvdRepository("dvd.txt") ctrl = Controller(BorrowRepo,DvdRepo) ui = UI(ctrl) ui.run()
def start_workers(num_agents: int = 1, env_name: str = '', state_builder: StateBuilder = None, num_epochs: int = 2001, update_frequency: int = 10): State.num_agents = num_agents for agent in range(num_agents): controller = Controller(learner=None, env_id=env_name, state_builder=state_builder, update_freq=update_frequency, id=agent) learner = QLearner(controller.get_action_space(), epsilon=0.1, init_alpha=.5, gamma=.9, decay_rate=.999) controller.set_learner(learner) agent_thread = threading.Thread(target=controller.train, kwargs={ "number_epochs": num_epochs, "save_location": '../models/{}-{}.model'.format( env_name, agent) }) agent_thread.start() return
def config(self): self.readSettings() clientRepo = None bookRepo = None rentalRepo = None if self.__settings['repository'] == "in-memory": clientRepo = ClientRepo() bookRepo = BookRepo() rentalRepo = RentalRepo() clientRepo.initialiseclients() bookRepo.initialisebooks() rentalRepo.initialiserentals() if self.__settings['repository'] == "text-file": clientRepo = FileClientRepo2(self.__settings["clients"]) bookRepo = FileBookRepo(self.__settings["books"]) rentalRepo = FileRentalRepo(self.__settings["rentals"]) if self.__settings['repository'] == "binary": clientRepo = BinaryClientRepo(self.__settings["clients"]) bookRepo = BinaryBookRepo(self.__settings["books"]) rentalRepo = BinaryRentalRepo(self.__settings["rentals"]) undo = UndoController() ctrl = Controller(bookRepo, clientRepo, rentalRepo, undo) ui = None if self.__settings['ui'] == "console": ui = UI(ctrl) if self.__settings['ui'] == 'gui': ui = GUI(ctrl) return ui
async def test_controller_remove_population(self): _ctl = Controller() _ctlSpace = ControllableSpace(name='test', maxPopulation=50) _ctl.addControllableSpace(_ctlSpace) _ctlTask = asyncio.ensure_future(_ctl.start()) _stopCtlTask = asyncio.ensure_future( ControllerTestCase.stop_controller(controller=_ctl)) _watchCtl = asyncio.ensure_future( ControllerWatcher(sleepInterval=1.0, controller=_ctl).start()) async def addControllableItems(howMany: int = 10): tries = 0 while True: logging.info(f'Adding {howMany} items') for _i in range(howMany): _ctl.addControllableItem(ControllableItem( objectLocation=self._nyc, controllable=True, name=f'name_{_i}_{tries}', parentController=_ctl), ctlSpace=_ctlSpace.name) await asyncio.sleep(0.2) tries += 1 await asyncio.sleep(1.0) async def removeControllableItems(howMany: int = 10): tries = 0 await asyncio.sleep(5.0) logging.info(f'Removing {howMany} items') for _i in range(howMany): _ctl.removeControllableItem(name=f'name_{_i}_{tries}', ctlSpace='test') await asyncio.sleep(3.0) _addCtlTask = asyncio.ensure_future(addControllableItems()) _delCtlTask = asyncio.ensure_future(removeControllableItems()) await _ctlTask await _stopCtlTask try: await _watchCtl except Exception as e: logging.exception(e) try: await _addCtlTask except MaxControllableSpacePopulationException as e: logging.exception(e) try: _delCtlTask.cancel() except Exception as e: logging.exception(e) logging.info('Test completed') self.assertEqual(50, _ctl.getControllablePopulation('test')) self.assertEqual(_ctl.controllerStop, True)
def test_cell_click(self): """when a cell is clicked, its text should appear in the top_text""" controller = Controller(self.grid) controller.clickAt((0, 0)) self.assertEqual("cell content", controller.getTopText())
def main(self): filename = "sudoku.txt" problem = Problem() problem.readFromFile(filename) contr = Controller(problem) cons = Console(contr) cons.mainMenu()
def main(): init() banner = ''' _____ _____ _____ |_ _| __ \\ / ____| | | | |__) |_____| | __ ___ ___ | | | ___/______| | |_ |/ _ \\/ _ \\ _| |_| | | |__| | __/ (_) | |_____|_| \\_____|\\___|\\___/ --------------------------------------- Created by : Homeless Version : 1.0.0 --------------------------------------- ''' print(Fore.RED + banner) ctrl = Controller() try: while True: try: print(Fore.GREEN + "[1] INGRESAR API-KEY MAXMIND.") print(Fore.GREEN + "[2] CONSULTAR IP.") print(Fore.GREEN + "[3] SALIR", end='\n\n') option = int(input("INGRESAR OPCION > ")) if option == 1: ctrl.add_api_key() continue elif option == 2: try: ctrl.query_ip() continue except ValueError as ex: print(Fore.RED + "[X] " + ex.__str__(), end="\n\n") elif option == 3: ctrl.exit_program() continue else: print(Fore.RED + "[X] Opcion no valida", end="\n\n") except ValueError: print(Fore.RED + "[X] Opcion no valida", end="\n\n") continue except requests.HTTPError as ex: print(Fore.RED + "[X] API-KEY Maxmind: " + ex.__str__(), end="\n\n") continue except KeyboardInterrupt: exit(0)
def main(): # Taxi-v2 cart_pole_ctrl = Controller(None, 'CartPole-v1', StateBuilderCartPole(), communicate=False) # cart_pole_ctrl = Controller(None, 'Taxi-v2', None, communicate=False) # cart_pole_ctrl = Controller(None, 'LunarLander-v2', state_builder=StateBuilderLunarLander(), communicate=False) # cart_pole_ctrl = Controller(None, 'FrozenLake-v0', None, communicate=False) running_cumulative_reward = [] for _ in range(3): learner = QLearner(cart_pole_ctrl.get_action_space(), epsilon=0.1, init_alpha=.5, gamma=.9, decay_rate=.999) cart_pole_ctrl.set_learner(learner) cumulative_reward, num_steps = cart_pole_ctrl.train(number_epochs=2001) running_cumulative_reward.append(cumulative_reward) ar = np.array(running_cumulative_reward) means = np.mean(ar, axis=0) standard_errors = scipy.stats.sem(ar, axis=0) uperconf = means + standard_errors lowerconf = means - standard_errors # avg_cumulative = ar.sum(axis=0) # avg_cumulative = avg_cumulative/len(running_cumulative_reward) x = np.arange(0, len(means)) # plt.plot(x, means, 'o') z = np.polyfit(x, means, 5) p = np.poly1d(z) plt.plot(x, p(x)) plt.fill_between(x, uperconf, lowerconf, alpha=0.3, antialiased=True) # plt.ylim(ymax=50, ymin=-800) plt.show() plt.close() # z = np.arange(0, len(num_steps)) # plt.plot(z, num_steps) # plt.show() # plt.close() cart_pole_ctrl.env.close()
def testSwap(self): repo = Repository() controller = Controller(repo) controller._guess = controller.getAll()[0] assert controller._guess[1] == 'c' assert controller._guess[2] == 'r' controller.swap(0, 1, 0, 2) assert controller._guess[1] == 'r' assert controller._guess[2] == 'c'
def __init__(self): Observer.__init__(self) self.window = tk.Tk() self.config = json.load(open("algorithms_config.json")) self.controller = Controller(self.config) self.window.protocol("WM_DELETE_WINDOW", self.on_closing) self.observe("ReloadConfigEvent", self.__on_reload_config) ###Utilities### self.maxwidth = self.window.winfo_screenwidth() self.maxheight = self.window.winfo_screenheight() self.width = int(self.maxwidth * 0.9) self.height = int(self.maxheight * 0.62) self.f1 = WorkingArea(self.width, self.height, Location.SUBTYPE, self.controller, self.window, self.config) self.f2 = WorkingArea(self.width, self.height, Location.SUPERTYPE, self.controller, self.window, self.config) self.custommenu = MenuView(self.window, self.config)
async def test_controller(self): _ctl = Controller() _ctlSpace = ControllableSpace(name='test', maxPopulation=50) _ctl.addControllableSpace(_ctlSpace) _ctlTask = asyncio.ensure_future(_ctl.start()) _stopCtlTask = asyncio.ensure_future( ControllerTestCase.stop_controller(controller=_ctl)) _watchCtl = asyncio.ensure_future( ControllerWatcher(sleepInterval=1.0, controller=_ctl).start()) await _ctlTask await _stopCtlTask try: await _watchCtl except Exception as e: logging.exception(e) logging.info('Test completed') self.assertEqual(_ctl.controllerStop, True)
def set_up_env(args): # Initialize agent and environment controller = Neurosmash.Agent() # This is an example agent. if args.use_controller: controller = Controller(args) # This is the main environment. try: environment = Neurosmash.Environment(args) except: print( "Connecting to environment failed. Please make sure Neurosmash is running and check your settings." ) print( f"Settings from world model: ip={args.ip}, port={args.port}, size={args.size}, timescale={args.timescale}" ) else: print("Successfully connected to Neurosmash!") return controller, environment
def use_model(): cart_pole_ctrl = Controller(None, 'CartPole-v1', StateBuilderCartPole(), communicate=False) # cart_pole_ctrl = Controller(None, 'Taxi-v2', None) # cart_pole_ctrl = Controller(None, 'LunarLander-v2', state_builder=StateBuilderLunarLander(), communicate=False) learner = QLearner(cart_pole_ctrl.get_action_space(), epsilon=0.0, init_alpha=.5, gamma=.9) cart_pole_ctrl.set_learner(learner) cart_pole_ctrl.load("models/CartPole-v1-7.model") count = 0 while True: cart_pole_ctrl.run(render=True) count += 1 print("Epoch {}".format(count))
def start_reference_aggregated_learner(env_name: str = ''): state_builder = StateBuilderCache.builders.get(env_name, None) controller = Controller(learner=None, env_id=env_name, state_builder=state_builder) learner = QLearner(controller.get_action_space(), epsilon=0.1, init_alpha=.5, gamma=.9, decay_rate=.999) # SET MODEL with copy of Server Model learner.set_model(copy.deepcopy(QServer.Q)) controller.set_learner(learner) agent_thread = threading.Thread(target=controller.run) agent_thread.start() print('Started Reference Learner') return
def main(): controller = Controller() controller.start_app()
""" Created on 29/01/2017 @author Stefan """ from console.console import Console from controller.Controller import Controller from controller.UndoController import UndoController from repository.SentenceRepository import SentenceRepository if __name__ == '__main__': sentence_repo = SentenceRepository() controller = Controller(sentence_repo) undo_controller = UndoController() console = Console(controller, undo_controller) console.run()
''' Created on Mar 14, 2017 @author: Utilizator ''' from ui.Console import Console from controller.Controller import Controller from domain.Graph import Graph graph = Graph( "C:\\Users\\Utilizator\\Desktop\\University\\Semester 2\\Graph Algorithms\\Lab1\\graph" ) ui = Console(Controller(graph)) ui.runApp()
''' Created on Jan 23, 2017 @author: Madalina ''' from repository.Repository import Repository from controller.Controller import Controller from ui.UI import UI repo = Repository() controller = Controller(repo) ui = UI(controller) ui.mainMenu()
def test_top_text_edit(self): controller = Controller(self.grid) controller.clickAt((1, 1)) controller.writeTopText("A new hope") self.assertEqual("A new hope", controller.getCurrentCellContent())
return settings settings = readSettings() studRepo = None assRepo = None grdRepo = None if 'CSV' == settings['repository']: studRepo = StudCSVFileRepository(settings['students']) assRepo = AssCSVFileRepository(settings['assignments']) grdRepo = GradeCSVFileRepository(settings['assignments'], settings['students']) if 'binary' == settings['repository']: studRepo = PickleFileRepository(settings['students']) assRepo = PickleFileRepository(settings['assignments']) grdRepo = PickleFileRepository(settings['grades']) assValidator = AssignmentValidator() studValidator = StudentValidator() opList = [] undoCtrl = UndoController(opList) studCtrl = StudentController(studRepo, studValidator) assCtrl = AssignmentController(assRepo, assValidator) grdCtrl = GradeController(grdRepo, assRepo, studRepo) statCtrl = StatisticsController(grdRepo) ctrl = Controller(studCtrl, assCtrl, grdCtrl, statCtrl, undoCtrl) ui = UI(ctrl, undoCtrl) ui.start()
doc_id = flask.request.args.get('doctorID') date = flask.request.args.get('date') return json.dumps(controller.getDocApps(int(doc_id), date)) @app.route("/deleteAppointment", methods=['DELETE']) def deleteAppointment(): doc_id = flask.request.args.get('doctorID') app_id = flask.request.args.get('appointmentID') return controller.deleteDocAppointment(int(doc_id), int(app_id)) @app.route("/addAppointment", methods=['POST']) def addAppointment(): doc_id = int(flask.request.args.get('doctorID')) f_name = flask.request.args.get('fName') l_name = flask.request.args.get('lName') date = flask.request.args.get('date') time = flask.request.args.get('time') kind = flask.request.args.get('kind') return json.dumps( controller.addAppointment(doc_id, f_name, l_name, date, time, kind)) if __name__ == '__main__': controller = Controller() app.run(host='0.0.0.0', debug=True)
from controller.Controller import Controller from models.HashTable import HashTable from models.Scanner import Scanner from models.Specification import Specification if __name__ == '__main__': fileName = input("Insert file name: ") controller = Controller(HashTable(), Scanner(Specification()), []) controller.run(fileName) controller.saveData()
def initStudents(): strepo.store(Student("1", "Ma Rupe", "916")) strepo.store(Student("2", "Tema Asta", "913")) strepo.store(Student("3", "Foarte Tare", "910")) strepo.store(Student("4", "Ioana", "915")) def initAssignments(): assrepo.store(Assignment("7", "descriere 1", "5.6")) assrepo.store(Assignment("8", "descriere nr 2", "12.10")) assrepo.store(Assignment("9", "descriere 4", "13.12")) assrepo.store(Assignment("10", "Spelling", "14.12")) def initGrades(): grdrepo.store( Grade("5", Assignment("10", "Spelling", "14.12"), Student("4", "Ioana", "915"), "6")) initStudents() initAssignments() initGrades() undoctrl = UndoController(opList) stctrl = StudentController(strepo, stvalidator) assctrl = AssignmentController(assrepo, assvalidator) grdctrl = GradeController(grdrepo, assrepo, strepo) ctrl = Controller(stctrl, assctrl, grdctrl, undoctrl) ui = UI(ctrl, undoctrl) ui.start()
def create_app(): app = Flask(__name__) app.config.from_object("settings") #app.config.from_object("settings") Controller(app).initialRouter() return app
# Created by Lionel Kornberger at 2019-04-01 import sys from PySide2.QtWidgets import QApplication from view.MainWindow import MainWindow from controller.Controller import Controller if __name__ == '__main__': app = QApplication(sys.argv) ui = MainWindow() ui.show() controller = Controller(ui) ui.set_controller(controller) sys.exit(app.exec_())
def __init__(self): QtGui.QWidget.__init__(self) self.batch_tracking_enabled = False #main widget self.setObjectName(_fromUtf8("self")) self.resize(1000, 835) self.setMinimumSize(QtCore.QSize(450, 770)) # main vertical layout self.vertLO_main = QtGui.QVBoxLayout(self) self.vertLO_main.setObjectName(_fromUtf8("vertLO_main")) # horizontal layout video + options self.hoLO_video_plus_options = QtGui.QHBoxLayout() self.hoLO_video_plus_options.setObjectName( _fromUtf8("hoLO_video_plus_options")) # graphical output label # self.lbl_video_output_label = QtGui.QLabel(self) # self.lbl_video_output_label.setMinimumWidth((self.geometry().width()-22)/2) # self.lbl_video_output_label.setObjectName(_fromUtf8("lbl_videl_output_label")) # self.lbl_video_output_label.setAlignment(QtCore.Qt.AlignCenter) # self.hoLO_video_plus_options.addWidget(self.lbl_video_output_label) # options tab widget self.tab_widget_options = QtGui.QTabWidget(self) self.tab_widget_options.setObjectName(_fromUtf8("tab_widget_options")) # file tab self.tab_file = TabFile() self.tab_widget_options.addTab(self.tab_file, _fromUtf8("")) # roi tab self.tab_roi = TabRoi() self.tab_widget_options.addTab(self.tab_roi, _fromUtf8("")) # adv tab self.tab_adv = TabAdv() self.tab_widget_options.addTab(self.tab_adv, _fromUtf8("")) # visuals tab self.tab_visual = TabVisual() self.tab_widget_options.addTab(self.tab_visual, _fromUtf8("")) # meta tab self.tab_meta = TabMeta() self.tab_widget_options.addTab(self.tab_meta, _fromUtf8("")) # add options widget to horizontal layout self.hoLO_video_plus_options.addWidget(self.tab_widget_options) # add video_plus_options tab to main widget self.vertLO_main.addLayout(self.hoLO_video_plus_options) # horizontal layout bot buttons self.hoLO_bot_buttons = QtGui.QHBoxLayout() self.hoLO_bot_buttons.setObjectName(_fromUtf8("hoLO_bot_buttons")) # button start tracking self.btn_start_tracking = QtGui.QPushButton(self) self.btn_start_tracking.setMinimumSize(QtCore.QSize(0, 50)) self.btn_start_tracking.setObjectName(_fromUtf8("btn_start_tracking")) self.btn_start_tracking.setDisabled(False) self.hoLO_bot_buttons.addWidget(self.btn_start_tracking) # vertical layout file label and progress label self.vert_lo_file_progress = QtGui.QVBoxLayout() # file bel self.lbl_file = QtGui.QLabel() self.lbl_file.setObjectName(_fromUtf8("lbl_file")) self.lbl_file.setText(_fromUtf8("no file started")) self.vert_lo_file_progress.addWidget(self.lbl_file) # progress label self.lbl_progress = QtGui.QLabel() self.lbl_progress.setObjectName(_fromUtf8("lbl_progress")) self.lbl_progress.setText(_fromUtf8("Progress:")) self.vert_lo_file_progress.addWidget(self.lbl_progress) self.hoLO_bot_buttons.addLayout(self.vert_lo_file_progress) # button abort tracking self.btn_abort_tracking = QtGui.QPushButton(self) self.btn_abort_tracking.setMinimumSize(QtCore.QSize(0, 50)) self.btn_abort_tracking.setObjectName(_fromUtf8("btn_abort_tracking")) self.btn_abort_tracking.setDisabled(True) self.hoLO_bot_buttons.addWidget(self.btn_abort_tracking) # add button layout to main widget layout self.vertLO_main.addLayout(self.hoLO_bot_buttons) self.retranslate_ui(self) self.tab_widget_options.setCurrentIndex(0) QtCore.QMetaObject.connectSlotsByName(self) self.controller = Controller(self) self.connect_controller_to_tabs() self.tracker = Tracker(controller=self.controller) # self.tab_roi.populate(self.tracker.roim) self.controller.preset_options() self.connect_widgets() self.set_shortcuts()
factory = OrganismFactory() # add one human org = factory.createOrganism(SpeciesEnum.HUMAN, model.getFreePositionInWorld()) org.world = model model.addOrganism(org) # add the rest for sp in SpeciesEnum: propName = "number_of_{0}".format(sp.name.lower()) if propName in globals(): propValInt = globals()[propName] # print(propValInt) if propName and not propName == "number_of_human": for i in range(0, propValInt): org = factory.createOrganism( sp, model.getFreePositionInWorld()) if org: org.world = model model.addOrganism(org) # -------------- # Simple MVC # -------------- app = wx.App(False) ogl.OGLInitialize() view = View(None) controller = Controller(app, model, view) app.MainLoop()
from controller.Controller import Controller app = Controller() app.mainloop()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._ctl = Controller()
from UI.UI import UI from controller.Controller import Controller ctrl = Controller() ui = UI(ctrl) ui.run()