mangono-addon-auto_migration 2.0.0__py3-none-any.whl

mangono_addon_auto_migration-2.0.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: mangono-addon-auto_migration
+Version: 2.0.0
+Project-URL: Homepage, https://mangono.fr
+Author-Email: mangono <opensource+odoo@mangono.fr>
+License-Expression: AGPL-3.0
+Classifier: Framework :: Odoo
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python
+Requires-Dist: environ-odoo-config<2,>=0.6.5
+Description-Content-Type: text/plain
+Description: This server wide module provides support to run pre- and post-installation scripts
+

mangono_addon_auto_migration-2.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+odoo/addons/auto_migration/__init__.py,sha256=XnrwL7vmyhRTYi9YvudtdpYr16kG23j-k59TRAWIQfU,123
+odoo/addons/auto_migration/__manifest__.py,sha256=xLi6VJzYkiJyDSj9yLEnTLEAmWLQqbzXBn_2JOiWe8M,489
+odoo/addons/auto_migration/auto_load.py,sha256=m70OuVD-Is7JA91Tu9wypgghr0ljAt1u3Wx7j-JY1A4,237
+odoo/addons/auto_migration/documentation.adoc,sha256=Hsp3wC5Y4LJTuw01efzzIZKlYrZhL75IQFBd0XFeaoE,6645
+odoo/addons/auto_migration/hooks.py,sha256=i9xOAVzoBtRVyDhs9f6b-wJAboXqwEuT16LIS9345xY,637
+odoo/addons/auto_migration/mangono_migration.py,sha256=BVjtDYW0ohkeVehEDnuHmlAfH-2BNXGFzg4CNJVvnuc,16123
+odoo/addons/auto_migration/i18n/fr.po,sha256=UqeDlp8ksOuoMFCBU9M3xJvqE09s3kKoKpCT2vK9uTA,432
+mangono_addon_auto_migration-2.0.0.dist-info/METADATA,sha256=m7iQ5kAo1-_kb5yhHQ4tb4kwqbVnxSbGZV7a3KEZVr4,522
+mangono_addon_auto_migration-2.0.0.dist-info/WHEEL,sha256=oMFM00-3w15fuhxrOoJBKP3EfQFiV1TFGhhmJn2iH-o,100
+mangono_addon_auto_migration-2.0.0.dist-info/entry_points.txt,sha256=oHx9JvLBZVSkJLv8uLpO0a895NFrUwRB-QzzmvEYSQM,126
+mangono_addon_auto_migration-2.0.0.dist-info/top_level.txt,sha256=QE6RBQ0QX5f4eFuUcGgU5Kbq1A_qJcDs-e_vpr6pmfU,4
+mangono_addon_auto_migration-2.0.0.dist-info/RECORD,,

mangono_addon_auto_migration-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: Mangono Wheel Builder: 0.5.1
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mangono_addon_auto_migration-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[environ_odoo_config.auto_server_wide_module]
+auto_migration = odoo.addons.auto_migration.auto_load:auto_load_auto_migration
+

mangono_addon_auto_migration-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+odoo

odoo/addons/auto_migration/__init__.py

@@ -0,0 +1,3 @@
+from . import mangono_migration
+from .hooks import create_migration_channel
+from .mangono_migration import patch_migration

odoo/addons/auto_migration/__manifest__.py

@@ -0,0 +1,16 @@
+{
+    "name": "auto_migration",
+    "description": "This server wide module provides support to run pre- and post-installation scripts",
+    "category": "Extra Tools",
+    "depends": ["base"],
+    "installable": False,
+    "auto_install": False,
+    "version": "2.0.0",
+    "author": "mangono",
+    "license": "AGPL-3",
+    "maintainer": "Mangono",
+    "website": "https://mangono.fr",
+    "data": [],
+    "pre_init_hook": "create_migration_channel",
+    "post_load": "patch_migration",
+}

odoo/addons/auto_migration/auto_load.py

@@ -0,0 +1,4 @@
+def auto_load_mangono_migration(environ: dict) -> bool:
+    return (environ.get("UPDATE", False) or environ.get("INIT", False)) and not environ.get(
+        "DISABLE_MANGONO_MIGRATION", environ.get("DISABLE_AUTO_MIGRATION", False)
+    )

odoo/addons/auto_migration/documentation.adoc

