c2cgeoportal-geoportal 2.6.0__py2.py3-none-any.whl → 2.8.1.180__py2.py3-none-any.whl

c2cgeoportal_geoportal/scripts/c2cupgrade.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2014-2021, Camptocamp SA
+# Copyright (c) 2014-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -36,15 +34,16 @@ import re
 import shutil
 import subprocess
 import sys
-from argparse import ArgumentParser
+from argparse import ArgumentParser, Namespace
+from json.decoder import JSONDecodeError
 from subprocess import call, check_call, check_output
-from typing import Any, Dict, cast
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
 import pkg_resources
 import requests
 import yaml
 
-from c2cgeoportal_geoportal.lib.bashcolor import GREEN, RED, YELLOW, colorize
+from c2cgeoportal_geoportal.lib.bashcolor import Color, colorize
 
 REQUIRED_TEMPLATE_KEYS = ["package", "srid", "extent"]
 TEMPLATE_EXAMPLE = {"package": "${package}", "srid": "${srid}", "extent": "489246, 78873, 837119, 296543"}
@@ -59,11 +58,44 @@ DIFF_NOTICE = (
 )
 
 
-def main():
-    """
-    tool used to do the application upgrade
-    """
+def fix_style() -> None:
+    """Fix the style of all the project files using isort, Black and Prettier."""
+
+    file_to_clean = []
+    for filename, content in (
+        (".prettierignore", "*.min.js\n"),
+        ("pyproject.toml", "[tool.black]\nline-length = 110\ntarget-version = ['py38']\n"),
+        (".prettierrc.yaml", "bracketSpacing: false\nquoteProps: preserve\n"),
+        (
+            ".editorconfig",
+            """root = true
+[*]
+max_line_length = 110
+""",
+        ),
+    ):
+        if not os.path.exists(filename):
+            file_to_clean.append(filename)
+            if os.path.exists(os.path.join("CONST_create_template", filename)):
+                shutil.copyfile(os.path.join("CONST_create_template", filename), filename)
+            else:
+                with open(filename, "w", encoding="utf8") as file_:
+                    file_.write(content)
+
+    if os.path.exists("ci/config.yaml"):
+        os.rename("ci/config.yaml", "ci/config.yaml_")
+    subprocess.run(["c2cciutils-checks", "--fix", "--check=isort"])  # pylint: disable=subprocess-run-check
+    subprocess.run(["c2cciutils-checks", "--fix", "--check=black"])  # pylint: disable=subprocess-run-check
+    subprocess.run(["c2cciutils-checks", "--fix", "--check=prettier"])  # pylint: disable=subprocess-run-check
+    if os.path.exists("ci/config.yaml_"):
+        os.rename("ci/config.yaml_", "ci/config.yaml")
+
+    for filename in file_to_clean:
+        os.remove(filename)
+
 
+def main() -> None:
+    """Tool used to do the application upgrade."""
     parser = _fill_arguments()
     options = parser.parse_args()
 
@@ -71,7 +103,7 @@ def main():
     c2cupgradetool.upgrade()
 
 
