source: coopr.pyomo/stable/2.3/coopr/pyomo/tests/unit/test_modeldata.py @ 2315

Last change on this file since 2315 was 2315, checked in by wehart, 11 years ago

Merged revisions 2232-2314 via svnmerge from
https://software.sandia.gov/svn/public/coopr/coopr.pyomo/trunk

........

r2242 | wehart | 2010-02-01 20:08:36 -0700 (Mon, 01 Feb 2010) | 2 lines


Documentation update.

........

r2244 | wehart | 2010-02-01 20:10:18 -0700 (Mon, 01 Feb 2010) | 2 lines


Tagging coopr.pyomo 2.3 release

........

r2253 | wehart | 2010-02-03 13:57:16 -0700 (Wed, 03 Feb 2010) | 2 lines


Changes due to termination condition refinement

........

r2264 | wehart | 2010-02-05 08:20:30 -0700 (Fri, 05 Feb 2010) | 3 lines


Misc rework of the scripting modules. These changes allow this
functionality to be used more effectively within other Python scripts.

........

r2274 | wehart | 2010-02-06 08:13:24 -0700 (Sat, 06 Feb 2010) | 8 lines


Added the 'include' command, which can include other *.dat files. This works
like the AMPL include command, with the exception that it must be terminated by
a semicolon.


Reworked the AMPL datafile plugin to simple execute an include command
on a *.dat file. This rework has the advantage that filename/lineno information
is now propigated throught he AMPL command processing.

........

r2278 | wehart | 2010-02-07 13:06:10 -0700 (Sun, 07 Feb 2010) | 7 lines


A major rework of the parsing of data command files (formerly known
as AMPL DAT files). This rework is the first step towards a full
parse of these files. I've used PLY to lex/yacc these files. This should
resolve a variety of issues that we've observed relating to the sensitivity of
the old parser to whitespace. This is also a first step towards a careful parse
of command lines for the 'import' command.

........

r2279 | wehart | 2010-02-08 06:07:14 -0700 (Mon, 08 Feb 2010) | 2 lines


Adding support for a basic 'import' command.

........

r2283 | jwatson | 2010-02-08 11:28:22 -0700 (Mon, 08 Feb 2010) | 1 line


Added suffix option to pyomo script, to enable specification of suffixes on the command-line.

........

r2285 | wehart | 2010-02-08 11:48:54 -0700 (Mon, 08 Feb 2010) | 2 lines


Working through more examples of the 'import' command.

........

r2287 | wehart | 2010-02-08 12:12:41 -0700 (Mon, 08 Feb 2010) | 2 lines


Adding a script to test the parser.

........

r2289 | wehart | 2010-02-08 15:13:22 -0700 (Mon, 08 Feb 2010) | 4 lines


Setting up 'import' tests for the other simple examples.
These seem to work, but the internal code is too ugly. I'm
going to clean that up next to help explain what is going on...

........

r2292 | wehart | 2010-02-09 12:21:24 -0700 (Tue, 09 Feb 2010) | 10 lines


Rework of the 'import' semantics. This supports
a simple import semantics, such as:


import foobar.tab: [A,B] X Y Z;


as well as index/parameter renaming:


import foobar.tab: J=[A,B] R=X S=Y T=Z;

........

r2293 | wehart | 2010-02-09 14:22:23 -0700 (Tue, 09 Feb 2010) | 2 lines


Bug fix for dealing with MS Windows filenames.

........

r2295 | wehart | 2010-02-09 16:23:37 -0700 (Tue, 09 Feb 2010) | 4 lines


Reworking tests to do basic evaluation of the
interface to Excel spreadsheets.

........

r2302 | wehart | 2010-02-09 20:25:42 -0700 (Tue, 09 Feb 2010) | 2 lines


Adding tests for loading sets and parameters from spreadsheets.

........

r2303 | wehart | 2010-02-09 20:50:12 -0700 (Tue, 09 Feb 2010) | 2 lines


Adding a plugin for reading CSV files.

........

r2304 | wehart | 2010-02-09 20:51:27 -0700 (Tue, 09 Feb 2010) | 4 lines


Renaming csv.py to csv_table.py


The former filename masked the system 'csv' module. :P

........

r2305 | wehart | 2010-02-09 20:57:12 -0700 (Tue, 09 Feb 2010) | 2 lines


Adding CSV data files for the tutorial.

........

r2306 | wehart | 2010-02-09 20:58:42 -0700 (Tue, 09 Feb 2010) | 2 lines


Adding tests for importing CSV files.

