def set_graph(self): from src.graph.regression_graph import StackedRegressionGraph g = StackedRegressionGraph( window_title='Peak Regression {}'.format('foo'), window_height=800, window_y=25, show_regression_editor=False ) cups = ['H2', 'H1', 'AX', 'L1', 'L2'] cups.reverse() for i, cup in enumerate(cups): g.new_plot(bounds=(50, 125), show_legend=True) g.new_series(plotid=i, fit_type='parabolic', type='scatter', marker='circle', marker_size=1.0) g.set_series_label(cup, plotid=i) g.set_x_limits(min=0, max=60) g.set_x_title('Time (sec)') do_after(5, g.edit_traits) self.graph = g
def main(): def listener(obj, traitname, old, new): print obj, traitname, old, new fred = Person(name='Fred', age=42) fred.on_trait_change(listener) fred.friend = Person(name='Wilma', age=34) def update_friend(): fred.friend.name = "Barney" fred.friend.age = 41 def set_friend(): print "Setting friend to Dino" fred.friend = Person(name="Dino", age=10) args = parse_command_line_args(description=__doc__) if args.web: person_view.serve(model=fred) else: app = QtGui.QApplication.instance() or QtGui.QApplication([]) do_after(3000, update_friend) do_after(4000, set_friend) person_view.show(model=fred) app.exec_() print fred.name print fred.age print fred.friend.name, fred.friend.age
def _left_down(self, event): """ Handles the left mouse being pressed. """ self._x, self._y = event.GetX(), event.GetY() self._pending = True self.control.CaptureMouse() do_after(150, self._delayed_click)
def debounced_callback(self, *emitting): """ This callback can be connected to a signal emitting object. When this signal debouncer is idle, the first signal will be dispatched and then follow-up signals will be ignored if they follow too closely. A final dispatch will be attempted at the end of the debounce interval. Parameters ---------- emitting: QtObject The emitting object. """ now = time() info = parallel_context.get_logger().info info('callback for {}, now is {}'.format(self.callback, self._signal_times)) if not len(self._signal_times): # dispatch now and start a new timer self.apply_callback(*emitting) self._signal_times.append(now) do_after(self.debounce_interval_ms, self.apply_callback, *emitting) else: if (now - self._signal_times[-1]) < self.debounce_interval_ms / 1000: # put this time on the end of the stack self._signal_times.append(now) else: # if more than the debounce interval has elapsed, clear the stack # and call this callback again self._signal_times = list() self.debounced_callback(*emitting)
def main(): def listener(obj, traitname, old, new): print obj, traitname, old, new fred = Person(name='Fred', age=42) fred.on_trait_change(listener) def update_fred(): fred.name = "Wilma" fred.age = 4 args = parse_command_line_args(description=__doc__) if args.web: import time from threading import Thread t = Thread(target=lambda:time.sleep(2) or update_fred()) t.daemon = True t.start() person_view.serve(model=fred) else: from pyface.qt import QtGui from pyface.timer.api import do_after app = QtGui.QApplication.instance() or QtGui.QApplication([]) person_view.show(model=fred) do_after(2000, update_fred) app.exec_() print fred.name print fred.age
def main(): app = QtGui.QApplication.instance() or QtGui.QApplication([]) fred = Person(name='Fred', age=42) person_view.show(model1=fred) do_after(2000, add_model) app.exec_()
def _source_changed ( self, source ): """ Handles the 'source' trait being changed. """ if self.can_save: if not self._dont_update: self.needs_save = True do_after( 750, self._syntax_check ) else: self._syntax_check()
def show(self, parent=None, title=''): """ Display the wait message for a limited duration. """ view = View(HGroup(spring, Item('message', show_label=False, style='readonly'), spring), title=title) do_after(int(1000.0 * self.time), self.edit_traits(parent=parent, view=view).dispose)
def show(self, parent=None, title="", width=200, height=80): view = View( spring, HGroup(spring, Item("message", show_label=False, style="readonly"), spring), spring, width=width, height=height, title=title, ) do_after(int(1000.0 * self.time), self.edit_traits(parent=parent, view=view).dispose)
def main(): app = QtGui.QApplication.instance() or QtGui.QApplication([]) fred = Person(name='Fred', age=42) def on_trait_change(obj, trait, old, new): print trait, old, new fred.on_trait_change(on_trait_change) person_view.show(model=fred) do_after(2000, fred.update_name, "Freddie") app.exec_()
def run_script(self, path): """Execute a script in the namespace of the viewer. """ pas = self.particle_arrays if len(pas) == 0 or pas[0].plot is None: do_after(2000, self.run_script, path) return with open(path) as fp: data = fp.read() ns = self._get_shell_namespace() exec(compile(data, path, 'exec'), ns)
def _update_hud(self): if self._maximum_delta > self.threshold and not self._timed_out: beep() # TODO: Requires patched version of pyface # See github:enthought/pyface pull request #35 # Don't beep more than once per second self._timed_out = True do_after(1000, self._switch_on_timeout) self.screen.hud('delta', 'Current average delta: {0._average_delta:.3f}\n' 'Current maximum delta: {0._maximum_delta:.3f}'.format(self))
def _left_down(self, event): """Handles the left mouse being pressed.""" self._x, self._y = event.GetX(), event.GetY() self._pending = True self._init_value() self.control.CaptureMouse() if self.factory.active_color_ != self.factory.hover_color_: self.control.Refresh() do_after(200, self._delayed_click)
def _left_down ( self, event ): """ Handles the left mouse being pressed. """ self._x, self._y = event.GetX(), event.GetY() self._pending = True self._init_value() self.control.CaptureMouse() if self.factory.active_color_ != self.factory.hover_color_: self.control.Refresh() do_after( 200, self._delayed_click )
def show ( self, parent = None, title = '' ): """ Display the wait message for a limited duration. """ view = View( HGroup( spring, Item( 'message', show_label = False, style = 'readonly' ), spring ), title = title ) do_after( int( 1000.0 * self.time ), self.edit_traits( parent = parent, view = view ).dispose )
def _context_is_modified(self, event): """ Handles the context modified event. """ if self.context_notification_delay <= 0: self._process_context_modified_event(event) else: if event.reset: self._context_reset = True self._context_modified = {} elif not self._context_reset: self._context_modified.update(dict.fromkeys(event.modified)) self._context_added_removed(self._context_removed, self._context_added, event.removed) self._context_added_removed(self._context_added, self._context_removed, event.added) do_after(self.context_notification_delay, self._propagate_context_modified) super(TraitsContext, self)._context_is_modified(event)
def _context_is_modified ( self, event ): """ Handles the context modified event. """ if self.context_notification_delay <= 0: self._process_context_modified_event( event ) else: if event.reset: self._context_reset = True self._context_modified = {} elif not self._context_reset: self._context_modified.update( dict.fromkeys( event.modified ) ) self._context_added_removed( self._context_removed, self._context_added, event.removed ) self._context_added_removed( self._context_added, self._context_removed, event.added ) do_after( self.context_notification_delay, self._propagate_context_modified ) super( TraitsContext, self )._context_is_modified( event )
def update_editor(self): """ Updates the editor when the object trait changes externally to the editor. """ control = self.control if self.playing: control.Stop() control.LoadFile(self.value) self._file_loaded = True # Note: It seems to be necessary to Play/Stop the control to avoid a # hard wx crash when 'PlayNextFrame' is called the first time (must be # some kind of internal initialization issue): control.Play() control.Stop() if self.playing or self._not_first: self._playing_changed() else: do_after(300, self._frame_changed) self._not_first = True
def update_editor ( self ): """ Updates the editor when the object trait changes externally to the editor. """ control = self.control if self.playing: control.Stop() control.LoadFile( self.value ) self._file_loaded = True # Note: It seems to be necessary to Play/Stop the control to avoid a # hard wx crash when 'PlayNextFrame' is called the first time (must be # some kind of internal initialization issue): control.Play() control.Stop() if self.playing or self._not_first: self._playing_changed() else: do_after( 300, self._frame_changed ) self._not_first = True
def main(): def listener(obj, traitname, old, new): print obj, traitname, old, new fred = Person(name='Fred', age=42) fred.on_trait_change(listener) wilma = Person(name="Wilma", age=42, fruits=['pineapple', 'litchi']) barney = Person(name="Barney", age=40) fred.fruits = ['peach', 'pear'] def set_list(): fred.fruits = ["banana", "kiwi"] fred.friends = [wilma] def update_list(): fred.fruits.append("apple") fred.friends.append(barney) fred.fruits[0] = 'mango' wilma.fruits.append('guava') wilma.fruits[0] = 'strawberry' args = parse_command_line_args(description=__doc__) if args.web: set_list() update_list() person_view.serve(model=fred) else: app = QtGui.QApplication.instance() or QtGui.QApplication([]) do_after(3000, set_list) do_after(4000, update_list) person_view.show(model=fred) app.exec_() print fred.fruits print wilma.fruits print [x.name for x in fred.friends]
def _context_is_modified(self, event): """ Handles the context modified event. """ if self.context_propagation_delay <= 0: super(DeferredContext, self)._context_is_modified(event) else: if event.reset: self._context_reset = True self._context_modified = {} elif not self._context_reset: self._context_modified.update(dict.fromkeys(event.modified)) self._context_changed.update(dict.fromkeys(event.changed)) self._move_dict_items(self._context_removed, self._context_added, event.removed) self._move_dict_items(self._context_added, self._context_removed, event.added) # (Is this correct? cf. 'event.merge_context_modified_events'...) do_after(self.context_propagation_delay, self._propagate_context_modified)
def record(self): t = self.time_generator.next() # d = pseudo_peak_regressions.next() d = 0 # come d.reverse() datum = [t] + d self.info('get data {},{}'.format(*datum)) self.data_manager.write_to_frame(datum) data = [(t, di) for di in d] if self.signals is None: self.signals = array(datum) else: self.signals = vstack((self.signals, datum)) do_after(1, self.graph.add_data, data) ''' if we have enough datapoints calculate an age ''' '''
def _context_is_modified ( self, event ): """ Handles the context modified event. """ if self.context_propagation_delay <= 0: super( DeferredContext, self )._context_is_modified( event ) else: if event.reset: self._context_reset = True self._context_modified = {} elif not self._context_reset: self._context_modified.update( dict.fromkeys( event.modified ) ) self._context_changed.update( dict.fromkeys( event.changed ) ) self._move_dict_items( self._context_removed, self._context_added, event.removed ) self._move_dict_items( self._context_added, self._context_removed, event.added ) # (Is this correct? cf. 'event.merge_context_modified_events'...) do_after( self.context_propagation_delay, self._propagate_context_modified )
def read_input_continuously(self): """ Polling function. This polls for any new data once every READ_INTERVAL_MS milliseconds. If there's an error, it stops polling. """ if self.read_input_buffer(): do_after(READ_INTERVAL_MS, self.read_input_continuously)
def open_file(self, path): try: new_workflow = load_yaml(path) # a few things to take care of when reloading. # we do this in the try block to catch people who # load valid YAML files that aren't from cytoflow. for wi_idx, wi in enumerate(new_workflow): # get wi lock wi.lock.acquire() # clear the wi status wi.status = "loading" # re-link the linked list. if wi_idx > 0: wi.previous_wi = new_workflow[wi_idx - 1] if wi_idx < len(new_workflow) - 1: wi.next_wi = new_workflow[wi_idx + 1] except yaml.parser.ParserError as e: error(None, "Parser error loading {} -- is it a Cytoflow file?\n\n{}" .format(path, str(e))) return except Exception as e: error(None, "{} loading {} -- is it a Cytoflow file?\n\n{}" .format(e.__class__.__name__, path, str(e))) return # are we just running a smoke test? if 'startup_test' in new_workflow[0].metadata: def quit_app(app): app.exit(force = True) from pyface.timer.api import do_after do_after(5*1000, quit_app, self.application) return # check that the FCS files are all there wi = new_workflow[0] assert(wi.operation.id == "edu.mit.synbio.cytoflow.operations.import") missing_tubes = 0 for tube in wi.operation.tubes: file = pathlib.Path(tube.file) if not file.exists(): missing_tubes += 1 if missing_tubes == len(wi.operation.tubes): warning(self.window.control, "Cytoflow couldn't find any of the FCS files from that " "workflow. If they've been moved, please open one FCS " "file to show Cytoflow where they've been moved to.") dialog = FileDialog(parent = self.window.control, action = 'open', wildcard = (FileDialog.create_wildcard("FCS files", "*.fcs *.lmd"))) # @UndefinedVariable if dialog.open() == OK: # find the "best" file match -- ie, the one with the longest # tail match fcs_path = pathlib.Path(dialog.path).parts best_path_len = -1 for tube in wi.operation.tubes: tube_path = pathlib.Path(tube.file).parts for i in range(len(fcs_path)): if list(reversed(fcs_path))[:i] == list(reversed(tube_path))[:i] and i > best_path_len: best_path_len = i if best_path_len >= 0: for tube in wi.operation.tubes: tube_path = pathlib.Path(tube.file).parts new_path = fcs_path[:-1 * best_path_len] + tube_path[-1 * best_path_len :] tube.file = str(pathlib.Path(*new_path)) elif missing_tubes > 0: warning(self.window.control, "Cytoflow couldn't find some of the FCS files from that " "workflow. You'll need to re-load them from the Import " "operation.") # replace the current workflow with the one we just loaded if False: # for debugging the loading of things from .event_tracer import record_events with record_events() as container: self.model.workflow = new_workflow container.save_to_directory(os.getcwd()) else: self.model.workflow = new_workflow self.model.modified = False for wi in self.model.workflow: wi.lock.release() if self.model.debug: self.model.run_all() else: ret = confirm(parent = None, message = "Do you want to execute the workflow now?", title = "Run workflow?") if ret == YES: self.model.run_all()
def stream_statement(self): self.info('stream') self.measurement_timer = Timer(250, self.stream) do_after(1, self.measurement_timer.Start)