-def _fill_arguments():
+def _fill_arguments() -> ArgumentParser:
     parser = ArgumentParser()
     parser.add_argument(
         "--git-remote", metavar="GITREMOTE", help="Specify the remote branch", default="origin"
@@ -82,38 +114,40 @@ def _fill_arguments():
 
 
 class InteruptedException(Exception):
-    pass
+    """The interrupted exception."""
 
 
 current_step_number = 0
 
 
 class Step:
-    def __init__(self, step_number, file_marker=True):
+    """Decorator used for en upgrade step."""
+
+    def __init__(self, step_number: int, file_marker: bool = True):
         global current_step_number
         current_step_number = step_number
         self.step_number = step_number
         self.file_marker = file_marker
 
-    def __call__(self, current_step):
-        def decorate(c2cupgradetool, *args, **kwargs):
+    def __call__(
+        self, current_step: Callable[["C2cUpgradeTool", int], None]
+    ) -> Callable[["C2cUpgradeTool"], None]:
+        def decorate(c2cupgradetool: "C2cUpgradeTool") -> None:
             try:
-                if os.path.isfile(".UPGRADE{}".format(self.step_number - 1)):
-                    os.unlink(".UPGRADE{}".format(self.step_number - 1))
+                if os.path.isfile(f".UPGRADE{self.step_number - 1}"):
+                    os.unlink(f".UPGRADE{self.step_number - 1}")
                 if self.file_marker:
-                    with open(".UPGRADE{}".format(self.step_number), "w"):
+                    with open(f".UPGRADE{self.step_number}", "w", encoding="utf8"):
                         pass
-                print("Start step {}.".format(self.step_number))
+                print(f"Start step {self.step_number}.")
                 sys.stdout.flush()
-                current_step(c2cupgradetool, self.step_number, *args, **kwargs)
+                current_step(c2cupgradetool, self.step_number)
             except subprocess.CalledProcessError as exception:
+                command = " ".join([f"'{exception}'" for exception in exception.cmd])
                 c2cupgradetool.print_step(
                     self.step_number,
                     error=True,
-                    message="The command `{}` returns the error code {}.".format(
-                        " ".join(["'{}'".format(exception) for exception in exception.cmd]),
-                        exception.returncode,
-                    ),
+                    message=f"The command `{command}` returns the error code {exception.returncode}.",
                     prompt="Fix the error and run the step again:",
                 )
                 sys.exit(1)
@@ -121,21 +155,20 @@ class Step:
                 c2cupgradetool.print_step(
                     self.step_number,
                     error=True,
-                    message="There was an error: {}.".format(exception),
+                    message=f"There was an error: {exception}.",
                     prompt="Fix the error and run the step again:",
                 )
                 sys.exit(1)
             except Exception as exception:
-                cautch_exception = exception
+                catch_exception = exception
 
-                global current_step_number
                 if self.step_number == current_step_number:
 
-                    def message():
+                    def message() -> None:
                         c2cupgradetool.print_step(
                             self.step_number,
                             error=True,
-                            message="The step had the error '{}'.".format(cautch_exception),
+                            message=f"The step had the error '{catch_exception}'.",
                             prompt="Fix the error and run the step again:",
                         )
 
@@ -146,84 +179,100 @@ class Step:
 
 
 class C2cUpgradeTool:
+    """The tool used to upgrade the application."""
 
-    color_bar = colorize("================================================================", GREEN)
+    color_bar = colorize("================================================================", Color.GREEN)
 
-    def __init__(self, options):
+    def __init__(self, options: Namespace):
         self.options = options
-        self.project: Dict[str, Any] = self.get_project()
+        self.project = self.get_project()
 
     @staticmethod
-    def get_project():
+    def get_project() -> Dict[str, Any]:
         if not os.path.isfile("project.yaml"):
-            print(colorize("Unable to find the required 'project.yaml' file.", RED))
+            print(colorize("Unable to find the required 'project.yaml' file.", Color.RED))
             sys.exit(1)
 
-        with open("project.yaml", "r") as project_file:
-            return yaml.safe_load(project_file)
+        with open("project.yaml", encoding="utf8") as project_file:
+            return cast(Dict[str, Any], yaml.safe_load(project_file))
 
     @staticmethod
-    def get_upgrade(section):
+    def get_upgrade(section: str) -> Union[List[Any], Dict[str, Any]]:
         if not os.path.isfile(".upgrade.yaml"):
-            print(colorize("Unable to find the required '.upgrade.yaml' file.", RED))
+            print(colorize("Unable to find the required '.upgrade.yaml' file.", Color.RED))
             sys.exit(1)
 
-        with open(".upgrade.yaml", "r") as project_file:
-            return yaml.safe_load(project_file)[section]
-
-    def print_step(self, step, error=False, message=None, prompt="To continue, type:"):
-        with open(".UPGRADE_INSTRUCTIONS", "w") as instructions:
+        with open(".upgrade.yaml", encoding="utf8") as project_file:
+            return cast(Union[List[Any], Dict[str, Any]], yaml.safe_load(project_file)[section])
+
+    def print_step(
+        self,
+        step: int,
+        error: bool = False,
+        message: Optional[str] = None,
+        prompt: str = "To continue, type:",
+    ) -> None:
+        with open(".UPGRADE_INSTRUCTIONS", "w", encoding="utf8") as instructions:
             print("")
             print(self.color_bar)
             if message is not None:
-                print(colorize(message, RED if error else YELLOW))
-                instructions.write("{}\n".format(message))
+                print(colorize(message, Color.RED if error else Color.YELLOW))
+                instructions.write(f"{message}\n")
             if step >= 0:
-                print(colorize(prompt, GREEN))
-                instructions.write("{}\n".format(prompt))
+                print(colorize(prompt, Color.GREEN))
+                instructions.write(f"{prompt}\n")
                 cmd = ["./upgrade", os.environ["VERSION"]]
                 if step != 0:
-                    cmd.append("{}".format(step))
-                print(colorize(" ".join(cmd), GREEN))
-                instructions.write("{}\n".format(" ".join(cmd)))
+                    cmd.append(f"{step}")
+                print(colorize(" ".join(cmd), Color.GREEN))
+                instructions.write(f"{' '.join(cmd)}\n")
 
-    def run_step(self, step):
-        getattr(self, "step{}".format(step))()
+    def run_step(self, step: int) -> None:
+        getattr(self, f"step{step}")()
 
-    def test_checkers(self):
-        run_curl = "Run `curl --insecure {} '{}'` for more information.".format(
-            " ".join(["--header {}={}".format(*i) for i in self.project.get("checker_headers", {}).items()]),
-            self.project["checker_url"],
+    def test_checkers(self) -> Tuple[bool, Optional[str]]:
+        headers = " ".join(
+            [f"--header {i[0]}={i[1]}" for i in self.project.get("checker_headers", {}).items()]
         )
+        run_curl = f"Run `curl --insecure {headers} '{self.project['checker_url']}'` for more information."
         try:
-            requests.packages.urllib3.disable_warnings()
+            requests.packages.urllib3.disable_warnings()  # type: ignore
             resp = requests.get(
-                self.project["checker_url"], headers=self.project.get("checker_headers"), verify=False
+                self.project["checker_url"],
+                headers=self.project.get("checker_headers"),
+                verify=False,  # nosec
             )
         except requests.exceptions.ConnectionError as exception:
-            return False, "\n".join(["Connection error: {}".format(exception), run_curl])
+            return False, "\n".join([f"Connection error: {exception}", run_curl])
         except ConnectionRefusedError as exception:
-            return False, "\n".join(["Connection refused: {}".format(exception), run_curl])
+            return False, "\n".join([f"Connection refused: {exception}", run_curl])
         if resp.status_code < 200 or resp.status_code >= 300:
-
-            print(colorize("=============", RED))
-            print(colorize("Checker error", RED))
-            for name, value in resp.json()["failures"].items():
-                print(colorize("Test '{}' failed with result:".format(name), YELLOW))
-                del value["level"]
-                del value["timing"]
-
-                print(yaml.dump(value) if value != {} else "No result")
+            print(colorize("=============", Color.RED))
+            print(colorize("Checker error", Color.RED))
+            try:
+                for name, value in resp.json()["failures"].items():
+                    print(colorize(f"Test '{name}' failed with result:", Color.YELLOW))
+                    del value["level"]
+                    del value["timing"]
+
+                    print(yaml.dump(value) if value != {} else "No result")
+            except JSONDecodeError:
+                print(
+                    colorize(
+                        f"Response is not a JSON '{resp.text}', {resp.reason} {resp.status_code}",
+                        Color.RED,
+                    )
+                )
 
             return False, "\n".join(["Checker error:", run_curl])
 
         return True, None
 
-    def upgrade(self):
+    def upgrade(self) -> None:
         self.run_step(self.options.step)
 
     @Step(0, file_marker=False)
-    def step0(self, step):
+    def step0(self, step: int) -> None:
         project_template_keys = list(cast(Dict[str, Any], self.project.get("template_vars")).keys())
         messages = []
         for required in REQUIRED_TEMPLATE_KEYS:
@@ -255,11 +304,11 @@ class C2cUpgradeTool:
                 message="Here is the output of 'git status'. Please make sure to commit all your "
                 "changes before going further. All uncommitted changes will be lost.\n"
                 "Note that for debugging purpose it is possible to pass directly to step 2 "
-                "e.-g.: ./upgrade --debug=../c2cgeoportal {version} 2".format(version=os.environ["VERSION"]),
+                f"e.-g.: ./upgrade --debug=../c2cgeoportal {os.environ['VERSION']} 2",
             )
 
     @Step(1)
-    def step1(self, step):
+    def step1(self, step: int) -> None:
         shutil.copyfile("project.yaml", "/tmp/project.yaml")
         try:
             check_call(["git", "reset", "--hard"])
@@ -270,75 +319,38 @@ class C2cUpgradeTool:
         self.run_step(step + 1)
 
     @Step(2)
-    def step2(self, step):
-        with open(".eslintrc", "w") as eslintrc_file:
-            eslintrc_file.write(
-                """extends:
-  - openlayers
-globals:
-  '{}': false
-env:
-  jquery: true
-parserOptions:
-  ecmaVersion: 2017
-rules:
-  no-console: 0
-  comma-dangle: 0
-  import/no-unresolved: 0
-  valid-jsdoc: 0
-  sort-imports-es6-autofix/sort-imports-es6: 0
-  prettier/prettier: 1
-""".format(
-                    self.project["project_package"]
-                )
-            )
-
-        app_js_files = []
-        for base in ("CONST_create_template/", ""):
-            try:
-                app_js_files.extend(
-                    check_output(
-                        [
-                            "find",
-                            base + self.project["project_package"] + "_geoportal/static-ngeo/js",
-                            "-type",
-                            "f",
-                            "-name",
-                            "*.js",
-                        ]
-                    )
-                    .decode()
-                    .split()
-                )
-            except Exception:
-                pass
-
-        if app_js_files:
-            call(["eslint", "--fix"] + app_js_files)
-
-        os.remove(".eslintrc")
-        check_call(["git", "add"] + app_js_files)
-        call(["git", "commit", "--message=Run code style"])
+    def step2(self, step: int) -> None:
+        fix_style()
+        subprocess.run(["git", "add", "-A"])  # pylint: disable=subprocess-run-check
+        subprocess.run(["git", "commit", "--message=Run code style"])  # pylint: disable=subprocess-run-check
 
         self.run_step(step + 1)
 
     @Step(3)
-    def step3(self, step):
+    def step3(self, step: int) -> None:
         project_path = os.path.join("/tmp", self.project["project_folder"])
         os.mkdir(project_path)
         shutil.copyfile("/src/project.yaml", os.path.join(project_path, "project.yaml"))
         check_call(
             [
                 "pcreate",
-                "--ignore-conflicting-name",
                 "--overwrite",
-                "--scaffold=c2cgeoportal_update",
+                "--scaffold=update",
                 project_path,
             ]
         )
+        if self.get_project().get("advance", False):
+            check_call(
+                [
+                    "pcreate",
+                    "--overwrite",
+                    "--scaffold=advance_update",
+                    project_path,
+                ]
+            )
 
         shutil.copyfile(os.path.join(project_path, ".upgrade.yaml"), ".upgrade.yaml")
-        for upgrade_file in self.get_upgrade("upgrade_files"):
+        for upgrade_file in cast(List[Dict[str, Any]], self.get_upgrade("upgrade_files")):
             action = upgrade_file["action"]
             if action == "remove":
                 self.files_to_remove(upgrade_file, prefix="CONST_create_template", force=True)
@@ -354,7 +366,7 @@ rules:
         self.run_step(step + 1)
 
     @Step(4)
-    def step4(self, step):
+    def step4(self, step: int) -> None:
         if os.path.exists("CONST_create_template"):
             check_call(["git", "rm", "-r", "--force", "CONST_create_template/"])
 
@@ -363,37 +375,79 @@ rules:
         check_call(
             [
                 "pcreate",
-                "--ignore-conflicting-name",
                 "--overwrite",
-                "--scaffold=c2cgeoportal_update",
+                "--scaffold=update",
                 project_path,
             ]
         )
+        if self.get_project().get("advance", False):
+            check_call(
+                [
+                    "pcreate",
+                    "--overwrite",
+                    "--scaffold=advance_update",
+                    project_path,
+                ]
+            )
         os.remove(project_path)
 
+        check_call(["git", "add", "--all", "CONST_create_template/"])
+
+        def changed_files() -> List[str]:
+            try:
+                status = [
+                    [s for s in status.strip().split(" ", maxsplit=1) if s]
+                    for status in check_git_status_output().strip().split("\n")
+                    if status
+                ]
+                return [
+                    file.strip().split(" ")[-1]
+                    for state, file in status
+                    if state == "M" and not file.strip().startswith("CONST_")
+                ]
+            except:  # pylint: disable=bare-except
+                self.print_step(
+                    step,
+                    error=True,
+                    message=f"Error while getting changed files:\n{check_git_status_output()}",
+                    prompt="Fix the error and run the step again:",
+                )
+                sys.exit(1)
+
+        changed_before_style = changed_files()
+
+        fix_style()
+
+        # Revert code style changes in the project otherwise we get an  error: does not match index
+        # on git apply.
+        changed_after_style = changed_files()
+        to_checkout = [file for file in changed_after_style if file not in changed_before_style]
+        if to_checkout:
+            subprocess.run(["git", "checkout"] + to_checkout, check=True)
+
         check_call(["git", "add", "--all", "CONST_create_template/"])
         check_call(["git", "clean", "-Xf", "CONST_create_template/"])
         self.run_step(step + 1)
 
     @Step(5)
-    def step5(self, step):
+    def step5(self, step: int) -> None:
         if "managed_files" not in self.project:
+            unmanaged_files = "\n".join(["- " + e for e in self.project.get("unmanaged_files", [])])
             self.print_step(
                 step,
-                message="In the new version, we will also manage almost all the create "
-                "template files.\n"
-                "By default, files conforming to the following regex pattern will not be replaced:\n{}"
-                "Therefore, you should fill the 'managed_files' in you 'project.yaml' file with at least "
-                "`[]`.".format("\n".join(["- " + e for e in self.project.get("unmanaged_files", [])])),
+                message="In the new version, we will also manage almost all the create template files.\n"
+                "By default, files conforming to the following regex pattern will not be replaced:\n"
+                f"{unmanaged_files} Therefore, you should fill the 'managed_files' in you 'project.yaml' "
+                "file with at least `[]`.",
                 prompt="Fill it and run the step again:",
             )
         else:
             self.run_step(step + 1)
 
     @Step(6)
-    def step6(self, step):
+    def step6(self, step: int) -> None:
         task_to_do = False
-        for upgrade_file in self.get_upgrade("upgrade_files"):
+        for upgrade_file in cast(List[Dict[str, Any]], self.get_upgrade("upgrade_files")):
             action = upgrade_file["action"]
             if action == "remove":
                 task_to_do |= self.files_to_remove(upgrade_file)
@@ -415,7 +469,7 @@ rules:
         else:
             self.run_step(step + 1)
 
-    def files_to_remove(self, element, prefix="", force=False):
+    def files_to_remove(self, element: Dict[str, Any], prefix: str = "", force: bool = False) -> bool:
         task_to_do = False
         for path in element["paths"]:
             file_ = os.path.join(prefix, path.format(package=self.project["project_package"]))
@@ -433,31 +487,30 @@ rules:
                             if no_touch:
                                 managed = True
                             else:
-                                # fmt: off
-                                print(colorize(
-                                    "The file '{}' has been removed but he is in the `managed_files` as '{}'."
-                                    .format(file_, pattern),
-                                    RED
-                                ))
-                                # fmt: on
+                                print(
+                                    colorize(
+                                        f"The file '{file_}' has been removed but he is in the "
+                                        f"`managed_files` as '{pattern}'.",
+                                        Color.RED,
+                                    )
+                                )
                                 task_to_do = True
                     for pattern in self.project.get("unmanaged_files", []):
                         if re.match(pattern + "$", file_):
-                            # fmt: off
-                            print(colorize(
-                                "The file '{}' has been removed but he is in the `unmanaged_files` as '{}'."
-                                .format(file_, pattern),
-                                YELLOW
-                            ))
-                            # fmt: on
+                            print(
+                                colorize(
+                                    f"The file '{file_}' has been removed but he is in the "
+                                    f"`unmanaged_files` as '{pattern}'.",
+                                    Color.YELLOW,
+                                )
+                            )
                             task_to_do = True
                 if not managed:
-                    print("The file '{}' is removed.".format(file_))
+                    print(f"The file '{file_}' is removed.")
                     if "version" in element and "from" in element:
                         print(
-                            "Was used in version {}, to be removed from version {}.".format(
-                                element["from"], element["version"]
-                            )
+                            f"Was used in version {element['from']}, to be removed from version "
+                            f"{element['version']}."
                         )
                     if os.path.isdir(file_):
                         shutil.rmtree(file_)
@@ -465,7 +518,7 @@ rules:
                         os.remove(file_)
         return task_to_do
 
-    def files_to_move(self, element, prefix="", force=False):
+    def files_to_move(self, element: Dict[str, Any], prefix: str = "", force: bool = False) -> bool:
         task_to_do = False
         src = os.path.join(prefix, element["from"].format(package=self.project["project_package"]))
         dst = os.path.join(prefix, element["to"].format(package=self.project["project_package"]))
@@ -486,20 +539,18 @@ rules:
                         else:
                             print(
                                 colorize(
-                                    "The {} '{}' is present in the `managed_files` as '{}', "
-                                    "but it has been moved to '{}'.".format(type_, src, pattern, dst),
-                                    RED,
+                                    f"The {type_} '{src}' is present in the `managed_files` as '{pattern}', "
+                                    f"but it has been moved to '{dst}'.",
+                                    Color.RED,
                                 )
                             )
                             task_to_do = True
                     if re.match(pattern + "$", dst):
                         print(
                             colorize(
-                                "The {} '{}' is present in the `managed_files` as '{}', "
-                                "but a file have been moved on it from '{}'.".format(
-                                    type_, dst, pattern, src
-                                ),
-                                RED,
+                                f"The {type_} '{dst}' is present in the `managed_files` as '{pattern}', "
+                                f"but a file have been moved on it from '{src}'.",
+                                Color.RED,
                             )
                         )
                         task_to_do = True
@@ -507,45 +558,46 @@ rules:
                     if re.match(pattern + "$", src):
                         print(
                             colorize(
-                                "The {} '{}' is present in the `unmanaged_files` as '{}', "
-                                "but it has been moved to '{}'.".format(type_, src, pattern, dst),
-                                YELLOW,
+                                f"The {type_} '{src}' is present in the `unmanaged_files` as '{pattern}', "
+                                f"but it has been moved to '{dst}'.",
+                                Color.YELLOW,
                             )
                         )
                         task_to_do = True
                     if re.match(pattern + "$", dst):
                         print(
                             colorize(
-                                "The {} '{}' is present in the `unmanaged_files` as '{}', "
-                                "but a file have been moved on it from '{}'.".format(
-                                    type_, dst, pattern, src
-                                ),
-                                YELLOW,
+                                f"The {type_} '{dst}' is present in the `unmanaged_files` as '{pattern}', "
+                                f"but a file have been moved on it from '{src}'.",
+                                Color.YELLOW,
                             )
                         )
                         task_to_do = True
             if not managed and os.path.exists(dst) and not element.get("override", False):
-                print(colorize("The destination '{}' already exists, ignoring.".format(dst), YELLOW))
+                print(colorize(f"The destination '{dst}' already exists, ignoring.", Color.YELLOW))
             elif not managed:
-                print("Move the {} '{}' to '{}'.".format(type_, src, dst))
+                print(f"Move the {type_} '{src}' to '{dst}'.")
                 if "version" in element:
-                    print("Needed from version {}.".format(element["version"]))
+                    print(f"Needed from version {element['version']}.")
                 if os.path.dirname(dst) != "":
                     os.makedirs(os.path.dirname(dst), exist_ok=True)
                 try:
                     check_call(["git", "mv", src, dst])
                 except Exception as exception:
-                    print("[Warning] Git move error: {}.".format(exception))
+                    print(f"[Warning] Git move error: {exception}.")
                     os.rename(src, dst)
         return task_to_do
 
     @Step(7)
-    def step7(self, step):
+    def step7(self, step: int) -> None:
         self.files_to_get(step)
         self.run_step(step + 1)
 
-    def is_managed(self, file_, files_to_get=False):
-        default_project_file = self.get_upgrade("default_project_file")
+    def is_managed(self, file_: str, files_to_get: bool = False) -> bool:
+        # Dictionary with:
+        # include: list of include regular expression
+        # exclude: list of exclude regular expression
+        default_project_file = cast(Dict[str, List[str]], self.get_upgrade("default_project_file"))
 
         # Managed means managed by the application owner, not the c2cupgrade
         managed = False
@@ -556,23 +608,23 @@ rules:
         ):
             for pattern in default_project_file["include"]:
                 if re.match(pattern + "$", file_):
