Changeset 2285


Ignore:
Timestamp:
Feb 8, 2010 1:48:54 PM (9 years ago)
Author:
wehart
Message:

Working through more examples of the 'import' command.

Location:
coopr.pyomo/trunk/coopr/pyomo
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/data/TableData.py

    r2274 r2285  
    6161
    6262    def _set_data(self, headers, rows):
     63        if self.options.symbol_map is None:
     64            mapped_headers = map(str,list(headers))
     65        else:
     66            mapped_headers = [self.options.symbol_map[tuple(header)] if tuple(header) in self.options.symbol_map else header for header in map(str,list(headers))]
     67        #print "X",mapped_headers,self.options.symbol_map,self.options.index
     68
    6369        if not self.options.set is None:
    6470           if self.options.format is None:
     
    6874           elif self.options.format is "set_array":
    6975              self._info = ["set",self.options.set, ":"]
    70               self._info = self._info + list(headers[1:])
     76              self._info = self._info + list(mapped_headers[1:])
    7177              self._info = self._info + [":="]
    7278              for row in rows:
     
    7783        elif self.options.index is not None and self.options.param is None:
    7884           self._info = ["param",":",self.options.index,":"]
    79            self._info = self._info + map(str,list(headers[1:]))
     85           self._info = self._info + mapped_headers[1:]
    8086           self._info.append(":=")
    8187           for row in rows:
     
    96102        elif self.options.param is not None and self.options.format is not None:
    97103           if self.options.format is "transposed_array":
    98               self._info = ["param",self.options.param,"(tr)",":"] + map(str,list(headers[1:]))
     104              self._info = ["param",self.options.param,"(tr)",":"] + mapped_headers[1:]
    99105           elif self.options.format is "array":
    100               self._info = ["param",self.options.param,":"] + map(str,list(headers[1:]))
     106              self._info = ["param",self.options.param,":"] + mapped_headers[1:]
    101107           else:
    102108              raise ValueError, "Unknown parameter format: "+self.options.format
     
    106112
    107113        else:
    108            if len(headers) == 1:
    109               self._info = ["set",headers[0],":="]
     114           if len(mapped_headers) == 1:
     115              self._info = ["set",mapped_headers[0],":="]
    110116              for row in rows:
    111117                self._info = self._info + list(row)
     
    113119              self._info = ["param",":"]
    114120              if self.options.param is None:
    115                  self._info = self._info + map(str,list(headers[1:]))
     121                 self._info = self._info + mapped_headers[1:]
    116122              elif type(self.options.param) is str:
    117123                 self._info = self._info + [self.options.param]
  • coopr.pyomo/trunk/coopr/pyomo/data/parse_datacmds.py

    r2279 r2285  
    8585
    8686def t_WORD(t):
    87     r'[a-zA-Z_][a-zA-Z_0-9\.\[\],]*'
     87    r'[a-zA-Z_0-9][a-zA-Z_0-9\.]*'
    8888    t.type = reserved.get(t.value,'WORD')    # Check for reserved words
    8989    return t
     
    127127
    128128def p_statement(p):
    129     '''statement : SET items COLONEQ setdecl SEMICOLON
    130                  | SET items COLONEQ SEMICOLON
     129    '''statement : SET WORD COLONEQ setdecl SEMICOLON
     130                 | SET WORD COLONEQ SEMICOLON
     131                 | SET WORD COLON items COLONEQ setdecl SEMICOLON
     132                 | SET WORD COLON items COLONEQ SEMICOLON
     133                 | SET indexed_word COLONEQ setdecl SEMICOLON
     134                 | SET indexed_word COLONEQ SEMICOLON
    131135                 | PARAM items COLONEQ paramdecl SEMICOLON
    132136                 | IMPORT importdecl SEMICOLON
     
    138142    global _parse_info
    139143    #print "STATEMENT",len(p), p[1:]
    140     if p[1] in ['set','param','import']:
     144    if p[1] in ['set','param']:
    141145        _parse_info.append( flatten(p[1:-1]) )
    142146    elif p[1] in ['include']:
    143147        _parse_info.append( p[1:-1] )
     148    elif p[1] in ['import']:
     149        _parse_info.append( [p[1]]+ p[2] )
     150        #_parse_info.append( [p[1], p[2][0], p[1:-1] )
    144151
    145152def p_setdecl(p):
     
    154161    '''importdecl : filename import_options
    155162                  | filename
    156                   | filename import_options COLON indices variable variable_options
    157                   | filename COLON indices variable variable_options
    158     '''
    159     p[0] = p[1]
     163                  | filename import_options COLON indices variable_options
     164                  | filename COLON indices variable_options
     165                  | filename import_options COLON variable_options
     166                  | filename COLON variable_options
     167    '''
     168    tmp = {'filename':p[1]}
     169    if len(p) == 2:
     170        p[0] = [tmp, [], {}]
     171    elif len(p) == 3:
     172        tmp.update(p[2])
     173        p[0] = [tmp, [], {}]
     174    elif len(p) == 4:
     175        p[0] = [tmp, [], p[3]]
     176    elif len(p) == 5:
     177        if p[2] == ':':
     178            p[0] = [tmp, p[3], p[4]]
     179        else:
     180            p[0] = [tmp, [], p[4]]
     181    elif len(p) == 6:
     182        tmp.update(p[2])
     183        p[0] = [tmp, p[4], p[5]]
     184    else:
     185        raise IOError, "Unexpected condition"
    160186
    161187def p_import_options(p):
     
    165191                      | WORD EQ QUOTEDSTRING
    166192    '''
    167     if len(p) == 3:
    168         p[0] = [p[1], p[3]]
    169     else:
    170         p[0] = [p[1], p[3]] + p[4]
     193    tmp = {p[1]:p[3]}
     194    if len(p) == 4:
     195        p[0] = tmp
     196    else:
     197        tmp.update(p[4])
     198        p[0] = tmp
    171199
    172200def p_variable_options(p):
     
    175203    '''
    176204    if len(p) == 2:
    177         p[0] = [p[1]]
    178     else:
    179         p[0] = [p[1]] + p[2]
     205        p[0] = p[1]
     206    else:
     207        p[1].update(p[2])
     208        p[0] = p[1]
    180209
    181210def p_variable(p):
    182211    '''variable : WORD
    183212                | WORD COLON WORD
    184     '''
    185     p[0] = p[1:]
     213                | WORD COLON WORD index_list
     214    '''
     215    if len(p) == 2:
     216        p[0] = {p[1]:[p[1]]}
     217    elif len(p) == 4:
     218        p[0] = {p[1]:[p[3]]}
     219    else:
     220        p[0] = {p[1]:[p[3]]+p[4]}
    186221
    187222def p_indices(p):
    188     '''indices : LBRACKET WORD index_list RBRACKET'''
    189     p[0] = p[1:]
     223    '''indices : LBRACKET WORD index_list RBRACKET
     224               | LBRACKET WORD RBRACKET
     225    '''
     226    if len(p) == 5:
     227        p[0] = [p[2]] + p[3]
     228    else:
     229        p[0] = [p[2]]
    190230
    191231def p_index_list(p):
    192232    '''index_list : COMMA WORD index_list
    193                   |
    194     '''
    195     p[0] = p[1:]
     233                  | COMMA WORD
     234    '''
     235    if len(p) == 4:
     236        p[0] = [p[2]]+p[3]
     237    else:
     238        p[0] = [p[2]]
     239
     240def p_indexed_word(p):
     241    '''indexed_word : WORD LBRACKET WORD index_list RBRACKET
     242                    | WORD LBRACKET WORD RBRACKET
     243    '''
     244    if len(p) == 6:
     245        p[0] = p[1]+p[2]+",".join([p[3]]+p[4])+p[5]
     246    else:
     247        p[0] = p[1]+p[2]+p[3]+p[4]
    196248
    197249def p_items(p):
  • coopr.pyomo/trunk/coopr/pyomo/data/process_data.py

    r2278 r2285  
    442442
    443443def _process_import(cmd, _model, _data, _default):
    444     #print "IMPROT",cmd
     444    #print "IMPORT",cmd
    445445    if len(cmd) < 2:
    446446        raise IOError, "The 'import' command must specify a filename"
     447
     448    options = Options(**cmd[1])
     449    for key in options:
     450        if not key in ['range','filename','format','using','query']:
     451            raise ValueError, "Unknown import option '%s'" % key
    447452
    448453    global Filename
     
    451456    Lineno = 0
    452457
    453     options = Options()
    454     options.file = cmd[1]
    455     cndx = 2
    456     while cndx < len(cmd) and cmd[cndx] != ':':
    457         cndx += 1
    458     #
    459     # Parse options
    460     #
    461     ndx = 2
    462     while ndx < cndx:
    463         if cmd[ndx] == 'range':
    464             if cndx == ndx+1:
    465                 raise ValueError, "No argument for 'range' option"
    466             options.range = cmd[ndx+1]
    467             ndx += 2
    468         elif cmd[ndx] == 'format':   
    469             if cndx == ndx+1:
    470                 raise ValueError, "No argument for 'format' option"
    471             options.format = cmd[ndx+1]
    472             ndx += 2
    473         elif cmd[ndx] == 'using':   
    474             if cndx == ndx+1:
    475                 raise ValueError, "No argument for 'using' option"
    476             options.using = cmd[ndx+1]
    477             ndx += 2
    478         elif cmd[ndx] == 'query':   
    479             if cndx == ndx+1:
    480                 raise ValueError, "No argument for 'query' option"
    481             options.query = cmd[ndx+1]
    482             ndx += 2
    483         else:
    484             raise ValueError, "Unknown option '%s'" % cmd[ndx]
    485458    #
    486459    # TODO: process mapping info
    487460    #
    488     tmp = options.file.split(".")[-1]
     461    tmp = options.filename.split(".")[-1]
    489462    data = DataManagerFactory(tmp)
    490     data.initialize(options.file)
     463    set_name=None
     464    #
     465    # Create symbol map
     466    #
     467    symb_map = {}
     468    for key in cmd[3]:
     469        symb_map[ tuple(cmd[3][key]) ] = key
     470    if len(cmd[2]) == 0:
     471        index=None
     472        if len(cmd[3]) == 1:
     473            set_name=cmd[3].keys()[0]
     474    else:
     475        tmp = []
     476        for item in cmd[2]:
     477            for key in symb_map:
     478                if item == key[0]:
     479                    tmp.append(symb_map[key])
     480        index=' '.join(tmp)
     481        if len(tmp) == 0 and len(cmd[3]) == 1:
     482            set_name=cmd[3].keys()[0]
     483    data.initialize(options.filename, index=index, symbol_map=symb_map, set=set_name)
    491484    data.open()
    492485    data.read()
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_modeldata.py

    r2279 r2285  
    308308        os.remove(currdir+'importB.dat')
    309309
    310     def Xtest_tableC(self):
     310    def test_tableC(self):
    311311        """Importing a multi-column table, where all columns are
    312312        treated as values for a set with tuple values."""
    313313        pyutilib.misc.setup_redirect(currdir+'importC.dat')
    314         print "import "+os.path.abspath(example_dir+'C.tab')+" : C:A,B ;"
    315         pyutilib.misc.reset_redirect()
    316         model=Model()
    317         model.A = Set()
    318         model.B = Set()
    319         model.C = model.A * model.B
     314        print "import "+os.path.abspath(example_dir+'C.tab')+" : C ;"
     315        pyutilib.misc.reset_redirect()
     316        model=Model()
     317        model.C = Set(dimen=2)
    320318        instance = model.create(currdir+'importC.dat')
    321         self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
    322         self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
    323         self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
     319        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
     320        os.remove(currdir+'importC.dat')
     321
     322    def Xtest_tableD(self):
     323        """Importing a 2D array of data as a set."""
     324        pyutilib.misc.setup_redirect(currdir+'importD.dat')
     325        print "import "+os.path.abspath(example_dir+'D.tab')+" format=set_array: C ;"
     326        pyutilib.misc.reset_redirect()
     327        model=Model()
     328        model.C = Set(dimen=2)
     329        instance = model.create(currdir+'importD.dat')
     330        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
    324331        os.remove(currdir+'importC.dat')
    325332
     
    339346        os.remove(currdir+'importS.dat')
    340347
    341     def test_tableXW(self):
     348    def test_tableXW_1(self):
    342349        """Importing a table, but only reporting the values for the non-index
    343350        parameter columns.  The first column is assumed to represent an
     
    356363        os.remove(currdir+'importXW.dat')
    357364
     365    def test_tableXW_2(self):
     366        """Like test_tableXW_1, except that set A is not defined."""
     367        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
     368        print "import "+os.path.abspath(example_dir+'XW.tab')+" ;"
     369        pyutilib.misc.reset_redirect()
     370        model=Model()
     371        model.A = Set()
     372        model.X = Param(model.A)
     373        model.W = Param(model.A)
     374        instance = model.create(currdir+'importXW.dat')
     375        self.failUnlessEqual(instance.A.data(), set())
     376        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     377        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
     378        os.remove(currdir+'importXW.dat')
     379
     380    def test_tableXW_3(self):
     381        """Like test_tableXW_1, except that set A is defined in the import statment."""
     382        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
     383        print "import "+os.path.abspath(example_dir+'XW.tab')+" : [A] A X W;"
     384        pyutilib.misc.reset_redirect()
     385        model=Model()
     386        model.A = Set()
     387        model.X = Param(model.A)
     388        model.W = Param(model.A)
     389        instance = model.create(currdir+'importXW.dat')
     390        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
     391        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     392        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
     393        os.remove(currdir+'importXW.dat')
     394
     395    def test_tableXW_4(self):
     396        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
     397        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
     398        print "import "+os.path.abspath(example_dir+'XW.tab')+" : [A] B:A R:X S:W;"
     399        pyutilib.misc.reset_redirect()
     400        model=Model()
     401        model.B = Set()
     402        model.R = Param(model.B)
     403        model.S = Param(model.B)
     404        instance = model.create(currdir+'importXW.dat')
     405        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
     406        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     407        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
     408        os.remove(currdir+'importXW.dat')
     409
    358410    def test_tableY(self):
    359411        """Same as tableXW."""
Note: See TracChangeset for help on using the changeset viewer.