def main(): cols, rows = 10, 10 screen = Screen(500, 500, rows) screen.show() screen.makeGrid() grid = [[Spot(screen, i, j) for j in range(0, rows)] for i in range(0, cols)] for i in range(0, cols): for j in range(0, rows): grid[i][j].addNeigbors(grid, cols, rows) start = grid[0][0] start.obstacle = False stop = grid[cols - 1][rows - 1] stop.obstacle = False pathFinder = PathFinder(grid, start, stop) while True: for event in pygame.event.get(): if (event.type == pygame.QUIT): screen.close() result = pathFinder.findPath() pathFinder.showOpenSet() pathFinder.showPath() screen.update()
def main_old(): screen = Screen(600, 600) screen.start() b = [] active = True tic = TicTacToe() tic.start(screen) reset_counter = 0 while (active): if (tic.show(screen) == -1): tic = TicTacToe() tic.start(screen) continue act = screen.act() if (isinstance(act, (list, tuple))): if (act[0] >= 0): tic.press(act[1]) if (act == -1): active = False break if (act == 'r' or reset_counter < 0): tic = TicTacToe() tic.start(screen) reset_counter = 0 if (0 not in tic.values): if (reset_counter <= 0): reset_counter = 101 else: reset_counter -= 2 screen.close()
def close(self, *retval): self.onHideFinished.remove(self.__hideFinished) Screen.close(self, *retval)
class Core(object): """ Class ExpCore - handle User, Config, Trial instances Usage: >>> from core.Core import Core >>> root_folder = 'path/to/application_root_folder/' >>># Create new experiment >>>Exp = Core() >>> >>># Initialize experiment >>>Exp.init(root_folder, custom=True) >>># Open main window and run the experiment >>>Exp.run() """ appname = "EasyExp" version = v.__version__ __logger = None def __init__(self): """ ExpCore constructor :return: """ # Dependencies self.config = None self.user = None self.trial = None self.screen = None self.design = None self.logger = None self.devices = None self.parameters = None self.__cli = False self.folders = {'rootFolder': None, 'data': None, 'expFolder': None} self.files = dict() self.experimentsFolder = None self.status = True self.settings = None self.startTime = None self.stopTime = None self.expname = None self.exp_version = None @staticmethod def __get_experiment(folder, cli=False): """ Provide the user with a dialog UI to choose the experiment to run :return: """ # Folders to exclude dirs_list = [f for f in listdir(folder) if isdir(join(folder, f))] data = { 'Experiment selection': { 'expname': { 'value': dirs_list[0], 'options': dirs_list, 'type': 'select', 'label': 'Select an experiment' } } } if cli: selectexp = GuiWrapper.factory(cli, 'nested', data, title='Select Experiment', mandatory=True) else: selectexp = GuiWrapper.factory(cli, 'nested', data, title='Select Experiment') return selectexp.out['Experiment selection']['expname']['value'] @staticmethod def get_logger(rootfolder, expname): """ Get application logger :param rootfolder: :param expname: :return: Logger instance :rtype: CustomLogger """ if Core.__logger is None: # Set application's logger log_file = '{}/logs/{}_{}.log'.format( rootfolder, expname, time.strftime("%d%m%y_%H%M%S")) Core.__logger = CustomLogger(Core.appname, file_name=log_file, level='debug') return Core.__logger def init(self, rootfolder, cli=False, conditions=None): """ Initialize dependencies :param string rootfolder: full path to root folder :type rootfolder: str :param cli: Run in command line (True) :type cli: bool :param conditions: dictionary providing experiment conditions (to be used instead of conditions.json) :type conditions: dict """ # Get experiment self.experimentsFolder = "{}/experiments/".format(rootfolder) self.expname = self.__get_experiment(self.experimentsFolder, cli=cli) # Get logger if not isdir('{}/logs'.format(rootfolder)): mkdir('{}/logs'.format(rootfolder)) self.logger = self.get_logger(rootfolder, self.expname) # Import experiment self.__import_experiment(self.experimentsFolder, self.expname) self.exp_version = RunTrial.version if hasattr(RunTrial, 'version') else '1.0.0' # Print welcome message print("\n##############################\n") self.logger.info("# Welcome to {} (version {})".format( self.appname, v.__version__)) self.logger.info("# {}".format(v.__copyright__)) self.logger.info("# Date: {}".format( time.strftime("%d-%m-%y %H:%M:%S"))) self.logger.info("# Experiment: {} (version {})".format( self.expname, self.exp_version)) print("\n##############################\n") # Get and set configuration self.config = Config(rootfolder=rootfolder, expname=self.expname, cli=cli) self.config.setup() self.settings = self.config.settings self.folders = self.config.folders self.files = self.config.files # Get experiment parameters self.parameters = Parameters(self.files['parameters']) # Create user self.user = User(data_folder=self.folders['data'], expname='{}_v{}'.format( self.expname, self.exp_version.replace('.', '-')), **self.__filter_args(User, self.settings['setup'])) self.user.setup(cli=cli) self.files['design'] = self.user.designfile # Make factorial design self.design = Design(conditionfile=self.files['conditions'], userfile=self.files['design'], folder=self.folders['expFolder'], conditions=conditions, **self.__filter_args(Design, self.settings['setup'])) self.design.make() # Devices self.devices = Devices(exp_folder=self.folders['expFolder'], base_name=self.user.dftName, cli=cli) # Screen self.screen = Screen(expfolder=self.folders['expFolder'], expname=self.expname, **self.__filter_args(Screen, self.settings['display'])) @staticmethod def __filter_args(class_obj, args): """ Filter arguments passed to class constructor :param class_obj: class instance :param args: arguments :return: filtered dictionary :rtype: dict """ import inspect this_args = inspect.getargspec(class_obj.__init__) new_dict = dict() for a in this_args[0]: if a is not "self" and a in args: new_dict.update({a: args[a]}) return new_dict def __import_experiment(self, exp_folder, exp_name): """ # Import experiment class from experiment's folder (e.g.: experiments/experiment_name/runtrial.py) :param exp_folder: path to experiments folder :param exp_name: experiment name :return: void """ try: sys.path.append(join(exp_folder, exp_name)) global RunTrial from runtrial import RunTrial except ImportError as e: msg = '[{}] Could not import RunTrial. Make sure you changed the name of '"runtrial_template.py"' ' \ 'to "runtrial.py": {}'.format(__name__, e) self.logger.fatal(msg) raise RuntimeError(msg) def run(self): """ Run and time experiment """ self.logger.info("[{}] --- Start Experiment: '{}' ---".format( __name__, self.expname, self.exp_version)) # Start timer self.startTime = time.time() # Open window self.screen.open() # Instantiate Trial and experiment self.trial = Trial(design=self.design, settings=self.settings, userfile=self.user.datafilename, pause_interval=int( self.settings['setup']['pauseInt'])) runtrial = RunTrial(exp_core=self) # Run experiment try: if self.screen.display_type == 'qt': self.screen.ptw.setExperiment(runtrial) # Enter main loop (the underscore prevents using the keyword) sys.exit(self.screen.QTapp.exec_()) elif self.screen.display_type == 'psychopy': runtrial.run() except (KeyboardInterrupt, SystemExit) as e: msg = '[{0}] Exit requested: {1}'.format(__name__, e) self.logger.exception(msg) # Quit experiment and close all devices runtrial.quit() except (RuntimeError, Exception) as e: msg = '[{0}] An unexpected error has occurred: {1}'.format( __name__, e) self.logger.exception(msg) # Quit experiment and close all devices runtrial.quit() raise Exception(msg) finally: # Stop experiment self.stop() # run callback script self.run_callback() # End exit() def stop(self): """ Stop experiment """ if self.screen.display_type == 'psychopy': self.screen.close() self.stopTime = time.time() duration = round((self.stopTime - self.startTime) / 60.0) self.logger.logger.info("[{}] End of Experiment '{}'".format( __name__, self.expname)) self.logger.logger.info("[{0}] Total duration: {1} minutes".format( __name__, duration)) def run_callback(self): """ Run callback script :return: """ filename = join(self.experimentsFolder, self.expname, 'callback.py') if isfile(filename): try: sys.path.insert(0, join(self.experimentsFolder, self.expname)) import callback except ImportError as e: msg = '[{}] Error while executing callback script [path: {}]: {}'.format( __name__, filename, e) self.logger.fatal(msg) raise RuntimeError(msg)