-                    print("File '{}' included by migration config pattern '{}'.".format(file_, pattern))
+                    print(f"File '{file_}' included by migration config pattern '{pattern}'.")
                     managed = True
                     break
             if managed:
                 for pattern in default_project_file["exclude"]:
                     if re.match(pattern + "$", file_):
-                        print("File '{}' excluded by migration config pattern '{}'.".format(file_, pattern))
+                        print(f"File '{file_}' excluded by migration config pattern '{pattern}'.")
                         print("managed", file_, pattern)
                         managed = False
                         break
         else:
-            print("New file '{}'.".format(file_))
+            print(f"New file '{file_}'.")
 
         if not managed and not os.path.exists(file_):
             for pattern in self.get_upgrade("extra"):
                 if re.match(pattern + "$", file_):
-                    print("File '{}' is an extra by migration config pattern '{}'.".format(file_, pattern))
+                    print(f"File '{file_}' is an extra by migration config pattern '{pattern}'.")
                     managed = True
 
         if not managed:
@@ -582,39 +634,29 @@ rules:
                 else:
                     pattern = files["pattern"]
                 if re.match(pattern + "$", file_):
-                    print(
-                        "File '{}' included by project config pattern `managed_files` '{}'.".format(
-                            file_, pattern
-                        )
-                    )
+                    print(f"File '{file_}' included by project config pattern `managed_files` '{pattern}'.")
                     print("managed", file_, pattern)
                     managed = True
                     break
         if managed:
             for pattern in self.project.get("unmanaged_files", []):
                 if re.match(pattern + "$", file_):
