Example #1
0
    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]
Example #2
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:
            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
Example #3
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:
            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
Example #4
0
    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]
Example #5
0
 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])
Example #6
0
 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])
Example #7
0
 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])
Example #8
0
File: GLPK.py Project: Pyomo/pyomo
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)
Example #9
0
File: GLPK.py Project: smars8/pyomo
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)
Example #10
0
 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)
Example #11
0
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)
Example #12
0
    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)
Example #13
0
 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])
Example #14
0
 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])
Example #15
0
 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
Example #16
0
    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)
Example #17
0
File: BARON.py Project: Pyomo/pyomo
    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)
Example #18
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 = 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)
Example #19
0
 def _get_version(self):
     """
     Returns a tuple describing the solver executable version.
     """
     if _glpk_version is None:
         return _extract_version('')
     return _glpk_version
Example #20
0
    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)
Example #21
0
 def _get_version(self):
     """
     Returns a tuple describing the solver executable version.
     """
     if _cbc_version is None:
         return _extract_version('')
     return _cbc_version
Example #22
0
 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])
Example #23
0
 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
Example #24
0
 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
Example #25
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 = 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
Example #26
0
    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)
Example #27
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,58,0,0)
Example #28
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)
Example #29
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
Example #30
0
 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
Example #31
0
    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]
Example #32
0
    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]
Example #33
0
 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)
Example #34
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)
Example #35
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)
Example #36
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)
Example #37
0
 def _get_version(self):
     """
     Returns a tuple describing the solver executable version.
     """
     return _extract_version('')
Example #38
0
 def version(self):
     return _extract_version('')
Example #39
0
 def _get_version(self):
     if _gurobi_version is None:
         return _extract_version('')
     return _gurobi_version
Example #40
0
 def version(self):
     return _extract_version('')
Example #41
0
 def _get_version(self):
     """
     Returns a tuple describing the solver executable version.
     """
     return _extract_version('')
Example #42
0
 def _get_version(self):
     if _gurobi_version is None:
         return _extract_version('')
     return _gurobi_version