update

database/docker-compose.yml

@@ -1,15 +0,0 @@
-version: '3.8'
-services:
-  db-test:
-    image: postgres:16
-    user: root
-    environment:
-      - POSTGRES_USER=${PG_USER:-changeme}
-      - POSTGRES_PASSWORD=${PG_PASS:-password}
-      - POSTGRES_DB=${PG_DB:-postgres}
-    restart: always
-    ports:
-      - ${PG_PORT:-5432}:5432
-    volumes:
-        - ${PG_DATA:-./postgresql}:/var/lib/postgresql/data
-        

database/env.template

@@ -1,5 +0,0 @@
-#Database
-PG_DB=nexterp
-PG_USER=nexterp
-PG_PASS=4ewLWdJ0WQ8I77Slqg0Y8kAj
-PG_PORT=

setup/package.py

@@ -18,9 +18,9 @@ from xmlrpc import client as xmlrpclib
 
 from glob import glob
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 # Utils
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 ROOTDIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
 TSTAMP = time.strftime("%Y%m%d", time.gmtime())
@@ -29,11 +29,11 @@ TSEC = time.strftime("%H%M%S", time.gmtime())
 version = ...
 version_info = ...
 nt_service_name = ...
-exec(open(os.path.join(ROOTDIR, 'odoo', 'release.py'), 'rb').read())
-VERSION = version.split('-')[0].replace('saas~', '')
-GPGPASSPHRASE = os.getenv('GPGPASSPHRASE')
-GPGID = os.getenv('GPGID')
-DOCKERVERSION = VERSION.replace('+', '')
+exec(open(os.path.join(ROOTDIR, "odoo", "release.py"), "rb").read())
+VERSION = version.split("-")[0].replace("saas~", "")
+GPGPASSPHRASE = os.getenv("GPGPASSPHRASE")
+GPGID = os.getenv("GPGID")
+DOCKERVERSION = VERSION.replace("+", "")
 INSTALL_TIMEOUT = 600
 
 DOCKERUSER = """
@@ -43,7 +43,10 @@ RUN mkdir /var/lib/odoo && \
     mkdir /data && \
     chown odoo:odoo /var/lib/odoo /data
 USER odoo
-""" % {'group_id': os.getgid(), 'user_id': os.getuid()}
+""" % {
+    "group_id": os.getgid(),
+    "user_id": os.getuid(),
+}
 
 
 class OdooTestTimeoutError(Exception):
@@ -55,28 +58,44 @@ class OdooTestError(Exception):
 
 
 def run_cmd(cmd, chdir=None, timeout=None):
-    logging.info("Running command: '%s'", ' '.join(cmd))
+    logging.info("Running command: '%s'", " ".join(cmd))
     return subprocess.run(cmd, cwd=chdir, timeout=timeout)
 
 
-def _rpc_count_modules(addr='http://127.0.0.1', port=8069, dbname='mycompany'):
+def _rpc_count_modules(addr="http://127.0.0.1", port=8069, dbname="mycompany"):
     time.sleep(5)
-    uid = xmlrpclib.ServerProxy('%s:%s/xmlrpc/2/common' % (addr, port)).authenticate(
-        dbname, 'admin', 'admin', {}
+    uid = xmlrpclib.ServerProxy("%s:%s/xmlrpc/2/common" % (addr, port)).authenticate(
+        dbname, "admin", "admin", {}
     )
-    modules = xmlrpclib.ServerProxy('%s:%s/xmlrpc/2/object' % (addr, port)).execute(
-        dbname, uid, 'admin', 'ir.module.module', 'search', [('state', '=', 'installed')]
+    modules = xmlrpclib.ServerProxy("%s:%s/xmlrpc/2/object" % (addr, port)).execute(
+        dbname,
+        uid,
+        "admin",
+        "ir.module.module",
+        "search",
+        [("state", "=", "installed")],
     )
     if len(modules) > 1:
         time.sleep(1)
-        toinstallmodules = xmlrpclib.ServerProxy('%s:%s/xmlrpc/2/object' % (addr, port)).execute(
-            dbname, uid, 'admin', 'ir.module.module', 'search', [('state', '=', 'to install')]
+        toinstallmodules = xmlrpclib.ServerProxy(
+            "%s:%s/xmlrpc/2/object" % (addr, port)
+        ).execute(
+            dbname,
+            uid,
+            "admin",
+            "ir.module.module",
+            "search",
+            [("state", "=", "to install")],
         )
         if toinstallmodules:
-            logging.error("Package test: FAILED. Not able to install dependencies of base.")
+            logging.error(
+                "Package test: FAILED. Not able to install dependencies of base."
+            )
             raise OdooTestError("Installation of package failed")
         else:
-            logging.info("Package test: successfuly installed %s modules" % len(modules))
+            logging.info(
+                "Package test: successfuly installed %s modules" % len(modules)
+            )
     else:
         logging.error("Package test: FAILED. Not able to install base.")
         raise OdooTestError("Package test: FAILED. Not able to install base.")
@@ -89,6 +108,7 @@ def publish(args, pub_type, extensions):
     :extensions: list of extensions to publish
     :returns: published files
     """
