gOdoo-cli 0.7.0__py3-none-any.whl

godoo_cli/commands/rpc/translations.py

@@ -0,0 +1,129 @@
+import logging
+from base64 import b64decode
+from pathlib import Path
+
+import typer
+from godoo_rpc.login import wait_for_odoo
+
+from ...cli_common import CommonCLI
+from ...helpers.odoo_files import get_odoo_module_paths
+from .modules import rpc_get_modules
+
+CLI = CommonCLI()
+LOGGER = logging.getLogger(__name__)
+
+
+def _dump_translation_for_module(module, target_path: Path):
+    """Dump Translation of a module into POT file.
+
+    Parameters
+    ----------
+    module : _type_
+        rpc record of module to export
+    target_path : Path
+        target pot path
+    """
+    trans_exp_mod = module.env["base.language.export"]
+
+    LOGGER.info("Exporting: %s --> %s", module.name, str(target_path))
+    trans_wiz_id = trans_exp_mod.create({"format": "po", "modules": [module.id]})
+    trans_wiz = trans_exp_mod.browse([trans_wiz_id])
+    trans_wiz.act_getfile()
+    trans_wiz = trans_exp_mod.browse([trans_wiz_id])
+    target_path.parent.mkdir(exist_ok=True)
+    target_path.write_bytes(b64decode(trans_wiz.data))
+
+
+def _dump_translations(
+    modules,
+    workspace_addon_path: Path,
+    upgrade_modules: bool = True,
+):
+    """Dump translations of given Modules into their addon folders.
+
+    Parameters
+    ----------
+    odoo_api : OdooApiWrapper
+        Odoo Api Wrapper
+    modules : _type_
+        Api Models of modules
+    workspace_addon_path : Path
+        path where those modules are installed
+    upgrade_modules : bool, optional
+        Wether to upgrade modules before dumping, by default True
+    """
+
+    if upgrade_modules:
+        LOGGER.info("Upgrading Modules: '%s'", ", ".join(modules.mapped("name")))
+        modules.button_immediate_upgrade()
+
+    for mod in modules:
+        ex_path: Path = workspace_addon_path / mod.name / "i18n"
+        pot_path: Path = ex_path / (mod.name + ".pot")
+        _dump_translation_for_module(mod, pot_path)
+
+
+def complete_workspace_addon_names(ctx: typer.Context, incomplete: str):
+    """Autocomplete handler that searches modules in Workspace_addon_path
+
+    Parameters
+    ----------
+    ctx : typer.Context
+        Contains calling parameters
+    incomplete : str
+        Incomplete current entry
+
+    Yields
+    ------
+    str
+        folder name
+    """
+    workspace_folder = ctx.params.get("workspace_addon_path")
+    if not workspace_folder:
+        return
+    workspace_folder = Path(workspace_folder)
+    addon_folders = get_odoo_module_paths(workspace_folder)
+    for fold in addon_folders:
+        if not incomplete or fold.name.startswith(incomplete):
+            yield fold.name
+
+
+@CLI.arg_annotator
+def dump_translations(
+    module_query=typer.Argument(
+        ...,
+        help="Module Name(s) comma Seperated. Add % to force =ilike match. Only works in workspace addon path",
+        autocompletion=complete_workspace_addon_names,
+    ),
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    rpc_host=CLI.rpc.rpc_host,
+    rpc_database=CLI.rpc.rpc_db_name,
+    rpc_user=CLI.rpc.rpc_user,
+    rpc_password=CLI.rpc.rpc_password,
+    no_upgrade_modules: bool = typer.Option(
+        False, "--no-upgrade-modules", help="don't upgrade modules before exporting"
+    ),
+):
+    """Dump Translations of module to <module_folder>/i18n/<module_name>.pot"""
+    addon_path = workspace_addon_path
+    addon_folders = get_odoo_module_paths(addon_path)
+    valid_module_names = [str(p.stem) for p in addon_folders]
+    LOGGER.debug("Found modules:\n%s", "\n".join(["\t" + mn for mn in valid_module_names]))
+
+    odoo_api = wait_for_odoo(
+        odoo_host=rpc_host,
+        odoo_db=rpc_database,
+        odoo_user=rpc_user,
+        odoo_password=rpc_password,
+    )
+
+    modules = rpc_get_modules(odoo_api, module_query, valid_module_names)
+    if not modules:
+        LOGGER.warning("No installed Modules found for Query string: '%s'", module_query)
+        return CLI.returner(1)
+
+    _dump_translations(
+        modules=modules,
+        workspace_addon_path=addon_path,
+        upgrade_modules=not no_upgrade_modules,
+    )

