Changeset 1109


Ignore:
Timestamp:
07/06/06 00:44:32 (13 years ago)
Author:
astephen
Message:

Stable-ish version with fully-ish working dxc client.

Location:
TI03-DataExtractor/trunk
Files:
163 added
26 edited

Legend:

Unmodified
Added
Removed
  • TI03-DataExtractor/trunk/INSTALL.txt

    r794 r1109  
    77locations. These components should all be installed automatically once 
    88you have configured the installation process by modifying the contents 
    9 of the "install.conf" file. 
     9of the "install.conf" file. Note that you will need to have permission  
     10to create directories and files in all the directories that you specify  
     11for in your configuration file. 
    1012 
    1113Please follow the instructions below to install the DX package(s): 
  • TI03-DataExtractor/trunk/cgi/dxui

    r794 r1109  
    4040        on the configuration and arguments provided. 
    4141        """ 
    42         self.username=None 
    43         self.password=None 
    44         self.secureToken=None 
     42        self.username="undefined" 
     43        self.password="undefined" 
     44        self.secureToken="undefined" 
    4545        self.userRoles=[] 
    4646        self.loginStatus="out" 
     
    7878                    CGIErrorHandler("Security error: "+str(sys.exc_type), noheader=0) 
    7979        else: 
    80             self.secureToken=None              
     80            self.secureToken="undefined" 
    8181             
    8282        # Call the dx Web Service with the arguments provided        
     
    119119            self.args[key]=args.getvalue(key)  
    120120                    
    121         if self.args.has_key("sessionID") and self.args["sessionID"]=="None": 
    122             self.args["sessionID"]=None      
     121        if self.args.has_key("sessionID") and self.args["sessionID"]=="undefined": 
     122            self.args["sessionID"]="undefined"       
    123123          
    124124        # Check for secure items, destroy if necessary and assign as instance variables     
     
    137137         
    138138        if not self.args.has_key("username"): 
    139             self.args["username"]=None 
    140              
    141         self._determineNumberOfDatasets() 
    142         self._parsePartialDimensionArgs() 
    143  
    144  
    145     def _determineNumberOfDatasets(self): 
     139            self.args["username"]="undefined" 
     140             
     141        #self._determineNumberOfDatasets() 
     142        #self._parsePartialDimensionArgs() 
     143         
     144        self._compileAxisSelections() 
     145         
     146 
     147    def _compileAxisSelections(self): 
     148        """ 
     149        Compiles partial selections from the last form selections 
     150        so that axis start and end components are linked into a 
     151        list of arguments and string components become whole date/time 
     152        strings. 
     153        """ 
     154        #print "Content-Type: text/html\n\n" 
     155        #print "<P>".join(["%s:%s" % (n,v) for (n,v) in self.args.items()])      
     156        dateTimeTemplate="%.4d-%.2d-%.2dT%.2d:%.2d:%f" 
     157        timeAxisItems=getDictSubsetMatching(self.args, "axis_.*_low\.time\.year", "regex") 
     158         
     159        # Must have come from dxui so if year is there all others will be 
     160        for name, value in timeAxisItems.items(): 
     161            axisIndex=re.match(r"axis_(.*)_low\.time\.year", name).groups()[0] 
     162            tcList=[] 
     163            for lh in ("low", "high"): 
     164                for t in "year month day hour minute second".split(): 
     165                    argName="axis_%s_%s.time.%s" % (axisIndex, lh, t) 
     166                    tcList.append(self.args[argName]) 
     167                    del self.args[argName] 
     168         
     169            # Now compile into start and end date time 
     170            floatList=[float(i) for i in tcList] 
     171            self.args["axis_%s" % axisIndex]=[dateTimeTemplate % tuple(floatList[:6]), 
     172                                              dateTimeTemplate % tuple(floatList[6:])] 
     173 
     174        otherAxisItems=getDictSubsetMatching(self.args, "axis_.*_low$", "regex") 
     175        for name, value in otherAxisItems.items(): 
     176            axisIndex=re.match(r"axis_(.*)_low$", name).groups()[0] 
     177            iList=[] 
     178            for lh in ("low", "high"): 
     179                argName="axis_%s_%s" % (axisIndex, lh) 
     180                iList.append(self.args[argName]) 
     181                del self.args[argName] 
     182         
     183            try: 
     184                iList=[float(i) for i in iList] 
     185            except: 
     186                try: 
     187                    iList=[int(i) for i in iList] 
     188                except: 
     189                    pass 
     190             
     191            self.args["axis_%s" % axisIndex]=iList 
     192         
     193        #print "Content-Type: text/html\n\n" 
     194        #print "<P>".join(["%s:%s" % (n,v) for (n,v) in self.args.items()]) 
     195         
     196                     
     197    def DEPRECATED_determineNumberOfDatasets(self): 
    146198        """ 
    147199        Returns the number of datasets the user is requesting. 
     
    165217 
    166218 
    167     def _parsePartialDimensionArgs(self): 
     219    def DEPRECATED_parsePartialDimensionArgs(self): 
    168220        """ 
    169221        Parses dimension arguments so that they are of the  
     
    192244                     
    193245 
    194     def _compileDateTimeArgs(self): 
     246    def DEPRECATED_compileDateTimeArgs(self): 
    195247        """ 
    196248        Converts a list of arguments for each date and time component 
     
    274326        isCompleteStatus=self._checkIfComplete() 
    275327         
    276         # If an argument received as "numberOfDatasets" then call WS to set that 
    277          
    278         if self.args.has_key("numberOfDatasets"): 
    279             status, self.secureToken=self.server.callServerMethod("setNumberOfDatasets",  
    280                                           [self.sessionID, self.args["numberOfDatasets"],  
    281                                            self.secureToken]) 
    282          
     328 
    283329        # Perform actions as requested by user 
    284330        if self.args.has_key("action"): 
     
    292338                del self.args["clearRequest"] 
    293339            else: 
    294                 del self.args["newRequest"] 
    295             #response=self._webServiceCallWrapper(self.server.newRequest(self.sessionID, self.secureToken)) 
    296             #self.sessionID, self.secureToken=response      
     340                del self.args["newRequest"]   
    297341            self.sessionID, self.secureToken=self.server.callServerMethod("newRequest",  
    298342                                                  [self.sessionID, self.secureToken])                                            
     
    306350 
    307351        # Get the options (and make selections if appropriate) 
    308         (optionCategories, options, optionStrings, secureToken)=self._getLatestOptions() 
    309  
    310         # ***Can probably delete ***Update secure token after 
    311         #if RESTRICTED_DATA==1: 
    312         #    self._upDateSecureToken(secureToken)        
     352        (optionCategories, options, optionStrings, summaryString, secureToken)=self._getLatestOptions()  
    313353         
    314354        # Get summary of request and determine number of datasets     
    315         #response=self._webServiceCallWrapper(self.server.summariseRequest(self.sessionID, self.secureToken)) 
    316         #self.summary=response[0] 
    317         self.summary=self.server.callServerMethod("summariseRequest", [self.sessionID, self.secureToken])[0] 
    318         numDatasetsMatch=re.search(r"numberOfDatasets:\t(\d+)", self.summary) 
     355        #self.summary=self.server.callServerMethod("summariseRequest", [self.sessionID, self.secureToken])[0] 
     356        """numDatasetsMatch=re.search(r"numberOfDatasets:\t(\d+)", self.summary) 
    319357        if numDatasetsMatch: 
    320             self.numberOfDatasets=int(numDatasetsMatch.groups()[0]) 
     358            self.numberOfDatasets=int(numDatasetsMatch.groups()[0])""" 
    321359             
    322360        # Analyse the request 
    323         self._respondToOptionCategories(optionCategories, options, optionStrings)        
     361        self._respondToOptionCategories(optionCategories, options, optionStrings, summaryString)         
    324362     
    325363         
     
    329367        """            
    330368        # If no session then start a session and get a sessionID 
    331         if not self.args.has_key("sessionID") or self.args["sessionID"] in (None, "None"): 
     369        if not self.args.has_key("sessionID") or self.args["sessionID"] in (None, "None", "undefined"): 
    332370            # Start session if not known about 
    333             #response=self._webServiceCallWrapper(self.server.startSession(self.username, self.password, self.secureToken)) 
    334             #self.sessionID, self.secureToken=response 
    335             #self.sessionID=self._deUnicodeObject(self.sessionID) 
    336371            self.sessionID, self.secureToken=self.server.callServerMethod("startSession", 
    337                                                  [self.username, self.password, self.secureToken]) 
     372                                                 [self.username, self.password, self.secureToken])[0] 
    338373        else: 
    339374            self.sessionID=self.args["sessionID"]  
     
    345380        """ 
    346381        isCompleteStatus=0         
    347         if self.args.has_key("isComplete"): 
    348             #response=self._webServiceCallWrapper(self.server.isComplete(self.sessionID, self.secureToken)) 
    349             #isCompleteStatus, self.secureToken=response         
     382        if self.args.has_key("isComplete"):      
    350383            isCompleteStatus, self.secureToken=self.server.callServerMethod("isComplete",  
    351384                                                      [self.sessionID, self.secureToken])      
     
    360393            action=self.args["action"] 
    361394            if action=="viewRequestSummary": 
    362                 #response=self._webServiceCallWrapper(self.server.summariseRequest(self.sessionID, self.secureToken))        
    363                 #summary=response[0] 
    364395                summary=self.server.callServerMethod("summariseRequest", [self.sessionID, self.secureToken])[0] 
    365396                self.displayer._displayHTTPHeader()  
     
    370401                 
    371402            elif action=="saveRequest": 
    372                 #response=self._webServiceCallWrapper(self.server.getDataSubsetSpecifier(self.sessionID, self.secureToken)) 
    373                 #dataSubsetSpecifier, self.secureToken=response 
    374403                dataSubsetSpecifier, self.secureToken=self.server.callServerMethod("getDataSubsetSpecifier", 
    375404                                                           [self.sessionID, self.secureToken]) 
     
    389418            elif action=="parseUploadedFile": 
    390419                xmlFileString=self.tempFileLink.read() 
    391                 #del self.args["uploadedFile"] 
    392                 #response=self._webServiceCallWrapper(self.server.uploadRequest(self.sessionID, xmlFileString, self.secureToken)) 
    393                 #status, self.secureToken=response           
    394420                status, self.secureToken=self.server.callServerMethod("uploadRequest",  
    395421                                              [self.sessionID, xmlFileString, self.secureToken]) 
     
    407433                       "VariablesPage":"variable", "DomainPage":"horizontalDomain"} 
    408434            optionCategory=tp2catMap[tp] 
    409             #response=self._webServiceCallWrapper(self.server.getOptions(self.sessionID, self.secureToken, optionCategory)) 
    410             #(optionCategories, options, optionStrings, secureToken)=response  
    411             (optionCategories, options, optionStrings, secureToken)=self.server.callServerMethod("getOptions",  
    412                                                                          [self.sessionID, self.secureToken,  
    413                                                                          optionCategory]) 
     435            response=self.server.callServerMethod("getOptions", [self.sessionID, self.secureToken, optionCategory]) 
    414436        else:   
    415             #print "Content-Type: text/html\n\n" 
    416             #args=self._packArgsAsList(self.args) 
    417             #print str(args) 
    418             #r=self.server.selectOptions(self.sessionID, []) 
    419             #raise str(r) 
    420             #r=apply(self.server.selectOptions, [self.sessionID, args]) 
    421             #response=self._webServiceCallWrapper(apply(self.server.selectOptions, [self.sessionID, args])) 
    422             #response=self._deUnicodeObject(response)                        
    423             #(optionCategories, options, optionStrings, secureToken)=response 
    424             (optionCategories, options, optionStrings, secureToken)=self.server.callServerMethod("selectOptions", 
    425                                                                        [self.sessionID, self._packArgsAsList(self.args)]) 
    426          
    427         return (optionCategories, options, optionStrings, secureToken) 
    428  
    429  
    430     def _respondToOptionCategories(self, optionCategories, options, optionStrings): 
     437            response=self.server.callServerMethod("selectOptions", [self.sessionID, self._packArgsAsList(self.args)]) 
     438         
     439        #self.displayer._displayHTTPHeader() 
     440        (optionCategories, options, optionStrings, summaryString, secureToken)=self._translateResponse(response)         
     441        #print (optionCategories, options, optionStrings, summaryString, secureToken)    
     442        return (optionCategories, options, optionStrings, summaryString, secureToken) 
     443 
     444     
     445    def _translateResponse(self, response): 
     446        """ 
     447        Takes an object received from the WS and translates to:  
     448        (optionCategories, options, optionStrings, secureToken) 
     449        """ 
     450        response=response[0][0][0] 
     451        optionCategories=[item[0] for item in response[:-2]] 
     452        options=[item[1] for item in response[:-2]] 
     453        optionStrings=options 
     454        summaryString=response[-2] 
     455        secureToken=response[-1]                 
     456        return (optionCategories, options, optionStrings, summaryString, secureToken) 
     457         
     458 
     459    def _respondToOptionCategories(self, optionCategories, options, optionStrings, summaryString): 
    431460        """ 
    432461        Work out what the option category is and respond by displaying 
    433462        the appropriate user interface. 
    434463        """      
     464        summaryDict=createSummaryDict(summaryString) 
    435465        # Analyse the option categories now 
    436         if optionCategories=="No category": 
     466        if optionCategories=="No category" or optionCategories==[]: 
    437467            optcat=None 
    438468        else: 
     
    444474            self.displayer._displayHTMLHeader()      
    445475            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
    446             self.displayer._displayDatasetSummaryLine(self.summary, optionCategories[0], self.sessionID) 
     476            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID) 
    447477            self.displayer._displayMainTableHeader(self.sessionID) 
    448             self.displayer._displayOptionsTable(optionCategories, options, optionStrings, self.sessionID, self.sessionObject) 
     478            self.displayer._displayOptionsTable(summaryDict, optionCategories, options, optionStrings, self.sessionID, self.sessionObject) 
    449479            self.displayer._displayMainTableFooter() 
    450480         
     
    452482        # for each domain as well as output format which are all 
    453483        # displayed on the same page.     
     484        elif optcat=="axis": 
     485            self.displayer._displayHTTPHeader()  
     486            self.displayer._displayHTMLHeader() 
     487            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID) 
     488            self.displayer._displayMainTableHeader(self.sessionID) 
     489            self.displayer._displayDomainOptions(summaryDict, optionCategories, options, optionStrings, self.sessionID)      
     490            self.displayer._displayMainTableFooter() 
     491         
    454492        elif optcat=="horizontalDomain": 
    455493            self.displayer._displayHTTPHeader()  
    456494            self.displayer._displayHTMLHeader() 
    457             self.displayer._displayDatasetSummaryLine(self.summary, optionCategories[0], self.sessionID) 
     495            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID) 
    458496            self.displayer._displayMainTableHeader(self.sessionID)           
    459497            print "<P><B>SPATIAL AND TEMPORAL SELECTION</B><P>"      
     
    461499             
    462500            # Now get the vertical domain options 
    463             self.args["optionCategoryRequested"]="verticalDomain" 
    464             #response=self._webServiceCallWrapper(apply(self.server.selectOptions, [self.sessionID, self._packArgsAsList(self.args)])) 
    465             #response=self._deUnicodeObject(response)        
    466             #(optionCategories, options, optionStrings, secureToken)=response    
     501            self.args["optionCategoryRequested"]="verticalDomain"        
    467502            (optionCategories, options, optionStrings, secureToken)=self.server.callServerMethod("selectOptions",  
    468503                                                                         [self.sessionID, self._packArgsAsList(self.args)]) 
     
    471506            # Now get the temporal domain options 
    472507            self.args["optionCategoryRequested"]="temporalDomain"            
    473             #response=self._webServiceCallWrapper(apply(self.server.selectOptions, [self.sessionID, self._packArgsAsList(self.args)])) 
    474             #response=self._deUnicodeObject(response)                
    475             #(optionCategories, options, optionStrings, secureToken)=response    
    476508            (optionCategories, options, optionStrings, secureToken)=self.server.callServerMethod("selectOptions",  
    477509                                                                         [self.sessionID, self._packArgsAsList(self.args)]) 
     
    479511 
    480512            # Now get the output format options 
    481             self.args["optionCategoryRequested"]="outputFormat"      
    482             #response=self._webServiceCallWrapper(apply(self.server.selectOptions, [self.sessionID, self._packArgsAsList(self.args)])) 
    483             #response=self._deUnicodeObject(response)                
    484             #(optionCategories, options, optionStrings, secureToken)=response        
     513            self.args["optionCategoryRequested"]="outputFormat"              
    485514            (optionCategories, options, optionStrings, secureToken)=self.server.callServerMethod("selectOptions",  
    486515                                                                         [self.sessionID, self._packArgsAsList(self.args)])          
     
    494523                self.displayer._displayHTTPHeader()  
    495524                self.displayer._displayHTMLHeader() 
    496                 self.displayer._displayDatasetSummaryLine(self.summary, optionCategories[0], self.sessionID)         
     525                self.displayer._displayDatasetSummaryLine(summaryString, optionCategories, self.sessionID)           
    497526                self.displayer._displayMainTableHeader(self.sessionID)    
    498527                print '<INPUT NAME="action" TYPE="hidden" VALUE="requestCosts">'  
    499                 self.displayer._displayConfirmationSection(self.summary) 
     528                self.displayer._displayConfirmationSection(summaryDict) 
    500529                 
    501530            # Or display final job processing page       
    502             elif self.args.has_key("action") and self.args["action"]=="requestCosts":  
    503                 #response=self._webServiceCallWrapper(self.server.getExtractionCosts(self.sessionID, self.secureToken)) 
    504                 #response=self._deUnicodeObject(response) 
    505                 #(estimatedDuration, estimatedVolume)=response[0:2]                  
     531            elif self.args.has_key("action") and self.args["action"]=="requestCosts":    
    506532                (estimatedDuration, estimatedVolume)=self.server.callServerMethod("getExtractionCosts",  
    507                                                           [self.sessionID, self.secureToken])[0:2] 
     533                                                          [self.sessionID, self.secureToken])[0][0:2] 
    508534                self.displayer._displayHTTPHeader()  
    509535                self.displayer._displayHTMLHeader() 
    510                 self.displayer._displayProcessingSection(estimatedDuration, estimatedVolume, self.sessionID)        
    511                 #response=self._webServiceCallWrapper(self.server.createOutput(self.sessionID, self.secureToken)) 
    512                 #response=self._deUnicodeObject(response)                
    513                 #pathList, self.secureToken=response 
    514                 pathList, self.secureToken=self.server.callServerMethod("createOutput", [self.sessionID, self.secureToken])              
    515                 self.displayer._displayOutputFileList(pathList[0]) 
    516                                  
    517  
    518     def _webServiceCallWrapper(self, response): 
    519         """ 
    520         Analyses the response from a Web Service call to check if an error has 
    521         occurred. If so it parses and reports the error. Otherwise it returns   
    522         the object returned from the Web Service call. 
    523         """ 
    524         if type(response)==type(""): 
    525             # String returns are errors 
    526             self.displayer._displayErrorPage(response) 
    527             self.displayer._displayHTMLFooter() 
    528             sys.exit() 
    529         else: 
    530             return response                      
     536                self.displayer._displayProcessingSection(estimatedDuration, estimatedVolume, self.sessionID) 
     537                pathList, self.secureToken=self.server.callServerMethod("createOutput", [self.sessionID, self.secureToken])[0]           
     538                self.displayer._displayOutputFileList(pathList[0][0])    
    531539 
    532540 
     
    542550         
    543551 
    544     def _deUnicodeObject(self, obj): 
    545         """ 
    546         Returns an identical object with all unicode strings returned as normal strings. 
    547         """ 
    548         return deUnicodeObject(obj) 
    549         """if type(obj)==type(u""): 
    550             return str(obj) 
    551         elif type(obj)==type([]): 
    552             newList=[] 
    553             for item in obj: 
    554                 if type(item)==type(u""): 
    555                     newList.append(str(item)) 
    556                 elif type(item)==type([]): 
    557                     extraList=[] 
    558                     for i in item: 
    559                         if type(i)==type(u""): 
    560                             extraList.append(str(i)) 
    561                         elif type(i)==type([]): 
    562                             anotherList=[] 
    563                             for a in i: 
    564                                 if type(a)==type(u""): 
    565                                     anotherList.append(str(a)) 
    566                                 elif type(a)==type([]): 
    567                                     wowList=[] 
    568                                     for x in a: 
    569                                         if type(x)==type(u""): 
    570                                             wowList.append(str(x)) 
    571                                         else: 
    572                                             wowList.append(x) 
    573                                     anotherList.append(wowList[:]) 
    574                                 else: 
    575                                     anotherList.append(a) 
    576                             extraList.append(anotherList[:]) 
    577                         else: 
    578                             extraList.append(i) 
    579                     newList.append(extraList[:]) 
    580                 else: 
    581                     newList.append(item) 
    582             return newList 
    583         else: 
    584             return obj""" 
    585  
    586          
    587     def _validateRequest(self): 
    588         """ 
    589         Calls the validation Web Service to check that the current selection is  
    590         within the available options. This will be needed as users can write their 
    591         own XML files and upload them. 
    592         """ 
    593         pass 
    594          
    595  
    596552if __name__=="__main__": 
    597553 
  • TI03-DataExtractor/trunk/dxc/scripts/exampleCLClient1.py

    r794 r1109  
    33sys.path=sys.path+["..","scripts","../..",".", "../../pydxc"] 
    44 
    5 import readline 
     5#import readline 
    66from ZSI.client import Binding 
    77from pydxc.common import * 
    8 from pydxc.clientConfig import SOAP_SERVER_PORT 
     8from pydxc.clientConfig import SOAP_SERVER_URL 
     9 
    910# start session 
    10 server = Binding(url="", host="localhost", port=8406) 
    11 (sessionID, secureToken)=server.startSession("jane", "jane1") 
    12 server.getOptions(sessionID, secureToken) 
    13 print "dsg" 
     11server = Binding(url=SOAP_SERVER_URL) 
     12(sessionID, secureToken)=server.startSession("jane", "jane1")[0] 
     13print sessionID 
     14 
     15print "\nsummary" 
     16print server.summariseRequest(sessionID, secureToken) 
     17 
     18print "\noptions" 
     19print server.getOptions(sessionID, secureToken) 
     20print sessionID 
     21 
     22print "\ndsg selected, ds options..." 
    1423print server.selectOptions(sessionID, [["secureToken",secureToken], ["datasetGroup_1","Test Data Group 1"]]) 
    15 print "ds" 
    16 print server.selectOptions(sessionID, [["secureToken",secureToken], ["dataset_1","Test Dataset 1"]]) 
    17 print "v" 
    18 print server.selectOptions(sessionID, [["secureToken",secureToken], ["variable_1","pqn"]]) 
    19 print "horiz" 
    20 print server.selectOptions(sessionID, [["secureToken",secureToken], ["horizontalDomain",(90,0,0,90)]]) 
    21 print "vert" 
    22 print server.selectOptions(sessionID, [["secureToken",secureToken], ["verticalDomain_1",["Single level"]]]) 
    23 print "options" 
    24 print server.getOptions(sessionID, secureToken) 
    25 print "time"  
    26 print server.selectOptions(sessionID, [["secureToken",secureToken], ["temporalDomain_1",[[1999,1,1,0,0,0],[1999,1,1,0,0,0],[1., "hour"]]]]) 
    27 print "format" 
    28 print server.selectOptions(sessionID, [["secureToken",secureToken], ["outputFormat", "NetCDF"]]) 
    29 print "complete" 
     24 
     25print "\nds selected, var options..." 
     26print server.selectOptions(sessionID, [["secureToken",secureToken], ["dataset_1.1","Test Dataset 1"]]) 
     27 
     28print "\nvar selected, domain options..." 
     29print server.selectOptions(sessionID, [["secureToken",secureToken], ["variable_1.1.1","pqn"]]) 
     30 
     31print "\ndomain selected, format options..."  
     32print server.selectOptions(sessionID, [["secureToken",secureToken], ["axis_1.1.1.1",[[1999,1,1,0,0,0],[1999,1,1,0,0,0]]]]) 
     33 
     34print "\nformat selected, remaining options...?" 
     35print server.selectOptions(sessionID, [["secureToken",secureToken], ["outputFormat_1.1.1", "NetCDF"]]) 
     36print sessionID 
     37print "\ncomplete" 
    3038print server.isComplete(sessionID, secureToken) 
    31 print "output" 
     39 
     40print "\noutput" 
    3241x=server.createOutput(sessionID, secureToken) 
     42 
    3343print x 
    34 x=deUnicodeObject(x[0][0][0]) 
    35 print "Output file is:", x.replace(OUTPUT_DIR_URL_PATH, OUTPUT_DIR_LOCAL_PATH) 
     44x=deUnicodeObject(x[0][0][0][0][0]) 
    3645 
     46print "\n", x 
     47print "\nOutput file is:", x.replace(OUTPUT_DIR_URL_PATH, OUTPUT_DIR_LOCAL_PATH) 
     48 
  • TI03-DataExtractor/trunk/dxc/scripts/exampleCLClient2.py

    r794 r1109  
    33sys.path=sys.path+["..","scripts","../..",".", "../../pydxc"] 
    44 
    5 import readline 
     5#import readline 
    66from ZSI.client import Binding 
    7 from pydxc.clientConfig import SOAP_SERVER_PORT 
    87from pydxc.common import * 
     8from pydxc.clientConfig import SOAP_SERVER_URL 
     9# start session 
     10server = Binding(url=SOAP_SERVER_URL) 
     11(sessionID, secureToken)=server.startSession("jane", "jane1")[0] 
    912 
    10 # start session 
    11 server = Binding(url="", host="localhost", port=8406) 
    12 sessionID, secureToken=server.startSession("jane", "jane1") 
    1313server.getOptions(sessionID, secureToken) 
     14 
    1415print "dsg" 
    1516print server.selectOptions(sessionID, [["secureToken",secureToken], ["datasetGroup_1","Test Data Group 1"]]) 
     17 
    1618print "ds" 
    17 print server.selectOptions(sessionID, [["secureToken",secureToken], ["dataset_1","Test Dataset 1"]]) 
     19print server.selectOptions(sessionID, [["secureToken",secureToken], ["dataset_1.1","Test Dataset 1"]]) 
     20 
    1821print "v" 
    19 print server.selectOptions(sessionID, [["secureToken",secureToken], ["variable_1","pqn"]]) 
    20 print "horiz" 
    21 print server.selectOptions(sessionID, [["secureToken",secureToken], ["horizontalDomain",(90,0,0,90)]]) 
    22 print "vert" 
    23 print server.selectOptions(sessionID, [["secureToken",secureToken], ["verticalDomain_1",("Single level",)]]) 
    24 print "options" 
    25 print server.getOptions(sessionID, secureToken) 
    26 print "time"  
    27 print server.selectOptions(sessionID, [["secureToken",secureToken], ["temporalDomain_1",[[1999,1,1,0,0,0],[1999,1,1,0,0,0],[1., "hour"]]]]) 
     22print server.selectOptions(sessionID, [["secureToken",secureToken], ["variable_1.1.1","pqn"]]) 
     23 
     24print "domain" 
     25print server.selectOptions(sessionID, [["secureToken",secureToken],["axis_1.1.1.3",(0,90)], ["axis_1.1.1.2",(90,0)],  
     26                                        ["axis_1.1.1.1",[[1999,1,1,0,0,0],[1999,1,1,0,0,0]]]]) 
    2827print "format" 
    29 print server.selectOptions(sessionID, [["secureToken",secureToken], ["outputFormat", "NetCDF"]]) 
     28print server.selectOptions(sessionID, [["secureToken",secureToken], ["outputFormat_1.1.1", "NetCDF"]]) 
     29 
    3030print "complete" 
    3131print server.isComplete(sessionID, secureToken) 
     32 
     33 
    3234print "cost" 
    3335print server.getExtractionCosts(sessionID, secureToken) 
     36 
    3437print "output" 
    3538x=server.createOutput(sessionID, secureToken) 
     39 
    3640print x 
    37 x=deUnicodeObject(x[0][0][0]) 
     41x=deUnicodeObject(x[0][0][0][0][0]) 
    3842print "Output file is:", x.replace(OUTPUT_DIR_URL_PATH, OUTPUT_DIR_LOCAL_PATH) 
    3943 
  • TI03-DataExtractor/trunk/dxc/scripts/exampleCLClient3.py

    r794 r1109  
    33#sys.path=sys.path+["..","scripts","../..",".", "../../pydxc"] 
    44 
    5 print """GOT AS FAR AS DatasetGroup, Dataset and Variable selections.\n"""*50 
     5raise "THIS DOESN'T YET WORK!!!" 
    66 
    7 import readline 
     7#import readline 
    88from ZSI.client import Binding 
    9 from pydxc.clientConfig import SOAP_SERVER_PORT 
    109from pydxc.common import * 
     10from pydxc.clientConfig import SOAP_SERVER_URL 
    1111 
    1212 
     
    1717           
    1818# start session 
    19 server = Binding(url="", host="localhost", port=SOAP_SERVER_PORT) 
    20 sessionID, secureToken=server.startSession("jane", "jane1") 
     19server = Binding(url=SOAP_SERVER_URL) 
     20(sessionID, secureToken)=server.startSession("jane", "jane1")[0] 
    2121 
    2222choices=show(server.getDatasetGroupOptions(sessionID, secureToken)) 
    23 selection=choices[1][0][1][0] 
    24 print selection,"\n\n" 
     23selection=choices[0][0][0][0] 
     24print "\nSelection:", selection,"\n\n" 
    2525choices=show(server.makeDatasetGroupSelections(sessionID, secureToken, [selection])) 
    2626 
  • TI03-DataExtractor/trunk/dxs/bin/DXWSInterface.py

    r794 r1109  
    1010 
    1111A web service wrapper around the entire package. 
    12  
    13 Wraps the package functionality into the following Web Service methods: 
    14  
    15 - callControllerDirectly(args) 
    16  
    17 - startSession(username=None, password=None, secureToken=None) 
    18  
    19 - getOptions(sessionID, secureToken=None) 
    20  
    21 - selectOptions(sessionID, opt_1, opt_2, ...,opt_n, secureToken=None) 
    22  
    23 - isComplete(sessionID, secureToken=None) 
    24  
    25 - createOutput(sessionID, secureToken=None) 
    26  
    27 - newSession(sessionID, secureToken=None) 
    28  
    2912 
    3013Notes about the sessionID and secureToken object 
     
    4225time valid) and returned. 
    4326 
    44 All errors will be present in the instance object's self.error variable. Check for 
    45 this after each call to test success. 
    46  
    47 Notes on ZSI implementation. All objects needed to be wrapped in Python 
    48 lists in order to be returned to the client. Hence a tuple of 4,5 has to  
    49 be represented as [[4],[5]]. Not sure why... 
    50  
    51 ############# THE FOLLOWING MIGHT BE IMPLEMENTED IN FUTURE ############# 
    52 getDatasetGroupOptions(sessionID, secureToken=None) 
    53  
    54 selectDatasetGroups(sessionID, datasetGroup_1, datasetGroup_2, ..., datasetGroup_n, secureToken=None) 
    55  
    56 getDatasetOptions(sessionID, secureToken=None) 
    57  
    58 selectDatasets(sessionID, dataset_1, dataset_2, ..., dataset_n, secureToken=None) 
    59  
    60 getVariableOptions(sessionID, secureToken=None) 
    61  
    62 selectVariables(sessionID, variable_1, variable_2, ..., variable_n, secureToken=None) 
    63  
    64 getHorizontalDomainOptions(sessionID, secureToken=None) 
    65  
    66 selectHorizontalDomain(sessionID, northernExtent, westernExtent, 
    67        easternExtent, southernExtent, secureToken=None) 
    68         
    69 getVerticalDomainOptions(sessionID, secureToken=None) 
    70  
    71 selectVerticalDomain(sessionID, verticalDomain_1, verticalDomain_2, ...,  
    72                         verticalDomain_n, secureToken=None) 
    73                          
    74 getTemporalDomainOptions(sessionID, secureToken=None) 
    75  
    76 selectTemporalDomainOptions(sessionID, startTime_1, endTime_1, startTime_2, endTime_2, 
    77                                 ..., startTime_n, endTime_n, secureToken=None) 
    78                 # Note that times are expressed as: "YYYY-MM-DD hh:mm:ss" or minimally as "YYYY" 
    79                 # which convert to "YYYY-01-01 00:00:00". 
    80                  
    81 getOutputFormatOptions(sessionID, secureToken=None) 
    82  
    83 selectOutputFormat(sessionID, outputFormat, secureToken=None) 
    8427 
    8528""" 
     
    9942 
    10043# Set global variables 
    101 sessionID=None 
    10244timePattern=re.compile("(\d{4})-(\d{1,2})-(\d{1,2}).(\d{1,2}):(\d{1,2}):(\d{1,2}(\.\d+)?)") 
    10345 
     
    12971 
    13072 
    131 def startSession(username=None, password=None, secureToken=None): 
     73def startSession(username="undefined", password="undefined", secureToken="undefined"): 
    13274    """ 
    13375    Logs a user in and supplies them with a session ID as well 
     
    13678    authorise their access. 
    13779    """ 
    138     print "Method called: startSession\n" 
     80    print "\nMethod called: startSession\n" 
    13981    args={"username":username, "password":password, "secureToken":secureToken}   
    14082        
     
    14789    secureToken=controller.secureToken 
    14890    # Have to return list of lists for ZSI to work (?!) 
    149     return [[sessionID], [secureToken]] 
     91    print sessionID, secureToken 
     92    return [sessionID, secureToken] 
    15093         
    15194 
    152 def getOptions(sessionID, secureToken=None, optionCategoryRequested=None): 
     95def getOptions(sessionID, secureToken="undefined", optionCategoryRequested="undefined"): 
    15396    """ 
    15497    Returns a category description of the next set of options (or the option category  
     
    166109        OutputFormat 
    167110    """     
    168     print "Method called: getOptions\n" 
    169     print "ARGS: sessionID: %s\nsecureToken: %s, optionCategoryRequested:%s" % (sessionID,  
    170               secureToken, optionCategoryRequested) 
     111    print "\nMethod called: getOptions\n" 
     112    print "ARGS: sessionID: %s\nsecureToken: %s, optionCategoryRequested:%s" %        (sessionID, secureToken, optionCategoryRequested) 
    171113    if type(sessionID)==type(u""): 
    172         sessionID=str(sessionID) 
    173     args={"sessionID":sessionID, "secureToken":secureToken, "optionCategoryRequested":optionCategoryRequested} 
    174  
    175     try: 
    176         controller=DXController(args) 
    177     except Exception, error: 
    178         return str(error)        
    179  
     114        sessionID=deUnicodeObject(sessionID) 
     115         
     116    args={"sessionID":sessionID, "secureToken":secureToken,  
     117                "optionCategoryRequested":optionCategoryRequested} 
     118 
     119    try: 
     120        controller=DXController(args) 
     121    except Exception, error: 
     122        return str(error) 
     123   
    180124    optionsObject=controller.options 
    181  
    182     if optionsObject=={}: 
    183         print "All options selected..." 
    184         return  [["No category"],["All options selected"],["All options selected"],[secureToken]] 
    185  
    186     ndatasets=len(optionsObject.keys())     
    187     # Create a list of option Categories 
    188     optionCategories=[str(optionsObject[str(n)][0]) for n in range(1, ndatasets+1)]  
    189     # Create a list of option lists 
    190     # If options are lists then need to make l[0] the optionString and 
    191     # l[1] the option 
    192  
    193     options=[optionsObject[str(n)][1:] for n in range(1, ndatasets+1)] 
    194  
    195     options2=[] 
    196     count=0 
    197     for l in options: 
    198         options2.append([]) 
    199         for i in l: 
    200             options2[count].append(deUnicodeObject(i)) 
    201         count=count+1 
    202    
    203     options=options2 
    204     optionStrings=options 
    205     if len(optionCategories)>0: 
    206         optcat0=optionCategories[0].split("_")[0] 
    207  
    208         if optcat0=="horizontalDomain" or optcat0=="outputFormat": 
    209             options=options[0][0] 
    210         elif optcat0 in ("dataset", "verticalDomain", "temporalDomain"): 
    211             newOpts=[] 
    212             optionStrings=[] 
    213             for opt in options: 
    214                 if type(opt[0][0])==type([]) and optcat0!="temporalDomain": 
    215                     newOpts.append([opt[0][0][1]]) 
    216                     optionStrings.append([opt[0][0][0]]) 
    217                 else: 
    218                     newOpts.append(opt[0]) 
    219                     optionStrings.append(opt[0]) 
    220  
    221             options=newOpts 
    222              
    223         elif optcat0=="datasetGroup": 
    224             # Need to sort out the metadata links sent as [longName, [detailedMetadataLink, discoveryMetadataLink]] 
    225             newOpts=[] 
    226             optionStrings=[] 
    227             for n in range(len(options)): 
    228                 newOpts.append([]) 
    229                 optionStrings.append([]) 
    230                                  
    231             for opt in options[0]: 
    232                 for i in opt:                
    233                     newOpts[options[0].index(opt)].append(i) 
    234                     optionStrings[options[0].index(opt)].append(i[0]) 
    235                      
    236             optionStringsMulti=[] 
    237             optionsMulti=[] 
    238             for n in range(len(options)): 
    239                 optionStringsMulti.append(optionStrings[0]) 
    240                 optionsMulti.append(newOpts[0]) 
    241                  
    242             optionStrings=optionStringsMulti 
    243             options=optionsMulti             
    244  
    245         elif optcat0=="variable": 
    246             newOpts=[] 
    247             optionStrings=[] 
    248             for n in range(len(options)): 
    249                 newOpts.append([]) 
    250                 optionStrings.append([]) 
    251                                  
    252             """for opt in options: 
    253                 for i in opt[0]: 
    254                     newOpts[options.index(opt)].append(i[1]) 
    255                     optionStrings[options.index(opt)].append(i[0]) 
    256          
    257             options=newOpts""" 
    258              
    259             counter=0 
    260             for opt in options: 
    261                 #print "opt:%s\n" % opt 
    262                 for i in opt[0]: 
    263                     #print "i:",i,"\n" 
    264                     newOpts[counter].append(i[1]) 
    265                     #print "newOpts:", newOpts, "\n" 
    266                     optionStrings[counter].append(i[0]) 
    267                 counter=counter+1 
    268              
    269             options=newOpts                  
    270               
    271     print "\nOPTIONS\n==========\n", options, "\n", "OPTIONSTRINGS:\n=================\n", optionStrings, "\nOPTIONCATS:\n================\n",  optionCategories 
    272  
    273     secureToken=controller.secureToken     
    274      
    275     # Returns the optionCategories as the first item for each dataset in order 
    276     # and a list of lists of options for the corresponding categories as the  
    277     # second item in the tuple.  
    278     return [[optionCategories], [options], [optionStrings], [secureToken]]    
     125    secureToken=controller.secureToken 
     126    print "Options object:", optionsObject 
     127 
     128    summaryString=createSummaryString(controller.bag) 
     129 
     130    return [[optionsObject+[summaryString]+[secureToken]]] 
    279131 
    280132 
     
    286138    user. Alternatively, if it fails, an errorString is returned.  
    287139    """ 
    288     print "Method called: selectOptions\n"     
    289     args={} 
     140    print "\nMethod called: selectOptions\n"     
     141    if type(sessionID)==type(u""): 
     142        sessionID=deUnicodeObject(sessionID) 
     143    args={"sessionID":sessionID} 
     144     
     145    print "Key, Value..." 
    290146    for key,value in argList: 
    291147        key=deUnicodeObject(key) 
     
    299155        args[newkey]=value    
    300156        print newkey, value 
    301               
    302     try: 
    303         args["sessionID"]=sessionID 
    304          
    305         if args.has_key("horizontalDomain"): 
    306             for hkey in HORIZ_KEYS: 
    307                 args[hkey]=args["horizontalDomain"][HORIZ_KEYS.index(hkey)] 
    308             del args["horizontalDomain"] 
    309          
    310         # Step through as many datasets as the user is choosing 
    311         for n in range(1, MAX_NUM_DATASETS+1): 
    312             if args.has_key("temporalDomain_%s" % n): 
    313                 temp=args["temporalDomain_%s" % n] 
    314                  
    315                 if type(temp[0]) in (types.TupleType, types.ListType, types.InstanceType): 
    316                     startTimeList=temp[0] 
    317                     endTimeList=temp[1]      
    318                     print  
    319                 elif type(temp[0])==types.StringType: 
    320                     startTimeList=[int(i) for i in timePattern.match(temp[0]).groups()[0:6]] 
    321                     endTimeList=[int(i) for i in timePattern.match(temp[1]).groups()[0:6]] 
    322  
    323                 else: 
    324                     raise "Could not identify temporalDomain argument: "+str(temp)    
    325  
    326                 startTimeString="%.4d-%.2d-%.2dT%.2d:%.2d:%.2f" % tuple(startTimeList) 
    327                 endTimeString="%.4d-%.2d-%.2dT%.2d:%.2d:%.2f" % tuple(endTimeList)    
    328                  
    329                 timeDict={"startTime":startTimeString, "endTime":endTimeString}                        
    330                 args["startDateTime_%s" % n]=timeDict["startTime"] 
    331                 args["endDateTime_%s" % n]=timeDict["endTime"] 
    332                 args["timeIntervalValue_%s" % n]=temp[2][0] 
    333                 args["timeIntervalUnits_%s" % n]=temp[2][1] 
    334                 del args["temporalDomain_%s" % n] 
    335                  
    336             elif args.has_key("verticalDomain_%s" % n): 
    337                 vert=args["verticalDomain_%s" % n] 
    338                 if type(vert) in (types.ListType, types.TupleType) and len(vert)==1: 
    339                         args["verticalDomain_%s" % n]=(vert[0],) 
    340                 else: 
    341                         args["verticalDomain_%s" % n]=vert 
    342          
    343         try: 
    344             controller=DXController(args) 
    345         except Exception, error: 
    346             return str(error) 
    347  
    348         secureToken=controller.secureToken       
    349         if args.has_key("optionCategoryRequested"): 
    350             optionCategoryRequested=args["optionCategoryRequested"] 
    351         else: 
    352             optionCategoryRequested=None 
    353  
    354         opts=getOptions(sessionID, secureToken, optionCategoryRequested) 
    355         return opts 
    356  
    357     except: 
    358         return ("ERROR: Could not make the selection you required.\n"+str(sys.exc_type), secureToken) 
    359         
    360      
    361 def isComplete(sessionID, secureToken=None): 
    362     """print  
     157 
     158    try: 
     159        controller=DXController(args) 
     160    except Exception, error: 
     161        return str(error) 
     162     
     163    optionsObject=controller.options 
     164    secureToken=controller.secureToken 
     165    print "Options object:", optionsObject 
     166 
     167    summaryString=createSummaryString(controller.bag) 
     168 
     169    return [[optionsObject+[summaryString]+[secureToken]]] 
     170    """secureToken=controller.secureToken        
     171     
     172    if args.has_key("optionCategoryRequested"): 
     173        optionCategoryRequested=args["optionCategoryRequested"] 
     174    else: 
     175        optionCategoryRequested="undefined" 
     176 
     177    opts=getOptions(sessionID, secureToken, optionCategoryRequested) 
     178    print "\n\nReturned from select options:\n", opts, "\n\n" 
     179    return opts""" 
     180  
     181     
     182def isComplete(sessionID, secureToken="undefined"): 
     183    """ 
    363184    Returns 1 if the request is complete (i.e. ready to create output file(s)) 
    364185    and 0 if not. Also returns a security token. 
    365186    """ 
    366     print "Method called: isComplete\n" 
     187    print "\nMethod called: isComplete\n" 
    367188    optionsObject=getOptions(sessionID, secureToken) 
    368     optionCategories=optionsObject[0][0] 
    369     secureToken=optionsObject[3][0] 
    370  
    371     if optionCategories=="No category": 
    372         return [[1], [secureToken]] 
     189    secureToken=optionsObject[-1] 
     190    if optionsObject==[secureToken]: 
     191        return [[1], secureToken] 
    373192    else: 
    374         return [[0], [secureToken]] 
    375      
    376  
    377 def createOutput(sessionID, secureToken=None): 
     193        return [[0], secureToken]  
     194     
     195 
     196def createOutput(sessionID, secureToken="undefined"): 
    378197    """ 
    379198    Creates the outputs specified by user selections. It writes these files 
     
    382201    Returns a list of paths and a security token. 
    383202    """ 
    384     print "Method called: createOutput\n" 
     203    print "\nMethod called: createOutput\n" 
    385204    args={"sessionID":sessionID, "secureToken":secureToken, "getOutput":"getOutput"} 
    386205      
     
    396215 
    397216 
    398 def newSession(sessionID, secureToken=None): 
     217def newSession(sessionID, secureToken="undefined"): 
    399218    """ 
    400219    Deletes content of current request. 
    401220    Returns the sessionID and the security token.. 
    402221    """ 
    403     print "Method called: newSession\n"     
     222    print "\nMethod called: newSession\n"     
    404223    args={"sessionID":sessionID, "secureToken":secureToken, "clearSession":"clearSession"} 
    405224      
     
    413232 
    414233 
    415 def setNumberOfDatasets(sessionID, n, secureToken=None): 
     234def setNumberOfDatasets(sessionID, n, secureToken="undefined"): 
    416235    """ 
    417236    Re-selects the number of datasets the user wants to deal with in the request. 
     
    419238    Returns 1 if successful and an errorString if not, as well as a security token. 
    420239    """ 
    421     print "Method called: setNumberOfDatasets\n" 
     240    print "\nMethod called: setNumberOfDatasets\n" 
    422241     
    423242    args={"sessionID":sessionID, "numberOfDatasets":n, "secureToken":secureToken} 
     
    432251         
    433252         
    434 def summariseRequest(sessionID, secureToken=None): 
     253def summariseRequest(sessionID, secureToken="undefined"): 
    435254    """ 
    436255    Returns a listing of the current request in a string and a security token. 
    437256    """     
    438     print "Method called: summariseRequest\n" 
     257    print "\nMethod called: summariseRequest\n" 
    439258    args={"sessionID":sessionID, "secureToken":secureToken} 
    440259    
     
    445264 
    446265    req=controller.bag 
    447     from pydxs.RequestSizer import RequestSizer 
    448     try: 
    449         sizer=RequestSizer(req) 
    450         req["numberOfDataPoints"]=sizer.npoints 
    451         req["sizeInBytes"]=sizer.size 
    452     except: 
    453         pass 
    454266     
    455267    summaryString="\n"+"*"*40 
    456268    summaryString=summaryString+"\nSummary of current request follows\n" 
    457269    summaryString=summaryString+"*"*40+"\n\n"  
    458     orderedSortedKeys=[] 
    459  
    460     keybins=[[]]*(MAX_NUM_DATASETS+1) 
    461     for key in req.keys(): 
    462         if key[0]=="_": continue 
    463         items=key.split("_") 
    464         if len(items)==1:  keybins[0].append(key) 
    465          
    466     for key in req.keys(): 
    467         if key[0]=="_": continue 
    468         items=key.split("_") 
    469         if len(items)==2: 
    470             keybins[int(items[1])].append(key) 
    471                  
    472     for n in range(0, MAX_NUM_DATASETS+1): 
    473         keylist=keybins[n] 
    474         keylist.sort() 
    475         orderedSortedKeys=orderedSortedKeys+keylist 
    476270     
    477271    exclusions=("callMethod", "secureToken", "optionCategoryRequested",  
    478272                "action", "targetPage") 
    479     for key in keylist: 
    480         if req[key]!="" and key not in exclusions:  summaryString=summaryString+("%s:\t%s\n" % (key, req[key])) 
     273                 
     274    for key in req.keys(): 
     275        if req[key]!="" and key not in exclusions:   
     276            summaryString=summaryString+("%s:\t%s\n" % (key, req[key])) 
    481277 
    482278    secureToken=controller.secureToken   
     
    484280       
    485281 
    486 def uploadRequest(sessionID, requestXMLString, secureToken=None): 
     282def uploadRequest(sessionID, requestXMLString, secureToken="undefined"): 
    487283    """ 
    488284    Allows the user to send a request in the form of a string containing the  
     
    513309 
    514310 
    515 def getDataSubsetSpecifier(sessionID, secureToken=None): 
     311def getDataSubsetSpecifier(sessionID, secureToken="undefined"): 
    516312    """ 
    517313    Returns the dataSubsetSpecifier XML document (which might be S-metadata) 
     
    519315    security token. 
    520316    """ 
    521     print "Method called: getDataSubsetSpecifier\n" 
     317    print "\nMethod called: getDataSubsetSpecifier\n" 
    522318    args={"sessionID":sessionID, "secureToken":secureToken} 
    523319     
     
    539335 
    540336 
    541 def getExtractionCosts(sessionID, secureToken=None): 
     337def getExtractionCosts(sessionID, secureToken="undefined"): 
    542338    """ 
    543339    Returns an estimated duration for the creation of the output data and the  
    544340    estimated volume of the output. 
    545341    """ 
    546     print "Method called: getExtractionCosts\n"     
     342    print "\nMethod called: getExtractionCosts\n"     
    547343    args={"sessionID":sessionID, "secureToken":secureToken, "action":"requestCosts"} 
    548344     
     
    551347    except Exception, error: 
    552348        return str(error)    
    553  
    554349             
    555350    secureToken=controller.secureToken 
     351    print "ESTIMATED COSTS:", (controller.estimatedDuration, controller.estimatedVolume)  
    556352    (estimatedDuration, estimatedVolume)=(controller.estimatedDuration, controller.estimatedVolume) 
    557     print "Returning...", [[estimatedDuration], [estimatedVolume], [secureToken]] 
    558     return [[estimatedDuration], [estimatedVolume], [secureToken]]        
    559  
    560  
    561 ####def getOptions(sessionID, secureToken=None, optionCategoryRequested=None): 
    562     """ 
    563     Returns a category description of the next set of options (or the option category  
    564     requested by the user), a list of options based  
    565     on what the user has yet to request, a string explaining some more about this and a 
    566     security token. 
    567      
    568     The options will be presented following the heirarchy: 
    569         DatasetGroups 
    570         Datasets 
    571         Variables 
    572         HorizontalDomain 
    573         VerticalDomain 
    574         TemporalDomain 
    575         OutputFormat 
    576     """     
    577  
    578 def getDatasetGroupOptions(sessionID, secureToken=None): 
     353    print "Returning...", [estimatedDuration, estimatedVolume, secureToken] 
     354    return [estimatedDuration, estimatedVolume, secureToken]        
     355 
     356 
     357def getDatasetGroupOptions(sessionID, secureToken="undefined"): 
    579358    """ 
    580359    Get the dataset group options available. 
    581360    """ 
    582     print "Method called: getDatasetGroupOptions\n\n" 
    583     return getOptions(sessionID, secureToken=None, optionCategoryRequested="datasetGroup") 
    584      
     361    print "\nMethod called: getDatasetGroupOptions\n\n" 
     362    return getOptions(sessionID, secureToken="undefined", optionCategoryRequested="datasetGroup") 
     363     
     364 
    585365def makeDatasetGroupSelections(sessionID, secureToken, datasetGroupList): 
     366    """ 
     367    Make selections for dataset group. 
     368    """ 
    586369    print "Called: makeDatasetGroupSelections\n" 
    587370    argList=[] 
     
    594377    return selectOptions(sessionID, argList) 
    595378 
    596 def getDatasetOptions(sessionID, secureToken=None): 
     379 
     380def getDatasetOptions(sessionID, secureToken="undefined"): 
    597381    """ 
    598382    Get the dataset options available. 
    599383    """ 
    600     print "Method called: getDatasetOptions\n\n" 
    601     return getOptions(sessionID, secureToken=None, optionCategoryRequested="dataset") 
     384    print "\nMethod called: getDatasetOptions\n\n" 
     385    return getOptions(sessionID, secureToken="undefined", optionCategoryRequested="dataset") 
     386     
    602387     
    603388def makeDatasetSelections(sessionID, secureToken, datasetList): 
     389    """ 
     390    Make selections for Dataset. 
     391    """ 
    604392    print "Called: makeDatasetSelections\n" 
    605393    argList=[] 
     
    612400    return selectOptions(sessionID, argList) 
    613401 
    614 def getVariableOptions(sessionID, secureToken=None): 
     402 
     403def getVariableOptions(sessionID, secureToken="undefined"): 
    615404    """ 
    616405    Get the variable options available. 
    617406    """ 
    618     print "Method called: getVariableOptions\n\n" 
    619     return getOptions(sessionID, secureToken=None, optionCategoryRequested="variable") 
     407    print "\nMethod called: getVariableOptions\n\n" 
     408    return getOptions(sessionID, secureToken="undefined", optionCategoryRequested="variable") 
     409     
    620410     
    621411def makeVariableSelections(sessionID, secureToken, variableList): 
     412    """ 
     413    Make selections for variables. 
     414    """ 
    622415    print "Called: makeVariableSelections\n" 
    623416    argList=[] 
     
    640433    portNumber=SOAP_SERVER_PORT 
    641434    print "Serving Web Service on port: %s" % portNumber     
    642     dispatch.AsServer(port=portNumber)    
    643  
    644  
    645  
     435    dispatch.AsServer(port=portNumber, rpc=True)    
  • TI03-DataExtractor/trunk/dxs/datasets/inputDatasets.xml

    r794 r1109  
    5656                                                 
    5757            <documentationLink> 
    58                                 none             
     58                                undefined             
    5959            </documentationLink> 
    6060                                         
     
    108108                                                                 
    109109                <detailedMetadataLink> 
    110                                         none                 
     110                                        undefined                 
    111111                </detailedMetadataLink> 
    112112                                                                 
     
    114114                                                                 
    115115                <discoveryMetadataLink> 
    116                                         none                 
     116                                        undefined                 
    117117                </discoveryMetadataLink> 
    118118                                                                 
     
    124124                                                                 
    125125                <documentationLink> 
    126                                         none                 
     126                                        undefined                 
    127127                </documentationLink> 
    128128                                                         
     
    178178                                                 
    179179            <detailedMetadataLink> 
    180                                 none             
     180                                undefined             
    181181            </detailedMetadataLink> 
    182182                                                 
     
    184184                                                 
    185185            <discoveryMetadataLink> 
    186                                 none             
     186                                undefined             
    187187            </discoveryMetadataLink> 
    188188                                                 
     
    190190                                                 
    191191            <usageMetadataLink> 
    192                                 none             
     192                                undefined             
    193193            </usageMetadataLink> 
    194194                                                 
    195195            <documentationLink> 
    196                                 none             
     196                                undefined             
    197197            </documentationLink> 
    198198                                         
     
    246246                                                                 
    247247                <detailedMetadataLink> 
    248                                         none                 
     248                                        undefined                 
    249249                </detailedMetadataLink> 
    250250                                                                 
     
    252252                                                                 
    253253                <discoveryMetadataLink> 
    254                                         none                 
     254                                        undefined                 
    255255                </discoveryMetadataLink> 
    256256                                                                 
     
    262262                                                                 
    263263                <documentationLink> 
    264                                         none                 
     264                                        undefined                 
    265265                </documentationLink> 
    266266                                                         
     
    316316                                                 
    317317            <detailedMetadataLink> 
    318                                 none             
     318                                undefined             
    319319            </detailedMetadataLink> 
    320320                                                 
     
    322322                                                 
    323323            <discoveryMetadataLink> 
    324                                 none             
     324                                undefined             
    325325            </discoveryMetadataLink> 
    326326                                                 
     
    328328                                                 
    329329            <usageMetadataLink> 
    330                                 none             
     330                                undefined             
    331331            </usageMetadataLink> 
    332332                                                 
    333333            <documentationLink> 
    334                                 none             
     334                                undefined             
    335335            </documentationLink> 
    336336                                         
     
    384384                                                                 
    385385                <detailedMetadataLink> 
    386                                         none                 
     386                                        undefined                 
    387387                </detailedMetadataLink> 
    388388                                                                 
     
    390390                                                                 
    391391                <discoveryMetadataLink> 
    392                                         none                 
     392                                        undefined                 
    393393                </discoveryMetadataLink> 
    394394                                                                 
     
    400400                                                                 
    401401                <documentationLink> 
    402                                         none                 
     402                                        undefined                 
    403403                </documentationLink> 
    404404                                                         
  • TI03-DataExtractor/trunk/install.conf

    r794 r1109  
    5252 
    5353[dxc] 
    54 # SOAP_SERVER_NAME: 
    55 # URL of server. If client and server running lcoally  
    56 # you can use "localhost". 
    57 SOAP_SERVER_NAME="PLEASE_REPLACE_ME" 
     54# SOAP_SERVER_URL: 
     55# URL to Web Service of the form: "http://<host>:<port>/<script> 
     56SOAP_SERVER_URL="PLEASE_REPLACE_ME" 
    5857 
    5958# BASEDIR: 
  • TI03-DataExtractor/trunk/install.sh

    r794 r1109  
    1515cd pydxs-${v} 
    1616 
    17 python setup.py install 
     17python setup.py install --overwrite 
    1818 
    1919 
  • TI03-DataExtractor/trunk/pydxc/DisplayManager.py

    r794 r1109  
    151151 
    152152                 
    153     def _displayOptionsTable(self, optionCategories, options, optionStrings, sessionID, sessionObj): 
    154         """ 
    155         Prints the options provided in the format (optionCategory, [option1, 
     153    def _displayOptionsTable(self, summaryDict, optionCategories, options, optionStrings, sessionID, sessionObj): 
     154        """ 
     155        Displays the options provided in the format (optionCategory, [option1, 
    156156        option2, .., optionN]). Each dataset has these. It also sends the  
    157157        sessionID as a hidden variable. 
    158158        """      
    159         #raise str(options)+"<P>"+str(optionStrings) 
    160 #        print '<TD WIDTH="90%" class="tablestyle" VALIGN="top">'  
    161  
    162159        # Get the category name to show on the  
    163160        itemMap={"datasetGroup":"Dataset Group", "dataset":"Dataset", 
    164161                 "variable":"Variable"}  
    165 #       print "<P><B>PLEASE SELECT: %s</B><P>" % itemMap[optionCategories[0].split("_")[0]] 
    166162         
    167163        if len(options)==0: 
     
    174170             
    175171        # Now loop through getting the appropriate list of values to show        
    176         for dsetNumber in range(1, self.numberOfDatasets+1): 
     172        """ 
     173        for dsetNumber in range(1, self.numberOfDatasets+1): 
    177174            selectedFlag=None 
    178175            tableWidth=100/(self.numberOfDatasets) 
     
    226223                        print '<BR><INPUT TYPE="radio" NAME="%s" VALUE="%s">%s</INPUT>' % (radioName, option, optionString)      
    227224                          
    228         print "</TD>" 
     225        print "</TD>" """ 
     226         
     227        itemTitle=itemMap[optionCategories[0].split("_")[0]] 
     228        print "<P><B>PLEASE SELECT: %s</B><P>" % itemTitle  
     229         
     230        if itemTitle=="Dataset Group": 
     231                # Need to wade through metadata links to deal with this one... 
     232                selectionIDs=optionCategories 
     233                datasetGroupValues=[i[0] for i in options] 
     234                datasetGroupNames=[i[0] for i in optionStrings] 
     235                detailedMetadataLinks=[i[1][0] for i in options] 
     236                discoveryMetadataLinks=[i[1][1] for i in options] 
     237 
     238                selectedFlag=None                   
     239                for i in range(len(selectionIDs)): 
     240                    selectionID=selectionIDs[i] 
     241                    datasetGroupValue=datasetGroupValues[i] 
     242                    datasetGroupName=datasetGroupNames[i] 
     243                    detailedMetadataLink=detailedMetadataLinks[i] 
     244                    discoveryMetadataLink=discoveryMetadataLinks[i]      
     245                             
     246                    if not selectedFlag: 
     247                        print '<BR><INPUT TYPE="checkBox" NAME="%s" VALUE="%s" CHECKED>%s</INPUT>' % (selectionID, datasetGroupName, datasetGroupValue)                  
     248                        selectedFlag=1 
     249                    else: 
     250                        print '<BR><INPUT TYPE="checkBox" NAME="%s" VALUE="%s">%s</INPUT>' % (selectionID, datasetGroupName, datasetGroupValue)                      
     251 
     252                    if detailedMetadataLink.lower()!="undefined": 
     253                        print '&nbsp;<A HREF="%s">[ Detailed Metadata ]</A>' % detailedMetadataLink 
     254                    if discoveryMetadataLink.lower()!="undefined": 
     255                        print '&nbsp;<A HREF="%s">[ Discovery Metadata ]</A>' % discoveryMetadataLink 
     256 
     257        elif itemTitle=="Dataset": 
     258                selectionIDs=optionCategories 
     259                itemValues=options 
     260                itemNames=optionStrings 
     261                selectedFlag=None  
     262                 
     263                lastDatasetGroup="WON'T MATCH"              
     264                for i in range(len(selectionIDs)): 
     265                    selectionID=selectionIDs[i] 
     266                    itemName=itemNames[i] 
     267                    itemValue=itemValues[i] 
     268                     
     269                    dsgKey=re.match("dataset_(\d+)\.", selectionID).groups()[0] 
     270                    datasetGroup=summaryDict["datasetGroups"][dsgKey] 
     271                    if datasetGroup!=lastDatasetGroup: 
     272                        print """<BR><B>%s -&gt; Dataset selection:</B>""" % datasetGroup            
     273 
     274                    if not selectedFlag: 
     275                        print '<BR><INPUT TYPE="checkBox" NAME="%s" VALUE="%s" CHECKED>%s</INPUT>' % (selectionID, itemName, itemValue)                  
     276                        selectedFlag=1 
     277                    else: 
     278                        print '<BR><INPUT TYPE="checkBox" NAME="%s" VALUE="%s">%s</INPUT>' % (selectionID, itemName, itemValue)                      
     279                 
     280                    lastDatasetGroup=datasetGroup        
     281                         
     282 
     283        elif itemTitle=="Variable": 
     284                selectionIDs=optionCategories 
     285                itemValues=[i[0] for i in options] 
     286                itemNames=[i[1] for i in optionStrings] 
     287                selectedFlag=None  
     288                 
     289                lastDataset="WON'T MATCH" 
     290                lastDatasetGroup="WON'T MATCH"              
     291                for i in range(len(selectionIDs)): 
     292                    selectionID=selectionIDs[i] 
     293                    itemName=itemNames[i] 
     294                    itemValue=itemValues[i] 
     295 
     296                    (dsgKey, dsKey)=re.match("variable_(\d+)\.(\d+)\.", selectionID).groups() 
     297                    datasetGroup=summaryDict["datasetGroups"][dsgKey] 
     298                    dataset=summaryDict["datasets"]["%s.%s" % (dsgKey, dsKey)] 
     299                    if dataset!=lastDataset or lastDatasetGroup!=datasetGroup: 
     300                        print """<BR><B>%s -&gt; %s -&gt; Variable selection:</B>""" % (datasetGroup, dataset) 
     301 
     302                    if not selectedFlag: 
     303                        print '<BR><INPUT TYPE="checkBox" NAME="%s" VALUE="%s" CHECKED>%s</INPUT>' % (selectionID, itemName, itemValue)                  
     304                        selectedFlag=1 
     305                    else: 
     306                        print '<BR><INPUT TYPE="checkBox" NAME="%s" VALUE="%s">%s</INPUT>' % (selectionID, itemName, itemValue)                      
     307                     
     308                    lastDataset=dataset  
     309                    lastDatasetGroup=datasetGroup            
    229310             
     311    def _displayDomainOptions(self, summaryDict, optionCategories, options, optionStrings, sessionID): 
     312        """ 
     313        Displays the domain options for each variable. 
     314        """      
     315        print "<P><B>PLEASE SELECT: Domain options</B><P>"       
     316        print "<TABLE>" 
     317        print """<TR CLASS="tablestyle"> 
     318                        <TD><B>AXIS NAME</B></TD> 
     319                        <TD><B>AXIS ID</B></TD> 
     320                        <TD><B>RECOGNISED AS</B></TD> 
     321                        <TD><B>UNITS</B></TD> 
     322                        <TD COLSPAN="3"><B>SELECTION</B></TD> 
     323                        <TD><B>INFORMATION</B></TD></TR>""" 
     324         
     325        # Predefine what we need for the axis selection in terms of interfaces... 
     326        knownAxisDict={} 
     327                 
     328        # Loop through keys to get the number of variables 
     329        axisDict={} 
     330        for i in range(len(optionCategories)): 
     331            optionName=optionCategories[i] 
     332            varIndex=".".join(optionName.split(".")[:-1])[5:] 
     333            axisIndex=int(optionName.split(".")[-1]) 
     334            items=options[i] 
     335            [knownAxis, id, longName, units, listType, unused]=items[:6]         
     336             
     337            if not axisDict.has_key(varIndex): 
     338                axisDict[varIndex]={"axes":[]} 
     339            if knownAxis in ("time", "latitude", "longitude"): 
     340                axisDict[varIndex][knownAxis]=axisIndex 
     341             
     342            axisDict[varIndex]["axes"].append([optionName, items]) 
     343               
     344        axisDictKeys=axisDict.keys() 
     345        axisDictKeys.sort() 
     346        #print axisDictKeys 
     347         
     348        for key in axisDictKeys: 
     349 
     350            varID=summaryDict["variables"][key] 
     351            dsgKey, dsKey=re.match("(\d+)\.(\d+)", key).groups() 
     352            datasetGroup=summaryDict["datasetGroups"][dsgKey] 
     353            dataset=summaryDict["datasets"]["%s.%s" % (dsgKey, dsKey)] 
     354            print """<TR><TD COLSPAN="8">&nbsp;</TD></TR>"""     
     355            print """<TR CLASS="tablestyle"><TD COLSPAN="8"><B>%s -&gt; %s -&gt; %s</TD></TR>""" % (datasetGroup, dataset, varID)            
     356         
     357            d=axisDict[key] 
     358            axes=d["axes"] 
     359             
     360            found={} 
     361            # Check time, lat and lon 
     362            for ax in ("time", "latitude", "longitude"): 
     363                if d.has_key(ax): 
     364                    found[ax]=d[ax] 
     365             
     366            for axis in axes: 
     367                (optionName, items)=axis 
     368                varIndex=".".join(optionName.split(".")[:-1])[5:] 
     369                axisIndex=int(optionName.split(".")[-1]) 
     370                #items=options[i] 
     371                [knownAxis, id, longName, units, listType, unused]=items[:6] 
     372 
     373                if (found.has_key("latitude") and found.has_key("longitude")) and \ 
     374                        axisIndex in (found["latitude"], found["longitude"]): 
     375                 
     376                    if found.has_key("used lat lon"):  continue 
     377                 
     378                    if axisIndex==found["latitude"]: 
     379                        # The current axis is latitude so need to get longitude 
     380                        latItems=items           
     381                        latOptionName=optionName         
     382                        lonIndex=found["longitude"] 
     383                         
     384                        for x in axes: 
     385                            if int(x[0].split(".")[-1])==lonIndex: 
     386                                # Found longitude axis in list 
     387                                (lonOptionName, lonItems)=x                      
     388                         
     389                    elif axisIndex==found["longitude"]: 
     390                        # The current axis is longitude so need to get latitude 
     391                        lonItems=items 
     392                        lonOptionName=optionName                         
     393                        latIndex=found["latitude"] 
     394                         
     395                        for x in axes: 
     396                            if int(x[0].split(".")[-1])==latIndex: 
     397                                # Found latitude axis in list 
     398                                (latOptionName, latItems)=x              
     399                                                                 
     400                    [latKnownAxis, latId, latLongName, latUnits, latListType, latUnused]=latItems[:6] 
     401                    northernExtent, southernExtent=latItems[6:8] 
     402                    [lonKnownAxis, lonId, lonLongName, lonUnits, lonListType, lonUnused]=lonItems[:6] 
     403                    westernExtent, easternExtent=lonItems[6:8] 
     404     
     405                    found["used lat lon"]=1 
     406                      
     407                    #print '<B>Horizontal Domain</B><P>' 
     408                      
     409                    print """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     410                     <TD WIDTH="30%%">%s</TD> 
     411                     <TD>%s</TD> 
     412                     <TD>%s</TD> 
     413                     <TD></TD>                                
     414                     <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     415                     <TD><B></B></TD> 
     416                     </TR>""" % (latLongName, latOptionName, latKnownAxis, latUnits,  
     417                                   latOptionName+"_high", northernExtent)   
     418                                                                              
     419                    print """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     420                     <TD WIDTH="30%%">%s</TD> 
     421                     <TD>%s</TD> 
     422                     <TD>%s</TD>                      
     423                     <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     424                     <TD><TABLE BORDER="0"><TR><TD ALIGN="LEFT">&nbsp;<B></B></TD><TD ALIGN="RIGHT"><B></B>&nbsp;</TD></TR></TABLE></TD>                      
     425                     <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     426                     </TR>""" % (lonLongName, lonOptionName, lonKnownAxis, lonUnits,  
     427                                   lonOptionName+"_low", westernExtent, lonOptionName+"_high", 
     428                                   easternExtent)   
     429                                                     
     430                    print """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     431                     <TD WIDTH="30%%">%s</TD> 
     432                     <TD>%s</TD> 
     433                     <TD>%s</TD>                      
     434                     <TD></TD>                                
     435                     <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     436                     <TD><B>&nbsp;</B></TD> 
     437                     </TR>""" % ("","","","",  
     438                                   latOptionName+"_low", southernExtent)                     
     439 
     440                elif found.has_key("time") and axisIndex==found["time"]: 
     441                    (start,end,intervalValue)=items[6:9] 
     442                    print """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     443                     <TD WIDTH="30%%">%s</TD> 
     444                     <TD>%s</TD> 
     445                     <TD>%s</TD>""" % (longName, optionName, knownAxis, units) 
     446 
     447                    self._displayTemporalDomainMenus(start, end, intervalValue, units, optionName) 
     448                              
     449                    """<TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     450                     <TD><TABLE BORDER="0"><TR><TD ALIGN="LEFT">&nbsp;<B>Low</B></TD><TD ALIGN="RIGHT"><B>High</B>&nbsp;</TD></TR></TABLE></TD>                       
     451                     <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     452                     </TR>""" % (optionName+"_low", start, optionName+"_high", end)    
     453                           
     454                else: 
     455                    start,end=items[6:8] 
     456                    print """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     457                     <TD WIDTH="30%%">%s</TD> 
     458                     <TD>%s</TD> 
     459                     <TD>%s</TD>                      
     460                     <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     461                     <TD><TABLE BORDER="0"><TR><TD ALIGN="LEFT">&lt;&nbsp;<B>Low</B></TD><TD ALIGN="RIGHT"><B>High</B>&nbsp;&gt;</TD></TR></TABLE></TD>               
     462                     <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
     463                     </TR>""" % (longName, optionName, knownAxis, units,  
     464                     optionName+"_low", start, optionName+"_high", end)    
     465 
     466            # Fudge output format for now 
     467            print """<TR><TD WIDTH="20%%"><B>OUTPUT FORMAT</B></TD>""" 
     468            print """<TD COLSPAN="4">Note that you should choose NetCDF format if you wish to visualise data.</TD>"""                 
     469            print '<TD COLSPAN="3"><SELECT NAME="outputFormat_%s">' % key 
     470            for format in ("NetCDF", "NASA Ames"): 
     471                print "<OPTION>%s</OPTION>" % format 
     472            print "</SELECT></TD>" 
     473                      
     474        print "</TABLE>" 
     475 
     476        print """<P><INPUT TYPE="checkbox" NAME="multipleFileOutput"> 
     477               &nbsp;Use multiple output files [ this is the default large files as limited by the server ].""" 
     478                
    230479 
    231480    def _displayUploadForm(self, sessionID): 
     
    435684        print "</TR></TABLE>" 
    436685 
    437          
    438     def _displayTemporalDomainOptions(self, options): 
     686 
     687    def _displayTemporalDomainMenus(self, startTime, endTime, intervalValue, intervalUnits, axisIndex): 
     688        """ 
     689        Displays a set of menus for entering the date and time limits for this axis. 
     690        """   
     691        startTime=getDateTimeComponents(startTime) 
     692        endTime=getDateTimeComponents(endTime) 
     693        super_index_list=[] 
     694        index_list=[] 
     695         
     696        # Get the bin list for all times 
     697        timeList=DateTimeManager.createList(startTime, endTime, (intervalValue, intervalUnits), listtype="tuple") 
     698        timeBins=DateTimeManager.getTimeBins(timeList) 
     699         
     700        for i in range(len(startTime)): 
     701            index_list.append(timeBins[i].index(startTime[i])) 
     702        #super_index_list=super_index_list+index_list[:]+index_list[:]  
     703 
     704        # Insert javascript functions to do date checking. 
     705        #if len(super_index_list)==12:  super_index_list=super_index_list+[0,0,0,0,0,0,0,0,0,0,0,0] 
     706        #print jsFunctions.js_dateCheckFunctionGroup % tuple(super_index_list)      
     707 
     708        # Temporal domain 
     709        #print '<P><B>Time</B><P><TABLE WIDTH="100%"><TR>' 
     710        #print '<INPUT NAME="timeIntervalUnits_%s" TYPE="hidden" VALUE="%s">' % (axisIndex, intervalUnits)  
     711        #print '<INPUT NAME="timeIntervalValue_%s" TYPE="hidden" VALUE="%s">' % (axisIndex, intervalValue) 
     712        #print '<TD WIDTH="50%">' 
     713        #print '<TABLE BORDER="1"><TR>' 
     714   
     715        print '<TD COLSPAN="3"><TABLE BORDER="1">' 
     716        for part in ("low", "", "high"): 
     717             
     718            if part in ("Dataset %s: Start time" % axisIndex, "End time"): 
     719                print '<TD COLSPAN="6">%s</TD>' % part 
     720            elif part=="": 
     721                print "<TR><TD>&nbsp;</TD></TR>" 
     722            else: 
     723                print '<TR>' 
     724                fieldFlag="" 
     725                count=0 
     726                for key in TIME_KEYS: 
     727                    if part=="text": 
     728                        print "<TD>%s</TD>" % key 
     729                    elif part in ("low", "high"): 
     730                        print """<TD><SELECT NAME="%s_%s.time.%s" %s onChange="checkDate('%s_%s')">""" % (axisIndex,  
     731                                   part, key.lower(), fieldFlag, part, axisIndex) 
     732                        if key=="year": 
     733                            timeFormat="%.4d" 
     734                        else: 
     735                            timeFormat="%.2d" 
     736 
     737                        for item in timeBins[count]: 
     738                            timeItem=timeFormat % item 
     739                            print """<OPTION VALUE="%s">%s</OPTION>""" % (timeItem, timeItem) 
     740                 
     741                        print "</SELECT></TD>" 
     742                        count=count+1 
     743 
     744                print "</TR>" 
     745        print "</TABLE></TD>" 
     746 
     747        #print "</TR></TABLE><P>" 
     748        # Call the javascript to update the date field at start 
     749        #print """<SCRIPT LANGUAGE="Javascript">resetAllDates(%s)</SCRIPT>""" % (dsetNumber-1)     
     750         
     751 
     752 
     753         
     754    def DEPRACATED_displayTemporalDomainOptions(self, options): 
    439755        """ 
    440756        Prints a form entry for specifying the temporal domain. 
     
    540856        # Get current number of Datasets before showing option of selecting number of datasets 
    541857        # This sets the instance variable that is re-used everywhere from now on - clunky, I know! 
    542         self.numberOfDatasets=int(summaryDict["numberOfDatasets"])       
     858        """self.numberOfDatasets=int(summaryDict["numberOfDatasets"])"""         
    543859         
    544860        if sessionID in (None, "None"): 
     
    548864         
    549865        # Show option for number of datasets if more than one allowed 
    550         if MAX_NUM_DATASETS>1: 
    551             print """ | Number of Datasets <SELECT NAME="ndsets" onchange="redirect(this);">""" 
     866        """if MAX_NUM_DATASETS>1: 
     867            print ' | Number of Datasets <SELECT NAME="ndsets" onchange="redirect(this);">' 
    552868             
    553869            for n in range(1, MAX_NUM_DATASETS+1): 
     
    557873                    print '<OPTION VALUE="%s?numberOfDatasets=%s%s">%s</OPTION>' % (CGI_SCRIPT_URL_PATH, n, sidString, n) 
    558874                     
    559             print "</SELECT>" 
     875            print "</SELECT>"  """ 
    560876         
    561877        # Link to view request summary 
     
    602918 
    603919        # Begin an HTML table 
    604         print '<TABLE WIDTH="100%"><TR class="tablerow"><TD COLSPAN="2">CURRENT REQUEST</TD></TR>' 
     920        """print '<TABLE WIDTH="100%"><TR class="tablerow"><TD COLSPAN="2">CURRENT REQUEST</TD></TR>' 
    605921 
    606922        print '<TR class="tablerow">' 
     
    631947          print "</TD>" 
    632948        print "</TR></TABLE>" 
    633         print "</I></B><P>" 
     949        print "</I></B><P>"   """ 
    634950 
    635951 
     
    680996        print "%s file%s been successfully written. The table below shows %s." % (nfiles, plural, displayedString) 
    681997        print "<TABLE>" 
     998         
    682999        for file in pathList: 
    683             if file=="...": 
     1000            localPath=file 
     1001            url=translateURI(localPath) 
     1002                 
     1003            if localPath=="...": 
    6841004                print """<TR class="tablerow"><TD COLSPAN="3">...</TD>""" 
    6851005            else: 
     
    6881008                         <TD><A HREF="%s">  Download  </A></TD> 
    6891009                         <TD><A HREF="%s?fileURIList=%s&fileVariable_1.1=SELECT_AUTOMATICALLY">  Visualise  </A></TD> 
    690                      </TR>""" % (file, file, GEOSPLAT_URL_PATH, file) 
     1010                     </TR>""" % (url, url, GEOSPLAT_URL_PATH, localPath) 
    6911011        print "</TABLE>" 
    6921012        print '<P><A HREF="%s">Start a new request</A>.' % CGI_SCRIPT_URL_PATH 
     
    7231043         
    7241044 
    725     def _displayRequestSummaryTable(self, summary): 
     1045    def _displayRequestSummaryTable(self, summaryDict): 
    7261046        """ 
    7271047        Prints a table summarising the current request. 
     
    7301050        print "<TABLE>" 
    7311051        # Chop up the request information into a dictionary 
    732         (summaryDict, orderedKeys)=self._chopUpSummary(summary) 
    733                  
    734         for key in orderedKeys: 
    735             print '<TR class="tablerow"><TD><B>%s</B></TD><TD>%s</TD></TR>' % (key, summaryDict[key]) 
     1052        #(summaryDict, orderedKeys)=self._chopUpSummary(summary) 
     1053         
     1054        d=summaryDict 
     1055        dsgKeys=d["datasetGroups"].keys() 
     1056        dsKeys=d["datasets"].keys() 
     1057        varKeys=d["variables"].keys() 
     1058        axisKeys=d["axes"].keys() 
     1059         
     1060        dsgKeys.sort() 
     1061        dsKeys.sort() 
     1062        varKeys.sort() 
     1063        axisKeys.sort() 
     1064         
     1065        template='<TR class="tablerow"><TD><B>%s%s</B></TD><TD>%s</TD></TR>' 
     1066         
     1067        for dsg in dsgKeys: 
     1068            print template % ("Dataset Group ", dsg, d["datasetGroups"][dsg])        
     1069             
     1070            for ds in dsKeys: 
     1071                (dsgIndex, dsIndex)=re.match(r"^(\d+)\.(\d+)$", ds).groups() 
     1072                if dsg==dsgIndex: 
     1073                    print template % ("Dataset ", ds, d["datasets"][ds]) 
     1074                     
     1075                for var in varKeys: 
     1076                    (dsgIndex, dsIndex, varIndex)=re.match(r"^(\d+)\.(\d+)\.(\d+)$", var).groups() 
     1077                    if dsg==dsgIndex and ds=="%s.%s" % (dsgIndex, dsIndex): 
     1078                        print template % ("Variable ", var, d["variables"][var]) 
     1079                        if d["outputFormats"].has_key(var): 
     1080                            print template % ("Output format ", var, d["outputFormats"][var]) 
     1081 
     1082                        if d["datasetURIs"].has_key(var): 
     1083                            print template % ("Dataset URI ", var, d["datasetURIs"][var])                        
     1084                         
     1085                    for axis in axisKeys: 
     1086                        (dsgIndex, dsIndex, varIndex, axisIndex)=re.match(r"^(\d+)\.(\d+)\.(\d+)\.(\d+)$", axis).groups() 
     1087                        if (dsg==dsgIndex and ds=="%s.%s" % (dsgIndex, dsIndex)) and var=="%s.%s.%s" % (dsgIndex, dsIndex, varIndex): 
     1088                            print template % ("Axis ", axis, d["axes"][axis]) 
     1089         
     1090            print "<TR><TD>&nbsp;</TD></TR>" 
     1091 
     1092         
     1093        # Now globals 
     1094        globalKeys=d["globals"].keys() 
     1095        globalKeys.sort() 
     1096         
     1097        for key in globalKeys: 
     1098            print template % (key, "", d["globals"][key]) 
    7361099         
    7371100        print "</TABLE>" 
     
    8291192        print '<P><A HREF="%s?sessionID=%s">Return to your current request</A><P>' % (CGI_SCRIPT_URL_PATH, sessionID) 
    8301193         
     1194 
     1195if __name__=="__main__": 
     1196    print "Testing DisplayManager.py..." 
     1197    DisplayManager() 
  • TI03-DataExtractor/trunk/pydxc/WSCaller.py

    r794 r1109  
    4848        try: 
    4949            response=apply(getattr(self.server, methodName), args)  
     50            response=deUnicodeObject(response) 
    5051        except Exception, error: 
    5152            if str(error)=="(111, 'Connection refused')": 
  • TI03-DataExtractor/trunk/pydxc/clientConfig.py

    r794 r1109  
    6868ADMIN_NOTIFICATION=0 
    6969 
    70 # SOAP_SERVER_PORT: 
    71 # Port over which the Web Service will run. 
    72 SOAP_SERVER_PORT=8406 
    73  
    74 # SOAP_SERVER_NAME: 
    75 # URL of server. If client and server running lcoally  
    76 # you can use "localhost". 
    77 SOAP_SERVER_NAME="localhost" 
     70# SOAP_SERVER_URL: 
     71# URL to Web Service of the form: "http://<host>:<port>/<script> 
     72SOAP_SERVER_URL="http://localhost:8406/DXController.py" 
    7873 
    7974# LOCAL_SERVER_PACKAGE 
     
    9085# Probably a temporary store. This directory needs to be visible from the  
    9186# webserver (e.g. /srv/www/htdocs/dx/request_xmls). 
    92 REQUEST_XML_DIR_LOCAL_PATH="/srv/www/htdocs/request_xmls" 
     87REQUEST_XML_DIR_LOCAL_PATH="/home/as56/apache/htdocs/request_xmls" 
    9388 
    9489# REQUEST_XML_DIR_URL_PATH: 
     
    10398# Location on the local machine of the webserver top level directory, 
    10499# i.e. the htdocs directory. 
    105 STATIC_WEBSERVER_LOCAL_PATH="/srv/www/htdocs" 
     100STATIC_WEBSERVER_LOCAL_PATH="/home/as56/apache/htdocs" 
    106101 
    107102# WEB_EXTRAS_URL_PATH: 
     
    123118# "/srv/www/cgi-bin/apwsui.py" is likely on a SUSE system but 
    124119# you are free to rename this as you wish. 
    125 CGI_SCRIPT_LOCAL_PATH="/srv/www/cgi-bin/dxui" 
     120CGI_SCRIPT_LOCAL_PATH="/home/as56/apache/cgi-bin/dxui" 
    126121 
    127122# TOKEN_VALID_LIFETIME: 
  • TI03-DataExtractor/trunk/pydxc/common.py

    r794 r1109  
    1212 
    1313# Import python modules 
    14 import os 
     14import os, re 
    1515 
    1616# Import package modules 
     
    2727HORIZ_KEYS=["northernExtent", "easternExtent", "southernExtent", "westernExtent"] 
    2828 
     29dateTimePattern=re.compile(r"^(\d{4}).(\d{1,2}).(\d{1,2})(\s+|T)(\d+):(\d+):(\d+\.?.*)$") 
     30 
    2931# Set up common functions 
    3032 
    31 def createTimeKeyList(): 
     33def DEPRECATEDcreateTimeKeyList(): 
    3234    """ 
    3335    Returns all the separate date and time component arguments required as a list. 
     
    3941                allTimeKeys.append("%s%s_%s" % (ts, key, i)) 
    4042    return allTimeKeys 
     43  
     44 
     45def getDateTimeComponents(dateTimeString): 
     46    """ 
     47    Takes in a time string in standard DateTime format and returns the items in it. 
     48    """ 
     49    match=dateTimePattern.match(dateTimeString) 
     50    if not match: 
     51        raise "Cannot match date time string: %s" % dateTimeString 
     52 
     53    items=match.groups() 
     54    (year, month, day, hour, minute)=[int(i) for i in items[:3]+items[4:6]] 
     55    second=float(items[6]) 
     56    return (year, month, day, hour, minute, second) 
     57 
     58  
     59def createSummaryDict(summaryString): 
     60    """ 
     61    Takes in a summary string containing details of a user request and 
     62    returns a more user-friendly dictionary version held as: 
     63     
     64    dict["datasetGroups"], dict["datasets"] etc 
     65     
     66    with all global selections as dict[selectionName] etc 
     67    """ 
     68    d={"globals":{}, "axes":{}} 
     69    for i in "datasetGroup dataset variable datasetURI outputFormat".split(): 
     70        d[i+"s"]={} 
     71         
     72    s=summaryString 
     73     
     74    items=s.split("\n") 
     75 
     76    matcher=re.compile(r"^(datasetGroup|dataset|variable|datasetURI|axis|outputFormat)_(\d+.*)$") 
     77     
     78    for item in items: 
     79        if item.find(":")<0: continue 
     80        colon=item.find(":") 
     81         
     82        (name, value)=(item[:colon], item[colon+1:]) 
     83        (name, value)=(name.strip(), value.strip()) 
     84        # deCamelCase later...??? 
     85        match=matcher.match(name) 
     86         
     87        if match: 
     88            (stringMatched, index)=match.groups() 
     89            if stringMatched=="axis": 
     90                d["axes"][index]=value 
     91            else: 
     92                d[stringMatched+"s"][index]=value 
     93        else: 
     94            d["globals"][name]=value 
     95             
     96    return d     
    4197    
     98    
     99def getDictSubsetMatching(dct, pattern, mode="string match"): 
     100    """ 
     101    Returns a dictionary of all items in input dictionary 'dct' 
     102    where keys match 'pattern'. 
     103    """ 
     104    rtdict={} 
     105    for key in dct.keys(): 
     106        if mode=="string match": 
     107            if key.find(pattern)>-1: 
     108                rtdict[key]=dct[key] 
     109        elif mode=="regex": 
     110            match=re.search(pattern, key) 
     111            if match: 
     112                rtdict[key]=dct[key]         
     113    return rtdict 
     114     
     115     
     116 
     117def translateURI(uri): 
     118    """ 
     119    Takes a URL and returns the location of the file on the local network 
     120    or takes a local path and returns the URL of the file/directory. 
     121    """ 
     122    if uri.find("http")>-1: 
     123        newpath=uri.replace(OUTPUT_DIR_URL_PATH, OUTPUT_DIR_LOCAL_PATH) 
     124    else: 
     125        newpath=uri.replace(OUTPUT_DIR_LOCAL_PATH, OUTPUT_DIR_URL_PATH) 
     126    return newpath 
     127 
    42128 
    43129def deUnicodeObject(obj): 
     
    88174        pass 
    89175 
     176 
     177if __name__=="__main__": 
     178    print createSummaryDict("""status: constructing  
     179    username: None  
     180    accessTime: 1146079648.25  
     181    variable_3.1.1: var3  
     182    proceed: Proceed  
     183    dataset_2.1: Test Dataset 2  
     184    userRoles: []  
     185    dataset_3.1: Test Dataset 3  
     186    datasetGroup_2: Test Data Group 2  
     187    datasetGroup_3: Test Data Group 3  
     188    sessionID: session_20060426190723114  
     189    datasetGroup_1: Test Data Group 1  
     190    variable_1.1.1: pqn  
     191    dataset_1.1: Test Dataset 1  
     192    variable_2.1.1: var2 """) 
     193     
     194    print getDateTimeComponents("2004-1-1T12:0:0.0") 
     195    print getDateTimeComponents("2004-07-04T12:45:33.489") 
  • TI03-DataExtractor/trunk/pydxs/CDMSDataHandler.py

    r794 r1109  
    1616 
    1717# Import required modules 
    18 import shelve 
    1918import os 
    2019import cdms 
     
    109108           v=self.file[var] 
    110109           name=self._getBestName(v, vcount) 
    111            """if not hasattr(v, "standard_name"):  
    112                if not hasattr(v, "long_name"): 
    113                    if not hasattr(v, "title"): 
    114                        if not hasattr(v, "name"): 
    115                            if hasattr(v, "id"): 
    116                                name=v.id  
    117                            else: 
    118                                vcount=vcount+1 
    119                                name="unnamed_var_%s" % vcount 
    120                        else: 
    121                            name=v.name 
    122                    else: 
    123                        name=v.title 
    124                else: 
    125                    name=v.long_name 
    126            else: 
    127                name=v.standard_name""" 
    128110                
    129111           # Fix name to remove leading asterisks and lower case surface start. 
     
    142124        Returns the full domain listing for a variable returning: 
    143125         
    144         [axisIndexString, knownAxisString, id, longName, units, listType, unusedItem,  
     126        [knownAxisString, id, longName, units, listType, unusedItem,  
    145127        listValue-1, listValue-2, ..., listValue-n] 
    146128         
    147129        For example: 
    148130         
    149         ["axis1.0", "time", "time", "Time", "hours since 1999-09-09 00:00:00", "start end interval", 
     131        ["time", "time", "Time", "hours since 1999-09-09 00:00:00", "start end interval", 
    150132        "", 0, 3, 6] 
    151133         
     
    164146        axcount=0 
    165147        for axis in var.getAxisList(): 
    166             axisIndexString="axis%s.%s" % ("77777", axcount) #(varIndex+1, axcount) 
     148            #axisIndexString="axis%s.%s" % ("77777", axcount) #(varIndex+1, axcount) 
    167149            units=None 
    168150            if axis.isTime(): 
     
    202184             
    203185            unused="" 
    204             rtlist.append([axisIndexString, knownAxis, id, longName, units, listType, unused]+arrayValues) 
     186            rtlist.append([knownAxis, id, longName, units, listType, unused]+arrayValues) 
    205187            axcount=axcount+1 
    206188             
     
    248230        var=self._getVariable(variable) 
    249231        time_axis=var.getTime() 
    250         time_keys=("year", "month", "day", "hour", "minute", "second") 
    251         start_time_components=time_axis.asComponentTime()[0] 
    252         end_time_components=time_axis.asComponentTime()[-1] 
    253         start_time=[] 
     232        #time_keys=("year", "month", "day", "hour", "minute", "second") 
     233        start_time=str(time_axis.asComponentTime()[0]).replace(" ", "T") 
     234        end_time=str(time_axis.asComponentTime()[-1]).replace(" ", "T") 
     235        """start_time=[] 
    254236        end_time=[] 
    255237        for key in time_keys: 
    256238            start_time.append(getattr(start_time_components, key)) 
    257             end_time.append(getattr(end_time_components, key))  
     239            end_time.append(getattr(end_time_components, key))"""  
    258240        time_units=time_axis.units.split()[0] 
    259241        if time_units[-1]=="s":  time_units=time_units[:-1] 
     
    282264        if timeAxis==None: 
    283265            return [] 
    284            
    285         startDateTime=None     
     266         
     267        startDateTime=None 
    286268        for key in axisSelectionDict.keys(): 
    287269            #print key, axisSelectionDict[key] 
    288             axisIndex=int(key.split(".")[-1]) 
     270            axisIndex=int(key.split(".")[-1])-1 
    289271            if axisIndex==timeAxisIndex: 
    290272                (startDateTime, endDateTime)=axisSelectionDict[key][:2] 
     
    320302                 
    321303        return selectedTimes 
    322  
    323  
    324     """def getSelectedVariableSubsetSize(self, datasetURI, variable, axisSelectionDict): 
    325         " 
    326         Returns the size in bytes of the selected subset of a variable. 
    327         "        
    328         self._openDataFile(datasetURI=datasetURI) 
    329         var=self._getVariable(variable) 
    330         varType=var.typecode() 
    331          
    332         timeAxisIndex=None 
    333         axcount=0 
    334         for axis in var.getAxisList(): 
    335             if axis.isTime(): 
    336                 timeAxisIndex=axcount 
    337             axcount=axcount+1 
    338            
    339         startDateTime=None     
    340          
    341         axesCounted=[] 
    342         size=1 
    343         for key in axisSelectionDict.keys(): 
    344             #print key, axisSelectionDict[key] 
    345             axisIndex=int(key.split(".")[-1]) 
    346             (low, high)=axisSelectionDict[key][:2] 
    347             axis=var.getAxis(axisIndex) 
    348              
    349             if axisIndex==timeAxisIndex: 
    350                 axlen=len(self.getSelectedTimeSteps(datasetURI, variable, {key:(low, high)}))            
    351             elif low==high:  
    352                 axlen=1 
    353             else: 
    354                 axlen=len(getValuesInRange(low, high, axis[:])) 
    355                 if axlen==0: 
    356                     raise DXOptionHandlingError, "All selected '%s' axis values for '%s' are out of range, please go back and re-select." % (axis.id, variable) 
    357             size=size*axlen 
    358             axesCounted.append(axisIndex) 
    359          
    360         axcount=0     
    361         for axis in var.getAxisList(): 
    362             if axcount not in axesCounted: 
    363                 size=size*len(axis) 
    364              
    365             axcount=axcount+1 
    366  
    367         if varType=="f": 
    368             size=size*4. 
    369         elif varType=="d": 
    370             size=size*8 
    371         elif varType=="i": 
    372             size=size    
    373  
    374         return size     """ 
    375304 
    376305 
     
    401330        for key in axisSelectionDict.keys(): 
    402331            #print key, axisSelectionDict[key] 
    403             axisIndex=int(key.split(".")[-1]) 
     332            # Set the axisIndex as value minus one because we index from 1 in the dx lists 
     333            axisIndex=int(key.split(".")[-1])-1 
    404334            (low, high)=axisSelectionDict[key][:2] 
    405335            axis=var.getAxis(axisIndex) 
     
    427357            axLens.append(axlen) 
    428358         
     359#       print axesCounted 
     360#       print axLens 
     361         
    429362        axcount=0 
    430363        arrayShape=[] 
     
    434367                arrayShape.append(len(axis)) 
    435368            else: 
    436                 arrayShape.append(axLens[axesCounted[axcount]])   
     369                #print axcount 
     370                arrayShape.append(axLens[axesCounted.index(axcount)])     
    437371            if axis.isLatitude() and latLength==None: 
    438372                latLength=len(axis) 
     
    452386            size=size*8 
    453387        elif varType=="i": 
    454             size=size    
     388            size=size 
    455389 
    456390        return (tuple(arrayShape), gridShape, size) 
     
    479413        for key in axisSelectionDict.keys(): 
    480414            #print key, axisSelectionDict[key] 
    481             axisIndex=int(key.split(".")[-1]) 
     415            axisIndex=int(key.split(".")[-1])-1 
    482416            axis=axisList[axisIndex]    
    483417            id=axis.id 
     
    494428            elif axis.isLatitude(): 
    495429                (low, high)=axisSelectionDict[key][:2] 
    496                 print "Nudging latitudes to nearest points..." 
    497430                if low==high: 
    498                     (low, high, nudgeMessage)=nudgeSingleValuesToAxisValues(low, axis[:], "Latitude")        
     431                    loworig=low 
     432                    (low, high, nudgeMessage)=nudgeSingleValuesToAxisValues(low, axis[:], "Latitude")     
     433                    if loworig!=low:   print "Nudged latitudes to nearest points..."                    
    499434            elif axis.isLongitude(): 
    500435                (low, high)=axisSelectionDict[key][:2] 
    501                 print "Nudging longitudes to nearest points..." 
    502436                if low==high: 
    503                     (low, high, nudgeMessage)=nudgeSingleValuesToAxisValues(low, axis[:], "Longitude")     
     437                    loworig=low 
     438                    (low, high, nudgeMessage)=nudgeSingleValuesToAxisValues(low, axis[:], "Longitude")   
     439                    if loworig!=low:   print "Nudged latitudes to nearest points..."                           
    504440            else: 
    505441                selector=axisSelectionDict[key][:2] 
     
    530466    a=CDMSDataHandler() 
    531467    print a.getVariables(datasetGroup='Test Data Group 1', dataset='Test Dataset 1') 
    532     print a.getVariables(datasetGroup='Test Data Group 3', datasetURI='file:/usr/local/dx/testdata/testdata3.xml')     
     468    print a.getVariables(datasetGroup='Test Data Group 3', datasetURI='file:/usr/local/test/dxs/testdata/testdata3.xml')     
    533469    print a.getDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    534470    print a.getHorizontalDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    535471    print a.getVerticalSpatialDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    536472    print a.getTemporalDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    537     print a.getCFGlobalAttributes("file:/usr/local/dx/testdata/testdata3.xml") 
    538     print a.getSelectedVariableArrayDetails('file:/usr/local/dx/testdata/testdata1.xml', "pqn",  
    539                      {"axis_1.1.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
    540                      "axis_1.1.1.1":(30,-30), "axis_1.1.1.2":(30,-30)}) 
     473    print a.getCFGlobalAttributes("file:/usr/local/test/dxs/testdata/testdata3.xml") 
     474    print a.getSelectedVariableArrayDetails('file:/usr/local/test/dxs/testdata/testdata1.xml', "pqn",  
     475                     {"axis_1.1.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     476                     "axis_1.1.1.2":(10,20), "axis_1.1.1.3":(0,90)}) 
     477    print a.getSelectedVariableArrayDetails('file:/usr/local/test/dxs/testdata/testdata1.xml', "pqn",  
     478                     {"axis_1.1.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     479                     "axis_1.1.1.3":(30,-30)}) 
     480    print a.getSelectedVariableSubsetSize("/usr/local/test/dxs/testdata/testdata1.xml", "pqn", 
     481                     {'axis_1.1.1.1':('1999-01-01T00:00:0.000000', '1999-01-01T00:00:0.000000'),   
     482                      'axis_1.1.1.3': [0.0, 355.0], 'axis_1.1.1.2': [-90.0, 90.0]}) 
  • TI03-DataExtractor/trunk/pydxs/CSMLDataHandler.py

    r794 r1109  
    1010 
    1111This module holds the CSMLDataHandler class that is used 
    12 to hold and access information about datasets held in CSML 
    13 format visible to the dx package. 
     12to hold and access information about datasets held in CSML-compatible 
     13formats visible to the dx package. 
    1414 
    1515""" 
    1616 
    1717# Import required modules 
    18 import shelve 
    1918import os 
    20 #import CSML 
     19import cdms 
    2120import re 
    2221 
    2322# Import global variables 
    24 from serverConfig import * 
    25 from common import * 
    26 from DXDMLHandler import DXDMLHandler 
    27 from DXErrors import * 
     23#from serverConfig import * 
     24#from common import * 
     25#from DXDMLHandler import DXDMLHandler 
     26#from DXErrors import * 
     27 
     28def getValuesInRange(start, end, array): 
     29    """ 
     30    Takes a start and end value and returns the values in the array that are bet 
     31ween them. 
     32    If not in range and are the same value then returns [start]. 
     33    """ 
     34    # check all are floats 
     35    array=map(lambda x: float(x), list(array)) 
     36    if array[0]>array[-1]: array.reverse() 
     37    if start>end:  (start, end)=(end, start) 
     38    (start, end)=(float(start), float(end)) 
     39    rtarray=[] 
     40    for i in array: 
     41        if i>=start and i<=end: 
     42            rtarray.append(i) 
     43    if rtarray==[] and start==end: 
     44        rtarray=[start] 
     45    return rtarray 
     46 
    2847 
    2948 
     
    3453    """ 
    3554   
    36     def __init__(self): 
     55    def __init__(self, datasetURI=None): 
    3756        """ 
    3857        Set up instance variables. 
    3958        """ 
    40         self.DXDML=DXDMLHandler() 
    41         self.file=None 
    42         self.datasetURI=None 
     59        self.DXDML=None #DXDMLHandler() 
     60        self.file=datasetURI 
     61        if self.file: self._openDataFile(datasetURI=self.file)   
    4362    
    4463    
     
    4766        Opens a file and allocates to file handle called: self.file. 
    4867        """ 
     68        print """CSML: _openDataFile(datasetURI) 
     69Sets:    self.file=CSMLDataset(datasetURI) 
     70CSML_END 
     71""" 
    4972        if datasetURI: 
    5073            cdmlfile=datasetURI 
     
    5275            for item in self.DXDML.getDatasetsAndDatasetURIs(datasetGroup): 
    5376                if item[0]==dataset: 
    54                     csmlfile=item[1] 
     77                    cdmlfile=item[1] 
     78         
    5579        try: 
    56             self.file=CSML.CSMLFile(csmlfile) 
     80            self.file=cdms.open(cdmlfile) 
    5781        except IOError, error: 
    5882            raise DXDataIOError, error 
    5983 
    6084 
    61     def _getVariable(self, variable): 
     85    def _getVariable(self, varname): 
    6286        """ 
    6387        Gets variable metadata object from a data file. 
    6488        """ 
    65         varname=variable 
     89        print """CSML: _getVariable(varname) 
     90Returns a CDML metadata variable. 
     91It contains metadata such as attributes and axes but not the 
     92data array. It is read from self.file. 
     93 
     94CSML_END 
     95"""      
    6696        try: 
    6797            rtvalue=self.file[varname] 
    6898        except: 
    69             raise "Cannot find variable %s in file %s" % (varname, self.file.id) 
     99            raise DXOptionHandlingError, "Cannot find variable %s in file %s" % (varname, self.file.id) 
    70100        return rtvalue 
     101         
     102 
     103    def _getBestName(self, v, vcount=0): 
     104        """ 
     105        Returns the best name for a cdms variable. 
     106        """ 
     107        print """CSML: _getBestName(v) 
     108Returns the best standard_name, long_name etc from those available. 
     109v is returned from self._getVariable() 
     110 
     111 
     112CSML_END 
     113"""      
     114        if not hasattr(v, "standard_name"):  
     115            if not hasattr(v, "long_name"): 
     116                if not hasattr(v, "title"): 
     117                    if not hasattr(v, "name"): 
     118                        if hasattr(v, "id"): 
     119                            name=v.id  
     120                        else: 
     121                            vcount=vcount+1 
     122                            name="unnamed_var_%s" % vcount 
     123                    else: 
     124                       name=v.name 
     125                else: 
     126                    name=v.title 
     127            else: 
     128                name=v.long_name 
     129        else: 
     130            name=v.standard_name 
     131        return name 
    71132 
    72133 
     
    77138        hierarchically depending on the available attributes. Each returned item in 
    78139        the list includes a [<long_name>, <id>]. 
    79         """         
     140        """  
     141        print """CSML: getVariables(datasetURI) 
     142Returns a list of rank-2 lists containing: 
     143 
     144[[bestVarName, varID], [bestVarName2, varID2],....] 
     145 
     146CSML_END 
     147"""              
    80148        self._openDataFile(datasetGroup, dataset, datasetURI) 
    81149        vars=self.file.listvariables() 
     
    83151        vcount=0 
    84152        for var in vars: 
    85            longname=self.file.getFeatureInstanceLongName(var) 
    86            rtvars.append([name, v.id])  
     153           v=self.file[var] 
     154           name=self._getBestName(v, vcount) 
     155                
     156           # Fix name to remove leading asterisks and lower case surface start. 
     157           name=name.replace("_", " ") 
     158           if name[:2]=="**": name=(name[2:]).strip() 
     159           if name[:7]=="surface": name=(name[7:]).strip() 
     160           # Remove variables they are actually bounds on axes or coefficients in formulae 
     161           if v.id not in ("bounds_longitude", "bounds_latitude", "bounds_level", "bounds_time", "p0"): 
     162               rtvars.append([name, v.id])  
    87163 
    88164        return rtvars 
     
    91167    def getDomain(self, datasetGroup=None, dataset=None, variable=None, datasetURI=None): 
    92168        """ 
    93         Returns the combined horizontal, vertical and temporal domains. 
     169        Returns the full domain listing for a variable returning: 
     170         
     171        [axisIndexString, knownAxisString, id, longName, units, listType, unusedItem,  
     172        listValue-1, listValue-2, ..., listValue-n] 
     173         
     174        For example: 
     175         
     176        ["axis1.0", "time", "time", "Time", "hours since 1999-09-09 00:00:00", "start end interval", 
     177        "", 0, 3, 6] 
     178         
     179        This listType represents 6-hourly time steps of 0,1,2,3 past the base time. 
     180         
     181        listType can also take the value "full list" where all values in the list are provided, 
     182        or "start end" where only the first and last value are given. 
    94183        """  
    95         (northernExtent, westernExtent, southernExtent, easternExtent) = self.getHorizontalDomain(datasetGroup, dataset, variable, datasetURI) 
    96         (vertical_domain, vertical_units) = self.getVerticalSpatialDomain(datasetGroup, dataset, variable, datasetURI) 
    97         (start_time, end_time, interval) = self.getTemporalDomain(datasetGroup, dataset, variable, datasetURI) 
    98         return ((northernExtent, westernExtent, southernExtent, easternExtent), (vertical_domain, vertical_units), (start_time, end_time, interval)) 
    99  
     184        print """CSML: getDomain(variable, datasetURI) 
     185        Returns the full domain listing for a variable returning: 
     186         
     187        [axisIndexString, knownAxisString, id, longName, units, listType, unusedItem,  
     188        listValue-1, listValue-2, ..., listValue-n] 
     189         
     190        For example: 
     191         
     192        ["axis1.0", "time", "time", "Time", "hours since 1999-09-09 00:00:00", "start end interval", 
     193        "", 0, 3, 6] 
     194         
     195        This listType represents 6-hourly time steps of 0,1,2,3 past the base time. 
     196         
     197        listType can also take the value "full list" where all values in the list are provided, 
     198        or "start end" where only the first and last value are given. 
     199 
     200CSML_END 
     201"""              
     202        self._openDataFile(datasetGroup, dataset, datasetURI) 
     203        var=self._getVariable(variable) 
     204        varList=self.file.listvariables() 
     205        varList.sort() 
     206        varIndex=varList.index(var.id) 
     207        rtlist=[] 
     208         
     209        axcount=0 
     210        for axis in var.getAxisList(): 
     211            axisIndexString="axis%s.%s" % ("77777", axcount) #(varIndex+1, axcount) 
     212            units=None 
     213            if axis.isTime(): 
     214                knownAxis="time" 
     215                (start, end, (intervalValue, intervalUnits))=self.getTemporalDomain(datasetGroup, dataset, variable, datasetURI) 
     216                arrayValues=[start, end, intervalValue] 
     217                listType="start end interval" 
     218                units=intervalUnits 
     219            elif axis.isLevel(): 
     220                knownAxis="level" 
     221                arrayValues=axis[:] 
     222                listType="full list" 
     223            elif axis.isLatitude(): 
     224                knownAxis="latitude" 
     225                arrayValues=[axis[0], axis[-1]] 
     226                arrayValues.sort() 
     227                arrayValues.reverse() 
     228                listType="start end"  
     229            elif axis.isLongitude(): 
     230                knownAxis="longitude" 
     231                arrayValues=[axis[0], axis[-1]] 
     232                arrayValues.sort()       
     233                listType="start end"                                     
     234            else: 
     235                # For any axis not known as above 
     236                knownAxis="" 
     237                if len(axis[:])>200: 
     238                    arrayValues=[axis[0], axis[-1]] 
     239                    listType="start end"                     
     240                else: 
     241                    arrayValues=axis[:] 
     242                    listType="full list" 
     243             
     244            id=axis.id 
     245            longName=self._getBestName(axis).title() 
     246            if not units:  units=getattr(axis, "units", "") 
     247             
     248            unused="" 
     249            rtlist.append([axisIndexString, knownAxis, id, longName, units, listType, unused]+arrayValues) 
     250            axcount=axcount+1 
     251             
     252        return rtlist 
     253         
    100254 
    101255    def getHorizontalDomain(self, datasetGroup=None, dataset=None, variable=None, datasetURI=None): 
     
    103257        Returns the horizontal domain as (northernExtent, westernExtent, southernExtent, easternExtent). 
    104258        """ 
     259        print "Deprecated: NOT NEEDED" 
    105260        self._openDataFile(datasetGroup, dataset, datasetURI) 
    106261        var=self._getVariable(variable) 
     
    118273        a list of levels (or "Single level" string) and the units. 
    119274        """ 
     275        print "Deprecated: NOT NEEDED"   
    120276        self._openDataFile(datasetGroup, dataset, datasetURI) 
    121277        var=self._getVariable(variable) 
     
    136292        (interval value, interval units)). 
    137293        """ 
     294        print "Deprecated: NOT NEEDED"   
    138295        self._openDataFile(datasetGroup, dataset, datasetURI) 
    139296        var=self._getVariable(variable) 
     
    156313 
    157314 
     315    def getSelectedTimeSteps(self, datasetURI, variable, axisSelectionDict): 
     316        """ 
     317        Returns a list of time step strings based on the selection. 
     318        """      
     319        print """CSML: getSelectedTimeSteps(datasetURI, variable, axisSelectionDict) 
     320Returns a list of time step strings based on the selection. 
     321 
     322Inputs look like: 
     323('file:/usr/local/dx/testdata/testdata1.xml', "pqn", {"axis_1.1.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     324                                                      "axis_1.1.1.1":(30,-30), "axis_1.1.1.2":(30,-30)} 
     325                                                       
     326Outputs look like: 
     327['1999-01-01 00:00:0.000000', '1999-01-01 06:00:0.000000'] 
     328 
     329CSML_END 
     330"""              
     331        self._openDataFile(datasetURI=datasetURI) 
     332        var=self._getVariable(variable) 
     333         
     334        timeAxis=None 
     335        axcount=0 
     336        for axis in var.getAxisList(): 
     337            if axis.isTime(): 
     338                timeAxisIndex=axcount 
     339                timeAxis=axis 
     340            axcount=axcount+1 
     341 
     342        if timeAxis==None: 
     343            return [] 
     344           
     345        startDateTime=None     
     346        for key in axisSelectionDict.keys(): 
     347            #print key, axisSelectionDict[key] 
     348            axisIndex=int(key.split(".")[-1]) 
     349            if axisIndex==timeAxisIndex: 
     350                (startDateTime, endDateTime)=axisSelectionDict[key][:2] 
     351         
     352        if startDateTime==None: 
     353            return [str(tst) for tst in timeAxis.asComponentTime()] 
     354         
     355        startDateTime=startDateTime.replace("T", " ") 
     356        items=startDateTime.split(":") 
     357        startDateTime=":".join(items[:-1])+":"+("%f" % float(items[-1])) 
     358        endDateTime=endDateTime.replace("T", " ") 
     359        items=endDateTime.split(":") 
     360        endDateTime=":".join(items[:-1])+":"+("%f" % float(items[-1])) 
     361         
     362        timeSteps=timeAxis.asComponentTime() 
     363        selectedTimes=[] 
     364 
     365        for timeStep in timeSteps: 
     366            ts=timeStep 
     367            timeStep="%.4d-%.2d-%.2d %.2d:%.2d:%f" % (ts.year, ts.month, ts.day, \ 
     368                                            ts.hour, ts.minute, ts.second) 
     369            #print str(timeStep), startDateTime 
     370            ts=str(timeStep) 
     371            if ts>endDateTime: 
     372                break 
     373            elif ts<startDateTime: 
     374                continue 
     375            else: 
     376                selectedTimes.append(ts) 
     377         
     378        if selectedTimes==[]: 
     379            raise DXOptionHandlingError, "All selected time steps for '%s' are out of range, please go back and re-select." % variable 
     380 
     381        return selectedTimes 
     382 
     383 
     384    def getSelectedVariableArrayDetails(self, datasetURI, variable, axisSelectionDict): 
     385        """ 
     386        Returns a tuple representing the (array shape, grid shape, size) 
     387        of the selected subset of a variable. Grid shape can be None if both latitude 
     388        and longitude axes are not present.  
     389        """      
     390        print """CSML: getSelectedVariableArrayDetails(datasetURI, variable, axisSelectionDict) 
     391Returns a tuple representing the (array shape, grid shape, size) 
     392of the selected subset of a variable. Grid shape can be None if both latitude 
     393and longitude axes are not present.  
     394 
     395Inputs look like: 
     396('file:/usr/local/dx/testdata/testdata1.xml', "pqn", {"axis_1.1.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     397                                                      "axis_1.1.1.1":(30,-30), "axis_1.1.1.2":(30,-30)} 
     398                                                       
     399Outputs look like: 
     400((2, 37, 72), (37, 72), 42624) 
     401 
     402CSML_END 
     403"""              
     404        self._openDataFile(datasetURI=datasetURI) 
     405        var=self._getVariable(variable) 
     406        varType=var.typecode() 
     407                 
     408        timeAxisIndex=None 
     409        axcount=0 
     410        for axis in var.getAxisList(): 
     411            if axis.isTime(): 
     412                timeAxisIndex=axcount 
     413            axcount=axcount+1 
     414           
     415        startDateTime=None     
     416         
     417        axesCounted=[] 
     418        axLens=[] 
     419        latLength=None 
     420        lonLength=None 
     421        size=1 
     422        for key in axisSelectionDict.keys(): 
     423            #print key, axisSelectionDict[key] 
     424            axisIndex=int(key.split(".")[-1]) 
     425            (low, high)=axisSelectionDict[key][:2] 
     426            axis=var.getAxis(axisIndex) 
     427             
     428            if axisIndex==timeAxisIndex: 
     429                axlen=len(self.getSelectedTimeSteps(datasetURI, variable, {key:(low, high)}))            
     430            elif low==high:  
     431                axlen=1 
     432            else: 
     433                axlen=len(getValuesInRange(low, high, axis[:])) 
     434                if axlen==0: 
     435                    if (axis.isLongitude() or axis.isLatitude()) and low==high: 
     436                        print "Lat and lon can be axis length zero because we'll nudge to nearest if only one value given." 
     437                        axlen=1 
     438                    else: 
     439                        raise DXOptionHandlingError, "All selected '%s' axis values for '%s' are out of range, please go back and re-select." % (axis.id, variable) 
     440         
     441                if axis.isLatitude(): 
     442                    latLength=axlen 
     443                elif axis.isLongitude(): 
     444                    lonLength=axlen 
     445                         
     446            size=size*axlen 
     447            axesCounted.append(axisIndex) 
     448            axLens.append(axlen) 
     449         
     450        axcount=0 
     451        arrayShape=[] 
     452        for axis in var.getAxisList(): 
     453            if axcount not in axesCounted: 
     454                size=size*len(axis) 
     455                arrayShape.append(len(axis)) 
     456            else: 
     457                arrayShape.append(axLens[axesCounted[axcount]])   
     458            if axis.isLatitude() and latLength==None: 
     459                latLength=len(axis) 
     460            elif axis.isLongitude() and lonLength==None: 
     461                lonLength=len(axis)    
     462            axcount=axcount+1 
     463         
     464        # Now work out gridShape if appropriate 
     465        if latLength and lonLength: 
     466            gridShape=(latLength, lonLength) 
     467        else: 
     468            gridShape=None 
     469         
     470        if varType=="f": 
     471            size=size*4. 
     472        elif varType=="d": 
     473            size=size*8 
     474        elif varType=="i": 
     475            size=size    
     476 
     477        return (tuple(arrayShape), gridShape, size) 
     478 
     479 
     480    def getSelectedVariableSubsetSize(self, datasetURI, varID, axisSelectionDict): 
     481        """ 
     482        Returns the size in bytes of the selected subset of a variable. 
     483        """ 
     484        print "IGNORE: Calls above method." 
     485        return self.getSelectedVariableArrayDetails(datasetURI, varID, axisSelectionDict)[2] 
     486 
     487         
     488    def readVariableSubsetIntoMemory(self, datasetURI, variable, axisSelectionDict, timeStep=None): 
     489        """ 
     490        Reads the variable with ID 'variable' into memory from file 
     491        'datasetURI' - sub-setting across all axes indicated in 'axisSelectionDict'. 
     492        If 'timeStep' is provided then override the time selection in 'axisSelectionDict' 
     493        with the 'timeStep' given. 
     494        """ 
     495        print """CSML: getSelectedTimeSteps(datasetURI, variable, axisSelectionDict, timeStep=None) 
     496        Reads the variable with ID 'variable' into memory from file 
     497        'datasetURI' - sub-setting across all axes indicated in 'axisSelectionDict'. 
     498        If 'timeStep' is provided then override the time selection in 'axisSelectionDict' 
     499        with the 'timeStep' given. 
     500 
     501Inputs look like: 
     502('file:/usr/local/dx/testdata/testdata1.xml', "pqn", {"axis_1.1.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     503                                                      "axis_1.1.1.1":(30,-30), "axis_1.1.1.2":(30,-30)}, "1999-01-01T12:00:00") 
     504                                                       
     505Output is a CDMS transient variable which is a python Numeric Masked Array with metadata attributes and axes attached. 
     506 
     507CSML_END 
     508"""      
     509        self._openDataFile(datasetURI=datasetURI) 
     510        var=self._getVariable(variable) 
     511         
     512        axisList=var.getAxisList() 
     513             
     514        selectionStrings=[] 
     515        for key in axisSelectionDict.keys(): 
     516            #print key, axisSelectionDict[key] 
     517            axisIndex=int(key.split(".")[-1]) 
     518            axis=axisList[axisIndex]    
     519            id=axis.id 
     520             
     521            # deal with time differently 
     522            if axis.isTime(): 
     523                if timeStep!=None:       
     524                    timeStep=timeStep.replace("T", " ")                  
     525                    selectionStrings.append('time="%s"' % timeStep) 
     526                else: 
     527                    selector=axisSelectionDict[key][:2] 
     528                    selector=(selector[0].replace("T", " "), selector[1].replace("T", " ")) 
     529                    selectionStrings.append('%s=%s' % (axis.id, str(selector)))          
     530            elif axis.isLatitude(): 
     531                (low, high)=axisSelectionDict[key][:2] 
     532                if low==high: 
     533                    loworig=low 
     534                    (low, high, nudgeMessage)=nudgeSingleValuesToAxisValues(low, axis[:], "Latitude")     
     535                    if loworig!=low:   print "Nudged latitudes to nearest points..."                    
     536            elif axis.isLongitude(): 
     537                (low, high)=axisSelectionDict[key][:2] 
     538                if low==high: 
     539                    loworig=low 
     540                    (low, high, nudgeMessage)=nudgeSingleValuesToAxisValues(low, axis[:], "Longitude")   
     541                    if loworig!=low:   print "Nudged latitudes to nearest points..."                           
     542            else: 
     543                selector=axisSelectionDict[key][:2] 
     544                selectionStrings.append('%s=%s' % (axis.id, str(selector))) 
     545         
     546        fullSelectionString=", ".join(selectionStrings) 
     547        variableData=eval("self.file('%s', %s)" % (variable, fullSelectionString)) 
     548        return variableData          
     549         
     550 
    158551    def getCFGlobalAttributes(self, datafile): 
    159552        """ 
     
    161554        from the source dataset/file. 
    162555        """ 
    163         # Make sure data file is open 
    164         if self.file==None: self._openDataFile(datafile) 
     556        print """CSML: getCFGlobalAttributes(datasetURI) 
     557Gets any CF metadta global attributes that are available from the source dataset/file. 
     558 
     559Inputs look like: 
     560('file:/usr/local/dx/testdata/testdata1.xml') 
     561                                                       
     562Output is a dictionary of attribute,value pairs got from the input file. 
     563 
     564CSML_END 
     565"""              
     566        if self.file==None: self._openDataFile(datasetURI=datafile) 
    165567        gatts={} 
     568        CF_METADATA_GLOBAL_ATTRIBUTE_KEYS="Conventions title source institution history references comment".split() 
    166569 
    167570        for gatt in CF_METADATA_GLOBAL_ATTRIBUTE_KEYS: 
     
    174577if __name__=="__main__":         
    175578    a=CSMLDataHandler() 
    176     print a.getVariables(datasetGroup='Test Data Group 3', dataset='Test Dataset 3') 
    177     print a.getVariables(datasetGroup='Test Data Group 3', datasetURI='file:/usr/local/dx/testdata/testdata3.xml')     
    178     print a.getDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    179     print a.getHorizontalDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    180     print a.getVerticalSpatialDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    181     print a.getTemporalDomain('Test Data Group 3', 'Test Dataset 3', "var3") 
    182     print a.getCFGlobalAttributes("file:/usr/local/dx/testdata/testdata3.xml") 
     579    print a.getVariables(datasetURI='var1.nc') 
     580    print a.getVariables(datasetURI='var1.nc')     
     581    print a.getDomain(datasetURI='var1.nc', variable="pqn") 
     582    print a.getCFGlobalAttributes('var1.nc') 
     583    print a.getSelectedVariableArrayDetails('var1.nc', "pqn",  
     584                     {"axis_1.1.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     585                     "axis_1.1.1.1":(30,-30), "axis_1.1.1.2":(30,-30)}) 
  • TI03-DataExtractor/trunk/pydxs/DXController.py

    r794 r1109  
    1919from serverConfig import BASEDIR 
    2020sys.path.insert(0, os.path.split(BASEDIR)[0]) 
     21sys.path.insert(0, "..") 
    2122from pydxs import * 
    2223 
     
    4950        self.sessionObj=None 
    5051        self.bag=self.sessionObj # alias                 
    51         self.secureToken=None 
     52        self.secureToken="undefined" 
    5253        self.error=None 
    5354     
     
    6667                    raise DXSecurityError, error     
    6768            else: 
    68                 self.secureToken=None 
     69                self.secureToken="undefined" 
    6970                     
    7071        # Construct the session object 
     
    9495                    raise DXSessionObjectError, error 
    9596                     
    96                 # Validate the selection against known information 
     97                """# Validate the selection against known information 
    9798                try:         
    9899                    self._validate()                 
    99100                except Exception, error: 
    100                     raise DXValidationError, error 
     101                    raise DXValidationError, error""" 
    101102             
    102103        # Estimate the cost of the extraction 
     
    114115        # Estimate the cost of the extraction 
    115116        if self.error==None:     
    116             if (self.bag.has_key("action") and self.bag["action"]=="requestCosts") and self.options=={}: 
     117            if (self.bag.has_key("action") and self.bag["action"]=="requestCosts") and self.options==[]: 
    117118             
    118119                try: 
     
    121122                    # If size is over limit then send a tidy error to the user 
    122123                    if self.estimatedVolume>sizeLimitInBytes: 
     124 
    123125                        sizeInMB=self.estimatedVolume/(2L**20.) 
     126 
    124127                        err="""Your request of %.1f MB is over the current %s MB size limit.     
    125128The Data Extractor cannot yet deal with such large requests. 
     
    132135        # Process the selections to generate some data 
    133136        if self.error==None:     
    134             if (self.bag.has_key("getOutput") and creditChecked==None) and self.options=={}: 
     137            if (self.bag.has_key("getOutput") and creditChecked==None) and self.options==[]: 
    135138                # Check user has sufficient credit 
    136139                try:         
     
    148151         
    149152        if self.error==None: 
    150             print "Saving session details:\n", self.bag, "\n\n"  
     153            print "\nSaving session details:\n", self.bag, "\n\n"  
    151154            if self.bag.has_key("action") and self.bag["action"]=="clearRequest": 
    152155                del self.bag["action"] 
     
    162165        """                      
    163166        self.args={} 
     167        print "ARGS in...", args 
    164168        for key, value in args.items(): 
    165169            if type(key)==type(u""): 
     
    190194        allowed groups from whatever implementation you have put in place. 
    191195        """ 
    192         secChecker=SecurityManager(self.username, self.password, self.secureToken)  
     196        if SECURITY_MODEL=="basic": 
     197            secChecker=NDGSecurityManager(self.username, self.password, self.secureToken) 
     198        elif SECURITY_MODEL=="ndg": 
     199            secChecker=SecurityManager(self.username, self.password, self.secureToken)  
     200        else: 
     201            raise DXSecurityError, "Security model '%s' not supported." % SECURITY_MODEL 
     202           
    193203        # Do something about logout here as well 
    194204      
     
    241251        else: 
    242252            self.bag["username"]=self.username 
    243                                  
    244         #if hasattr(self, "numberOfDatasets"): 
    245         #    self.request["numberOfDatasets"]=self.numberOfDatasets 
    246         if not self.bag.has_key("numberOfDatasets"): 
    247             self.bag["numberOfDatasets"]=1 
    248         else: 
    249             if type(self.bag["numberOfDatasets"]) in (type(""), type(u"")): 
    250                 self.bag["numberOfDatasets"]=int(self.bag["numberOfDatasets"]) 
    251               
    252         # Now check through if we have datasetURIs to see if they relate to our known 
    253         # datasetGroups and datasets    
    254         self._populateRequestFromURI() 
    255  
    256  
    257     def _populateRequestFromURI(self): 
    258         """ 
    259         Takes the request and adds datasetGroup and/or dataset information if 
    260         a datasetURI was provided rather than a datasetGroup/dataset pairing. 
    261         It then does a security check on the resulting data. 
    262         """ 
    263         for n in range(1, self.bag["numberOfDatasets"]+1):  
    264             if self.bag.has_key("datasetURI_%s" % n) and not self.bag.has_key("datasetGroup_%s" % n):  
    265                 DXDML=DXDMLHandler()  
    266                 URIList=DXDML.getDatasetURIList()  
    267  
    268                 for i in URIList:  
    269                     i[0]=i[0].replace("file:", "") 
    270                     if self.bag["datasetURI_%s" % n]==i[0]: # if it is a known dataset  
    271                         self.bag["datasetGroup_%s" % n]=i[2]  
    272                         self.bag["dataset_%s" %n]=i[1]  
    273                          
    274                 if not self.bag.has_key("datasetGroup_%s" % n):  
    275                     #self.bag["datasetGroup_%s" % n]="User dataset group"  
    276                     #self.bag["dataset_%s" % n]="User dataset"  
    277                     # Note if it is not known then not allowed to see it! 
    278                     raise "You do not have permission to access the requested data!" 
    279                      
    280                 self.bag["targetPage"]="VariablesPage"  
    281          
    282         # Tidy up request based on number of datasets requested 
    283         if self.bag.has_key("numberOfDatasets") and self.bag["numberOfDatasets"]==1:  
    284             for n in range(2, MAX_NUM_DATASETS+1): 
    285                 for key in ("datasetGroup_%s", "dataset_%s", "variable_%s", "datasetURI_%s"): 
    286                     item=key % n  
    287                     if self.bag.has_key(item):  del self.bag[item]  
    288           
    289         if self.bag.has_key("targetPage"):  
    290             self.targetPage=self.bag["targetPage"]  
    291         else:  
    292             self.targetPage="DatasetGroupPage"  
    293          
     253             
     254        # Sort out time selections if lists 
     255        axisSelections=getDictSubsetMatching(self.bag, "axis_") 
     256        axKeys=axisSelections.keys() 
     257        if len(axKeys)>0: 
     258            for key, value in axisSelections.items(): 
     259                if type(value[0])==type([1,2]) and len(value[0])==6: 
     260                    self.bag[key]=("%.4d-%.2d-%.2dT%.2d:%.2d:%f" % tuple(value[0]), 
     261                                   "%.4d-%.2d-%.2dT%.2d:%.2d:%f" % tuple(value[1])) 
     262 
    294263 
    295264    def _generateOptions(self): 
     
    301270        optHandler=OptionHandler(self.bag) 
    302271        self.options=optHandler.options 
    303          
    304          
    305     def _validate(self): 
     272        print "\nself.options:", self.options 
     273         
     274         
     275    def DEPRECATED_validate(self): 
    306276        """ 
    307277        Validates the selections made by the user. Returns 1 if successful 
     
    329299        Creates either data files or a dataSubsetSpecifier xml file. 
    330300        """    
    331         # Roundabout method of getting dataset xml file out of list of lists.  
    332         sourceXMLS=[]  
    333         for n in range(1, self.bag["numberOfDatasets"]+1):  
    334             print self.bag 
    335             if self.bag.has_key("datasetGroup_%s" % n): 
    336                 if self.bag["datasetGroup_%s" % n]=="User dataset group":  
    337                     sourceXMLS.append(self.bag["datasetURI_%s" % n])  
    338                 else:  
    339                     DXDML=DXDMLHandler() 
    340                     dsg=self.bag["datasetGroup_%s" % n] 
    341                     ds=self.bag["dataset_%s" % n] 
    342                     dsURI=DXDML.getDatasetURI(dsg, ds) 
    343                     sourceXMLS.append(dsURI) 
    344                                  
    345         if costOnly==1: 
    346             requestCoster=RequestCost(sourceXMLS, self.bag)  
    347             return requestCoster.getDurationAndVolume(self.bag["outputFormat"])    
    348                   
    349         formatClassDict={"NetCDF":NetCDFOutputManager, "NASA Ames":NASAAmesOutputManager}       
    350  
    351         # Now really get data...  
    352         outputManager=apply(formatClassDict[self.bag["outputFormat"]],  
    353             (sourceXMLS, self.bag),)             
    354         outputManager.getParam() 
    355         outputFilePaths=outputManager.generateOutputFilePaths()          
    356         outputFilePathsURLs=[] 
    357         for outputFile in outputFilePaths: 
    358             newpath=outputFile.replace(OUTPUT_DIR, OUTPUT_DIR_URL) 
    359             outputFilePathsURLs.append(newpath)       
    360         self.bag["outputFilePaths"]=outputFilePathsURLs  
     301        outputManager=OutputManager(self.bag) 
     302        pathDict=outputManager.getOutputFilePathDict() 
     303        sizeDict=outputManager.getOutputSizes() 
     304        durationDict=outputManager.getOutputDurationEstimates() 
     305         
     306        outputFilePaths=[] 
     307        outputSize=0 
     308        duration=0 
     309         
     310        for key in pathDict.keys(): 
     311            outputSize=outputSize+sizeDict[key] 
     312            duration=duration+durationDict[key] 
     313            outputFilePaths=outputFilePaths+pathDict[key] 
     314             
     315        self.bag["outputFilePaths"]=outputFilePaths     
     316             
     317        if costOnly==1: 
     318            return (duration, outputSize) 
    361319         
    362320        print """Should really fork this process at this point so that we can return  
     
    365323 
    366324 
    367  
     325if __name__=="__main__": 
     326    x=DXController({}).bag 
     327    sessionID=x["sessionID"] 
     328    DXController({"sessionID":sessionID, "secureToken":None}) 
     329    DXController({"sessionID":sessionID, "secureToken":None, "datasetGroup_1":"Test Data Group 1"}) 
     330    DXController({"sessionID":sessionID, "secureToken":None, "dataset_1.1":"Test Dataset 1"})     
     331    DXController({"sessionID":sessionID, "secureToken":None, "variable_1.1.1":"pqn"}) 
     332    DXController({"sessionID":sessionID, "secureToken":None, "axis_1.1.1.2":(-30,30)})  
     333    DXController({"sessionID":sessionID, "secureToken":None, "axis_1.1.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00")}) 
     334    DXController({"sessionID":sessionID, "secureToken":None, "outputFormat_1.1.1":"NetCDF"})   
     335    DXController({"sessionID":sessionID, "secureToken":None, "outputFormat_1.1.1":"NetCDF", "action":"requestCosts"})            
     336    DXController({"sessionID":sessionID, "secureToken":None, "getOutput":"getOutput"})     
    368337     
  • TI03-DataExtractor/trunk/pydxs/DXDMLHandler.py

    r794 r1109  
    4343        for dsg in dsgNodes: 
    4444            dsgNames.append(dsg.getElementsByTagName("dxGroupLongName")[0].childNodes[0].nodeValue.strip()) 
     45        dsgNames.sort() 
    4546        return dsgNames 
    4647 
     
    6061        if dsNames==[]: 
    6162            raise DXOptionHandlingError, "Cannot match any datasets to dataset group: '%s'" % datasetGroup 
     63        dsNames.sort() 
    6264        return dsNames     
    6365 
     
    8183        if rtlist==[]: 
    8284            raise DXOptionHandlingError, "Cannot match any datasets to dataset group: '%s'" % datasetGroup 
     85        rtlist.sort() 
    8386        return rtlist                    
    8487 
     
    102105                    dsURIs.append([dsURI, dsName, dsgName]) 
    103106 
     107        dsURIs.sort() 
    104108        return dsURIs     
    105109 
  • TI03-DataExtractor/trunk/pydxs/FileNames.py

    r794 r1109  
    5353            self.template=self.template[:-1] 
    5454             
    55         extMap={"NetCDF":"nc", "NASA Ames":"na"} 
    5655        if self.fileFormat:  
    57             self.template=self.template+"."+extMap[self.fileFormat]              
     56            self.template=self.template+"."+mapFileFormatToExtension(self.fileFormat) 
    5857        self.template=self._tidyFileNameObject(self.template)     
    5958         
  • TI03-DataExtractor/trunk/pydxs/LogManager.py

    r794 r1109  
    7171        dt=self._getDateTime() 
    7272        r=self.requestObj 
    73         ndatasets=r["numberOfDatasets"] 
    7473        logString="%s:%s:%s" % (dt, r["sessionID"], r["username"]) 
    7574         
    7675        for i in ("datasetGroup", "dataset", "variable"): 
    7776            tempString="" 
    78             for n in range(1, ndatasets+1): 
    79                 if tempString=="": 
    80                     comma="" 
    81                 else: 
    82                     comma="," 
    83                 tempString=tempString+comma+r["%s_%s" % (i,n)] 
     77            tempString="FIX_ME" 
    8478            logString=logString+":"+tempString 
    8579             
     
    9286        except: 
    9387            fileVolumes="NOT CAPTURED YET!"     
    94         logString="%s:%s:%s:%s" % (logString, r["outputFormat"], numberOfFiles, fileVolumes)                          
     88        logString="%s:%s:%s:%s" % (logString, "outputFormat", numberOfFiles, fileVolumes)                          
    9589        self.requestLog.log(5, logString)        
    9690         
  • TI03-DataExtractor/trunk/pydxs/NumericalOperations.py

    r794 r1109  
    99Holds the NumericalOperations class used to perform various  
    1010mathematical operations involving one or more variables. 
     11 
     12Some notes on what is to come... 
     13 
     14currently we support: 
     15 
     16MA.log 
     17log10 
     18maximum 
     19minimum 
     20pi 
     21sin 
     22tan 
     23sqrt 
     24cos 
     25arccos 
     26arctan 
     27arcsin 
     28exp 
     29absolute 
     30+ 
     31- 
     32() 
     33/ 
     34* 
     35** 
     36 
     37and variables must be represented 
     38as (variableXXX) 
     39 
     40start by parsing out all the  
     41 
     42start with 
     43(variableXXX)-(variableXXX) 
     44 
     45"###########################" 
     46 
     47replace any whitespace with nothing. 
     48 
     49"##########################" 
     50 
     51search for "(variable\d+)" 
     52 
     53"###(variable1)#(variable2)" 
     54 
     55search for "+-*/" 
     56 
     57"##+(variable1)*(variable2)" 
     58 
     59search for "pi,exp,cos, arctan, ...etc" 
     60 
     61"pi+(variable1)*(variable2)" 
     62 
    1163 
    1264""" 
     
    2173from serverConfig import * 
    2274from common import * 
     75from DXErrors import * 
     76 
    2377 
    2478class NumericalOperations: 
     
    4094        Parses the operation string. 
    4195        """ 
    42         matchedIndices=re.findall(r"\(variable(\d+)\)", opstring) 
     96        matchedIndices=re.findall(r"\(var(\d+)\)", opstring) 
    4397        self.variableIndices=[int(i)-1 for i in matchedIndices] 
    44         if opstring=="(variable2)-(variable1)": 
     98        if opstring=="(var2)-(var1)": 
    4599            self.opMethod=self.var2_minus_var1 
    46         elif opstring=="(variable1)-(variable2)": 
     100        elif opstring=="(var1)-(var2)": 
    47101            self.opMethod=self.var1_minus_var2 
     102        else: 
     103            raise DXOptionHandlingError, "Operation '%s' is not supported." % opstring 
    48104         
    49105             
     
    52108        Calls appropriate method to actually perform operation. 
    53109        """ 
    54         apply(self.opMethod, (varList,)) 
    55  
    56          
    57     def _chooseOperation(self, opstring): 
    58         """ 
    59         Method to map operation string to a known method. 
    60         """ 
    61         if opstring=="var1 - var2": 
    62             method=self.v1minusv2 
    63         elif opstring=="var2 - var1": 
    64             method=self.v2minusv1 
    65         elif opstring=="var1 + var2": 
    66             method=self.v1addv2 
    67         elif opstring=="var1 * var2": 
    68             method=self.v1timesv2 
    69         elif opstring=="var1 / var2": 
    70             method=self.v1dividedbyv2 
    71         elif opstring=="var2 / var1": 
    72             method=self.v2dividedbyv1 
    73         elif opstring=="((var1**2) + (var2**2))**0.5": 
    74             method=self.magv1v2 
    75         elif opstring=="var1, var2 (as they come)": 
    76             method=self.v1andv2 
    77         return method 
    78  
    79          
    80     def processOperation(self, variables): 
    81         """ 
    82         Method to actually process the operation. 
    83         """ 
    84         vars=self.operation() 
    85         return vars 
     110        try:  
     111            rtVar=apply(self.opMethod, (varList,)) 
     112            return rtVar 
     113        except: 
     114            raise DXProcessingError, "Could not complete '%s' operation requested." % self.opMethod.__name__ 
    86115         
    87116         
     
    102131        (var1, var2)=varList 
    103132 
    104         if compareGrids(var1.getGrid(), var2.getGrid())==0: 
     133        if var1.getGrid()==None and var2.getGrid()==None: 
     134            pass 
     135        elif compareGrids(var1.getGrid(), var2.getGrid())==0: 
    105136            # Use the standard CDAT regridder to interpolate variable 2 to variable 1 grid. 
    106137            # This might be replaced by the SCRIP regridder (or other) in future. 
     
    139170 
    140171if __name__=="__main__": 
    141     x=NumericalOperations("(variable1)-(variable2)") 
     172    x=NumericalOperations("(var1)-(var2)") 
    142173    print x.variableIndices 
    143     print x.opMethod 
     174    print x.opMethod.__name__ 
    144175    print x.performOperation([cdms.open("/usr/local/dx/testdata/testdata1.xml")("pqn", time=slice(0,1)), cdms.open("/usr/local/dx/testdata/testdata2.xml")("var2")]) 
     176    x=NumericalOperations("(var1)-(var2)") 
     177    print x.performOperation([cdms.open("/dxd/zeros.nc")("t"), cdms.open("/dxd/200plus.nc")("t")]) 
     178    x=NumericalOperations("(var2)-(var1)") 
     179    print x.performOperation([cdms.open("/dxd/zeros.nc")("t"), cdms.open("/dxd/200plus.nc")("t")]) 
    145180     
  • TI03-DataExtractor/trunk/pydxs/OptionHandler.py

    r794 r1109  
    1515# Import required modules 
    1616import os 
    17 #import cdms 
    18 import vcs 
    1917import sys 
    2018 
     
    4341        self.username=self.bag["username"] 
    4442        self.DXDML=DXDMLHandler() 
    45         self.options={} 
     43        self.options=[] 
    4644         
    4745        optsRequested=self._getRequestedOptionCategory() 
     
    4947        self._populateOptionsDict(optsRequested) 
    5048         
     49         
    5150    def _getRequestedOptionCategory(self): 
    5251        """ 
     
    5453        """ 
    5554        # Define a parameter to pick up whether user wants a specific set of options 
    56         optsRequested=None 
     55        optsRequested="undefined" 
    5756        if self.bag.has_key("optionCategoryRequested"): 
    5857            optsRequested=self.bag["optionCategoryRequested"] 
    59  
     58         
    6059        # Get the required option category (going to highest level for all datasets) 
    61         if optsRequested==None or optsRequested in ("datasetGroup", "dataset", "variable"):      
    62             for n in range(1, self.bag["numberOfDatasets"]+1): 
    63                 if isUndefined(self.bag, "datasetGroup_%s" % n) or optsRequested=="datasetGroup": 
    64                     if TOP_LEVEL=="dataset" and (isUndefined(self.bag, "dataset_%s" % n)): 
     60        if optsRequested=="undefined" or optsRequested in ("datasetGroup", "dataset", "variable"):       
     61                if not keyPatternMatch(self.bag, "datasetGroup_") or optsRequested=="datasetGroup": 
     62                    if TOP_LEVEL=="dataset" and (not keyPatternMatch(self.bag, "dataset_\d+\.\d+", "regex")): 
    6563                        optsRequested="dataset"  # to ensure all options are at this level 
    6664                    elif TOP_LEVEL=="datasetGroup": 
    6765                        optsRequested="datasetGroup"  # to ensure all options are at this level 
    6866                 
    69                 elif isUndefined(self.bag, "dataset_%s" % n): 
     67                elif not keyPatternMatch(self.bag, "dataset_\d+\.\d+", "regex"): 
    7068                    optsRequested="dataset"  # to ensure all options are at this level                   
    7169                 
    72                 elif isUndefined(self.bag, "variable_%s" % n): 
     70                elif not keyPatternMatch(self.bag, "variable_\d+\.\d+\.\d+", "regex"): 
    7371                    optsRequested="variable"  # to ensure all options are at this level  
    7472 
     
    9694        Populates the options dictionary according to what was requested or logically comes next. 
    9795        """ 
    98         for n in range(1, self.bag["numberOfDatasets"]+1):           
    99          
    100             choices=None 
    101             if optsRequested=="datasetGroup": 
    102                     choices=("datasetGroup_%s" % n, self.getDatasetGroupList())    
    103             elif optsRequested=="dataset":                     
    104                     choices=("dataset_%s" % n,  
    105                         self.getDatasetList(self.bag["datasetGroup_%s" % n])) 
    106             elif optsRequested=="variable": 
    107                 choices=("variable_%s" % n, self.getVariableList(self.bag["datasetGroup_%s" % n], 
    108                          self.bag["dataset_%s" % n])) 
    109   
    110             if choices:   
    111                 self.options[str(n)]=choices 
    112          
    113         if self.options!={}:   
     96        choices=[] 
     97        print "OPTS REQ:", optsRequested 
     98         
     99        if optsRequested=="datasetGroup": 
     100            count=1 
     101            for dsg in self.getDatasetGroupList(): 
     102                choices.append(("datasetGroup_%s" % count, dsg)) 
     103                count=count+1 
     104            self.options=choices 
     105             
     106        elif optsRequested=="dataset":   
     107            dsgDict=getDictSubsetMatching(self.bag, r"datasetGroup_\d+", "regex") 
     108            dsgKeys=dsgDict.keys() 
     109            dsgKeys.sort() 
     110 
     111            for dsgKey in dsgKeys:       
     112                dsgCode=int(dsgKey.split("_")[-1]) 
     113                dsg=dsgDict[dsgKey] 
     114                datasets=self.getDatasetList(dsg) 
     115 
     116                count=1 
     117                for ds in datasets: 
     118                    choices.append(("dataset_%s.%s" % (dsgCode, count), ds)) 
     119                    count=count+1 
     120                 
     121            self.options=choices 
     122             
     123        elif optsRequested=="variable":  
     124            dsDict=getDictSubsetMatching(self.bag, r"dataset_\d+", "regex") 
     125            dsKeys=dsDict.keys() 
     126            dsKeys.sort() 
     127 
     128            for dsKey in dsKeys:         
     129                dsgCode, dsCode=[int(i) for i in dsKey.split("_")[-1].split(".")] 
     130                 
     131                dsgString="datasetGroup_%s" % dsgCode 
     132                vars=self.getVariableList(self.bag[dsgString], dsDict[dsKey]) 
     133                 
     134                count=1 
     135                for var in vars: 
     136                    choices.append(("variable_%s.%s.%s" % (dsgCode, dsCode, count), var)) 
     137                    count=count+1 
     138                 
     139            self.options=choices                     
     140 
     141        if self.options!=[]:   
    114142            # If datasetGroup, dataset or variable is the option then return 
    115143            return      
    116          
    117         dsg_ds_dsuri=self._getDatasetInfo(1) 
    118         dataFileHandler=apply(DatasetFormatDecider, dsg_ds_dsuri).datasetFormat 
    119                  
    120         # Now move on to the horizontal domain (fixed for all)            
    121         if not self._isHorizontalDomainDefined() and optsRequested in (None, "horizontalDomain"): 
    122             choices=("horizontalDomain", dataFileHandler.getHorizontalDomain(self.bag["datasetGroup_%s" % 1], 
    123                      self.bag["dataset_%s" % 1], self.bag["variable_%s" % 1]))   
    124             self.options["1"]=choices 
    125             return 
    126                       
    127         # Now deal with the other axes (varying with each variable). 
    128         for n in range(1, self.bag["numberOfDatasets"]+1): 
    129          
    130             dsg_ds_dsuri=self._getDatasetInfo(n) 
    131             dataFileHandler=apply(DatasetFormatDecider, dsg_ds_dsuri).datasetFormat              
    132              
    133             choices=None  
    134             if isUndefined(self.bag, "verticalDomain_%s" % n) and optsRequested in (None, "verticalDomain"): 
    135                 choices=("verticalDomain_%s" % n, dataFileHandler.getVerticalSpatialDomain(self.bag["datasetGroup_%s" % n], 
    136                          self.bag["dataset_%s" % n], self.bag["variable_%s" % n])) 
    137                 optsRequested="verticalDomain"  # to ensure all options are at this level 
    138                           
    139             elif not self._isTemporalDomainDefined(n) and optsRequested in (None, "temporalDomain"): 
    140                 choices=("temporalDomain_%s" % n, dataFileHandler.getTemporalDomain(self.bag["datasetGroup_%s" % n], 
    141                          self.bag["dataset_%s" % n], self.bag["variable_%s" % n])) 
    142                 optsRequested="temporalDomain"  # to ensure all options are at this level 
    143                                  
    144             if choices:  self.options[str(n)]=choices 
    145              
    146         if self.options!={}:   
    147             # If vertical or temporal domain is the option then return 
    148             return       
    149          
    150         if isUndefined(self.bag, "outputFormat") and optsRequested in (None, "outputFormat"): 
    151             choices=("outputFormat", OUTPUT_FORMATS) 
    152             self.options["1"]=choices 
    153         return 
    154      
     144 
     145        if optsRequested=="domainAndFormat": 
     146            self.options=self._getDomainOptions()+self._getFormatOptions() 
     147 
     148        elif not keyPatternMatch(self.bag, "axis_1"): 
     149            self.options=self._getDomainOptions()        
     150 
     151        elif not keyPatternMatch(self.bag, "outputFormat_") or optsRequested=="outputFormat": 
     152            self.options=self._getFormatOptions() 
     153     
     154     
     155    def _getDomainOptions(self): 
     156        """ 
     157        Returns the domain options list. 
     158        """ 
     159        choices=[] 
     160        varDict=getDictSubsetMatching(self.bag, r"variable_\d+\.\d+\.\d+", "regex") 
     161        varKeys=varDict.keys() 
     162        varKeys.sort() 
     163             
     164        for varKey in varKeys: 
     165            (dsgCode, dsCode, varCode)=[int(i) for i in varKey.split("_")[-1].split(".")] 
     166            dsgString="datasetGroup_%s" % dsgCode 
     167            dsString="dataset_%s.%s" % (dsgCode, dsCode) 
     168 
     169            datasetGroup=self.bag[dsgString] 
     170            dataset=self.bag[dsString] 
     171            dataHandler=DatasetFormatDecider(datasetGroup, dataset).datasetFormat 
     172            domain=dataHandler.getDomain(datasetGroup, dataset, varDict[varKey]) 
     173            count=1 
     174             
     175            for axis in domain: 
     176                choices.append(("axis_%s.%s.%s.%s" % (dsgCode, dsCode, varCode, count), axis)) 
     177                count=count+1 
     178                 
     179        return choices 
     180                            
     181 
     182    def _getFormatOptions(self): 
     183        """ 
     184        Returns the format options. 
     185        """ 
     186        choices=[] 
     187        varDict=getDictSubsetMatching(self.bag, r"variable_\d+\.\d+\.\d+", "regex") 
     188        varKeys=varDict.keys() 
     189        varKeys.sort() 
     190             
     191        for varKey in varKeys: 
     192            (dsgCode, dsCode, varCode)=[int(i) for i in varKey.split("_")[-1].split(".")] 
     193            dsgString="datasetGroup_%s" % dsgCode 
     194            dsString="dataset_%s.%s" % (dsgCode, dsCode) 
     195 
     196            datasetGroup=self.bag[dsgString] 
     197            dataset=self.bag[dsString] 
     198            dataHandler=DatasetFormatDecider(datasetGroup, dataset).datasetFormat 
     199             
     200            if isinstance(dataHandler, CDMSDataHandler): 
     201                outputFormatList=["NetCDF", "NASA Ames"] 
     202            else: 
     203                raise "Non CDMS data models not yet implemented." 
     204                 
     205            choices.append(("outputFormat_%s.%s.%s" % (dsgCode, dsCode, varCode), outputFormatList)) 
     206                 
     207        return choices 
     208  
    155209     
    156210    def getDatasetGroupList(self): 
     
    223277        and dataset/datasetURI. 
    224278        """ 
    225         #dsg_ds_dsuri=self._getDatasetInfo(n) 
    226         #datasetFormatType=apply(DatasetFormatDecider, dsg_ds_dsuri).datasetFormat 
    227         dataFileHandler=DatasetFormatDecider(datasetGroup, dataset, datasetURI).datasetFormat 
    228              
    229         rtVariables=dataFileHandler.getVariables(datasetGroup, dataset, datasetURI) 
     279        dataHandler=DatasetFormatDecider(datasetGroup, dataset, datasetURI).datasetFormat 
     280             
     281        rtVariables=dataHandler.getVariables(datasetGroup, dataset, datasetURI) 
    230282        rtVariables.sort() 
    231283        if rtVariables==[]: 
     
    234286        return rtVariables 
    235287     
    236              
    237     def _isTemporalDomainDefined(self, dset_num): 
    238         """ 
    239         Method to check if all required temporal domain fields have been set. 
    240         Returns 1 if yes and None if no. 
    241         """ 
    242         for n in range(1, self.bag["numberOfDatasets"]+1): 
    243             for item in ["startDateTime_%s" % n, "endDateTime_%s" % n]: 
    244                 if item not in self.bag.keys(): 
    245                     return 
    246         return 1 
    247      
    248      
    249     def _isHorizontalDomainDefined(self): 
    250         """ 
    251         Method to check if all required horizontal domain fields have been set. 
    252         Returns 1 if yes and None if no. 
    253         """ 
    254         for hk in HORIZ_KEYS: 
    255             if not self.bag.has_key(hk): 
    256                 return 
    257                  
    258         return 1 
    259288 
    260289 
    261290if __name__=="__main__": 
     291    x=OptionHandler({"userRoles":[], "username":"jane"}) 
     292    print x.options, "\n" 
     293     
     294    x=OptionHandler({"userRoles":[], "username":"jane", "datasetGroup_1":"Test Data Group 2",  
     295                          "datasetGroup_2":"Test Data Group 3"}) 
     296    print x.options, "\n"    
     297  
     298    x=OptionHandler({"userRoles":[], "username":"jane", "datasetGroup_1":"Test Data Group 2",  
     299                          "datasetGroup_2":"Test Data Group 3", "dataset_1.1":"Test Dataset 2", 
     300                          "dataset_2.1":"Test Dataset 3"}) 
     301    print x.options, "\n"     
     302 
     303    x=OptionHandler({"userRoles":[], "username":"jane", "datasetGroup_1":"Test Data Group 2",  
     304                          "datasetGroup_2":"Test Data Group 3", "dataset_1.1":"Test Dataset 2", 
     305                          "dataset_2.1":"Test Dataset 3", "variable_1.1.1":"var2", "variable_2.1.1":"var3"}) 
     306    print x.options, "\n"     
     307  
     308    x=OptionHandler({"userRoles":[], "username":"jane", "datasetGroup_1":"Test Data Group 2",  
     309                          "datasetGroup_2":"Test Data Group 3", "dataset_1.1":"Test Dataset 2", 
     310                          "dataset_2.1":"Test Dataset 3", "variable_1.1.1":"var2", "variable_2.1.1":"var3", 
     311                          "optionCategoryRequested":"domainAndFormat"}) 
     312    print x.options, "\n"         
     313    sys.exit() 
    262314    x=OptionHandler({"datasetURI_1":"file:/home/as56/abstractWebService/dxs/testdata/testdata1.xml", 
    263315                         "userRoles":[], "username":"jane", "numberOfDatasets":1}) 
    264316    print x.options, "\n\n" 
    265     x=OptionHandler({"datasetGroup_1":"Test Data Group 1", "dataset_1":"Test Dataset 1", "variable_1":"pqn", 
     317    x=OptionHandler({"datasetGroup_1":"Test Data Group 1", "dataset_1":"Test Dataset 1", "variable_1.1.1":"pqn", 
    266318                         "userRoles":[], "username":"jane", "numberOfDatasets":1}) 
    267     print x.options 
     319    print x.options, "\n" 
  • TI03-DataExtractor/trunk/pydxs/OutputManager.py

    r794 r1109  
    5656        self.outputDir=checkSubDirectory(self.bag["username"])   
    5757        self.DXDML=DXDMLHandler() 
    58                  
     58        self.varDict={} 
     59                         
    5960 
    6061    def _getDatasetDetails(self, varCodes): 
     
    8586        and estimated duration for producing the output. 
    8687        """ 
     88        if self.varDict!={}: 
     89            return self.varDict 
    8790        if self.bag.has_key("numericalOperation"): 
    8891            self._handleNumericalOperation(mode="file names") 
     
    172175            dataFileHandler=DatasetFormatDecider(datasetGroup, dataset, datasetURI).datasetFormat 
    173176            outputFormat=self.bag["outputFormat_%s" % varCodes] 
    174             print dataFileHandler 
     177            #print dataFileHandler 
    175178             
    176179            axisSelectionDict=getDictSubsetMatching(self.bag, "axis_%s" % varCodes) 
    177180 
    178181            timeStepStringList=dataFileHandler.getSelectedTimeSteps(datasetURI, varID, axisSelectionDict) 
    179                      
     182            
    180183            sizeOfRequest=dataFileHandler.getSelectedVariableSubsetSize(datasetURI, varID, axisSelectionDict) 
    181184            sizeOfRequest=self._adjustFileSizeByFormat(sizeOfRequest, outputFormat) 
     
    294297             
    295298            if outputFilePathList==None:  
    296                 outputFileName="%s_%s.%s" % (opMethod, os.getpid(), outputFormat)            
     299                outputFileName="%s_%s.%s" % (opMethod, os.getpid(), mapFileFormatToExtension(outputFormat))          
    297300                outputFilePathList=[os.path.join(self.outputDir, outputFileName)] 
    298301             
     
    305308 
    306309            (arrayShape, gridShape, size)=dataFileHandler.getSelectedVariableArrayDetails(datasetURI, varID, axisSelectionDict) 
    307             print gridShape, arrayShape 
     310            #print gridShape, arrayShape 
    308311            varGrids.append(gridShape) 
    309312            arrayShapes.append(arrayShape) 
     
    344347                varsToUse.append(dataFileHandler.readVariableSubsetIntoMemory(datasetURI, varID, axisSelectionDict)) 
    345348                 
    346             opController.performOperation(fileVarSelectorList) 
    347  
    348         self.varDict[0]=(datasetURI, opMethod, outputSize, outputFormat, outputFilePathList[:]) 
    349  
    350  
    351 """ 
    352             timeStepStringList=dataFileHandler.getSelectedTimeSteps(datasetURI, varID, axisSelectionDict) 
    353                      
    354             sizeOfRequest=dataFileHandler.getSelectedVariableSubsetSize(datasetURI, varID, axisSelectionDict) 
    355             sizeOfRequest=self._adjustFileSizeByFormat(sizeOfRequest, outputFormat) 
    356              
    357              
    358                      
    359             if sizeOfRequest>(MAX_FILE_SIZE*(2**20)) or ONE_FILE_PER_TIMESTEP==1: 
     349            data=opController.performOperation(varsToUse) 
     350             
     351            # Now write the data 
     352            outputHandler=self._getOutputHandler(outputFormat, dataFileHandler)  
     353            outputFilePath=outputFilePathList[0]                 
     354            outputFileHandler=outputHandler(outputFilePath) 
     355            outputFileHandler.writeVariableAndGlobalAttributes(data, {}) 
     356            outputFileHandler.closeFile() 
     357             
     358            print "\nWrote variable '%s' to output file: %s" % (data.id, outputFilePath)                     
     359             
     360 
     361        outputVarID=opMethod 
     362        self.varDict[0]=(datasetURI, outputVarID, outputSize, outputFormat, outputFilePathList[:]) 
     363 
     364 
     365             
    360366                     
    361                 print "\n\n\n", (MAX_FILE_SIZE*(2**20)), sizeOfRequest, ONE_FILE_PER_TIMESTEP 
    362                 if mode=="file names": 
    363                     fileNamer=FileNames(datasetGroup=datasetGroup, dataset=dataset, timeSteps=timeStepStringList,  
    364                                     fileFormat=outputFormat, variables=[varID], 
    365                                     basedir=self.outputDir) 
    366                     outputFilePathList=fileNamer.createFileNameList() 
    367                  
    368                 elif mode=="create outputs": 
    369                     # Now get the real data 
    370                     outputHandler=self._getOutputHandler(outputFormat, dataFileHandler) 
    371                      
    372                     outputFilePathList=[] 
    373                     for timeStep in timeStepStringList: 
    374                         fileNamer=FileNames(datasetGroup=datasetGroup, dataset=dataset, timeSteps=[timeStep],  
    375                                     fileFormat=outputFormat, variables=[varID], 
    376                                     basedir=self.outputDir) 
    377                         outputFilePath=fileNamer.createFileNameList()[0] 
    378                         outputFilePathList.append(outputFilePath) 
    379                                                  
    380                         data=dataFileHandler.readVariableSubsetIntoMemory(datasetURI, varID, axisSelectionDict, timeStep) 
    381                          
    382                         outputFileHandler=outputHandler(outputFilePath) 
    383                         globalAttributes=dataFileHandler.getCFGlobalAttributes(datasetURI) 
    384                         outputFileHandler.writeVariableAndGlobalAttributes(data, globalAttributes) 
    385                         outputFileHandler.closeFile() 
    386                         print "\nWrote variable '%s' to output file: %s" % (varID, outputFilePath)               
    387                          
    388             else: 
    389                 if len(timeStepStringList)==0: 
    390                     timeStepStringList=[] 
    391                 elif len(timeStepStringList)==1: 
    392                     timeStepStringList=timeStepStringList 
    393                 else: 
    394                     timeStepStringList=["%s-%s" % (timeStepStringList[0], timeStepStringList[-1])] 
    395                              
    396                 print "Work out file name as only one file..." 
    397                 fileNamer=FileNames(datasetGroup=datasetGroup, dataset=dataset, timeSteps=timeStepStringList,  
    398                                     fileFormat=outputFormat, variables=[varID], 
    399                                     basedir=self.outputDir) 
    400                 outputFilePathList=fileNamer.createFileNameList()        
    401                  
    402                 if mode=="create outputs": 
    403                     # Now get the real data 
    404                     outputHandler=self._getOutputHandler(outputFormat, dataFileHandler)          
    405                     outputFilePath=outputFilePathList[0] 
    406                     data=dataFileHandler.readVariableSubsetIntoMemory(datasetURI, varID, axisSelectionDict) 
    407                          
    408                     outputFileHandler=outputHandler(outputFilePath) 
    409                     globalAttributes=dataFileHandler.getCFGlobalAttributes(datasetURI) 
    410                     outputFileHandler.writeVariableAndGlobalAttributes(data, globalAttributes) 
    411                     outputFileHandler.closeFile() 
    412                     print "\nWrote variable '%s' to output file: %s" % (varID, outputFilePath)               
    413                      
    414      
    415             self.varDict[varCount]=(datasetURI, varID, sizeOfRequest, outputFormat, outputFilePathList[:]) 
    416          
    417 """ 
    418  
     367     
    419368 
    420369if __name__=="__main__": 
     
    429378    x=OutputManager({"username":"jane", "datasetGroup_1":"Test Data Group 1", 
    430379                     "dataset_1.3":"Test Dataset 1", "variable_1.3.1":"pqn", 
    431                      "axis_1.3.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     380                     "axis_1.3.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
    432381                     "outputFormat_1.3.1":"NetCDF", 
    433382                     "datasetGroup_2":"Test Data Group 2", 
    434383                     "dataset_2.1":"Test Dataset 2", "variable_2.1.1":"var2", 
    435                      "axis_2.1.1.0":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
     384                     "axis_2.1.1.1":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
    436385                     "outputFormat_2.1.1":"NetCDF"}) 
    437386 
     
    441390    x=OutputManager({"username":"jane", "datasetGroup_1":"Test Data Group 1", 
    442391                     "dataset_1.3":"Test Dataset 1", "variable_1.3.1":"pqn", 
    443                      "axis_1.3.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     392                     "axis_1.3.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
    444393                     "outputFormat_1.3.1":"NetCDF", 
    445394                     "datasetGroup_2":"Test Data Group 2", 
    446395                     "dataset_2.1":"Test Dataset 2", "variable_2.1.1":"var2", 
    447                      "axis_2.1.1.0":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
    448                      "axis_2.1.1.1":(30,-30), 
     396                     "axis_2.1.1.1":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
     397                     "axis_2.1.1.2":(30,-30), 
    449398                     "outputFormat_2.1.1":"NetCDF"}) 
    450399 
     
    455404    x=OutputManager({"username":"jane", "datasetGroup_1":"Test Data Group 1", 
    456405                     "dataset_1.3":"Test Dataset 1", "variable_1.3.1":"pqn", 
    457                      "axis_1.3.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     406                     "axis_1.3.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
    458407                     "outputFormat_1.3.1":"NetCDF", 
    459408                     "datasetGroup_2":"Test Data Group 2", 
    460409                     "dataset_2.1":"Test Dataset 2", "variable_2.1.1":"var2", 
    461                      "axis_2.1.1.0":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
    462                      "axis_2.1.1.1":(30,-30), 
     410                     "axis_2.1.1.1":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
     411                     "axis_2.1.1.2":(30,-30), 
    463412                     "outputFormat_2.1.1":"NetCDF"}) 
    464413    print x.getOutputFilePathDict()        
     
    466415    x=OutputManager({"username":"jane", "datasetGroup_1":"Test Data Group 1", 
    467416                     "dataset_1.3":"Test Dataset 1", "variable_1.3.1":"pqn", 
    468                      "axis_1.3.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     417                     "axis_1.3.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
    469418                     "outputFormat_1.3.1":"NetCDF", 
    470419                     "datasetGroup_2":"Test Data Group 2", 
    471420                     "dataset_2.1":"Test Dataset 2", "variable_2.1.1":"var2", 
    472                      "axis_2.1.1.0":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
    473                      "axis_2.1.1.1":(30,-30), 
     421                     "axis_2.1.1.1":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
     422                     "axis_2.1.1.2":(30,-30), 
    474423                     "outputFormat_2.1.1":"NetCDF"}) 
    475424    x.createOutputs()     
     
    479428    print x.getOutputSizes() 
    480429     
    481     x=OutputManager({"username":"jane", "datasetGroup_1":"Test Data Group 1", 
    482                      "dataset_1.3":"Test Dataset 1", "variable_1.3.1":"pqn", 
    483                      "axis_1.3.1.0":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
     430    print "\n\n\n" 
     431    print "DIFFERENCING VARS..." 
     432    x=OutputManager({"username":"jane", "datasetGroup_1":"Test Data Group 1", 
     433                     "dataset_1.3":"Test Dataset 1", "variable_1.3.1":"pqn", 
     434                     "axis_1.3.1.1":("1999-01-01T00:00:00", "1999-01-01T06:00:00"), 
    484435                     "outputFormat_1.3.1":"NetCDF", 
    485436                     "datasetGroup_2":"Test Data Group 2", 
    486437                     "dataset_2.1":"Test Dataset 2", "variable_2.1.1":"var2", 
    487                      "axis_2.1.1.0":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
    488                      "axis_2.1.1.1":(30,-30), 
     438                     "axis_2.1.1.1":("2004-01-01T12:00:00", "2004-01-01T12:00:00"), 
     439                     "axis_2.1.1.2":(30,-30), 
    489440                     "outputFormat_2.1.1":"NetCDF", 
    490                      "numericalOperation":"(variable2)-(variable1)"})    
    491      
     441                     "numericalOperation":"(var2)-(var1)"})      
     442     
     443    x.getOutputFilePathDict() 
     444    x.createOutputs() 
     445 
     446    print "TRYING REAL TEST.................." 
     447    x=OutputManager({'username':None, 'variable_1.1.1':'pqn',  
     448                     'outputFormat_1.1.1':'NetCDF', 'userRoles':[],  
     449                     'datasetGroup_1':'Test Data Group 1',  
     450                     'axis_1.1.1.3':(-30, 30), 'dataset_1.1':'Test Dataset 1'}) 
     451    print x.getOutputFilePathDict() 
  • TI03-DataExtractor/trunk/pydxs/__init__.py

    r794 r1109  
    3232# method calls to query the current options during a session. 
    3333from OptionHandler import OptionHandler  
    34  
    35 # MailUser class deals with mailing users 
    36 from mailUser import * 
    3734 
    3835# RequestDict is the wrapper class for the request dictionary 
  • TI03-DataExtractor/trunk/pydxs/common.py

    r794 r1109  
    3333 
    3434# Set up common functions 
     35 
     36def mapFileFormatToExtension(format): 
     37    """ 
     38    Returns a suitable file extension for a known file format. 
     39    """ 
     40    extMap={"NetCDF":"nc", "NASA Ames":"na"} 
     41    return extMap[format] 
     42     
    3543 
    3644def createTimeKeyList(): 
     
    5765 
    5866 
    59 def keyPatternMatch(dct, pattern): 
     67def keyPatternMatch(dct, pattern, mode="string match"): 
    6068    """ 
    6169    Returns 1 if one or more keys in the dictionary 'dct' match the 
     
    6371    """ 
    6472    for key in dct.keys(): 
    65         if key.find(pattern)>-1: 
    66             return 1 
     73        if mode=="string match": 
     74            if key.find(pattern)>-1: 
     75                return 1 
     76        elif mode=="regex": 
     77            match=re.search(pattern, key) 
     78            if match: 
     79                return 1 
    6780    return 0 
    6881 
     
    87100 
    88101 
    89 def getSortedKeysLike(dct, pattern): 
     102def getSortedKeysLike(dct, pattern, mode="string match"): 
    90103    """ 
    91104    Returns a list of all keys in the dictionary 'dct' that do a  
     
    94107    rtlist=[] 
    95108    for key in dct.keys(): 
    96         if key.find(pattern)>-1: 
    97             rtlist.append(key) 
     109        if mode=="string match": 
     110            if key.find(pattern)>-1: 
     111                rtlist.append(key) 
     112        elif mode=="regex": 
     113            match=re.search(pattern, key) 
     114            if match: 
     115                rtlist.append(key) 
    98116    rtlist.sort()         
    99117    return rtlist 
    100118     
    101119  
    102 def getDictSubsetMatching(dct, pattern): 
     120def getDictSubsetMatching(dct, pattern, mode="string match"): 
    103121    """ 
    104122    Returns a dictionary of all items in input dictionary 'dct' 
     
    107125    rtdict={} 
    108126    for key in dct.keys(): 
    109         if key.find(pattern)>-1: 
    110             rtdict[key]=dct[key] 
    111              
     127        if mode=="string match": 
     128            if key.find(pattern)>-1: 
     129                rtdict[key]=dct[key] 
     130        elif mode=="regex": 
     131            match=re.search(pattern, key) 
     132            if match: 
     133                rtdict[key]=dct[key]         
    112134    return rtdict 
    113135 
     
    267289 
    268290 
     291def createSummaryString(reqDict): 
     292    """ 
     293    Returns a summary string of a request dictionary. 
     294    """ 
     295    exclusions=("callMethod", "secureToken", "optionCategoryRequested",  
     296                "action", "targetPage", "sessionID") 
     297         
     298    summaryString=""     
     299    for key in reqDict.keys(): 
     300        if reqDict[key]!="" and key not in exclusions:   
     301            summaryString=summaryString+("%s:\t%s\n" % (key, reqDict[key])) 
     302     
     303    return summaryString 
     304 
     305 
    269306def makeDirsAndPerms(basedir, dirs, permissions, owner, verbose="no"): 
    270307    """ 
  • TI03-DataExtractor/trunk/pydxs/serverConfig.py

    r794 r1109  
    3333# can be called. 
    3434RESTRICTED_DATA=0 
     35 
     36# SECURITY_MODEL: 
     37# The name of the security model being used. The standard  
     38# ***and insecure (until you have implemented your local hooks)*** 
     39# version is "basic". NERC DataGrid is "ndg". 
     40SECURITY_MODEL="ndg" 
    3541 
    3642# PACKAGE_NAME: 
     
    111117# as the value of OUTPUT_DIR_LOCAL_PATH in the client (dxc) 
    112118# package. 
    113 OUTPUT_DIR="/srv/www/htdocs/dx/output" 
     119OUTPUT_DIR="/home/as56/apache/htdocs/dx/output" 
    114120 
    115121# OUTPUT_DIR_URL: 
  • TI03-DataExtractor/trunk/setup.py

    r794 r1109  
    198198            except: 
    199199                raise "Cannot create directory: %s" % OUTPUT_DIR""" 
     200            else: 
     201                makeDirAndPerm(OUTPUT_DIR, OUTPUT_DIR_PERMISSION, OUTPUT_FILE_USER, OUTPUT_FILE_GROUP)   
    200202 
    201203        for dirToMake in ["OUTPUT_DIR_LOCAL_PATH"]: 
     
    378380def checkBeforeMakingDir(dirname, permissions=0755, owner=None, group=None): 
    379381    """ 
    380     Checks with the user before deleting and re-creating directories. 
    381     """ 
     382   Checks with the user before deleting and re-creating directories. 
     383   """ 
    382384    if os.path.isdir(dirname): 
    383385        print "\nThis package needs uses the following directory which already exists:\n",dirname 
     
    394396    print "Directory is ready: ", dirname         
    395397 
     398 
    396399def removeDirWithCheck(dirname): 
    397400    """ 
     
    409412    """ 
    410413    if not os.path.isdir(dirname): 
    411         os.mkdir(dirname) 
     414        parentDir=os.path.split(dirname)[0] 
     415        if not os.path.isdir(parentDir): 
     416            makeDirAndPerm(parentDir) 
     417        os.mkdir(dirname) 
    412418        os.chmod(dirname, permissions) 
    413419        os.system("chown %s %s" % (owner, dirname)) 
Note: See TracChangeset for help on using the changeset viewer.