-                    print(
-                        "File '{}' excluded by project config pattern `unmanaged_files` '{}'.".format(
-                            file_, pattern
-                        )
-                    )
+                    print(f"File '{file_}' excluded by project config pattern `unmanaged_files` '{pattern}'.")
                     managed = False
                     break
 
         return managed
 
-    def files_to_get(self, step, pre=False):
+    def files_to_get(self, step: int, pre: bool = False) -> bool:
         error = False
         for root, _, files in os.walk("CONST_create_template"):
-            # fmt: off
-            root = root[len("CONST_create_template/"):]
-            # fmt: on
+            root = root[len("CONST_create_template/") :]
             for file_ in files:
                 destination = os.path.join(root, file_)
                 managed = self.is_managed(destination, True)
                 source = os.path.join("CONST_create_template", destination)
                 if not managed and (not os.path.exists(destination) or not filecmp.cmp(source, destination)):
-                    print(colorize("Get the file '{}' from the create template.".format(destination), GREEN))
+                    print(colorize(f"Get the file '{destination}' from the create template.", Color.GREEN))
                     if not pre:
                         if os.path.dirname(destination) != "":
                             os.makedirs(os.path.dirname(destination), exist_ok=True)
@@ -633,17 +675,17 @@ rules:
                             )
                             sys.exit(1)
                 elif managed:
