class BasicH5Configurator(AbstractConfigurator): """ BasicH5Configurator reads the starting network from an HD5 file. It receives the path of the file from the simulation option 'h5_file', which has to be specified in the command line option description. """ options = {'h5_file'} starting_graph = Instance(h5py.File, allow_none=False) node_type = Type node_options = Instance(set) def create_edges(self): pass def create_nodes(self): ifile = h5py.File(self.h5_file, 'r') indptr = ifile['indptr'] max_node = indptr.len() - 1 self.node_arguments = extract_sub_dictionary(self.full_parameters, self.node_options) node_manager_id = node_manager.NodeManager.name answers = [ self.send(node_manager_id, 'create_node', cls=self.node_type, parameters=self.node_arguments) for _ in xrange(max_node) ] SequenceAsyncResult(answers).get() self.node_identifiers = xrange(max_node)
class DummyModelInfo(HasTraits): object = Instance(HasTraits) ui = Instance(DummyUI) def _ui_default(self): return DummyUI()
class PyannoResult(HasStrictTraits): """Class for database entries """ #: :class:`~pyanno.annotations.AnnotationsContainer` object anno_container = Instance(AnnotationsContainer) #: pyAnno model (subclass of :class:`~pyanno.abstract_model.AbstractModel`) model = Instance(AbstractModel) #: value of the model performance (usually the log likelihood) value = Float
class NXGraphConfigurator(AbstractConfigurator): """ Sets up a network reading the initial configuration from a graph in a file supported by the NetworkX library. """ options = {'starting_graph'} """ The NXGraphConfigurator agent reads the `starting_graph` property """ starting_graph = Instance(nx.Graph, allow_none=False) node_type = Type node_options = Instance(set) def create_edges(self): """ Creates the edges as specified in the network it read. """ graph = self.starting_graph for u, v in graph.edges_iter(): u1 = self.node_map[u] v1 = self.node_map[v] self.send(v1, 'accept_link', originating_node=u1) def create_nodes(self): """ Requires the `NodeManager` to create the nodes as specified in the network it read. """ self.node_arguments = extract_sub_dictionary(self.full_parameters, self.node_options) node_manager_id = node_manager.NodeManager.name graph = self.starting_graph assert isinstance(graph, nx.Graph) self.node_map = {} # create all the nodes nit_1, nit_2 = itertools.tee(graph.nodes_iter()) answers = [ self.send(node_manager_id, 'create_node', cls=self.node_type, parameters=self.node_arguments) for _node in nit_1 ] self.node_map = { node: identifier for node, identifier in itertools.izip( nit_2, SequenceAsyncResult(answers).get()) } self.node_identifiers = self.node_map.viewvalues()
class DummyParent(HasTraits): number = Int() number2 = Int() instance = Instance(Dummy, allow_none=True) instance2 = Instance(Dummy) income = Float() dummies = List(Dummy)
class PAFTest(HasTraits): context = Instance(ParametricModelingContext) parameters = Instance(Parameters) update = Button r = Float(1.) a = Float(100.) view = View( Item("parameters", editor=PAFContextEditorFactory(context='context')), Item("update"), Item("a"), Item("r")) def _update_changed(self): self.parameters.a = self.a self.parameters.r = self.r
class Target(HasTraits): event = Event(Instance(SomeEvent)) event_count = Int(0) def _event_fired(self): self.event_count += 1
class DateEditor(EditorFactory): """ Editor factory for date/time editors. """ # ------------------------------------------------------------------------- # Trait definitions: # ------------------------------------------------------------------------- # -- ReadonlyEditor traits ------------------------------------------------ #: Message to show when Date is None. message = Str("Undefined") #: The string representation of the date to show. Uses time.strftime #: format. strftime = Str("%B %d %Y (%a)") #: An optional view to display when a read-only text editor is clicked: view = AView # -- CustomEditor traits -------------------------------------------------- #: Should users be able to pick future dates when using the CustomEditor? allow_future = Bool(True) #: How many months to show at a time. months = Int(3) #: True: Must be a List of Dates. False: Must be a Date instance. multi_select = Bool(False) #: When a user multi-selects entries and some of those entries are already #: selected and some are not, what should be the behavior for the seletion? #: #: Options: #: #: - 'toggle': Toggle each day to the opposite of the current state. #: - 'on': Always turn them on. #: - 'off': Always turn them off. #: - 'max_change': Change all to same state, with most days changing. #: For example 1 selected and 9 not, then they would all get selected. #: - 'min_change': Change all to same state, with min days changing. #: For example 1 selected and 9 not, then they would all get unselected. on_mixed_select = Enum("toggle", "on", "off", "max_change", "min_change") #: How much space to put between the individual months. padding = Int(5) #: Does the user have to hold down Shift for the left-click multiselect? shift_to_select = Bool(False) #: Style used when a date is selected. selected_style = Instance( CellFormat, kw={ "bold": True, "fgcolor": (255, 255, 255), "bgcolor": (0, 128, 0) }, )
class ListOfFloatsWithCSVEditor(ModelView): model = Instance(ListOfFloats) traits_view = View( Item(label="Close the window to append data"), Item("model.data", editor=CSVListEditor()), buttons=["OK"], )
class PosteriorView(HasTraits): show_maximum = Bool(False) show_majority_vote = Bool(False) posterior_plot = Instance(PosteriorPlot) annotations = Array def traits_view(self): height = 760 if is_display_small() else 900 traits_view = View(VGroup(VGroup( Item('show_maximum', label='Show MAP estimate (circle)'), Item('show_majority_vote', label='Show majority vote (triangle)'), ), VGroup( Item('posterior_plot', editor=InstanceEditor(), style='custom', show_label=False), ), padding=0), height=height, scrollable=True, resizable=True) return traits_view def _show_maximum_changed(self): plot = self.posterior_plot if self.show_maximum: maximum = plot.posterior.argmax(1) plot.add_markings(maximum, 'MAP', 'circle', 0., 0., marker_size=3, line_width=2., marker_color='gray') else: plot.remove_markings('MAP') plot.plot_posterior.request_redraw() def _show_majority_vote_changed(self): plot = self.posterior_plot if self.show_majority_vote: majority = majority_vote(self.annotations) plot.add_markings(majority, 'majority', 'triangle', 0., 0., marker_size=3, line_width=1., marker_color='green') else: plot.remove_markings('majority') plot.plot_posterior.request_redraw()
class PAFContextEditor(Editor): display = Instance(OCCViewer) initialized = Bool parameters = Instance(Parameters) context = Instance(ParametricModelingContext) def init(self, parent): self.control = OCCTraitViewer(self) self.sync_value(self.name, 'parameters', 'both') self.sync_value(self.factory.context, 'context', 'both') if self.factory.display: self.sync_value(self.factory.display, 'display', 'both') print(self.display) def _initialized_changed(self): r"""when display has been set on the first paint event""" self.context.set_display(self.control._display) print('Display initialiazed')
class ExtendedListenerInList(HasTraits): # Used in regression test for enthought/traits#403. dummy = Instance(Dummy) changed = Bool(False) @on_trait_change(["dummy:x"]) def set_changed(self): self.changed = True
class FigureWnd(HasTraits): figure = Instance(Figure) def _figure_default(self): pass def update_figure(self): fig = Figure() self.create_plot(fig) self.figure = fig
def Optional(trait: TraitType) -> Union: """ Return Union of function argument and Instance(_Undefined) Args: trait (TraitType): optional trait Returns: union with undefined instance """ return Union(trait, Instance(_Undefined))
class CodeView(ModelView): model = Instance(CodeModel) show_line_numbers = Bool(True) style = Enum('simple', 'readonly') def default_traits_view(self): traits_view = View( Item('model.code', editor=CodeEditor(show_line_numbers=self.show_line_numbers), style=self.style)) return traits_view
class FoobotChat(Controller): model = Instance(Foobot, ()) def traits_view(self): v = View(UItem('console', style='custom', editor=TextEditor(read_only=True)), UItem('message', editor=TextEditor(enter_set=True, auto_set=False)), width=500, height=400, resizable=True) return v
class DelegateMess(HasTraits): dummy1 = Instance(Dummy, args=()) dummy2 = Instance(Dummy2) y = DelegatesTo("dummy2") handler_called = Bool(False) def _dummy2_default(self): # Create `self.dummy1` return Dummy2(dummy=self.dummy1) @on_trait_change("dummy1.x") def _on_dummy1_x(self): self.handler_called = True def _init_trait_listeners(self): """ Force the DelegatesTo listener to hook up first to exercise the worst case. """ for name in ["y", "_on_dummy1_x"]: data = self.__class__.__listener_traits__[name] getattr(self, "_init_trait_%s_listener" % data[0])(name, *data)
class NewModelDialog(HasTraits): """Create a dialog requesting the parameters to create a pyAnno model.""" model_name = Str parameters_group = Instance(Group) def traits_view(self): traits_view = View( Include('parameters_group'), buttons=OKCancelButtons, title='Create new ' + self.model_name, #kind='modal' ) return traits_view
class ModelB_MultipleThetaView(HasTraits): """Tabular view for the parameters theta in Model B. Includes a spin box to select the parameters for each annotator. """ @classmethod def show(cls, theta): """Create a window that with a ThetaView inside.""" tv = cls(theta=theta) tv.edit_traits() # 3D tensor to be displayed theta = Array # 4D tensor of samples (may be None if no samples available) theta_samples = Any # title of the view window title = "Model B, parameters theta" # annotator number annotator_idx = Int(0) # tabular view of theta for annotator j theta_j_view = Instance(HasTraits) def traits_view(self): traits_view = View( VGroup( Item('annotator_idx', label='Annotator index', editor=RangeEditor(mode='spinner', low=0, high=self.theta.shape[0]-1, ), ), HGroup( Item('theta_j_view', style='custom', show_label=False), ), ), width = 500, height = 400, resizable = True ) return traits_view
class AbstractWnd(HasTraits): figure = Instance(Figure) def _figure_default(self): pass alive = Bool() auto_update = Bool(False) enable_update = Bool() start = Button() def _start_fired(self): self.enable_update = True Thread(target=self._loop).start() stop = Button() def _stop_fired(self): self.enable_update = False def _loop(self): if self.auto_update: while self.auto_update and self.enable_update: self._update() else: self._update() def _update(self): self.alive = True def stop_condition(t, tstart): return not self.enable_update data = self.measure(self.conf, stop_condition) self.alive = False fig = Figure() self.plot(data, fig) self.figure = fig
class AbstractRandomSelector(HasTraits): implements(IRandomSelector) graph_container = Instance(IGraph) _initialized_preferential_attachment = false def preferential_attachment(self): if not self._initialized_preferential_attachment: self.prepare_preferential_attachment() self._initialized_preferential_attachment = True return int(self.extract_preferential_attachment()) def prepare_preferential_attachment(self): raise NotImplementedError() def random_edge(self): raise NotImplementedError() def random_node(self): raise NotImplementedError() def extract_preferential_attachment(self): raise NotImplementedError()
class BandwidthHighlighter(HasTraits): container = Instance(HPlotContainer) plot = Instance(Component) colormap_name_1 = Str('gray') path = Str # add_band = Button('Add band') highlight_bands = List(Band) def update_path(self, new): self.path = new def delete_band(self): self.highlight_bands.pop(-1) def add_band(self): self.highlight_bands.append(Band()) def _path_changed(self): self._load_image(self.path) @on_trait_change('highlight_bands:[center,threshold,color, use]') def _refresh_highlight_bands(self, obj, name, old, new): if self.path: plot = self.oplot im = Image.open(self.path) rgb_arr = array(im.convert('RGB')) # im_arr=array(im) gray_im = array(im.convert('L')) for band in self.highlight_bands: if band.use: low = band.center - band.threshold high = band.center + band.threshold mask = where((gray_im > low) & (gray_im < high)) # print band.color[:3] rgb_arr[mask] = band.color.toTuple()[:3] imgplot = plot.plots['plot0'][0] tools = imgplot.tools overlays = imgplot.overlays plot.delplot('plot0') plot.data.set_data('img', rgb_arr) img_plot = plot.img_plot('img', colormap=color_map_name_dict[self.colormap_name_1])[0] for ti in tools + overlays: ti.component = img_plot img_plot.tools = tools img_plot.overlays = overlays plot.request_redraw() def _load_image(self, path): self.container = self._container_factory() im = Image.open(path) # oim = array(im) im = im.convert('L') odim = ndim = array(im) pd = ArrayPlotData() pd.set_data('img', odim) plot = Plot(data=pd, padding=[30, 5, 5, 30], default_origin='top left') img_plot = plot.img_plot('img', colormap=color_map_name_dict[self.colormap_name_1] )[0] self.add_inspector(img_plot) self.add_tools(img_plot) self.oplot = plot self.container.add(self.oplot) # self.container.add(self.plot) self.container.request_redraw() def add_inspector(self, img_plot): imgtool = ImageInspectorTool(img_plot) img_plot.tools.append(imgtool) overlay = ImageInspectorOverlay(component=img_plot, image_inspector=imgtool, bgcolor="white", border_visible=True) img_plot.overlays.append(overlay) def add_tools(self, img_plot): zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False) pan = PanTool(component=img_plot, restrict_to_data=True) img_plot.tools.append(pan) img_plot.overlays.append(zoom) def _highlight_bands_default(self): return [Band(color='red'), Band(color='green'), Band(color='blue')] def traits_view(self): ctrl_grp = VGroup( # HGroup(UItem('add_band')), UItem('highlight_bands', height=115,editor=ListEditor(mutable=False, style='custom', editor=InstanceEditor()))) v = View( VSplit( ctrl_grp, UItem('container', editor=ComponentEditor(height=700)))) return v def _container_factory(self): pc = HPlotContainer(padding=[5, 5, 5, 20]) return pc def _container_default(self): return self._container_factory() #============= EOF =============================================
def test_list_editor_list_instance(self): trait = List(Instance(HasTraits)) editor = list_editor(trait, trait) self.assertIsInstance(editor, traitsui.api.TableEditor)
class Target(HasTraits): event = Event(Instance(SomeEvent)) event_count = Int(0)
class MassSpecAnalysisExporter(Exporter): destination = Instance(MassSpecDestination, ()) def __init__(self, *args, **kw): """ destination: dict. dict, required keys are (username, password, host, name) """ super(MassSpecAnalysisExporter, self).__init__(*args, **kw) importer = MassSpecDatabaseImporter() self.importer = importer @on_trait_change('destination:[username, password, host, name]') def set_destination(self, name, new): importer = self.importer db = importer.db # for k in ('username', 'password', 'host', 'name'): setattr(db, name, new) # db.connect() def start_export(self): self.importer.db.connect() return self.importer.db.connected def export(self): self.info('committing current session to database') self.importer.db.commit() self.info('commit successful') # self.extractor.db.close() def rollback(self): """ Mass Spec schema doesn't allow rollback """ pass # self.info('rollback') # self.extractor.db.rollback() # self.extractor.db.reset() def _make_spec(self, ai): rs_name, rs_text = '', '' rid = ai.record_id exp = MassSpecExportSpec( runid=rid, runscript_name=rs_name, runscript_text=rs_text, mass_spectrometer=ai.mass_spectrometer.capitalize(), isotopes=ai.isotopes) exp.load_record(ai) return exp def add(self, analysis): spec = self._make_spec(analysis) db = self.importer.db # rid = spec.runid # convert rid # if rid == 'c': # if spec.mass_spectrometer == 'Pychron Jan': # rid = '4359' # else: # rid = '4358' rid = self.importer.get_identifier(spec) irrad = spec.irradiation level = spec.level prodid = self.importer.add_irradiation_production( spec.production_name, spec.production_ratios, spec.interference_corrections) self.importer.add_irradiation_chronology(irrad, spec.chron_dosages) self.importer.add_irradiation(irrad, level, prodid) self.importer.add_irradiation_position(spec.irradpos, '{}{}'.format(irrad, level), spec.irradiation_position, j=float( nominal_value(spec.j or 0)), jerr=float(std_dev(spec.j or 0))) if db.get_analysis(rid, spec.aliquot, spec.step): self.debug('analysis {} already exists in database'.format(rid)) else: spec.update_rundatetime = True self.importer.add_analysis(spec) return True
class Consoleable(Loggable): use_message_colormapping = Bool console_display = Instance( 'pychron.core.displays.display.DisplayController') # console_updated = Event console_bgcolor = LIGHT_YELLOW console_fontsize = Int(11) console_default_color = Color('black') def console_bind_preferences(self, prefid): from pychron.core.ui.preference_binding import color_bind_preference, bind_preference color_bind_preference(self, 'console_bgcolor', '{}.bgcolor'.format(prefid)) color_bind_preference(self, 'console_default_color', '{}.textcolor'.format(prefid)) bind_preference(self, 'console_fontsize', '{}.fontsize'.format(prefid)) def console_set_preferences(self, preferences, prefid): from pychron.core.ui.preference_binding import set_preference, color_set_preference color_set_preference(preferences, self, 'console_bgcolor', '{}.bg_color'.format(prefid)) color_set_preference(preferences, self, 'console_default_color', '{}.textcolor'.format(prefid)) set_preference(preferences, self, 'console_fontsize', '{}.fontsize'.format(prefid), cast=int) def warning(self, msg, log=True, color=None, *args, **kw): super(Consoleable, self).warning(msg, *args, **kw) if color is None: color = 'red' msg = msg.upper() if self.console_display: self.console_display.add_text(msg, color=color) # self.console_updated = '{}|{}'.format(color, msg) def heading(self, msg, decorate_chr='*', *args, **kw): d = decorate_chr * 7 msg = '{} {} {}'.format(d, msg, d) self.info(msg) def info(self, msg, log=True, color=None, *args, **kw): if color is None: # or not self.use_message_colormapping: color = self.console_default_color if self.console_display: t = datetime.now().strftime('%H:%M:%S') msg = '{} -- {}'.format(t, msg) self.console_display.add_text(msg, color=color) if log: super(Consoleable, self).info(msg, *args, **kw) # self.console_updated = '{}|{}'.format(color, msg) def info_marker(self, char='=', color=None): if color is None: color = self.console_default_color if self.console_display: self.console_display.add_marker(char, color=color) def info_heading(self, msg): self.info('') self.info_marker('=') self.info(msg) self.info_marker('=') self.info('') def _console_display_default(self): from pychron.core.displays.display import DisplayController return DisplayController(bgcolor=self.console_bgcolor, font_size=self.console_fontsize, default_color=self.console_default_color, max_blocks=100)
class ClassWithInstance(HasTraits): instance = Instance(ClassWithNumber)
class AnnotationsStatisticsView(HasTraits): statistics_name = Enum(ALL_STATS_NAMES) annotations = Array nclasses = Int info_button = Button("Info...") stats_view = Instance(HasTraits) def _info_button_fired(self): """Open dialog with description of statistics.""" if self.statistics_name in GLOBAL_STATS: stat_func = GLOBAL_STATS[self.statistics_name] else: stat_func = PAIRWISE_STATS[self.statistics_name] message(message=stat_func.__doc__, title='Statistics info') @on_trait_change('statistics_name') def _update_stats_view(self): if self.statistics_name in GLOBAL_STATS: stat_func = GLOBAL_STATS[self.statistics_name] try: res = stat_func(self.annotations, nclasses=self.nclasses) except PyannoValueError as e: logger.info(e) res = np.nan self.stats_view = _SingleStatView(value=res, name=self.statistics_name) else: stat_func = PAIRWISE_STATS[self.statistics_name] try: res = measures.pairwise_matrix(stat_func, self.annotations, nclasses=self.nclasses) except PyannoValueError as e: logger.info(e) nannotators = self.annotations.shape[1] res = np.empty((nannotators, nannotators)) res.fill(np.nan) self.stats_view = MatrixPlot(matrix=res, colormap_low=-1.0, colormap_high=1.0, title=self.statistics_name) def traits_view(self): self.statistics_name = "Cohen's Kappa" traits_view = View(VGroup( HGroup(Item("statistics_name", show_label=False), Item("info_button", show_label=False)), Spring(), HGroup( Spring(), Item("stats_view", style="custom", show_label=False, width=300, resizable=False), Spring()), ), width=400, resizable=True) return traits_view
class MatrixPlot(PyannoPlotContainer): # data to be displayed matrix = Array #### plot-related traits colormap_low = Float(None) colormap_high = Float(None) origin = Str('top left') matrix_plot_container = Instance(HPlotContainer) def _create_colormap(self): if self.colormap_low is None: self.colormap_low = self.matrix.min() if self.colormap_high is None: self.colormap_high = self.matrix.max() if self.colormap_low >= 0.0: colormap_factory = Reds else: colormap_factory = reverse(RdBu) colormap = colormap_factory( DataRange1D(low=self.colormap_low, high=self.colormap_high)) return colormap def _matrix_plot_container_default(self): matrix = np.nan_to_num(self.matrix) width = matrix.shape[0] # create a plot data object and give it this data plot_data = ArrayPlotData() plot_data.set_data("values", matrix) # create the plot plot = Plot(plot_data, origin=self.origin) img_plot = plot.img_plot("values", interpolation='nearest', xbounds=(0, width), ybounds=(0, width), colormap=self._create_colormap())[0] #### fix axes self._remove_grid_and_axes(plot) axis = self._create_increment_one_axis(plot, 0.5, width, 'bottom') self._add_value_axis(plot, axis) axis = self._create_increment_one_axis( plot, 0.5, width, 'left', ticks=[str(i) for i in range(width - 1, -1, -1)]) self._add_index_axis(plot, axis) #### tweak plot attributes self._set_title(plot) plot.aspect_ratio = 1. # padding [left, right, up, down] plot.padding = [0, 0, 25, 25] # create the colorbar, handing in the appropriate range and colormap colormap = img_plot.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=img_plot, orientation='v', resizable='v', width=20, padding=[0, 20, 0, 0]) colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom # create a container to position the plot and the colorbar side-by-side container = HPlotContainer(use_backbuffer=True) container.add(plot) container.add(colorbar) container.bgcolor = 0xFFFFFF self.decorate_plot(container, self.matrix) return container resizable_plot_item = Item('matrix_plot_container', editor=ComponentEditor(), resizable=True, show_label=False, width=600, height=400) traits_plot_item = Instance(Item) def _traits_plot_item_default(self): return Item('matrix_plot_container', editor=ComponentEditor(), resizable=False, show_label=False, height=-200, width=-200)
class EventSelectionDialog(HasTraits): source_class_label = String("Select Event Source Classes") severity_level_label = String("Select Event Severity Levels") search = String(regex="^[_a-zA-Z0-9\*\.\$\^\?\s]*$") shown_event_names_list = String(regex="[_a-zA-Z0-9\*\.\$\^\?\n]*") quit_button = Button('Quit') query_button = Button('Run Query...') period_start_date = DelegatesTo("query_object") period_end_date = DelegatesTo("query_object") selected_list_of_event_severity_levels = DelegatesTo("query_object") list_of_event_severity_levels = DelegatesTo("query_object") selected_list_of_source_classes = DelegatesTo("query_object") list_of_source_classes = DelegatesTo("query_object") query_object = Instance(EventSelectionQuery) spring = Spring help_text = ( "Search engine like queries using alphanumeric characters and '_'and '.' \n" + "Space indicate OR-separated queries\n" + "? = match any character\n" + "* = any number of characters\n" + "^ = match beginning\n" "$ = match end") view = View( Group( VGroup( HGroup(Item("period_start_date", label="Period"), Item("period_end_date", show_label=False), Item("", resizable=True, width=1.0, show_label=False), HGroup(Item('quit_button', show_label=False), Item('query_button', show_label=False)), springy=True), HGroup( VGroup( HGroup( Item("severity_level_label", show_label=False, style="readonly")), Item("selected_list_of_event_severity_levels", editor=CheckListEditor( name="list_of_event_severity_levels"), style="custom", show_label=False)), VGroup( HGroup( Item("source_class_label", show_label=False, style="readonly")), Item("selected_list_of_source_classes", editor=CheckListEditor( name="list_of_source_classes"), style="custom", show_label=False)), # springy=True ), show_border=True), Item("_"), VGroup(Item("search", editor=HistoryEditor(auto_set=True), show_label=False, width=1.0, tooltip=help_text), Item( name='shown_event_names_list', style='readonly', resizable=True, show_label=False, ), scrollable=True, show_border=True), orientation='vertical', ), title='Select Events to Visualize', dock='horizontal', resizable=True, width=.5, height=.7) def __init__(self, query_object, **kwargs): ''' Creates a dialog window for selecting date period, source classes and event severity levels/types. :param query_object: :return: ''' assert isinstance(query_object, EventSelectionQuery) self.shown_event_names_list = "\n".join( list(query_object.list_of_event_names)) self.query_object = query_object self.query_start_date = query_object.period_start_date self.query_end_date = query_object.period_end_date HasTraits.__init__(self, **kwargs) def _search_changed(self): ''' Matches search query to the event names. :return: ''' query_st = str(self.search).strip() if re.match("^[_a-zA-Z0-9\*\.\$\^\?\s]*$", query_st) is None: return query_st = query_st.replace(".", "\.") query_st = query_st.replace("*", ".*") query_st = query_st.replace("?", ".?") queries = query_st.split() print self.search, query_st, queries, if len(queries) == 0: queries = [""] result = [ s for s in list(self.query_object.list_of_event_names) for q in queries if re.search((".*%s.*" % q), s) is not None ] self.query_object.selected_list_of_event_names = result self.shown_event_names_list = "\n".join(result) print len(self.shown_event_names_list) def _save_search(self): # A bug fix, stops the clearing of the search expression tmp = self.search self.search = " " self.search = tmp print len(self.query_object.selected_list_of_event_names) def _query_button_changed(self): self._save_search() self.query_object.execute_query() def _quit_button_changed(self): self._save_search() sys.exit(0)