Changeset 13e46abe in sasview


Ignore:
Timestamp:
Mar 2, 2015 4:29:01 PM (9 years ago)
Author:
Doucet, Mathieu <doucetm@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
038c00cf
Parents:
6bd3a8d1
Message:

Clean up pylint

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/sas/models/c_extension/python_wrapper/WrapperGenerator.py

    rfd5ac0d r13e46abe  
    33""" 
    44 
    5 import os, sys,re 
     5import os, sys, re 
    66import lineparser 
    77 
    8 class WrapperGenerator: 
     8class WrapperGenerator(object): 
    99    """ Python wrapper generator for C models 
    10      
    11         The developer must provide a header file describing  
     10 
     11        The developer must provide a header file describing 
    1212        the new model. 
    13          
     13 
    1414        To provide the name of the Python class to be 
    15         generated, the .h file must contain the following  
     15        generated, the .h file must contain the following 
    1616        string in the comments: 
    17          
     17 
    1818        // [PYTHONCLASS] = my_model 
    19          
     19 
    2020        where my_model must be replaced by the name of the 
    2121        class that you want to import from sas.models. 
    2222        (example: [PYTHONCLASS] = MyModel 
    2323          will create a class MyModel in sas.models.MyModel. 
    24           It will also create a class CMyModel in  
     24          It will also create a class CMyModel in 
    2525          sas_extension.c_models.) 
    26            
    27         Also in comments, each parameter of the params  
     26 
     27        Also in comments, each parameter of the params 
    2828        dictionary must be declared with a default value 
    2929        in the following way: 
    30          
     30 
    3131        // [DEFAULT]=param_name=default_value 
    32          
     32 
    3333        (example: 
    3434            //  [DEFAULT]=radius=20.0 
    3535        ) 
    36            
     36 
    3737        See cylinder.h for an example. 
    38          
    39          
     38 
    4039        A .c file corresponding to the .h file should also 
    4140        be provided (example: my_model.h, my_model.c). 
    42      
     41 
    4342        The .h file should define two function definitions. For example, 
    4443        cylinder.h defines the following: 
    45          
     44 
    4645        /// 1D scattering function 
    4746        double cylinder_analytical_1D(CylinderParameters *pars, double q); 
    48              
     47 
    4948        /// 2D scattering function 
    5049        double cylinder_analytical_2D(CylinderParameters *pars, double q, double phi); 
    51              
     50 
    5251        The .c file implements those functions. 
    53          
     52 
    5453        @author: Mathieu Doucet / UTK 
    5554        @contact: mathieu.doucet@nist.gov 
    5655    """ 
    57      
     56 
    5857    def __init__(self, filename, output_dir='.', c_wrapper_dir='.'): 
    5958        """ Initialization """ 
    60          
     59 
    6160        ## Name of .h file to generate wrapper from 
    6261        self.file = filename 
    63          
     62 
    6463        # Info read from file 
    65          
     64 
    6665        ## Name of python class to write 
    6766        self.pythonClass = None 
    … …  
    8382        self.disp_params = [] 
    8483        #model description 
    85         self.description='' 
     84        self.description = '' 
    8685        # paramaters for fittable 
    87         self.fixed= [] 
     86        self.fixed = [] 
    8887        # paramaters for non-fittable 
    89         self.non_fittable= [] 
     88        self.non_fittable = [] 
    9089        ## parameters with orientation 
    91         self.orientation_params =[] 
     90        self.orientation_params = [] 
    9291        ## parameter with magnetism 
    9392        self.magentic_params = [] 
    … …  
    10099        self.c_wrapper_dir = c_wrapper_dir 
    101100 
    102          
    103          
    104101    def __repr__(self): 
    105102        """ Simple output for printing """ 
    106          
    107         rep  = "\n Python class: %s\n\n" % self.pythonClass 
     103 
     104        rep = "\n Python class: %s\n\n" % self.pythonClass 
    108105        rep += "  struc name: %s\n\n" % self.structName 
    109106        rep += "  params:     %s\n\n" % self.params 
    110107        rep += "  description:    %s\n\n" % self.description 
    111         rep += "  Fittable parameters:     %s\n\n"% self.fixed 
    112         rep += "  Non-Fittable parameters:     %s\n\n"% self.non_fittable 
    113         rep += "  Orientation parameters:  %s\n\n"% self.orientation_params 
    114         rep += "  Magnetic parameters:  %s\n\n"% self.magnetic_params 
     108        rep += "  Fittable parameters:     %s\n\n" % self.fixed 
     109        rep += "  Non-Fittable parameters:     %s\n\n" % self.non_fittable 
     110        rep += "  Orientation parameters:  %s\n\n" % self.orientation_params 
     111        rep += "  Magnetic parameters:  %s\n\n" % self.magnetic_params 
    115112        return rep 
    116          
     113 
    117114    def read(self): 
    118115        """ Reads in the .h file to catch parameters of the wrapper """ 
    119          
     116 
    120117        # Check if the file is there 
    121118        if not os.path.isfile(self.file): 
    122119            raise ValueError, "File %s is not a regular file" % self.file 
    123          
     120 
    124121        # Read file 
    125         f = open(self.file,'r') 
     122        f = open(self.file, 'r') 
    126123        buf = f.read() 
    127          
     124 
    128125        self.default_list = "\n    List of default parameters:\n\n" 
    129126        #lines = string.split(buf,'\n') 
    130127        lines = buf.split('\n') 
    131         self.details  = "## Parameter details [units, min, max]\n" 
     128        self.details = "## Parameter details [units, min, max]\n" 
    132129        self.details += "        self.details = {}\n" 
    133          
     130 
    134131        #open item in this case Fixed 
    135         text='text' 
    136         key2="<%s>"%text.lower() 
     132        text = 'text' 
     133        key2 = "<%s>" % text.lower() 
    137134        # close an item in this case fixed 
    138         text='TexT' 
    139         key3="</%s>"%text.lower() 
    140          
     135        text = 'TexT' 
     136        key3 = "</%s>" % text.lower() 
     137 
    141138        ## Catch fixed parameters 
    142139        key = "[FIXED]" 
    143140        try: 
    144             self.fixed= lineparser.readhelper(lines, key,  
    145                                               key2, key3, file=self.file) 
     141            self.fixed = lineparser.readhelper(lines, key, 
     142                                               key2, key3, file=self.file) 
    146143        except: 
    147            raise    
     144            raise 
    148145        ## Catch non-fittable parameters parameters 
    149146        key = "[NON_FITTABLE_PARAMS]" 
    150147        try: 
    151             self.non_fittable= lineparser.readhelper(lines, key, key2, 
    152                                                      key3, file=self.file) 
     148            self.non_fittable = lineparser.readhelper(lines, key, key2, 
     149                                                      key3, file=self.file) 
    153150        except: 
    154            raise    
     151            raise 
    155152 
    156153        ## Catch parameters with orientation 
    157         key = "[ORIENTATION_PARAMS]"     
     154        key = "[ORIENTATION_PARAMS]" 
    158155        try: 
    159             self.orientation_params = lineparser.readhelper(lines, key,  
    160                                                     key2, key3, file=self.file) 
     156            self.orientation_params = lineparser.readhelper(lines, key, 
     157                                                            key2, key3, file=self.file) 
    161158        except: 
    162            raise  
    163         
     159            raise 
     160 
    164161        ## Catch parameters with orientation 
    165         key = "[MAGNETIC_PARAMS]"     
     162        key = "[MAGNETIC_PARAMS]" 
    166163        try: 
    167             self.magnetic_params = lineparser.readhelper( lines,key,  
    168                                                     key2,key3, file= self.file) 
     164            self.magnetic_params = lineparser.readhelper(lines, key, 
     165                                                         key2, key3, file=self.file) 
    169166        except: 
    170            raise  
    171         
     167            raise 
     168 
    172169        ## Catch Description 
    173170        key = "[DESCRIPTION]" 
    174          
     171 
    175172        find_description = False 
    176         temp="" 
     173        temp = "" 
    177174        for line in lines: 
    178             if line.count(key)>0 : 
    179                  
     175            if line.count(key) > 0: 
    180176                try: 
    181                     find_description= True 
     177                    find_description = True 
    182178                    index = line.index(key) 
    183                     toks = line[index:].split("=",1 ) 
    184                     temp=toks[1].lstrip().rstrip() 
    185                     text='text' 
    186                     key2="<%s>"%text.lower() 
    187                     if re.match(key2,temp)!=None: 
    188      
    189                         toks2=temp.split(key2,1) 
    190                         self.description=toks2[1] 
    191                         text='text' 
    192                         key2="</%s>"%text.lower() 
    193                         if re.search(key2,toks2[1])!=None: 
    194                             temp=toks2[1].split(key2,1) 
    195                             self.description=temp[0] 
     179                    toks = line[index:].split("=", 1) 
     180                    temp = toks[1].lstrip().rstrip() 
     181                    text = 'text' 
     182                    key2 = "<%s>" % text.lower() 
     183                    if re.match(key2, temp) != None: 
     184 
     185                        toks2 = temp.split(key2, 1) 
     186                        self.description = toks2[1] 
     187                        text = 'text' 
     188                        key2 = "</%s>" % text.lower() 
     189                        if re.search(key2, toks2[1]) != None: 
     190                            temp = toks2[1].split(key2, 1) 
     191                            self.description = temp[0] 
    196192                            break 
    197                        
     193 
    198194                    else: 
    199                         self.description=temp 
     195                        self.description = temp 
    200196                        break 
    201197                except: 
    202                      raise ValueError, "Could not parse file %s" % self.file 
     198                    raise ValueError, "Could not parse file %s" % self.file 
    203199            elif find_description: 
    204                 text='text' 
    205                 key2="</%s>"%text.lower() 
    206                 if re.search(key2,line)!=None: 
    207                     tok=line.split(key2,1) 
    208                     temp=tok[0].split("//",1) 
    209                     self.description+=tok[1].lstrip().rstrip() 
     200                text = 'text' 
     201                key2 = "</%s>" % text.lower() 
     202                if re.search(key2, line) != None: 
     203                    tok = line.split(key2, 1) 
     204                    temp = tok[0].split("//", 1) 
     205                    self.description += tok[1].lstrip().rstrip() 
    210206                    break 
    211207                else: 
    212                     if re.search("//",line)!=None: 
    213                         temp=line.split("//",1) 
    214                         self.description+='\n\t\t'+temp[1].lstrip().rstrip() 
    215                          
     208                    if re.search("//", line) != None: 
     209                        temp = line.split("//", 1) 
     210                        self.description += '\n\t\t' + temp[1].lstrip().rstrip() 
     211 
    216212                    else: 
    217                         self.description+='\n\t\t'+line.lstrip().rstrip() 
    218                      
    219                  
    220       
     213                        self.description += '\n\t\t' + line.lstrip().rstrip() 
     214 
     215 
     216 
    221217        for line in lines: 
    222              
     218 
    223219            # Catch class name 
    224220            key = "[PYTHONCLASS]" 
    225             if line.count(key)>0: 
     221            if line.count(key) > 0: 
    226222                try: 
    227223                    index = line.index(key) 
    228                     toks = line[index:].split("=" ) 
     224                    toks = line[index:].split("=") 
    229225                    self.pythonClass = toks[1].lstrip().rstrip() 
    230226 
    231227                except: 
    232228                    raise ValueError, "Could not parse file %s" % self.file 
    233                  
     229 
    234230            key = "[CATEGORY]" 
    235             if line.count(key)>0: 
     231            if line.count(key) > 0: 
    236232                try: 
    237233                    index = line.index(key) 
    … …  
    255251            # Catch struct name 
    256252            # C++ class definition 
    257             if line.count("class")>0: 
     253            if line.count("class") > 0: 
    258254                # We are entering a class definition 
    259255                self.inParDefs = True 
    260256                self.foundCPP = True 
    261                  
     257 
    262258            # Old-Style C struct definition 
    263             if line.count("typedef struct")>0: 
     259            if line.count("typedef struct") > 0: 
    264260                # We are entering a struct block 
    265261                self.inParDefs = True 
    266262                self.inStruct = True 
    267              
    268             if self.inParDefs and line.count("}")>0: 
     263 
     264            if self.inParDefs and line.count("}") > 0: 
    269265                # We are exiting a struct block 
    270266                self.inParDefs = False 
    271                  
     267 
    272268                if self.inStruct: 
    273269                    self.inStruct = False 
    274270                    # Catch the name of the struct 
    275271                    index = line.index("}") 
    276                     toks = line[index+1:].split(";") 
     272                    toks = line[index + 1:].split(";") 
    277273                    # Catch pointer definition 
    278274                    toks2 = toks[0].split(',') 
    279275                    self.structName = toks2[0].lstrip().rstrip() 
    280             
     276 
    281277            # Catch struct content 
    282278            key = "[DEFAULT]" 
    283             if self.inParDefs and line.count(key)>0: 
     279            if self.inParDefs and line.count(key) > 0: 
    284280                # Found a new parameter 
    285281                try: 
    … …  
    295291                    self.default_list += "    * %-15s = %s %s\n" % \ 
    296292                        (toks[1], val, units) 
    297                      
     293 
    298294                    # Check for min and max 
    299                     min = "None" 
    300                     max = "None" 
     295                    value_min = "None" 
     296                    value_max = "None" 
    301297                    if len(toks2) == 4: 
    302                         min = toks2[2] 
    303                         max = toks2[3] 
    304                      
     298                        value_min = toks2[2] 
     299                        value_max = toks2[3] 
     300 
    305301                    self.details += "        self.details['%s'] = ['%s', %s, %s]\n" % \ 
    306                         (toks[1].lstrip().rstrip(), units.lstrip().rstrip(), min, max) 
     302                        (toks[1].lstrip().rstrip(), units.lstrip().rstrip(), value_min, value_max) 
    307303                except: 
    308304                    raise ValueError, "Could not parse input file %s \n  %s" % \ 
    309305                        (self.file, sys.exc_value) 
    310                  
    311                  
     306 
     307 
    312308            # Catch need for numerical calculations 
    313309            key = "CalcParameters calcPars" 
    314             if line.count(key)>0: 
     310            if line.count(key) > 0: 
    315311                self.modelCalcFlag = True 
    316                  
     312 
    317313            # Catch list of dispersed parameters  
    318314            key = "[DISP_PARAMS]" 
    319             if line.count(key)>0: 
     315            if line.count(key) > 0: 
    320316                try: 
    321317                    index = line.index(key) 
    … …  
    330326            The file is written in C[PYTHONCLASS].c 
    331327        """ 
    332         file_path = os.path.join(self.c_wrapper_dir,  
    333                                  "C"+self.pythonClass+'.cpp') 
     328        file_path = os.path.join(self.c_wrapper_dir, 
     329                                 "C" + self.pythonClass + '.cpp') 
    334330        file = open(file_path, 'w') 
    335          
    336         template = open(os.path.join(os.path.dirname(__file__),  
     331 
     332        template = open(os.path.join(os.path.dirname(__file__), 
    337333                                     "classTemplate.txt"), 'r') 
    338          
     334 
    339335        tmp_buf = template.read() 
    340336        #tmp_lines = string.split(tmp_buf,'\n') 
    341337        tmp_lines = tmp_buf.split('\n') 
    342          
     338 
    343339        for tmp_line in tmp_lines: 
    344              
     340 
    345341            # Catch class name 
    346             newline = self.replaceToken(tmp_line,  
    347                                         "[PYTHONCLASS]", 'C'+self.pythonClass) 
     342            newline = self.replaceToken(tmp_line, 
     343                                        "[PYTHONCLASS]", 'C' + self.pythonClass) 
    348344            #Catch model description 
    349345            #newline = self.replaceToken(tmp_line,  
    350346            #                            "[DESCRIPTION]", self.description) 
    351347            # Catch C model name 
    352             newline = self.replaceToken(newline,  
     348            newline = self.replaceToken(newline, 
    353349                                        "[CMODEL]", self.pythonClass) 
    354              
     350 
    355351            # Catch class name 
    356             newline = self.replaceToken(newline,  
     352            newline = self.replaceToken(newline, 
    357353                                        "[MODELSTRUCT]", self.structName) 
    358354 
    359355            # Sort model initialization based on multifunc 
    360             if(self.is_multifunc): 
     356            if self.is_multifunc: 
    361357                line = "int level = 1;\nPyArg_ParseTuple(args,\"i\",&level);\n" 
    362358                line += "self->model = new " + self.pythonClass + "(level);" 
    363359            else: 
    364360                line = "self->model = new " + self.pythonClass + "();" 
    365      
    366             newline = self.replaceToken(newline,"[INITIALIZE_MODEL]", 
    367                                             line) 
    368              
     361 
     362            newline = self.replaceToken(newline, "[INITIALIZE_MODEL]", line) 
     363 
    369364            # Dictionary initialization 
    370             param_str = "// Initialize parameter dictionary\n"             
     365            param_str = "// Initialize parameter dictionary\n" 
    371366            for par in self.params: 
    372367                param_str += "        PyDict_SetItemString(self->params,\"%s\",Py_BuildValue(\"d\",%10.12f));\n" % \ 
    373368                    (par, self.params[par]) 
    374369 
    375             if len(self.disp_params)>0: 
     370            if len(self.disp_params) > 0: 
    376371                param_str += "        // Initialize dispersion / averaging parameter dict\n" 
    377372                param_str += "        DispersionVisitor* visitor = new DispersionVisitor();\n" 
    … …  
    384379                    param_str += "        self->model->%s.dispersion->accept_as_source(visitor, self->model->%s.dispersion, disp_dict);\n" % (par, par) 
    385380                    param_str += "        PyDict_SetItemString(self->dispersion, \"%s\", disp_dict);\n" % par 
    386                  
     381 
    387382            # Initialize dispersion object dictionnary 
    388383            param_str += "\n" 
    389              
    390                  
     384 
     385 
    391386            newline = self.replaceToken(newline, 
    392387                                        "[INITDICTIONARY]", param_str) 
    393              
     388 
    394389            # Read dictionary 
    395390            param_str = "    // Reader parameter dictionary\n" 
    … …  
    397392                param_str += "    self->model->%s = PyFloat_AsDouble( PyDict_GetItemString(self->params, \"%s\") );\n" % \ 
    398393                    (par, par) 
    399                      
    400             if len(self.disp_params)>0: 
     394 
     395            if len(self.disp_params) > 0: 
    401396                param_str += "    // Read in dispersion parameters\n" 
    402397                param_str += "    PyObject* disp_dict;\n" 
    … …  
    408403                    param_str += "    disp_dict = PyDict_GetItemString(self->dispersion, \"%s\");\n" % par 
    409404                    param_str += "    self->model->%s.dispersion->accept_as_destination(visitor, self->model->%s.dispersion, disp_dict);\n" % (par, par) 
    410                  
     405 
    411406            newline = self.replaceToken(newline, "[READDICTIONARY]", param_str) 
    412                  
     407 
    413408            # Name of .c file 
    414409            #toks = string.split(self.file,'.') 
    … …  
    416411            toks = basename.split('.') 
    417412            newline = self.replaceToken(newline, "[C_FILENAME]", toks[0]) 
    418              
     413 
    419414            # Include file 
    420415            basename = os.path.basename(self.file) 
    421             newline = self.replaceToken(newline,  
    422                                         "[INCLUDE_FILE]", self.file)   
     416            newline = self.replaceToken(newline, 
     417                                        "[INCLUDE_FILE]", self.file) 
    423418            if self.foundCPP: 
    424                 newline = self.replaceToken(newline,  
    425                             "[C_INCLUDE_FILE]", "")   
    426                 newline = self.replaceToken(newline,  
    427                             "[CPP_INCLUDE_FILE]", "#include \"%s\"" % basename)   
    428             else:   
    429                 newline = self.replaceToken(newline,  
    430                             "[C_INCLUDE_FILE]", "#include \"%s\"" % basename)    
    431                 newline = self.replaceToken(newline,  
    432                             "[CPP_INCLUDE_FILE]", "#include \"models.hh\"")   
    433                  
     419                newline = self.replaceToken(newline, "[C_INCLUDE_FILE]", "") 
     420                newline = self.replaceToken(newline, 
     421                                            "[CPP_INCLUDE_FILE]", 
     422                                            "#include \"%s\"" % basename) 
     423            else: 
     424                newline = self.replaceToken(newline, 
     425                                            "[C_INCLUDE_FILE]", 
     426                                            "#include \"%s\"" % basename) 
     427                newline = self.replaceToken(newline, 
     428                                            "[CPP_INCLUDE_FILE]", 
     429                                            "#include \"models.hh\"") 
     430 
    434431            # Numerical calcs dealloc 
    435432            dealloc_str = "\n" 
    436433            if self.modelCalcFlag: 
    437434                dealloc_str = "    modelcalculations_dealloc(&(self->model_pars.calcPars));\n" 
    438             newline = self.replaceToken(newline,  
    439                                         "[NUMERICAL_DEALLOC]", dealloc_str)      
    440                  
     435            newline = self.replaceToken(newline, 
     436                                        "[NUMERICAL_DEALLOC]", dealloc_str) 
     437 
    441438            # Numerical calcs init 
    442439            init_str = "\n" 
    443440            if self.modelCalcFlag: 
    444441                init_str = "        modelcalculations_init(&(self->model_pars.calcPars));\n" 
    445             newline = self.replaceToken(newline,  
    446                                         "[NUMERICAL_INIT]", init_str)      
    447                  
     442            newline = self.replaceToken(newline, 
     443                                        "[NUMERICAL_INIT]", init_str) 
     444 
    448445            # Numerical calcs reset 
    449446            reset_str = "\n" 
    450447            if self.modelCalcFlag: 
    451448                reset_str = "modelcalculations_reset(&(self->model_pars.calcPars));\n" 
    452             newline = self.replaceToken(newline,  
    453                                         "[NUMERICAL_RESET]", reset_str)      
    454                  
     449            newline = self.replaceToken(newline, 
     450                                        "[NUMERICAL_RESET]", reset_str) 
     451 
    455452            # Setting dispsertion weights 
    456453            set_weights = "    // Ugliness necessary to go from python to C\n" 
    … …  
    463460                set_weights += "        self->model->%s.dispersion = dispersion;\n" % par 
    464461                set_weights += "    } else" 
    465             newline = self.replaceToken(newline,  
    466                                         "[SET_DISPERSION]", set_weights)      
    467              
     462            newline = self.replaceToken(newline, 
     463                                        "[SET_DISPERSION]", set_weights) 
     464 
    468465            # Write new line to the wrapper .c file 
    469             file.write(newline+'\n') 
    470              
    471              
     466            file.write(newline + '\n') 
     467 
     468 
    472469        file.close() 
    473          
     470 
    474471    def write_python_wrapper(self): 
    475472        """ Writes the python file to create the python extension class  
    476473            The file is written in ../[PYTHONCLASS].py 
    477474        """ 
    478         file_path = os.path.join(self.output_dir, self.pythonClass+'.py') 
     475        file_path = os.path.join(self.output_dir, self.pythonClass + '.py') 
    479476        file = open(file_path, 'w') 
    480         template = open(os.path.join(os.path.dirname(__file__),  
     477        template = open(os.path.join(os.path.dirname(__file__), 
    481478                                     "modelTemplate.txt"), 'r') 
    482          
     479 
    483480        tmp_buf = template.read() 
    484481        tmp_lines = tmp_buf.split('\n') 
    485          
     482 
    486483        for tmp_line in tmp_lines: 
    487              
     484 
    488485            # Catch class name 
    489             newline = self.replaceToken(tmp_line,  
    490                                         "[CPYTHONCLASS]",  
     486            newline = self.replaceToken(tmp_line, 
     487                                        "[CPYTHONCLASS]", 
    491488                                        'C' + self.pythonClass) 
    492              
     489 
    493490            # Catch class name 
    494             newline = self.replaceToken(newline,  
     491            newline = self.replaceToken(newline, 
    495492                                        "[PYTHONCLASS]", self.pythonClass) 
    496              
     493 
    497494            # Include file 
    498             newline = self.replaceToken(newline,  
    499                                         "[INCLUDE_FILE]", self.file)     
    500                     
     495            newline = self.replaceToken(newline, 
     496                                        "[INCLUDE_FILE]", self.file) 
     497 
    501498            # Include file 
    502             newline = self.replaceToken(newline,  
     499            newline = self.replaceToken(newline, 
    503500                                        "[DEFAULT_LIST]", self.default_list) 
    504501            # model description 
    505             newline = self.replaceToken(newline,  
     502            newline = self.replaceToken(newline, 
    506503                                        "[DESCRIPTION]", self.description) 
    507504            # Parameter details 
    508             newline = self.replaceToken(newline,  
     505            newline = self.replaceToken(newline, 
    509506                                        "[PAR_DETAILS]", self.details) 
    510              
     507 
    511508            # Call base constructor 
    512509            if self.is_multifunc: 
    513                 newline = self.replaceToken(newline,"[CALL_CPYTHON_INIT]", 
    514                     'C' + self.pythonClass + \ 
     510                newline = self.replaceToken(newline, "[CALL_CPYTHON_INIT]", 
     511                                            'C' + self.pythonClass + \ 
    515512                    ".__init__(self,multfactor)\n\tself.is_multifunc = True") 
    516                 newline = self.replaceToken(newline,"[MULTIPLICITY_INFO]",  
     513                newline = self.replaceToken(newline, "[MULTIPLICITY_INFO]", 
    517514                                            self.multiplicity_info) 
    518515            else: 
    519                 newline = self.replaceToken(newline,"[CALL_CPYTHON_INIT]", 
    520                     'C' + self.pythonClass + \ 
     516                newline = self.replaceToken(newline, "[CALL_CPYTHON_INIT]", 
     517                                            'C' + self.pythonClass + \ 
    521518                    ".__init__(self)\n        self.is_multifunc = False") 
    522                 newline = self.replaceToken(newline,  
     519                newline = self.replaceToken(newline, 
    523520                                            "[MULTIPLICITY_INFO]", "None") 
    524521 
    525             
    526522            # fixed list  details 
    527523            fixed_str = str(self.fixed) 
    528524            fixed_str = fixed_str.replace(', ', ',\n                      ') 
    529525            newline = self.replaceToken(newline, "[FIXED]", fixed_str) 
    530              
     526 
    531527            # non-fittable list details 
    532528            pars_str = str(self.non_fittable) 
    533             pars_str = pars_str.replace(', ',  
     529            pars_str = pars_str.replace(', ', 
    534530                                        ',\n                             ') 
    535             newline = self.replaceToken(newline,  
     531            newline = self.replaceToken(newline, 
    536532                                        "[NON_FITTABLE_PARAMS]", pars_str) 
    537              
     533 
    538534            ## parameters with orientation 
    539535            oriented_str = str(self.orientation_params) 
    540536            formatted_endl = ',\n                                   ' 
    541537            oriented_str = oriented_str.replace(', ', formatted_endl) 
    542             newline = self.replaceToken(newline,  
    543                                "[ORIENTATION_PARAMS]", oriented_str) 
    544            ## parameters with magnetism 
    545             newline = self.replaceToken(newline,  
    546                                "[MAGNETIC_PARAMS]", str(self.magnetic_params)) 
     538            newline = self.replaceToken(newline, 
     539                                        "[ORIENTATION_PARAMS]", oriented_str) 
     540            ## parameters with magnetism 
     541            newline = self.replaceToken(newline, 
     542                                        "[MAGNETIC_PARAMS]", 
     543                                        str(self.magnetic_params)) 
    547544 
    548545            if self.category: 
    549                 newline = self.replaceToken(newline, "[CATEGORY]",  
     546                newline = self.replaceToken(newline, "[CATEGORY]", 
    550547                                            '"' + self.category + '"') 
    551548            else: 
    552549                newline = self.replaceToken(newline, "[CATEGORY]", 
    553550                                            "None") 
    554              
     551 
    555552 
    556553 
    557554            # Write new line to the wrapper .c file 
    558             file.write(newline+'\n') 
    559                 
     555            file.write(newline + '\n') 
     556 
    560557        file.close() 
    561          
    562          
     558 
     559 
    563560    def replaceToken(self, line, key, value): #pylint: disable-msg=R0201 
    564561        """ Replace a token in the template file  
    … …  
    570567        lenkey = len(key) 
    571568        newline = line 
    572         
    573         while newline.count(key)>0: 
     569 
     570        while newline.count(key) > 0: 
    574571            index = newline.index(key) 
    575             newline = newline[:index]+value+newline[index+lenkey:] 
    576          
     572            newline = newline[:index] + value + newline[index + lenkey:] 
     573 
    577574        return newline 
    578          
     575 
    579576    def getModelName(self): 
    580577        return self.pythonClass 
    581          
     578 
    582579 
    583580 
    584581# main 
    585582if __name__ == '__main__': 
    586     if len(sys.argv)>1: 
     583    if len(sys.argv) > 1: 
    587584        print "Will look for file %s" % sys.argv[1] 
    588585        app = WrapperGenerator(sys.argv[1]) 
    … …  
    593590    app.write_python_wrapper() 
    594591    print app 
    595     
     592 
    596593# End of file         
Note: See TracChangeset for help on using the changeset viewer.