-                    print("The file '{}' is managed by the project.".format(destination))
+                    print(f"The file '{destination}' is managed by the project.")
                 elif os.path.exists(destination) and filecmp.cmp(source, destination):
-                    print("The file '{}' does not change.".format(destination))
+                    print(f"The file '{destination}' does not change.")
                 else:
-                    print("Unknown stat for the file '{}'.".format(destination))
+                    print(f"Unknown stat for the file '{destination}'.")
                     sys.exit(2)
         return error
 
     @Step(8)
-    def step8(self, step):
-        with open("changelog.diff", "w") as diff_file:
+    def step8(self, step: int) -> None:
+        with open("changelog.diff", "w", encoding="utf8") as diff_file:
             check_call(["git", "diff", "--", "CONST_CHANGELOG.txt"], stdout=diff_file)
 
         from210 = False
@@ -664,30 +706,28 @@ rules:
                 "file (listed in the `changelog.diff` file).",
             )
 
-    def get_modified(self, status_path):
-        status = check_git_status_output([status_path])
-        status = [s for s in status.split("\n") if len(s) > 3]
+    def get_modified(self, status_path: str) -> List[str]:
+        status = check_git_status_output([status_path]).split("\n")
+        status = [s for s in status if len(s) > 3]
         status = [s[3:] for s in status if s[:3].strip() == "M"]
         for pattern in self.get_upgrade("no_diff"):