godoo_cli/commands/shell.py

@@ -0,0 +1,45 @@
+import logging
+from typing import List
+
+import typer
+
+from ..cli_common import CommonCLI
+from ..helpers.system import run_cmd
+
+CLI = CommonCLI()
+LOGGER = logging.getLogger(__name__)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def uninstall_modules(
+    module_list: List[str] = typer.Argument(..., help="List of Modules to uninstall"),
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+):
+    """
+    Uninstall given Modules from Odoo via shell.
+    """
+    module_list_str = str(list(module_list))
+    uninstall_cmd = f"env['ir.module.module'].search([('name','in',{module_list_str})]).filtered(lambda m: m.state not in ['uninstallable','uninstalled']).button_immediate_uninstall()"
+    uninstall_shell = f'echo "{uninstall_cmd}" | {str(odoo_main_path.absolute())}/odoo-bin shell -c {str(odoo_conf_path.absolute())} --no-http'
+    LOGGER.info("Launching Uninstaller: '%s'", uninstall_shell)
+    ret = run_cmd(uninstall_shell).returncode
+    return CLI.returner(ret)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def odoo_shell(
+    pipe_in_command: str = typer.Argument("", help="Python command, that will be piped into odoo-bin shell"),
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+):
+    """
+    Start Odoo session in an Interactive shell.
+    """
+    shell_cmd = f"{str(odoo_main_path.absolute())}/odoo-bin shell -c {str(odoo_conf_path.absolute())} --no-http"
+    if pipe_in_command:
+        shell_cmd = f'echo "{pipe_in_command}" |' + shell_cmd
+    LOGGER.debug("Running Command: %s", shell_cmd)
+    return CLI.returner(run_cmd(shell_cmd).returncode)

godoo_cli/commands/source_get.py

