Changeset 581


Ignore:
Timestamp:
Apr 30, 2012 12:42:29 PM (9 years ago)
Author:
toby
Message:

refactor to simplify import setup

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASII.py

    r580 r581  
    193193        self.Bind(wx.EVT_MENU, self.OnSeqRefine, id=wxID_SEQREFINE)
    194194       
    195     def _init_Import_Phase(self,parent):
    196         '''import all the G2importphase*.py files that are found in the
    197         path and configure the Import Phase menus accordingly
     195    def _init_Import_routines(self,parent,prefix,readerlist,errprefix):
     196        '''import all the import readers matching the prefix
    198197        '''
    199 
    200198        path2GSAS2 = os.path.dirname(os.path.realpath(__file__)) # location of this file
    201199        pathlist = sys.path[:]
     
    203201        filelist = []
    204202        for path in pathlist:
    205             for filename in glob.iglob(os.path.join(path, "G2importphase*.py")):
     203            for filename in glob.iglob(os.path.join(
     204                path,
     205                "G2import"+prefix+"*.py")):
    206206                filelist.append(filename)   
    207207                #print 'found',filename
    208208        filelist = sorted(list(set(filelist))) # remove duplicates
    209         self.ImportPhaseReaderlist = []
    210209        for filename in filelist:
    211210            path,rootname = os.path.split(filename)
     
    223222                            if not callable(getattr(clss[1],m)): break
    224223                        else:
    225                             reader = clss[1]() # create a phase import instance
    226                             self.ImportPhaseReaderlist.append(reader)
     224                            reader = clss[1]() # create an import instance
     225                            readerlist.append(reader)
    227226            except AttributeError:
    228                 print 'Import_Phase: Attribute Error',filename
     227                print 'Import_'+errprefix+': Attribute Error'+str(filename)
    229228                pass
    230229            except ImportError:
    231                 print 'Import_Phase: Error importing file',filename
     230                print 'Import_'+errprefix+': Error importing file'+str(filename)
    232231                pass
    233232            finally:
    234233                if fp: fp.close()
    235         submenu = wx.Menu()
    236         item = parent.AppendMenu(wx.ID_ANY, 'Import Phase menu',
    237             submenu, help='Import phase data')
    238         self.PhaseImportMenuId = {}
    239         item = submenu.Append(wx.ID_ANY,
    240                               help='Import phase data based selected by extension',
    241                               kind=wx.ITEM_NORMAL,text='Import Phase by extension')
    242         self.Bind(wx.EVT_MENU, self.OnImportPhaseGeneric, id=item.GetId())
    243         for reader in self.ImportPhaseReaderlist:
    244             item = submenu.Append(wx.ID_ANY,
    245                 help='Import specific format phase data',
    246                 kind=wx.ITEM_NORMAL,text='Import Phase '+reader.formatName+'...')
    247             self.PhaseImportMenuId[item.GetId()] = reader
    248             self.Bind(wx.EVT_MENU, self.OnImportPhaseGeneric, id=item.GetId())
    249 
    250     def OnImportPhaseGeneric(self,event):
    251         # find out which format was requested
    252         reader = self.PhaseImportMenuId.get(event.GetId())
     234
     235    def OnImportGeneric(self,reader,readerlist,label):
     236        '''Call the requested import reader or all of the appropriate
     237        import readers in response to a menu item
     238        '''
     239        self.lastimport = ''
    253240        if reader is None:
    254241            #print "use all formats"
    255             readerlist = self.ImportPhaseReaderlist
    256242            choices = "any file (*.*)|*.*"
    257243            extdict = {}
     
    281267        # get the file
    282268        dlg = wx.FileDialog(
    283             self, message="Choose phase input file",
     269            self, message="Choose "+label+" input file",
    284270            #defaultDir=os.getcwd(),
    285271            defaultFile="",
     
    291277                file = dlg.GetPath()
    292278            else: # cancel was pressed
    293                 return
     279                return None
    294280        finally:
    295281            dlg.Destroy()
     
    305291        if len(secondaryReaders) + len(primaryReaders) == 0:
    306292            self.ErrorDialog('No Format','No matching format for file '+file)
    307             return
     293            return None
    308294       
    309295        fp = None
    310296        try:
    311297            fp = open(file,'r')
     298            self.lastimport = file
    312299            # try the file first with Readers that specify the
    313300            # files extension and later with ones that allow it
     
    327314                    continue
    328315                if not flag: continue
    329                 dlg = wx.TextEntryDialog( # allow editing of phase name
    330                     self, 'Enter the name for the new phase',
    331                     'Edit phase name', rd.Phase['General']['Name'],
    332                     style=wx.OK)
    333                 dlg.CenterOnParent()
    334                 if dlg.ShowModal() == wx.ID_OK:
    335                     rd.Phase['General']['Name'] = dlg.GetValue()
    336                 dlg.Destroy()
    337                 PhaseName = rd.Phase['General']['Name']
    338                 print 'Read phase '+str(PhaseName)+' from file '+str(file)
    339                 self.CheckNotebook()
    340                 if not G2gd.GetPatternTreeItemId(self,self.root,'Phases'):
    341                     sub = self.PatternTree.AppendItem(parent=self.root,text='Phases')
    342                 else:
    343                     sub = G2gd.GetPatternTreeItemId(self,self.root,'Phases')
    344                 psub = self.PatternTree.AppendItem(parent=sub,text=PhaseName)
    345                 self.PatternTree.SetItemPyData(psub,rd.Phase)
    346                 self.PatternTree.Expand(self.root) # make sure phases are seen
    347                 self.PatternTree.Expand(sub)
    348                 self.PatternTree.Expand(psub)
    349                 return # success
     316                return rd
    350317        except:
    351318            import traceback
    352319            print traceback.format_exc()
    353             self.ErrorDialog('Open Error',
    354                              'Error on open of file '+file)
     320            self.ErrorDialog('Open Error','Error on open of file '+file)
    355321        finally:
    356322            if fp: fp.close()
    357 
    358         return
     323        return None
     324
     325    def _init_Import_Phase(self,parent):
     326        '''import all the G2importphase*.py files that are found in the
     327        path and configure the Import Phase menus accordingly
     328        '''
     329        self.ImportPhaseReaderlist = []
     330        self._init_Import_routines(parent,'phase',
     331                                   self.ImportPhaseReaderlist,
     332                                   'Phase')
     333        submenu = wx.Menu()
     334        item = parent.AppendMenu(wx.ID_ANY, 'Import Phase menu',
     335            submenu, help='Import phase data')
     336        item = submenu.Append(wx.ID_ANY,
     337                              help='Import phase data based selected by extension',
     338                              kind=wx.ITEM_NORMAL,text='Import Phase by extension')
     339        self.Bind(wx.EVT_MENU, self.OnImportPhase, id=item.GetId())
     340        for reader in self.ImportPhaseReaderlist:
     341            item = submenu.Append(wx.ID_ANY,
     342                help='Import specific format phase data',
     343                kind=wx.ITEM_NORMAL,text='Import Phase '+reader.formatName+'...')
     344            self.ImportMenuId[item.GetId()] = reader
     345            self.Bind(wx.EVT_MENU, self.OnImportPhase, id=item.GetId())
     346
     347    def OnImportPhase(self,event):
     348        # look up which format was requested
     349        reader = self.ImportMenuId.get(event.GetId())
     350        rd = self.OnImportGeneric(reader,
     351                                  self.ImportPhaseReaderlist,
     352                                  'phase')
     353        if rd is None: return
     354        dlg = wx.TextEntryDialog( # allow editing of phase name
     355            self, 'Enter the name for the new phase',
     356            'Edit phase name', rd.Phase['General']['Name'],
     357            style=wx.OK)
     358        dlg.CenterOnParent()
     359        if dlg.ShowModal() == wx.ID_OK:
     360            rd.Phase['General']['Name'] = dlg.GetValue()
     361        dlg.Destroy()
     362        PhaseName = rd.Phase['General']['Name']
     363        print 'Read phase '+str(PhaseName)+' from file '+str(self.lastimport)
     364        self.CheckNotebook()
     365        if not G2gd.GetPatternTreeItemId(self,self.root,'Phases'):
     366            sub = self.PatternTree.AppendItem(parent=self.root,text='Phases')
     367        else:
     368            sub = G2gd.GetPatternTreeItemId(self,self.root,'Phases')
     369        psub = self.PatternTree.AppendItem(parent=sub,text=PhaseName)
     370        self.PatternTree.SetItemPyData(psub,rd.Phase)
     371        self.PatternTree.Expand(self.root) # make sure phases are seen
     372        self.PatternTree.Expand(sub)
     373        self.PatternTree.Expand(psub)
     374        return # success
    359375       
    360376    def _init_Import_Sfact(self,parent):
     
    362378        path and configure the Import Structure Factor menus accordingly
    363379        '''
    364 
    365         path2GSAS2 = os.path.dirname(os.path.realpath(__file__)) # location of this file
    366         pathlist = sys.path[:]
    367         if path2GSAS2 not in pathlist: pathlist.append(path2GSAS2)
    368         filelist = []
    369         for path in pathlist:
    370             #print path
    371             for filename in glob.iglob(os.path.join(path, "G2importsfact*.py")):
    372                 filelist.append(filename)   
    373                 #print 'found',filename
    374         filelist = sorted(list(set(filelist))) # remove duplicates
    375380        self.ImportSfactReaderlist = []
    376         for filename in filelist:
    377             path,rootname = os.path.split(filename)
    378             pkg = os.path.splitext(rootname)[0]
    379             try:
    380                 fp = None
    381                 fp, fppath,desc = imp.find_module(pkg,[path,])
    382                 pkg = imp.load_module(pkg,fp,fppath,desc)
    383                 for clss in inspect.getmembers(pkg): # find classes defined in package
    384                     if clss[0].startswith('_'): continue
    385                     if inspect.isclass(clss[1]):
    386                         # check if we have the required methods
    387                         for m in 'Reader','ExtensionValidator','ContentsValidator':
    388                             if not hasattr(clss[1],m): break
    389                             if not callable(getattr(clss[1],m)): break
    390                         else:
    391                             reader = clss[1]() # create a Structure Factor import instance
    392                             self.ImportSfactReaderlist.append(reader)
    393             except AttributeError:
    394                 print 'Import_Sfact: Attribute Error',filename
    395                 pass
    396             except ImportError:
    397                 print 'Import_Sfact: Error importing file',filename
    398                 pass
    399             finally:
    400                 if fp: fp.close()
     381        self._init_Import_routines(parent,'sfact',
     382                                   self.ImportSfactReaderlist,
     383                                   'Struct_Factor')
    401384        submenu = wx.Menu()
    402385        item = parent.AppendMenu(wx.ID_ANY, 'Import Structure Factor menu',
    403386            submenu, help='Import Structure Factor data')
    404         self.SfactImportMenuId = {}
    405387        item = submenu.Append(wx.ID_ANY,
    406388                              help='Import Structure Factor data based selected by extension',
    407389                              kind=wx.ITEM_NORMAL,text='Import Structure Factor by extension')
    408         self.Bind(wx.EVT_MENU, self.OnImportSfactGeneric, id=item.GetId())
     390        self.Bind(wx.EVT_MENU, self.OnImportSfact, id=item.GetId())
    409391        for reader in self.ImportSfactReaderlist:
    410392            item = submenu.Append(wx.ID_ANY,
    411393                help='Import specific format Structure Factor data',
    412394                kind=wx.ITEM_NORMAL,text='Import Structure Factor '+reader.formatName+'...')
    413             self.SfactImportMenuId[item.GetId()] = reader
    414             self.Bind(wx.EVT_MENU, self.OnImportSfactGeneric, id=item.GetId())
    415 
    416     def OnImportSfactGeneric(self,event):
    417         # find out which format was requested
    418         reader = self.SfactImportMenuId.get(event.GetId())
    419         if reader is None:
    420             #print "use all formats"
    421             readerlist = self.ImportSfactReaderlist
    422             choices = "any file (*.*)|*.*"
    423             extdict = {}
    424             # compile a list of allowed extensions
    425             for rd in readerlist:
    426                 fmt = rd.formatName
    427                 for extn in rd.extensionlist:
    428                     if not extdict.get(extn): extdict[extn] = []
    429                     extdict[extn] += [fmt,]
    430             for extn in sorted(extdict.keys(),cmp=lambda x,y: cmp(x.lower(), y.lower())):
    431                 fmt = ''
    432                 for f in extdict[extn]:
    433                     if fmt != "": fmt += ', '
    434                     fmt += f
    435                 choices += "|" + fmt + " file (*" + extn + ")|*" + extn
    436         else:
    437             readerlist = [reader,]
    438             # compile a list of allowed extensions
    439             choices = reader.formatName + " file ("
    440             w = ""
    441             for extn in reader.extensionlist:
    442                 if w != "": w += ";"
    443                 w += "*" + extn
    444             choices += w + ")|" + w
    445             if not reader.strictExtension:
    446                 choices += "|any file (*.*)|*.*"
    447         # get the file
    448         dlg = wx.FileDialog(
    449             self, message="Choose Structure Factor input file",
    450             #defaultDir=os.getcwd(),
    451             defaultFile="",
    452             wildcard=choices,
    453             style=wx.OPEN | wx.CHANGE_DIR
    454             )
    455         try:
    456             if dlg.ShowModal() == wx.ID_OK:
    457                 file = dlg.GetPath()
    458             else: # cancel was pressed
    459                 return
    460         finally:
    461             dlg.Destroy()
    462         # set what formats are compatible with this file
    463         primaryReaders = []
    464         secondaryReaders = []
    465         for reader in readerlist:
    466             flag = reader.ExtensionValidator(file)
    467             if flag is None:
    468                 secondaryReaders.append(reader)
    469             elif flag:
    470                 primaryReaders.append(reader)
    471         if len(secondaryReaders) + len(primaryReaders) == 0:
    472             self.ErrorDialog('No Format','No matching format for file '+file)
    473             return
    474        
    475         fp = None
    476         try:
    477             fp = open(file,'r')
    478             # try the file first with Readers that specify the
    479             # files extension and later with ones that allow it
    480             for rd in primaryReaders+secondaryReaders:
    481                 fp.seek(0)  # rewind
    482                 if not rd.ContentsValidator(fp):
    483                     continue # rejected on cursory check
    484                 try:
    485                     fp.seek(0)  # rewind
    486                     flag = rd.Reader(file,fp,self)
    487                 except:
    488                     import traceback
    489                     print traceback.format_exc()
    490                     self.ErrorDialog('Read Error',
    491                                      'Error reading file '+file
    492                                      +' with format '+ rd.formatName)
    493                     continue
    494                 if not flag: continue
    495                 HistName = ospath.basename(file)
    496                 dlg = wx.TextEntryDialog( # allow editing of Structure Factor name
    497                     self, 'Enter the name for the new Structure Factor',
    498                     'Edit Structure Factor name', HistName,
    499                     style=wx.OK)
    500                 dlg.CenterOnParent()
    501                 if dlg.ShowModal() == wx.ID_OK:
    502                     HistName = dlg.GetValue()
    503                 dlg.Destroy()
    504                 print 'Read structure factor table '+str(HistName)+' from file '+str(file)
    505                 self.CheckNotebook()
    506                 Id = self.PatternTree.AppendItem(parent=self.root,
    507                                                  text='HKLF '+HistName)
    508                 self.PatternTree.SetItemPyData(Id,rd.RefList)
    509                 Sub = self.PatternTree.AppendItem(Id,text='Instrument Parameters')
    510                 self.PatternTree.SetItemPyData(Sub,rd.Parameters)
    511                 self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(
    512                     Id,text='HKL Plot Controls'),
    513                                                rd.Controls)
    514                 self.PatternTree.SelectItem(Id)
    515                 self.PatternTree.Expand(Id)
    516                 self.Sngl = Id
    517                 return # success
    518         except:
    519             import traceback
    520             print traceback.format_exc()
    521             self.ErrorDialog('Open Error',
    522                              'Error on open of file '+file)
    523         finally:
    524             if fp: fp.close()
    525 
    526         return
     395            self.ImportMenuId[item.GetId()] = reader
     396            self.Bind(wx.EVT_MENU, self.OnImportSfact, id=item.GetId())
     397
     398    def OnImportSfact(self,event):
     399        # look up which format was requested
     400        reader = self.ImportMenuId.get(event.GetId())
     401        rd = self.OnImportGeneric(reader,
     402                                  self.ImportSfactReaderlist,
     403                                  'Structure Factor')
     404        if rd is None: return
     405        HistName = ospath.basename(self.lastimport)
     406        dlg = wx.TextEntryDialog( # allow editing of Structure Factor name
     407            self, 'Enter the name for the new Structure Factor',
     408            'Edit Structure Factor name', HistName,
     409            style=wx.OK)
     410        dlg.CenterOnParent()
     411        if dlg.ShowModal() == wx.ID_OK:
     412            HistName = dlg.GetValue()
     413        dlg.Destroy()
     414        print 'Read structure factor table '+str(HistName)+' from file '+str(self.lastimport)
     415        self.CheckNotebook()
     416        Id = self.PatternTree.AppendItem(parent=self.root,
     417                                         text='HKLF '+HistName)
     418        self.PatternTree.SetItemPyData(Id,rd.RefList)
     419        Sub = self.PatternTree.AppendItem(Id,text='Instrument Parameters')
     420        self.PatternTree.SetItemPyData(Sub,rd.Parameters)
     421        self.PatternTree.SetItemPyData(
     422            self.PatternTree.AppendItem(Id,text='HKL Plot Controls'),
     423            rd.Controls)
     424        self.PatternTree.SelectItem(Id)
     425        self.PatternTree.Expand(Id)
     426        self.Sngl = Id
     427        return # success
    527428
    528429    def _init_coll_Import_Items(self,parent):
     
    572473        self._init_coll_Data_Items(self.Data)
    573474        self._init_coll_Calculate_Items(self.Calculate)
     475        self.ImportMenuId = {}
    574476        self._init_Import_Phase(self.Import)
    575477        self._init_Import_Sfact(self.Import)
  • trunk/GSASIIIO.py

    r580 r581  
    13731373        than one phase
    13741374        '''
    1375         self.BlockSelector(ChoiceList, ParentFrame, title, size, header)
     1375        return self.BlockSelector(ChoiceList,
     1376                                  ParentFrame,
     1377                                  title,
     1378                                  size,
     1379                                  header)
    13761380
    13771381######################################################################
Note: See TracChangeset for help on using the changeset viewer.