class Network(BaseNetwork): name = Str nodes = List(Node) edges = List(Edge) def __init__(self, name): self.name = name def add_node(self, n, **attr): """ How to store bidir node names? Add a dictionary and/or a list of parameters """ a = Node(n) # create Traits attribute for dict a.attr.trait_set(**attr) #for k,v in attr.items(): # a.attr.add_trait(k, v) self.nodes.append(a)
class ToolkitEditorFactory(EditorFactory): """ Editor factory for graph editors. """ #-------------------------------------------------------------------------- # Trait definitions: #-------------------------------------------------------------------------- canvas = Instance(GraphCanvas) # Graph node definitions. nodes = List(Instance(GraphNode)) # Graph edge definitions. edges = List(Instance(GraphEdge)) # Called when a graph element is selected. on_select = Callable #-------------------------------------------------------------------------- # Property getters: #-------------------------------------------------------------------------- def _get_simple_editor_class(self): """ Returns the editor class to use for "simple" style views. """ return SimpleGraphEditor
class PupilGenerator(HasTraits): wavelength = Float(700) NA = Float(1.49) n = Float(1.51) pupilSizeX = Int(61) pixelSize = Float(70) pupils = List(_pupils) aberations = List(ZernikeMode, value=[ZernikeMode(i) for i in range(25)]) basePupil = Instance(Pupil, _getDefaultPupil) pupil = None view = View(Item( 'basePupil', label='Pupil source', editor=InstanceEditor(name='pupils', editable=True), ), Item('_'), Item('wavelength'), Item('n'), Item('NA'), Item('pupilSizeX'), Item('pixelSize'), Item('_'), Item('aberations'), buttons=[OKButton]) def GetPupil(self): u, v, R, pupil = self.basePupil.GeneratePupil(self.pixelSize, self.pupilSizeX, self.wavelength, self.NA, self.n)
class Equalizer(HasTraits): freq = Range(10.0, SAMPLING_RATE / 2, 1000) Q = Range(0.1, 10.0, 1.0) gain = Range(-24.0, 24.0, 0) a = List(Float, [1.0, 0.0, 0.0]) b = List(Float, [1.0, 0.0, 0.0]) h = Array(dtype=np.complex, transient=True) def __init__(self): super(Equalizer, self).__init__() self.design_parameter() @on_trait_change("freq,Q,gain") def design_parameter(self): '''设计系数并计算频率响应''' try: self.b, self.a = design_equalizer(self.freq, self.Q, self.gain, SAMPLING_RATE) except: self.b, self.a = [1.0, 0.0, 0.0], [1.0, 0.0, 0.0] self.h = myfreqz(self.b, self.a, W) def export_parameters(self, f): '''输出滤波器系数为C语言数组''' tmp = self.b[0], self.b[1], self.b[2], self.a[1], self.a[ 2], self.freq, self.Q, self.gain f.write("{%s,%s,%s,%s,%s}, // %s,%s,%s\n" % tmp)
class CheckListTest ( Handler ): #--------------------------------------------------------------------------- # Trait definitions: #--------------------------------------------------------------------------- value = List( editor = CheckListEditor( name = 'values', cols = 5 ) ) values = List( Str ) values_text = Str( 'red orange yellow green blue indigo violet' ) #--------------------------------------------------------------------------- # Traits view definitions: #--------------------------------------------------------------------------- simple_view = View( 'value', 'values_text@' ) custom_view = View( 'value@', 'values_text@' ) #--------------------------------------------------------------------------- # 'Initializes the object: #--------------------------------------------------------------------------- def __init__ ( self, **traits ): super( CheckListTest, self ).__init__( **traits ) self._values_text_changed() #--------------------------------------------------------------------------- # Event handlers: #--------------------------------------------------------------------------- def _values_text_changed ( self ): self.values = self.values_text.split()
class MultiSelect ( HasPrivateTraits ): choices = List( Str ) selected = List( Str ) view = View( HGroup( Item( 'choices', show_label = False, editor = TabularEditor( show_titles = False, selected = 'selected', editable = False, multi_select = True, adapter = MultiSelectAdapter() ) ), Item( 'selected', show_label = False, editor = TabularEditor( show_titles = False, editable = False, adapter = MultiSelectAdapter() ) ) ) )
class Patient(HasTraits): studies = List(Study) dicom_datasets = List(PythonValue) patient_id = Str name = Str label = Property(depends_on=['dicom_dataset']) def _get_label(self): return "%s <%s>" % (self.name, self.patient_id) @on_trait_change("dicom_datasets[]") def update_studies(self, obj, name, old, new): print "Patient.update_studies()" studyuids = defaultdict(lambda: []) for x in self.dicom_datasets: studyuids[x.StudyInstanceUID].append(x) sd = {x.study_instance_uid: x for x in self.studies} newuids = [uid for uid in studyuids if uid not in sd] goneuids = [uid for uid in sd if uid not in studyuids] updateduids = [uid for uid in sd if uid in studyuids] for uid in newuids: self.studies.append( Study(dicom_datasets=studyuids[uid], patient=self, study_instance_uid=uid)) for uid in goneuids: self.studies.pop(sd[uid]) for uid in updateduids: sd[uid].dicom_datasets = studyuids[uid]
class Series(HasTraits): sopinstances = List(SOPInstance) # study = Instance(Study) dicom_datasets = List(PythonValue) series_instance_uid = Str label = Property(depends_on=['dicom_dataset']) def _get_label(self): return "Series %s [%s]" % (self.dicom_datasets[0].Modality, self.series_instance_uid) @on_trait_change("dicom_datasets[]") def update_sopinstances(self, obj, name, old, new): print "Series.update_sopinstances()" sopuids = defaultdict(lambda: []) for x in self.dicom_datasets: sopuids[x.SOPInstanceUID].append(x) sd = {x.sopinstanceuid: x for x in self.sopinstances} newuids = [uid for uid in sopuids if uid not in sd] goneuids = [uid for uid in sd if uid not in sopuids] for uid in newuids: assert len(sopuids[uid]) == 1 cls = specialsops[sopuids[uid][0].SOPClassUID] print "building %s" % (cls, ) self.sopinstances.append( cls(dicom_dataset=sopuids[uid][0], series=self)) for uid in goneuids: self.sopinstances.pop(sd[uid])
class IUserManager(Interface): """The interface implemented by a user manager to manage users.""" # The list of PyFace management actions (ie. actions related to all users) # implemented by this user manager. management_actions = List(Instance(Action)) # The current user. user = Instance(IUser) # The list of PyFace user actions (ie. actions related to the current user) # implemented by this user manager. user_actions = List(Instance(Action)) # This is fired whenever the currently authenticated user changes. It will # be None if the current user isn't authenticated. user_authenticated = Event(IUser) def bootstrapping(self): """Return True if the user manager is bootstrapping. Typically this is when no users have been defined.""" def authenticate_user(self): """Authenticate (ie. login) the user. If successfully authenticated all secured objects are re-enabled according to the user's permissions. """ def unauthenticate_user(self): """Unauthenticate (ie. logout) the user. All secured objects are disabled.""" def select_user(self, name): """Return an object that implements IUser for the user selected based
class MultiSelect(HasPrivateTraits): """ This class demonstrates using the StringListEditor to select a set of string values from a set of choices. """ # The list of choices to select from: choices = List(Str) # The currently selected list of choices: selected = List(Str) # A dummy result so that we can display the selection using the same # StringListEditor: result = List(Str) # A traits view showing the list of choices on the left-hand side, and # the currently selected choices on the right-hand side: view = View(HGroup( Item('selected', show_label=False, editor=StringListEditor(choices='choices')), Item('result', show_label=False, editor=StringListEditor(choices='selected'))), width=0.20, height=0.25)
class _StringListEditor(UIEditor): # Indicate that the editor is scrollable/resizable: scrollable = True # The list of available editor choices: choices = List(Str) # The list of currently selected items: selected = List(Str) # The traits UI view used by the editor: view = View(Item('choices', show_label=False, editor=TabularEditor(show_titles=False, selected='selected', editable=False, multi_select=True, adapter=MultiSelectAdapter())), id='string_list_editor', resizable=True) def init_ui(self, parent): self.sync_value(self.factory.choices, 'choices', 'from', is_list=True) self.selected = self.value return self.edit_traits(parent=parent, kind='subpanel') @on_trait_change(' selected') def _selected_modified(self): self.value = self.selected
class Study(HasTraits): series = List(Series) # patient = Instance(Patient) dicom_datasets = List(PythonValue) study_instance_uid = Str label = Property(depends_on=['dicom_dataset']) def _get_label(self): return "Study %s [%s]" % (self.dicom_datasets[0].StudyID, self.study_instance_uid) @on_trait_change("dicom_datasets[]") def update_series(self, obj, name, old, new): print "Study.update_series()" seriesuids = defaultdict(lambda: []) for x in self.dicom_datasets: seriesuids[x.SeriesInstanceUID].append(x) sd = {x.series_instance_uid: x for x in self.series} newuids = [uid for uid in seriesuids if uid not in sd] goneuids = [uid for uid in sd if uid not in seriesuids] updateduids = [uid for uid in sd if uid in seriesuids] for uid in newuids: self.series.append( Series(dicom_datasets=seriesuids[uid], study=self, series_instance_uid=uid)) for uid in goneuids: self.series.pop(sd[uid]) for uid in updateduids: sd[uid].dicom_datasets = seriesuids[uid]
class ExplorerPlugin(Plugin): # Extension points we contribute to. PERSPECTIVES = 'enthought.envisage.ui.workbench.perspectives' VIEWS = 'enthought.envisage.ui.workbench.views' SERVICE_OFFERS = 'enthought.envisage.ui.workbench.service_offers' # The plugin's unique identifier. id = 'explorer3d.Explorer3D' # The plugin's name (suitable for displaying to the user). name = '3D function explorer' # Perspectives. perspectives = List(contributes_to=PERSPECTIVES) # Services we contribute. service_offers = List(contributes_to=SERVICE_OFFERS) # Views. views = List(contributes_to=VIEWS) ###################################################################### # Private methods. def _perspectives_default(self): """ Trait initializer. """ return [ExplorerPerspective] def _service_offers_default(self): """ Trait initializer. """ explorer_service_offer = ServiceOffer( protocol='explorer_app.Explorer3D', factory='explorer_app.Explorer3D') return [explorer_service_offer] def _views_default(self): """ Trait initializer. """ return [self._explorer_view_factory] def _explorer_view_factory(self, window, **traits): """ Factory method for explorer views. """ from enthought.pyface.workbench.traits_ui_view import \ TraitsUIView explorer = self._get_explorer(window) tui_engine_view = TraitsUIView(obj=explorer, id='explorer3d.Explorer3D', name='Explorer3D', window=window, position='left', **traits) return tui_engine_view def _get_explorer(self, window): """Return the explorer service.""" return window.get_service('explorer_app.Explorer3D')
class NBSNetworkParameter(HasTraits): choices1 = List(Str) selected1 = List(Str) choices2 = List(Str) selected2 = List(Str) view = View( HGroup( Group(HGroup( Item('choices1', show_label=False, editor=TabularEditor(show_titles=False, selected='selected1', editable=False, multi_select=True, adapter=MultiSelectAdapter())), Item('selected1', show_label=False, editor=TabularEditor(show_titles=False, editable=False, adapter=MultiSelectAdapter())), ), label="First group"), Group(HGroup( Item('choices2', show_label=False, editor=TabularEditor(show_titles=False, selected='selected2', editable=False, multi_select=True, adapter=MultiSelectAdapter())), Item('selected2', show_label=False, editor=TabularEditor(show_titles=False, editable=False, adapter=MultiSelectAdapter())), ), label="Second group"), ), title='Select networks', width=0.5, height=0.5, buttons=['OK'], resizable=True, ) def __init__(self, cfile, **traits): super(NBSNetworkParameter, self).__init__(**traits) li = [] for cobj in cfile.connectome_network: li.append(cobj.obj.name) self.choices1 = li self.choices2 = li
class SetEditorDemo(HasTraits): """ Defines the SetEditor demo class. """ # Define a trait each for four SetEditor variants: unord_nma_set = List( editor=SetEditor(values=['kumquats', 'pomegranates', 'kiwi'], can_move_all=False, left_column_title='Available Fruit', right_column_title='Exotic Fruit Bowl')) unord_ma_set = List( editor=SetEditor(values=['kumquats', 'pomegranates', 'kiwi'], left_column_title='Available Fruit', right_column_title='Exotic Fruit Bowl')) ord_nma_set = List( editor=SetEditor(values=['apples', 'berries', 'cantaloupe'], ordered=True, can_move_all=False, left_column_title='Available Fruit', right_column_title='Fruit Bowl')) ord_ma_set = List( editor=SetEditor(values=['apples', 'berries', 'cantaloupe'], ordered=True, left_column_title='Available Fruit', right_column_title='Fruit Bowl')) # SetEditor display, unordered, no move-all buttons: no_nma_group = Group(Item('unord_nma_set', style='simple'), label='Unord I', show_labels=False) # SetEditor display, unordered, move-all buttons: no_ma_group = Group(Item('unord_ma_set', style='simple'), label='Unord II', show_labels=False) # SetEditor display, ordered, no move-all buttons: o_nma_group = Group(Item('ord_nma_set', style='simple'), label='Ord I', show_labels=False) # SetEditor display, ordered, move-all buttons: o_ma_group = Group(Item('ord_ma_set', style='simple'), label='Ord II', show_labels=False) # The view includes one group per data type. These will be displayed # on separate tabbed panels: view = View(no_nma_group, no_ma_group, o_nma_group, o_ma_group, title='SetEditor', buttons=['OK'])
class CheckListEditorDemo(HasTraits): """ Define the main CheckListEditor demo class. """ # Define a trait for each of three formations: checklist_4col = List( editor=CheckListEditor(values=['one', 'two', 'three', 'four'], cols=4)) checklist_2col = List( editor=CheckListEditor(values=['one', 'two', 'three', 'four'], cols=2)) checklist_1col = List( editor=CheckListEditor(values=['one', 'two', 'three', 'four'], cols=1)) # CheckListEditor display with four columns: cl_4_group = Group(Item('checklist_4col', style='simple', label='Simple'), Item('_'), Item('checklist_4col', style='custom', label='Custom'), Item('_'), Item('checklist_4col', style='text', label='Text'), Item('_'), Item('checklist_4col', style='readonly', label='ReadOnly'), label='4-column') # CheckListEditor display with two columns: cl_2_group = Group(Item('checklist_2col', style='simple', label='Simple'), Item('_'), Item('checklist_2col', style='custom', label='Custom'), Item('_'), Item('checklist_2col', style='text', label='Text'), Item('_'), Item('checklist_2col', style='readonly', label='ReadOnly'), label='2-column') # CheckListEditor display with one column: cl_1_group = Group(Item('checklist_1col', style='simple', label='Simple'), Item('_'), Item('checklist_1col', style='custom', label='Custom'), Item('_'), Item('checklist_1col', style='text', label='Text'), Item('_'), Item('checklist_1col', style='readonly', label='ReadOnly'), label='1-column') # The view includes one group per column formation. These will be displayed # on separate tabbed panels. view1 = View(cl_4_group, cl_2_group, cl_1_group, title='CheckListEditor', buttons=['OK'], resizable=True)
class _RegistryData(HasTraits): # Object's script ID script_id = Property(Str) # Path to object in object hierarchy. path = Property(Str) # Parent data for this object if any. parent_data = Instance('_RegistryData', allow_none=True) # The name of the trait on the parent which is this object. trait_name_on_parent = Str('') # List of traits we are listening for on this object. names = List(Str) # Nested recordable instances on the object. sub_recordables = List(Str) # List of traits that are lists. list_names = List(Str) _script_id = Str('') ###################################################################### # Non-public interface. ###################################################################### def _get_path(self): pdata = self.parent_data path = '' if pdata is not None: pid = pdata.script_id ppath = pdata.path tnop = self.trait_name_on_parent if '[' in tnop: # If the object is a nested object through an iterator, # we instantiate it and don't refer to it through the # path, this makes scripting convenient. if len(ppath) == 0: path = pid + '.' + tnop else: path = ppath + '.' + tnop else: path = ppath + '.' + tnop return path def _get_script_id(self): sid = self._script_id if len(sid) == 0: pdata = self.parent_data sid = pdata.script_id + '.' + self.trait_name_on_parent return sid def _set_script_id(self, id): self._script_id = id
class GraphCanvas(HasPrivateTraits): """ Defines a representation of a graph canvas for use by the graph editor and the graph editor factory classes. """ # Names of list traits whose elements are represented as nodes. node_children = List(Str) # Names of the list traits whose elements are represented as edges. edge_children = List(Str)
class Facet(Sphere): """Facet class creates Facet from triangle list, follows the usual VTK pipeline and creates a Facet actor, which is passed to the show_actor() function as an argument. """ ##################################################################### # Traits definitions coords = List(value=[[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], 0.0, 0.0, 1.0], desc='the vertex list') indices = List(value=[[0, 1, 2]], desc='the triangle index list') color = vtk_color_trait((1.0, 1.0, 1.0)) representation = Enum('s', 'w', 'p') visibility = Bool(True) viewer = Any polydata = Instance(tvtk.PolyData, ()) property = Instance(tvtk.Property) actor = Instance(tvtk.Actor, ()) # tvtk Actor, for the usual pipeline architecture. ###################################################################### # User interface view traits_view = View( Group(Item(name='coords', style='simple', label='Vertices'), Item(name='indices', label='Triangle indices'), Item(name='color'), Item(name='visibility'), Item(name='representation'), label='Facet Properties', show_border=True)) def __init__(self, **traits): self.property = self.actor.property HasTraits.__init__(self, **traits) self._create_points(self.coords, self.indices) self._color_changed(self.color) self._visibility_changed(self.visibility) normals = tvtk.PolyDataNormals(input=self.polydata) m = tvtk.PolyDataMapper( input=normals.output) # the usual vtk pipleine countinuation self.actor.mapper = m self.property = self.actor.property self.property.representation = self.representation show_actor(self.actor) # passing the actors function for rendering self.viewer = get_viewer() # getting the ivtk viewer self.property.on_trait_change(self.viewer.scene.render) self.actor.on_trait_change(self.viewer.scene.render) ###################################################################### # Non-public methods, Event handlers def _create_points(self, c, i): self.polydata = tvtk.PolyData(points=numpy.array(c), polys=numpy.array(i)) self.points = c return self.points, self.polydata.polys
class AcmeUIPreferencesHelper(PreferencesHelper): """ A helper! """ # The traits that we want to initialize from preferences. bgcolor = Str width = Int ratio = Float visible = Bool description = Unicode offsets = List(Int) names = List(Str)
class GodotPlugin(Plugin): """ Godot plug-in. """ # Extension point IDs EDITORS = "puddle.resource.editors" NEW_WIZARDS = "puddle.resource.new_wizards" ACTION_SETS = "enthought.envisage.ui.workbench.action_sets" # Unique plugin identifier id = "godot.plugin" # Human readable plugin name name = "Godot" #-------------------------------------------------------------------------- # Extensions (Contributions): #-------------------------------------------------------------------------- # Contributed workspace editors: editors = List(contributes_to=EDITORS) # Contributed new resource wizards: new_wizards = List(contributes_to=NEW_WIZARDS) # Contributed action sets: action_sets = List(contributes_to=ACTION_SETS) #-------------------------------------------------------------------------- # "ImageEditorPlugin" interface: #-------------------------------------------------------------------------- def _editors_default(self): """ Trait initialiser. """ from graph_editor import GraphEditorExtension from tree_editor import TreeEditorExtension return [GraphEditorExtension, TreeEditorExtension] def _new_wizards_default(self): """ Trait initialiser. """ from wizard import NewDotWizardExtension return [NewDotWizardExtension] def _action_sets_default(self): """ Trait initialiser. """ from action import GodotWorkbenchActionSet return [GodotWorkbenchActionSet]
class ListDemo2(HasTraits): filter_types = List(Str, value=[u"低通", u"高通", u"带通", u"带阻"]) items = List(Str) view = View(HGroup(Item("filter_types", label=u"候选"), Item("items", style="custom", editor=CheckListEditor(name="filter_types")), show_labels=False), resizable=True, width=300, height=180, title=u"动态修改候选值")
class MatchDialog(HasTraits): choices = List(Str) selection = List(Str) view = TraitsView(Item('selection', editor=SetEditor(name='choices', can_move_all=True, ordered=False), show_label=False), buttons=[OKButton, CancelButton], kind='modal', title='Parameters to match')
class LoggerDemoPlugin(Plugin): """ Add some perspectives. """ id = 'LoggerDemoPlugin' BINDINGS = 'enthought.plugins.python_shell.bindings' PERSPECTIVES = 'enthought.envisage.ui.workbench.perspectives' COMMANDS = 'enthought.plugins.python_shell.commands' MAIL_FILES = 'enthought.logger.plugin.mail_files' perspectives = List(contributes_to=PERSPECTIVES) bindings = List(contributes_to=BINDINGS) commands = List(contributes_to=COMMANDS) mail_files = List(contributes_to=MAIL_FILES) def _perspectives_default(self): return [LoggerDemoPerspective] def _bindings_default(self): bindings = [dict( test=self._test, test_timing=self._test_timing, )] return bindings def _commands_default(self): commands = [ 'import logging', ] return commands def _mail_files_default(self): return [self._package_project_files] def _test(self, n=2000): for i in range(n): logging.warn('foo %r', i) def _test_timing(self, n=2000): t = time.time() for i in range(1, n + 1): if not (i % 100): t2 = time.time() print '%1.2f s for 100 logs' % (t2 - t) t = t2 logging.warn('foo %r', i) def _package_project_files(self, zf): """ Add dummy project files to the userdata.zip file to be mailed back. """ write_str_to_zipfile(zf, 'logger_demo/data.txt', 'Foo!\n')
class AcmeUIPreferencesHelper(PreferencesHelper): """ A helper! """ # The path to the preferences node that contains our preferences. preferences_path = 'acme.ui' # The traits that we want to initialize from preferences. bgcolor = Str('blue') width = Int(50) ratio = Float(1.0) visible = Bool(True) description = Unicode(u'description') offsets = List(Int, [1, 2, 3, 4]) names = List(Str, ['joe', 'fred', 'jane'])
class RunOutput(HasTraits): '''class to store the output if a sequence of runcases''' # the names of the variables variable_names = List(String) # 2d array variable_values = Array(numpy.float, shape=(None, None)) eigenmodes = List(List(EigenMode)) eigenmatrix = List(EigenMatrix) #output_view = Instance(View) #eigenmode_view = Instance(View) def save_variables(self, file): file.write('"%s"\n' %('"\t"'.join(self.variable_names))) for row in self.variable_values: file.write('%s\n' %('\t'.join([str(var) for var in row])))
class AcmeUIPreferencesHelper(PreferencesHelper): """ A helper! """ # The path to the preferences node that contains our preferences. preferences_path = 'acme.ui' # The traits that we want to initialize from preferences. bgcolor = Str width = Int ratio = Float visible = Bool description = Unicode offsets = List(Int) names = List(Str)
class TableTest(HasStrictTraits): #--------------------------------------------------------------------------- # Trait definitions: #--------------------------------------------------------------------------- #people = Instance( Person ) people = List(Person) #--------------------------------------------------------------------------- # Traits view definitions: #--------------------------------------------------------------------------- _valid_states = List(["AL", "AR", "AZ", "AK"]) _state_editor = EnumEditor(name="_valid_states", evaluate=evaluate_value, object='table_editor_object') table_editor = TableEditor(columns=[ ObjectColumn(name='name'), ObjectColumn(name='age'), ObjectColumn(name='phone'), ObjectColumn(name='state', editor=_state_editor), ], editable=True, deletable=True, sortable=True, sort_model=True, show_lines=True, orientation='vertical', show_column_labels=True, edit_view=View( ['name', 'age', 'phone', 'state', '|[]'], resizable=True), filter=None, filters=filters, row_factory=Person) traits_view = View( [Item('people', id='people', editor=table_editor), '|[]<>'], title='Table Editor Test', id='enthought.traits.ui.tests.table_editor_test', dock='horizontal', width=.4, height=.3, resizable=True, buttons=NoButtons, kind='live')
class PipelineInfo(HasTraits): """ This class represents the information that a particular input or output of an object should contain. """ # The datasets supported by the object. datasets = List(DataSet) # The attribute types the object works on. attribute_types = List(AttributeType) # The attributes the object can use/produce. attributes = List(Attribute)
class DataSet(HasTraits): """ A class encapsulating a dataset of binary masks of segmented images stored in an HDF5 file. """ h5file = Instance(tables.File) plates = List(Str) def __init__(self, *args, **kwargs): """ Construct a DataSet object from the given PyTables file handle. """ super(DataSet, self).__init__(*args, **kwargs) for platenode in self.h5file.root: self.plates.append(getattr(platenode, '_v_pathname')) def __len__(self): return len(self.plates) def __getitem__(self, key): if type(key) is slice: indices = islice(xrange(len(self)), *key.indices(len(self))) return [self[nkey] for nkey in indices] else: node = self.h5file.getNode(self.plates[key]) return Plate(h5file=self.h5file, node=node) def __contains__(self): raise TypeError("Containment checking not supported: %s" % str(self))