@@ -0,0 +1,279 @@
+"""Commands to clone Odoo and addon source code"""
+import configparser
+import logging
+import shutil
+import tempfile
+from enum import Enum
+from pathlib import Path
+from typing import List
+
+import typer
+from ruamel.yaml import YAML
+
+from ..cli_common import CommonCLI
+from ..git import GitUrl, git_ensure_addon_repos, git_ensure_odoo_repo
+from ..helpers.bootstrap import _install_py_reqs_for_modules
+from ..helpers.odoo_files import get_addon_paths, get_odoo_module_paths, get_zip_addon_path
+from ..helpers.odoo_manifest import remove_unused_folders
+from ..helpers.system import download_file
+from .db.connection import DBConnection
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+class UpdateMode(str, Enum):
+    all = "all"
+    zip = "zip"
+    odoo = "odoo"
+    thirdparty = "thirdparty"
+
+
+def unpack_addon_archives(
+    archive_folder: Path,
+    target_addon_folder: Path,
+    remove_excess: bool = False,
+):
+    """Take archive files from archive_folder and extract them into target_addon_folder.
+
+    Parameters
+    ----------
+    archive_folder : Path
+        Where to look for zip files
+    target_addon_folder : Path
+        where to place them
+    remove_excess : bool , optional
+        remove all and then unzip, by default False
+    """
+    target_addon_folder.mkdir(exist_ok=True, parents=True)
+    if remove_excess:
+        LOGGER.debug("Clearing out unarchive folder: %s", target_addon_folder)
+        for folder in target_addon_folder.iterdir():
+            shutil.rmtree(folder)
+    LOGGER.info("Extracting archive addons to: %s", target_addon_folder)
+    for zip_file in archive_folder.glob("*.zip"):
+        LOGGER.info("Extracting addon archive: %s", zip_file)
+        with tempfile.TemporaryDirectory() as td:
+            td = Path(td)
+            shutil.unpack_archive(zip_file, td)
+            # We can have zip files with one or more modules.
+            # Either the first folder contains multiple or its a module by itself
+            # So first get the real modules form the zip root or one level down and then move them to subpaths
+            zip_module_paths = get_odoo_module_paths([td] + list(td.glob("*/")))
+            if not zip_module_paths:
+                LOGGER.warning("Could not find valid modules in thirdparty zip: %s", zip_file)
+                continue
+            LOGGER.debug(
+                "Found modules in Zipfile:\n%s",
+                "\n".join([str(f.relative_to(td)) for f in zip_module_paths]),
+            )
+            target_folder = target_addon_folder / ("single_mods" if len(zip_module_paths) == 1 else zip_file.stem)
+            target_folder.mkdir(exist_ok=True)
+            for m in zip_module_paths:
+                module_target = target_folder / m.stem
+                shutil.rmtree(module_target, ignore_errors=True)
+                shutil.move(m, module_target)
+
+
+def update_odoo_conf_addon_paths(odoo_conf: Path, addon_paths: List[Path]):
+    """Update Odoo.Conf with Addon Paths
+
+    Parameters
+    ----------
+    odoo_conf : Path
+        odoo.conf location
+    addon_paths : List[Path]
+        list of paths
+    """
+    if not odoo_conf.exists():
+        raise FileNotFoundError("Odoo.conf not found at: %s" % odoo_conf)
+    config = configparser.ConfigParser()
+    config.read(odoo_conf)
+    addon_paths = ",".join([str(p.absolute()) for p in addon_paths])
+    config["options"]["addons_path"] = addon_paths
+    LOGGER.info("Writing Addon Paths to Odoo Config.")
+    LOGGER.debug(addon_paths)
+    config.write(odoo_conf.open("w"))
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def py_depends_by_db(
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_name=CLI.database.db_name,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+):
+    """Insall Python Dependencies for all installed modules in DB."""
+    connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+    with connection.connect() as conn:
+        try:
+            conn.execute("SELECT name FROM ir_module_module WHERE state='installed'")
+        except UnboundLocalError as e:
+            LOGGER.error("Could not connect to DB. Check your DB Connection settings.")
+            raise typer.Exit(1) from e
+        module_list = [r[0] for r in conn.fetchall()]
+        LOGGER.info("Installing Py Reqiurements for Modules: %s", module_list)
+        odoo_addon_paths = get_addon_paths(
+            odoo_main_repo=odoo_main_path,
+            workspace_addon_path=workspace_addon_path,
+            thirdparty_addon_path=thirdparty_addon_path,
+        )
+        _install_py_reqs_for_modules(odoo_addon_paths, module_list)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def py_depends_by_modules(
+    module_list: List[str] = typer.Argument(
+        ...,
+        help="Modules to check for dependencies (can use all for all available addons)",
+    ),
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+):
+    """Install dependencies from __manifest__.py in specified modules."""
+    odoo_addon_paths = get_addon_paths(
+        odoo_main_repo=odoo_main_path,
+        workspace_addon_path=workspace_addon_path,
+        thirdparty_addon_path=thirdparty_addon_path,
+    )
+    if len(module_list) == 1 and module_list[0] == "all":
+        search_addon_paths = [p for p in odoo_addon_paths if odoo_main_path not in p.parents]
+        module_list = [p.stem for p in get_odoo_module_paths(search_addon_paths)]
+    _install_py_reqs_for_modules(odoo_addon_paths, module_list)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def get_source_file(
+    manifest_path=CLI.source.mainfest_path,
+    repo_url: str = typer.Option("", help="git repo url, for specific repo (skip manifest_yml)"),
+    file_ref: str = typer.Option("", help="When not using manifest. File Branch, Commit, Tag..."),
+    file_path: str = typer.Option(..., help="Relative Filepath in Repository"),
+    save_path: Path = typer.Option(..., file_okay=True, dir_okay=False, help="Where to write the file"),
+):
+    """Get Raw file from manifest git remotes or specific git remote."""
+
+    if not repo_url and not manifest_path:
+        raise ValueError("Need to provide either manifest_yml or repo_url")
+    if manifest_path and not repo_url:
+        manifest = YAML().load(manifest_path.resolve())
+        odoo_spec = manifest["odoo"]
+        repo_url = odoo_spec["url"]
+        file_ref = odoo_spec.get("commit") or odoo_spec.get("branch")
+    if not file_ref:
+        raise ValueError(
+            "Need to provide file ref. If you provided a manifest, make sure there is a branch or commit key in the odoo section"
+        )
+    git_url = GitUrl(repo_url)
+    file_url = git_url.get_file_raw_url(ref=file_ref, file_path=file_path)
+
+    return download_file(url=file_url, save_path=save_path)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def get_source(
+    update_mode: UpdateMode = typer.Argument(UpdateMode.all, help="What to Update"),
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    manifest_path=CLI.source.mainfest_path,
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+    download_zipmode=CLI.source.source_download_archive,
+    thirdparty_zip_source: Path = typer.Option(
+        ..., envvar="ODOO_THIRDPARTY_ZIP_LOCATION", help="Source folder, where to look for Addon zips"
+    ),
+    add_compare_comments: bool = typer.Option(
+        False, "--add-compare-comments", help="Wether to add github.com three dot compare links as comments."
+    ),
+    remove_unspecified_addons: bool = typer.Option(
+        False, "--remove-unspecified-addons", help="Remove Addon folders that are not in YML or thirdparty.zip"
+    ),
+    force_fetch: bool = typer.Option(
+        False,
+        "--force-fetch",
+        help="Forces origin fetch, regardless of current branch or commit sha (may be slow)",
+    ),
+):
+    """Download/Unzip Odoo Source and thirdparty addons."""
+    LOGGER.info("Updating Source Repos")
+    zip_addon_path = get_zip_addon_path(thirdparty_addon_path)
+
+    if update_mode in ["all", "zip"]:
+        unpack_addon_archives(thirdparty_zip_source, zip_addon_path, remove_excess=remove_unspecified_addons)
+
+    if update_mode in ["all", "odoo"]:
+        git_ensure_odoo_repo(
+            target_folder=odoo_main_path,
+            manifest_file=manifest_path,
+            force_fetch=force_fetch,
+            add_compare_comment=add_compare_comments,
+            download_archive=download_zipmode,
+        )
+
+    if update_mode in ["all", "thirdparty"]:
+        git_repos = git_ensure_addon_repos(
+            root_folder=thirdparty_addon_path,
+            git_yml_path=manifest_path,
+            generate_yml_compare_comments=add_compare_comments,
+            download_archive=download_zipmode,
+        )
+        if remove_unspecified_addons:
+            remove_unused_folders(
+                thirdparty_addon_path=thirdparty_addon_path,
+                thirdparty_repos=git_repos.get("thirdparty", []),
+                keep_folders=[zip_addon_path],
+            )
+
+    if (conf_path := odoo_conf_path).exists():
+        odoo_addon_paths = get_addon_paths(
+            odoo_main_repo=odoo_main_path,
+            workspace_addon_path=workspace_addon_path,
+            thirdparty_addon_path=thirdparty_addon_path,
+        )
+        update_odoo_conf_addon_paths(odoo_conf=conf_path, addon_paths=odoo_addon_paths)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def update_odoo_conf(
+    odoo_conf=CLI.odoo_paths.conf_path,
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+):
+    """Update Odoo.conf with Addon Paths."""
+    odoo_addon_paths = get_addon_paths(
+        odoo_main_repo=odoo_main_path,
+        workspace_addon_path=workspace_addon_path,
+        thirdparty_addon_path=thirdparty_addon_path,
+    )
+    update_odoo_conf_addon_paths(odoo_conf=odoo_conf, addon_paths=odoo_addon_paths)
+
+
+def source_cli_app():
+    app = typer.Typer(
+        no_args_is_help=True,
+        help="Functions concerning with Odoo Source code",
+    )
+
+    app.command("get")(get_source)
+    app.command("sync-conf")(update_odoo_conf)
+    app.command("get-file")(get_source_file)
+    app.command("get-dependencies")(py_depends_by_modules)
+    app.command("get-dependencies-db")(py_depends_by_db)
+
+    return app

