[WIP] Full renaming (package/module/class)

The goal is to have more consistency in names choices across the
library, between and even within problem type.

discrete_optimization/coloring/coloring_parser.py → discrete_optimization/coloring/parser.py

@@ -6,7 +6,7 @@
 from collections.abc import Hashable
 from typing import Any, Optional
 
-from discrete_optimization.coloring.coloring_model import ColoringProblem
+from discrete_optimization.coloring.problem import ColoringProblem
 from discrete_optimization.datasets import get_data_home
 from discrete_optimization.generic_tools.graph_api import Graph
 
@@ -71,5 +71,5 @@ def parse_file(file_path: str) -> ColoringProblem:
     """
     with open(file_path, "r", encoding="utf-8") as input_data_file:
         input_data = input_data_file.read()
-        coloring_model = parse(input_data)
-        return coloring_model
+        coloring_problem = parse(input_data)
+        return coloring_problem

discrete_optimization/coloring/coloring_plot.py → discrete_optimization/coloring/plot.py

@@ -5,10 +5,7 @@
 import matplotlib.pyplot as plt
 import networkx as nx
 
-from discrete_optimization.coloring.coloring_model import (
-    ColoringProblem,
-    ColoringSolution,
-)
+from discrete_optimization.coloring.problem import ColoringProblem, ColoringSolution
 
 
 def plot_coloring_solution(solution: ColoringSolution, name_figure: str = ""):

discrete_optimization/coloring/coloring_model.py → discrete_optimization/coloring/problem.py

@@ -185,7 +185,7 @@ def transform_color_values_to_value_precede(color_vector: list[int]) -> list[int
     return new_colors_vector
 
 
-class ConstraintsColoring:
+class ColoringConstraints:
     """Data structure to store additional constraints. Attributes will grow
     Attributes:
         color_constraint (dict[Hashable, int]): dictionary filled with color constraint.
@@ -218,7 +218,7 @@ def __init__(
         self,
         graph: Graph,
         subset_nodes: set[Hashable] = None,
-        constraints_coloring: Optional[ConstraintsColoring] = None,
+        constraints_coloring: Optional[ColoringConstraints] = None,
     ):
         self.graph = graph
         self.number_of_nodes = len(self.graph.nodes_infos_dict)
