def __init__(self, module_suffix=None): path_utils.setup_user_directories(app_name="spikepy") self.config_manager = config_manager self.trial_manager = TrialManager() self.plugin_manager = plugin_manager self.strategy_manager = StrategyManager() self.strategy_manager.load_all_strategies() self._current_strategy = None self.current_strategy = self.get_default_strategy() self.process_manager = ProcessManager(self.trial_manager) # register callback for open_files self.process_manager.open_files.add_callback(self._files_opened, takes_target_results=True)
class Session(object): def __init__(self, module_suffix=None): path_utils.setup_user_directories(app_name="spikepy") self.config_manager = config_manager self.trial_manager = TrialManager() self.plugin_manager = plugin_manager self.strategy_manager = StrategyManager() self.strategy_manager.load_all_strategies() self._current_strategy = None self.current_strategy = self.get_default_strategy() self.process_manager = ProcessManager(self.trial_manager) # register callback for open_files self.process_manager.open_files.add_callback(self._files_opened, takes_target_results=True) # FILE RELATED def export(self, data_interpreter_name, base_path=None, **kwargs): if base_path is None: base_path = os.getcwd() di = self.plugin_manager.data_interpreters[data_interpreter_name] return di.write_data_file(self.marked_trials, base_path, **kwargs) def load(self, filename): """Load session from a file.""" return self.open_file(filename) def open_file(self, fullpath): """Open file located at fullpath.""" return self.process_manager.open_file(fullpath) @supports_callbacks def open_files(self, fullpaths): """Open the files located at fullpaths""" return self.process_manager.open_files(fullpaths) def save(self, filename, gzipped=True): """Save this session.""" if not filename.endswith(".ses"): filename = "%s.ses" % filename trial_dicts = [] for trial in self.trials: trial_dicts.append(trial.as_dict) strategy_dict = self.current_strategy.as_dict session_dict = {"trials": trial_dicts, "strategy": strategy_dict} if gzipped: ofile = gzip.open(filename, "wb") else: ofile = open(filename, "wb") cPickle.dump(session_dict, ofile, protocol=-1) ofile.close() return filename # TRIAL RELATED def get_trial(self, name_or_id): """Return the trial with the given name or id""" if isinstance(name_or_id, uuid.UUID): return self.trial_manager.get_trial_with_id(name_or_id) else: return self.trial_manager.get_trial_with_name(name_or_id) def get_trial_with_name(self, name): """ Find the trial with display_name=<name> and return it. Raises RuntimeError if trial cannot be found. """ return self.trial_manager.get_trial_with_name(name) def mark_all_trials(self, status=True): """Mark all trials according to <status>""" for trial in self.trials: try: self.mark_trial(trial.display_name, status) except CannotMarkTrialError: pass @supports_callbacks def mark_trial(self, name_or_id, status=True): """Mark trial with name_or_id according to <status>.""" trial = self.get_trial(name_or_id) return self.trial_manager.mark_trial(trial.display_name, status=status) @property def marked_trials(self): """Return all currently marked trials.""" return self.trial_manager.marked_trials def remove_marked_trials(self): """Remove all currently marked trials.""" results = [] for trial in self.marked_trials: results.append(self.remove_trial(self.marked_trials)) return results @supports_callbacks def remove_trial(self, name_or_id): """Remove the trial with name or id given.""" trial = self.get_trial(name_or_id) return self.trial_manager.remove_trial(trial) @supports_callbacks def rename_trial(self, old_name_or_id, proposed_name): """Find trial with <old_name_or_id> and rename it to <proposed_name>.""" trial = self.get_trial(old_name_or_id) return self.trial_manager.rename_trial(trial.display_name, proposed_name) @property def trials(self): """Return all currently marked and unmarked trials.""" return self.trial_manager.trials def visualize(self, trial_name, visualization_name, **kwargs): """ Generate and display the visualization with the given <visualization_name> (or name subset) using the trial with name <trial_name>. """ visualization = self.plugin_manager.visualizations[visualization_name] trial = self.get_trial(trial_name) return visualization.draw(trial, **kwargs) # STRATEGY RELATED @property def current_strategy(self): """The currently selected strategy.""" return self._current_strategy @current_strategy.setter def current_strategy(self, strategy_or_name): """Set the current strategy with either a name or a Strategy object.""" if isinstance(strategy_or_name, Strategy): if strategy_or_name is not self.current_strategy: try: strategy = self.strategy_manager.get_strategy(strategy_or_name) except MissingStrategyError: # its okay if not under management strategy = strategy_or_name strategy_or_name.name = self.strategy_manager.get_strategy_name(strategy_or_name) self._set_current_strategy(strategy_or_name) else: strategy = self.strategy_manager.get_strategy(strategy_or_name) if strategy is not self.current_strategy: self._set_current_strategy(strategy) @supports_callbacks def _set_current_strategy(self, strategy): validated_strategy = self.plugin_manager.validate_strategy(strategy) self._current_strategy = strategy return strategy def save_current_strategy(self, strategy_name): """Save the current strategy, giving it the name <strategy_name>""" self.strategy_manager.save_current_strategy(strategy_name) # RUN RELATED def join_run(self): """Join the run thread (if there is one).""" if hasattr(self, "_run_thread"): self._run_thread.join() @property def is_running(self): if hasattr(self, "_run_thread"): return self._run_thread.is_alive() else: return False def run(self, stage_name=None, strategy=None, message_queue=multiprocessing.Queue(), async=False): """ Run the given strategy (defaults to current_strategy), or a stage from that strategy. Results are placed into the appropriate trial's resources. Inputs: strategy: A Strategy object. If not passed, session.current_strategy will be used. stage_name: If passed, only that stage will be run. message_queue: If passed, will be populated with run messages. async: If True, processing will run in a separate thread. This thread can be joined with session.join_run() """ if strategy is None or not isinstance(strategy, Strategy): strategy = self.current_strategy # if still none, then abort run. if strategy is None: raise NoCurrentStrategyError("You must supply a strategy or set the session's current strategy.") self.process_manager.prepare_to_run_strategy(strategy, stage_name=stage_name) self._run_thread = threading.Thread( target=self.process_manager.run_tasks, kwargs={"message_queue": message_queue} ) self._run_thread.start() if not async: self._run_thread.join()