godoo_cli/commands/test.py

@@ -0,0 +1,126 @@
+import logging
+import re
+from pathlib import Path
+from typing import List
+
+import typer
+
+from ..cli_common import CommonCLI
+from ..helpers.odoo_files import get_changed_modules, get_depends_of_module, get_odoo_module_paths
+from ..helpers.system import run_cmd
+from .launch import pre_launch
+
+CLI = CommonCLI()
+LOGGER = logging.getLogger(__name__)
+
+
+def _test_modules_special_cases(in_modules: List[str], workspace_addon_path: Path):
+    if len(in_modules) == 1:
+        command = in_modules[0]
+        out_modules = []
+        if command == "all":
+            out_modules = get_odoo_module_paths(workspace_addon_path)
+
+        if re_match := re.match(r"changes\:(.*)", command):
+            compare_branch = re_match.group(1)
+            changed_modules = get_changed_modules(addon_path=workspace_addon_path, diff_branch=compare_branch)
+            if not changed_modules:
+                return []
+            change_modules_depends = []
+            for module in changed_modules:
+                change_modules_depends += get_depends_of_module(
+                    out_modules, module, already_done_modules=change_modules_depends
+                )
+            out_modules = changed_modules + change_modules_depends
+        if out_modules:
+            out_modules_with_tests = [p for p in out_modules if any(p.rglob("tests/__init__.py"))]
+            return [p.stem for p in out_modules_with_tests]
+    return in_modules
+
+
+@CLI.arg_annotator
+def odoo_test(
+    test_modules: List[str] = typer.Argument(
+        ...,
+        help="Modules to install and test (Use 'all' for all Workspace modules), ('changes:<branch> to compare git changes)",
+    ),
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+    extra_launch_args=CLI.odoo_launch.extra_cmd_args,
+    db_filter=CLI.database.db_filter,
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_name=CLI.database.db_name,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+    skip_test_modules: List[str] = typer.Option(
+        [], envvar="ODOO_TEST_SKIP_MODULES", help="Modules not to Test even if specified in test_modules"
+    ),
+    odoo_log_level: str = typer.Option("test", help="Log level"),
+):
+    """Bootstrap or Launch odoo in Testing Mode."""
+
+    test_modules = _test_modules_special_cases(test_modules, workspace_addon_path)
+
+    skip_test_modules = [m for m in skip_test_modules if m in test_modules]  # Filter out skip mods that arent requested
+    if skip_test_modules:
+        LOGGER.info("Skipping Tests for Modules:\n%s", ", ".join(["\t" + m for m in skip_test_modules]))
+        test_modules = [m for m in test_modules if m not in skip_test_modules]
+
+    if not test_modules:
+        LOGGER.info("Nothing to Test. Skipping.")
+        return
+
+    test_module_list = ",".join(["/" + m for m in test_modules])
+    module_list = ",".join(test_modules)
+
+    LOGGER.info("Testing Odoo Modules:\n%s", "\n".join(sorted(["\t" + m for m in test_modules])))
+
+    bootstrap_args = [
+        "--test-enable",
+        f"--init {module_list}",
+    ]
+    if re.search("(sale|account)", test_module_list, re.IGNORECASE):
+        bootstrap_args[-1] += ",l10n_generic_coa"
+
+    bootstrap_args.append(f"--test-tags {test_module_list}")
+    bootstrap_args.append("--load-language en_US")
+    launch_args = [
+        f"-u {module_list}",
+        "--test-enable",
+        f"--log-level {odoo_log_level}",
+        "--stop-after-init",
+        "--no-http",
+        f"--test-tags {test_module_list}",
+    ]
+
+    if extra_launch_args:
+        launch_args = extra_launch_args + launch_args
+
+    launch_cmd = pre_launch(
+        odoo_main_path=odoo_main_path,
+        workspace_addon_path=workspace_addon_path,
+        thirdparty_addon_path=thirdparty_addon_path,
+        odoo_conf_path=odoo_conf_path,
+        db_filter=db_filter,
+        db_host=db_host,
+        db_port=db_port,
+        db_name=db_name,
+        db_user=db_user,
+        db_password=db_password,
+        dev_mode=False,
+        install_base=True,
+        install_workspace_addons=False,
+        extra_launch_args=launch_args,
+        extra_bootstrap_args=bootstrap_args,
+        multithread_worker_count=0,
+        odoo_demo=True,
+        launch_or_bootstrap=True,
+    )
+    if isinstance(launch_cmd, str):
+        LOGGER.info("Launching Odoo Tests")
+        return CLI.returner(run_cmd(launch_cmd).returncode)
+
+    return CLI.returner(launch_cmd)