@@ -424,7 +424,7 @@ def evaluate_from_encoding(
 def compute_constraints_penalty(
     coloring_solution: ColoringSolution,
     coloring_problem: ColoringProblem,
-    constraints_coloring: ConstraintsColoring,
+    constraints_coloring: ColoringConstraints,
 ):
     violations = 0
     for n in constraints_coloring.color_constraint:
@@ -439,7 +439,7 @@ def compute_constraints_penalty(
 def transform_coloring_problem(
     coloring_problem: ColoringProblem,
     subset_nodes: Optional[set[Hashable]] = None,
-    constraints_coloring: Optional[ConstraintsColoring] = None,
+    constraints_coloring: Optional[ColoringConstraints] = None,
 ) -> ColoringProblem:
     return ColoringProblem(
         graph=coloring_problem.graph,

discrete_optimization/coloring/solvers/__init__.py

@@ -1,3 +1,14 @@
 #  Copyright (c) 2022 AIRBUS and its affiliates.
 #  This source code is licensed under the MIT license found in the
 #  LICENSE file in the root directory of this source tree.
+
+from .coloring_solver import ColoringSolver
+from .coloring_solvers_map import (
+    look_for_solver,
+    look_for_solver_class,
+    return_solver,
+    solve,
+    solvers,
+    solvers_compatibility,
+    solvers_map,
+)

discrete_optimization/coloring/solvers/coloring_asp_solver.py → discrete_optimization/coloring/solvers/asp.py

@@ -7,20 +7,20 @@
 
 import clingo
 
-from discrete_optimization.coloring.coloring_model import ColoringSolution
-from discrete_optimization.coloring.solvers.coloring_solver_with_starting_solution import (
-    SolverColoringWithStartingSolution,
+from discrete_optimization.coloring.problem import ColoringSolution
+from discrete_optimization.coloring.solvers.starting_solution import (
+    WithStartingSolutionColoringSolver,
 )
 from discrete_optimization.generic_tools.asp_tools import ASPClingoSolver
 
 cur_folder = os.path.abspath(os.path.dirname(__file__))
 logger = logging.getLogger(__name__)
 
 
-class ColoringASPSolver(ASPClingoSolver, SolverColoringWithStartingSolution):
+class ASPColoringSolver(ASPClingoSolver, WithStartingSolutionColoringSolver):
     """Solver based on Answer Set Programming formulation and clingo solver."""
 
-    hyperparameters = SolverColoringWithStartingSolution.hyperparameters
+    hyperparameters = WithStartingSolutionColoringSolver.hyperparameters
 
     def retrieve_solution(self, model: clingo.Model) -> ColoringSolution:
         symbols = model.symbols(atoms=True)

discrete_optimization/coloring/solvers/coloring_solver.py

@@ -2,9 +2,9 @@
 #  This source code is licensed under the MIT license found in the
 #  LICENSE file in the root directory of this source tree.
 
-from discrete_optimization.coloring.coloring_model import ColoringProblem
+from discrete_optimization.coloring.problem import ColoringProblem
 from discrete_optimization.generic_tools.do_solver import SolverDO
 
 
-class SolverColoring(SolverDO):
+class ColoringSolver(SolverDO):
     problem: ColoringProblem

discrete_optimization/coloring/coloring_solvers.py → discrete_optimization/coloring/solvers/coloring_solvers_map.py

@@ -6,20 +6,20 @@
 
 from typing import Any
 
-from discrete_optimization.coloring.solvers.coloring_asp_solver import ColoringASPSolver
-from discrete_optimization.coloring.solvers.coloring_cp_solvers import ColoringCP
-from discrete_optimization.coloring.solvers.coloring_cpsat_solver import (
-    ColoringCPSatSolver,
+from discrete_optimization.coloring.solvers import ColoringSolver
+from discrete_optimization.coloring.solvers.asp import ASPColoringSolver
+from discrete_optimization.coloring.solvers.cp_mzn import CPColoringSolver
+from discrete_optimization.coloring.solvers.cpsat import (
+    CPSatColoringSolver,
     ModelingCPSat,
 )
-from discrete_optimization.coloring.solvers.coloring_lp_solvers import (
-    ColoringLP,
-    ColoringLPMathOpt,
-)
-from discrete_optimization.coloring.solvers.coloring_solver import SolverColoring
-from discrete_optimization.coloring.solvers.greedy_coloring import (
+from discrete_optimization.coloring.solvers.greedy import (
     ColoringProblem,
-    GreedyColoring,
+    GreedyColoringSolver,
+)
+from discrete_optimization.coloring.solvers.lp import (
+    GurobiColoringSolver,
+    MathOptColoringSolver,
 )
 from discrete_optimization.generic_tools.cp_tools import ParametersCP
 from discrete_optimization.generic_tools.do_problem import Problem
@@ -32,36 +32,34 @@
 except:
     toulbar2_available = False
 else:
-    from discrete_optimization.coloring.solvers.coloring_toulbar_solver import (
-        ToulbarColoringSolver,
-    )
+    from discrete_optimization.coloring.solvers.toulbar import ToulbarColoringSolver
 
     toulbar2_available = True
 
 
-solvers: dict[str, list[tuple[type[SolverColoring], dict[str, Any]]]] = {
+solvers: dict[str, list[tuple[type[ColoringSolver], dict[str, Any]]]] = {
     "lp": [
         (
-            ColoringLP,
+            GurobiColoringSolver,
             {},
         ),
         (
-            ColoringLPMathOpt,
+            MathOptColoringSolver,
             {},
         ),
     ],
     "cp": [
         (
-            ColoringCPSatSolver,
+            CPSatColoringSolver,
             {"modeling": ModelingCPSat.BINARY, "parameters_cp": ParametersCP.default()},
         ),
         (
-            ColoringCP,
+            CPColoringSolver,
             {},
         ),
     ],
-    "greedy": [(GreedyColoring, {})],
-    "asp": [(ColoringASPSolver, {"time_limit": 5})],
+    "greedy": [(GreedyColoringSolver, {})],
+    "asp": [(ASPColoringSolver, {"time_limit": 5})],
 }
 if toulbar2_available:
     solvers["toulbar2"] = [(ToulbarColoringSolver, {"time_limit": 5})]
@@ -71,13 +69,13 @@
     for solver, param in solvers[key]:
         solvers_map[solver] = (key, param)
 
-solvers_compatibility: dict[type[SolverColoring], list[type[Problem]]] = {}
+solvers_compatibility: dict[type[ColoringSolver], list[type[Problem]]] = {}
 for x in solvers:
     for y in solvers[x]:
         solvers_compatibility[y[0]] = [ColoringProblem]
 
 
-def look_for_solver(domain: "ColoringProblem") -> list[type[SolverColoring]]:
+def look_for_solver(domain: "ColoringProblem") -> list[type[ColoringSolver]]:
     """Given an instance of ColoringProblem, return a list of class of solvers.
 
 
@@ -92,7 +90,7 @@ def look_for_solver(domain: "ColoringProblem") -> list[type[SolverColoring]]:
 
 def look_for_solver_class(
     class_domain: type[ColoringProblem],
-) -> list[type[SolverColoring]]:
+) -> list[type[ColoringSolver]]:
     """Given a class domain, return a list of class of solvers.
 
 
@@ -109,7 +107,7 @@ def look_for_solver_class(
 
 
 def solve(
-    method: type[SolverColoring], problem: ColoringProblem, **kwargs: Any
+    method: type[ColoringSolver], problem: ColoringProblem, **kwargs: Any
 ) -> ResultStorage:
     """Solve a coloring instance with a given class of solver.
 
@@ -130,8 +128,8 @@ def solve(
 
 
 def return_solver(
-    method: type[SolverColoring], problem: ColoringProblem, **kwargs: Any
-) -> SolverColoring:
+    method: type[ColoringSolver], problem: ColoringProblem, **kwargs: Any
+) -> ColoringSolver:
     """Return the solver initialized with the coloring problem instance
 
     Args: