source: coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_modeldata.py @ 2306

Last change on this file since 2306 was 2306, checked in by wehart, 10 years ago

Adding tests for importing CSV files.

File size: 47.5 KB
Line 
1#
2# Unit Tests for ModelData objects
3#
4
5import unittest
6import os
7import sys
8from os.path import abspath, dirname
9coopr_dir=dirname(dirname(abspath(__file__)))+os.sep+".."+os.sep+".."
10sys.path.insert(0, coopr_dir)
11from coopr.pyomo import *
12import coopr
13import pyutilib.common
14
15currdir=dirname(abspath(__file__))+os.sep
16example_dir=coopr_dir+os.sep+".."+os.sep+"examples"+os.sep+"pyomo"+os.sep+"tutorials"+os.sep+"tab"+os.sep
17csv_dir=coopr_dir+os.sep+".."+os.sep+"examples"+os.sep+"pyomo"+os.sep+"tutorials"+os.sep+"csv"+os.sep
18tutorial_dir=coopr_dir+os.sep+".."+os.sep+"examples"+os.sep+"pyomo"+os.sep+"tutorials"+os.sep
19
20try:
21  from win32com.client.dynamic import Dispatch
22  _win32com=True
23except:
24  _win32com=False #pragma:nocover
25
26
27class PyomoTableData(unittest.TestCase):
28
29    def run(self, result=None):
30        """ Disable the tests if win32com is not available """
31        if not _win32com:
32           return
33        unittest.TestCase.run(self,result)
34
35    def setUp(self):
36        pass
37
38    def construct(self,filename):
39        pass
40
41    def test_read_set(self):
42        td = DataManagerFactory('xls')
43        td.initialize(currdir+"Book1.xls", range="TheRange", format='set', set="X")
44        try:
45           td.open()
46           td.read()
47           td.close()
48           self.failUnlessEqual( td._info, ['set', 'X', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
49        except pyutilib.common.ApplicationError:
50           pass
51
52    def test_read_param1(self):
53        td = DataManagerFactory('xls')
54        td.initialize(currdir+"Book1.xls", range="TheRange", index=['aa'], param=['bb','cc','dd'])
55        try:
56          td.open()
57          td.read()
58          td.close()
59          self.failUnlessEqual( td._info, ['param', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
60        except pyutilib.common.ApplicationError:
61          pass
62
63    def test_read_param2(self):
64        td = DataManagerFactory('xls')
65        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa'], param=['bb','cc','dd'])
66        try:
67          td.open()
68          td.read()
69          td.close()
70          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
71        except pyutilib.common.ApplicationError:
72          pass
73
74    def test_read_param3(self):
75        td = DataManagerFactory('xls')
76        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa','bb','cc'], param=["dd"], param_name={'dd':'a'})
77        try:
78          td.open()
79          td.read()
80          td.close()
81          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'a', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
82        except pyutilib.common.ApplicationError:
83          pass
84
85    def test_read_param4(self):
86        td = DataManagerFactory('xls')
87        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa','bb'], param=['cc','dd'], param_name={'cc':'a', 'dd':'b'})
88        try:
89          td.open()
90          td.read()
91          td.close()
92          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'a', 'b', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
93        except pyutilib.common.ApplicationError:
94          pass
95
96    def test_read_array1(self):
97        td = DataManagerFactory('xls')
98        td.initialize(currdir+"Book1.xls",range="TheRange", param="X", format="array")
99        try:
100          td.open()
101          td.read()
102          td.close()
103          self.failUnlessEqual( td._info, ['param', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
104        except pyutilib.common.ApplicationError:
105          pass
106
107    def test_read_array2(self):
108        td = DataManagerFactory('xls')
109        td.initialize(currdir+"Book1.xls",range="TheRange",param="X",format="transposed_array")
110        try:
111          td.open()
112          td.read()
113          td.close()
114          self.failUnlessEqual( td._info, ['param', 'X', '(tr)',':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
115        except pyutilib.common.ApplicationError:
116          pass
117
118    def test_error1(self):
119        td = DataManagerFactory('xls')
120        td.initialize("bad")
121        try:
122            td.open()
123            self.fail("Expected IOError because of bad file")
124        except IOError:
125            pass
126
127    def test_error2(self):
128        td = DataManagerFactory('xls')
129        try:
130            td.open()
131            self.fail("Expected IOError because no file specified")
132        except (IOError,AttributeError):
133            pass
134
135    def test_error3(self):
136        td = DataManagerFactory('txt')
137        try:
138            td.initialize(currdir+"display.txt")
139            td.open()
140            self.fail("Expected IOError because of bad file type")
141        except (IOError, AttributeError):
142            pass
143
144    def test_error4(self):
145        td = DataManagerFactory('txt')
146        try:
147            td.initialize(filename=currdir+"dummy")
148            td.open()
149            self.fail("Expected IOError because of bad file type")
150        except (IOError, AttributeError):
151            pass
152
153    def test_error5(self):
154        td = DataManagerFactory('tab')
155        td.initialize(example_dir+"D.tab", param="D", format="foo")
156        td.open()
157        try:
158            td.read()
159            self.fail("Expected IOError because of bad format")
160        except ValueError:
161            pass
162
163
164class PyomoModelData(unittest.TestCase):
165
166    def test_md1(self):
167        md = ModelData()
168        md.add(example_dir+"A.tab")
169        try:
170            md.read()
171            self.fail("Must specify a model")
172        except ValueError:
173            pass
174        model=Model()
175        try:
176            md.read(model)
177            self.fail("Expected IOError")
178        except IOError:
179            pass
180        model.A=Set()
181
182    def test_md2(self):
183        md = ModelData()
184        md.add(currdir+"data1.dat")
185        model=Model()
186        model.A=Set()
187        md.read(model)
188
189    def test_md3(self):
190        md = ModelData()
191        md.add(currdir+"data2.dat")
192        model=Model()
193        model.A=Set()
194        try:
195            md.read(model)
196            self.fail("Expected error because of extraneous text")
197        except IOError:
198            pass
199
200    def test_md4(self):
201        md = ModelData()
202        md.add(currdir+"data3.dat")
203        model=Model()
204        model.A=Set()
205        model.B=Set()
206        model.C=Set()
207        md.read(model)
208
209    def test_md5(self):
210        md = ModelData()
211        md.add(currdir+"data4.dat")
212        model=Model()
213        model.A=Set()
214        try:
215            md.read(model)
216        except ValueError:
217            pass
218
219    def test_md6(self):
220        md = ModelData()
221        md.add(currdir+"data5.dat")
222        model=Model()
223        model.A=Set()
224        try:
225            md.read(model)
226        except ValueError:
227            pass
228
229    def test_md7(self):
230        md = ModelData()
231        md.add(currdir+"data1.tab")
232        model=Model()
233        try:
234            md.read(model)
235            self.fail("Expected IOError")
236        except IOError:
237            pass
238
239    def test_md8(self):
240        md = ModelData()
241        md.add(currdir+"data6.dat")
242        model=Model()
243        model.A=Set()
244        try:
245            md.read(model)
246            self.fail("Expected IOError")
247        except IOError:
248            pass
249
250    def test_md9(self):
251        md = ModelData()
252        md.add(currdir+"data7.dat")
253        model=Model()
254        model.A=Set()
255        model.B=Param(model.A)
256        md.read(model)
257
258    def test_md10(self):
259        md = ModelData()
260        md.add(currdir+"data8.dat")
261        model=Model()
262        model.A=Param(within=Boolean)
263        model.B=Param(within=Boolean)
264        md.read(model)
265
266    def test_md11(self):
267        cwd = os.getcwd()
268        os.chdir(currdir)
269        md = ModelData()
270        md.add(currdir+"data11.dat")
271        model=Model()
272        model.A=Set()
273        model.B=Set()
274        model.C=Set()
275        model.D=Set()
276        md.read(model)
277        os.chdir(cwd)
278
279
280class TestTextImport(unittest.TestCase):
281
282    def test_tableA1(self):
283        """Importing a single column of data"""
284        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
285        print "import "+os.path.abspath(example_dir+'A.tab')+" format=set: A;"
286        pyutilib.misc.reset_redirect()
287        model=Model()
288        model.A = Set()
289        instance = model.create(currdir+'importA1.dat')
290        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
291        os.remove(currdir+'importA1.dat')
292
293    def test_tableA2(self):
294        """Importing a single column of data"""
295        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
296        print "import "+os.path.abspath(example_dir+'A.tab')+" ;"
297        pyutilib.misc.reset_redirect()
298        model=Model()
299        model.A = Set()
300        try:
301            instance = model.create(currdir+'importA2.dat')
302            self.fail("Should fail because no set name is specified")
303        except IOError:
304            pass
305        os.remove(currdir+'importA2.dat')
306
307    def test_tableA3(self):
308        """Importing a single column of data"""
309        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
310        print "import "+os.path.abspath(example_dir+'A.tab')+" : A ;"
311        pyutilib.misc.reset_redirect()
312        model=Model()
313        model.A = Set()
314        try:
315            instance = model.create(currdir+'importA3.dat')
316            self.fail("Should fail because no index is specified")
317        except IOError:
318            pass
319        os.remove(currdir+'importA3.dat')
320
321    def test_tableB(self):
322        """Same as test_tableA"""
323        pyutilib.misc.setup_redirect(currdir+'importB.dat')
324        print "import "+os.path.abspath(example_dir+'B.tab')+" format=set:B;"
325        pyutilib.misc.reset_redirect()
326        model=Model()
327        model.B = Set()
328        instance = model.create(currdir+'importB.dat')
329        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
330        os.remove(currdir+'importB.dat')
331
332    def test_tableC(self):
333        """Importing a multi-column table, where all columns are
334        treated as values for a set with tuple values."""
335        pyutilib.misc.setup_redirect(currdir+'importC.dat')
336        print "import "+os.path.abspath(example_dir+'C.tab')+" format=set: C ;"
337        pyutilib.misc.reset_redirect()
338        model=Model()
339        model.C = Set(dimen=2)
340        instance = model.create(currdir+'importC.dat')
341        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
342        os.remove(currdir+'importC.dat')
343
344    def test_tableD(self):
345        """Importing a 2D array of data as a set."""
346        pyutilib.misc.setup_redirect(currdir+'importD.dat')
347        print "import "+os.path.abspath(example_dir+'D.tab')+" format=set_array: C ;"
348        pyutilib.misc.reset_redirect()
349        model=Model()
350        model.C = Set(dimen=2)
351        instance = model.create(currdir+'importD.dat')
352        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
353        os.remove(currdir+'importD.dat')
354
355    def test_tableZ(self):
356        """Importing a single parameter"""
357        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
358        print "import "+os.path.abspath(example_dir+'Z.tab')+" format=param: Z ;"
359        pyutilib.misc.reset_redirect()
360        model=Model()
361        model.Z = Param(default=99.0)
362        instance = model.create(currdir+'importZ.dat')
363        self.failUnlessEqual(instance.Z.value, 1.1)
364        os.remove(currdir+'importZ.dat')
365
366    def test_tableY(self):
367        """Same as tableXW."""
368        pyutilib.misc.setup_redirect(currdir+'importY.dat')
369        print "import "+os.path.abspath(example_dir+'Y.tab')+" : [A] Y;"
370        pyutilib.misc.reset_redirect()
371        model=Model()
372        model.A = Set(initialize=['A1','A2','A3','A4'])
373        model.Y = Param(model.A)
374        instance = model.create(currdir+'importY.dat')
375        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
376        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
377        os.remove(currdir+'importY.dat')
378
379    def test_tableXW_1(self):
380        """Importing a table, but only reporting the values for the non-index
381        parameter columns.  The first column is assumed to represent an
382        index column."""
383        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
384        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
385        pyutilib.misc.reset_redirect()
386        model=Model()
387        model.A = Set(initialize=['A1','A2','A3','A4'])
388        model.X = Param(model.A)
389        model.W = Param(model.A)
390        instance = model.create(currdir+'importXW.dat')
391        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
392        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
393        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
394        os.remove(currdir+'importXW.dat')
395
396    def test_tableXW_2(self):
397        """Like test_tableXW_1, except that set A is not defined."""
398        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
399        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
400        pyutilib.misc.reset_redirect()
401        model=Model()
402        model.A = Set()
403        model.X = Param(model.A)
404        model.W = Param(model.A)
405        instance = model.create(currdir+'importXW.dat')
406        self.failUnlessEqual(instance.A.data(), set())
407        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
408        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
409        os.remove(currdir+'importXW.dat')
410
411    def test_tableXW_3(self):
412        """Like test_tableXW_1, except that set A is defined in the import statment."""
413        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
414        print "import "+os.path.abspath(example_dir+'XW.tab')+": A=[A] X W;"
415        pyutilib.misc.reset_redirect()
416        model=Model()
417        model.A = Set()
418        model.X = Param(model.A)
419        model.W = Param(model.A)
420        instance = model.create(currdir+'importXW.dat')
421        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
422        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
423        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
424        os.remove(currdir+'importXW.dat')
425
426    def test_tableXW_4(self):
427        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
428        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
429        print "import "+os.path.abspath(example_dir+'XW.tab')+": B=[A] R=X S=W;"
430        pyutilib.misc.reset_redirect()
431        model=Model()
432        model.B = Set()
433        model.R = Param(model.B)
434        model.S = Param(model.B)
435        instance = model.create(currdir+'importXW.dat')
436        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
437        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
438        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
439        os.remove(currdir+'importXW.dat')
440
441    def test_tableT(self):
442        """Importing a 2D array of parameters that are transposed."""
443        pyutilib.misc.setup_redirect(currdir+'importT.dat')
444        print "import "+os.path.abspath(example_dir+'T.tab')+" format=transposed_array : T;"
445        pyutilib.misc.reset_redirect()
446        model=Model()
447        model.A = Set()
448        model.B = Set()
449        model.T = Param(model.A, model.B)
450        instance = model.create(currdir+'importT.dat')
451        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5})
452        os.remove(currdir+'importT.dat')
453
454    def test_tableU(self):
455        """Importing a 2D array of parameters."""
456        pyutilib.misc.setup_redirect(currdir+'importU.dat')
457        print "import "+os.path.abspath(example_dir+'U.tab')+" format=array : U;"
458        pyutilib.misc.reset_redirect()
459        model=Model()
460        model.A = Set()
461        model.B = Set()
462        model.U = Param(model.A, model.B)
463        instance = model.create(currdir+'importU.dat')
464        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4})
465        os.remove(currdir+'importU.dat')
466
467    def test_tableS(self):
468        """Importing a table, but only reporting the values for the non-index
469        parameter columns.  The first column is assumed to represent an
470        index column.  A missing value is represented in the column data."""
471        pyutilib.misc.setup_redirect(currdir+'importS.dat')
472        print "import "+os.path.abspath(example_dir+'S.tab')+": [A] S ;"
473        pyutilib.misc.reset_redirect()
474        model=Model()
475        model.A = Set(initialize=['A1','A2','A3','A4'])
476        model.S = Param(model.A)
477        instance = model.create(currdir+'importS.dat')
478        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
479        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
480        os.remove(currdir+'importS.dat')
481
482    def test_tablePO(self):
483        """Importing a table that has multiple indexing columns"""
484        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
485        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
486        pyutilib.misc.reset_redirect()
487        model=Model()
488        model.J = Set(dimen=2)
489        model.P = Param(model.J)
490        model.O = Param(model.J)
491        instance = model.create(currdir+'importPO.dat')
492        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
493        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
494        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
495        os.remove(currdir+'importPO.dat')
496
497
498class TestCsvImport(unittest.TestCase):
499
500    def test_tableA1(self):
501        """Importing a single column of data"""
502        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
503        print "import "+os.path.abspath(csv_dir+'A.csv')+" format=set: A;"
504        pyutilib.misc.reset_redirect()
505        model=Model()
506        model.A = Set()
507        instance = model.create(currdir+'importA1.dat')
508        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
509        os.remove(currdir+'importA1.dat')
510
511    def test_tableA2(self):
512        """Importing a single column of data"""
513        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
514        print "import "+os.path.abspath(csv_dir+'A.csv')+" ;"
515        pyutilib.misc.reset_redirect()
516        model=Model()
517        model.A = Set()
518        try:
519            instance = model.create(currdir+'importA2.dat')
520            self.fail("Should fail because no set name is specified")
521        except IOError:
522            pass
523        os.remove(currdir+'importA2.dat')
524
525    def test_tableA3(self):
526        """Importing a single column of data"""
527        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
528        print "import "+os.path.abspath(csv_dir+'A.csv')+" : A ;"
529        pyutilib.misc.reset_redirect()
530        model=Model()
531        model.A = Set()
532        try:
533            instance = model.create(currdir+'importA3.dat')
534            self.fail("Should fail because no index is specified")
535        except IOError:
536            pass
537        os.remove(currdir+'importA3.dat')
538
539    def test_tableB(self):
540        """Same as test_tableA"""
541        pyutilib.misc.setup_redirect(currdir+'importB.dat')
542        print "import "+os.path.abspath(csv_dir+'B.csv')+" format=set:B;"
543        pyutilib.misc.reset_redirect()
544        model=Model()
545        model.B = Set()
546        instance = model.create(currdir+'importB.dat')
547        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
548        os.remove(currdir+'importB.dat')
549
550    def test_tableC(self):
551        """Importing a multi-column table, where all columns are
552        treated as values for a set with tuple values."""
553        pyutilib.misc.setup_redirect(currdir+'importC.dat')
554        print "import "+os.path.abspath(csv_dir+'C.csv')+" format=set: C ;"
555        pyutilib.misc.reset_redirect()
556        model=Model()
557        model.C = Set(dimen=2)
558        instance = model.create(currdir+'importC.dat')
559        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
560        os.remove(currdir+'importC.dat')
561
562    def test_tableD(self):
563        """Importing a 2D array of data as a set."""
564        pyutilib.misc.setup_redirect(currdir+'importD.dat')
565        print "import "+os.path.abspath(csv_dir+'D.csv')+" format=set_array: C ;"
566        pyutilib.misc.reset_redirect()
567        model=Model()
568        model.C = Set(dimen=2)
569        instance = model.create(currdir+'importD.dat')
570        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
571        os.remove(currdir+'importD.dat')
572
573    def test_tableZ(self):
574        """Importing a single parameter"""
575        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
576        print "import "+os.path.abspath(csv_dir+'Z.csv')+" format=param: Z ;"
577        pyutilib.misc.reset_redirect()
578        model=Model()
579        model.Z = Param(default=99.0)
580        instance = model.create(currdir+'importZ.dat')
581        self.failUnlessEqual(instance.Z.value, 1.1)
582        os.remove(currdir+'importZ.dat')
583
584    def test_tableY(self):
585        """Same as tableXW."""
586        pyutilib.misc.setup_redirect(currdir+'importY.dat')
587        print "import "+os.path.abspath(csv_dir+'Y.csv')+" : [A] Y;"
588        pyutilib.misc.reset_redirect()
589        model=Model()
590        model.A = Set(initialize=['A1','A2','A3','A4'])
591        model.Y = Param(model.A)
592        instance = model.create(currdir+'importY.dat')
593        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
594        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
595        os.remove(currdir+'importY.dat')
596
597    def test_tableXW_1(self):
598        """Importing a table, but only reporting the values for the non-index
599        parameter columns.  The first column is assumed to represent an
600        index column."""
601        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
602        print "import "+os.path.abspath(csv_dir+'XW.csv')+": [A] X W;"
603        pyutilib.misc.reset_redirect()
604        model=Model()
605        model.A = Set(initialize=['A1','A2','A3','A4'])
606        model.X = Param(model.A)
607        model.W = Param(model.A)
608        instance = model.create(currdir+'importXW.dat')
609        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
610        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
611        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
612        os.remove(currdir+'importXW.dat')
613
614    def test_tableXW_2(self):
615        """Like test_tableXW_1, except that set A is not defined."""
616        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
617        print "import "+os.path.abspath(csv_dir+'XW.csv')+": [A] X W;"
618        pyutilib.misc.reset_redirect()
619        model=Model()
620        model.A = Set()
621        model.X = Param(model.A)
622        model.W = Param(model.A)
623        instance = model.create(currdir+'importXW.dat')
624        self.failUnlessEqual(instance.A.data(), set())
625        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
626        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
627        os.remove(currdir+'importXW.dat')
628
629    def test_tableXW_3(self):
630        """Like test_tableXW_1, except that set A is defined in the import statment."""
631        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
632        print "import "+os.path.abspath(csv_dir+'XW.csv')+": A=[A] X W;"
633        pyutilib.misc.reset_redirect()
634        model=Model()
635        model.A = Set()
636        model.X = Param(model.A)
637        model.W = Param(model.A)
638        instance = model.create(currdir+'importXW.dat')
639        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
640        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
641        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
642        os.remove(currdir+'importXW.dat')
643
644    def test_tableXW_4(self):
645        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
646        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
647        print "import "+os.path.abspath(csv_dir+'XW.csv')+": B=[A] R=X S=W;"
648        pyutilib.misc.reset_redirect()
649        model=Model()
650        model.B = Set()
651        model.R = Param(model.B)
652        model.S = Param(model.B)
653        instance = model.create(currdir+'importXW.dat')
654        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
655        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
656        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
657        os.remove(currdir+'importXW.dat')
658
659    def test_tableT(self):
660        """Importing a 2D array of parameters that are transposed."""
661        pyutilib.misc.setup_redirect(currdir+'importT.dat')
662        print "import "+os.path.abspath(csv_dir+'T.csv')+" format=transposed_array : T;"
663        pyutilib.misc.reset_redirect()
664        model=Model()
665        model.A = Set()
666        model.B = Set()
667        model.T = Param(model.A, model.B)
668        instance = model.create(currdir+'importT.dat')
669        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5})
670        os.remove(currdir+'importT.dat')
671
672    def test_tableU(self):
673        """Importing a 2D array of parameters."""
674        pyutilib.misc.setup_redirect(currdir+'importU.dat')
675        print "import "+os.path.abspath(csv_dir+'U.csv')+" format=array : U;"
676        pyutilib.misc.reset_redirect()
677        model=Model()
678        model.A = Set()
679        model.B = Set()
680        model.U = Param(model.A, model.B)
681        instance = model.create(currdir+'importU.dat')
682        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4})
683        os.remove(currdir+'importU.dat')
684
685    def test_tableS(self):
686        """Importing a table, but only reporting the values for the non-index
687        parameter columns.  The first column is assumed to represent an
688        index column.  A missing value is represented in the column data."""
689        pyutilib.misc.setup_redirect(currdir+'importS.dat')
690        print "import "+os.path.abspath(csv_dir+'S.csv')+": [A] S ;"
691        pyutilib.misc.reset_redirect()
692        model=Model()
693        model.A = Set(initialize=['A1','A2','A3','A4'])
694        model.S = Param(model.A)
695        instance = model.create(currdir+'importS.dat')
696        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
697        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
698        os.remove(currdir+'importS.dat')
699
700    def test_tablePO(self):
701        """Importing a table that has multiple indexing columns"""
702        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
703        print "import "+os.path.abspath(csv_dir+'PO.csv')+" : J=[A,B] P O;"
704        pyutilib.misc.reset_redirect()
705        model=Model()
706        model.J = Set(dimen=2)
707        model.P = Param(model.J)
708        model.O = Param(model.J)
709        instance = model.create(currdir+'importPO.dat')
710        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
711        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
712        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
713        os.remove(currdir+'importPO.dat')
714
715
716
717class TestSpreadsheet(unittest.TestCase):
718
719    def run(self, result=None):
720        """ Disable the tests if win32com is not available """
721        if not _win32com:
722           return
723        unittest.TestCase.run(self,result)
724
725    def test_tableA1(self):
726        """Importing a single column of data"""
727        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
728        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable format=set: A;"
729        pyutilib.misc.reset_redirect()
730        model=Model()
731        model.A = Set()
732        instance = model.create(currdir+'importA1.dat')
733        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
734        os.remove(currdir+'importA1.dat')
735
736    def test_tableA2(self):
737        """Importing a single column of data"""
738        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
739        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable ;"
740        pyutilib.misc.reset_redirect()
741        model=Model()
742        model.A = Set()
743        try:
744            instance = model.create(currdir+'importA2.dat')
745            self.fail("Should fail because no set name is specified")
746        except IOError:
747            pass
748        os.remove(currdir+'importA2.dat')
749
750    def test_tableA3(self):
751        """Importing a single column of data"""
752        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
753        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable : A ;"
754        pyutilib.misc.reset_redirect()
755        model=Model()
756        model.A = Set()
757        try:
758            instance = model.create(currdir+'importA3.dat')
759            self.fail("Should fail because no index is specified")
760        except IOError:
761            pass
762        os.remove(currdir+'importA3.dat')
763
764    def test_tableB(self):
765        """Same as test_tableA"""
766        pyutilib.misc.setup_redirect(currdir+'importB.dat')
767        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Btable format=set:B;"
768        pyutilib.misc.reset_redirect()
769        model=Model()
770        model.B = Set()
771        instance = model.create(currdir+'importB.dat')
772        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
773        os.remove(currdir+'importB.dat')
774
775    def test_tableC(self):
776        """Importing a multi-column table, where all columns are
777        treated as values for a set with tuple values."""
778        pyutilib.misc.setup_redirect(currdir+'importC.dat')
779        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ctable format=set: C ;"
780        pyutilib.misc.reset_redirect()
781        model=Model()
782        model.C = Set(dimen=2)
783        instance = model.create(currdir+'importC.dat')
784        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
785        os.remove(currdir+'importC.dat')
786
787    def test_tableD(self):
788        """Importing a 2D array of data as a set."""
789        pyutilib.misc.setup_redirect(currdir+'importD.dat')
790        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Dtable format=set_array: C ;"
791        pyutilib.misc.reset_redirect()
792        model=Model()
793        model.C = Set(dimen=2)
794        instance = model.create(currdir+'importD.dat')
795        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
796        os.remove(currdir+'importD.dat')
797
798    def test_tableZ(self):
799        """Importing a single parameter"""
800        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
801        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Zparam format=param: Z ;"
802        pyutilib.misc.reset_redirect()
803        model=Model()
804        model.Z = Param(default=99.0)
805        instance = model.create(currdir+'importZ.dat')
806        self.failUnlessEqual(instance.Z.value, 1.1)
807        os.remove(currdir+'importZ.dat')
808
809    def test_tableY(self):
810        """Same as tableXW."""
811        pyutilib.misc.setup_redirect(currdir+'importY.dat')
812        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ytable : [A] Y;"
813        pyutilib.misc.reset_redirect()
814        model=Model()
815        model.A = Set(initialize=['A1','A2','A3','A4'])
816        model.Y = Param(model.A)
817        instance = model.create(currdir+'importY.dat')
818        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
819        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
820        os.remove(currdir+'importY.dat')
821
822    def test_tableXW_1(self):
823        """Importing a table, but only reporting the values for the non-index
824        parameter columns.  The first column is assumed to represent an
825        index column."""
826        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
827        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
828        pyutilib.misc.reset_redirect()
829        model=Model()
830        model.A = Set(initialize=['A1','A2','A3','A4'])
831        model.X = Param(model.A)
832        model.W = Param(model.A)
833        instance = model.create(currdir+'importXW.dat')
834        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
835        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
836        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
837        os.remove(currdir+'importXW.dat')
838
839    def test_tableXW_2(self):
840        """Like test_tableXW_1, except that set A is not defined."""
841        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
842        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
843        pyutilib.misc.reset_redirect()
844        model=Model()
845        model.A = Set()
846        model.X = Param(model.A)
847        model.W = Param(model.A)
848        instance = model.create(currdir+'importXW.dat')
849        self.failUnlessEqual(instance.A.data(), set())
850        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
851        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
852        os.remove(currdir+'importXW.dat')
853
854    def test_tableXW_3(self):
855        """Like test_tableXW_1, except that set A is defined in the import statment."""
856        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
857        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: A=[A] X W;"
858        pyutilib.misc.reset_redirect()
859        model=Model()
860        model.A = Set()
861        model.X = Param(model.A)
862        model.W = Param(model.A)
863        instance = model.create(currdir+'importXW.dat')
864        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
865        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
866        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
867        os.remove(currdir+'importXW.dat')
868
869    def test_tableXW_4(self):
870        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
871        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
872        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: B=[A] R=X S=W;"
873        pyutilib.misc.reset_redirect()
874        model=Model()
875        model.B = Set()
876        model.R = Param(model.B)
877        model.S = Param(model.B)
878        instance = model.create(currdir+'importXW.dat')
879        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
880        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
881        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
882        os.remove(currdir+'importXW.dat')
883
884    def test_tableT(self):
885        """Importing a 2D array of parameters that are transposed."""
886        pyutilib.misc.setup_redirect(currdir+'importT.dat')
887        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ttable format=transposed_array : T;"
888        pyutilib.misc.reset_redirect()
889        model=Model()
890        model.A = Set()
891        model.B = Set()
892        model.T = Param(model.A, model.B)
893        instance = model.create(currdir+'importT.dat')
894        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5})
895        os.remove(currdir+'importT.dat')
896
897    def test_tableU(self):
898        """Importing a 2D array of parameters."""
899        pyutilib.misc.setup_redirect(currdir+'importU.dat')
900        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Utable format=array : U;"
901        pyutilib.misc.reset_redirect()
902        model=Model()
903        model.A = Set()
904        model.B = Set()
905        model.U = Param(model.A, model.B)
906        instance = model.create(currdir+'importU.dat')
907        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4})
908        os.remove(currdir+'importU.dat')
909
910    def test_tableS(self):
911        """Importing a table, but only reporting the values for the non-index
912        parameter columns.  The first column is assumed to represent an
913        index column.  A missing value is represented in the column data."""
914        pyutilib.misc.setup_redirect(currdir+'importS.dat')
915        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Stable : [A] S ;"
916        pyutilib.misc.reset_redirect()
917        model=Model()
918        model.A = Set(initialize=['A1','A2','A3','A4'])
919        model.S = Param(model.A)
920        instance = model.create(currdir+'importS.dat')
921        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
922        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
923        os.remove(currdir+'importS.dat')
924
925    def test_tablePO(self):
926        """Importing a table that has multiple indexing columns"""
927        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
928        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=POtable : J=[A,B] P O;"
929        pyutilib.misc.reset_redirect()
930        model=Model()
931        model.J = Set(dimen=2)
932        model.P = Param(model.J)
933        model.O = Param(model.J)
934        instance = model.create(currdir+'importPO.dat')
935        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
936        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
937        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
938        os.remove(currdir+'importPO.dat')
939
940
941class TestModelData(unittest.TestCase):
942
943    def test_tableA1(self):
944        """Importing a single column of data"""
945        md = ModelData()
946        md.add(os.path.abspath(example_dir+'A.tab'), format='set', set='A')
947        model=Model()
948        model.A = Set()
949        md.read(model)
950        instance = model.create(md)
951        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
952
953    def test_tableA2(self):
954        """Importing a single column of data"""
955        md = ModelData()
956        md.add(os.path.abspath(example_dir+'A.tab'))
957        model=Model()
958        model.A = Set()
959        try:
960            md.read(model)
961            instance = model.create(md)
962            self.fail("Should fail because no set name is specified")
963        except IOError:
964            pass
965
966    def test_tableA3(self):
967        """Importing a single column of data"""
968        md = ModelData()
969        md.add(os.path.abspath(example_dir+'A.tab'), set='A')
970        model=Model()
971        model.A = Set()
972        try:
973            md.read(model)
974            instance = model.create(md)
975            self.fail("Should fail because no index is specified")
976        except IOError:
977            pass
978
979    def test_tableB(self):
980        """Same as test_tableA"""
981        md = ModelData()
982        md.add(os.path.abspath(example_dir+'B.tab'), format='set', set='B')
983        model=Model()
984        model.B = Set()
985        md.read(model)
986        instance = model.create(md)
987        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
988
989    def test_tableC(self):
990        """Importing a multi-column table, where all columns are
991        treated as values for a set with tuple values."""
992        md = ModelData()
993        md.add(os.path.abspath(example_dir+'C.tab'), format='set', set='C')
994        model=Model()
995        model.C = Set(dimen=2)
996        md.read(model)
997        instance = model.create(md)
998        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
999
1000    def test_tableD(self):
1001        """Importing a 2D array of data as a set."""
1002        md = ModelData()
1003        md.add(os.path.abspath(example_dir+'D.tab'), format='set_array', set='C')
1004        model=Model()
1005        model.C = Set(dimen=2)
1006        md.read(model)
1007        instance = model.create(md)
1008        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
1009
1010    def test_tableZ(self):
1011        """Importing a single parameter"""
1012        md = ModelData()
1013        md.add(os.path.abspath(example_dir+'Z.tab'), format='param', param='Z')
1014        model=Model()
1015        model.Z = Param(default=99.0)
1016        md.read(model)
1017        instance = model.create(md)
1018        self.failUnlessEqual(instance.Z.value, 1.1)
1019
1020    def test_tableY(self):
1021        """Same as tableXW."""
1022        md = ModelData()
1023        md.add(os.path.abspath(example_dir+'Y.tab'), index=['A'], param=['Y'])
1024        model=Model()
1025        model.A = Set(initialize=['A1','A2','A3','A4'])
1026        model.Y = Param(model.A)
1027        md.read(model)
1028        instance = model.create(md)
1029        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1030        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1031
1032    def test_tableXW_1(self):
1033        """Importing a table, but only reporting the values for the non-index
1034        parameter columns.  The first column is assumed to represent an
1035        index column."""
1036        md = ModelData()
1037        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
1038        model=Model()
1039        model.A = Set(initialize=['A1','A2','A3','A4'])
1040        model.X = Param(model.A)
1041        model.W = Param(model.A)
1042        md.read(model)
1043        instance = model.create(md)
1044        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1045        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1046        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1047
1048    def test_tableXW_2(self):
1049        """Like test_tableXW_1, except that set A is not defined."""
1050        md = ModelData()
1051        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
1052        model=Model()
1053        model.A = Set()
1054        model.X = Param(model.A)
1055        model.W = Param(model.A)
1056        md.read(model)
1057        instance = model.create(md)
1058        self.failUnlessEqual(instance.A.data(), set())
1059        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1060        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1061
1062    def test_tableXW_3(self):
1063        """Like test_tableXW_1, except that set A is defined in the import statment."""
1064        md = ModelData()
1065        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='A', index=['A'], param=['X','W'])
1066        model=Model()
1067        model.A = Set()
1068        model.X = Param(model.A)
1069        model.W = Param(model.A)
1070        md.read(model)
1071        instance = model.create(md)
1072        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
1073        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1074        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1075
1076    def test_tableXW_4(self):
1077        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
1078        md = ModelData()
1079        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='B', index=['A'], param=['X','W'], param_name={'X':'R', 'W':'S'})
1080        model=Model()
1081        model.B = Set()
1082        model.R = Param(model.B)
1083        model.S = Param(model.B)
1084        md.read(model)
1085        instance = model.create(md)
1086        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
1087        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1088        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1089
1090    def test_tableT(self):
1091        """Importing a 2D array of parameters that are transposed."""
1092        md = ModelData()
1093        md.add(os.path.abspath(example_dir+'T.tab'), format='transposed_array', param='T')
1094        model=Model()
1095        model.A = Set()
1096        model.B = Set()
1097        model.T = Param(model.A, model.B)
1098        md.read(model)
1099        instance = model.create(md)
1100        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5})
1101
1102    def test_tableU(self):
1103        """Importing a 2D array of parameters."""
1104        md = ModelData()
1105        md.add(os.path.abspath(example_dir+'T.tab'), format='array', param='U')
1106        model=Model()
1107        model.A = Set()
1108        model.B = Set()
1109        model.U = Param(model.A, model.B)
1110        md.read(model)
1111        instance = model.create(md)
1112        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4})
1113
1114    def test_tableS(self):
1115        """Importing a table, but only reporting the values for the non-index
1116        parameter columns.  The first column is assumed to represent an
1117        index column.  A missing value is represented in the column data."""
1118        md = ModelData()
1119        md.add(os.path.abspath(example_dir+'S.tab'), index=['A'], param=['S'])
1120        model=Model()
1121        model.A = Set(initialize=['A1','A2','A3','A4'])
1122        model.S = Param(model.A)
1123        md.read(model)
1124        instance = model.create(md)
1125        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1126        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
1127
1128    def test_tablePO(self):
1129        """Importing a table that has multiple indexing columns"""
1130        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
1131        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
1132        pyutilib.misc.reset_redirect()
1133        md = ModelData()
1134        md.add(os.path.abspath(example_dir+'PO.tab'), index_name='J', index=['A','B'], param=['P','O'])
1135        model=Model()
1136        model.J = Set(dimen=2)
1137        model.P = Param(model.J)
1138        model.O = Param(model.J)
1139        md.read(model)
1140        instance = model.create(md)
1141        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
1142        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
1143        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
1144
1145
1146if __name__ == "__main__":
1147   unittest.main()
1148
Note: See TracBrowser for help on using the repository browser.