Full renaming (package/module/class)

.github/workflows/build.yml

@@ -167,8 +167,8 @@ jobs:
         run: |
           python -c "
           try:
-            from discrete_optimization.generic_tools.cp_tools import find_right_minizinc_solver_name, CPSolverName
-            find_right_minizinc_solver_name(CPSolverName.CHUFFED)
+            from discrete_optimization.generic_tools.cp_tools import find_right_minizinc_solver_name, CpSolverName
+            find_right_minizinc_solver_name(CpSolverName.CHUFFED)
           except RuntimeError:
             pass
           else:

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,5 @@
 #  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

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
+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/solvers/coloring_cp_solvers.py → discrete_optimization/coloring/solvers/cp_mzn.py

@@ -17,20 +17,20 @@
 import pymzn
 from minizinc import Instance, Model, Solver
 
-from discrete_optimization.coloring.coloring_model import (
+from discrete_optimization.coloring.problem import (
+    ColoringConstraints,
     ColoringProblem,
     ColoringSolution,
-    ConstraintsColoring,
 )
-from discrete_optimization.coloring.coloring_toolbox import compute_cliques
-from discrete_optimization.coloring.solvers.coloring_solver import SolverColoring
-from discrete_optimization.coloring.solvers.greedy_coloring import (
-    GreedyColoring,
-    NXGreedyColoringMethod,
+from discrete_optimization.coloring.solvers import ColoringSolver
+from discrete_optimization.coloring.solvers.greedy import (
+    GreedyColoringSolver,
+    NxGreedyColoringMethod,
 )
+from discrete_optimization.coloring.utils import compute_cliques
 from discrete_optimization.generic_tools.cp_tools import (
-    CPSolverName,
-    MinizincCPSolver,
+    CpSolverName,
+    MinizincCpSolver,
     find_right_minizinc_solver_name,
 )
 from discrete_optimization.generic_tools.do_problem import ParamsObjectiveFunction
@@ -46,25 +46,25 @@
 logger = logging.getLogger(__name__)
 
 
-class ColoringCPModel(Enum):
+class CpColoringModel(Enum):
     CLIQUES = 0
     DEFAULT = 1
     LNS = 2
     DEFAULT_WITH_SUBSET = 3
 
 
 file_dict = {
-    ColoringCPModel.CLIQUES: "coloring_clique.mzn",
-    ColoringCPModel.DEFAULT: "coloring.mzn",
-    ColoringCPModel.LNS: "coloring_for_lns.mzn",
-    ColoringCPModel.DEFAULT_WITH_SUBSET: "coloring_subset_nodes.mzn",
+    CpColoringModel.CLIQUES: "coloring_clique.mzn",
+    CpColoringModel.DEFAULT: "coloring.mzn",
+    CpColoringModel.LNS: "coloring_for_lns.mzn",
+    CpColoringModel.DEFAULT_WITH_SUBSET: "coloring_subset_nodes.mzn",
 }
 
 
-class ColoringCP(MinizincCPSolver, SolverColoring):
-    hyperparameters = MinizincCPSolver.hyperparameters + [
+class CpColoringSolver(MinizincCpSolver, ColoringSolver):
+    hyperparameters = MinizincCpSolver.hyperparameters + [
         EnumHyperparameter(
-            name="cp_model", enum=ColoringCPModel, default=ColoringCPModel.DEFAULT
+            name="cp_model", enum=CpColoringModel, default=CpColoringModel.DEFAULT
         ),
         CategoricalHyperparameter(
             name="include_seq_chain_constraint", choices=[True, False], default=True
@@ -75,7 +75,7 @@ def __init__(
         self,
         problem: ColoringProblem,
         params_objective_function: Optional[ParamsObjectiveFunction] = None,
-        cp_solver_name: CPSolverName = CPSolverName.CHUFFED,
+        cp_solver_name: CpSolverName = CpSolverName.CHUFFED,
         silent_solve_error: bool = False,
         **kwargs: Any,
     ):
@@ -84,7 +84,7 @@ def __init__(
         Args:
             problem (ColoringProblem): coloring problem instance to solve
             params_objective_function (ParamsObjectiveFunction): params of the objective function
-            cp_solver_name (CPSolverName): backend solver to use with minizinc
+            cp_solver_name (CpSolverName): backend solver to use with minizinc
             silent_solve_error: if True, raise a warning instead of an error if the underlying instance.solve() crashes
             **args:
         """
@@ -107,12 +107,12 @@ def init_model(self, **kwargs: Any) -> None:
 
         Keyword Args:
             nb_colors (int): upper bound of number of colors to be considered by the model.
-            object_output (bool): specify if the solution are returned in a ColoringCPSolution object
+            object_output (bool): specify if the solution are returned in a ColoringCpSolution object
                                   or native minizinc output.
             include_seq_chain_constraint (bool) : include the value_precede_chain in the minizinc model.
                         See documentation of minizinc for the specification of this global constraint.
-            cp_model (ColoringCPModel): CP model version.
-            max_cliques (int): if cp_model == ColoringCPModel.CLIQUES, specify the max number of cliques to include
+            cp_model (CpColoringModel): CP model version.
+            max_cliques (int): if cp_model == ColoringCpModel.CLIQUES, specify the max number of cliques to include
                                in the model.
 
 
@@ -128,8 +128,8 @@ def init_model(self, **kwargs: Any) -> None:
             solution: ColoringSolution = self.get_solution(**kwargs)
             nb_colors = self.problem.count_colors_all_index(solution.colors)
         model_type = kwargs["cp_model"]
-        if with_subset_nodes and model_type != ColoringCPModel.DEFAULT_WITH_SUBSET:
-            model_type = ColoringCPModel.DEFAULT_WITH_SUBSET
+        if with_subset_nodes and model_type != CpColoringModel.DEFAULT_WITH_SUBSET:
+            model_type = CpColoringModel.DEFAULT_WITH_SUBSET
         path = os.path.join(path_minizinc, file_dict[model_type])
         model = Model(path)
         solver = Solver.lookup(find_right_minizinc_solver_name(self.cp_solver_name))
@@ -139,13 +139,13 @@ def init_model(self, **kwargs: Any) -> None:
         instance["nb_colors"] = nb_colors
         keys = []
         if model_type in {
-            ColoringCPModel.DEFAULT,
-            ColoringCPModel.CLIQUES,
-            ColoringCPModel.DEFAULT_WITH_SUBSET,
+            CpColoringModel.DEFAULT,
+            CpColoringModel.CLIQUES,
+            CpColoringModel.DEFAULT_WITH_SUBSET,
         }:
             instance["include_seq_chain_constraint"] = include_seq_chain_constraint
             keys += ["include_seq_chain_constraint"]
-        if model_type == ColoringCPModel.DEFAULT_WITH_SUBSET:
+        if model_type == CpColoringModel.DEFAULT_WITH_SUBSET:
             instance["subset_node"] = [
                 node in self.problem.subset_nodes for node in self.problem.nodes_name
             ]
@@ -159,7 +159,7 @@ def init_model(self, **kwargs: Any) -> None:
         g.add_nodes_from([i for i in range(1, self.number_of_nodes + 1)])
         g.add_edges_from(edges)
         self.g = g
-        if model_type == ColoringCPModel.CLIQUES:
+        if model_type == CpColoringModel.CLIQUES:
             cliques, not_all = compute_cliques(g, kwargs.get("max_cliques", 200))
             instance["cliques"] = [set(c) for c in cliques]
             instance["n_cliques"] = len(instance["cliques"])
@@ -219,7 +219,7 @@ def retrieve_solution(
         ]
         return ColoringSolution(self.problem, sol)
 
-    def add_coloring_constraint(self, coloring_constraint: ConstraintsColoring):
+    def add_coloring_constraint(self, coloring_constraint: ColoringConstraints):
         s = []
         for n in coloring_constraint.color_constraint:
             index = self.index_nodes_name[n]
@@ -241,12 +241,12 @@ def get_solution(self, **kwargs: Any) -> ColoringSolution:
         greedy_start = kwargs.get("greedy_start", True)
         if greedy_start:
             logger.info("Computing greedy solution")
-            greedy_solver = GreedyColoring(
+            greedy_solver = GreedyColoringSolver(
                 self.problem,
                 params_objective_function=self.params_objective_function,
             )
             result_store = greedy_solver.solve(
-                strategy=kwargs.get("greedy_method", NXGreedyColoringMethod.best),
+                strategy=kwargs.get("greedy_method", NxGreedyColoringMethod.best),
             )
             solution = result_store.get_best_solution()
             if solution is None: