Changeset 3349


Ignore:
Timestamp:
09/02/08 21:07:03 (12 years ago)
Author:
astephen
Message:

Tidied some variable names and boolean types.

Location:
nappy/trunk/nappy
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • nappy/trunk/nappy/BUG_FIX_LOG.txt

    r3314 r3349  
    4040output - so far only implemented in NAFile2010.py  
    4141 
    42 NEED TO DO THE REST - Note that we should only cater for spacing and floatFormat 
     42NEED TO DO THE REST - Note that we should only cater for spacing and float_format 
    4343in the main data arrays, NOT in all the header stuff!!! 
  • nappy/trunk/nappy/Plans for re-factoring 2008.txt

    r3346 r3349  
    8585Global find and replace: 
    8686 
    87  * floatFormat 
    88  * naDict 
     87 * float_format 
     88 * na_dict 
    8989===================== 
    9090 
  • nappy/trunk/nappy/bin/nc2na.py

    r3324 r3349  
    6262    spacer="    " 
    6363    sizeLimit=None 
    64     floatFormat="%8.3f"  
     64    float_format="%8.3f"         
    6565    naVars={} 
    6666 
     
    7171            outfile=args[args.index(arg)+1] 
    7272        elif arg=="-f": 
    73             floatFormat=args[args.index(arg)+1] 
     73            float_format=args[args.index(arg)+1] 
    7474        elif arg=="-j": 
    7575            nFilesOnly="yes" 
     
    8888 
    8989    rtvalue=cdms2na(infile, outfile, naVars, variables, nFilesOnly, sizeLimit=sizeLimit, rule=rule, spacer=spacer,  
    90 floatFormat=floatFormat)  
     90float_format=float_format)  
    9191    if nFilesOnly=="yes": 
    9292        print "\n\nOutput files would be:" 
  • nappy/trunk/nappy/contrib/aircraft/old_na_to_nc_with_aircraft.py

    r3344 r3349  
    4949 
    5050def cdms2na(ncfile, na_file_names, naVars={}, variables=None, nFilesOnly="no",  
    51             rule=None, ffi="automatic", spacer="    ", floatFormat="%g",  
     51            rule=None, ffi="automatic", spacer="    ", float_format="%g",  
    5252            rules=None, sizeLimit=None): 
    5353    """ 
     
    118118     
    119119    builder=NAContentCollector(vars, globals, rule=rule, cdmsfile=cdmsfile) 
    120     #print builder.naDict["X"] 
    121     builtNADicts=[[builder.naDict, builder.varIDs]] 
     120    #print builder.na_dict["X"] 
     121    builtNADicts=[[builder.na_dict, builder.varIDs]] 
    122122    if builder.varIDs==None: 
    123123        msg="\nNo files created after variables parsed." 
     
    129129        builder=NAContentCollector(builder.varBin, globals, rule=rule, cdmsfile=cdmsfile) 
    130130        outputMessage=outputMessage+builder.outputMessage 
    131         if builder.varIDs!=None:  builtNADicts.append([builder.naDict, builder.varIDs]) 
     131        if builder.varIDs!=None:  builtNADicts.append([builder.na_dict, builder.varIDs]) 
    132132 
    133133    # Return only filenames if only want to know them now. 
     
    210210                newnamePlusLetter="%s-%.3d.na" % (newname[:-3], ivol) 
    211211                fileList.append(newnamePlusLetter) 
    212                 general.openNAFile(newnamePlusLetter, 'w', NADictCopy, spacer=spacer, floatFormat=floatFormat) 
     212                general.openNAFile(newnamePlusLetter, 'w', NADictCopy, spacer=spacer, float_format=float_format) 
    213213                msg="\nOutput files split on size limit: %s\nFilename used: %s" % (sizeLimit, newnamePlusLetter) 
    214214                print msg 
     
    219219 
    220220        else:            
    221             general.openNAFile(newname, 'w', builtNADict, spacer=spacer, floatFormat=floatFormat) 
     221            general.openNAFile(newname, 'w', builtNADict, spacer=spacer, float_format=float_format) 
    222222 
    223223        msg="\nWrote the following variables:"+"\n\t"+("\n\t".join(i[1][0])) 
     
    268268        self.cdmsfile=cdmsfile 
    269269        self.outputMessage=[] 
    270         self.naDict={} 
     270        self.na_dict={} 
    271271        self.vars=vars 
    272272        self.varIDs=None 
     
    281281            self.varIDs=[[var.id for var in self.orderedVars],[var.id for var in auxVars], self.rankZeroVarIDs] 
    282282         
    283             self.naDict["NLHEAD"]="-999" 
     283            self.na_dict["NLHEAD"]="-999" 
    284284         
    285285            #print [var.id for var in self.orderedVars] 
     
    291291            self.defineGeneralHeader() 
    292292            # Quick fudge 
    293             if self.naDict["FFI"]==1001: self.naDict["X"]=self.naDict["X"][0] 
     293            if self.na_dict["FFI"]==1001: self.na_dict["X"]=self.na_dict["X"][0] 
    294294 
    295295 
     
    347347        shape=bestVar.shape 
    348348        ndims=len(shape) 
    349         self.naDict["NIV"]=ndims 
     349        self.na_dict["NIV"]=ndims 
    350350 
    351351        # Work out which File Format Index is appropriate  
    352352        if ndims in (2,3,4): 
    353             self.naDict["FFI"]=10+(ndims*1000) 
     353            self.na_dict["FFI"]=10+(ndims*1000) 
    354354        elif ndims>4: 
    355355            raise "Cannot write variables defined against greater than 4 axes in NASA Ames format." 
    356356        else: 
    357             if len(auxVars4NA)>0 or (self.naDict.has_key("NAUXV") and self.naDict["NAUXV"]>0): 
    358                 self.naDict["FFI"]=1010 
     357            if len(auxVars4NA)>0 or (self.na_dict.has_key("NAUXV") and self.na_dict["NAUXV"]>0): 
     358                self.na_dict["FFI"]=1010 
    359359            else: 
    360                 self.naDict["FFI"]=1001 
    361         #print self.naDict["FFI"] 
     360                self.na_dict["FFI"]=1001 
     361        #print self.na_dict["FFI"] 
    362362        axes=bestVar.getAxisList() 
    363363         
     
    439439        associated metadata. 
    440440        """ 
    441         self.naDict["NV"]=len(vars) 
    442         self.naDict["VNAME"]=[] 
    443         self.naDict["VMISS"]=[] 
    444         self.naDict["VSCAL"]=[] 
    445         self.naDict["V"]=[] 
     441        self.na_dict["NV"]=len(vars) 
     442        self.na_dict["VNAME"]=[] 
     443        self.na_dict["VMISS"]=[] 
     444        self.na_dict["VSCAL"]=[] 
     445        self.na_dict["V"]=[] 
    446446        for var in vars: 
    447447            name=getBestName(var) 
    448             self.naDict["VNAME"].append(name) 
     448            self.na_dict["VNAME"].append(name) 
    449449            miss=getMissingValue(var) 
    450450            if type(miss) not in (float, int, long):  miss=miss[0] 
    451             self.naDict["VMISS"].append(miss) 
    452             #print self.naDict["VMISS"] 
    453             self.naDict["VSCAL"].append(1) 
     451            self.na_dict["VMISS"].append(miss) 
     452            #print self.na_dict["VMISS"] 
     453            self.na_dict["VSCAL"].append(1) 
    454454            # AND THE ARRAY 
    455455            # Populate the variable list   
    456456            ######## NOTE - might not have to do this ##### 
    457457            ######## It  might handle writing from a Numeric array ######## 
    458             self.naDict["V"].append(var._data) 
     458            self.na_dict["V"].append(var._data) 
    459459            #listOfListsCreator(inlist, var.shape) 
    460460            #arrayToList(var, inlist) 
    461461 
    462             if not self.naDict.has_key("X"): 
    463                 self.naDict["NXDEF"]=[] 
    464                 self.naDict["NX"]=[] 
     462            if not self.na_dict.has_key("X"): 
     463                self.na_dict["NXDEF"]=[] 
     464                self.na_dict["NX"]=[] 
    465465                # Create independent variable information 
    466466                #print var.id, var.getAxis(0) 
    467467                self.ax0=var.getAxis(0) 
    468                 self.naDict["X"]=[list(self.ax0._data_)] 
    469                 self.naDict["XNAME"]=[getBestName(self.ax0)] 
     468                self.na_dict["X"]=[list(self.ax0._data_)] 
     469                self.na_dict["XNAME"]=[getBestName(self.ax0)] 
    470470                if len(self.ax0)==1: 
    471                     self.naDict["DX"]=[0] 
     471                    self.na_dict["DX"]=[0] 
    472472                else: 
    473473                    incr=self.ax0[1]-self.ax0[0] 
    474474                    # Set default increment as gap between first two 
    475                     self.naDict["DX"]=[incr] 
     475                    self.na_dict["DX"]=[incr] 
    476476                    # Now overwrite it as zero if non-uniform interval in axis 
    477477                    for i in range(1, len(self.ax0)): 
    478478                        if (self.ax0[i]-self.ax0[i-1])!=incr: 
    479                             self.naDict["DX"]=[0] 
     479                            self.na_dict["DX"]=[0] 
    480480                            break 
    481481 
     
    490490        associated metadata. 
    491491        """ 
    492         self.naDict["NAUXV"]=len(auxVars) 
    493         self.naDict["ANAME"]=[] 
    494         self.naDict["AMISS"]=[] 
    495         self.naDict["ASCAL"]=[] 
    496         self.naDict["A"]=[] 
     492        self.na_dict["NAUXV"]=len(auxVars) 
     493        self.na_dict["ANAME"]=[] 
     494        self.na_dict["AMISS"]=[] 
     495        self.na_dict["ASCAL"]=[] 
     496        self.na_dict["A"]=[] 
    497497        for var in auxVars: 
    498498            name=getBestName(var) 
    499             self.naDict["ANAME"].append(name) 
     499            self.na_dict["ANAME"].append(name) 
    500500            miss=getMissingValue(var) 
    501501            if type(miss)!=float:  miss=miss[0] 
    502             self.naDict["AMISS"].append(miss) 
    503             self.naDict["ASCAL"].append(1) 
     502            self.na_dict["AMISS"].append(miss) 
     503            self.na_dict["ASCAL"].append(1) 
    504504            # AND THE ARRAY 
    505505            # Populate the variable list   
    506506            ######## NOTE - might not have to do this ##### 
    507507            ######## It  might handle writing from a Numeric array ######## 
    508             self.naDict["A"].append(var._data) 
     508            self.na_dict["A"].append(var._data) 
    509509            #listOfListsCreator(inlist, var.shape) 
    510510            #arrayToList(var, inlist)      
     
    518518        """ 
    519519        length=len(axis) 
    520         self.naDict["NX"].append(length) 
    521         self.naDict["XNAME"].append(getBestName(axis)) 
     520        self.na_dict["NX"].append(length) 
     521        self.na_dict["XNAME"].append(getBestName(axis)) 
    522522        # If only one item in axis values 
    523523        if length<2: 
    524             self.naDict["DX"].append(0) 
    525             self.naDict["NXDEF"].append(length) 
    526             self.naDict["X"].append(list(axis._data_))         
     524            self.na_dict["DX"].append(0) 
     525            self.na_dict["NXDEF"].append(length) 
     526            self.na_dict["X"].append(list(axis._data_))         
    527527            return 
    528528    
     
    530530        for i in range(1, length): 
    531531            if (axis[i]-axis[i-1])!=incr: 
    532                 self.naDict["DX"].append(0) 
    533                 self.naDict["NXDEF"].append(length) 
    534                 self.naDict["X"].append(list(axis._data_)) 
     532                self.na_dict["DX"].append(0) 
     533                self.na_dict["NXDEF"].append(length) 
     534                self.na_dict["X"].append(list(axis._data_)) 
    535535                break 
    536536        else: 
    537537            maxLength=length 
    538538            if length>3: maxLength=3 
    539             self.naDict["DX"].append(incr) 
    540             self.naDict["NXDEF"].append(maxLength) 
    541             self.naDict["X"].append(axis[:maxLength]) 
     539            self.na_dict["DX"].append(incr) 
     540            self.na_dict["NXDEF"].append(maxLength) 
     541            self.na_dict["X"].append(axis[:maxLength]) 
    542542        return 
    543543 
     
    573573                    match=re.match(r"(.*)\s+\(ONAME from NASA Ames file\);\s+(.*)\s+\(ORG from NASA Ames file\)\.", self.globals[key]) 
    574574                    if match: 
    575                         self.naDict["ONAME"]=match.groups()[0] 
    576                         self.naDict["ORG"]=match.groups()[1] 
     575                        self.na_dict["ONAME"]=match.groups()[0] 
     576                        self.na_dict["ORG"]=match.groups()[1] 
    577577                    else: 
    578                         self.naDict["ONAME"]=self.globals[key] 
    579                         self.naDict["ORG"]=self.globals[key]                 
     578                        self.na_dict["ONAME"]=self.globals[key] 
     579                        self.na_dict["ORG"]=self.globals[key]                
    580580                     
    581581                    # NOte: should probably do the following search and replace on all string lines 
    582                     self.naDict["ONAME"]=self.naDict["ONAME"].replace("\n", "  ") 
    583                     self.naDict["ORG"]=self.naDict["ORG"].replace("\n", "  ") 
     582                    self.na_dict["ONAME"]=self.na_dict["ONAME"].replace("\n", "  ") 
     583                    self.na_dict["ORG"]=self.na_dict["ORG"].replace("\n", "  ") 
    584584                                     
    585585                elif key=="comment": 
     
    612612                                     
    613613                elif key=="first_valid_date_of_data": 
    614                     self.naDict["DATE"]=self.globals[key] 
     614                    self.na_dict["DATE"]=self.globals[key] 
    615615                 
    616616                elif key in ("Conventions", "references"): 
     
    618618                    self.extra_comments[2].append("%s:   %s" % (key, self.globals[key])) 
    619619                else: 
    620                     self.naDict[globalmap[key]]=self.globals[key] 
     620                    self.na_dict[globalmap[key]]=self.globals[key] 
    621621            else: 
    622622                self.extra_comments[2].append("%s:   %s" % (key, self.globals[key])) 
     
    741741                    SCOM_cleaned.append(line) 
    742742                     
    743         self.naDict["NCOM"]=NCOM_cleaned 
    744         self.naDict["NNCOML"]=len(self.naDict["NCOM"])#+hiddenNewLineCount1 
    745         self.naDict["SCOM"]=SCOM_cleaned 
    746         self.naDict["NSCOML"]=len(self.naDict["SCOM"])#+hiddenNewLineCount2 
     743        self.na_dict["NCOM"]=NCOM_cleaned 
     744        self.na_dict["NNCOML"]=len(self.na_dict["NCOM"])#+hiddenNewLineCount1 
     745        self.na_dict["SCOM"]=SCOM_cleaned 
     746        self.na_dict["NSCOML"]=len(self.na_dict["SCOM"])#+hiddenNewLineCount2 
    747747        return 
    748748 
     
    755755        # Check if DATE field previously known in NASA Ames file 
    756756        time_now=time.strftime("%Y %m %d", time.localtime(time.time())).split() 
    757         if not self.naDict.has_key("RDATE"): 
    758             self.naDict["RDATE"]=time_now 
     757        if not self.na_dict.has_key("RDATE"): 
     758            self.na_dict["RDATE"]=time_now 
    759759         
    760760        if self.ax0.isTime(): 
     
    763763                (unit, start_date)=re.match("(\w+)\s+?since\s+?(\d+-\d+-\d+)", self.ax0.units).groups()             
    764764                comptime=cdtime.s2c(start_date) 
    765                 first_day=comptime.add(self.naDict["X"][0][0], getattr(cdtime, unit.capitalize())) 
    766                 self.naDict["DATE"]=string.replace(str(first_day).split(" ")[0], "-", " ").split() 
     765                first_day=comptime.add(self.na_dict["X"][0][0], getattr(cdtime, unit.capitalize())) 
     766                self.na_dict["DATE"]=string.replace(str(first_day).split(" ")[0], "-", " ").split() 
    767767            except: 
    768768                msg="Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
    769769                print msg 
    770770                self.outputMessage.append(msg) 
    771                 self.naDict["DATE"]=("DATE", "NOT", "KNOWN") 
     771                self.na_dict["DATE"]=("DATE", "NOT", "KNOWN") 
    772772        else:  
    773             if not self.naDict.has_key("DATE"): 
     773            if not self.na_dict.has_key("DATE"): 
    774774                msg="Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
    775775                print msg 
    776776                self.outputMessage.append(msg) 
    777                 self.naDict["DATE"]=("DATE", "NOT", "KNOWN") 
    778         self.naDict["IVOL"]=1 
    779         self.naDict["NVOL"]=1 
     777                self.na_dict["DATE"]=("DATE", "NOT", "KNOWN") 
     778        self.na_dict["IVOL"]=1 
     779        self.na_dict["NVOL"]=1 
    780780        for key in header_items.keys(): 
    781              self.naDict[key]=header_items[key] 
     781             self.na_dict[key]=header_items[key] 
    782782        return 
    783783 
  • nappy/trunk/nappy/na_file/na_core.py

    r3330 r3349  
    4545        Returns a dictionary of the contents of a NASA Ames file. 
    4646        """ 
    47         na_dict = {} 
     47        dct = {} 
    4848        for key in NACore.na_dictionary_keys: 
    49             na_dict[key] = getattr(self, key) 
    50  
    51         self.naDict={} 
    52         for i in na_dict.keys(): 
    53             if na_dict[i] != None: 
    54                 self.naDict[i] = na_dict[i] 
    55         return self.naDict 
     49            dct[key] = getattr(self, key) 
     50 
     51        self.na_dict={} 
     52        for i in dct.keys(): 
     53            if dct[i] != None: 
     54                self.na_dict[i] = dct[i] 
     55        return self.na_dict 
    5656 
    5757    def __getitem__(self, item): 
  • nappy/trunk/nappy/na_file/na_file.py

    r3330 r3349  
    4141    """ 
    4242 
    43     def __init__(self, filename, mode="r", naDict={}, spacer="    ", floatFormat="%8.3f"): 
     43    def __init__(self, filename, mode="r", na_dict={}, spacer="    ", float_format="%8.3f"): 
    4444        """ 
    4545        Initialization of class, decides if user wishes to read or write 
     
    4747        """ 
    4848        nappy.na_file.na_core.NACore.__init__(self) 
    49         self.naDict = naDict 
     49        self.na_dict = na_dict 
    5050        self.filename = filename 
    5151        self._open(mode) 
    5252        self.spacer = spacer 
    53         self.floatFormat = floatFormat 
     53        self.float_format = float_format 
    5454 
    5555        if mode == "r": 
    56             self._normalizedX = "yes" 
     56            self._normalized_X = True 
    5757            self.readHeader() 
    5858        elif mode == "w": 
     
    7575    def _parseDictionary(self): 
    7676        """ 
    77         Parser for the optional naDict argument containing a dictionary 
     77        Parser for the optional na_dict argument containing a dictionary 
    7878        of NASA Ames internal variables. These are saved as instance attributes 
    7979        with the name used in the NASA Ames documentation. 
    8080        """ 
    81         for i in self.naDict.keys(): 
    82             setattr(self, i, self.naDict[i]) 
     81        for i in self.na_dict.keys(): 
     82            setattr(self, i, self.na_dict[i]) 
    8383 
    8484    def _readTopLine(self): 
  • nappy/trunk/nappy/na_file/na_file_1020.py

    r3321 r3349  
    3030        Reads FFI-specifc header section. 
    3131        """     
    32         self._normalizedX = "no" 
     32        self._normalized_X = False 
    3333        self._readCommonHeader() 
    3434        self.DX = utils.text_parser.readItemsFromLine(self.file.readline(), self.NIV, float) 
     
    6969 
    7070        self.X[0] = newX 
    71         self._normalizedX = "yes" 
     71        self._normalized_X = True 
    7272 
    7373    def writeHeader(self):                                                                               
  • nappy/trunk/nappy/na_file/na_file_2010.py

    r3321 r3349  
    2929        Reads FFI-specifc header section. 
    3030        """         
    31         self._normalizedX = "no" 
     31        self._normalized_X = False 
    3232        self._readCommonHeader() 
    3333        self.DX = utils.text_parser.readItemsFromLine(self.file.readline(), self.NIV, float) 
     
    6464 
    6565        for i in range(self.NIV - 1): 
    66             X_lines.append(((self.floatFormat + self.spacer) * self.NXDEF[i] + "\n") % tuple(self.X[i + 1][0:self.NXDEF[i]])) 
     66            X_lines.append(((self.float_format + self.spacer) * self.NXDEF[i] + "\n") % tuple(self.X[i + 1][0:self.NXDEF[i]])) 
    6767 
    6868        X_lines.reverse() 
     
    129129        for m in range(len(self.X[0])): 
    130130            # Write Independent variable mark and auxiliary variables 
    131             var_string = (self.floatFormat + self.spacer) % self.X[0][m] 
     131            var_string = (self.float_format + self.spacer) % self.X[0][m] 
    132132            for a in range(self.NAUXV): 
    133                 var_string = var_string + ((self.floatFormat + self.spacer) % self.A[a][m]) 
     133                var_string = var_string + ((self.float_format + self.spacer) % self.A[a][m]) 
    134134            self.file.write("%s\n" % var_string.rstrip()) 
    135135            # Write Variables 
    136136            for n in range(self.NV): 
    137                 outlines = utils.list_manipulator.recursiveListWriter(self.V[n][m], self.NX, spacer = self.spacer, floatFormat = self.floatFormat) 
     137                outlines = utils.list_manipulator.recursiveListWriter(self.V[n][m], self.NX, spacer = self.spacer, float_format = self.float_format) 
    138138                for line in outlines: 
    139139                    self.file.write(line) 
     
    154154                    self.X[i + 1].append(nextx) 
    155155                    count = count + 1 
    156         self._normalizedX = "yes" 
     156        self._normalized_X = True 
  • nappy/trunk/nappy/na_file/na_file_2160.py

    r3321 r3349  
    2727        Reads FFI-specifc header section. 
    2828        """ 
    29         self._normalizedX = "no" 
     29        self._normalized_X = False 
    3030        self._readCommonHeader() 
    3131        self.DX = utils.text_parser.readItemsFromLine(self.file.readline(), 1, float) 
  • nappy/trunk/nappy/na_file/na_file_2310.py

    r3321 r3349  
    2727        Reads FFI-specifc header section. 
    2828        """         
    29         self._normalizedX = "no" 
     29        self._normalized_X = False 
    3030        self._readCommonHeader() 
    3131        self.DX = utils.text_parser.readItemsFromLine(self.file.readline(), 1, float) 
  • nappy/trunk/nappy/nappy_api.py

    r3334 r3349  
    1414from nappy.utils.common_utils import * 
    1515 
    16 def openNAFile(filename, mode="r", naDict=None, spacer="    ", floatFormat="%8.3f"): 
     16def openNAFile(filename, mode="r", na_dict=None, spacer="    ", float_format="%8.3f"): 
    1717    """ 
    1818    Function wrapper around the NASA Ames File classes. Any NASA Ames 
     
    2525 
    2626    elif mode == "w": 
    27         if naDict.has_key('FFI') and type(naDict['FFI']) == type(3): 
    28             ffi = naDict['FFI'] 
     27        if na_dict.has_key('FFI') and type(na_dict['FFI']) == type(3): 
     28            ffi = na_dict['FFI'] 
    2929        else: 
    30             ffi = chooseFFI(naDict) 
    31             naDict['FFI'] = ffi 
     30            ffi = chooseFFI(na_dict) 
     31            na_dict['FFI'] = ffi 
    3232            print "\nFormat identified as:", ffi     
    33         return apply(getNAFileClass(ffi), (filename,), {"mode":mode, "naDict":naDict, "spacer":spacer, "floatFormat":floatFormat}) 
     33        return apply(getNAFileClass(ffi), (filename,), {"mode":mode, "na_dict":na_dict, "spacer":spacer, "float_format":float_format}) 
    3434    else: 
    3535        raise Exception("File mode not recognised '" + mode + "'.") 
  • nappy/trunk/nappy/nc_interface/cdms_to_na.py

    r3348 r3349  
    4545 
    4646def cdms2na(ncfile, na_file_names, na_vars={}, variables=None, only_return_file_names="no",  
    47             ffi="automatic", spacer="    ", floatFormat="%g", size_limit=None): 
     47            ffi="automatic", spacer="    ", float_format="%g", size_limit=None): 
    4848    """ 
    4949    Main conversion function that calls the appropriate classes and functions 
     
    9898     
    9999    builder = NAContentCollector(vars, globals, rule=rule, cdms_file=cdms_file) 
    100     built_na_dicts = [[builder.naDict, builder.var_ids]] 
     100    built_na_dicts = [[builder.na_dict, builder.var_ids]] 
    101101 
    102102    if builder.var_ids == None: 
     
    109109        builder = NAContentCollector(builder.varBin, globals, rule=rule, cdms_file=cdms_file) 
    110110        output_message = output_message + builder.output_message 
    111         if builder.var_ids != None:  built_na_dicts.append([builder.naDict, builder.var_ids]) 
     111        if builder.var_ids != None:  built_na_dicts.append([builder.na_dict, builder.var_ids]) 
    112112 
    113113    # Return only file_names if only want to know them now. 
     
    190190                new_namePlusLetter = "%s-%.3d.na" % (new_name[:-3], ivol) 
    191191                fileList.append(new_namePlusLetter) 
    192                 general.openNAFile(new_namePlusLetter, 'w', NADictCopy, spacer=spacer, floatFormat=floatFormat) 
     192                general.openNAFile(new_namePlusLetter, 'w', NADictCopy, spacer=spacer, float_format=float_format) 
    193193                msg = "\nOutput files split on size limit: %s\nFilename used: %s" % (size_limit, new_namePlusLetter) 
    194194                print msg 
     
    199199 
    200200        else:            
    201             general.openNAFile(new_name, 'w', builtNADict, spacer=spacer, floatFormat=floatFormat) 
     201            general.openNAFile(new_name, 'w', builtNADict, spacer=spacer, float_format=float_format) 
    202202 
    203203        msg = "\nWrote the following variables:" + "\n\t" + ("\n\t".join(i[1][0])) 
  • nappy/trunk/nappy/nc_interface/na_content_collector.py

    r3348 r3349  
    3838cdms.setAutoBounds("off")  
    3939 
    40 class CdmsToNABuilder --> NAContentCollector: (naDict, var_ids, varBin) 
     40class CdmsToNABuilder --> NAContentCollector: (na_dict, var_ids, varBin) 
    4141__init__ --> sets everything up and runs it move some to --> analyse() 
    4242analyseVariables 
  • nappy/trunk/nappy/nc_interface/na_to_cdms.py

    r3324 r3349  
    331331        Creates a cdms axis from a NASA Ames independent variable. 
    332332        """ 
    333         if self._normalizedX == "no": self.na_file_obj._normalizeIndVars() 
     333        if self._normalized_X == False:  self.na_file_obj._normalizeIndVars() 
    334334 
    335335        if self.na_file_obj.NIV == 1: 
     
    347347            axis.id = safe_nc_id.sub("_", var_name).lower() 
    348348        else: 
    349             axis.id = "naAuxVariable_%s" % (ivar_number) 
     349            axis.id = "naIndVariable_%s" % (ivar_number) 
    350350 
    351351        if units: axis.units = units 
  • nappy/trunk/nappy/unit_tests/test_na_file_1001.py

    r3339 r3349  
    3535    def test_write1001(self): 
    3636        "Tests writing FFI 1001." 
    37         self.fobj = nappy.openNAFile(self.outfile, mode="w", naDict=self.na_dict)                
     37        self.fobj = nappy.openNAFile(self.outfile, mode="w", na_dict=self.na_dict)               
    3838        self.failUnless(isinstance(self.fobj, nappy.na_file.na_file.NAFile)) 
    3939 
  • nappy/trunk/nappy/utils/common_utils.py

    r3336 r3349  
    3333 
    3434 
    35 def chooseFFI(naDict): 
     35def chooseFFI(na_dict): 
    3636    """ 
    3737    Function to choose the appropriate FFI based on the contents of the 
    38     'naDict' dictionary object that holds NASA Ames internal variables. 
     38    'na_dict' dictionary object that holds NASA Ames internal variables. 
    3939    """ 
    40     d = naDict 
     40    d = na_dict 
    4141 
    4242    if d["NIV"] > 4:      # More than 4 independent variables not allowed 
  • nappy/trunk/nappy/utils/list_manipulator.py

    r3336 r3349  
    2020    """ 
    2121    dimlist = array.shape 
    22     if len(dimlist[1:])>0: 
     22    if len(dimlist[1:]) > 0: 
    2323        for i in range(dimlist[0]): 
    2424            arrayToList(inlist[i], array[i]) 
     
    4545 
    4646 
    47 def recursiveListWriter(inlist, dimlist, spacer="    ", floatFormat="%8.3f"): 
     47def recursiveListWriter(inlist, dimlist, spacer="    ", float_format="%8.3f"): 
    4848    "Function wrapper around class method RecursiveListManipulator().writeLines()." 
    49     return RecursiveListManipulator().writeLines(inlist, dimlist, spacer=spacer, floatFormat=floatFormat) 
     49    return RecursiveListManipulator().writeLines(inlist, dimlist, spacer=spacer, float_format=float_format) 
    5050 
    5151 
     
    6464 
    6565        if not hasattr(self, "_counter"): 
    66             self._counter=0 
    67         if len(dimlist[1:])>0: 
     66            self._counter = 0 
     67        if len(dimlist[1:]) > 0: 
    6868            for i in range(dimlist[0]): 
    6969                inlist.append([]) 
    7070                self.populator(inlist[i], array, dimlist[1:]) 
    7171        else: 
    72             count=self._counter 
    73             self._counter=self._counter+dimlist[0] 
    74             endcount=self._counter 
     72            count = self._counter 
     73            self._counter = self._counter + dimlist[0] 
     74            endcount = self._counter 
    7575            for i in range(count, endcount): 
    7676                inlist.append(array[i]) 
    7777        return inlist 
    7878 
    79     def writeLines(self, inlist, dimlist, spacer="    ", floatFormat="%8.3f"): 
     79    def writeLines(self, inlist, dimlist, spacer="    ", float_format="%8.3f"): 
    8080        """ 
    8181        Method to walk through all the levels of the multi-level list object 
     
    8484        """ 
    8585        if not hasattr(self, "rtlines"): 
    86             self.rtlines=[] 
    87         if len(dimlist[1:])>0: 
     86            self.rtlines = [] 
     87        if len(dimlist[1:]) > 0: 
    8888            for i in range(dimlist[0]): 
    89                 self.writeLines(inlist[i], dimlist[1:], spacer=spacer, floatFormat=floatFormat) 
     89                self.writeLines(inlist[i], dimlist[1:], spacer=spacer, float_format=float_format) 
    9090        else: 
    91             var_string="" 
     91            var_string = "" 
    9292            for i in range(dimlist[0]): 
    93                 var_string=var_string+((floatFormat+spacer) % inlist[i]) 
     93                var_string = var_string + ((float_format+spacer) % inlist[i]) 
    9494            self.rtlines.append("%s\n" % var_string.rstrip()) 
    9595        return self.rtlines 
Note: See TracChangeset for help on using the changeset viewer.