godoo_cli/git/__init__.py

@@ -0,0 +1,4 @@
+from .git_odoo import git_ensure_odoo_repo
+from .git_odoo_addons import git_ensure_addon_repos
+from .git_repo import git_ensure_repo
+from .git_url import GitUrl

godoo_cli/git/git_odoo.py

@@ -0,0 +1,89 @@
+import json
+import logging
+from pathlib import Path
+
+from ..helpers.odoo_manifest import yaml_add_compare_commit, yaml_remove_compare_commit, yaml_roundtrip_loader
+from .git_repo import git_ensure_repo
+
+LOGGER = logging.getLogger(__name__)
+
+
+def git_ensure_odoo_repo(
+    target_folder: Path,
+    manifest_file: Path,
+    force_fetch: bool,
+    add_compare_comment: bool,
+    download_archive: bool,
+):
+    yaml = yaml_roundtrip_loader()
+    git_repos = yaml.load(manifest_file.resolve())
+    if not git_repos:
+        raise FileNotFoundError(f"Couldnt load yml file from: {str(manifest_file)}")
+
+    odoo_data = git_repos.get("odoo")
+    if not odoo_data:
+        raise KeyError(f"Could not find key 'odoo' in {str(manifest_file)}")
+
+    odoo_url = odoo_data["url"]
+    odoo_branch = odoo_data.get("branch", "master")
+    odoo_commit = odoo_data.get("commit", "")
+
+    download_stubs(target_folder, force_fetch, download_archive, odoo_data, odoo_branch)
+
+    if add_compare_comment:
+        yaml_add_compare_commit(odoo_data, odoo_branch)
+    else:
+        yaml_remove_compare_commit(odoo_data)
+
+    git_ensure_repo(
+        target_folder=target_folder,
+        repo_src=odoo_url,
+        branch=odoo_branch,
+        commit=odoo_commit,
+        pull=force_fetch,
+        zip_mode=download_archive,
+        filter="blob:none",
+        single_branch=True,
+    )
+
+    yaml.dump(git_repos, manifest_file)
+
+
+def download_stubs(
+    target_folder: Path,
+    force_fetch: bool,
+    download_archive: bool,
+    odoo_data,
+    odoo_branch: str,
+):
+    """Download Odoo stubs for https://github.com/odoo-ide/vscode-odoo
+
+    Hopefully this Method will become obsolete in the future, when the vscode-odoo extension includes stubs in the extension itself.
+
+    Parameters
+    ----------
+    target_folder : Path
+        Stubs will be downloaded to target_folder.parent/odoo-stubs
+    force_fetch : bool
+        passed down to git_ensure_repo
+    download_archive : bool
+        passed down to git_ensure_repo
+    odoo_data : Dict
+        odoo_data from manifest.yml
+    odoo_branch : str
+        branch to download stubs from
+    """
+    odoo_stubs = odoo_data.get("stubs")
+    if odoo_stubs:
+        stub_target_path = target_folder.parent / "odoo-stubs"
+        git_ensure_repo(
+            target_folder=stub_target_path,
+            repo_src=odoo_stubs["url"],
+            branch=odoo_branch,
+            pull=force_fetch,
+            zip_mode=download_archive,
+            filter="blob:none",
+            single_branch=True,
+        )
+        if pyright_path := odoo_stubs.get("pyright_conf"):
+            json.dump({"stubPath": str(stub_target_path.absolute())}, Path(pyright_path).open("w"))