-            matcher = re.compile("CONST_create_template/{}$".format(pattern))
+            matcher = re.compile(f"CONST_create_template/{pattern}$")
             status = [s for s in status if not matcher.match(s)]
-        # fmt: off
-        status = [s for s in status if os.path.exists(s[len("CONST_create_template/"):])]
-        status = [s for s in status if not filecmp.cmp(s, s[len("CONST_create_template/"):])]
-        # fmt: on
+        status = [s for s in status if os.path.exists(s[len("CONST_create_template/") :])]
+        status = [s for s in status if not filecmp.cmp(s, s[len("CONST_create_template/") :])]
         return status
 
     @Step(9)
-    def step9(self, step):
+    def step9(self, step: int) -> None:
         if os.path.isfile("changelog.diff"):
             os.unlink("changelog.diff")
 
         status = self.get_modified(
-            "CONST_create_template/geoportal/{}_geoportal/static-ngeo".format(self.project["project_package"])
+            f"CONST_create_template/geoportal/{self.project['project_package']}_geoportal/static-ngeo"
         )
         status += ["CONST_create_template/geoportal/vars.yaml"]
 
-        with open("ngeo.diff", "w") as diff_file:
+        with open("ngeo.diff", "w", encoding="utf8") as diff_file:
             if status:
                 check_call(
                     ["git", "diff", "--relative=CONST_create_template", "--staged", "--"] + status,
@@ -705,7 +745,7 @@ rules:
             )
 
     @Step(10)
