Mathieu Benoit
2a5e83b5c7
The root pyproject.toml and poetry.lock are unversioned symlinks to the active version's files in requirement/, created by the version switch. Without them the script died on a FileNotFoundError traceback. It now names the fix, make switch_odoo_XX for the active Odoo version; on a terminal it offers to run it and restarts with the same arguments. Checked: an existing file passes, a missing one exits 1 off a terminal and on a declined prompt. The accepted path, which runs the switch, is not tested. --- FR --- [FIX] poetry update : arrêt sur pyproject.toml absent, switch proposé pyproject.toml et poetry.lock à la racine sont des liens non versionnés vers les fichiers de la version active dans requirement/, créés par le switch de version. Sans eux, le script mourait sur un FileNotFoundError. Il nomme désormais le remède, make switch_odoo_XX pour la version Odoo active ; dans un terminal, il propose de le lancer et se relance avec les mêmes arguments. Vérifié : un fichier présent passe, un absent sort en 1 hors terminal et sur un refus. L'acceptation, qui lance le switch, n'est pas testée. Assisted-by: Claude Opus 5.5
747 lines
30 KiB
Python
Executable file
747 lines
30 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
# © 2021-2026 TechnoLibre (http://www.technolibre.ca)
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
|
|
|
|
import argparse
|
|
import ast
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import sys
|
|
from collections import OrderedDict, defaultdict
|
|
from pathlib import Path
|
|
|
|
import iscompatible
|
|
import toml
|
|
from colorama import Fore, Style
|
|
from packaging.markers import default_environment
|
|
from packaging.requirements import Requirement
|
|
from packaging.version import Version
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
_logger.setLevel(logging.INFO)
|
|
|
|
|
|
def get_config():
|
|
"""Parse command line arguments, extracting the config file name,
|
|
returning the union of config file and command line arguments
|
|
|
|
:return: dict of config file settings and command line arguments
|
|
"""
|
|
parser = argparse.ArgumentParser(
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
description="""\
|
|
Update pip dependency in Poetry, clear pyproject.toml, search all dependencies
|
|
from requirements.txt, search conflict version and generate a new list.
|
|
Launch Poetry installation.
|
|
""",
|
|
epilog="""\
|
|
""",
|
|
)
|
|
parser.add_argument(
|
|
"-d",
|
|
"--dir",
|
|
dest="dir",
|
|
default="./",
|
|
help="Path of repo to change remote, including submodule.",
|
|
)
|
|
parser.add_argument(
|
|
"-f",
|
|
"--force",
|
|
action="store_true",
|
|
help="Force create new list of dependency, ignore poetry.lock.",
|
|
)
|
|
parser.add_argument(
|
|
"-v",
|
|
"--verbose",
|
|
action="store_true",
|
|
help="More information in execution, show stats.",
|
|
)
|
|
parser.add_argument(
|
|
"--dry",
|
|
action="store_true",
|
|
help="Don't apply change, only show warning.",
|
|
)
|
|
parser.add_argument(
|
|
"--set_version_poetry",
|
|
help="Force to change poetry version, default is from file './.poetry-version'.",
|
|
)
|
|
parser.add_argument(
|
|
"--set_version_odoo",
|
|
help="Force to change odoo version, default is from file './.odoo-version'.",
|
|
)
|
|
parser.add_argument(
|
|
"--set_version_python",
|
|
help="Force to change python version, default is from file './.python-odoo-version'.",
|
|
)
|
|
parser.add_argument(
|
|
"--set_version_erplibre",
|
|
help="Force to change erplibre version, default is from file './.erplibre-version'.",
|
|
)
|
|
args = parser.parse_args()
|
|
if not args.set_version_poetry:
|
|
with open("./.poetry-version", "r", encoding="utf-8") as fichier:
|
|
args.set_version_poetry = fichier.read().strip()
|
|
if not args.set_version_odoo:
|
|
with open("./.odoo-version", "r", encoding="utf-8") as fichier:
|
|
args.set_version_odoo = fichier.read().strip()
|
|
if not args.set_version_python:
|
|
with open("./.python-odoo-version", "r", encoding="utf-8") as fichier:
|
|
args.set_version_python = fichier.read().strip()
|
|
if not args.set_version_erplibre:
|
|
with open("./.erplibre-version", "r", encoding="utf-8") as fichier:
|
|
args.set_version_erplibre = fichier.read().strip()
|
|
return args
|
|
|
|
|
|
def get_lst_requirements_txt(
|
|
config, ignore_dir_startswith: list = None, force_add_item: list = None
|
|
):
|
|
return get_file_from_glob(
|
|
config,
|
|
"requirements.[tT][xX][tT]",
|
|
ignore_dir_startswith=ignore_dir_startswith,
|
|
force_add_item=force_add_item,
|
|
)
|
|
|
|
|
|
def get_lst_manifest_py(config, ignore_dir_startswith: list = None):
|
|
return get_file_from_glob(
|
|
config, "__manifest__.py", ignore_dir_startswith=ignore_dir_startswith
|
|
)
|
|
|
|
|
|
def get_file_from_glob(
|
|
config,
|
|
glob_txt,
|
|
ignore_dir_startswith: list = None,
|
|
force_add_item: list = None,
|
|
):
|
|
lst_v = []
|
|
# TODO take all groups odoo##.# from manifest, will create a dependency
|
|
# Hardcode logic from manifest
|
|
lst_path = [
|
|
Path(f"./odoo{config.set_version_odoo}/addons").rglob(glob_txt),
|
|
Path(f"./odoo{config.set_version_odoo}/odoo").rglob(glob_txt),
|
|
]
|
|
for gen_path in lst_path:
|
|
for a in gen_path:
|
|
a_dirname = os.path.dirname(a)
|
|
if a_dirname.startswith(".repo/") or a_dirname.startswith(".venv"):
|
|
continue
|
|
if ignore_dir_startswith:
|
|
ignore_it = False
|
|
for item_ignore_dir in ignore_dir_startswith:
|
|
if a_dirname.startswith(item_ignore_dir):
|
|
ignore_it = True
|
|
break
|
|
if ignore_it:
|
|
continue
|
|
lst_v.append(a)
|
|
if force_add_item:
|
|
for item in force_add_item:
|
|
lst_v.append(Path(item))
|
|
return lst_v
|
|
|
|
|
|
def combine_requirements(config):
|
|
"""
|
|
Search all module and version in all requirements.txt file in this project.
|
|
For each version, check compatibility and show warning with provenance file
|
|
Generate requirements.txt to "./.venv/build_dependency.txt"
|
|
:param config:
|
|
:return:
|
|
"""
|
|
priority_filename_requirement = (
|
|
f"requirement/requirements.{config.set_version_erplibre}.txt"
|
|
)
|
|
second_priority_filename_requirement = (
|
|
f"odoo{config.set_version_odoo}/odoo/requirements.txt"
|
|
)
|
|
except_sign = ";"
|
|
lst_sign = ("==", "!=", ">=", "<=", "<", ">", except_sign, "~=")
|
|
lst_requirements = []
|
|
lst_replace_special_sign = {}
|
|
ignore_requirements = ["sys_platform == 'win32'", "python_version < '3.7'"]
|
|
dct_requirements = defaultdict(set)
|
|
lst_requirements_file = get_lst_requirements_txt(
|
|
config,
|
|
ignore_dir_startswith=["script/"],
|
|
force_add_item=[priority_filename_requirement],
|
|
)
|
|
# lst_requirements_with_condition = set()
|
|
# dct_special_condition = defaultdict(list)
|
|
|
|
if not os.path.isfile(priority_filename_requirement):
|
|
_logger.error(f"File {priority_filename_requirement} not found.")
|
|
|
|
print(f"Find {len(lst_requirements_file)} requirements.txt files.")
|
|
|
|
dct_requirements_module_filename = defaultdict(list)
|
|
for requirements_filename in lst_requirements_file:
|
|
with open(requirements_filename, "r") as f:
|
|
for a in f.readlines():
|
|
b = a.strip()
|
|
if not b or b[0] == "#":
|
|
continue
|
|
if " @ " in b:
|
|
# Support when requirement line is like "package @ git+https://URL"
|
|
b = b.split("@ ")[1]
|
|
if "#" in b:
|
|
# remove comments at the end of module
|
|
b = b[: b.index("#")].strip()
|
|
comment_depend = ""
|
|
# Défini pour TOUTE ligne : il est relu plus bas, y compris
|
|
# pour les lignes sans marqueur.
|
|
keep_marker = ""
|
|
if except_sign in b:
|
|
# current_python_version = platform.python_version()
|
|
# current_platform = sys.platform
|
|
current_platform_2 = default_environment()
|
|
current_platform_2["python_version"] = ".".join(
|
|
config.set_version_python.split(".")[:2]
|
|
)
|
|
current_platform_2["python_full_version"] = (
|
|
config.set_version_python
|
|
)
|
|
current_platform_2["implementation_version"] = (
|
|
config.set_version_python
|
|
)
|
|
req = Requirement(b)
|
|
# Le nom de l'artefact généré — pyproject.odooXX_pythonYY —
|
|
# fige la version d'Odoo et celle de Python, PAS
|
|
# l'architecture. Évaluer « python_version » ici est donc
|
|
# juste ; évaluer « platform_machine » y graverait
|
|
# silencieusement l'architecture de la machine qui génère,
|
|
# et le lock produit sur x86 devient faux sur s390x.
|
|
# Un tel marqueur est donc CONSERVÉ et transmis à Poetry,
|
|
# qui sait résoudre les deux branches dans un seul lock.
|
|
if "platform_machine" in str(req.marker):
|
|
keep_marker = str(req.marker)
|
|
else:
|
|
is_compatible = req.marker.evaluate(current_platform_2)
|
|
if not is_compatible:
|
|
continue
|
|
# this support python_version into comment_depend, check odoo/requirements.txt
|
|
# b, comment_depend = b.split(except_sign)
|
|
# b = b.strip()
|
|
# comment_depend = comment_depend.strip()
|
|
# print(comment_depend)
|
|
# Rewrite dependancy : module==version
|
|
b = req.name + str(req.specifier)
|
|
if keep_marker:
|
|
b += f" ; {keep_marker}"
|
|
|
|
# Deux lignes du même module portant des marqueurs DIFFÉRENTS
|
|
# ne sont pas un conflit : elles s'excluent mutuellement. La
|
|
# clé inclut donc le marqueur, sans quoi la détection de
|
|
# versions divergentes les opposerait et en éliminerait une.
|
|
#
|
|
# Le nom vient de PEP 508 et non d'un découpage : avec un
|
|
# marqueur, le premier opérateur de la ligne est souvent celui
|
|
# du marqueur (« != »), et le découpage rendrait
|
|
# « factur-x>=4.2 » comme nom de module — que la liste des
|
|
# ignorés ne retrouverait plus.
|
|
if keep_marker:
|
|
module_name = f"{req.name} ; {keep_marker}"
|
|
dct_requirements[module_name].add(b)
|
|
dct_requirements_module_filename[b].append(
|
|
str(requirements_filename)
|
|
)
|
|
continue
|
|
|
|
# Regroup requirement
|
|
for sign in lst_sign:
|
|
if sign in b:
|
|
# Exception, some time the sign ; can be first, just check
|
|
if (
|
|
sign != except_sign
|
|
and except_sign in b
|
|
and b.find(sign) > b.find(except_sign)
|
|
):
|
|
module_name = b[: b.find(except_sign)]
|
|
else:
|
|
module_name = b[: b.find(sign)]
|
|
module_name = module_name.strip()
|
|
# Special condition for ";", ignore it
|
|
# if except_sign in b:
|
|
# for ignore_string in ignore_requirements:
|
|
# if ignore_string in b:
|
|
# break
|
|
# if ignore_string in b:
|
|
# break
|
|
# # lst_requirements_with_condition.add(module_name)
|
|
# value = b[: b.find(except_sign)].strip()
|
|
# # dct_special_condition[module_name].append(b)
|
|
# else:
|
|
# value = b
|
|
value = b
|
|
dct_requirements[module_name].add(value)
|
|
filename = str(requirements_filename)
|
|
dct_requirements_module_filename[value].append(
|
|
filename
|
|
)
|
|
break
|
|
else:
|
|
dct_requirements[b].add(b)
|
|
filename = str(requirements_filename)
|
|
dct_requirements_module_filename[b].append(filename)
|
|
lst_requirements.append(b)
|
|
|
|
dct_requirements = get_manifest_external_dependencies(
|
|
config, dct_requirements, lst_sign
|
|
)
|
|
|
|
# Un module dont les requirements donnent des variantes par marqueur ne doit
|
|
# pas recevoir en plus une entrée NUE. Les manifest.py des addons déclarent
|
|
# « factur-x » sans version ni marqueur : cette entrée s'ajouterait aux deux
|
|
# branches et poetry recevrait trois contraintes pour le même paquet, dont
|
|
# une sans condition — ce qui annulerait la distinction par architecture.
|
|
marked_names = {
|
|
key.split(";")[0].strip() for key in dct_requirements if ";" in key
|
|
}
|
|
for name in marked_names:
|
|
if name in dct_requirements:
|
|
del dct_requirements[name]
|
|
print(
|
|
f"{Fore.YELLOW}WARNING{Style.RESET_ALL} - '{name}' est déjà"
|
|
" décliné par marqueur : l'entrée sans condition est ignorée."
|
|
)
|
|
|
|
# Merge all requirement by insensitive
|
|
dct_requirement_insensitive = {}
|
|
copy_dct_requirements = dct_requirements.copy()
|
|
dct_requirements = defaultdict(set)
|
|
for req_name, set_info in copy_dct_requirements.items():
|
|
lower_req_name = req_name.lower()
|
|
associate_req_name = dct_requirement_insensitive.get(lower_req_name)
|
|
if not associate_req_name:
|
|
dct_requirement_insensitive[lower_req_name] = req_name
|
|
dct_requirements[req_name] = set_info
|
|
else:
|
|
dct_requirements[associate_req_name] = set.union(
|
|
dct_requirements[associate_req_name], set_info
|
|
)
|
|
|
|
dct_requirements_diff_version = {
|
|
k: v for k, v in dct_requirements.items() if len(v) > 1
|
|
}
|
|
# dct_requirements_same_version = {k: v for k, v in dct_requirements.items() if
|
|
# len(v) == 1}
|
|
if config.verbose:
|
|
# TODO show total repo to compare lst requirements
|
|
print(
|
|
f"Total requirements.txt {len(lst_requirements_file)}, total"
|
|
f" module {len(lst_requirements)}, unique module"
|
|
f" {len(dct_requirements)}, module with different version"
|
|
f" {len(dct_requirements_diff_version)}."
|
|
)
|
|
|
|
if dct_requirements_diff_version:
|
|
# Validate compatibility
|
|
for key, lst_requirement in dct_requirements_diff_version.items():
|
|
result = None
|
|
|
|
lst_version_requirement = []
|
|
for requirement in lst_requirement:
|
|
# if ".*" in requirement:
|
|
# requirement = requirement.replace(".*", "")
|
|
if "~=" in requirement:
|
|
old_requirement = requirement
|
|
requirement = requirement.replace("~=", "==")
|
|
lst_replace_special_sign[requirement] = old_requirement
|
|
|
|
requirement_begin = requirement.split(except_sign)[0]
|
|
match = re.search(r"[=<>~!]{1,2}(.*)", requirement_begin)
|
|
if not match:
|
|
# Ignore empty version
|
|
continue
|
|
match_version = match.group(1).strip()
|
|
if ".*" in match_version:
|
|
match_version = match_version.replace(".*", "")
|
|
match_sign = match.group(0).strip()[: -len(match_version)]
|
|
match_app_name = requirement[
|
|
: -(len(match_sign) + len(match_version))
|
|
]
|
|
match_version_format = match_version.replace("'", "").replace(
|
|
'"', ""
|
|
)
|
|
result_number = [(match_sign, Version(match_version_format))]
|
|
# result_number = iscompatible.parse_requirements(requirement)
|
|
if not result_number:
|
|
continue
|
|
lst_version_requirement.append((requirement, result_number))
|
|
# Check compatibility with all possibility
|
|
is_compatible = True
|
|
if len(lst_version_requirement) > 1:
|
|
highest_value = sorted(
|
|
lst_version_requirement, key=lambda tup: tup[1][0][1]
|
|
)[-1]
|
|
for version_requirement in lst_version_requirement:
|
|
# TODO support me in iscompatible lib
|
|
# check after ., because b can appear in number
|
|
# v_r_split = version_requirement[0].split(".", 1)
|
|
# if len(v_r_split) > 1 and "b" in v_r_split[1]:
|
|
# version_requirement_upd = version_requirement[0][
|
|
# : version_requirement[0].rindex("b")
|
|
# ]
|
|
# else:
|
|
# version_requirement_upd = version_requirement[0]
|
|
version_requirement_upd = version_requirement[0]
|
|
if ".*" in version_requirement_upd:
|
|
version_requirement_upd = (
|
|
version_requirement_upd.replace(".*", "")
|
|
)
|
|
try:
|
|
is_compatible &= iscompatible.iscompatible(
|
|
version_requirement_upd, highest_value[1][0][1]
|
|
)
|
|
except Exception as e:
|
|
_logger.error(e)
|
|
is_compatible &= iscompatible.iscompatible(
|
|
version_requirement_upd, highest_value[1][0][1]
|
|
)
|
|
if is_compatible:
|
|
result = highest_value[0]
|
|
else:
|
|
# Find the requirements file and print the conflict
|
|
# Take the version from Odoo by default, else take the more recent
|
|
odoo_value = None
|
|
erplibre_value = None
|
|
for version_requirement in lst_version_requirement:
|
|
key_require = version_requirement[0]
|
|
if key_require in lst_replace_special_sign.keys():
|
|
key_require = lst_replace_special_sign.get(
|
|
key_require
|
|
)
|
|
filename_1 = dct_requirements_module_filename.get(
|
|
key_require
|
|
)
|
|
if not filename_1:
|
|
_logger.error(
|
|
f"Cannot find key '{key_require}' into list of requirements."
|
|
)
|
|
else:
|
|
if priority_filename_requirement in filename_1:
|
|
erplibre_value = version_requirement[0]
|
|
elif (
|
|
second_priority_filename_requirement
|
|
in filename_1
|
|
):
|
|
odoo_value = version_requirement[0]
|
|
|
|
if erplibre_value:
|
|
str_result_choose = (
|
|
f"Select {erplibre_value} because from ERPLibre"
|
|
)
|
|
result = erplibre_value
|
|
elif odoo_value:
|
|
str_result_choose = (
|
|
f"Select {odoo_value} because from Odoo"
|
|
)
|
|
result = odoo_value
|
|
else:
|
|
result = highest_value[0]
|
|
str_result_choose = f"Select highest value {result}"
|
|
str_versions = " VS ".join(
|
|
[
|
|
f"{a[0]} from"
|
|
f" {dct_requirements_module_filename.get(a[0])}"
|
|
for a in lst_version_requirement
|
|
]
|
|
)
|
|
print(
|
|
f"{Fore.YELLOW}WARNING{Style.RESET_ALL} - Not"
|
|
f" compatible {str_versions} - {str_result_choose}."
|
|
)
|
|
elif len(lst_version_requirement) == 1:
|
|
result = lst_version_requirement[0][0]
|
|
else:
|
|
result = key
|
|
|
|
if result:
|
|
dct_requirements[key] = {result}
|
|
else:
|
|
print(f"Internal error, missing result for {lst_requirement}.")
|
|
|
|
# Support ignored requirements
|
|
lst_ignore, ignore_requirement_file = get_list_ignored()
|
|
lst_ignored_key = []
|
|
for key in dct_requirements.keys():
|
|
# La clé n'est pas toujours un nom nu : selon la branche qui l'a créée
|
|
# elle porte un marqueur (« paquet ; platform_machine … ») ou une
|
|
# version (« pymssql<=2.2.5 »). La liste d'ignorés ne nomme que le
|
|
# module, on ramène donc la clé à son nom avant de comparer.
|
|
bare_key = re.split(r"[\[<>=!~;]", key)[0].strip()
|
|
for ignored in lst_ignore:
|
|
if ignored == bare_key:
|
|
lst_ignored_key.append(key)
|
|
for key in lst_ignored_key:
|
|
del dct_requirements[key]
|
|
print(
|
|
f"{Fore.YELLOW}WARNING{Style.RESET_ALL} - Ignore '{key}' from '{ignore_requirement_file}'"
|
|
)
|
|
|
|
venv_dir = f".venv.{config.set_version_erplibre}"
|
|
with open(f"./{venv_dir}/build_dependency.txt", "w") as f:
|
|
# TODO remove all comment
|
|
f.writelines([f"{list(a)[0]}\n" for a in dct_requirements.values()])
|
|
|
|
|
|
def sorted_dependency_poetry(pyproject_filename):
|
|
# Open pyproject.toml
|
|
with open(pyproject_filename, "r") as f:
|
|
dct_pyproject = toml.load(f)
|
|
|
|
# Get dependencies and update list, sorted
|
|
# [tool.poetry.dependencies]
|
|
tool = dct_pyproject.get("tool")
|
|
if tool:
|
|
poetry = tool.get("poetry")
|
|
if poetry:
|
|
dependencies = poetry.get("dependencies")
|
|
python_dependency = ("python", dependencies.get("python", ""))
|
|
lst_dependency = [
|
|
(k, v) for k, v in dependencies.items() if k != "python"
|
|
]
|
|
lst_dependency = sorted(lst_dependency, key=lambda tup: tup[0])
|
|
poetry["dependencies"] = OrderedDict(
|
|
[python_dependency] + lst_dependency
|
|
)
|
|
|
|
# Rewrite pyproject.toml
|
|
with open(pyproject_filename, "w") as f:
|
|
toml.dump(dct_pyproject, f)
|
|
|
|
|
|
def delete_dependency_poetry(pyproject_filename):
|
|
# Open pyproject.toml
|
|
with open(pyproject_filename, "r") as f:
|
|
dct_pyproject = toml.load(f)
|
|
|
|
# Get dependencies and update list, sorted
|
|
# [tool.poetry.dependencies]
|
|
tool = dct_pyproject.get("tool")
|
|
if tool:
|
|
poetry = tool.get("poetry")
|
|
if poetry:
|
|
dependencies = poetry.get("dependencies")
|
|
python_dependency = ("python", dependencies.get("python", ""))
|
|
poetry["dependencies"] = OrderedDict([python_dependency])
|
|
|
|
# Rewrite pyproject.toml
|
|
with open(pyproject_filename, "w") as f:
|
|
toml.dump(dct_pyproject, f)
|
|
|
|
|
|
def get_manifest_external_dependencies(config, dct_requirements, lst_sign):
|
|
lst_manifest_file = get_lst_manifest_py(
|
|
config, ignore_dir_startswith=["script/"]
|
|
)
|
|
print(f"Find {len(lst_manifest_file)} manifest.py files.")
|
|
lst_dct_ext_depend = []
|
|
for manifest_file in lst_manifest_file:
|
|
with open(manifest_file, "r") as f:
|
|
contents = f.read()
|
|
try:
|
|
dct = ast.literal_eval(contents)
|
|
except:
|
|
_logger.error(f"File {manifest_file} contains error, skip.")
|
|
continue
|
|
ext_depend = dct.get("external_dependencies")
|
|
if not ext_depend:
|
|
continue
|
|
python = ext_depend.get("python")
|
|
if not python:
|
|
continue
|
|
for depend in python:
|
|
# TODO duplicate code, check combine_requirements()
|
|
module_name = depend
|
|
for sign in lst_sign:
|
|
if sign in depend:
|
|
module_name = depend[: depend.find(sign)].strip()
|
|
requirement = dct_requirements.get(module_name)
|
|
if requirement:
|
|
requirement.add(depend)
|
|
else:
|
|
dct_requirements[module_name] = set([depend])
|
|
|
|
return dct_requirements
|
|
|
|
|
|
def apply_marker_variants(pyproject_filename, build_dependency_filename):
|
|
"""Rétablit les paquets déclinés en plusieurs branches par marqueur.
|
|
|
|
« poetry add » déduplique par nom : des deux branches de factur-x, seule la
|
|
dernière survit, et l'architecture qui n'est pas la sienne hérite de la
|
|
mauvaise version. Poetry sait pourtant exprimer le cas — mais uniquement
|
|
dans le pyproject, en liste de contraintes, hors de portée du CLI. On la
|
|
reconstruit depuis build_dependency.txt, qui porte toutes les branches.
|
|
|
|
:return: True si le pyproject a été réécrit, donc si le lock est à refaire
|
|
"""
|
|
dct_variant = defaultdict(list)
|
|
with open(build_dependency_filename, "r") as f:
|
|
for line in f:
|
|
line = line.strip()
|
|
if not line or ";" not in line:
|
|
continue
|
|
req = Requirement(line)
|
|
dct_variant[req.name].append(
|
|
{"version": str(req.specifier), "markers": str(req.marker)}
|
|
)
|
|
dct_variant = {k: v for k, v in dct_variant.items() if len(v) > 1}
|
|
if not dct_variant:
|
|
return False
|
|
|
|
with open(pyproject_filename, "r") as f:
|
|
dct_pyproject = toml.load(f)
|
|
dependencies = (
|
|
dct_pyproject.get("tool", {}).get("poetry", {}).get("dependencies")
|
|
)
|
|
if not dependencies:
|
|
return False
|
|
|
|
has_changed = False
|
|
for name, lst_branch in dct_variant.items():
|
|
key = next(
|
|
(k for k in dependencies if k.lower() == name.lower()), None
|
|
)
|
|
if not key:
|
|
continue
|
|
dependencies[key] = lst_branch
|
|
has_changed = True
|
|
str_branch = ", ".join(
|
|
f"{d['version']} si {d['markers']}" for d in lst_branch
|
|
)
|
|
print(f"Décline '{key}' par marqueur : {str_branch}.")
|
|
|
|
if has_changed:
|
|
with open(pyproject_filename, "w") as f:
|
|
toml.dump(dct_pyproject, f)
|
|
return has_changed
|
|
|
|
|
|
def call_poetry_lock(config):
|
|
"""
|
|
:return: True if success
|
|
"""
|
|
venv_dir = f".venv.{config.set_version_erplibre}"
|
|
status = os.system(f"./{venv_dir}/bin/poetry lock")
|
|
return status == 0
|
|
|
|
|
|
def call_poetry_add_build_dependency():
|
|
"""
|
|
|
|
:return: True if success
|
|
"""
|
|
status = os.system("./script/poetry/poetry_add_build_dependency.sh")
|
|
return status == 0
|
|
|
|
|
|
def get_list_ignored():
|
|
odoo_erplibre_version = ""
|
|
with open("./.erplibre-version", "r", encoding="utf-8") as fichier:
|
|
odoo_erplibre_version = fichier.read().strip()
|
|
if not odoo_erplibre_version:
|
|
_logger.warning(
|
|
"Missing ./.erplibre-version file to determine which requirement/ignore_requirement to use."
|
|
)
|
|
return []
|
|
ignore_requirement_file = (
|
|
f"./requirement/ignore_requirements.{odoo_erplibre_version}.txt"
|
|
)
|
|
with open(ignore_requirement_file, "r") as f:
|
|
lst_ignore_requirements = [
|
|
a.strip() for a in f.readlines() if a.strip()
|
|
]
|
|
return lst_ignore_requirements, ignore_requirement_file
|
|
|
|
|
|
def ensure_pyproject_link(config, pyproject_filename):
|
|
"""Stop cleanly when the root pyproject.toml is missing.
|
|
|
|
pyproject.toml and poetry.lock at the root are symlinks to the active
|
|
version's files in requirement/, created by the version switch; they are
|
|
not versioned. When absent, or dangling, the fix is `make switch_odoo_XX`.
|
|
On a terminal, offer to run it and restart this script with the same
|
|
arguments; otherwise print the command and exit with code 1.
|
|
|
|
:param config: parsed arguments, set_version_odoo gives the make target
|
|
:param pyproject_filename: path of the pyproject.toml to open
|
|
:return: None when the file exists; never returns otherwise
|
|
"""
|
|
if os.path.isfile(pyproject_filename):
|
|
return
|
|
odoo_major = config.set_version_odoo.split(".")[0]
|
|
make_cmd = f"make switch_odoo_{odoo_major}"
|
|
print(
|
|
f"{Fore.RED}ERROR{Style.RESET_ALL} - Missing '{pyproject_filename}':"
|
|
" the Poetry links of the active version are not created."
|
|
)
|
|
print(f"Fix: run '{make_cmd}', then relaunch this script.")
|
|
if not sys.stdin.isatty():
|
|
sys.exit(1)
|
|
answer = input(f"Run '{make_cmd}' and relaunch now? [y/N] ")
|
|
if answer.strip().lower() not in ("y", "yes", "o", "oui"):
|
|
sys.exit(1)
|
|
if os.system(make_cmd) != 0 or not os.path.isfile(pyproject_filename):
|
|
print(f"{Fore.RED}ERROR{Style.RESET_ALL} - '{make_cmd}' failed.")
|
|
sys.exit(1)
|
|
os.execv(sys.executable, [sys.executable] + sys.argv)
|
|
|
|
|
|
def main():
|
|
# repo = Repo(root_path)
|
|
# lst_repo = get_all_repo()
|
|
config = get_config()
|
|
|
|
# print(
|
|
# f"Version: ERPLibre '{config.set_version_erplibre}' : Python ERPLibre '{config.set_version_python_erplibre}' : Poetry '{config.set_version_poetry}' : Odoo '{config.set_version_odoo}' : Python Odoo '{config.set_version_python_odoo}'"
|
|
# )
|
|
print(
|
|
f"Version: Poetry '{config.set_version_poetry}' : Odoo '{config.set_version_odoo}' : Python '{config.set_version_python}' : ERPLibre '{config.set_version_erplibre}'"
|
|
)
|
|
|
|
poetry_default_lock_path = "./poetry.lock"
|
|
pyproject_toml_filename = ""
|
|
poetry_target_lock_path = (
|
|
f"./requirement/poetry.{config.set_version_erplibre}.lock"
|
|
)
|
|
|
|
if not config.dry:
|
|
pyproject_toml_filename = f"{config.dir}pyproject.toml"
|
|
ensure_pyproject_link(config, pyproject_toml_filename)
|
|
delete_dependency_poetry(pyproject_toml_filename)
|
|
combine_requirements(config)
|
|
if not config.dry:
|
|
if config.force and os.path.isfile(poetry_default_lock_path):
|
|
os.remove(poetry_default_lock_path)
|
|
status = call_poetry_add_build_dependency()
|
|
if status and pyproject_toml_filename:
|
|
sorted_dependency_poetry(pyproject_toml_filename)
|
|
build_dependency_filename = (
|
|
f"./.venv.{config.set_version_erplibre}/build_dependency.txt"
|
|
)
|
|
if apply_marker_variants(
|
|
pyproject_toml_filename, build_dependency_filename
|
|
):
|
|
# Le lock écrit par « poetry add » ignore les branches qu'on
|
|
# vient de rétablir : il ne décrit plus le pyproject.
|
|
status = call_poetry_lock(config)
|
|
if (
|
|
config.force
|
|
and not os.path.islink(poetry_default_lock_path)
|
|
and os.path.isfile(poetry_default_lock_path)
|
|
and os.path.isfile(poetry_target_lock_path)
|
|
):
|
|
# If "./poetry.lock" is not symbolic link, force replace original
|
|
os.remove(poetry_target_lock_path)
|
|
shutil.move(poetry_default_lock_path, poetry_target_lock_path)
|
|
os.symlink(poetry_target_lock_path, poetry_default_lock_path)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|