@@ -0,0 +1,159 @@
+= AUTO MIGRATION
+
+== Purpose
+
+Provide service for pre-installation and post-installation scripts (migration scripts)
+
+scripts are run upon install or update (-i ou -u)
+Goal is to avoid having to play manually SQL or python script
+
+We do not use odoo migration script system because it requires to manage module's version, which is difficult for project with simultaneous dev
+
+== Usage
+=== settings
+this module must be declared as server wide module
+
+- docker : `--load web,kanban,auto_migration`
+- nestor : using `nestor.cfg` file at the project's root, for example :
+----
+default:
+  version: "13.0"
+  workers: 3
+  options:
+    load: auto_migration
+----
+- clever cloud : using `.clever/envs/update.env` file
+----
+LOAD_AUTO_MIGRATION="True"
+----
+
+- odoo-cloud
+
+This module is auto-loadable and will be loaded if the library is present in your `requirements.txt`
+
+You may need to add an explicit load if you want to use it in the install step of the runbot
+----
+  variables:
+    # ODOO_ENV aare propagated to the odoo service inside the runbot
+    LOAD_AUTO_MIGRATION: auto_migration
+----
+
+- mise runbot
+
+If you need the module loaded in the install step of mise runbot, you need to set `ODOO_ENV_CONFIG_EXCLUDE_EXT: "auto_load_widemodules"` in addition to `LOAD_AUTO_MIGRATION`.
+
+`*IMPORTANT*` : *do not install the auto_migration module!* +
+
+
+`auto_migrations` directory must be created at the root of your module's directory (__`mangono_migration` directory is kept for backward compatibility, will be deprecated in future release__)
+
+A `auto_migration` table will be created in your database to record the status of the script running and record logs. *There is no graphical interface, and there is no odoo models*.
+You can use SQL request to check script execution, and use usual `_logger.info()` to log script activity.
+
+_auto_migration  library is available from V12 to V19, with python >= 3.8.19
+
+
+=== pre-installation
+pre-installation script are run before update of the module, and allow to fix data before module update or create column to avoid compute.
+
+each pre_installation script for a given ticket must be in a python file called `pre_<ticket_number>.py`, located in a 'migrations/auto' directory in your module. +
+Scripts are played in alphabetical order of the file's names. Inside a file, method are played in declaration order, unless priority parameter is set in the decorator.
+Lowest number is highest priority (1 more priority than 25). +
+
+you must import :
+           `from odoo.addons.auto_migration.mangono_migration import auto_migrate`
+
+the functions must be decorated by `@auto_migrate` and have this signature :
+          `def xxxxx(self)` or for backward compatibility `def xxxxx(self, has_run):`
+
+self is a factice object (not usual odoo self), but self.env is a real odoo env, `self.env['model']` is able to access odoo models, `self.env.cr` or `self.cr` can be used to perform request +
+self.has_run is a boolean true if the script has already been run (same for has_run parameter if used)
+
+EXAMPLE:
+[source,python]
+----
+       @migrate_mangono(run_always=False, priority=10, allowed_to_fail=True)
+       def pre_t1245(self):
+           # the function will always get self.has_run = False,
+           # because it will be called only if it has not run yet
+           self.env['my.model'].search(my_domain).unlink  # with allowed_to_fail, if this fails, the script
+                                                          # action will be rollbacked but update goes on
+----
+
+SIMPLE EXAMPLE:
+[source,python]
+----
+@migrate_mangono
+def pre_t5432(self):
+    self.cr.execute("UPDATE xxxx")
+----
+
+if the optional decorator parameter `run_always` is set to True
+       the method must use the has_run bool to check if the script has already been run on this base or check if
+       there is something to do before doing it. (_default value of run_always is False_)
+
+in case of exception the script is rollbacked, it is not written as run in the `auto_migration` table and installation will stop, other scripts will not be executed
+
+if the optional decorator parameter `allowed_to_fail` is set to `True`, the script failure will not interrupt installation or update process. The DB is rollbacked to the state at the beginning of the script execution. Failure logs will be reported in table logs and a warning level log is issued in odoo logs. (_default is False_)
+
+The optional decorator parameter `priority` can be set to a priority from 1 to 9999 (_default_) to decide the order in which script from the same python file will be played (priority 1 is played first).
+
+NOTE: old decorator @migrate_mangono is kept for backaward compatibility
+
+=== post-installation
+
+post-installation script are run after the module is installed/updated, before module translation are loaded, and before `post_init_hook`
+
+python file must be called `post_<Ticket_number>`
+
+decorator use is the same
+
+IMPORTANT: when a post script fails, all post action are rollbacked, but pre action are committed
+
+=== end
+
+same as post, with end_XXXX +
+Ces scripts sont joués après l'installation/mise à jour de tous les modules.
+
+=== afterbase
+Use to play a script just after base is updated, before any other modules are updated.
+
+To allow this, your script must reside in any installed modules (usually project_erp) and the file must be named `afterbase_xxxx.py`. You must run `update base`
+
+You cannot use models in this script, everything must be done with SQL
+
+=== jobification :
+
+you can start job from the script by calling `with_delay` as usual. +
+Note that job will not start during update phase. They will only start when the instance is restarted after the update.
+
+=== helper function
+`table_exists_in_db(cr, tablename)` can be used to check if a table exists in database
+
+`column_exists_in_db(cr, table_name, column_name)` can be used to check if a column exists in the given table.
+
+
+== Script example
+
+[source,python]
+----
+
+import logging
+from odoo.addons.auto_migration.mangono_migration import auto_migrate
+
+_logger = logging.getLogger(__name__)
+
+
+@auto_migrate(run_always=False, allowed_to_fail=False)
+def update_rh_rights(self, has_run):
+    # Le script consiste à :
+    # - extraire tous les utilisateurs faisant partie du groupe Admin/Droits d'accès
+    # - les faire appartenir au groupe RH/Formation.
+    group_admin = self.env.ref('base.group_erp_manager')
+    group_training = self.env.ref(
+        'xxx_donnees_ref.group_xxx_training_manager')
+    users = group_admin.users
+    for user in users:
+        _logger.info(u"user %s added to RRH/formation group", user)
+        user.groups_id = [(4, group_training.id)]
+----

