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()
