def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version("") outname = pyutilib.services.TempfileManager.create_tempfile(suffix=".gurobi.version") with open(outname, "w") as f: # **Note, adding a 'timelimit' keyword here results in empty output for some reason results = pyutilib.subprocess.run( [solver_exec], stdin=("from gurobipy import *; " "print(gurobi.version()); exit()"), ostream=f ) tmp = None try: with open(outname, "r") as f: tmp = tuple(eval(f.read().strip())) while len(tmp) < 4: tmp += (0,) except SyntaxError: tmp = None if tmp is None: return _extract_version("") return tmp[:4]
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if (solver_exec, 'version') in self._solver_info_cache: return self._solver_info_cache[(solver_exec, 'version')] if solver_exec is None: ver = _extract_version('') else: results = subprocess.run( [solver_exec], input=('import gurobipy; ' 'print(gurobipy.gurobi.version()); quit()'), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, ) ver = None try: ver = tuple(eval(results.stdout.strip())) while (len(ver) < 4): ver += (0, ) except SyntaxError: ver = _extract_version('') if ver is not None: ver = ver[:4] self._solver_info_cache[(solver_exec, 'version')] = ver return ver
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if (solver_exec, 'version') in self._solver_info_cache: return self._solver_info_cache[(solver_exec, 'version')] if solver_exec is None: ver = _extract_version('') else: f = StringIO() results = run([solver_exec], stdin=('from gurobipy import *; ' 'print(gurobi.version()); exit()'), ostream=f) ver = None try: ver = tuple(eval(f.getvalue().strip())) while (len(ver) < 4): ver += (0, ) except SyntaxError: ver = _extract_version('') ver = ver[:4] self._solver_info_cache[(solver_exec, 'version')] = ver return ver
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') outname = pyutilib.services.TempfileManager.create_tempfile( suffix='.gurobi.version') with open(outname, 'w') as f: # **Note, adding a 'timelimit' keyword here results in empty output for some reason results = pyutilib.subprocess.run( [solver_exec], stdin=('from gurobipy import *; ' 'print(gurobi.version()); exit()'), ostream=f) tmp = None try: with open(outname, 'r') as f: tmp = tuple(eval(f.read().strip())) while (len(tmp) < 4): tmp += (0, ) except SyntaxError: tmp = None if tmp is None: return _extract_version('') return tmp[:4]
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = pyutilib.subprocess.run( [solver_exec], timelimit=1 ) return _extract_version(results[1])
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = pyutilib.subprocess.run([solver_exec, "-v"], timelimit=1) return _extract_version(results[1])
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = run([solver_exec, '-c', 'quit'], timelimit=1) return _extract_version(results[1])
def configure_glpk(): global _glpk_version if _glpk_version is not None: return _glpk_version = _extract_version("") if not Executable("glpsol"): return errcode, results = pyutilib.subprocess.run( [Executable('glpsol').path(), "--version"], timelimit=2) if errcode == 0: _glpk_version = _extract_version(results)
def configure_glpk(): global _glpk_version if _glpk_version is not None: return _glpk_version = _extract_version("") if registered_executable("glpsol") is None: return errcode, results = pyutilib.subprocess.run( [registered_executable('glpsol').get_path(), "--version"], timelimit=2) if errcode == 0: _glpk_version = _extract_version(results)
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = subprocess.run( [solver_exec], timeout=1, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) return _extract_version(results.stdout)
def configure_glpk(): global _glpk_version if _glpk_version is not None: return _glpk_version = _extract_version("") if not Executable("glpsol"): return result = subprocess.run([Executable('glpsol').path(), "--version"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=1, universal_newlines=True) if not result.returncode: _glpk_version = _extract_version(result.stdout)
def _get_version(self): """Returns a tuple describing the solver executable version.""" solver_exec = self.executable() if solver_exec is None: return _extract_version('') else: # specify logging to stdout for windows compatibility # technically this command makes gams complain because we're not # providing a filename, but it will include the version name anyway cmd = [solver_exec, "", "lo=3"] _, txt = pyutilib.subprocess.run(cmd, tee=False) return _extract_version(txt)
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = pyutilib.subprocess.run([solver_exec, "--version"], timelimit=1) # 'PICO --version' seems to print 'pebble <version>, PICO <version> # we don't wan't the pebble version being advertised so we split # the string at the comma before extracting a version number. It # also exits with a nonzero return code so don't bother checking it. return _extract_version(results[1].split(',')[1])
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = run([solver_exec, "--version"], timelimit=1) # 'PICO --version' seems to print 'pebble <version>, PICO <version> # we don't wan't the pebble version being advertised so we split # the string at the comma before extracting a version number. It # also exits with a nonzero return code so don't bother checking it. return _extract_version(results[1].split(',')[1])
def _get_version(self): """ Returns a tuple describing the solver executable version. """ results = subprocess.run([self.executable(), "-stop"], timeout=5, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) _version = _extract_version(results.stdout) if _version is None: return _extract_version('') return _version
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') else: fnames = self._get_dummy_input_files(check_license=False) try: results = pyutilib.subprocess.run([solver_exec, fnames[0]]) return _extract_version(results[1]) finally: self._remove_dummy_input_files(fnames)
def configure_cbc(): global _cbc_compiled_with_asl global _cbc_version global _cbc_old_version if _cbc_compiled_with_asl is not None: return # manually look for the cbc executable to prevent the # CBC.execute() from logging an error when CBC is missing executable = Executable("cbc") if not executable: return cbc_exec = executable.path() results = subprocess.run([cbc_exec, "-stop"], timeout=1, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) _cbc_version = _extract_version(results.stdout) results = subprocess.run([cbc_exec, "dummy", "-AMPL", "-stop"], timeout=1, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) _cbc_compiled_with_asl = not ('No match for AMPL' in results.stdout) if _cbc_version is not None: _cbc_old_version = _cbc_version < (2, 7, 0, 0)
def _get_version(self): """ Returns a tuple describing the solver executable version. """ if _glpk_version is None: return _extract_version('') return _glpk_version
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') else: dummy_prob_file = tempfile.NamedTemporaryFile(mode='w') dummy_prob_file.write("//This is a dummy .bar file created to " "return the baron version//\nPOSITIVE_VARIABLES " "x1;\nOBJ: minimize x1;") dummy_prob_file.seek(0) results = pyutilib.subprocess.run( [solver_exec,dummy_prob_file.name]) return _extract_version(results[1],length=3)
def _get_version(self): """ Returns a tuple describing the solver executable version. """ if _cbc_version is None: return _extract_version('') return _cbc_version
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = subprocess.run([solver_exec, "--version"], timeout=1, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) # 'PICO --version' seems to print 'pebble <version>, PICO <version> # we don't wan't the pebble version being advertised so we split # the string at the comma before extracting a version number. It # also exits with a nonzero return code so don't bother checking it. return _extract_version(results.stdout.split(',')[1])
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') try: results = subprocess.run([solver_exec, "-v"], timeout=2, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) return _extract_version(results.stdout) except OSError: pass except subprocess.TimeoutExpired: pass
def _get_version(self): """Returns a tuple describing the solver executable version.""" if not self.available(exception_flag=False): return _extract_version('') from gams import GamsWorkspace ws = GamsWorkspace() version = tuple(int(i) for i in ws._version.split('.')[:4]) while (len(version) < 4): version += (0, ) return version
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if (solver_exec, 'version') in self._solver_info_cache: return self._solver_info_cache[(solver_exec, 'version')] if solver_exec is None: ver = _extract_version('') else: fnames = self._get_dummy_input_files(check_license=False) try: results = run([solver_exec, fnames[0]]) ver = _extract_version(results[1]) finally: self._remove_dummy_input_files(fnames) self._solver_info_cache[(solver_exec, 'version')] = ver return ver
def _get_version(self): """ Returns a tuple describing the solver executable version. """ # The subprocess below can sometimes time out if we're low on resources. This gives us a much # cheaper way of getting the version version_from_env = _extract_version(os.environ.get( 'CPLEX_VERSION', '')) if version_from_env: return version_from_env solver_exec = self.executable() if solver_exec is None: return _extract_version('') results = subprocess.run([solver_exec, '-c', 'quit'], timeout=1, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) return _extract_version(results.stdout)
def configure_glpk(): global glpk_file_flag global _glpk_version if glpk_file_flag is not None: return glpk_file_flag = False if registered_executable("glpsol") is None: return errcode, results = pyutilib.subprocess.run( [registered_executable('glpsol').get_path(), "--version"], timelimit=2) if errcode == 0: _glpk_version = _extract_version(results) glpk_file_flag = _glpk_version >= (4,58,0,0)
def configure_glpk(): global glpk_file_flag global _glpk_version if glpk_file_flag is not None: return glpk_file_flag = False if registered_executable("glpsol") is None: return errcode, results = pyutilib.subprocess.run( [registered_executable('glpsol').get_path(), "--version"], timelimit=2) if errcode == 0: _glpk_version = _extract_version(results) glpk_file_flag = _glpk_version >= (4,42,0,0)
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if (solver_exec, 'version') in self._solver_info_cache: return self._solver_info_cache[(solver_exec, 'version')] if solver_exec is None: ver = _extract_version('') else: fnames = self._get_dummy_input_files(check_license=False) try: results = subprocess.run([solver_exec, fnames[0]], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) ver = _extract_version(results.stdout) finally: self._remove_dummy_input_files(fnames) self._solver_info_cache[(solver_exec, 'version')] = ver return ver
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') try: results = subprocess.run([solver_exec, "-v"], timeout=5, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) ver = _extract_version(results.stdout) if ver is None: # Some ASL solvers do not export a version number if results.stdout.strip().split()[-1].startswith('ASL('): return '0.0.0' return ver except OSError: pass except subprocess.TimeoutExpired: pass
def _get_version(self): """ Returns a tuple describing the solver executable version. """ solver_exec = self.executable() if solver_exec is None: return _extract_version('') f = StringIO() results = pyutilib.subprocess.run([solver_exec], stdin=('from gurobipy import *; ' 'print(gurobi.version()); exit()'), ostream=f) tmp = None try: tmp = tuple(eval(f.getvalue().strip())) while(len(tmp) < 4): tmp += (0,) except SyntaxError: tmp = None if tmp is None: return _extract_version('') return tmp[:4]
def _get_version(self, executable=None): """ Returns a tuple describing the solver executable version. """ if executable is None: executable = self.executable() result = subprocess.run( [executable, "--version"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=1, universal_newlines=True, ) return _extract_version(result.stdout)
def configure_cbc(): global _cbc_compiled_with_asl global _cbc_version global _cbc_old_version if _cbc_compiled_with_asl is not None: return # manually look for the cbc executable to prevent the # CBC.execute() from logging an error when CBC is missing if pyutilib.services.registered_executable("cbc") is None: return cbc_exec = pyutilib.services.registered_executable("cbc").get_path() results = pyutilib.subprocess.run([cbc_exec, "-stop"], timelimit=1) _cbc_version = _extract_version(results[1]) results = pyutilib.subprocess.run([cbc_exec, "dummy", "-AMPL", "-stop"], timelimit=1) _cbc_compiled_with_asl = not ('No match for AMPL' in results[1]) if _cbc_version is not None: _cbc_old_version = _cbc_version < (2, 7, 0, 0)
def configure_cbc(): global _cbc_compiled_with_asl global _cbc_version global _cbc_old_version if _cbc_compiled_with_asl is not None: return # manually look for the cbc executable to prevent the # CBC.execute() from logging an error when CBC is missing if pyutilib.services.registered_executable("cbc") is None: return cbc_exec = pyutilib.services.registered_executable("cbc").get_path() results = pyutilib.subprocess.run( [cbc_exec,"-stop"], timelimit=1 ) _cbc_version = _extract_version(results[1]) results = pyutilib.subprocess.run( [cbc_exec,"dummy","-AMPL","-stop"], timelimit=1 ) _cbc_compiled_with_asl = not ('No match for AMPL' in results[1]) if _cbc_version is not None: _cbc_old_version = _cbc_version < (2,7,0,0)
def configure_cbc(): global _cbc_compiled_with_asl global _cbc_version global _cbc_old_version if _cbc_compiled_with_asl is not None: return # manually look for the cbc executable to prevent the # CBC.execute() from logging an error when CBC is missing executable = Executable("cbc") if not executable: return cbc_exec = executable.path() results = run([cbc_exec, "-stop"], timelimit=1) _cbc_version = _extract_version(results[1]) results = run([cbc_exec, "dummy", "-AMPL", "-stop"], timelimit=1) _cbc_compiled_with_asl = not ('No match for AMPL' in results[1]) if _cbc_version is not None: _cbc_old_version = _cbc_version < (2, 7, 0, 0)
def _get_version(self): """ Returns a tuple describing the solver executable version. """ return _extract_version('')
def version(self): return _extract_version('')
def _get_version(self): if _gurobi_version is None: return _extract_version('') return _gurobi_version