Ignore:
Timestamp:
15/01/10 16:26:13 (10 years ago)
Author:
pnorton
Message:

First attempt at getting the buildplot action to work.

Location:
qesdi/graphplotter/trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • qesdi/graphplotter/trunk

    • Property svn:ignore
      •  

        old new  
        11.pydevproject 
        22.project 
         3Paste-1.7.2-py2.5.egg 
         4PasteDeploy-1.3.3-py2.5.egg 
         5PasteScript-1.7.3-py2.5.egg 
  • qesdi/graphplotter/trunk/buildout

    • Property svn:ignore set to
      bin
      develop-eggs
      eggs
      parts
      .installed.cfg
  • qesdi/graphplotter/trunk/graphplotter.egg-info/PKG-INFO

    r6311 r6313  
    11Metadata-Version: 1.0 
    22Name: graphplotter 
    3 Version: 0.1dev-r6309 
     3Version: 0.1dev-r6311 
    44Summary: UNKNOWN 
    55Home-page: UNKNOWN 
  • qesdi/graphplotter/trunk/graphplotter.egg-info/SOURCES.txt

    r6311 r6313  
    11MANIFEST.in 
    22README.txt 
     3development.ini 
     4ez_setup.py 
    35setup.cfg 
    46setup.py 
     7test.ini 
     8buildout/bootstrap.py 
     9buildout/buildout.cfg 
     10buildout/pnorton_buildout.cfg 
     11df_config/co2.ini 
     12docs/index.txt 
    513graphplotter/__init__.py 
    614graphplotter/websetup.py 
  • qesdi/graphplotter/trunk/graphplotter/controllers/buildplot.py

    r6311 r6313  
    77 
    88from graphplotter.lib.df_config_reader import DFConfigReader 
     9from graphplotter.lib.data_reader import DataReader 
     10 
    911from graphplotter.lib.utils import getParams 
    1012 
     
    1921         
    2022        c.dataFiles = [''] + cr.getDataFileList() 
    21          
     23        log.debug("c.dataFiles = %s" % (c.dataFiles,)) 
    2224        params = getParams(request) 
    2325         
    24         c.selectedDataFile = params.get('datafile_select') 
     26        c.selectedDataFile = params.get('datafile', '') 
    2527         
    2628        # if datafile is selected, 
    27          
    28         #  need to know all the variables 
    29          
    30         #  if a variable is selected 
    31          
    32         #    need to know all the axis 
    33          
    34         #    if a plot axis is selected 
    35          
    36         #      need to make a selection 
    37          
    38         #      need to the ranges for numeric axis 
    39          
    40         #      need to the possible values for index axis 
     29        if c.selectedDataFile != '': 
     30             
     31            dfConfig = cr.getConfig(c.selectedDataFile) 
     32            reader = DataReader(dfConfig['path'], dfConfig['axisLookup']) 
     33             
     34            c.variables = [''] + reader.getVariableNames() 
     35            c.selectedVariable = params.get('variable', '') 
     36             
     37            if c.selectedVariable != '': 
     38                 
     39                c.axis = [''] + reader.getAxisNames(c.selectedVariable) 
     40                c.selectedAxis = params.get('axis', '') 
     41                 
     42                if c.selectedAxis != '': 
     43                     
     44                    for k in params: 
     45                        if k[:4] == 'sel_': 
     46                            log.debug("k = %s" % (k,)) 
     47                            setattr(c, k, params[k]) 
     48                                             
     49                    c.axisSelect = {} 
     50                     
     51                    for ax in c.axis: 
     52                        if ax in ['', c.selectedAxis]: 
     53                            continue 
     54                         
     55                        vals = reader.getAxisValues(c.selectedVariable, ax) 
     56                         
     57                        if type(vals[0]) == str: 
     58                            c.axisSelect[ax] = [''] + vals 
     59                        else: 
     60                            c.axisSelect[ax] = "%s - %s" % (min(vals), max(vals)) 
    4161         
    4262        return render('buildplot.html') 
  • qesdi/graphplotter/trunk/graphplotter/lib/data_reader.py

    r6311 r6313  
    1212class DataReader(object): 
    1313     
    14     def __init__(self, file, variable, axis, selection, axisLookup): 
     14    def __init__(self, file, axisLookup): 
    1515         
    1616        self.file = file 
    17         self.variable = variable 
    18         self.axis = axis 
    19         self.selection = selection 
    2017        self.axisLookup = axisLookup 
    2118     
    22     def getData(self): 
     19    def getData(self, variable, axis, selection): 
     20         
    2321        fin = cdms.open(self.file) 
    2422         
    2523        try: 
    26             var = fin(self.variable) 
     24            var = fin(variable) 
    2725             
    28             selKW = self._buildSelectionKeywords(fin, var) 
     26            selKW = self._buildSelectionKeywords(fin, var, axis, selection) 
    2927             
    30             xdata, ydata = self._getData(var, selKW) 
     28            xdata, ydata = self._getData(var, selKW, axis) 
    3129             
    3230        finally: 
     
    3533        return xdata, ydata 
    3634     
    37     def _buildSelectionKeywords(self, fin, var): 
     35    def getVariableNames(self): 
     36        fin = cdms.open(self.file) 
     37         
     38        variableNames = None 
     39 
     40        try: 
     41            variableNames = fin.listvariables() 
     42        finally: 
     43            fin.close() 
     44         
     45        return variableNames 
     46     
     47    def getAxisNames(self, variable): 
     48        fin = cdms.open(self.file) 
     49         
     50        axisNames = None 
     51        try: 
     52            var = fin(variable) 
     53            axisNames = var.getAxisIds() 
     54        finally: 
     55            fin.close() 
     56         
     57        return axisNames 
     58     
     59    def getAxisValues(self, variable, axis): 
     60        fin = cdms.open(self.file) 
     61         
     62        axisValues = None 
     63        try: 
     64            var = fin(variable) 
     65             
     66            if axis in self.axisLookup: 
     67                axisVar = fin(self.axisLookup[axis]) 
     68                axisValues = axisVar[:] 
     69                if type(axisValues[0]) is not str: 
     70                    axisValues = [self._getString(n) for n in axisValues]                 
     71            else: 
     72                axis = var.getAxis(var.getAxisIndex(axis)) 
     73                axisValues = axis[:] 
     74                 
     75        finally: 
     76            fin.close() 
     77         
     78        return axisValues 
     79     
     80    def getSelectionData(self, variable, axis): 
     81        """ 
     82        Get the data require to build a selection control to set the values of 
     83        the other axis given that variable and axis have already been selected. 
     84        """ 
     85        pass 
     86     
     87    def _buildSelectionKeywords(self, fin, var, axis, selection): 
    3888        selKW = {} 
    3989         
     
    4191            # we don't want to generate a selection for the axis 
    4292            # that will be used for the xdata 
    43             if ax.id == self.axis: 
     93            if ax.id == axis: 
    4494                continue 
    4595         
    46             value = self.selection[ax.id] 
     96            value = selection[ax.id] 
    4797     
    4898            if ax.id in self.axisLookup: 
     
    61111        return selKW 
    62112     
    63     def _getData(self, var, selKW): 
     113    def _getData(self, var, selKW, axis): 
    64114         
    65115        #get the y data by selecting from the variable 
     
    67117         
    68118        #get the x-data from the named axis 
    69         xdata = var.getAxis(var.getAxisIndex(str(self.axis)))[:] 
     119        xdata = var.getAxis(var.getAxisIndex(axis))[:] 
    70120         
    71121        return xdata, ydata 
  • qesdi/graphplotter/trunk/graphplotter/lib/df_config_reader.py

    r6311 r6313  
    5151         
    5252        files = os.listdir(self.configDirectory) 
    53         dataFiles = [x[:-4] for x in files] 
     53        dataFiles = [] 
     54        for f in files: 
     55             
     56            path = os.path.join(self.configDirectory, f) 
     57             
     58            #skip directories 
     59            if os.path.isdir(path): continue 
     60             
     61            # skip hidden or non ini files 
     62            if f[0] == '.' or f[-4:] != '.ini': continue 
     63             
     64            dataFiles.append(f[:-4]) 
     65         
    5466         
    5567        return dataFiles 
  • qesdi/graphplotter/trunk/graphplotter/lib/helpers.py

    r6311 r6313  
    66# Import helpers as desired, or define your own, ie: 
    77 
    8 from webhelpers.html.tags import select 
     8from webhelpers.html.tags import select, text 
     9from routes import url_for 
  • qesdi/graphplotter/trunk/graphplotter/lib/plot_builder.py

    r6311 r6313  
    3232         
    3333         
    34         reader = DataReader(self.config['path'], self.params['variable'],  
    35                             self.params['axis'], selection,  
    36                             self.config['axisLookup']) 
     34        reader = DataReader(self.config['path'], self.config['axisLookup']) 
    3735         
    38          
    39         xdata, ydata = reader.getData() 
     36        log.debug("reader.getData = %s" % (reader.getData,)) 
     37        xdata, ydata = reader.getData(self.params['variable'],  
     38                            self.params['axis'], selection) 
    4039         
    4140        log.debug("xdata = %s, ydata = %s" % (xdata, ydata,)) 
  • qesdi/graphplotter/trunk/graphplotter/lib/utils.py

    r6311 r6313  
    1010    for k in request.params.keys(): 
    1111        value = request.params[k] 
    12          
    13         if value == "": 
    14             value = None 
    15          
     12                 
    1613        if value.__class__ == unicode: 
    1714            value = value.encode('latin-1') 
  • qesdi/graphplotter/trunk/graphplotter/templates/buildplot.html

    r6311 r6313  
    1616<script type="text/javascript"> 
    1717 
     18var refreshAction = "${h.url_for(controller='buildplot')}"; 
     19var plotAction = "${h.url_for(controller='getplot')}"; 
    1820function init() { 
    1921     
     
    2426    form.action = refreshAction; 
    2527    form.target = ''; 
     28    form.submit(); 
     29} 
     30 
     31function onPlotClick() { 
     32    var form = document.getElementById('buildplot'); 
     33    form.action = plotAction; 
     34    form.target = '_blank'; 
    2635    form.submit(); 
    2736} 
     
    3847     
    3948    <form id='buildplot'> 
     49        <div> 
     50            Select Data File: 
     51            ${ h.select('datafile', c.selectedDataFile, c.dataFiles)} 
     52        </div> 
     53         
     54         <py:if test="c.selectedDataFile != ''"> 
     55             
     56         <div> 
     57            Select Variable: 
     58            ${ h.select('variable', c.selectedVariable, c.variables)} 
     59         </div> 
     60          
     61         </py:if> 
     62          
     63         <py:if test="c.selectedVariable != ''"> 
     64             
     65         <div> 
     66            Select Plotting Axis: 
     67            ${ h.select('axis', c.selectedAxis, c.axis)} 
     68         </div> 
     69          
     70         </py:if> 
     71          
     72          
     73         <py:if test="c.selectedAxis != ''"> 
     74          
     75         <div> 
     76            Axis Selection: 
     77             
     78            <py:for each="axSelect in c.axisSelect.keys()"> 
     79            <div> 
     80                ${axSelect}: 
     81                <py:if test="type(c.axisSelect[axSelect]) is str"> 
     82                Range ${c.axisSelect[axSelect] + ' ' + h.text('sel_' + axSelect)} 
     83                </py:if> 
     84                <py:if test="type(c.axisSelect[axSelect]) is not str"> 
     85                ${h.select('sel_' + axSelect, getattr(c, 'sel_' + axSelect), c.axisSelect[axSelect])} 
     86                </py:if> 
     87            </div>                 
     88            </py:for> 
     89         </div> 
     90          
     91         </py:if> 
     92         
     93         
    4094    </form> 
    41     <div> 
    42         Select Data File: 
    43         ${ h.select('datafile_select', c.selectedDataFile, c.dataFiles)} 
    44     </div> 
    4595     
    4696    <input type="button" value="Refresh" onClick="onRefreshClick();"></input> 
     97    <input type="button" value="Plot" onClick="onPlotClick();"></input> 
    4798</body> 
    4899 
  • qesdi/graphplotter/trunk/graphplotter/tests/functional/test_buildplot.py

    r6311 r6313  
    55class TestBuildplotController(TestController): 
    66 
     7    @patch('graphplotter.controllers.buildplot.DataReader', spec=True) 
    78    @patch('graphplotter.controllers.buildplot.DFConfigReader', spec=True) 
    8     def test_001_indexContainsDataFiles(self, mockConfigReader): 
     9    def test_001_indexContainsDataFiles(self, mockConfigReader, mockDataReader): 
    910         
    1011        configFiles = ['alpha','beta','gamma','delta'] 
     
    1819        for cf in configFiles: 
    1920            assert cf in response 
     21             
     22        assert mockDataReader.called == False 
    2023     
    21      
     24    @patch('graphplotter.controllers.buildplot.DataReader', spec=True) 
     25    @patch('graphplotter.controllers.buildplot.DFConfigReader', spec=True) 
     26    def test_002_indexContainsVariable(self, mockConfigReader, mockDataReader): 
     27         
     28        dfConfig = {'path':'/path/to/file.nc', 'axisLookup':{'a':'b'}} 
     29        configFiles = ['alpha','beta','gamma','delta'] 
     30        variable = ['red', 'blue', 'green', 'yellow'] 
     31         
     32        mockDataReader().getVariableNames.return_value = variable 
     33        mockConfigReader().getDataFileList.return_value = configFiles 
     34        mockConfigReader().getConfig.return_value = dfConfig 
     35         
     36        response = self.app.get(url(controller='buildplot', action='index'), {'datafile':'alpha'}) 
     37         
     38        print response.body 
     39         
     40        # check that the alpha value is selected 
     41        assert 'selected="selected" value="alpha"' in response 
     42         
     43        assert mockConfigReader().getConfig.callled 
     44        assert mockConfigReader().getConfig.call_args[0] == ('alpha',) 
     45         
     46        assert mockDataReader.called 
     47        assert mockDataReader.call_args == ((dfConfig['path'], dfConfig['axisLookup']), {}) 
     48         
     49        for v in variable: 
     50            assert v in response, "variable '%s' not found in response" % (v,) 
     51         
     52    @patch('graphplotter.controllers.buildplot.DataReader', spec=True) 
     53    @patch('graphplotter.controllers.buildplot.DFConfigReader', spec=True) 
     54    def test_003_indexContainsAxis(self, mockConfigReader, mockDataReader): 
     55         
     56        dfConfig = {'path':'/path/to/file.nc', 'axisLookup':{'a':'b'}} 
     57        configFiles = ['alpha','beta','gamma','delta'] 
     58        variable = ['red', 'blue', 'green', 'yellow'] 
     59        axis = ['circle','square','triangle', 'rectangle'] 
     60         
     61        mockDataReader().getVariableNames.return_value = variable 
     62        mockConfigReader().getDataFileList.return_value = configFiles 
     63        mockConfigReader().getConfig.return_value = dfConfig 
     64        mockDataReader().getAxisNames.return_value = axis 
     65         
     66        response = self.app.get(url(controller='buildplot', action='index'), {'datafile':'alpha', 
     67                                                                              'variable':'blue'}) 
     68         
     69        print response.body 
     70         
     71        # check that the blue variable value is selected 
     72        assert 'selected="selected" value="blue"' in response, "variable 'blue' wasn't selected in the response" 
     73         
     74        # check that the axis were requested for the blue variable 
     75         
     76        assert mockDataReader().getAxisNames.called 
     77        assert mockDataReader().getAxisNames.call_args == (('blue',), {}) 
     78                 
     79        for a in axis: 
     80            assert a in response, "axis '%s' not found in response" % (a,) 
     81             
     82    @patch('graphplotter.controllers.buildplot.DataReader', spec=True) 
     83    @patch('graphplotter.controllers.buildplot.DFConfigReader', spec=True) 
     84    def test_004_indexContainsAxisValueSelection(self, mockConfigReader, mockDataReader): 
     85         
     86        dfConfig = {'path':'/path/to/file.nc', 'axisLookup':{'a':'b'}} 
     87        configFiles = ['alpha','beta','gamma','delta'] 
     88        variable = ['red', 'blue', 'green', 'yellow'] 
     89        axis = ['circle','square','triangle', 'rectangle'] 
     90         
     91        mockDataReader().getVariableNames.return_value = variable 
     92        mockConfigReader().getDataFileList.return_value = configFiles 
     93        mockConfigReader().getConfig.return_value = dfConfig 
     94        mockDataReader().getAxisNames.return_value = axis 
     95         
     96        axisValues  = {'circle':['a','b','c'], 
     97                       'square':['one','two','three'],  
     98                       'triangle':[1.5,2.0,3.8]} 
     99         
     100        def getAxisVals(var, name): 
     101            assert var == 'blue' 
     102            return axisValues[name] 
     103         
     104        mockDataReader().getAxisValues.side_effect = getAxisVals 
     105         
     106        response = self.app.get(url(controller='buildplot', action='index'), {'datafile':'alpha', 
     107                                                                              'variable':'blue', 
     108                                                                               'axis':'rectangle'}) 
     109         
     110        print response.body 
     111         
     112        # check that the rectangle axis value is selected 
     113        assert 'selected="selected" value="rectangle"' in response, "axis 'rectangle' wasn't selected in the response" 
     114         
     115        # check that the index values appear in the response 
     116        for ax in ['circle','square']: 
     117            for v in axisValues[ax]: 
     118                assert  '<option value="%s">%s</option>' % (v, v) in response, " option '%s' wasn't found in the response" % (v,) 
     119             
     120        # check that the range appears in the response 
     121        assert '1.5 - 3.8' in response 
  • qesdi/graphplotter/trunk/graphplotter/tests/unit/test_data_reader.py

    r6311 r6313  
    1818        self.axisLookup = {'axisB':'axisB_var', 'axisC':'axisC_var'} 
    1919         
    20         self.reader  = DataReader(self.file, self.variable, self.axis, self.selection, self.axisLookup) 
     20        self.reader  = DataReader(self.file, self.axisLookup) 
    2121     
    2222     
     
    5959        self._setMockFHSideEffect(mockFH, mockVariable) 
    6060                 
    61         xdata, ydata = self.reader.getData() 
     61        xdata, ydata = self.reader.getData(self.variable, self.axis, self.selection) 
    6262     
    6363        #opens the file 
     
    8989        self._setMockFHSideEffect(mockFH, mockVariable) 
    9090         
    91         xdata, ydata = self.reader.getData() 
     91        xdata, ydata = self.reader.getData(self.variable, self.axis, self.selection) 
    9292         
    9393        assert xdata == mockVariable.getAxis.return_value 
     
    9696        assert mockVariable.call_args == ((), {'axisB': 0, 'axisC': 1, 'axisD':40, 'squeeze':1}) 
    9797         
     98    @patch('graphplotter.lib.data_reader.cdms', spec=True) 
     99    def test_003_getsVariableNames(self, mockCDMS): 
     100                 
     101        mockFH = mockCDMS.open.return_value 
     102         
     103        assert mockFH.listvariables.return_value == self.reader.getVariableNames() 
     104         
     105    @patch('graphplotter.lib.data_reader.cdms', spec=True) 
     106    def test_004_getsAxisNamesForVariable(self, mockCDMS): 
     107                 
     108        mockFH = mockCDMS.open.return_value 
     109         
     110        mockFH().getAxisIds.return_value = ['axisA','axisB','axisC','axisD'] 
     111         
     112        assert mockFH().getAxisIds.return_value == self.reader.getAxisNames('variable1') 
     113         
     114        assert mockFH.called 
     115        assert mockFH.call_args == (('variable1',), {}) 
     116      
     117    @patch('graphplotter.lib.data_reader.cdms', spec=True) 
     118    def test_006_getAxisValues(self, mockCDMS): 
     119         
     120        mockFH = mockCDMS.open.return_value 
     121         
     122        mockVar = Mock() 
     123        mockVar.getAxis.return_value = [1,2,3,4,5] 
     124         
     125        def fhOpenVar(name): 
     126            if name == 'var1': 
     127                return mockVar 
     128            elif name == 'axisB_var': 
     129                return ['one','two','three'] 
     130            else: 
     131                raise Exception("Unknown variable %s" % (name,)) 
     132             
     133        mockFH.side_effect = fhOpenVar 
     134         
     135        # test for an axis with a lookup variable 
     136        bValues = self.reader.getAxisValues('var1','axisB', ) 
     137        assert bValues == ['one','two','three'] 
     138         
     139        # test for an axis without a lookup variable 
     140        dValues = self.reader.getAxisValues('var1','axisD', ) 
     141        assert dValues == [1,2,3,4,5]  
     142 
     143        assert mockVar.getAxisIndex.called 
     144        assert mockVar.getAxisIndex.call_args == (('axisD',), {}) 
     145         
     146        assert mockVar.getAxis.called 
     147        assert mockVar.getAxis.call_args == ((mockVar.getAxisIndex.return_value,), {}) 
     148         
     149     
  • qesdi/graphplotter/trunk/graphplotter/tests/unit/test_df_config_reader.py

    r6311 r6313  
    6060        pprint(config) 
    6161     
     62    @patch('os.path.isdir') 
    6263    @patch('os.listdir') 
    63     def test_002_getDataFileList(self, mockListDir): 
     64    def test_002_getDataFileList(self, mockListDir, mockIsDir): 
     65 
     66        # say that no files are directories appart from the 'a_directory.ini' file 
     67        def isDir(path): 
     68            if path == self.newConfig['df_config_dir'] + '/a_directory.ini': 
     69                return True 
     70            return False 
     71         
     72        mockIsDir.side_effect = isDir 
    6473         
    6574        configFiles = ['co2', 'temp', 'sea_level'] 
    66         configFilesWithIni = [x + '.ini' for x in configFiles] 
     75        allFiles = [x + '.ini' for x in configFiles] + ['.hiddenFile', 'a_directory.ini'] 
    6776         
    68         mockListDir.return_value = configFilesWithIni 
     77        mockListDir.return_value = allFiles 
    6978         
    7079        reader = DFConfigReader() 
     
    7887         
    7988         
    80          
    8189     
  • qesdi/graphplotter/trunk/graphplotter/tests/unit/test_plot_builder.py

    r6311 r6313  
    5959         
    6060        assert img == 'returned image' 
    61          
    62         print mockDataReader.called 
    63         print mockDataReader.call_args 
    64          
     61                 
    6562        expectedSelection = {'scenario':'B1', 
    6663                             'model':'isam', 
    6764                             'sensitivity':'High'} 
    6865         
    69         expectedArgs = (self.config['path'], self.params['variable'], self.params['axis'], 
     66        expectedArgs =  (self.params['variable'], self.params['axis'], 
    7067                        expectedSelection, self.config['axisLookup']) 
    7168         
    72         print "mockDataReader.call_args[0]", mockDataReader.call_args[0] 
    73         print "expectedArgs", expectedArgs 
    7469         
    7570        assert mockDataReader.called 
    76         assert mockDataReader.call_args[0] == expectedArgs 
     71        assert mockDataReader.call_args[0] == (self.config['path'],) 
    7772         
     73        assert mockDataReader().getData.called 
     74        assert mockDataReader().getData.call_args[0] == expectedArgs 
     75         
Note: See TracChangeset for help on using the changeset viewer.