Sourcery refactored master branch

benchmark/scripts/benchmark_ortools.py

@@ -44,11 +44,7 @@ def knapsack_model(n, solver):
     weight = randint(1, 100, size=n)
     value = randint(1, 100, size=n)
 
-    # Create variables
-    x = {}
-    for i in range(n):
-        x[i] = solver.BoolVar("x_%d" % i)
-
+    x = {i: solver.BoolVar("x_%d" % i) for i in range(n)}
     # Create constraints
     solver.Add(solver.Sum([weight[i] * x[i] for i in range(n)]) <= 200)
 

benchmark/scripts/merge-benchmarks.py

@@ -6,6 +6,7 @@
 @author: fabian
 """
 
+
 from pathlib import Path
 
 import pandas as pd
@@ -24,7 +25,7 @@
 solver_time = df.loc[df.API == "Solving Process", "Time"].values
 
 # Make a correction of the memory usage, some APIs use external processes for the solving process
-api_with_external_process = set(["pyomo"])
+api_with_external_process = {"pyomo"}
 api_with_internal_process = set(snakemake.params.apis).difference(
     api_with_external_process
 )

doc/conf.py

@@ -23,13 +23,7 @@
 
 # The full version, including alpha/beta/rc tags
 version = pkg_resources.get_distribution("linopy").version
-if "dev" in version:
-    # remove the dev description and reduce by minor one release
-    release = "master"
-else:
-    release = version
-
-
+release = "master" if "dev" in version else version
 # -- General configuration ---------------------------------------------------
 
 # Add any Sphinx extension module names here, as strings. They can be

linopy/solvers.py

@@ -4,6 +4,7 @@
 Linopy module for solving lp files with different solvers.
 """
 
+
 import contextlib
 import io
 import logging
@@ -30,41 +31,29 @@
 which = "where" if os.name == "nt" else "which"
 
 # the first available solver will be the default solver
-try:
+with contextlib.suppress(ImportError):
     import gurobipy
 
     available_solvers.append("gurobi")
-except (ModuleNotFoundError, ImportError):
-    pass
-
-try:
+with contextlib.suppress(ImportError):
     import highspy
 
     available_solvers.append("highs")
-except (ModuleNotFoundError, ImportError):
-    pass
-
 if sub.run([which, "glpsol"], stdout=sub.DEVNULL, stderr=sub.STDOUT).returncode == 0:
     available_solvers.append("glpk")
 
 
 if sub.run([which, "cbc"], stdout=sub.DEVNULL, stderr=sub.STDOUT).returncode == 0:
     available_solvers.append("cbc")
 
-try:
+with contextlib.suppress(ImportError):
     import cplex
 
     available_solvers.append("cplex")
-except (ModuleNotFoundError, ImportError):
-    pass
-
-try:
+with contextlib.suppress(ImportError):
     import xpress
 
     available_solvers.append("xpress")
-except (ModuleNotFoundError, ImportError):
-    pass
-
 logger = logging.getLogger(__name__)
 
 
@@ -80,11 +69,9 @@ def safe_get_solution(status, func):
     if status.is_ok:
         return func()
     elif status.status == SolverStatus.unknown:
-        try:
+        with contextlib.suppress(Exception):
             logger.warning("Solution status unknown. Trying to parse solution.")
             return func()
-        except Exception:
-            pass
     return Solution()
 
 
@@ -271,7 +258,7 @@ def run_glpk(
     def read_until_break(f):
         while True:
             line = f.readline()
-            if line == "\n" or line == "":
+            if line in ["\n", ""]:
                 break
             yield line
 
@@ -462,11 +449,8 @@ def run_cplex(
 
     is_lp = m.problem_type[m.get_problem_type()] == "LP"
 
-    try:
+    with contextlib.suppress(cplex.exceptions.errors.CplexSolverError):
         m.solve()
-    except cplex.exceptions.errors.CplexSolverError as e:
-        pass
-
     condition = m.solution.get_status_string()
     termination_condition = CONDITION_MAP.get(condition, condition)
     status = Status.from_termination_condition(termination_condition)

test/test_constraint.py

@@ -166,10 +166,7 @@ def test_anonymous_constraint_sel(x, y):
 
 def test_constraint_from_rule(m, x, y):
     def bound(m, i, j):
-        if i % 2:
-            return (i - 1) * x[i - 1] + y[j] >= 0
-        else:
-            return i * x[i] >= 0
+        return (i - 1) * x[i - 1] + y[j] >= 0 if i % 2 else i * x[i] >= 0
 
     coords = [x.coords["first"], y.coords["second"]]
     con = Constraint.from_rule(m, bound, coords)

test/test_linear_expression.py

@@ -207,10 +207,7 @@ def test_linear_expression_with_errors(m, x):
 
 def test_linear_expression_from_rule(m, x, y):
     def bound(m, i):
-        if i == 1:
-            return (i - 1) * x[i - 1] + y[i] + 1 * x[i]
-        else:
-            return i * x[i] - y[i]
+        return (i - 1) * x[i - 1] + y[i] + 1 * x[i] if i == 1 else i * x[i] - y[i]
 
     expr = LinearExpression.from_rule(m, bound, x.coords)
     assert isinstance(expr, LinearExpression)

test/test_repr.py

@@ -83,13 +83,13 @@ def test_variable_repr():
 
 def test_scalar_variable_repr():
     for var in [u, v, x, y, z, a, b, c, d]:
-        coord = tuple([var.indexes[c][0] for c in var.dims])
+        coord = tuple(var.indexes[c][0] for c in var.dims)
         repr(var[coord])
 
 
 def test_single_variable_repr():
     for var in [u, v, x, y, z, a, b, c, d]:
-        coord = tuple([var.indexes[c][0] for c in var.dims])
+        coord = tuple(var.indexes[c][0] for c in var.dims)
         repr(var.loc[coord])
 
 
@@ -104,13 +104,13 @@ def test_linear_expression_long():
 
 def test_scalar_linear_expression_repr():
     for var in [u, v, x, y, z, a, b, c, d]:
-        coord = tuple([var.indexes[c][0] for c in var.dims])
+        coord = tuple(var.indexes[c][0] for c in var.dims)
         repr(1 * var[coord])
 
 
 def test_single_linear_repr():
     for var in [u, v, x, y, z, a, b, c, d]:
-        coord = tuple([var.indexes[c][0] for c in var.dims])
+        coord = tuple(var.indexes[c][0] for c in var.dims)
         repr(1 * var.loc[coord])
 
 
@@ -120,13 +120,13 @@ def test_anonymous_constraint_repr():
 
 
 def test_scalar_constraint_repr():
-    repr(1 * u[0, 0] >= 0)
+    repr(u[0, 0] >= 0)
 
 
 def test_single_constraint_repr():
     for var in [u, v, x, y, z, a, b, c, d]:
-        coord = tuple([var.indexes[c][0] for c in var.dims])
-        repr(1 * var.loc[coord] == 0)
+        coord = tuple(var.indexes[c][0] for c in var.dims)
+        repr(var.loc[coord] == 0)
         repr(1 * var.loc[coord] - var.loc[coord] == 0)
 
 

test/test_variable.py

@@ -70,7 +70,7 @@ def test_variable_getter(x, z):
         x[0, 0]
 
     with pytest.raises(AssertionError):
-        x[0:5]
+        x[:5]
 
     with pytest.raises(AssertionError):
         x[[1, 2, 3]]