-    def step10(self, step):
+    def step10(self, step: int) -> None:
         if os.path.isfile("ngeo.diff"):
             os.unlink("ngeo.diff")
 
@@ -714,15 +754,13 @@ rules:
             s
             for s in status
             if not s.startswith(
-                "CONST_create_template/geoportal/{}_geoportal/static-ngeo/".format(
-                    self.project["project_package"]
-                )
+                f"CONST_create_template/geoportal/{self.project['project_package']}_geoportal/static-ngeo/"
             )
         ]
         status = [s for s in status if s != "CONST_create_template/geoportal/vars.yaml"]
 
         if status:
-            with open("create.diff", "w") as diff_file:
+            with open("create.diff", "w", encoding="utf8") as diff_file:
                 if status:
                     check_call(
                         ["git", "diff", "--relative=CONST_create_template", "--staged", "--"] + status,
@@ -743,24 +781,24 @@ rules:
             self.run_step(step + 1)
 
     @Step(11)
-    def step11(self, step):
+    def step11(self, step: int) -> None:
         if os.path.isfile("create.diff"):
             os.unlink("create.diff")
 
         message = [
             "The upgrade is nearly done, now you should:",
             "- Build your application with `./upgrade --finalize [build arguments]`",
-            "- Test your application on '{}'.".format(self.project.get("application_url", "... missing ...")),
+            f"- Test your application on '{self.project.get('application_url', '... missing ...')}'.",
         ]
 
         if os.path.isfile(".upgrade.yaml"):
             os.unlink(".upgrade.yaml")
-        with open(".UPGRADE_SUCCESS", "w"):
+        with open(".UPGRADE_SUCCESS", "w", encoding="utf8"):
             pass
         self.print_step(step + 1, message="\n".join(message))
 
     @Step(12, file_marker=False)
-    def step12(self, step):
+    def step12(self, step: int) -> None:
         if os.path.isfile(".UPGRADE_SUCCESS"):
             os.unlink(".UPGRADE_SUCCESS")
         good, message = self.test_checkers()
@@ -772,12 +810,12 @@ rules:
                 error=True,
                 message=message,
                 prompt="Correct the checker, then run the step again "
-                "(If you want to fix it later you can pass to the next step):",
+                "(If you want to fix it later you can pass to the next step:int):",
             )
             sys.exit(1)
 
     @Step(13, file_marker=False)
