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()