Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/perspectives/fitting/pagestate.py

    r6c382da re89aed5  
    22    Class that holds a fit page state 
    33""" 
    4 #TODO: Refactor code so we don't need to use getattr/setattr 
     4# TODO: Refactor code so we don't need to use getattr/setattr 
    55################################################################################ 
    6 #This software was developed by the University of Tennessee as part of the 
    7 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    8 #project funded by the US National Science Foundation. 
     6# This software was developed by the University of Tennessee as part of the 
     7# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     8# project funded by the US National Science Foundation. 
    99# 
    10 #See the license text in license.txt 
     10# See the license text in license.txt 
    1111# 
    12 #copyright 2009, University of Tennessee 
     12# copyright 2009, University of Tennessee 
    1313################################################################################ 
    1414import time 
    … …  
    3030from sas.sascalc.dataloader.readers.cansas_reader import Reader as CansasReader 
    3131from sas.sascalc.dataloader.readers.cansas_reader import get_content, write_node 
    32 from sas.sascalc.dataloader.data_info import Data2D 
    33 from sas.sascalc.dataloader.data_info import Collimation 
    34 from sas.sascalc.dataloader.data_info import Detector 
    35 from sas.sascalc.dataloader.data_info import Process 
    36 from sas.sascalc.dataloader.data_info import Aperture 
    37 #Information to read/write state as xml 
     32from sas.sascalc.dataloader.data_info import Data2D, Collimation, Detector 
     33from sas.sascalc.dataloader.data_info import Process, Aperture 
     34# Information to read/write state as xml 
    3835FITTING_NODE_NAME = 'fitting_plug_in' 
    3936CANSAS_NS = "cansas1d/1.0" 
    … …  
    123120            try: 
    124121                return node.get(item[0]).strip() == "True" 
    125  
    126122            except: 
    127123                return None 
    … …  
    146142        """ 
    147143        self.file = None 
    148         #Time of state creation 
     144        # Time of state creation 
    149145        self.timestamp = time.time() 
    150         ## Data member to store the dispersion object created 
     146        # Data member to store the dispersion object created 
    151147        self._disp_obj_dict = {} 
    152         #------------------------ 
    153         #Data used for fitting 
     148        # ------------------------ 
     149        # Data used for fitting 
    154150        self.data = data 
    155151        # model data 
    156152        self.theory_data = None 
    157         #Is 2D 
     153        # Is 2D 
    158154        self.is_2D = False 
    159155        self.images = None 
    160156 
    161         #save additional information on data that dataloader.reader does not read 
     157        # save additional information on data that dataloader.reader 
     158        # does not read 
    162159        self.is_data = None 
    163160        self.data_name = "" 
    … …  
    172169            self.data_group_id = self.data.group_id 
    173170 
    174         ## reset True change the state of exsiting button 
     171        # reset True change the state of existing button 
    175172        self.reset = False 
    176173 
    … …  
    180177        self.model = model 
    181178        self.m_name = None 
    182         #list of process done to model 
     179        # list of process done to model 
    183180        self.process = [] 
    184         #fit page manager 
     181        # fit page manager 
    185182        self.manager = None 
    186         #Store the parent of this panel parent 
     183        # Store the parent of this panel parent 
    187184        # For this application fitpanel is the parent 
    188185        self.parent = parent 
    189186        # Event_owner is the owner of model event 
    190187        self.event_owner = None 
    191         ##page name 
     188        # page name 
    192189        self.page_name = "" 
    193190        # Contains link between model, all its parameters, and panel organization 
    … …  
    196193        self.str_parameters = [] 
    197194        # Contains list of parameters that cannot be fitted and reference to 
    198         #panel objects 
     195        # panel objects 
    199196        self.fixed_param = [] 
    200197        # Contains list of parameters with dispersity and reference to 
    201         #panel objects 
     198        # panel objects 
    202199        self.fittable_param = [] 
    203         ## orientation parameters 
     200        # orientation parameters 
    204201        self.orientation_params = [] 
    205         ## orientation parameters for gaussian dispersity 
     202        # orientation parameters for gaussian dispersity 
    206203        self.orientation_params_disp = [] 
    207         ## smearer info 
     204        # smearer info 
    208205        self.smearer = None 
    209206        self.smear_type = None 
    … …  
    214211        self.dxl = None 
    215212        self.dxw = None 
    216         #list of dispersion parameters 
     213        # list of dispersion parameters 
    217214        self.disp_list = [] 
    218215        if self.model is not None: 
    … …  
    223220        self.weights = {} 
    224221 
    225         #contains link between a model and selected parameters to fit 
     222        # contains link between a model and selected parameters to fit 
    226223        self.param_toFit = [] 
    227         ##dictionary of model type and model class 
     224        # dictionary of model type and model class 
    228225        self.model_list_box = None 
    229         ## save the state of the context menu 
     226        # save the state of the context menu 
    230227        self.saved_states = {} 
    231         ## save selection of combobox 
     228        # save selection of combobox 
    232229        self.formfactorcombobox = None 
    233230        self.categorycombobox = None 
    234231        self.structurecombobox = None 
    235232 
    236         ## radio box to select type of model 
    237         #self.shape_rbutton = False 
    238         #self.shape_indep_rbutton = False 
    239         #self.struct_rbutton = False 
    240         #self.plugin_rbutton = False 
    241         ## the indice of the current selection 
     233        # radio box to select type of model 
     234        # self.shape_rbutton = False 
     235        # self.shape_indep_rbutton = False 
     236        # self.struct_rbutton = False 
     237        # self.plugin_rbutton = False 
     238        # the indice of the current selection 
    242239        self.disp_box = 0 
    243         ## Qrange 
    244         ## Q range 
     240        # Qrange 
     241        # Q range 
    245242        self.qmin = 0.001 
    246243        self.qmax = 0.1 
    247         #reset data range 
     244        # reset data range 
    248245        self.qmax_x = None 
    249246        self.qmin_x = None 
    … …  
    253250        self.multi_factor = None 
    254251        self.magnetic_on = False 
    255         ## enable smearering state 
     252        # enable smearering state 
    256253        self.enable_smearer = False 
    257254        self.disable_smearer = True 
    … …  
    263260        self.dI_sqrdata = False 
    264261        self.dI_idata = False 
    265         ## disperity selection 
     262        # disperity selection 
    266263        self.enable_disp = False 
    267264        self.disable_disp = True 
    268265 
    269         ## state of selected all check button 
     266        # state of selected all check button 
    270267        self.cb1 = False 
    271         ## store value of chisqr 
     268        # store value of chisqr 
    272269        self.tcChi = None 
    273270 
    … …  
    293290        obj.structurecombobox = self.structurecombobox 
    294291 
    295         #obj.shape_rbutton = self.shape_rbutton 
    296         #obj.shape_indep_rbutton = self.shape_indep_rbutton 
    297         #obj.struct_rbutton = self.struct_rbutton 
    298         #obj.plugin_rbutton = self.plugin_rbutton 
     292        # obj.shape_rbutton = self.shape_rbutton 
     293        # obj.shape_indep_rbutton = self.shape_indep_rbutton 
     294        # obj.struct_rbutton = self.struct_rbutton 
     295        # obj.plugin_rbutton = self.plugin_rbutton 
    299296 
    300297        obj.manager = self.manager 
    … …  
    386383        rep += "data's name : %s\n" % self.data_name 
    387384        rep += "data's id : %s\n" % self.data_id 
    388         if self.model != None: 
     385        if self.model is not None: 
    389386            m_name = self.model.__class__.__name__ 
    390387            if m_name == 'Model': 
    … …  
    397394        rep += "model type (Category) selected: %s\n" % self.categorycombobox 
    398395        rep += "data : %s\n" % str(self.data) 
    399         rep += "Plotting Range: min: %s, max: %s, steps: %s\n" % (str(self.qmin), 
    400                                                                   str(self.qmax), str(self.npts)) 
     396        rep += "Plotting Range: min: %s, max: %s, steps: %s\n" % \ 
     397               (str(self.qmin),str(self.qmax), str(self.npts)) 
    401398        rep += "Dispersion selection : %s\n" % str(self.disp_box) 
    402399        rep += "Smearing enable : %s\n" % str(self.enable_smearer) 
    … …  
    414411 
    415412        rep += "2D enable : %s\n" % str(self.enable2D) 
    416         rep += "All parameters checkbox selected: %s\n" % (self.cb1) 
     413        rep += "All parameters checkbox selected: %s\n" % str(self.cb1) 
    417414        rep += "Value of Chisqr : %s\n" % str(self.tcChi) 
    418415        rep += "Smear object : %s\n" % str(self.smearer) 
    419         rep += "Smear type : %s\n" % (self.smear_type) 
     416        rep += "Smear type : %s\n" % str(self.smear_type) 
    420417        rep += "dq_l  : %s\n" % self.dq_l 
    421418        rep += "dq_r  : %s\n" % self.dq_r 
    … …  
    434431            if not self.is_2D: 
    435432                for item in self.parameters: 
    436                     if not item in self.orientation_params: 
     433                    if item not in self.orientation_params: 
    437434                        temp_parameters.append(item) 
    438435                for item in self.fittable_param: 
    439                     if not item in self.orientation_params_disp: 
     436                    if item not in self.orientation_params_disp: 
    440437                        temp_fittable_param.append(item) 
    441438            else: 
    … …  
    443440                temp_fittable_param = self.fittable_param 
    444441 
    445             rep += "number parameters(self.parameters): %s\n" % len(temp_parameters) 
     442            rep += "number parameters(self.parameters): %s\n" % \ 
     443                   len(temp_parameters) 
    446444            rep = self._repr_helper(list=temp_parameters, rep=rep) 
    447             rep += "number str_parameters(self.str_parameters): %s\n" % len(self.str_parameters) 
     445            rep += "number str_parameters(self.str_parameters): %s\n" % \ 
     446                   len(self.str_parameters) 
    448447            rep = self._repr_helper(list=self.str_parameters, rep=rep) 
    449             rep += "number fittable_param(self.fittable_param): %s\n" % len(temp_fittable_param) 
     448            rep += "number fittable_param(self.fittable_param): %s\n" % \ 
     449                   len(temp_fittable_param) 
    450450            rep = self._repr_helper(list=temp_fittable_param, rep=rep) 
    451451        return rep 
    … …  
    551551                    paramval_string += CENTRE % param + "\n" 
    552552 
    553         text_string = "\n\n\n%s\n\n%s\n%s\n%s\n\n%s" % (title, file, q_name, chi2, paramval) 
     553        text_string = "\n\n\n%s\n\n%s\n%s\n%s\n\n%s" % \ 
     554                      (title, file, q_name, chi2, paramval) 
    554555 
    555556        title_name = self._check_html_format(title_name) 
    … …  
    632633            element.appendChild(sub_element) 
    633634 
    634     def toXML(self, file="fitting_state.fitv", doc=None, entry_node=None): 
    635         """ 
    636         Writes the state of the InversionControl panel to file, as XML. 
     635    def toXML(self, file="fitting_state.fitv", doc=None, 
     636              entry_node=None, batch_fit_state=None): 
     637        """ 
     638        Writes the state of the fit panel to file, as XML. 
    637639 
    638640        Compatible with standalone writing, or appending to an 
    … …  
    691693        element.setAttributeNode(attr) 
    692694        top_element.appendChild(element) 
     695 
    693696        # Inputs 
    694697        inputs = newdoc.createElement("Attributes") 
    … …  
    743746            self._toXML_helper(thelist=getattr(self, item[1]), element=element, newdoc=newdoc) 
    744747            inputs.appendChild(element) 
     748 
     749        # Combined and Simultaneous Fit Parameters 
     750        if batch_fit_state is not None: 
     751            batch_combo = newdoc.createElement('simultaneous_fit') 
     752            top_element.appendChild(batch_combo) 
     753 
     754            # Simultaneous Fit Number For Linking Later 
     755            element = newdoc.createElement('sim_fit_number') 
     756            element.setAttribute('fit_number', str(batch_fit_state.fit_page_no)) 
     757            batch_combo.appendChild(element) 
     758 
     759            # Save constraints 
     760            constraints = newdoc.createElement('constraints') 
     761            batch_combo.appendChild(constraints) 
     762            for constraint in batch_fit_state.constraints_list: 
     763                # model_cbox, param_cbox, egal_txt, constraint, btRemove, sizer 
     764                doc_cons = newdoc.createElement('constraint') 
     765                doc_cons.setAttribute('model_cbox', 
     766                                      str(constraint.model_cbox.GetValue())) 
     767                doc_cons.setAttribute('param_cbox', 
     768                                      str(constraint.param_cbox.GetValue())) 
     769                doc_cons.setAttribute('egal_txt', 
     770                                      str(constraint.egal_txt.GetLabel())) 
     771                doc_cons.setAttribute('constraint', 
     772                                      str(constraint.constraint.GetValue())) 
     773                constraints.appendChild(doc_cons) 
     774 
     775            # Save all models 
     776            models = newdoc.createElement('model_list') 
     777            batch_combo.appendChild(models) 
     778            for model in batch_fit_state.model_list: 
     779                doc_model = newdoc.createElement('model_list_item') 
     780                doc_model.setAttribute('checked', str(model[0].GetValue())) 
     781                keys = model[1].keys() 
     782                doc_model.setAttribute('name', str(keys[0])) 
     783                values = model[1].get(keys[0]) 
     784                doc_model.setAttribute('fit_number', str(model[2])) 
     785                doc_model.setAttribute('fit_page_source', str(model[3])) 
     786                doc_model.setAttribute('model_name', str(values.model.id)) 
     787                models.appendChild(doc_model) 
     788 
     789            # Select All Checkbox 
     790            element = newdoc.createElement('select_all') 
     791            if batch_fit_state.select_all: 
     792                element.setAttribute('checked', 'True') 
     793            else: 
     794                element.setAttribute('checked', 'False') 
     795            batch_combo.appendChild(element) 
    745796 
    746797        # Save the file 
    … …  
    809860        :param file: .fitv file 
    810861        :param node: node of a XML document to read from 
    811  
    812862        """ 
    813863        if file is not None: 
    … …  
    816866            raise RuntimeError, msg 
    817867 
    818         if node.get('version')and node.get('version') == '1.0': 
     868        if node.get('version') and node.get('version') == '1.0': 
    819869 
    820870            # Get file name 
    … …  
    9601010        self.cansas = cansas 
    9611011        self.state = None 
     1012        # batch fitting params for saving 
     1013        self.batchfit_params = [] 
    9621014 
    9631015    def get_state(self): 
    … …  
    12191271 
    12201272        :param entry: XML node to read from 
    1221  
    12221273        :return: PageState object 
    12231274        """ 
    … …  
    12281279            nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, 
    12291280                                namespaces={'ns': CANSAS_NS}) 
    1230             if nodes != []: 
     1281            if nodes: 
    12311282                # Create an empty state 
    12321283                state = PageState() 
    … …  
    12381289 
    12391290        return state 
     1291 
     1292    def _parse_simfit_state(self, entry): 
     1293        """ 
     1294        Parses the saved data for a simultaneous fit 
     1295        :param entry: XML object to read from 
     1296        :return: XML object for a simultaneous fit or None 
     1297        """ 
     1298        nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, 
     1299                            namespaces={'ns': CANSAS_NS}) 
     1300        if nodes: 
     1301            simfitstate = nodes[0].xpath('ns:simultaneous_fit', 
     1302                                         namespaces={'ns': CANSAS_NS}) 
     1303            if simfitstate: 
     1304                from simfitpage import SimFitPageState 
     1305                sim_fit_state = SimFitPageState() 
     1306                simfitstate_0 = simfitstate[0] 
     1307                all = simfitstate_0.xpath('ns:select_all', 
     1308                                        namespaces={'ns': CANSAS_NS}) 
     1309                atts = all[0].attrib 
     1310                checked = atts.get('checked') 
     1311                sim_fit_state.select_all = bool(checked) 
     1312                model_list = simfitstate_0.xpath('ns:model_list', 
     1313                                               namespaces={'ns': CANSAS_NS}) 
     1314                model_list_items = model_list[0].xpath('ns:model_list_item', 
     1315                                                       namespaces={'ns': CANSAS_NS}) 
     1316                for model in model_list_items: 
     1317                    attrs = model.attrib 
     1318                    sim_fit_state.model_list.append(attrs) 
     1319                constraints = simfitstate_0.xpath('ns:constraints', 
     1320                                                namespaces={'ns': CANSAS_NS}) 
     1321                constraint_list = constraints[0].xpath('ns:constraint', 
     1322                                                       namespaces={'ns': CANSAS_NS}) 
     1323                for constraint in constraint_list: 
     1324                    attrs = constraint.attrib 
     1325                    sim_fit_state.constraints_list.append(attrs) 
     1326 
     1327                return sim_fit_state 
     1328            else: 
     1329                return None 
    12401330 
    12411331    def _parse_save_state_entry(self, dom): 
    … …  
    14761566        nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS}) 
    14771567        if len(nodes) > 1: 
    1478             raise RuntimeError, "CanSAS reader is not compatible with multiple SASdata entries" 
     1568            raise RuntimeError, "CanSAS reader is not compatible with" + \ 
     1569                                " multiple SASdata entries" 
    14791570 
    14801571        for entry in nodes: 
    … …  
    14981589    def _read_cansas(self, path): 
    14991590        """ 
    1500         Load data and P(r) information from a CanSAS XML file. 
     1591        Load data and fitting information from a CanSAS XML file. 
    15011592 
    15021593        :param path: file path 
    1503  
    15041594        :return: Data1D object if a single SASentry was found, 
    15051595                    or a list of Data1D objects if multiple entries were found, 
    15061596                    or None of nothing was found 
    1507  
    15081597        :raise RuntimeError: when the file can't be opened 
    15091598        :raise ValueError: when the length of the data vectors are inconsistent 
    1510  
    15111599        """ 
    15121600        output = [] 
     1601        simfitstate = None 
    15131602        basename = os.path.basename(path) 
    15141603        root, extension = os.path.splitext(basename) 
    … …  
    15161605        try: 
    15171606            if os.path.isfile(path): 
    1518  
    1519                 #TODO: eventually remove the check for .xml once 
    1520                 # the P(r) writer/reader is truly complete. 
    1521                 if  ext in self.ext or \ 
    1522                     ext == '.xml': 
    1523  
     1607                if ext in self.ext or ext == '.xml': 
    15241608                    tree = etree.parse(path, parser=etree.ETCompatXMLParser()) 
    15251609                    # Check the format version number 
    1526                     # Specifying the namespace will take care of the file format version 
     1610                    # Specifying the namespace will take care of the file 
     1611                    # format version 
    15271612                    root = tree.getroot() 
    15281613                    entry_list = root.xpath('ns:SASentry', 
    … …  
    15341619                            raise 
    15351620                        fitstate = self._parse_state(entry) 
    1536  
    1537                         #state could be None when .svs file is loaded 
    1538                         #in this case, skip appending to output 
    1539                         if fitstate != None: 
     1621                        simfitstate = self._parse_simfit_state(entry) 
     1622 
     1623                        # state could be None when .svs file is loaded 
     1624                        # in this case, skip appending to output 
     1625                        if fitstate is not None: 
    15401626                            sas_entry.meta_data['fitstate'] = fitstate 
    15411627                            sas_entry.filename = fitstate.file 
    15421628                            output.append(sas_entry) 
     1629 
    15431630            else: 
    15441631                self.call_back(format=ext) 
    … …  
    15801667                        name = original_fname 
    15811668                    state.data.group_id = name 
    1582                     #store state in fitting 
     1669                    # store state in fitting 
    15831670                    self.call_back(state=state, 
    15841671                                   datainfo=output[ind], format=ext) 
    15851672                    self.state = state 
     1673                if simfitstate is not None: 
     1674                    self.call_back(state=simfitstate) 
     1675 
    15861676                return output 
    15871677        except: 
    … …  
    15991689        """ 
    16001690        # Sanity check 
    1601         if self.cansas == True: 
     1691        if self.cansas: 
    16021692            # Add fitting information to the XML document 
    16031693            doc = self.write_toXML(datainfo, fitstate) 
    … …  
    16111701        fd.close() 
    16121702 
    1613     def write_toXML(self, datainfo=None, state=None): 
     1703    def write_toXML(self, datainfo=None, state=None, batchfit=None): 
    16141704        """ 
    16151705        Write toXML, a helper for write(), 
    … …  
    16191709        """ 
    16201710 
    1621         if state.data is None: 
    1622             data = sas.sascalc.dataloader.data_info.Data1D(x=[], y=[]) 
     1711        self.batchfit_params = batchfit 
     1712        if state.data is None or not state.data.is_data: 
    16231713            return None 
    1624         elif not state.data.is_data: 
    1625             return None 
     1714        # make sure title and data run are filled. 
     1715        if state.data.title is None or state.data.title == '': 
     1716            state.data.title = state.data.name 
     1717        if state.data.run_name is None or state.data.run_name == {}: 
     1718            state.data.run = [str(state.data.name)] 
     1719            state.data.run_name[0] = state.data.name 
     1720 
     1721        if issubclass(state.data.__class__, 
     1722                      sas.sascalc.dataloader.data_info.Data1D): 
     1723            data = state.data 
     1724            doc, sasentry = self._to_xml_doc(data) 
    16261725        else: 
    1627             #make sure title and data run is filled up. 
    1628             if state.data.title == None or state.data.title == '': 
    1629                 state.data.title = state.data.name 
    1630             if state.data.run_name == None or state.data.run_name == {}: 
    1631                 state.data.run = [str(state.data.name)] 
    1632                 state.data.run_name[0] = state.data.name 
    1633  
    1634             if issubclass(state.data.__class__, 
    1635                           sas.sascalc.dataloader.data_info.Data1D): 
    1636                 data = state.data 
    1637                 doc, sasentry = self._to_xml_doc(data) 
    1638             else: 
    1639                 data = state.data 
    1640                 doc, sasentry = self._data2d_to_xml_doc(data) 
     1726            data = state.data 
     1727            doc, sasentry = self._data2d_to_xml_doc(data) 
    16411728 
    16421729        if state is not None: 
    1643             doc = state.toXML(doc=doc, file=data.filename, entry_node=sasentry) 
     1730            doc = state.toXML(doc=doc, file=data.filename, entry_node=sasentry, 
     1731                              batch_fit_state=self.batchfit_params) 
    16441732 
    16451733        return doc 
    1646  
    1647 # Simple html report templet 
    1648 HEADER = "<html>\n" 
    1649 HEADER += "<head>\n" 
    1650 HEADER += "<meta http-equiv=Content-Type content='text/html; " 
    1651 HEADER += "charset=windows-1252'> \n" 
    1652 HEADER += "<meta name=Generator >\n" 
    1653 HEADER += "</head>\n" 
    1654 HEADER += "<body lang=EN-US>\n" 
    1655 HEADER += "<div class=WordSection1>\n" 
    1656 HEADER += "<p class=MsoNormal><b><span ><center><font size='4' >" 
    1657 HEADER += "%s</font></center></span></center></b></p>" 
    1658 HEADER += "<p class=MsoNormal>&nbsp;</p>" 
    1659 PARA = "<p class=MsoNormal><font size='4' > %s \n" 
    1660 PARA += "</font></p>" 
    1661 CENTRE = "<p class=MsoNormal><center><font size='4' > %s \n" 
    1662 CENTRE += "</font></center></p>" 
    1663 FEET_1 = \ 
    1664 """ 
    1665 <p class=MsoNormal>&nbsp;</p> 
    1666 <br> 
    1667 <p class=MsoNormal><b><span ><center> <font size='4' > Graph 
    1668 </font></span></center></b></p> 
    1669 <p class=MsoNormal>&nbsp;</p> 
    1670 <center> 
    1671 <br><font size='4' >Model Computation</font> 
    1672 <br><font size='4' >Data: "%s"</font><br> 
    1673 """ 
    1674 FEET_2 = \ 
    1675 """ 
    1676 <img src="%s" > 
    1677 </img> 
    1678 """ 
    1679 FEET_3 = \ 
    1680 """ 
    1681 </center> 
    1682 </div> 
    1683 </body> 
    1684 </html> 
    1685 """ 
    1686 ELINE = "<p class=MsoNormal>&nbsp;</p>" 
    1687  
    1688 if __name__ == "__main__": 
    1689     state = PageState(parent=None) 
    1690     #state.toXML() 
    1691     """ 
    1692  
    1693     file = open("test_state", "w") 
    1694     pickle.dump(state, file) 
    1695     print pickle.dumps(state) 
    1696     state.data_name = "hello---->" 
    1697     pickle.dump(state, file) 
    1698     file = open("test_state", "r") 
    1699     new_state= pickle.load(file) 
    1700     print "new state", new_state 
    1701     new_state= pickle.load(file) 
    1702     print "new state", new_state 
    1703     #print "state", state 
    1704     """ 
    1705     import bsddb 
    1706     import pickle 
    1707     db = bsddb.btopen('file_state.db', 'c') 
    1708     val = (pickle.dumps(state), "hello", "hi") 
    1709     db['state1'] = pickle.dumps(val) 
    1710     print pickle.loads(db['state1']) 
    1711     state.data_name = "hello---->22" 
    1712     db['state2'] = pickle.dumps(state) 
    1713     state.data_name = "hello---->2" 
    1714     db['state3'] = pickle.dumps(state) 
    1715     del db['state3'] 
    1716     state.data_name = "hello---->3" 
    1717     db['state4'] = pickle.dumps(state) 
    1718     new_state = pickle.loads(db['state1']) 
    1719     #print db.last() 
    1720     db.set_location('state2') 
    1721     state.data_name = "hello---->5" 
    1722     db['aastate5'] = pickle.dumps(state) 
    1723     db.keys().sort() 
    1724     print pickle.loads(db['state2']) 
    1725  
    1726     db.close() 
Note: See TracChangeset for help on using the changeset viewer.