odoo/addons/auto_migration/hooks.py

@@ -0,0 +1,7 @@
+def create_migration_channel(cr):
+    """create if necessary the root.migration_job channel for execution of job launched by migration"""
+    cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname='queue_job_channel'")
+    if cr.fetchall():  # queue_job_channel may not exists if module connector is not installed
+        cr.execute("""SELECT COUNT(*) FROM queue_job_channel WHERE NAME = 'root.migration_jobs'""")
+        if not cr.fetchall()[0][0]:  # the channel doesn(t exist yet, let's create it
+            cr.execute("""INSERT INTO queue_job_channel (name, parent_id) VALUES ('root.migration_jobs', 1)""")

odoo/addons/auto_migration/i18n/fr.po

@@ -0,0 +1,16 @@
+# Translation of Odoo Server.
+# This file contains the translation of the following modules:
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Odoo Server 8.0\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2019-03-12 11:13+0000\n"
+"PO-Revision-Date: 2019-03-12 11:13+0000\n"
+"Last-Translator: <>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: \n"
+"Plural-Forms: \n"
+

odoo/addons/auto_migration/mangono_migration.py

@@ -0,0 +1,415 @@
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import logging
+import os
+from inspect import getmembers, isfunction
+from operator import attrgetter
+from typing import Any
+
+from environ_odoo_config.odoo_utils import get_server_wide_modules
+from typing_extensions import Self
+
+import odoo
+
+Path = str
+MAJOR = odoo.release.version_info[0]
+MAJOR_STR = odoo.release.serie
+MIGRATION_DIR = [
+    "auto_migrations",
+    "ndp_migration",
+    "mangono_migration",  # Name of the directory where the script must be located
+]
+if MAJOR < 19:
+    from odoo import (
+        SUPERUSER_ID,
+        api,
+        fields,
+        registry,  # pylint: disable=ungrouped-imports; pylint: disable=ungrouped-imports
+    )
+else:
+    from odoo import (
+        SUPERUSER_ID,
+        api,
+        fields,
+    )
+
+    # from odoo.addons.queue_job.models import with_delay
+from odoo.modules.migration import MigrationManager  # pylint: disable=ungrouped-imports
+from odoo.modules.module import (
+    get_module_path,
+    get_modules,  # pylint: disable=ungrouped-imports; pylint: disable=ungrouped-imports
+)
+from odoo.tools import config  # pylint: disable=ungrouped-imports
+
+_logger = logging.getLogger(__name__)
+
+
+def _is_valid_migration_file_for_stage(stage: str, name: str) -> bool:
+    """
+    :param name: filename without path
+    :return: True is filename is in the form : stage_XXXX.py (case insensitive)
+    """
+    _, ext = os.path.splitext(name)
+    return ext.lower() == ".py" and name.lower().startswith((stage + "_").lower())
+
+
+def table_exists_in_db(cr, tablename: str) -> bool:
+    """
+    :param cr: a cursor object
+    :param tablename: name of the table (stock_move)
+    :return: True if the table exists in database, False otherwise
+    """
+    cr.execute(
+        """
+    SELECT EXISTS (
+        SELECT FROM pg_catalog.pg_class c
+        JOIN   pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE  n.nspname = 'public'
+        AND    c.relname = %s)
+        """,
+        (tablename,),
+    )
+    return cr.fetchone()[0]
+
+
+def column_exists_in_db(cr, table_name: str, column_name: str) -> bool:
+    """
+    :param cr: cursor object
+    :param table_name: 'stock_move' for exmaple
+    :param column_name: 'location_id' for example
+    :return: True if column exists in table, false if columns or table doesn't exist
+    """
+    if table_exists_in_db(cr, table_name):
+        cr.execute(
+            """
+        SELECT EXISTS(SELECT *
+          FROM   INFORMATION_SCHEMA.COLUMNS
+          WHERE  TABLE_NAME = %s
+                 AND COLUMN_NAME = %s);
+        """,
+            (table_name, column_name),
+        )
+        return cr.fetchone()[0]
+    return False
+
+
+def mangono_migrate_module(self, pkg, stage: str):
+    # this function is called from loading.py, self gives access to cr and graph
+    _logger.debug("auto_migrate_module stage %s module %s", pkg.name, stage)
+    if pkg.name not in ["base", "auto_migration"] and not config["test_enable"]:
+        run_migration_script(self, stage, pkg)
+    result = MigrationManager.origin_migrate_module(self, pkg, stage)
+    return result
+
+
+# ruff: noqa: PERF203
+def get_module_filetree(module_path: Path) -> dict[str, Path]:
+    """return a dict of file: absolute_path for every file in migration directory of module_path"""
+    res = {}
+    for directory in MIGRATION_DIR:
+        try:
+            res.update(
+                {
+                    f: os.path.join(module_path, directory, f)
+                    for f in sorted(os.listdir(os.path.join(module_path, directory)))
+                }
+            )
+        except FileNotFoundError:
+            continue
+    return res
+
+
+def just_after_base(self, stage: str, pkg) -> None:
+    """
+    :param stage: the migration stage
+    :param pkg: a Package object
+    :return: if the package is the first one after base, looks for scripts with stage 'afterbase' in all migration dirs
+    During an "update base", this will execute these migration script beginning with afterbase_ ...
+    before any other community, common, ... modules are loaded (only base is loaded)
+    """
+    if MAJOR < 19:
+        list_pkg = list(pkg.graph)
+    else:
+        list_pkg = list(pkg.module_graph)
+    if stage == "pre" and list_pkg[0].name == "base" and list_pkg[1] == pkg:  # we are the first package after base
+        mods = get_modules()
+        for mod in mods:
+            self.cr.execute("""select state from ir_module_module where name = %s""", (mod,))
+            state = self.cr.fetchone()
+            if state and state[0] in [
+                "installed",
+                "to upgrade",
+            ]:  # we check only installed modules
+                module_path = get_module_path(mod)
+                file_tree = get_module_filetree(module_path)
+                if file_tree:
+                    run_scripts_of_module(self, file_tree, "afterbase")
+
+
+def run_migration_script(self, stage: str, pkg) -> None:
+    _logger.info("Running migration script %s stage: %s", pkg.name, stage)
+    if MAJOR >= 18:
+        _registry = odoo.modules.registry.Registry(self.cr.dbname)
+    else:
+        _registry = registry(self.cr.dbname)
+    just_after_base(self, stage, pkg)  # really working ??
+    module_path = get_module_path(pkg.name)
+    file_tree = get_module_filetree(module_path)
+    if file_tree:
+        if stage == "pre":
+            if MAJOR >= 19:
+                _registry._setup_models__(self.cr)
+            else:
+                _registry.setup_models(self.cr)
+        _logger.debug("=== found auto migration directory in %s for stage %s", pkg.name, stage)
+        run_scripts_of_module(self, file_tree, stage)
+
+
+def run_scripts_of_module(self, file_tree: dict[str, Path], stage: str) -> None:
+    """run all script in this module matching stage (python file beginning with stage_)"""
+    _logger.debug("=== running auto migration module %s", stage)
+    for filename, file_path in file_tree.items():
+        # python file must be directly under auto_migrations directory
+        if _is_valid_migration_file_for_stage(stage, filename):
+            file_without_ext = os.path.splitext(filename)[0]
+            # load and execute _pre_migrate()
+            py_mod = load_module_from_file(file_without_ext, file_path)
+            # we recognize the python function to run because the @auto_migrate wrapper adds an
+            # 'is_auto_migration' attribute to it, <migrate_mangono> is imported by the import, must not be run
+            scripts = [
+                f[1]
+                for f in getmembers(py_mod, isfunction)
+                if f[0] != "migrate_mangono"
+                and (hasattr(f[1], "is_mangono_migration") or hasattr(f[1], "is_auto_migration"))
+            ]
+            for method in sorted(scripts, key=attrgetter("priority")):
+                module = file_path.split("/")[-3]
+                ident = "{module}.{method}".format(module=module or "", method=method.__name__)
+                script = MangonoMigration.get_or_create(self.cr, ident)
+                script.run_method_if_needed(method)
+
+
+def patch_migration() -> None:
+    if "auto_migration" in get_server_wide_modules(MAJOR_STR) and not config["test_enable"]:
+        MigrationManager.origin_migrate_module = (
+            hasattr(MigrationManager, "origin_migrate_module")
+            and MigrationManager.origin_migrate_module
+            or MigrationManager.migrate_module
+        )
+        MigrationManager.migrate_module = mangono_migrate_module
+        if "openupgrade_framework" in get_server_wide_modules(MAJOR_STR) and hasattr(
+            MigrationManager.origin_migrate_module, "_original_method"
+        ):
+            # When openupgrade is activated with mangono_migration we need to copy _original_method ref
+            mangono_migrate_module._original_method = MigrationManager.origin_migrate_module._original_method  # pyright: ignore[reportFunctionMemberAccess]
+        MigrationManager._logger = hasattr(MigrationManager, "_logger") and MigrationManager._logger or _logger
+        _logger.info("module auto_migration enabled")
+
+
+class MangonoMigration:  # pylint: disable=useless-object-inheritance
+    """
+    Provide service for pre-installation and post-installation scripts
+    see <documentation.adoc> for detailed documentation
+    """
+
+    _description = "Automation scripting system for pre and post installation scripting"
+
+    def __init__(
+        self,
+        ticket: str,
+        cr,
+        md5: str | None = None,
+        has_run: bool = False,
+        create_date=None,
+        write_date=None,
+        log: str | None = None,
+    ):
+        """prepare the table for script execution recording if necessary"""
+        super().__init__()
+        self.ticket = ticket
+        self.md5 = md5 or ""
+        self.log = log or ""
+        self.has_run = has_run
+        self.create_date = create_date or fields.Datetime.now()
+        self.write_date = write_date or fields.Datetime.now()
+        self.cr = cr
+
+    @classmethod
+    def create_table_if_needed(cls, cr) -> None:
+        """Keep as classmethod because used in get_or_create to create an instance of MangonoMigration"""
+        cr.execute("ALTER TABLE IF EXISTS ndp_migration RENAME TO auto_migration")
+        cr.execute("ALTER TABLE IF EXISTS mangono_migration RENAME TO auto_migration")
+        cr.execute(
+            """CREATE TABLE IF NOT EXISTS auto_migration ( id serial  NOT NULL
+            CONSTRAINT
+            mangono_migration_pkey
+            PRIMARY
+            KEY,
+            create_date
+            timestamp,
+            write_date
+            timestamp,
+            ticket
+            varchar
+            NOT
+            NULL
+            CONSTRAINT
+            mangono_migration_unique_ticket
+            UNIQUE,
+            md5
+            varchar,
+            has_run bool,
+            log varchar
+            );"""
+        )
+
+    def set_run(self) -> None:
+        """record the fact that this script has been run"""
+        md5 = ""
+        self.create_table_if_needed(self.cr)
+        date_str = fields.Datetime.to_string(fields.Datetime.now())
+        _logger.debug("script %s has run succesfully", self.ticket)
+        self.cr.execute(
+            """UPDATE auto_migration SET has_run = TRUE, md5 = %s, write_date = %s, log = %s
+                      WHERE ticket = %s""",
+            (md5, date_str, self.log + "\n" + date_str + " has_run", self.ticket),
+        )
+
+    @classmethod
+    def get_or_create(cls, cr, ident: str) -> Self:
+        """return MangonoMigration object from existing record of database, create it in base if it doesn't exist"""
+
+        def get_value() -> dict[str, Any]:
+            # odoo himself use string formating to insert table name into query
+            cls.create_table_if_needed(cr)
+            cr.execute("""SELECT * FROM auto_migration WHERE ticket = %s""", (ident,))
+            return cr.dictfetchone()
+
+        res = get_value()
+        if not res:
+            cr.execute(
+                """INSERT INTO auto_migration
+                        (ticket, has_run, create_date, write_date)
+                        VALUES (%s, FALSE, %s, %s)""",
+                (ident, fields.Datetime.now(), fields.Datetime.now()),
+            )
+            res = get_value()
+        res.pop("id")
+        return MangonoMigration(cr=cr, **res)
+
+    def log_error(self, msg: str) -> None:
+        self.create_table_if_needed(self.cr)
+        self.cr.execute(
+            """UPDATE auto_migration SET log = %s WHERE ticket = %s""",
+            (
+                f"{self.log}\n{fields.Datetime.to_string(fields.Datetime.now())} : {msg}",
+                self.ticket,
+            ),
+        )
+
+    def run_method_if_needed(self, method: callable) -> None:
+        _logger.info("preparing to run %s", method.__name__)
+        try:
+            if method.run_always or not self.has_run:
+                if method.allowed_to_fail:
+                    with self.cr.savepoint():  # when failed, changes are rollbacked
+                        _logger.info(
+                            "auto_migration executing %s allowed to fail",
+                            method.__name__,
+                        )
+                        self._call_method(method)
+                else:
+                    _logger.info(
+                        "auto_migration executing %s not allowed to fail",
+                        method.__name__,
+                    )
+                    self._call_method(method)
+        # pylint: disable=broad-except
+        except Exception as err:
+            _logger.warning("Error during migration <%s>: %s", self.ticket, err)
+            self.log_error(f"{err}")
+            if not method.allowed_to_fail:
+                # note that the self allowed_to_fail which fails will have an error log, but not set to run
+                raise
+        else:
+            if method.run_always or not self.has_run:
+                self.set_run()
+
+    def _call_method(self, method: callable) -> None:
+        parameters = inspect.signature(method).parameters
+        if len(parameters) > 2:
+            self.log_error(f"{method.__name__} wrong signature (too many arguments)")
+        elif len(parameters) == 2 and parameters.get("has_run"):
+            # old signature with parameter has_run
+            method(ProxySelf(self.cr, self.has_run), self.has_run)
+        else:  # cas où la méthode ne prend pas has_run en paramètre
+            method(ProxySelf(self.cr, self.has_run))
+
+
+class ProxySelf:  # pylint: disable=useless-object-inheritance
+    """provide a factice object with env attribute to be able to use self.env, self.env.cr in script
+    self.has_run is true when the script has already been run (for run_always script)
+    """
+
+    def __init__(self, cr, has_run: bool = False):
+        super().__init__()
+        env = api.Environment(cr, SUPERUSER_ID, {})
+        self.env = env
+        self.cr = cr
+        self.uid = SUPERUSER_ID
+        self.context = self.env.context
+        self.has_run = has_run
+
+
+def auto_migrate(run_always: bool | callable = False, priority: int = 9999, allowed_to_fail: bool = False) -> callable:
+    def _migrate_mangono(method: callable) -> callable:
+        """This decorator decorate the method with the argument declared in the call to auto_migrate()
+        and return the decorated method without changing the signature"""
+        method.run_always = run_always
+        method.priority = priority
+        method.allowed_to_fail = allowed_to_fail
+        method.is_auto_migration = True
+        return method
+
+    if callable(run_always):
+        # use case of @auto_migrate without bracket, in this case the first argument is the method, we need
+        # to implement default value for missings arguments
+        method = run_always
+        run_always = False
+        priority = 9999
+        allowed_to_fail = False
+        return _migrate_mangono(method)
+
+    return _migrate_mangono
+
+
+migrate_mangono = auto_migrate
+
+
+##############################################################################
+# Copyright (c) 2013-2018, Lawrence Livermore National Security, LLC.
+# Produced at the Lawrence Livermore National Laboratory.
+# Extract from spack
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License (as
+# published by the Free Software Foundation) version 2.1, February 1999.
+##############################################################################
+def load_module_from_file(module_name, module_path):
+    """Loads a python module from the path of the corresponding file.
+    Args:
+        module_name (str): namespace where the python module will be loaded,
+            e.g. ``foo.bar``
+        module_path (str): path of the python file containing the module
+    Returns:
+        A valid module object
+    Raises:
+        ImportError: when the module can't be loaded
+        FileNotFoundError: when module_path doesn't exist
+    """
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    return module