def get_cplex_version(context):
'''Submits a minimal job on DOCplexcloud and get the CPLEX version from
logs
Args:
context: The context to use to connect
Returns:
A tuple (major, minor, micro), for instance (12, 7, 1)
'''
import re
from docplex.mp.compat23 import StringIO
from docplex.mp.model import Model
logs = StringIO()
model = Model()
model.solve(url=context.solver.docloud.url,
key=context.solver.docloud.key,
log_output=logs)
v = re.search(
'CPLEX version ([0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])',
logs.getvalue())
try:
major = int(v.group(1))
minor = int(v.group(2))
micro = int(v.group(3))
return (major, minor, micro)
except IndexError:
raise RuntimeError('Could not find CPLEX version in resulting logs')
except:
raise ValueError('Could not determine version from %s' % v.group(0))
def _serialize_conflict_refiner(self, artifact_as_xml):
if sys.version_info[0] < 3:
oss = StringIO()
else:
oss = BytesIO()
ConflictRefinerPrinter.print_to_stream(artifact_as_xml, out=oss)
serialized_artifact = oss.getvalue()
return serialized_artifact
def print_to_string(cls, solutions, write_level=WriteLevel.Auto, **kwargs):
from docplex.mp.compat23 import StringIO
oss = StringIO()
cls.print_to_stream(solutions,
out=oss,
write_level=write_level,
**kwargs)
return oss.getvalue()
def serialize_model(self, mdl):
# step 1 : prints the model in whatever exchange format
printer = self._new_printer(ctx=mdl.context)
if self._exchange_format.is_binary:
filemode = "wb"
oss = BytesIO()
else:
filemode = "w"
oss = StringIO()
printer.printModel(mdl, oss)
# lp name to docplex var
self._lpname_to_var_map = printer.get_name_to_var_map(mdl)
# DEBUG: dump request file
if self.debug_dump:
dump_path = make_path(error_handler=mdl.error_handler,
basename=mdl.name,
output_dir=self.debug_dump_dir,
extension=printer.extension(),
name_transformer="docloud_%s")
print("DEBUG DUMP in " + dump_path)
with open(dump_path, filemode) as out_file:
out_file.write(oss.getvalue())
if self._exchange_format.is_binary:
model_data = oss.getvalue()
else:
model_data = oss.getvalue().encode('utf-8')
return model_data
def print_info_to_string(self, overload_params=None, print_defaults=False):
""" Writes parameters in readable format to a string.
The logic of overload is the same as in :func:`export_prm`.
A parameter is written if either it is a key on `overload_params`,
or it has a non-default value.
This allows merging non-default params with temporary parameter values.
Args:
overload_params: A dictionary of overloaded values, possibly None.
Note:
This method has no side effects on the parameters.
Returns:
A string.
"""
oss = StringIO()
self.print_info_to_stream(oss, print_defaults=print_defaults, overload_params=overload_params)
return oss.getvalue()
def export_prm_to_string(self, overload_params=None):
""" Exports non-default parameters in PRM format to a string.
The logic of overload is the same as in :func:`export_prm`.
A parameter is written if either it is a key on `overload_params`,
or it has a non-default value.
This allows merging non-default parameters with temporary parameter values.
Args:
overload_params: A dictionary of overloaded values, possibly None.
Note:
This method has no side effects on the parameters.
Returns:
string: A string in CPLEX PRM format.
"""
oss = StringIO()
self.export_prm(oss, overload_params)
return oss.getvalue()
def print_to_string(cls, mdl):
oss = StringIO()
cls.print_to_stream(mdl, out=oss)
return oss.getvalue()
def export_as_string(self, format="json", **kwargs):
oss = StringIO()
self.export(oss, format=format, **kwargs)
return oss.getvalue()
def to_string(self, print_zeros=True):
oss = StringIO()
self.to_stringio(oss, print_zeros=print_zeros)
return oss.getvalue()
def print_to_string(cls, solutions, indent=None):
oss = StringIO()
cls.print_to_stream(solutions, out=oss, indent=indent)
return oss.getvalue()
def _serialize_relaxables(self, relaxables):
oss = StringIO()
FeasibilityPrinter.print_to_stream(out=oss, relaxables=relaxables)
serialized_relaxables = oss.getvalue()
return serialized_relaxables
def _export_as_string(self, fmt, **kwargs):
oss = StringIO()
printer = self.get_printer(fmt)
printer.print_to_stream(self, oss, **kwargs)
return oss.getvalue()
def to_string(self):
oss = StringIO()
oss.write("status = {0}\n".format(self._solve_status))
oss.write("time = {0:g} s.\n".format(self._time))
oss.write("problem = {0}\n".format(self._problem_type))
if self._miprelgap >= 0:
oss.write("gap = {0:g}%\n".format(100.0 * self._miprelgap))
return oss.getvalue()
def print_to_string(cls, solutions):
oss = StringIO()
cls.print_to_stream(solutions, out=oss)
return oss.getvalue()
def to_string(self):
oss = StringIO()
oss.write(" - number of variables: %d\n" % self.number_of_variables)
var_fmt = ' - binary={0}, integer={1}, continuous={2}'
if self._number_of_semicontinuous_variables:
var_fmt += ', semi-continuous={3}'
oss.write(
var_fmt.format(self.number_of_binary_variables,
self.number_of_integer_variables,
self.number_of_continuous_variables,
self._number_of_semicontinuous_variables))
oss.write('\n')
nb_constraints = self.number_of_constraints
oss.write(' - number of constraints: {0}\n'.format(nb_constraints))
if nb_constraints:
ct_fmt = ' - linear={0}'
if self._number_of_indicator_constraints:
ct_fmt += ', indicator={1}'
if self._number_of_equivalence_constraints:
ct_fmt += ', equiv={2}'
if self._number_of_quadratic_constraints:
ct_fmt += ', quadratic={3}'
oss.write(
ct_fmt.format(self.number_of_linear_constraints,
self.number_of_indicator_constraints,
self.number_of_equivalence_constraints,
self.number_of_quadratic_constraints))
return oss.getvalue()