........

r2307 | wehart | 2010-02-09 22:02:40 -0700 (Tue, 09 Feb 2010) | 3 lines


Adding a test that is used to verify that data commands can include indexed variables with astrices
in their arguments.

........

r2309 | wehart | 2010-02-10 22:06:28 -0700 (Wed, 10 Feb 2010) | 3 lines


Misc edits, which preserve some data that I was playing with to validate some
advanced parser features.

........

r2310 | wehart | 2010-02-10 22:38:44 -0700 (Wed, 10 Feb 2010) | 2 lines


Generalizing parsing behavior for set strings.

........

File size: 47.6 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,IOError):
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        model.Z=Set()
265        md.read(model)
266        instance = model.create(md)
267        #self.failUnlessEqual(instance.Z.data(), set(['foo[*]' 'bar' '[' '*' ']' 'bar[1,*,a,*]' 'foo-bar' 'hello-goodbye']))
268
269    def test_md11(self):
270        cwd = os.getcwd()
271        os.chdir(currdir)
272        md = ModelData()
273        md.add(currdir+"data11.dat")
274        model=Model()
275        model.A=Set()
276        model.B=Set()
277        model.C=Set()
278        model.D=Set()
279        md.read(model)
280        os.chdir(cwd)
281
282
283class TestTextImport(unittest.TestCase):
284
285    def test_tableA1(self):
286        """Importing a single column of data"""
287        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
288        print "import "+os.path.abspath(example_dir+'A.tab')+" format=set: A;"
289        pyutilib.misc.reset_redirect()
290        model=Model()
291        model.A = Set()
292        instance = model.create(currdir+'importA1.dat')
293        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
294        os.remove(currdir+'importA1.dat')
295
296    def test_tableA2(self):
297        """Importing a single column of data"""
298        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
299        print "import "+os.path.abspath(example_dir+'A.tab')+" ;"
300        pyutilib.misc.reset_redirect()
301        model=Model()
302        model.A = Set()
303        try:
304            instance = model.create(currdir+'importA2.dat')
305            self.fail("Should fail because no set name is specified")
306        except IOError:
307            pass
308        os.remove(currdir+'importA2.dat')
309
310    def test_tableA3(self):
311        """Importing a single column of data"""
312        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
313        print "import "+os.path.abspath(example_dir+'A.tab')+" : A ;"
314        pyutilib.misc.reset_redirect()
315        model=Model()
316        model.A = Set()
317        try:
318            instance = model.create(currdir+'importA3.dat')
319            self.fail("Should fail because no index is specified")
320        except IOError:
321            pass
322        os.remove(currdir+'importA3.dat')
323
324    def test_tableB(self):
325        """Same as test_tableA"""
326        pyutilib.misc.setup_redirect(currdir+'importB.dat')
327        print "import "+os.path.abspath(example_dir+'B.tab')+" format=set:B;"
328        pyutilib.misc.reset_redirect()
329        model=Model()
330        model.B = Set()
331        instance = model.create(currdir+'importB.dat')
332        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
333        os.remove(currdir+'importB.dat')
334
335    def test_tableC(self):
336        """Importing a multi-column table, where all columns are
337        treated as values for a set with tuple values."""
338        pyutilib.misc.setup_redirect(currdir+'importC.dat')
339        print "import "+os.path.abspath(example_dir+'C.tab')+" format=set: C ;"
340        pyutilib.misc.reset_redirect()
341        model=Model()
342        model.C = Set(dimen=2)
343        instance = model.create(currdir+'importC.dat')
344        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
345        os.remove(currdir+'importC.dat')
346
347    def test_tableD(self):
348        """Importing a 2D array of data as a set."""
349        pyutilib.misc.setup_redirect(currdir+'importD.dat')
350        print "import "+os.path.abspath(example_dir+'D.tab')+" format=set_array: C ;"
351        pyutilib.misc.reset_redirect()
352        model=Model()
353        model.C = Set(dimen=2)
354        instance = model.create(currdir+'importD.dat')
355        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
356        os.remove(currdir+'importD.dat')
357
358    def test_tableZ(self):
359        """Importing a single parameter"""
360        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
361        print "import "+os.path.abspath(example_dir+'Z.tab')+" format=param: Z ;"
362        pyutilib.misc.reset_redirect()
363        model=Model()
364        model.Z = Param(default=99.0)
365        instance = model.create(currdir+'importZ.dat')
366        self.failUnlessEqual(instance.Z.value, 1.1)
367        os.remove(currdir+'importZ.dat')
368
369    def test_tableY(self):
370        """Same as tableXW."""
371        pyutilib.misc.setup_redirect(currdir+'importY.dat')
372        print "import "+os.path.abspath(example_dir+'Y.tab')+" : [A] Y;"
373        pyutilib.misc.reset_redirect()
374        model=Model()
375        model.A = Set(initialize=['A1','A2','A3','A4'])
376        model.Y = Param(model.A)
377        instance = model.create(currdir+'importY.dat')
378        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
379        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
380        os.remove(currdir+'importY.dat')
381
382    def test_tableXW_1(self):
383        """Importing a table, but only reporting the values for the non-index
384        parameter columns.  The first column is assumed to represent an
385        index column."""
386        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
387        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
388        pyutilib.misc.reset_redirect()
389        model=Model()
390        model.A = Set(initialize=['A1','A2','A3','A4'])
391        model.X = Param(model.A)
392        model.W = Param(model.A)
393        instance = model.create(currdir+'importXW.dat')
394        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
395        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
396        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
397        os.remove(currdir+'importXW.dat')
398
399    def test_tableXW_2(self):
400        """Like test_tableXW_1, except that set A is not defined."""
401        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
402        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
403        pyutilib.misc.reset_redirect()
404        model=Model()
405        model.A = Set()
406        model.X = Param(model.A)
407        model.W = Param(model.A)
408        instance = model.create(currdir+'importXW.dat')
409        self.failUnlessEqual(instance.A.data(), set())
410        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
411        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
412        os.remove(currdir+'importXW.dat')
413
414    def test_tableXW_3(self):
415        """Like test_tableXW_1, except that set A is defined in the import statment."""
416        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
417        print "import "+os.path.abspath(example_dir+'XW.tab')+": A=[A] X W;"
418        pyutilib.misc.reset_redirect()
419        model=Model()
420        model.A = Set()
421        model.X = Param(model.A)
422        model.W = Param(model.A)
423        instance = model.create(currdir+'importXW.dat')
424        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
425        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
426        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
427        os.remove(currdir+'importXW.dat')
428
429    def test_tableXW_4(self):
430        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
431        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
432        print "import "+os.path.abspath(example_dir+'XW.tab')+": B=[A] R=X S=W;"
433        pyutilib.misc.reset_redirect()
434        model=Model()
435        model.B = Set()
436        model.R = Param(model.B)
437        model.S = Param(model.B)
438        instance = model.create(currdir+'importXW.dat')
439        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
440        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
441        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
442        os.remove(currdir+'importXW.dat')
443
444    def test_tableT(self):
445        """Importing a 2D array of parameters that are transposed."""
446        pyutilib.misc.setup_redirect(currdir+'importT.dat')
447        print "import "+os.path.abspath(example_dir+'T.tab')+" format=transposed_array : T;"
448        pyutilib.misc.reset_redirect()
449        model=Model()
450        model.A = Set()
451        model.B = Set()
452        model.T = Param(model.A, model.B)
453        instance = model.create(currdir+'importT.dat')
454        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})
455        os.remove(currdir+'importT.dat')
456
457    def test_tableU(self):
458        """Importing a 2D array of parameters."""
459        pyutilib.misc.setup_redirect(currdir+'importU.dat')
460        print "import "+os.path.abspath(example_dir+'U.tab')+" format=array : U;"
461        pyutilib.misc.reset_redirect()
462        model=Model()
463        model.A = Set()
464        model.B = Set()
465        model.U = Param(model.A, model.B)
466        instance = model.create(currdir+'importU.dat')
467        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})
468        os.remove(currdir+'importU.dat')
469
470    def test_tableS(self):
471        """Importing a table, but only reporting the values for the non-index
472        parameter columns.  The first column is assumed to represent an
473        index column.  A missing value is represented in the column data."""
474        pyutilib.misc.setup_redirect(currdir+'importS.dat')
475        print "import "+os.path.abspath(example_dir+'S.tab')+": [A] S ;"
476        pyutilib.misc.reset_redirect()
477        model=Model()
478        model.A = Set(initialize=['A1','A2','A3','A4'])
479        model.S = Param(model.A)
480        instance = model.create(currdir+'importS.dat')
481        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
482        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
483        os.remove(currdir+'importS.dat')
484
485    def test_tablePO(self):
486        """Importing a table that has multiple indexing columns"""
487        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
488        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
489        pyutilib.misc.reset_redirect()
490        model=Model()
491        model.J = Set(dimen=2)
492        model.P = Param(model.J)
493        model.O = Param(model.J)
494        instance = model.create(currdir+'importPO.dat')
495        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
496        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
497        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
498        os.remove(currdir+'importPO.dat')
499
500
501class TestCsvImport(unittest.TestCase):
502
503    def test_tableA1(self):
504        """Importing a single column of data"""
505        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
506        print "import "+os.path.abspath(csv_dir+'A.csv')+" format=set: A;"
507        pyutilib.misc.reset_redirect()
508        model=Model()
509        model.A = Set()
510        instance = model.create(currdir+'importA1.dat')
511        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
512        os.remove(currdir+'importA1.dat')
513
514    def test_tableA2(self):
515        """Importing a single column of data"""
516        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
517        print "import "+os.path.abspath(csv_dir+'A.csv')+" ;"
518        pyutilib.misc.reset_redirect()
519        model=Model()
520        model.A = Set()
521        try:
522            instance = model.create(currdir+'importA2.dat')
523            self.fail("Should fail because no set name is specified")
524        except IOError:
525            pass
526        os.remove(currdir+'importA2.dat')
527
528    def test_tableA3(self):
529        """Importing a single column of data"""
530        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
531        print "import "+os.path.abspath(csv_dir+'A.csv')+" : A ;"
532        pyutilib.misc.reset_redirect()
533        model=Model()
534        model.A = Set()
535        try:
536            instance = model.create(currdir+'importA3.dat')
537            self.fail("Should fail because no index is specified")
538        except IOError:
539            pass
540        os.remove(currdir+'importA3.dat')
541
542    def test_tableB(self):
543        """Same as test_tableA"""
544        pyutilib.misc.setup_redirect(currdir+'importB.dat')
545        print "import "+os.path.abspath(csv_dir+'B.csv')+" format=set:B;"
546        pyutilib.misc.reset_redirect()
547        model=Model()
548        model.B = Set()
549        instance = model.create(currdir+'importB.dat')
550        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
551        os.remove(currdir+'importB.dat')
552
553    def test_tableC(self):
554        """Importing a multi-column table, where all columns are
555        treated as values for a set with tuple values."""
556        pyutilib.misc.setup_redirect(currdir+'importC.dat')
557        print "import "+os.path.abspath(csv_dir+'C.csv')+" format=set: C ;"
558        pyutilib.misc.reset_redirect()
559        model=Model()
560        model.C = Set(dimen=2)
561        instance = model.create(currdir+'importC.dat')
562        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
563        os.remove(currdir+'importC.dat')
564
565    def test_tableD(self):
566        """Importing a 2D array of data as a set."""
567        pyutilib.misc.setup_redirect(currdir+'importD.dat')
568        print "import "+os.path.abspath(csv_dir+'D.csv')+" format=set_array: C ;"
569        pyutilib.misc.reset_redirect()
570        model=Model()
571        model.C = Set(dimen=2)
572        instance = model.create(currdir+'importD.dat')
573        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
574        os.remove(currdir+'importD.dat')
575
576    def test_tableZ(self):
577        """Importing a single parameter"""
578        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
579        print "import "+os.path.abspath(csv_dir+'Z.csv')+" format=param: Z ;"
580        pyutilib.misc.reset_redirect()
581        model=Model()
582        model.Z = Param(default=99.0)
583        instance = model.create(currdir+'importZ.dat')
584        self.failUnlessEqual(instance.Z.value, 1.1)
585        os.remove(currdir+'importZ.dat')
586
587    def test_tableY(self):
588        """Same as tableXW."""
589        pyutilib.misc.setup_redirect(currdir+'importY.dat')
590        print "import "+os.path.abspath(csv_dir+'Y.csv')+" : [A] Y;"
591        pyutilib.misc.reset_redirect()
592        model=Model()
593        model.A = Set(initialize=['A1','A2','A3','A4'])
594        model.Y = Param(model.A)
595        instance = model.create(currdir+'importY.dat')
596        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
597        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
598        os.remove(currdir+'importY.dat')
599
600    def test_tableXW_1(self):
601        """Importing a table, but only reporting the values for the non-index
602        parameter columns.  The first column is assumed to represent an
603        index column."""
604        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
605        print "import "+os.path.abspath(csv_dir+'XW.csv')+": [A] X W;"
606        pyutilib.misc.reset_redirect()
607        model=Model()
608        model.A = Set(initialize=['A1','A2','A3','A4'])
609        model.X = Param(model.A)
610        model.W = Param(model.A)
611        instance = model.create(currdir+'importXW.dat')
612        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
613        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
614        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
615        os.remove(currdir+'importXW.dat')
616
617    def test_tableXW_2(self):
618        """Like test_tableXW_1, except that set A is not defined."""
619        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
620        print "import "+os.path.abspath(csv_dir+'XW.csv')+": [A] X W;"
621        pyutilib.misc.reset_redirect()
622        model=Model()
623        model.A = Set()
624        model.X = Param(model.A)
625        model.W = Param(model.A)
626        instance = model.create(currdir+'importXW.dat')
627        self.failUnlessEqual(instance.A.data(), set())
628        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
629        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
630        os.remove(currdir+'importXW.dat')
631
632    def test_tableXW_3(self):
633        """Like test_tableXW_1, except that set A is defined in the import statment."""
634        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
635        print "import "+os.path.abspath(csv_dir+'XW.csv')+": A=[A] X W;"
636        pyutilib.misc.reset_redirect()
637        model=Model()
638        model.A = Set()
639        model.X = Param(model.A)
640        model.W = Param(model.A)
641        instance = model.create(currdir+'importXW.dat')
642        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
643        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
644        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
645        os.remove(currdir+'importXW.dat')
646
647    def test_tableXW_4(self):
648        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
649        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
650        print "import "+os.path.abspath(csv_dir+'XW.csv')+": B=[A] R=X S=W;"
651        pyutilib.misc.reset_redirect()
652        model=Model()
653        model.B = Set()
654        model.R = Param(model.B)
655        model.S = Param(model.B)
656        instance = model.create(currdir+'importXW.dat')
657        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
658        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
659        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
660        os.remove(currdir+'importXW.dat')
661
662    def test_tableT(self):
663        """Importing a 2D array of parameters that are transposed."""
664        pyutilib.misc.setup_redirect(currdir+'importT.dat')
665        print "import "+os.path.abspath(csv_dir+'T.csv')+" format=transposed_array : T;"
666        pyutilib.misc.reset_redirect()
667        model=Model()
668        model.A = Set()
669        model.B = Set()
670        model.T = Param(model.A, model.B)
671        instance = model.create(currdir+'importT.dat')
672        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})
673        os.remove(currdir+'importT.dat')
674
675    def test_tableU(self):
676        """Importing a 2D array of parameters."""
677        pyutilib.misc.setup_redirect(currdir+'importU.dat')
678        print "import "+os.path.abspath(csv_dir+'U.csv')+" format=array : U;"
679        pyutilib.misc.reset_redirect()
680        model=Model()
681        model.A = Set()
682        model.B = Set()
683        model.U = Param(model.A, model.B)
684        instance = model.create(currdir+'importU.dat')
685        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})
686        os.remove(currdir+'importU.dat')
687
688    def test_tableS(self):
689        """Importing a table, but only reporting the values for the non-index
690        parameter columns.  The first column is assumed to represent an
691        index column.  A missing value is represented in the column data."""
692        pyutilib.misc.setup_redirect(currdir+'importS.dat')
693        print "import "+os.path.abspath(csv_dir+'S.csv')+": [A] S ;"
694        pyutilib.misc.reset_redirect()
695        model=Model()
696        model.A = Set(initialize=['A1','A2','A3','A4'])
697        model.S = Param(model.A)
698        instance = model.create(currdir+'importS.dat')
699        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
700        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
701        os.remove(currdir+'importS.dat')
702
703    def test_tablePO(self):
704        """Importing a table that has multiple indexing columns"""
705        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
706        print "import "+os.path.abspath(csv_dir+'PO.csv')+" : J=[A,B] P O;"
707        pyutilib.misc.reset_redirect()
708        model=Model()
709        model.J = Set(dimen=2)
710        model.P = Param(model.J)
711        model.O = Param(model.J)
712        instance = model.create(currdir+'importPO.dat')
713        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
714        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
715        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
716        os.remove(currdir+'importPO.dat')
717
718
719
720class TestSpreadsheet(unittest.TestCase):
721
722    def run(self, result=None):
723        """ Disable the tests if win32com is not available """
724        if not _win32com:
725           return
726        unittest.TestCase.run(self,result)
727
728    def test_tableA1(self):
729        """Importing a single column of data"""
730        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
731        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable format=set: A;"
732        pyutilib.misc.reset_redirect()
733        model=Model()
734        model.A = Set()
735        instance = model.create(currdir+'importA1.dat')
736        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
737        os.remove(currdir+'importA1.dat')
738
739    def test_tableA2(self):
740        """Importing a single column of data"""
741        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
742        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable ;"
743        pyutilib.misc.reset_redirect()
744        model=Model()
745        model.A = Set()
746        try:
747            instance = model.create(currdir+'importA2.dat')
748            self.fail("Should fail because no set name is specified")
749        except IOError:
750            pass
751        os.remove(currdir+'importA2.dat')
752
753    def test_tableA3(self):
754        """Importing a single column of data"""
755        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
756        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable : A ;"
757        pyutilib.misc.reset_redirect()
758        model=Model()
759        model.A = Set()
760        try:
761            instance = model.create(currdir+'importA3.dat')
762            self.fail("Should fail because no index is specified")
763        except IOError:
764            pass
765        os.remove(currdir+'importA3.dat')
766
767    def test_tableB(self):
768        """Same as test_tableA"""
769        pyutilib.misc.setup_redirect(currdir+'importB.dat')
770        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Btable format=set:B;"
771        pyutilib.misc.reset_redirect()
772        model=Model()
773        model.B = Set()
774        instance = model.create(currdir+'importB.dat')
775        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
776        os.remove(currdir+'importB.dat')
777
778    def test_tableC(self):
779        """Importing a multi-column table, where all columns are
780        treated as values for a set with tuple values."""
781        pyutilib.misc.setup_redirect(currdir+'importC.dat')
782        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ctable format=set: C ;"
783        pyutilib.misc.reset_redirect()
784        model=Model()
785        model.C = Set(dimen=2)
786        instance = model.create(currdir+'importC.dat')
787        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
788        os.remove(currdir+'importC.dat')
789
790    def test_tableD(self):
791        """Importing a 2D array of data as a set."""
792        pyutilib.misc.setup_redirect(currdir+'importD.dat')
793        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Dtable format=set_array: C ;"
794        pyutilib.misc.reset_redirect()
795        model=Model()
796        model.C = Set(dimen=2)
797        instance = model.create(currdir+'importD.dat')
798        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
799        os.remove(currdir+'importD.dat')
800
801    def test_tableZ(self):
802        """Importing a single parameter"""
803        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
804        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Zparam format=param: Z ;"
805        pyutilib.misc.reset_redirect()
806        model=Model()
807        model.Z = Param(default=99.0)
808        instance = model.create(currdir+'importZ.dat')
809        self.failUnlessEqual(instance.Z.value, 1.1)
810        os.remove(currdir+'importZ.dat')
811
812    def test_tableY(self):
813        """Same as tableXW."""
814        pyutilib.misc.setup_redirect(currdir+'importY.dat')
815        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ytable : [A] Y;"
816        pyutilib.misc.reset_redirect()
817        model=Model()
818        model.A = Set(initialize=['A1','A2','A3','A4'])
819        model.Y = Param(model.A)
820        instance = model.create(currdir+'importY.dat')
821        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
822        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
823        os.remove(currdir+'importY.dat')
824
825    def test_tableXW_1(self):
826        """Importing a table, but only reporting the values for the non-index
827        parameter columns.  The first column is assumed to represent an
828        index column."""
829        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
830        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
831        pyutilib.misc.reset_redirect()
832        model=Model()
833        model.A = Set(initialize=['A1','A2','A3','A4'])
834        model.X = Param(model.A)
835        model.W = Param(model.A)
836        instance = model.create(currdir+'importXW.dat')
837        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
838        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
839        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
840        os.remove(currdir+'importXW.dat')
841
842    def test_tableXW_2(self):
843        """Like test_tableXW_1, except that set A is not defined."""
844        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
845        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
846        pyutilib.misc.reset_redirect()
847        model=Model()
848        model.A = Set()
849        model.X = Param(model.A)
850        model.W = Param(model.A)
851        instance = model.create(currdir+'importXW.dat')
852        self.failUnlessEqual(instance.A.data(), set())
853        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
854        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
855        os.remove(currdir+'importXW.dat')
856
857    def test_tableXW_3(self):
858        """Like test_tableXW_1, except that set A is defined in the import statment."""
859        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
860        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: A=[A] X W;"
861        pyutilib.misc.reset_redirect()
862        model=Model()
863        model.A = Set()
864        model.X = Param(model.A)
865        model.W = Param(model.A)
866        instance = model.create(currdir+'importXW.dat')
867        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
868        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
869        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
870        os.remove(currdir+'importXW.dat')
871
872    def test_tableXW_4(self):
873        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
874        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
875        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: B=[A] R=X S=W;"
876        pyutilib.misc.reset_redirect()
877        model=Model()
878        model.B = Set()
879        model.R = Param(model.B)
880        model.S = Param(model.B)
881        instance = model.create(currdir+'importXW.dat')
882        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
883        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
884        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
885        os.remove(currdir+'importXW.dat')
886
887    def test_tableT(self):
888        """Importing a 2D array of parameters that are transposed."""
889        pyutilib.misc.setup_redirect(currdir+'importT.dat')
890        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ttable format=transposed_array : T;"
891        pyutilib.misc.reset_redirect()
892        model=Model()
893        model.A = Set()
894        model.B = Set()
895        model.T = Param(model.A, model.B)
896        instance = model.create(currdir+'importT.dat')
897        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})
898        os.remove(currdir+'importT.dat')
899
900    def test_tableU(self):
901        """Importing a 2D array of parameters."""
902        pyutilib.misc.setup_redirect(currdir+'importU.dat')
903        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Utable format=array : U;"
904        pyutilib.misc.reset_redirect()
905        model=Model()
906        model.A = Set()
907        model.B = Set()
908        model.U = Param(model.A, model.B)
909        instance = model.create(currdir+'importU.dat')
910        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})
911        os.remove(currdir+'importU.dat')
912
913    def test_tableS(self):
914        """Importing a table, but only reporting the values for the non-index
915        parameter columns.  The first column is assumed to represent an
916        index column.  A missing value is represented in the column data."""
917        pyutilib.misc.setup_redirect(currdir+'importS.dat')
918        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Stable : [A] S ;"
919        pyutilib.misc.reset_redirect()
920        model=Model()
921        model.A = Set(initialize=['A1','A2','A3','A4'])
922        model.S = Param(model.A)
923        instance = model.create(currdir+'importS.dat')
924        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
925        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
926        os.remove(currdir+'importS.dat')
927
928    def test_tablePO(self):
929        """Importing a table that has multiple indexing columns"""
930        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
931        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=POtable : J=[A,B] P O;"
932        pyutilib.misc.reset_redirect()
933        model=Model()
934        model.J = Set(dimen=2)
935        model.P = Param(model.J)
936        model.O = Param(model.J)
937        instance = model.create(currdir+'importPO.dat')
938        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
939        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
940        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
941        os.remove(currdir+'importPO.dat')
942
943
944class TestModelData(unittest.TestCase):
945
946    def test_tableA1(self):
947        """Importing a single column of data"""
948        md = ModelData()
949        md.add(os.path.abspath(example_dir+'A.tab'), format='set', set='A')
950        model=Model()
951        model.A = Set()
952        md.read(model)
953        instance = model.create(md)
954        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
955
956    def test_tableA2(self):
957        """Importing a single column of data"""
958        md = ModelData()
959        md.add(os.path.abspath(example_dir+'A.tab'))
960        model=Model()
961        model.A = Set()
962        try:
963            md.read(model)
964            instance = model.create(md)
965            self.fail("Should fail because no set name is specified")
966        except IOError:
967            pass
968
969    def test_tableA3(self):
970        """Importing a single column of data"""
971        md = ModelData()
972        md.add(os.path.abspath(example_dir+'A.tab'), set='A')
973        model=Model()
974        model.A = Set()
975        try:
976            md.read(model)
977            instance = model.create(md)
978            self.fail("Should fail because no index is specified")
979        except IOError:
980            pass
981
982    def test_tableB(self):
983        """Same as test_tableA"""
984        md = ModelData()
985        md.add(os.path.abspath(example_dir+'B.tab'), format='set', set='B')
986        model=Model()
987        model.B = Set()
988        md.read(model)
989        instance = model.create(md)
990        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
991
992    def test_tableC(self):
993        """Importing a multi-column table, where all columns are
994        treated as values for a set with tuple values."""
995        md = ModelData()
996        md.add(os.path.abspath(example_dir+'C.tab'), format='set', set='C')
997        model=Model()
998        model.C = Set(dimen=2)
999        md.read(model)
1000        instance = model.create(md)
1001        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
1002
1003    def test_tableD(self):
1004        """Importing a 2D array of data as a set."""
1005        md = ModelData()
1006        md.add(os.path.abspath(example_dir+'D.tab'), format='set_array', set='C')
1007        model=Model()
1008        model.C = Set(dimen=2)
1009        md.read(model)
1010        instance = model.create(md)
1011        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
1012
1013    def test_tableZ(self):
1014        """Importing a single parameter"""
1015        md = ModelData()
1016        md.add(os.path.abspath(example_dir+'Z.tab'), format='param', param='Z')
1017        model=Model()
1018        model.Z = Param(default=99.0)
1019        md.read(model)
1020        instance = model.create(md)
1021        self.failUnlessEqual(instance.Z.value, 1.1)
1022
1023    def test_tableY(self):
1024        """Same as tableXW."""
1025        md = ModelData()
1026        md.add(os.path.abspath(example_dir+'Y.tab'), index=['A'], param=['Y'])
1027        model=Model()
1028        model.A = Set(initialize=['A1','A2','A3','A4'])
1029        model.Y = Param(model.A)
1030        md.read(model)
1031        instance = model.create(md)
1032        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1033        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1034
1035    def test_tableXW_1(self):
1036        """Importing a table, but only reporting the values for the non-index
1037        parameter columns.  The first column is assumed to represent an
1038        index column."""
1039        md = ModelData()
1040        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
1041        model=Model()
1042        model.A = Set(initialize=['A1','A2','A3','A4'])
1043        model.X = Param(model.A)
1044        model.W = Param(model.A)
1045        md.read(model)
1046        instance = model.create(md)
1047        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1048        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1049        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1050
1051    def test_tableXW_2(self):
1052        """Like test_tableXW_1, except that set A is not defined."""
1053        md = ModelData()
1054        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
1055        model=Model()
1056        model.A = Set()
1057        model.X = Param(model.A)
1058        model.W = Param(model.A)
1059        md.read(model)
1060        instance = model.create(md)
1061        self.failUnlessEqual(instance.A.data(), set())
1062        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1063        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1064
1065    def test_tableXW_3(self):
1066        """Like test_tableXW_1, except that set A is defined in the import statment."""
1067        md = ModelData()
1068        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='A', index=['A'], param=['X','W'])
1069        model=Model()
1070        model.A = Set()
1071        model.X = Param(model.A)
1072        model.W = Param(model.A)
1073        md.read(model)
1074        instance = model.create(md)
1075        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
1076        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1077        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1078
1079    def test_tableXW_4(self):
1080        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
1081        md = ModelData()
1082        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='B', index=['A'], param=['X','W'], param_name={'X':'R', 'W':'S'})
1083        model=Model()
1084        model.B = Set()
1085        model.R = Param(model.B)
1086        model.S = Param(model.B)
1087        md.read(model)
1088        instance = model.create(md)
1089        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
1090        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1091        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1092
1093    def test_tableT(self):
1094        """Importing a 2D array of parameters that are transposed."""
1095        md = ModelData()
1096        md.add(os.path.abspath(example_dir+'T.tab'), format='transposed_array', param='T')
1097        model=Model()
1098        model.A = Set()
1099        model.B = Set()
1100        model.T = Param(model.A, model.B)
1101        md.read(model)
1102        instance = model.create(md)
1103        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})
1104
1105    def test_tableU(self):
1106        """Importing a 2D array of parameters."""
1107        md = ModelData()
1108        md.add(os.path.abspath(example_dir+'T.tab'), format='array', param='U')
1109        model=Model()
1110        model.A = Set()
1111        model.B = Set()
1112        model.U = Param(model.A, model.B)
1113        md.read(model)
1114        instance = model.create(md)
1115        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})
1116
1117    def test_tableS(self):
1118        """Importing a table, but only reporting the values for the non-index
1119        parameter columns.  The first column is assumed to represent an
1120        index column.  A missing value is represented in the column data."""
1121        md = ModelData()
1122        md.add(os.path.abspath(example_dir+'S.tab'), index=['A'], param=['S'])
1123        model=Model()
1124        model.A = Set(initialize=['A1','A2','A3','A4'])
1125        model.S = Param(model.A)
1126        md.read(model)
1127        instance = model.create(md)
1128        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1129        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
1130
1131    def test_tablePO(self):
1132        """Importing a table that has multiple indexing columns"""
1133        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
1134        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
1135        pyutilib.misc.reset_redirect()
1136        md = ModelData()
1137        md.add(os.path.abspath(example_dir+'PO.tab'), index_name='J', index=['A','B'], param=['P','O'])
1138        model=Model()
1139        model.J = Set(dimen=2)
1140        model.P = Param(model.J)
1141        model.O = Param(model.J)
1142        md.read(model)
1143        instance = model.create(md)
1144        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
1145        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
1146        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
1147
1148
1149if __name__ == "__main__":
1150   unittest.main()
1151
Note: See TracBrowser for help on using the repository browser.