+
     def _publish(release):
         build_path = os.path.join(args.build_dir, release)
         filename = release.split(os.path.sep)[-1]
@@ -98,7 +118,7 @@ def publish(args, pub_type, extensions):
 
         # Latest/symlink handler
         release_abspath = os.path.abspath(release_path)
-        latest_abspath = release_abspath.replace(TSTAMP, 'latest')
+        latest_abspath = release_abspath.replace(TSTAMP, "latest")
 
         if os.path.islink(latest_abspath):
             os.unlink(latest_abspath)
@@ -121,20 +141,23 @@ def gen_deb_package(args, published_files):
     # Executes command to produce file_name in path, and moves it to args.pub/deb
     def _gen_file(args, command, file_name, path):
         cur_tmp_file_path = os.path.join(path, file_name)
-        with open(cur_tmp_file_path, 'w') as out:
+        with open(cur_tmp_file_path, "w") as out:
             subprocess.call(command, stdout=out, cwd=path)
-        shutil.copy(cur_tmp_file_path, os.path.join(args.pub, 'deb', file_name))
+        shutil.copy(cur_tmp_file_path, os.path.join(args.pub, "deb", file_name))
 
     # Copy files to a temp directory (required because the working directory must contain only the
     # files of the last release)
-    temp_path = tempfile.mkdtemp(suffix='debPackages')
+    temp_path = tempfile.mkdtemp(suffix="debPackages")
     for pub_file_path in published_files:
         shutil.copy(pub_file_path, temp_path)
 
     commands = [
-        (['dpkg-scanpackages', '--multiversion', '.'], "Packages"),  # Generate Packages file
-        (['dpkg-scansources', '.'], "Sources"),  # Generate Sources file
-        (['apt-ftparchive', 'release', '.'], "Release")  # Generate Release file
+        (
+            ["dpkg-scanpackages", "--multiversion", "."],
+            "Packages",
+        ),  # Generate Packages file
+        (["dpkg-scansources", "."], "Sources"),  # Generate Sources file
+        (["apt-ftparchive", "release", "."], "Release"),  # Generate Release file
     ]
     # Generate files
     for command in commands:
@@ -145,7 +168,22 @@ def gen_deb_package(args, published_files):
     if args.sign:
         # Generate Release.gpg (= signed Release)
         # Options -abs: -a (Create ASCII armored output), -b (Make a detach signature), -s (Make a signature)
-        subprocess.call(['gpg', '--default-key', GPGID, '--passphrase', GPGPASSPHRASE, '--yes', '-abs', '--no-tty', '-o', 'Release.gpg', 'Release'], cwd=os.path.join(args.pub, 'deb'))
+        subprocess.call(
+            [
+                "gpg",
+                "--default-key",
+                GPGID,
+                "--passphrase",
+                GPGPASSPHRASE,
+                "--yes",
+                "-abs",
+                "--no-tty",
+                "-o",
+                "Release.gpg",
+                "Release",
+            ],
+            cwd=os.path.join(args.pub, "deb"),
+        )
 
 
 # ---------------------------------------------------------
@@ -154,26 +192,54 @@ def gen_deb_package(args, published_files):
 def rpm_sign(args, file_name):
     """Genereate a rpm repo in publish directory"""
     # Sign the RPM
-    rpmsign = pexpect.spawn('/bin/bash', ['-c', 'rpm --resign %s' % file_name], cwd=os.path.join(args.pub, 'rpm'))
-    rpmsign.expect_exact('Enter passphrase: ')
-    rpmsign.send(GPGPASSPHRASE + '\r\n')
+    rpmsign = pexpect.spawn(
+        "/bin/bash",
+        ["-c", "rpm --resign %s" % file_name],
+        cwd=os.path.join(args.pub, "rpm"),
+    )
+    rpmsign.expect_exact("Enter passphrase: ")
+    rpmsign.send(GPGPASSPHRASE + "\r\n")
     rpmsign.expect(pexpect.EOF)
 
 
 def _prepare_build_dir(args, win32=False, move_addons=True):
     """Copy files to the build directory"""
     logging.info('Preparing build dir "%s"', args.build_dir)