-    def step13(self, step):
+    def step13(self, step: int) -> None:
         # Required to remove from the Git stage the ignored file when we lunch the step again
         check_call(["git", "reset", "--mixed"])
 
@@ -788,35 +826,35 @@ rules:
             step + 1,
             message="We will commit all the above files!\n"
             "If there are some files which should not be committed, then you should "
-            "add them into the `.gitignore` file and launch upgrade {} again.".format(step),
+            f"add them into the `.gitignore` file and launch upgrade {step} again.",
             prompt="Then to commit your changes type:",
         )
 
     @Step(14, file_marker=False)
-    def step14(self, _):
+    def step14(self, _: int) -> None:
         if os.path.isfile(".UPGRADE_INSTRUCTIONS"):
             os.unlink(".UPGRADE_INSTRUCTIONS")
         check_call(
             [
                 "git",
                 "commit",
-                "--message=Upgrade to GeoMapFish {}".format(
-                    pkg_resources.get_distribution("c2cgeoportal_commons").version
-                ),
+                "--message=Upgrade to GeoMapFish "
+                f"{pkg_resources.get_distribution('c2cgeoportal_commons').version}",
             ]
         )
 
         print("")
         print(self.color_bar)
         print("")
-        print(colorize("Congratulations, your upgrade was successful.", GREEN))
+        print(colorize("Congratulations, your upgrade was successful.", Color.GREEN))
         print("")
         branch = check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"]).decode("utf-8").strip()
         print("Now all your files are committed; you should do a git push:")
-        print("git push {0!s} {1!s}.".format(self.options.git_remote, branch))
+        print(f"git push {self.options.git_remote} {branch}.")
 
 
-def check_git_status_output(args=None):
+def check_git_status_output(args: Optional[List[str]] = None) -> str:
+    """Check if there is something that's not committed."""
     return check_output(["git", "status", "--short"] + (args if args is not None else [])).decode("utf-8")