def _process_load(cmd, _model, _data, _default, options=None):
#print("LOAD %s" % cmd)
from pyomo.core import Set
_cmd_len = len(cmd)
_options = {}
_options['filename'] = cmd[1]
i = 2
while cmd[i] != ':':
_options[cmd[i]] = cmd[i + 2]
i += 3
i += 1
_Index = (None, [])
if type(cmd[i]) is tuple:
_Index = (None, cmd[i])
i += 1
elif i + 1 < _cmd_len and cmd[i + 1] == '=':
_Index = (cmd[i], cmd[i + 2])
i += 3
_smap = OrderedDict()
while i < _cmd_len:
if i + 2 < _cmd_len and cmd[i + 1] == '=':
_smap[cmd[i + 2]] = cmd[i]
i += 3
else:
_smap[cmd[i]] = cmd[i]
i += 1
if len(cmd) < 2:
raise IOError("The 'load' command must specify a filename")
options = Options(**_options)
for key in options:
if not key in [
'range', 'filename', 'format', 'using', 'driver', 'query',
'table', 'user', 'password', 'database'
]:
raise ValueError("Unknown load option '%s'" % key)
global Filename
Filename = options.filename
global Lineno
Lineno = 0
#
# TODO: process mapping info
#
if options.using is None:
tmp = options.filename.split(".")[-1]
data = DataManagerFactory(tmp)
if (data is None) or \
isinstance(data, UnknownDataManager):
raise ApplicationError("Data manager '%s' is not available." % tmp)
else:
try:
data = DataManagerFactory(options.using)
except:
data = None
if (data is None) or \
isinstance(data, UnknownDataManager):
raise ApplicationError("Data manager '%s' is not available." %
options.using)
set_name = None
#
# Create symbol map
#
symb_map = _smap
if len(symb_map) == 0:
raise IOError(
"Must specify at least one set or parameter name that will be loaded"
)
#
# Process index data
#
_index = None
index_name = _Index[0]
_select = None
#
# Set the 'set name' based on the format
#
_set = None
if options.format == 'set' or options.format == 'set_array':
if len(_smap) != 1:
raise IOError(
"A single set name must be specified when using format '%s'" %
options.format)
set_name = list(_smap.keys())[0]
_set = set_name
#
# Set the 'param name' based on the format
#
_param = None
if options.format == 'transposed_array' or options.format == 'array' or options.format == 'param':
if len(_smap) != 1:
raise IOError(
"A single parameter name must be specified when using format '%s'"
% options.format)
if options.format in ('transposed_array', 'array', 'param', None):
if _Index[0] is None:
_index = None
else:
_index = _Index[0]
_param = []
_select = list(_Index[1])
for key in _smap:
_param.append(_smap[key])
_select.append(key)
if options.format in ('transposed_array', 'array'):
_select = None
#print "YYY", _param, options
if not _param is None and len(
_param) == 1 and not _model is None and isinstance(
getattr(_model, _param[0]), Set):
_select = None
_set = _param[0]
_param = None
_index = None
#print "SELECT", _param, _select
#
data.initialize(model=options.model,
filename=options.filename,
index=_index,
index_name=index_name,
param_name=symb_map,
set=_set,
param=_param,
format=options.format,
range=options.range,
query=options.query,
using=options.using,
table=options.table,
select=_select,
user=options.user,
password=options.password,
database=options.database)
#
data.open()
try:
data.read()
except Exception:
data.close()
raise
data.close()
data.process(_model, _data, _default)
def _process_table(cmd, _model, _data, _default, options=None):
#print("TABLE %s" % cmd)
#
_options = {}
_set = OrderedDict()
_param = OrderedDict()
_labels = []
_cmd = cmd[1]
_cmd_len = len(_cmd)
name = None
i = 0
while i < _cmd_len:
try:
#print("CMD i=%s cmd=%s" % (i, _cmd[i:]))
#
# This should not be error prone, so we treat errors
# with a general exception
#
#
# Processing labels
#
if _cmd[i] == ':':
i += 1
while i < _cmd_len:
_labels.append(_cmd[i])
i += 1
continue
#
# Processing options
#
name = _cmd[i]
if i + 1 == _cmd_len:
_param[name] = []
_labels = ['Z']
i += 1
continue
if _cmd[i + 1] == '=':
if type(_cmd[i + 2]) is list:
_set[name] = _cmd[i + 2]
else:
_options[name] = _cmd[i + 2]
i += 3
continue
# This should be a parameter declaration
if not type(_cmd[i + 1]) is tuple:
raise IOError
if i + 2 < _cmd_len and _cmd[i + 2] == '=':
_param[name] = (_cmd[i + 1], _cmd[i + 3][0])
i += 4
else:
_param[name] = _cmd[i + 1]
i += 2
except:
raise IOError("Error parsing table options: %s" % name)
#print("_options %s" % _options)
#print("_set %s" % _set)
#print("_param %s" % _param)
#print("_labels %s" % _labels)
#
options = Options(**_options)
for key in options:
if not key in ['columns']:
raise ValueError("Unknown table option '%s'" % key)
#
ncolumns = options.columns
if ncolumns is None:
ncolumns = len(_labels)
if ncolumns == 0:
if not (len(_set) == 1 and len(_set[_set.keys()[0]]) == 0):
raise IOError(
"Must specify either the 'columns' option or column headers"
)
else:
ncolumns = 1
else:
ncolumns = int(ncolumns)
#
data = cmd[2]
Ldata = len(cmd[2])
#
cmap = {}
if len(_labels) == 0:
for i in range(ncolumns):
cmap[i + 1] = i
for label in _param:
ndx = cmap[_param[label][1]]
if ndx < 0 or ndx >= ncolumns:
raise IOError("Bad column value %s for data %s" %
(str(ndx), label))
cmap[label] = ndx
_param[label] = _param[label][0]
else:
i = 0
for label in _labels:
cmap[label] = i
i += 1
#print("CMAP %s" % cmap)
#
#print("_param %s" % _param)
#print("_set %s" % _set)
for sname in _set:
# Creating set sname
cols = _set[sname]
tmp = []
for col in cols:
if not col in cmap:
raise IOError(
"Unexpected table column '%s' for index set '%s'" %
(col, sname))
tmp.append(cmap[col])
if not sname in cmap:
cmap[sname] = tmp
cols = list(flatten_tuple(tmp))
#
_cmd = ['set', sname, ':=']
i = 0
while i < Ldata:
row = []
#print("COLS %s NCOLS %d" % (cols, ncolumns))
for col in cols:
#print("Y %s %s" % (i, col))
row.append(data[i + col])
if len(row) > 1:
_cmd.append(tuple(row))
else:
_cmd.append(row[0])
i += ncolumns
#print("_data %s" % _data)
_process_set(_cmd, _model, _data)
#
#print("CMAP %s" % cmap)
_i = 0
if ncolumns == 0:
raise IOError
for vname in _param:
_i += 1
# create value vname
cols = _param[vname]
tmp = []
for col in cols:
#print("COL %s" % col)
if not col in cmap:
raise IOError(
"Unexpected table column '%s' for table value '%s'" %
(col, vname))
tmp.append(cmap[col])
#print("X %s %s" % (len(cols), tmp))
cols = list(flatten_tuple(tmp))
#print("X %s" % len(cols))
#print("VNAME %s %s" % (vname, cmap[vname]))
if vname in cmap:
cols.append(cmap[vname])
else:
cols.append(ncolumns - 1 - (len(_param) - _i))
#print("X %s" % len(cols))
#
_cmd = ['param', vname, ':=']
i = 0
while i < Ldata:
#print("HERE %s %s %s" % (i, cols, ncolumns))
for col in cols:
_cmd.append(data[i + col])
i += ncolumns
#print("HERE %s" % _cmd)
#print("_data %s" % _data)
_process_param(_cmd, _model, _data, None, ncolumns=len(cols))