-    cmd = ['rsync', '-a', '--delete', '--exclude', '.git', '--exclude', '*.pyc', '--exclude', '*.pyo']
+    cmd = [
+        "rsync",
+        "-a",
+        "--delete",
+        "--exclude",
+        ".git",
+        "--exclude",
+        "Dockerfile",
+        "--exclude",
+        ".github",
+        "--exclude",
+        ".gitea",
+        "--exclude",
+        "*.pyc",
+        "--exclude",
+        "*.pyo",
+        "--exclude",
+        "automation",
+        "--exclude",
+        "extra-addons",
+        "--exclude",
+        "exercise",
+        "--exclude",
+        "deployment",
+    ]
     if win32 is False:
-        cmd += ['--exclude', 'setup/win32']
+        cmd += ["--exclude", "setup/win32"]
 
-    run_cmd(cmd + ['%s/' % args.odoo_dir, args.build_dir])
+    run_cmd(cmd + ["%s/" % args.odoo_dir, args.build_dir])
     if not move_addons:
         return
-    for addon_path in glob(os.path.join(args.build_dir, 'addons/*')):
+    for addon_path in glob(os.path.join(args.build_dir, "addons/*")):
         if args.blacklist is None or os.path.basename(addon_path) not in args.blacklist:
             try:
-                shutil.move(addon_path, os.path.join(args.build_dir, 'odoo/addons'))
+                shutil.move(addon_path, os.path.join(args.build_dir, "odoo/addons"))
             except shutil.Error as e:
                 logging.warning("Warning '%s' while moving addon '%s", e, addon_path)
                 if addon_path.startswith(args.build_dir) and os.path.isdir(addon_path):
@@ -181,12 +247,15 @@ def _prepare_build_dir(args, win32=False, move_addons=True):
                     try:
                         shutil.rmtree(addon_path)
                     except shutil.Error as rm_error:
-                        logging.warning("Cannot remove '{}': {}".format(addon_path, rm_error))
+                        logging.warning(
+                            "Cannot remove '{}': {}".format(addon_path, rm_error)
+                        )
 
 
 #  Docker stuffs
-class Docker():
+class Docker:
     """Base Docker class. Must be inherited by specific Docker builder class"""
+
     arch = None
 
     def __init__(self, args):
