Changeset 2227


Ignore:
Timestamp:
Feb 1, 2010 4:40:08 PM (10 years ago)
Author:
wehart
Message:

This is a major rework of the ModelData? logic. I've extracted the
actual operations for data loading into different plugins. These
plugins share a common code base for processing the data into a form that
Pyomo can use, but that logic is now separate from the ModelData? class itself.
This will provide a path-forward for cleaning up this code, as well as
modularizing the parsing of AMPL *.dat files.

Location:
coopr.pyomo/trunk
Files:
7 added
7 edited

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/__init__.py

    r2201 r2227  
    1717import base.pyomo as pyomo
    1818from expr import *
     19import data
    1920import io
    2021from components import *
  • coopr.pyomo/trunk/coopr/pyomo/base/PyomoModelData.py

    r1958 r2227  
    99#  _________________________________________________________________________
    1010
    11 import re
    12 import copy
    13 import math
    14 import os
    15 from pyutilib.misc import quote_split
     11__all__ = ['ModelData']
     12
     13from plugin import *
    1614import pyomo
    17 from pyutilib.excel import ExcelSpreadsheet
    18 import coopr
    1915
    2016
     
    2218    """
    2319    An object that manages data for a model.
     20
    2421    This object contains the interface routines for importing and
    2522    exporting data from external data sources.
    2623    """
    2724
    28     def __init__(self,model=None,filename=None):
     25    def __init__(self, **kwds):
    2926        """
    3027        Constructor
    3128        """
     29        #
     30        # This is the data that is imported from various data sources
     31        #
     32        self._default={}
     33        self._data={}
     34        #
    3235        self._info=[]
    33         #self._info_dict={}
    34         self._data={}
    35         self._default={}
    36         self._model=model
    37         self._table={}
    38         if filename is not None:
    39            self.import_data_file(filename)
     36        if 'model' in kwds:
     37            self._model=kwds['model']
     38            del kwds['model']
     39        else:
     40            self._model=None
     41        if 'filename' in kwds:
     42            if not kwds['filename'] is None:
     43                filename = kwds['filename']
     44                del kwds['filename']
     45                self.add(filename, **kwds)
     46                self.read()
     47        elif len(kwds) > 0:
     48            raise ValueError, "Unknown options: %s" % str(kwds.keys())
    4049
     50    def add(self, filename, **kwds):
     51        tmp = filename.split(".")[-1]
     52        data = DataManagerFactory(tmp)
     53        data.initialize(filename, **kwds)
     54        self._info.append(data)
    4155
    42     #def add_data_file(self,filename, name=None):
    43         #if name is not None:
    44         #   self._info_dict[name] = len(self._info)
    45     def add_data_file(self,filename):
    46         self._info.append(filename)
    47 
    48 
    49     def add_table(self, filename, range=None, **kwds):
    50         """
    51         Add an Excel table
    52         """
    53         #if "name" in kwds:
    54         #   if name is not None:
    55         #      self._info_dict[kwds["name"]] = len(self._info)
    56         if filename not in self._table.keys():
    57            kwds["filename"]=filename
    58            self._table[filename] = TableData(**kwds)
    59         self._info.append((filename,range,kwds))
    60 
    61 
    62     def read(self,model=None):
     56    def read(self, model=None):
    6357        """
    6458        Read data
     
    6963           raise ValueError, "Cannot read model data without a model"
    7064        #
    71         # Open all tables
     65        # Although we want to load data in a particular order, it
     66        # may make sense to open/close all data resources all at once.
     67        # Should we do this by default, or make this a configuration option
     68        # for this class?
    7269        #
    73         for key in self._table.keys():
    74           self._table[key].open()
    75         #
    76         # For every information item, import the data or table
    77         #
    78         for item in self._info:
    79           if type(item) is str:
    80              if pyomo.debug("verbose"):         #pragma:nocover
    81                 print "Importing data from file "+item,
    82              status = self.import_data_file(item)
    83              if pyomo.debug("verbose"):         #pragma:nocover
    84                 print "... done."
    85           else:       
    86              if pyomo.debug("verbose"):         #pragma:nocover
    87                 print "Importing data from table "+item[0],
    88                 if item[1] is not None:
    89                    print "at range "+item[1],
    90              try:
    91                 status = self.import_table(self._table[item[0]], item[1], item[2])
    92              except IOError, err:
    93                 raise IOError, "Problem importing data from table "+item[0]+": "+str(err)
    94              except AttributeError, err:
    95                 raise IOError, "Problem importing data from table "+item[0]+": "+str(err)
    96              if pyomo.debug("verbose"):         #pragma:nocover
    97                 print "... done."
    98           if not status:
    99              print "Warning: status is "+str(status)+" after processing "+str(item)
    100         #
    101         # Close all tables
    102         #
    103         for key in self._table.keys():
    104           self._table[key].close()
     70        for data in self._info:
     71            if pyomo.debug("verbose"):         #pragma:nocover
     72                print "Importing data..."
     73            data.open()
     74            if not data.read():
     75                print "Warning: error occured while processing %s" % str(data)
     76            data.close()
     77            if pyomo.debug("verbose"):         #pragma:nocover
     78                print "Processing data ..."
     79            #
     80            # Update the _data and _default dictionaries with data that
     81            # was read in.
     82            #
     83            status = data.process(self._model, self._data, self._default)
     84            data.clear()
     85            if pyomo.debug("verbose"):         #pragma:nocover
     86                print "Done."
    10587
    106 
    107     def import_table(self, table, range, keywords):
    108         """
    109         Import a table
    110         """
    111         table.read(range, keywords)
    112         tmp = table.data()
    113         if pyomo.debug("reader"):               #pragma:nocover
    114            print "import_table - data: "+str(tmp)
    115         status = self._process_data(tmp)
    116         table.clear()
    117         return status
    118 
    119 
    120     def import_data_file(self, filename):
    121         """
    122         Create a table of tuples to values, based on data from a file.
    123         We assume that this data is defined in a format that is
    124         compatible with AMPL.
    125         """
    126         global Filename
    127         Filename = filename
    128         global Lineno
    129         Lineno = 0
    130         INPUT = open(filename,"r")
    131         cmd=""
    132         status=True
    133         for line in INPUT:
    134           Lineno += 1
    135           line = re.sub(":"," :",line)
    136           line = line.strip()
    137           if line == "" or line[0] == '#':
    138              continue
    139           cmd = cmd + " " + line
    140           if ';' in cmd:
    141              #
    142              # We assume that a ';' indicates an end-of-command declaration.
    143              # However, the user might have put multiple commands on a single
    144              # line, so we need to split the line based on these values.
    145              # BUT, at the end of the line we should see an 'empty' command,
    146              # which we ignore.
    147              #
    148              for item in cmd.split(';'):
    149                item = item.strip()
    150                if item != "":
    151                   status = self._process_data(quote_split("[\t ]+",item))
    152                if not status:
    153                   break
    154              cmd = ""
    155           if not status:
    156                  break
    157         if cmd != "":
    158            raise IOError, "ERROR: There was unprocessed text at the end of the data file!: \"" + cmd + "\""
    159         return status
    160 
    161 
    162     def _preprocess_data(self,cmd):
    163         """
    164         Called by _process_data() to (1) combine tokens that comprise a tuple
    165         and (2) combine the ':' token with the previous token
    166         """
    167         if pyomo.debug("reader"):               #pragma:nocover
    168            print "_preprocess_data(start)",cmd
    169         status=")"
    170         newcmd=[]
    171         for token in cmd:
    172           if type(token) in (str,unicode):
    173              token=str(token)
    174              if "(" in token and ")" in token:
    175                 newcmd.append(token)
    176                 status=")"
    177              elif "(" in token:
    178                 if status == "(":
    179                    raise ValueError, "Two '('s follow each other in data "+token
    180                 status="("
    181                 newcmd.append(token)
    182              elif ")" in token:
    183                 if status == ")":
    184                    raise ValueError, "Two ')'s follow each other in data"
    185                 status=")"
    186                 newcmd[-1] = newcmd[-1]+token
    187              elif status == "(":
    188                 newcmd[-1] = newcmd[-1]+token
    189              else:
    190                 newcmd.append(token)
    191           else:
    192              if type(token) is float and math.floor(token) == token:
    193                 token=int(token)
    194              newcmd.append(token)
    195         if pyomo.debug("reader"):               #pragma:nocover
    196            print "_preprocess_data(end)",newcmd
    197         return newcmd
    198 
    199 
    200     def _process_data(self,cmd):
    201         """
    202         Called by import_file() to (1) preprocess data and (2) call
    203         subroutines to process different types of data
    204         """
    205         global Lineno
    206         global Filename
    207         if pyomo.debug("reader"):               #pragma:nocover
    208            print "DEBUG: _process_data (start)",cmd
    209         if len(cmd) == 0:                       #pragma:nocover
    210            raise ValueError, "ERROR: Empty list passed to Model::_process_data"
    211         cmd = self._preprocess_data(cmd)
    212         if cmd[0] == "data":
    213            return True
    214         if cmd[0] == "end":
    215            return False
    216         if cmd[0][0:3] == "set":
    217            self._process_set(cmd)
    218         elif cmd[0][0:5] == "param":
    219            self._process_param(cmd)
    220         else:
    221            raise IOError, "ERROR: Trouble on line "+str(Lineno)+" of file "+Filename+": Unknown data command: "+" ".join(cmd)
    222         return True
    223 
    224 
    225     def _process_set(self,cmd):
    226         """
    227         Called by _process_data() to process a set declaration.
    228         """
    229         if pyomo.debug("reader"):               #pragma:nocover
    230            print "DEBUG: _process_set(start)",cmd
    231         #
    232         # Process a set
    233         #
    234         if "[" in cmd[1]:
    235            tokens = re.split("[\[\]]",cmd[1])
    236            ndx=tokens[1]
    237            ndx=tuple(self._data_eval(ndx.split(",")))
    238            if tokens[0] not in self._data:
    239               self._data[tokens[0]] = {}
    240            self._data[tokens[0]][ndx] = self._process_set_data(cmd[3:],tokens[0])
    241         elif cmd[2] == ":":
    242            self._data[cmd[1]] = {}
    243            self._data[cmd[1]][None] = []
    244            i=3
    245            while cmd[i] != ":=":
    246               i += 1
    247            ndx1 = cmd[3:i]
    248            i += 1
    249            while i<len(cmd):
    250               ndx=cmd[i]
    251               for j in range(0,len(ndx1)):
    252                 if cmd[i+j+1] == "+":
    253                    self._data[cmd[1]][None] += self._process_set_data(["("+str(ndx1[j])+","+str(cmd[i])+")"],cmd[1])
    254               i += len(ndx1)+1
    255         else:
    256            self._data[cmd[1]] = {}
    257            self._data[cmd[1]][None] = self._process_set_data(cmd[3:], cmd[1])
    258 
    259 
    260     def _process_set_data(self,cmd,sname):
    261         """
    262         Called by _process_set() to process set data.
    263         """
    264         if pyomo.debug("reader"):               #pragma:nocover
    265            print "DEBUG: _process_set_data(start)",cmd
    266         if len(cmd) == 0:
    267            return []
    268         sd = getattr(self._model,sname)
    269         #d = sd.dimen
    270         cmd = self._data_eval(cmd)
    271         ans=[]
    272         i=0
    273         flag=type(cmd[0]) is tuple
    274         tmp=None
    275         ndx=None
    276         while i<len(cmd):
    277           if type(cmd[i]) is not tuple:
    278             if flag:
    279                #if type(cmd[i]) is not tuple:
    280                #   raise ValueError, "Problem initializing set="+sname+" with input data="+str(cmd)+" - first element was interpreted as a tuple, but element="+str(i)+" is of type="+str(type(cmd[i]))+"; types must be consistent"
    281                tmpval=tmp
    282                tmpval[ndx] = self._data_eval([cmd[i]])[0]
    283                #
    284                # WEH - I'm not sure what the next two lines are for
    285                #        These are called when initializing a set with more than
    286                #        one dimension
    287                #if d > 1:
    288                #   tmpval = util.tuplize(tmpval,d,sname)
    289                ans.append(tuple(tmpval))
    290             else:
    291                ans.append(cmd[i])
    292           elif "*" not in cmd[i]:
    293             ans.append(cmd[i])
    294           else:
    295             j = i
    296             tmp=list(cmd[j])
    297             ndx=tmp.index("*")
    298           i += 1
    299         if pyomo.debug("reader"):               #pragma:nocover
    300            print "DEBUG: _process_set_data(end)",ans
    301         return ans
    302 
    303 
    304     def _process_param(self,cmd):
    305         """
    306         Called by _process_data to process data for a Parameter declaration
    307         """
    308         if pyomo.debug("reader"):               #pragma:nocover
    309            print "DEBUG: _process_param(start)",cmd
    310         #
    311         # Process parameters
    312         #
    313         dflt = None
    314         singledef = True
    315         cmd = cmd[1:]
    316         #print "HERE",cmd
    317         #
    318         # WEH - this is apparently not used
    319         #
    320         #if cmd[0] == "default":
    321         #   dflt = self._data_eval(cmd[1])[0]
    322         #   cmd = cmd[2:]
    323         if cmd[0] == ":":
    324            singledef = False
    325            cmd = cmd[1:]
    326         if singledef:
    327            pname = cmd[0]
    328            cmd = cmd[1:]
    329            if len(cmd) >= 2 and cmd[0] == "default":
    330               dflt = self._data_eval(cmd[1])[0]
    331               cmd = cmd[2:]
    332            if dflt != None:
    333               self._default[pname] = dflt
    334            if cmd[0] == ":=":
    335               cmd = cmd[1:]
    336            transpose = False
    337            if cmd[0] == "(tr)":
    338               transpose = True
    339               if cmd[1] == ":":
    340                  cmd = cmd[1:]
    341               else:
    342                  cmd[0] = ":"
    343            if cmd[0] != ":":
    344               if pyomo.debug("reader"):             #pragma:nocover
    345                  print "DEBUG: _process_param (singledef without :...:=)",cmd
    346               if not transpose:
    347                  if pname not in self._data:
    348                     self._data[pname] = {}
    349                  finaldata = self._process_data_list(getattr(self._model,pname).dim(), self._data_eval(cmd))
    350                  for key in finaldata:
    351                     self._data[pname][key]=finaldata[key]
    352               else:
    353                  tmp = ["param", pname, ":="]
    354                  i=1
    355                  while i < len(cmd):
    356                     i0 = i
    357                     while cmd[i] != ":=":
    358                       i=i+1
    359                     ncol = i - i0 + 1
    360                     lcmd = i
    361                     while lcmd < len(cmd) and cmd[lcmd] != ":":
    362                       lcmd += 1
    363                     j0 = i0 - 1
    364                     for j in range(1,ncol):
    365                       ii = 1 + i
    366                       kk = ii + j
    367                       while kk < lcmd:
    368                         if cmd[kk] != ".":
    369                         #if 1>0:
    370                            tmp.append(copy.copy(cmd[j+j0]))
    371                            tmp.append(copy.copy(cmd[ii]))
    372                            tmp.append(copy.copy(cmd[kk]))
    373                         ii = ii + ncol
    374                         kk = kk + ncol
    375                     i = lcmd + 1
    376                  self._process_param(tmp)
    377            else:
    378               tmp = ["param", pname, ":="]
    379               i=1
    380               if pyomo.debug("reader"):             #pragma:nocover
    381                  print "DEBUG: _process_param (singledef with :...:=)",cmd
    382               while i < len(cmd):
    383                 i0 = i
    384                 while i<len(cmd) and cmd[i] != ":=":
    385                   i=i+1
    386                 if i==len(cmd):
    387                    raise ValueError, "ERROR: Trouble on line "+str(Lineno)+" of file "+Filename
    388                 ncol = i - i0 + 1
    389                 lcmd = i
    390                 while lcmd < len(cmd) and cmd[lcmd] != ":":
    391                   lcmd += 1
    392                 j0 = i0 - 1
    393                 for j in range(1,ncol):
    394                   ii = 1 + i
    395                   kk = ii + j
    396                   while kk < lcmd:
    397                     if cmd[kk] != ".":
    398                         if transpose:
    399                            tmp.append(copy.copy(cmd[j+j0]))
    400                            tmp.append(copy.copy(cmd[ii]))
    401                         else:
    402                            tmp.append(copy.copy(cmd[ii]))
    403                            tmp.append(copy.copy(cmd[j+j0]))
    404                         tmp.append(copy.copy(cmd[kk]))
    405                     ii = ii + ncol
    406                     kk = kk + ncol
    407                 i = lcmd + 1
    408                 self._process_param(tmp)
    409 
    410         else:
    411            if pyomo.debug("reader"):                #pragma:nocover
    412               print "DEBUG: _process_param (cmd[0]=='param:')",cmd
    413            i=0
    414            nsets=0
    415            while i<len(cmd) and cmd[i] != ":=":
    416              if cmd[i] == ":":
    417                 nsets = i
    418              i += 1
    419            if i==len(cmd):
    420               raise ValueError, "Trouble on data file line "+str(Lineno)+" of file "+Filename
    421            if pyomo.debug("reader"):                #pragma:nocover
    422               print "NSets",nsets
    423            Lcmd = len(cmd)
    424            j=0
    425            d = 1
    426            #
    427            # Process sets first
    428            #
    429            while j<nsets:
    430              sname = cmd[j]
    431              d = getattr(self._model,sname).dimen
    432              np = i-1
    433              if pyomo.debug("reader"):              #pragma:nocover
    434                 print "I,J,SName,d",i,j,sname,d
    435              dnp = d + np - 1
    436              #k0 = i + d - 2
    437              ii = i + j + 1
    438              tmp = [ "set", cmd[j], ":=" ]
    439              while ii < Lcmd:
    440                for dd in range(0,d):
    441                  tmp.append(copy.copy(cmd[ii+dd]))
    442                ii += dnp
    443              self._process_set(tmp)
    444              j += 1
    445            if nsets > 0:
    446               j += 1
    447            #
    448            # Process parameters second
    449            #
    450            while j < i:
    451              pname = cmd[j]
    452              if pyomo.debug("reader"):              #pragma:nocover
    453                 print "I,J,Pname",i,j,pname
    454              #d = 1
    455              d = getattr(self._model,pname).dim()
    456              if nsets > 0:
    457                 np = i-1
    458                 dnp = d+np-1
    459                 ii = i + 1
    460                 kk = i + d + j-1
    461              else:
    462                 np = i
    463                 dnp = d + np
    464                 ii = i + 1
    465                 kk = np + 1 + d + nsets + j
    466              tmp = [ "param", pname, ":=" ]
    467              if pyomo.debug("reader"):              #pragma:nocover
    468                 print "dnp",dnp
    469                 print "np",np
    470              while kk < Lcmd:
    471                if pyomo.debug("reader"):                #pragma:nocover
    472                   print "kk,ii",kk,ii
    473                iid = ii + d
    474                while ii < iid:
    475                  tmp.append(copy.copy(cmd[ii]))
    476                  ii += 1
    477                ii += dnp-d
    478                tmp.append(copy.copy(cmd[kk]))
    479                kk += dnp
    480              self._process_param(tmp)
    481              j += 1
    482 
    483 
    484     def _process_data_list(self,dim,cmd):
    485         """
    486         Called by _process_param() to process a list of data for a
    487         Parameter.
    488         """
    489         if pyomo.debug("reader"):               #pragma:nocover
    490            print "process_data_list",dim,cmd
    491         if len(cmd) % (dim+1) != 0:
    492            raise ValueError, "Parameter data has "+str(len(cmd))+" values (" + str(cmd) + "), which is incompatible with having "+str(dim)+" dimensions"           
    493         ans={}
    494         if dim==0:
    495            ans[None]=cmd[0]
    496            return ans
    497         i=0
    498         while i<len(cmd):
    499           ndx = tuple(cmd[i:i+dim])
    500           ##print i,cmd[i:i+dim],ndx,cmd[i+dim]
    501           if cmd[i+dim] != ".":
    502                  ans[ndx] = cmd[i+dim]
    503           i += dim+1
    504         return ans
    505 
    506 
    507     def _data_eval(self, values):
    508         """
    509         Evaluate the list of values to make them bool, integer or float,
    510         or a tuple value.
    511         """
    512         if pyomo.debug("reader"):               #pragma:nocover
    513            print "DEBUG: _data_eval(start)",values
    514         ans = []
    515         for val in values:
    516           if type(val) in (bool,int,float,long):
    517              ans.append(val)
    518              continue
    519           if val in ('True','true','TRUE'):
    520              ans.append(True)
    521              continue
    522           if val in ('False','false','FALSE'):
    523              ans.append(False)
    524              continue
    525           tmp = None
    526           if "(" in val and ")" in val:
    527              vals = []
    528              tval = val[1:-1]
    529              for item in tval.split(","):
    530                tmp=self._data_eval([item])
    531                vals.append(tmp[0])
    532              ans.append(tuple(vals))
    533              continue
    534           try:
    535              tmp = int(val)
    536              ans.append(tmp)
    537           except ValueError:
    538              pass
    539           if tmp is None:
    540              try:
    541                tmp = float(val)
    542                ans.append(tmp)
    543              except ValueError:
    544                ans.append(val)
    545         if pyomo.debug("reader"):               #pragma:nocover
    546            print "DEBUG: _data_eval(end)",ans
    547         return ans
    548 
    549 
    550 
    551 class TableData(object):
    552     """
    553     An object that imports data from a table in an external data source.
    554     The initialization of this object depends on the format specified by the
    555     file:
    556  
    557                 *.tab       Simple ASCII table
    558                 *.xls       Excel spreadsheet
    559                 *.mdb       MSAccess database
    560 
    561     NOTE: it probably makes sense to migrate the table handlers to
    562     external classes, and to enable registration of table handlers.
    563     But for ValueErrornow, this is convenient.
    564     """
    565 
    566     def __init__(self,*args,**kwds):
    567         """
    568         Constructor
    569         """
    570         self._info=None
    571         #
    572         self._reinitialize(kwds)
    573 
    574 
    575     def _reinitialize(self,kwds):
    576         if kwds is None:
    577            return
    578         self._data=None
    579         self._filename=None
    580         self._range=None
    581         self._format=None
    582         self._set=None
    583         self._param=None
    584         self._index=None
    585         for key in kwds:
    586           if key not in ["set","format","index","param","data","filename","range"]:
    587              raise ValueError, "Unknown keyword '"+key+"' when initializing TableData object"
    588           setattr(self,"_"+key,kwds[key])
    589 
    590     def open(self,filename=None):
    591         """
    592         Open the table
    593         """
    594         if filename is not None:
    595            self._filename=filename
    596         if self._filename is None:
    597            raise IOError, "No filename specified"
    598         if not os.path.exists(self._filename):
    599            raise IOError, "Cannot find file: \""+self._filename+"\""
    600         tmp = self._filename.split(".")
    601         if len(tmp) == 1:
    602            raise IOError, "Unknown file type: \""+self._filename+"\""
    603         self._type=tmp[-1]
    604         if self._type == "tab":
    605            self._open_tab()
    606         elif self._type == "xls":
    607            self._open_xls()
    608         elif self._type == "mdb":       #pragma:nocover
    609            self._open_mdb()
    610         else:
    611            raise IOError, "Unknown file type: \""+self._filename+"\""
    612 
    613 
    614     def read(self,range=None, keywords=None):
    615         """
    616         Read data from the table
    617         """
    618         self._reinitialize(keywords)
    619         if range is not None:
    620            self._range=range
    621         if self._type == "tab":
    622            self._read_tab()
    623         elif self._type == "xls":
    624            self._read_xls()
    625         elif self._type == "mdb":       #pragma:nocover
    626            self._read_mdb()
    627 
    628 
    629     def close(self):
    630         """
    631         Close the table
    632         """
    633         if self._type == "tab":
    634            self._close_tab()
    635         elif self._type == "xls":
    636            self._close_xls()
    637         elif self._type == "mdb":
    638            self._close_mdb()            #pragma:nocover
    639 
    640 
    641     def _open_tab(self):
    642         self.INPUT = open(self._filename,"r")
    643 
    644     def _read_tab(self):
    645         tmp=[]
    646         for line in self.INPUT.readlines():
    647           line=line.strip()
    648           tokens = re.split("[\t ]+",line)
    649           if tokens != ['']:
    650              tmp.append(tokens)
    651         if len(tmp) == 0:
    652            raise IOError, "Empty *.tab file"
    653         elif len(tmp) == 1:
    654            self._info = ["param",self._param,":=",tmp[0][0]]
    655         else:
    656            self._set_data(tmp[0], tmp[1:])
    657 
    658     def _close_tab(self):
    659         self.INPUT.close()
    660        
    661 
    662     def _open_xls(self):
    663         self.sheet = None
    664         if self._data is not None:
    665            self.sheet = self._data
    666         else:
    667            try:
    668               self.sheet = ExcelSpreadsheet(self._filename)
    669            except pyutilib.ApplicationError:
    670               raise
    671 
    672     def _read_xls(self):
    673         if self.sheet is None:
    674            return
    675         tmp = self.sheet.get_range(self._range, raw=True)
    676         if type(tmp) in (int,long,float):
    677            self._info = ["param",self._param,":=",tmp]
    678         else:
    679            self._set_data(tmp[0], tmp[1:])
    680 
    681     def _close_xls(self):
    682         if self._data is None and not self.sheet is None:
    683            del self.sheet
    684 
    685 
    686     def _open_mdb(self):
    687         pass                #pragma:nocover
    688 
    689     def _read_mdb(self):
    690         pass                #pragma:nocover
    691 
    692     def _close_mdb(self):
    693         pass                #pragma:nocover
    694 
    695 
    696     def data(self):
    697         return self._info
    698 
    699 
    700     def clear(self):
    701         self._info = None
    702 
    703 
    704     def _set_data(self, headers, rows):
    705         if self._set is not None:
    706            if self._format is None:
    707               self._info = ["set",self._set,":="]
    708               for row in rows:
    709                 self._info = self._info + list(row)
    710            elif self._format is "array":
    711               self._info = ["set",self._set, ":"]
    712               self._info = self._info + list(headers[1:])
    713               self._info = self._info + [":="]
    714               for row in rows:
    715                 self._info = self._info + list(row)
    716            else:
    717               raise ValueError, "Unknown set format: "+self._format
    718 
    719         elif self._index is not None and self._param is None:
    720            self._info = ["param",":",self._index,":"]
    721            self._info = self._info + map(str,list(headers[1:]))
    722            self._info.append(":=")
    723            for row in rows:
    724              self._info = self._info + list(row)
    725 
    726         elif self._index is not None and self._param is not None:
    727            self._info = ["param",":",self._index,":"]
    728            if type(self._param) is str:
    729               self._info = self._info + [self._param]
    730            elif type(self._param) is tuple:
    731               self._info = self._info + list(self._param)
    732            else:
    733               self._info = self._info + self._param
    734            self._info.append(":=")
    735            for row in rows:
    736              self._info = self._info + list(row)
    737 
    738         elif self._param is not None and self._format is not None:
    739            if self._format is "transposed_array":
    740               self._info = ["param",self._param,"(tr)",":"] + map(str,list(headers[1:]))
    741            elif self._format is "array":
    742               self._info = ["param",self._param,":"] + map(str,list(headers[1:]))
    743            else:
    744               raise ValueError, "Unknown parameter format: "+self._format
    745            self._info.append(":=")
    746            for row in rows:
    747              self._info = self._info + list(row)
    748 
    749         else:
    750            if len(headers) == 1:
    751               self._info = ["set",headers[0],":="]
    752               for row in rows:
    753                 self._info = self._info + list(row)
    754            else:
    755               self._info = ["param",":"]
    756               if self._param is None:
    757                  self._info = self._info + map(str,list(headers[1:]))
    758               elif type(self._param) is str:
    759                  self._info = self._info + [self._param]
    760               else:
    761                  self._info = self._info + list(self._param)
    762               self._info.append(":=")
    763               for row in rows:
    764                 self._info = self._info + list(row)
    765 
  • coopr.pyomo/trunk/coopr/pyomo/base/__init__.py

    r1414 r2227  
    1212from numtypes import *
    1313from plugin import *
     14from PyomoModelData import *
    1415#
    1516# Components
     
    2122#
    2223from set_types import *
    23 from PyomoModelData import *
    2424from misc import *
    2525from PyomoModel import *
  • coopr.pyomo/trunk/coopr/pyomo/base/plugin.py

    r2201 r2227  
    1313        'ComponentFactory',
    1414        'IPyomoPresolver', 'IPyomoPresolveAction',
     15        'DataManagerRegistration',
     16        'DataManagerFactory',
    1517        'IModelTransformation',
    1618        'apply_transformation']
     
    130132
    131133
     134class IDataManager(Interface):
     135
     136    def type(self):
     137        """Return the type of the data manager"""
     138
     139    def cls(self):
     140        """Return the class type of this data manager"""
     141
     142    def create(self):
     143        """Create an instance of this data manager"""
     144
     145
     146class DataManagerRegistration(Plugin):
     147
     148    implements(IDataManager)
     149
     150    def __init__(self, type, cls, doc=""):
     151        Plugin.__init__(self, name=type)
     152        self._type = type
     153        self._cls = cls
     154        self.doc=doc
     155
     156    def type(self):
     157        return self._type
     158
     159    def cls(self):
     160        return self._cls
     161
     162    def create(self):
     163        return self._cls()
     164
     165
     166def DataManagerFactory(name=None, args=[]):
     167    ep = ExtensionPoint(IDataManager)
     168    if name is None:
     169        return map(lambda x:x.name, ep())
     170    return ep.service(name).create()
     171
     172
     173
    132174class IModelTransformation(Interface):
    133175
  • coopr.pyomo/trunk/coopr/pyomo/tests/examples/test10.txt

    r2148 r2227  
     1Importing data...
     2Processing data ...
     3Done.
    14Constructing Param, name=N, from data={None: 5}
    25Constructing Param, name=P, from data={None: 3}
     
    4346Construcing constraint num_facilities
    4447   Constructing constraint index None
    45 Writing model unknown to file '/tmp/tmp1NxKh4.pyomo.lp'  with format cpxlp
     48Writing model unknown to file '/tmp/tmpb2g1nA.pyomo.lp'  with format cpxlp
    4649
    4750# ==========================================================
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_modeldata.py

    r1448 r2227  
    172172    def test_md1(self):
    173173        md = ModelData()
    174         md.add_table(example_dir+"A.tab")
     174        md.add(example_dir+"A.tab")
    175175        try:
    176176            md.read()
     
    188188    def test_md2(self):
    189189        md = ModelData()
    190         md.add_data_file(currdir+"data1.dat")
     190        md.add(currdir+"data1.dat")
    191191        model=Model()
    192192        model.A=Set()
     
    195195    def test_md3(self):
    196196        md = ModelData()
    197         md.add_data_file(currdir+"data2.dat")
     197        md.add(currdir+"data2.dat")
    198198        model=Model()
    199199        model.A=Set()
     
    206206    def test_md4(self):
    207207        md = ModelData()
    208         md.add_data_file(currdir+"data3.dat")
     208        md.add(currdir+"data3.dat")
    209209        model=Model()
    210210        model.A=Set()
     
    215215    def test_md5(self):
    216216        md = ModelData()
    217         md.add_data_file(currdir+"data4.dat")
     217        md.add(currdir+"data4.dat")
    218218        model=Model()
    219219        model.A=Set()
     
    225225    def test_md6(self):
    226226        md = ModelData()
    227         md.add_data_file(currdir+"data5.dat")
     227        md.add(currdir+"data5.dat")
    228228        model=Model()
    229229        model.A=Set()
     
    235235    def test_md7(self):
    236236        md = ModelData()
    237         md.add_table(currdir+"data1.tab")
     237        md.add(currdir+"data1.tab")
    238238        model=Model()
    239239        try:
     
    245245    def test_md8(self):
    246246        md = ModelData()
    247         md.add_data_file(currdir+"data6.dat")
     247        md.add(currdir+"data6.dat")
    248248        model=Model()
    249249        model.A=Set()
     
    256256    def test_md9(self):
    257257        md = ModelData()
    258         md.add_data_file(currdir+"data7.dat")
     258        md.add(currdir+"data7.dat")
    259259        model=Model()
    260260        model.A=Set()
     
    264264    def test_md10(self):
    265265        md = ModelData()
    266         md.add_data_file(currdir+"data8.dat")
     266        md.add(currdir+"data8.dat")
    267267        model=Model()
    268268        model.A=Param(within=Boolean)
  • coopr.pyomo/trunk/examples/pyomo/tutorials/table.py

    r909 r2227  
    108108#model.pprint()
    109109
    110 data = ModelData(model)
    111 data.add_table("tab/A.tab")
    112 data.add_table("tab/B.tab")
    113 data.add_table("tab/C.tab", set="C")
    114 data.add_table("tab/D.tab", set="D", format="array")
    115 data.add_table("tab/E.tab", set="E")
    116 data.add_table("tab/I.tab")
    117 data.add_table("tab/Z.tab", param="Z")
    118 data.add_table("tab/Y.tab")
    119 data.add_table("tab/XW.tab")
    120 data.add_table("tab/T.tab", param="T", format="transposed_array")
    121 data.add_table("tab/U.tab", param="U", format="array")
    122 data.add_table("tab/S.tab")
    123 data.add_table("tab/RQ.tab", index="H")
    124 data.add_table("tab/PO.tab", index="J", param=("P","O"))
    125 data.add_table("tab/PP.tab", param="PP")
     110data = ModelData(model=model)
     111data.add("tab/A.tab")
     112data.add("tab/B.tab")
     113data.add("tab/C.tab", set="C")
     114data.add("tab/D.tab", set="D", format="set_array")
     115data.add("tab/E.tab", set="E")
     116data.add("tab/I.tab")
     117data.add("tab/Z.tab", param="Z")
     118data.add("tab/Y.tab")
     119data.add("tab/XW.tab")
     120data.add("tab/T.tab", param="T", format="transposed_array")
     121data.add("tab/U.tab", param="U", format="array")
     122data.add("tab/S.tab")
     123data.add("tab/RQ.tab", index="H")
     124data.add("tab/PO.tab", index="J", param=("P","O"))
     125data.add("tab/PP.tab", param="PP")
    126126data.read()
    127127
Note: See TracChangeset for help on using the changeset viewer.