Question: How to Free Up Gurobi License for Sequential MIP Solves in PuLP?

[jpruente92]

I am using PuLP to solve multiple MIP problems sequentially (not in parallel) on a server that has only one Gurobi license using a token server. The issue I am encountering is that when I try to solve the second problem, PuLP defaults to using CBC instead of Gurobi. I suspect this happens because the Gurobi license is still blocked by the first solver instance, even though I have deleted the solver and run the garbage collector.

Is there a way to properly release the Gurobi license after each solve in PuLP? Or is there a functionality similar to Gurobi's context manager in their Python API, like:

with gp.Env() as env:
    with gp.Model(env=env) as model1:
         ...

Any help or guidance on how to ensure the Gurobi license is freed up between solves would be greatly appreciated. Thank you!

[pchtsp]

Not sure if this answers your question but the GUROBI solver has an env, envOptions and manageEnv arguments . See:
https://coin-or.github.io/pulp/technical/solvers.html#pulp.apis.GUROBI
I'm not sure why the documentation doesn't show all the arguments.
if you check the source code there are instructions:
(

pulp/pulp/apis/gurobi_api.py

Line 68 in 7286f40

def __init__(

)

        If ``manageEnv`` is set to True, the ``GUROBI`` object creates a
        local Gurobi environment and manages all associated Gurobi
        resources. Importantly, this enables Gurobi licenses to be freed
        and connections terminated when the ``.close()`` function is called
        (this function always disposes of the Gurobi model, and the
        environment)::

            solver = GUROBI(manageEnv=True)
            prob.solve(solver)
            solver.close() # Must be called to free Gurobi resources.
            # All Gurobi models and environments are freed

        ``manageEnv=True`` is required when setting license or connection
        parameters. The ``envOptions`` argument is used to pass parameters
        to the Gurobi environment. For example, to connect to a Gurobi
        Cluster Manager::

            options = {
                "CSManager": "<url>",
                "CSAPIAccessID": "<access-id>",
                "CSAPISecret": "<api-key>",
            }
            solver = GUROBI(manageEnv=True, envOptions=options)
            solver.close()
            # Compute server connection terminated

        Alternatively, one can also pass a ``gp.Env`` object. In this case,
        to be safe, one should still call ``.close()`` to dispose of the
        model::

            with gp.Env(params=options) as env:
                # Pass environment as a parameter
                solver = GUROBI(env=env)
                prob.solve(solver)
                solver.close()
                # Still call `close` as this disposes the model which is required to correctly free env

        If ``manageEnv`` is set to False (the default), the ``GUROBI``
        object uses the global default Gurobi environment which will be
        freed once the object is deleted. In this case, one can still call
        ``.close()`` to dispose of the model::

            solver = GUROBI()
            prob.solve(solver)
            # The global default environment and model remain active
            solver.close()
            # Only the global default environment remains active

[jpruente92]

Hi,
this is exactly what I was looking for. Thank you!