@@ -194,31 +263,50 @@ class Docker():
         :param args: argparse parsed arguments
         """
         self.args = args
-        self.tag = 'odoo-%s-%s-nightly-tests' % (DOCKERVERSION, self.arch)
+        self.tag = "odoo-%s-%s-nightly-tests" % (DOCKERVERSION, self.arch)
         self.container_name = None
         self.exposed_port = None
         docker_templates = {
-            'tgz': os.path.join(args.build_dir, 'setup/package.dfsrc'),
-            'deb': os.path.join(args.build_dir, 'setup/package.dfdebian'),
-            'rpm': os.path.join(args.build_dir, 'setup/package.dffedora'),
-            'win': os.path.join(args.build_dir, 'setup/package.dfwine'),
+            "tgz": os.path.join(args.build_dir, "setup/package.dfsrc"),
+            "deb": os.path.join(args.build_dir, "setup/package.dfdebian"),
+            "rpm": os.path.join(args.build_dir, "setup/package.dffedora"),
+            "win": os.path.join(args.build_dir, "setup/package.dfwine"),
         }
-        self.docker_template = Path(docker_templates[self.arch]).read_text(encoding='utf-8').replace('USER odoo', DOCKERUSER)
-        self.test_log_file = '/data/src/test-%s.log' % self.arch
-        self.docker_dir = Path(self.args.build_dir) / 'docker'
+        self.docker_template = (
+            Path(docker_templates[self.arch])
+            .read_text(encoding="utf-8")
+            .replace("USER odoo", DOCKERUSER)
+        )
+        self.test_log_file = "/data/src/test-%s.log" % self.arch
+        self.docker_dir = Path(self.args.build_dir) / "docker"
         if not self.docker_dir.exists():
             self.docker_dir.mkdir()
         self.build_image()
 
     def build_image(self):
         """Build the dockerimage by copying Dockerfile into build_dir/docker"""
-        docker_file = self.docker_dir / 'Dockerfile'
+        docker_file = self.docker_dir / "Dockerfile"
         docker_file.write_text(self.docker_template)
-        shutil.copy(os.path.join(self.args.build_dir, 'requirements.txt'), self.docker_dir)
-        run_cmd(["docker", "build", "--rm=True", "-t", self.tag, "."], chdir=self.docker_dir, timeout=1200).check_returncode()
+        shutil.copy(
+            os.path.join(self.args.build_dir, "requirements.txt"), self.docker_dir
+        )
+        run_cmd(
+            ["docker", "build", "--rm=True", "-t", self.tag, "."],
+            chdir=self.docker_dir,
+            timeout=1200,
+        ).check_returncode()
         shutil.rmtree(self.docker_dir)
 
-    def run(self, cmd, build_dir, container_name, user='odoo', exposed_port=None, detach=False, timeout=None):
+    def run(
+        self,
+        cmd,
+        build_dir,
+        container_name,
+        user="odoo",
+        exposed_port=None,
+        detach=False,
+        timeout=None,
+    ):
         self.container_name = container_name
         docker_cmd = [
             "docker",
@@ -226,38 +314,37 @@ class Docker():
             "--user=%s" % user,
             "--name=%s" % container_name,
             "--rm",
-            "--volume=%s:/data/src" % build_dir
+            "--volume=%s:/data/src" % build_dir,
         ]
 
         if exposed_port:
-            docker_cmd.extend(['-p', '127.0.0.1:%s:%s' % (exposed_port, exposed_port)])
+            docker_cmd.extend(["-p", "127.0.0.1:%s:%s" % (exposed_port, exposed_port)])
             self.exposed_port = exposed_port
         if detach:
-            docker_cmd.append('-d')
+            docker_cmd.append("-d")
             # preserve logs in case of detached docker container
-            cmd = '(%s) > %s 2>&1' % (cmd, self.test_log_file)
+            cmd = "(%s) > %s 2>&1" % (cmd, self.test_log_file)
 
-        docker_cmd.extend([
-            self.tag,
-            "/bin/bash",
-            "-c",
-            "cd /data/src && %s" % cmd
-        ])
+        docker_cmd.extend([self.tag, "/bin/bash", "-c", "cd /data/src && %s" % cmd])
         run_cmd(docker_cmd, timeout=timeout).check_returncode()
 
     def is_running(self):
-        dinspect = subprocess.run(['docker', 'container', 'inspect', self.container_name], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+        dinspect = subprocess.run(
+            ["docker", "container", "inspect", self.container_name],
+            stderr=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+        )
         return True if dinspect.returncode == 0 else False
 
     def stop(self):
         run_cmd(["docker", "stop", self.container_name]).check_returncode()
 
     def test_odoo(self):
-        logging.info('Starting to test Odoo install test')
+        logging.info("Starting to test Odoo install test")
         start_time = time.time()
         while self.is_running() and (time.time() - start_time) < INSTALL_TIMEOUT:
             time.sleep(5)
-            if os.path.exists(os.path.join(args.build_dir, 'odoo.pid')):
+            if os.path.exists(os.path.join(args.build_dir, "odoo.pid")):
                 try:
                     _rpc_count_modules(port=self.exposed_port)
                 finally:
@@ -265,8 +352,13 @@ class Docker():
                 return
         if self.is_running():
             self.stop()
-            raise OdooTestTimeoutError('Odoo pid file never appeared after %s sec' % INSTALL_TIMEOUT)
-        raise OdooTestError('Error while installing/starting Odoo after %s sec.\nSee testlogs.txt in build dir' % int(time.time() - start_time))
+            raise OdooTestTimeoutError(
+                "Odoo pid file never appeared after %s sec" % INSTALL_TIMEOUT
+            )
+        raise OdooTestError(
+            "Error while installing/starting Odoo after %s sec.\nSee testlogs.txt in build dir"
+            % int(time.time() - start_time)
+        )
 
     def build(self):
         """To be overriden by specific builder"""
@@ -280,21 +372,31 @@ class Docker():
 class DockerTgz(Docker):
     """Docker class to build python src package"""
 
-    arch = 'tgz'
+    arch = "tgz"
 
     def build(self):
-        logging.info('Start building python tgz package')
-        self.run('python3 setup.py sdist --quiet --formats=gztar,zip', self.args.build_dir, 'odoo-src-build-%s' % TSTAMP)
-        os.rename(glob('%s/dist/odoo-*.tar.gz' % self.args.build_dir)[0], '%s/odoo_%s.%s.tar.gz' % (self.args.build_dir, VERSION, TSTAMP))
-        os.rename(glob('%s/dist/odoo-*.zip' % self.args.build_dir)[0], '%s/odoo_%s.%s.zip' % (self.args.build_dir, VERSION, TSTAMP))
-        logging.info('Finished building python tgz package')
+        logging.info("Start building python tgz package")
+        self.run(
+            "python3 setup.py sdist --quiet --formats=gztar,zip",
+            self.args.build_dir,
+            "odoo-src-build-%s" % TSTAMP,
+        )
+        os.rename(
+            glob("%s/dist/odoo-*.tar.gz" % self.args.build_dir)[0],
+            "%s/odoo_%s.%s.tar.gz" % (self.args.build_dir, VERSION, TSTAMP),
+        )
+        os.rename(
+            glob("%s/dist/odoo-*.zip" % self.args.build_dir)[0],
+            "%s/odoo_%s.%s.zip" % (self.args.build_dir, VERSION, TSTAMP),
+        )
+        logging.info("Finished building python tgz package")
 
     def start_test(self):
         if not self.args.test:
             return
-        logging.info('Start testing python tgz package')
+        logging.info("Start testing python tgz package")
         cmds = [
-            'service postgresql start',
+            "service postgresql start",
             'su postgres -s /bin/bash -c "createuser -s odoo"',
             'su odoo -s /bin/bash -c "python3 -m venv /var/lib/odoo/odoovenv"',
             'su odoo -s /bin/bash -c "/var/lib/odoo/odoovenv/bin/python3 -m pip install --upgrade pip"',
@@ -304,92 +406,122 @@ class DockerTgz(Docker):
             'su odoo -s /bin/bash -c "/var/lib/odoo/odoovenv/bin/odoo -d mycompany -i base --stop-after-init"',
             'su odoo -s /bin/bash -c "/var/lib/odoo/odoovenv/bin/odoo -d mycompany --pidfile=/data/src/odoo.pid"',
         ]
-        self.run(' && '.join(cmds), self.args.build_dir, 'odoo-src-test-%s' % TSTAMP, user='root', detach=True, exposed_port=8069, timeout=300)
+        self.run(
+            " && ".join(cmds),
+            self.args.build_dir,
+            "odoo-src-test-%s" % TSTAMP,
+            user="root",
+            detach=True,
+            exposed_port=8069,
+            timeout=300,
+        )
         self.test_odoo()
-        logging.info('Finished testing tgz package')
+        logging.info("Finished testing tgz package")
 
 
 class DockerDeb(Docker):
     """Docker class to build debian package"""
 
-    arch = 'deb'
+    arch = "deb"
 
     def build(self):
-        logging.info('Start building debian package')
+        logging.info("Start building debian package")
         # Append timestamp to version for the .dsc to refer the right .tar.gz
-        cmds = ["sed -i '1s/^.*$/odoo (%s.%s) stable; urgency=low/' debian/changelog" % (VERSION, TSTAMP)]
-        cmds.append('dpkg-buildpackage -rfakeroot -uc -us -tc')
+        cmds = [
+            "sed -i '1s/^.*$/odoo (%s.%s) stable; urgency=low/' debian/changelog"
+            % (VERSION, TSTAMP)
+        ]
+        cmds.append("dpkg-buildpackage -rfakeroot -uc -us -tc")
         # As the packages are built in the parent of the buildir, we move them back to build_dir
-        cmds.append('mv ../odoo_* ./')
-        self.run(' && '.join(cmds), self.args.build_dir, 'odoo-deb-build-%s' % TSTAMP)
-        logging.info('Finished building debian package')
+        cmds.append("mv ../odoo_* ./")
+        self.run(" && ".join(cmds), self.args.build_dir, "odoo-deb-build-%s" % TSTAMP)
+        logging.info("Finished building debian package")
 
     def start_test(self):
         if not self.args.test:
             return
-        logging.info('Start testing debian package')
+        logging.info("Start testing debian package")
         cmds = [
-            'service postgresql start',
-            '/usr/bin/apt-get update -y',
-            f'/usr/bin/apt-get install -y /data/src/odoo_{VERSION}.{TSTAMP}_all.deb',
+            "service postgresql start",
+            "/usr/bin/apt-get update -y",
+            f"/usr/bin/apt-get install -y /data/src/odoo_{VERSION}.{TSTAMP}_all.deb",
             'su odoo -s /bin/bash -c "odoo -d mycompany -i base --pidfile=/data/src/odoo.pid"',
         ]
-        self.run(' && '.join(cmds), self.args.build_dir, 'odoo-deb-test-%s' % TSTAMP, user='root', detach=True, exposed_port=8069, timeout=300)
+        self.run(
+            " && ".join(cmds),
+            self.args.build_dir,
+            "odoo-deb-test-%s" % TSTAMP,
+            user="root",
+            detach=True,
+            exposed_port=8069,
+            timeout=300,
+        )
         self.test_odoo()
-        logging.info('Finished testing debian package')
+        logging.info("Finished testing debian package")
 
 
 class DockerRpm(Docker):
     """Docker class to build rpm package"""
 
-    arch = 'rpm'
+    arch = "rpm"
 
     def build(self):
-        logging.info('Start building fedora rpm package')
-        rpmbuild_dir = '/var/lib/odoo/rpmbuild'
+        logging.info("Start building fedora rpm package")
+        rpmbuild_dir = "/var/lib/odoo/rpmbuild"
         cmds = [
-            'cd /data/src',
-            'mkdir -p dist',
-            'rpmdev-setuptree -d',
-            f'cp -a /data/src/setup/rpm/odoo.spec {rpmbuild_dir}/SPECS/',
+            "cd /data/src",
+            "mkdir -p dist",
+            "rpmdev-setuptree -d",
+            f"cp -a /data/src/setup/rpm/odoo.spec {rpmbuild_dir}/SPECS/",
             f'tar --transform "s/^\\./odoo-{VERSION}/" -c -z -f {rpmbuild_dir}/SOURCES/odoo-{VERSION}.tar.gz .',
             f'rpmbuild -bb --define="%version {VERSION}" /data/src/setup/rpm/odoo.spec',
-            f'mv {rpmbuild_dir}/RPMS/noarch/odoo*.rpm /data/src/dist/'
+            f"mv {rpmbuild_dir}/RPMS/noarch/odoo*.rpm /data/src/dist/",
         ]
-        self.run(' && '.join(cmds), self.args.build_dir, f'odoo-rpm-build-{TSTAMP}')
-        os.rename(glob('%s/dist/odoo-*.noarch.rpm' % self.args.build_dir)[0], '%s/odoo_%s.%s.rpm' % (self.args.build_dir, VERSION, TSTAMP))
-        logging.info('Finished building fedora rpm package')
+        self.run(" && ".join(cmds), self.args.build_dir, f"odoo-rpm-build-{TSTAMP}")
+        os.rename(
+            glob("%s/dist/odoo-*.noarch.rpm" % self.args.build_dir)[0],
+            "%s/odoo_%s.%s.rpm" % (self.args.build_dir, VERSION, TSTAMP),
+        )
+        logging.info("Finished building fedora rpm package")
 
     def start_test(self):
         if not self.args.test:
             return
-        logging.info('Start testing rpm package')
+        logging.info("Start testing rpm package")
         cmds = [
             'su postgres -c "/usr/bin/pg_ctl -D /var/lib/postgres/data start"',
-            'sleep 5',
+            "sleep 5",
             'su postgres -c "createuser -s odoo"',
             'su odoo -c "createdb mycompany"',
-            'dnf install -d 0 -e 0 /data/src/odoo_%s.%s.rpm -y' % (VERSION, TSTAMP),
+            "dnf install -d 0 -e 0 /data/src/odoo_%s.%s.rpm -y" % (VERSION, TSTAMP),
             'su odoo -s /bin/bash -c "odoo -c /etc/odoo/odoo.conf -d mycompany -i base --stop-after-init"',
             'su odoo -s /bin/bash -c "odoo -c /etc/odoo/odoo.conf -d mycompany --pidfile=/data/src/odoo.pid"',
         ]
-        self.run(' && '.join(cmds), args.build_dir, 'odoo-rpm-test-%s' % TSTAMP, user='root', detach=True, exposed_port=8069, timeout=300)
+        self.run(
+            " && ".join(cmds),
+            args.build_dir,
+            "odoo-rpm-test-%s" % TSTAMP,
+            user="root",
+            detach=True,
+            exposed_port=8069,
+            timeout=300,
+        )
         self.test_odoo()
-        logging.info('Finished testing rpm package')
+        logging.info("Finished testing rpm package")
 
     def gen_rpm_repo(self, args, rpm_filepath):
-        pub_repodata_path = os.path.join(args.pub, 'rpm', 'repodata')
+        pub_repodata_path = os.path.join(args.pub, "rpm", "repodata")
         # Removes the old repodata
         if os.path.isdir(pub_repodata_path):
             shutil.rmtree(pub_repodata_path)
 
         # Copy files to a temp directory (required because the working directory must contain only the
         # files of the last release)
-        temp_path = tempfile.mkdtemp(suffix='rpmPackages')
+        temp_path = tempfile.mkdtemp(suffix="rpmPackages")
         shutil.copy(rpm_filepath, temp_path)
 
-        logging.info('Start creating rpm repo')
-        self.run('createrepo /data/src/', temp_path, 'odoo-rpm-createrepo-%s' % TSTAMP)
+        logging.info("Start creating rpm repo")
+        self.run("createrepo /data/src/", temp_path, "odoo-rpm-createrepo-%s" % TSTAMP)
         shutil.copytree(os.path.join(temp_path, "repodata"), pub_repodata_path)
 
         # Remove temp directory
@@ -399,46 +531,84 @@ class DockerRpm(Docker):
 class DockerWine(Docker):
     """Docker class to build Windows package"""
 
-    arch = 'win'
+    arch = "win"
 
     def build_image(self):
-        shutil.copy(os.path.join(self.args.build_dir, 'setup/win32/requirements-local-proxy.txt'), self.docker_dir)
+        shutil.copy(
+            os.path.join(
+                self.args.build_dir, "setup/win32/requirements-local-proxy.txt"
+            ),
+            self.docker_dir,
+        )
         super().build_image()
 
     def build(self):
-        logging.info('Start building windows package')
-        winver = "%s.%s" % (VERSION.replace('~', '_').replace('+', ''), TSTAMP)
-        container_python = '/var/lib/odoo/.wine/drive_c/odoobuild/WinPy64/python-3.12.3.amd64/python.exe'
-        nsis_args = f'/DVERSION={winver} /DMAJOR_VERSION={version_info[0]} /DMINOR_VERSION={version_info[1]} /DSERVICENAME={nt_service_name} /DPYTHONVERSION=3.12.3'
+        logging.info("Start building windows package")
+        winver = "%s.%s" % (VERSION.replace("~", "_").replace("+", ""), TSTAMP)
+        container_python = "/var/lib/odoo/.wine/drive_c/odoobuild/WinPy64/python-3.12.3.amd64/python.exe"
+        nsis_args = f"/DVERSION={winver} /DMAJOR_VERSION={version_info[0]} /DMINOR_VERSION={version_info[1]} /DSERVICENAME={nt_service_name} /DPYTHONVERSION=3.12.3"
         cmds = [
-            rf'wine {container_python} -m pip install --upgrade pip',
+            rf"wine {container_python} -m pip install --upgrade pip",
             rf'cat /data/src/requirements*.txt  | while read PACKAGE; do wine {container_python} -m pip install "${{PACKAGE%%#*}}" ; done',
             rf'wine "c:\nsis-3.10\makensis.exe" {nsis_args} "c:\odoobuild\server\setup\win32\setup.nsi"',
-            rf'wine {container_python} -m pip list'
+            rf"wine {container_python} -m pip list",
         ]
-        self.run(' && '.join(cmds), self.args.build_dir, 'odoo-win-build-%s' % TSTAMP)
-        logging.info('Finished building Windows package')
+        self.run(" && ".join(cmds), self.args.build_dir, "odoo-win-build-%s" % TSTAMP)
+        logging.info("Finished building Windows package")
+
 
 def parse_args():
     ap = argparse.ArgumentParser()
     build_dir = "%s-%s-%s" % (ROOTDIR, TSEC, TSTAMP)
-    log_levels = {"debug": logging.DEBUG, "info": logging.INFO, "warning": logging.WARN, "error": logging.ERROR, "critical": logging.CRITICAL}
+    log_levels = {
+        "debug": logging.DEBUG,
+        "info": logging.INFO,
+        "warning": logging.WARN,
+        "error": logging.ERROR,
+        "critical": logging.CRITICAL,
+    }
 
-    ap.add_argument("-b", "--build-dir", default=build_dir, help="build directory (%(default)s)", metavar="DIR")
-    ap.add_argument("-p", "--pub", default=None, help="pub directory %(default)s", metavar="DIR")
-    ap.add_argument("--logging", action="store", choices=list(log_levels.keys()), default="info", help="Logging level")
+    ap.add_argument(
+        "-b",
+        "--build-dir",
+        default=build_dir,
+        help="build directory (%(default)s)",
+        metavar="DIR",
+    )
+    ap.add_argument(
+        "-p", "--pub", default=None, help="pub directory %(default)s", metavar="DIR"
+    )
+    ap.add_argument(
+        "--logging",
+        action="store",
+        choices=list(log_levels.keys()),
+        default="info",
+        help="Logging level",
+    )
     ap.add_argument("--build-deb", action="store_true")
     ap.add_argument("--build-rpm", action="store_true")
     ap.add_argument("--build-tgz", action="store_true")
     ap.add_argument("--build-win", action="store_true")
 
-    ap.add_argument("-t", "--test", action="store_true", default=False, help="Test built packages")
-    ap.add_argument("-s", "--sign", action="store_true", default=False, help="Sign Debian package / generate Rpm repo")
+    ap.add_argument(
+        "-t", "--test", action="store_true", default=False, help="Test built packages"
+    )
+    ap.add_argument(
+        "-s",
+        "--sign",
+        action="store_true",
+        default=False,
+        help="Sign Debian package / generate Rpm repo",
+    )
     ap.add_argument("--no-remove", action="store_true", help="don't remove build dir")
     ap.add_argument("--blacklist", nargs="*", help="Modules to blacklist in package")
 
     parsed_args = ap.parse_args()
-    logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %I:%M:%S', level=log_levels[parsed_args.logging])
+    logging.basicConfig(
+        format="%(asctime)s %(levelname)s: %(message)s",
+        datefmt="%Y-%m-%d %I:%M:%S",
+        level=log_levels[parsed_args.logging],
+    )
     parsed_args.odoo_dir = ROOTDIR
     return parsed_args
 
@@ -451,7 +621,7 @@ def main(args):
             docker_tgz.build()
             try:
                 docker_tgz.start_test()
-                published_files = publish(args, 'tgz', ['tar.gz', 'zip'])
+                published_files = publish(args, "tgz", ["tar.gz", "zip"])
             except Exception as e:
                 logging.error("Won't publish the tgz release.\n Exception: %s" % str(e))
         if args.build_rpm:
@@ -460,11 +630,11 @@ def main(args):
             docker_rpm.build()
             try:
                 docker_rpm.start_test()
-                published_files = publish(args, 'rpm', ['rpm'])
+                published_files = publish(args, "rpm", ["rpm"])
                 if args.sign:
-                    logging.info('Signing rpm package')
+                    logging.info("Signing rpm package")
                     rpm_sign(args, published_files[0])
-                    logging.info('Generate rpm repo')
+                    logging.info("Generate rpm repo")
                     docker_rpm.gen_rpm_repo(args, published_files[0])
             except Exception as e:
                 logging.error("Won't publish the rpm release.\n Exception: %s" % str(e))
@@ -474,7 +644,9 @@ def main(args):
             docker_deb.build()
             try:
                 docker_deb.start_test()
-                published_files = publish(args, 'deb', ['deb', 'dsc', 'changes', 'tar.xz'])
+                published_files = publish(
+                    args, "deb", ["deb", "dsc", "changes", "tar.xz"]
+                )
                 gen_deb_package(args, published_files)
             except Exception as e:
                 logging.error("Won't publish the deb release.\n Exception: %s" % str(e))
@@ -483,11 +655,11 @@ def main(args):
             docker_wine = DockerWine(args)
             docker_wine.build()
             try:
-                published_files = publish(args, 'windows', ['exe'])
+                published_files = publish(args, "windows", ["exe"])
             except Exception as e:
                 logging.error("Won't publish the exe release.\n Exception: %s" % str(e))
     except Exception as e:
-        logging.error('Something bad happened ! : {}'.format(e))
+        logging.error("Something bad happened ! : {}".format(e))
         traceback.print_exc()
     finally:
         if args.no_remove:
@@ -495,10 +667,10 @@ def main(args):
         else:
             if os.path.exists(args.build_dir):
                 shutil.rmtree(args.build_dir)
-                logging.info('Build dir %s removed' % args.build_dir)
+                logging.info("Build dir %s removed" % args.build_dir)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     args = parse_args()
     if os.path.exists(args.build_dir):
         logging.error('Build dir "%s" already exists.', args.build_dir)