gOdoo-cli 0.8.6__tar.gz → 0.9.3__tar.gz

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gOdoo-cli
-Version: 0.8.6
+Version: 0.9.3
 Summary: Wrapper around Odoo-Bin with some convinience RPC functions.
 Home-page: https://github.com/OpenJKSoftware/gOdoo
 License: LGPL-3

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "gOdoo-cli"
-version = "0.8.6"
+version = "0.9.3"
 description = "Wrapper around Odoo-Bin with some convinience RPC functions."
 authors = ["Joshua Kreuder <Joshua_Kreuder@outlook.com>"]
 license = "LGPL-3"

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/cli_common.py

@@ -8,7 +8,15 @@ from typer_common_functions import get_type_from_default, typer_retuner, typer_u
 
 @dataclass
 class OdooLaunchArgs:
-    extra_cmd_args: List[str] = Option(None, help="extra agruments to pass to odoo-bin", rich_help_panel="Odoo")
+    extra_cmd_args: List[str] = Option(
+        None, help="extra agruments to pass to odoo-bin", envvar="ODOO_BIN_ARGS", rich_help_panel="Odoo"
+    )
+    extra_cmd_args_bootstrap: List[str] = Option(
+        None,
+        help="extra agruments to pass to odoo-bin in bootstrap mode",
+        envvar="ODOO_BIN_BOOTSTRAP_ARGS",
+        rich_help_panel="Odoo",
+    )
     multithread_worker_count: int = Option(
         -1, help="count of worker threads. will enable proxy_mode if >0. (Autodetect with -1)", rich_help_panel="Odoo"
     )

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/backup/cli.py

@@ -1,5 +1,6 @@
 import typer
 
+from .dump import dump_instance
 from .load import load_instance_data
 from .pull import InstancePuller
 
@@ -13,5 +14,6 @@ def backup_cli_app():
 
     app.command("pull")(puller.pull_instance_data)
     app.command("load")(load_instance_data)
+    app.command("dump")(dump_instance)
 
     return app

godoo_cli-0.9.3/src/godoo_cli/commands/backup/dump.py

@@ -0,0 +1,85 @@
+import logging
+import shutil
+from configparser import ConfigParser
+from datetime import datetime
+from pathlib import Path
+
+import typer
+
+from ...cli_common import CommonCLI
+from ...helpers.odoo_files import odoo_bin_get_version
+from ..db.connection import DBConnection
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+@CLI.arg_annotator
+def dump_instance(
+    dump_path: Path = typer.Argument(
+        ...,
+        help="Path to dump to",
+        file_okay=False,
+        dir_okay=True,
+        writable=True,
+        resolve_path=True,
+    ),
+    db_name=CLI.database.db_name,
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    conf_path=CLI.odoo_paths.conf_path,
+):
+    """Dump DB and Filestore into Folder"""
+    db_connection = DBConnection(
+        db_name=db_name,
+        hostname=db_host,
+        username=db_user,
+        password=db_password,
+        port=db_port,
+    )
+    dump_path.mkdir(parents=True, exist_ok=True)
+
+    if not conf_path:
+        raise typer.Exit("No Odoo Conf Path provided. Cannot dump Filestore")
+
+    # Read .conf value [options] datad_dir
+    conf_path = Path(conf_path)
+    parser = ConfigParser()
+    parser.read(conf_path)
+    data_dir = parser["options"]["data_dir"]
+    data_dir = Path(data_dir)
+
+    # Copy Filestore
+    LOGGER.info("Dumping Filestore")
+    filestore_target = dump_path / "odoo_filestore"
+    shutil.rmtree(filestore_target, ignore_errors=True)
+    shutil.copytree(data_dir, filestore_target)
+
+    # Dump DB using pg_dump
+    LOGGER.info("Dumping DB")
+    db_dump_target = dump_path / "odoo.dump"
+    db_dump_target.unlink(missing_ok=True)
+    db_connection.run_psql_shell_command("pg_dump --format c {} > %s" % db_dump_target)
+
+    readme_path = Path(dump_path) / "README.md"
+    readme_path.unlink(missing_ok=True)
+
+    odoo_version = odoo_bin_get_version(odoo_main_path)
+
+    readme_content = f"""
+# gOdoo Dump
+
+SQL Dump and Filestore of gOdoo Instance.
+
+## Metadata
+
+
+- Odoo Version: {odoo_version.raw}
+- Filestore: [{ datetime.fromtimestamp(filestore_target.stat().st_mtime)}]({filestore_target.relative_to(dump_path)})
+- SQL Dump: [{ datetime.fromtimestamp(db_dump_target.stat().st_mtime)}]({db_dump_target.relative_to(dump_path)})
+
+"""
+    readme_path.write_text(readme_content)

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/bootstrap.py

@@ -2,7 +2,7 @@ import logging
 import os
 import re
 from pathlib import Path
-from typing import Any, List
+from typing import Any, List, Optional
 
 import typer
 from typing_extensions import Annotated
@@ -11,6 +11,7 @@ from ..cli_common import CommonCLI
 from ..helpers.bootstrap import _install_py_reqs_by_odoo_cmd
 from ..helpers.odoo_files import get_addon_paths, get_odoo_module_paths
 from ..helpers.system import run_cmd
+from .db.connection import DBConnection
 
 CLI = CommonCLI()
 
@@ -27,13 +28,9 @@ def _boostrap_command(
     odoo_conf_path: Path,
     addon_paths: List[Path],
     workspace_addon_path: Path,
-    db_host: str,
     db_filter: str,
-    db_name: str,
-    db_user: str,
-    db_password: str,
-    db_port: str,
-    extra_cmd_args: List[str] = None,
+    db_connection: DBConnection,
+    extra_cmd_args: Optional[List[str]] = None,
     install_workspace_modules: bool = True,
     multithread_worker_count: int = -1,
     languages: str = "de_DE,en_US",
@@ -53,16 +50,8 @@ def _boostrap_command(
         path to addons in dev repo
     db_filter : str
         db filter for odoo.conf
-    db_host : str
-        db hostname for odoo.conf
-    db_name : str
-        database name for odoo.conf
-    db_user : str
-        db user
-    db_password : str
-        db user password
-    db_port : str
-        db host port
+    db_connection : DBConnection
+        DB Connection
     extra_cmd_args : List[str], optional
         extra args to pass to odoo-bin, by default None
     install_workspace_modules : bool, optional
@@ -82,11 +71,11 @@ def _boostrap_command(
     odoo_conf_path.parent.mkdir(parents=True, exist_ok=True)
 
     db_command = [
-        f"--database {db_name}",
-        f"--db_user {db_user}",
-        f"--db_password {db_password}",
-        f"--db_host {db_host}" if db_host else "",
-        f"--db_port {db_port}" if db_host else "",
+        f"--database {db_connection.db_name}",
+        f"--db_user {db_connection.username}",
+        f"--db_password {db_connection.password}",
+        f"--db_host {db_connection.hostname}" if db_connection.hostname else "",
+        f"--db_port {db_connection.port}" if db_connection.hostname else "",
         f"--db-filter=^{db_filter}$",
     ]
 
@@ -149,7 +138,7 @@ def bootstrap_odoo(
     db_name=CLI.database.db_name,
     db_user=CLI.database.db_user,
     db_password=CLI.database.db_password,
-    extra_cmd_args=CLI.odoo_launch.extra_cmd_args,
+    extra_cmd_args=CLI.odoo_launch.extra_cmd_args_bootstrap,
     multithread_worker_count=CLI.odoo_launch.multithread_worker_count,
     languages=CLI.odoo_launch.languages,
     install_workspace_modules=CLI.odoo_launch.install_workspace_modules,
@@ -170,17 +159,21 @@ def bootstrap_odoo(
         thirdparty_addon_path=thirdparty_addon_path,
     )
 
+    db_connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+
     cmd_string = _boostrap_command(
         odoo_main_path=odoo_main_path,
         odoo_conf_path=odoo_conf_path,
         workspace_addon_path=workspace_addon_path,
         addon_paths=addon_paths,
-        db_host=db_host,
-        db_name=db_name,
         db_filter=db_filter,
-        db_user=db_user,
-        db_password=db_password,
-        db_port=db_port,
+        db_connection=db_connection,
         extra_cmd_args=extra_cmd_args,
         install_workspace_modules=install_workspace_modules,
         multithread_worker_count=multithread_worker_count,

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/db/cli.py

@@ -2,7 +2,7 @@ import typer
 
 from .connection import login_db
 from .passwords import set_passwords
-from .query import query_database
+from .query import get_installed_modules, is_bootstrapped, query_database
 
 
 def db_cli_app():
@@ -14,5 +14,7 @@ def db_cli_app():
     app.command()(set_passwords)
     app.command("login")(login_db)
     app.command("query")(query_database)
+    app.command("odoo-bootstrapped")(is_bootstrapped)
+    app.command("installed-modules")(get_installed_modules)
 
     return app

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/db/connection.py

@@ -52,6 +52,17 @@ class DBConnection:
             connect_timeout=self.conn_timeout,
         )
 
+    @property
+    def cli_dict(self):
+        """Return a dict that when expanded Matches the Default DB connection Args used throuout gOdoo"""
+        return {
+            "db_host": self.hostname,
+            "db_port": self.port,
+            "db_name": self.db_name,
+            "db_user": self.username,
+            "db_password": self.password,
+        }
+
     @contextmanager
     def connect(self):
         connection = self.get_connection()

godoo_cli-0.9.3/src/godoo_cli/commands/db/query.py

@@ -0,0 +1,125 @@
+import logging
+from enum import Enum
+
+import typer
+from psycopg2 import OperationalError, ProgrammingError
+
+from ...cli_common import CommonCLI
+from ...helpers.cli import check_dangerous_command
+from .connection import DBConnection
+
+
+class DB_BOOTSTRAP_STATUS(Enum):
+    BOOTSTRAPPED = 0
+    NO_DB = 1
+    EMPTY_DB = 2
+
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+@CLI.arg_annotator
+def query_database(
+    query: str = typer.Argument(..., help="SQL Query"),
+    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,
+):
+    """Run a Query against the database."""
+
+    check_dangerous_command()
+    # regex to check if SQL query contains writing command
+
+    connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+    with connection.connect() as cursor:
+        try:
+            LOGGER.info("Running Query: %s", query)
+            cursor.execute(query)
+            LOGGER.info("Affected Rows: %s", cursor.rowcount)
+            try:
+                rows = cursor.fetchall()
+                for row in rows:
+                    print("\t".join(row))  # pylint: disable=print-used
+            except ProgrammingError:
+                pass
+        except Exception as e:
+            LOGGER.exception(e)
+            raise typer.Exit(1)
+
+
+def _is_bootstrapped(db_connection: DBConnection) -> DB_BOOTSTRAP_STATUS:
+    """check if postgres contains database db_name and if this database has any tables present"""
+    try:
+        with db_connection.connect() as cursor:
+            cursor.execute("SELECT EXISTS (SELECT 1 FROM pg_tables WHERE schemaname = 'public');")
+            if not cursor.fetchone()[0]:
+                LOGGER.warning("Database %s is empty", db_connection.db_name)
+                return DB_BOOTSTRAP_STATUS.EMPTY_DB
+            LOGGER.debug("Database %s is not empty", db_connection.db_name)
+            return DB_BOOTSTRAP_STATUS.BOOTSTRAPPED
+    except OperationalError:
+        LOGGER.warning("Database %s does not exist", db_connection.db_name)
+        return DB_BOOTSTRAP_STATUS.NO_DB
+
+
+@CLI.arg_annotator
+def is_bootstrapped(
+    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,
+):
+    """Check if the database is empty. Return code  = 1 if database does not exist, 2 if database is empty, 0 if database is not empty."""
+    check_dangerous_command()
+    connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+    boot = _is_bootstrapped(db_connection=connection)
+    raise typer.Exit(boot.value)
+
+
+def _get_installed_modules(db_connection: DBConnection):
+    """Get list of installed modules in database"""
+    if boot := _is_bootstrapped(db_connection=db_connection) != DB_BOOTSTRAP_STATUS.BOOTSTRAPPED:
+        return boot.value
+    with db_connection.connect() as cursor:
+        cursor.execute("SELECT name FROM ir_module_module WHERE state = 'installed';")
+        sql_res = cursor.fetchall()
+        return [r[0] for r in sql_res]
+
+
+@CLI.arg_annotator
+def get_installed_modules(
+    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,
+):
+    """Returns Modules Marked as installed by Odoo in the database"""
+    db_connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+    installed_modules = _get_installed_modules(db_connection=db_connection)
+    if isinstance(installed_modules, int):
+        raise typer.Exit(installed_modules)
+    for module in sorted(installed_modules):
+        print(module)  # pylint: disable=print-used

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/launch.py

@@ -10,6 +10,8 @@ from ..cli_common import CommonCLI
 from ..helpers.odoo_files import get_odoo_module_paths, odoo_bin_get_version
 from ..helpers.system import run_cmd
 from .bootstrap import bootstrap_odoo
+from .db.connection import DBConnection
+from .db.query import DB_BOOTSTRAP_STATUS, _is_bootstrapped
 from .rpc import import_to_odoo
 from .source_get import py_depends_by_db, update_odoo_conf
 
@@ -60,11 +62,7 @@ def pre_launch(
     thirdparty_addon_path: Path,
     odoo_conf_path: Path,
     db_filter: str,
-    db_host: str,
-    db_port: int,
-    db_name: str,
-    db_user: str,
-    db_password: str,
+    db_connection: DBConnection,
     odoo_demo: bool,
     dev_mode: bool,
     multithread_worker_count: int = 0,
@@ -89,16 +87,8 @@ def pre_launch(
         path to odoo conf
     db_filter : str
         odoo.conf db_filter
-    db_host : str
-        database host url. Empty string for Unix sock
-    db_port : int
-        database port. 0 for unix sock
-    db_name : str
-        odoo main database name
-    db_user : str
-        database user
-    db_password : str
-        database password
+    db_connection : DBConnection
+        DBConnection object
     odoo_demo : bool
         if false, add --without-demo to bootstrap
     dev_mode : bool
@@ -142,12 +132,8 @@ def pre_launch(
         if not odoo_demo:
             _extra_bootstrap_args += ["--without-demo all"]
         ret = bootstrap_odoo(
-            db_name=db_name,
+            **db_connection.cli_dict,
             db_filter=db_filter,
-            db_user=db_user,
-            db_password=db_password,
-            db_host=db_host,
-            db_port=db_port,
             thirdparty_addon_path=thirdparty_addon_path,
             odoo_main_path=odoo_main_path,
             odoo_conf_path=odoo_conf_path,
@@ -172,6 +158,9 @@ def pre_launch(
     odoo_main_path = odoo_main_path
     odoo_version = odoo_bin_get_version(odoo_main_path)
 
+    if _is_bootstrapped(db_connection) != DB_BOOTSTRAP_STATUS.BOOTSTRAPPED:
+        return 404
+
     update_odoo_conf(
         odoo_conf=odoo_conf_path,
         odoo_main_path=odoo_main_path,
@@ -183,11 +172,7 @@ def pre_launch(
             odoo_main_path=odoo_main_path,
             workspace_addon_path=workspace_addon_path,
             thirdparty_addon_path=thirdparty_addon_path,
-            db_host=db_host,
-            db_port=db_port,
-            db_name=db_name,
-            db_user=db_user,
-            db_password=db_password,
+            **db_connection.cli_dict,
         )
 
     if dev_mode:
@@ -224,26 +209,28 @@ def launch_odoo(
     dev_mode=CLI.odoo_launch.dev_mode,
     install_workspace_modules=CLI.odoo_launch.install_workspace_modules,
     extra_args=CLI.odoo_launch.extra_cmd_args,
-    extra_bootstrap_args=CLI.odoo_launch.extra_cmd_args,
+    extra_bootstrap_args=CLI.odoo_launch.extra_cmd_args_bootstrap,
     log_file_path=CLI.odoo_launch.log_file_path,
     multithread_worker_count=CLI.odoo_launch.multithread_worker_count,
     languages=CLI.odoo_launch.languages,
 ):
     """
-    Launch Odoo, Bootstrap if bootstrapflag is not present.
+    Launch Odoo, Bootstrap if db is empty.
     """
-
+    db_connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
     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,
+        db_connection=db_connection,
         odoo_demo=odoo_demo,
         dev_mode=dev_mode,
         install_workspace_addons=install_workspace_modules,
@@ -285,11 +272,18 @@ def launch_import(
     dev_mode=CLI.odoo_launch.dev_mode,
     install_workspace_modules=CLI.odoo_launch.install_workspace_modules,
     extra_launch_args=CLI.odoo_launch.extra_cmd_args,
-    extra_bootstrap_args=CLI.odoo_launch.extra_cmd_args,
+    extra_bootstrap_args=CLI.odoo_launch.extra_cmd_args_bootstrap,
     log_file_path=CLI.odoo_launch.log_file_path,
     multithread_worker_count=CLI.odoo_launch.multithread_worker_count,
 ):
     """Bootstrap and Start odoo. Launches RPC import in second thread."""
+    db_connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
 
     launch_cmd = pre_launch(
         odoo_main_path=odoo_main_path,
@@ -297,11 +291,7 @@ def launch_import(
         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,
+        db_connection=db_connection,
         odoo_demo=odoo_demo,
         dev_mode=dev_mode,
         install_workspace_addons=install_workspace_modules,

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/source_get.py

@@ -17,6 +17,7 @@ from ..helpers.odoo_files import get_addon_paths, get_odoo_module_paths, get_zip
 from ..helpers.odoo_manifest import remove_unused_folders
 from ..helpers.system import download_file
 from .db.connection import DBConnection
+from .db.query import _get_installed_modules
 
 LOGGER = logging.getLogger(__name__)
 CLI = CommonCLI()
@@ -109,28 +110,47 @@ def py_depends_by_db(
     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,
+    connection = DBConnection(hostname=db_host, port=db_port, username=db_user, password=db_password, db_name=db_name)
+    module_list = _get_installed_modules(connection)
+    if isinstance(module_list, int):
+        return CLI.returner(module_list)
+    LOGGER.info("Ensuring Py Reqiurements for Installed Modules are met")
+    LOGGER.debug("Modules:\n%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,
     )
-    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("Ensuring Py Reqiurements for Installed Modules are met")
-        LOGGER.debug("Modules:\n%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)
+    module_list = [m for m in module_list if m != "base"]
+    _install_py_reqs_for_modules(odoo_addon_paths, module_list)
+
+
+@CLI.arg_annotator
+def get_installed_module_paths(
+    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,
+):
+    """Get Paths of all installed modules in DB."""
+    connection = DBConnection(hostname=db_host, port=db_port, username=db_user, password=db_password, db_name=db_name)
+    module_list = _get_installed_modules(connection)
+    if isinstance(module_list, int):
+        return CLI.returner(module_list)
+    LOGGER.debug("Searching Folders for:\n%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,
+    )
+    module_list = [m for m in module_list if m != "base"]
+    module_paths = get_odoo_module_paths(odoo_addon_paths, module_names=module_list)
+    for p in module_paths:
+        print(p.absolute())  # pylint: disable=print-used
 
 
 @CLI.unpacker
@@ -276,5 +296,6 @@ def source_cli_app():
     app.command("get-file")(get_source_file)
     app.command("get-dependencies")(py_depends_by_modules)
     app.command("get-dependencies-db")(py_depends_by_db)
+    app.command("installed-module-paths")(get_installed_module_paths)
 
     return app

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/test/test_load_data.py

@@ -5,6 +5,7 @@ import typer
 
 from ...cli_common import CommonCLI
 from ...helpers.system import run_cmd
+from ..db.connection import DBConnection
 from ..launch import pre_launch
 from ..shell import odoo_shell
 
@@ -56,17 +57,21 @@ def odoo_load_test_data(
     if extra_launch_args:
         launch_args = extra_launch_args + launch_args
 
+    db_connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+
     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,
+        db_connection=db_connection,
         dev_mode=False,
         install_workspace_addons=False,
         extra_launch_args=launch_args,

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/commands/test/test_run.py

@@ -9,6 +9,7 @@ from typing_extensions import Annotated
 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 ..db.connection import DBConnection
 from ..launch import pre_launch
 from ..shell import odoo_pregenerate_assets
 
@@ -113,17 +114,21 @@ def odoo_run_tests(
 
     bootstrap_args = extra_bootstrap_args + bootstrap_args
 
+    db_connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+
     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,
+        db_connection=db_connection,
         dev_mode=False,
         install_workspace_addons=False,
         extra_launch_args=launch_args,

godoo_cli-0.9.3/src/godoo_cli/git/git_odoo.py

@@ -0,0 +1,46 @@
+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", "")
+
+    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)

{godoo_cli-0.8.6 → godoo_cli-0.9.3}/src/godoo_cli/helpers/odoo_files.py

@@ -4,7 +4,7 @@ import re
 from ast import literal_eval
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Union
+from typing import List, Optional, Union
 
 from git import Repo
 
@@ -26,7 +26,7 @@ class OdooVersion:
         return f"{self.major}.{self.minor}"
 
 
-def odoo_bin_get_version(odoo_main_repo_path: Path) -> str:
+def odoo_bin_get_version(odoo_main_repo_path: Path) -> OdooVersion:
     """Get Odoo Version by calling 'odoo-bin --version'
 
     Parameters
@@ -71,13 +71,18 @@ def folder_is_odoo_module(folder: Path) -> bool:
     return folder.is_dir() and any(folder.glob("__manifest__.py"))
 
 
-def get_odoo_module_paths(search_folders: Union[List[Path], Path]) -> List[Path]:
+def get_odoo_module_paths(
+    search_folders: Union[List[Path], Path],
+    module_names: Optional[List[str]] = None,
+) -> List[Path]:
     """List all Valid odoo module names in one or many Odoo addons folder.
 
     Parameters
     ----------
     search_folders : Path
         Folder(s) to search in.
+    module_names : Optional[List[str]], optional
+        Filter for module names, by default None
 
     Returns
     -------
@@ -94,6 +99,11 @@ def get_odoo_module_paths(search_folders: Union[List[Path], Path]) -> List[Path]
         for folder in folder.iterdir():
             if folder_is_odoo_module(folder):
                 module_paths.append(folder)
+    if module_names:
+        filtered_module_paths = [p for p in module_paths if p.stem in module_names]
+        if unavailable_modules := set(module_names).difference([p.stem for p in filtered_module_paths]):
+            LOGGER.warning("Could not find Module folder for: %s", unavailable_modules)
+        return filtered_module_paths
     return module_paths
 
 
@@ -143,7 +153,7 @@ def get_changed_modules(
 def get_depends_of_module(
     all_modules: List[Path],
     module_to_check: Path,
-    already_done_modules: List[Path] = None,
+    already_done_modules: Optional[List[Path]] = None,
 ):
     """Recursively Searches sub dependencies for Odoo modules.
 
@@ -253,18 +263,7 @@ def _get_python_requirements_of_modules(addon_paths: List[Path], filter_module_n
         Modules to look for manifests, by default all available modules
     """
     available_modules = get_odoo_module_paths(addon_paths)
-    available_module_names = [p.stem for p in available_modules]
-
-    if not filter_module_names:
-        filter_module_names = available_module_names
-    filter_module_names = [f for f in filter_module_names if f != "base"]
-
-    LOGGER.debug("Checking python requirements of Modules: %s", sorted(filter_module_names))
-    if unavailable_modules := set(filter_module_names).difference(available_module_names):
-        LOGGER.warning("Could not find __manifest__ for: %s", unavailable_modules)
-        LOGGER.debug("Search Paths:\n%s", map(str, addon_paths))
-
-    check_modules = [mp for mp in available_modules if mp.stem in filter_module_names]
+    check_modules = get_odoo_module_paths(addon_paths, module_names=filter_module_names)
 
     if odoo_main_path := _get_odoo_main_path(addon_paths):
         # When the Odoo main path is in the supplied path, exclude those modules.

godoo_cli-0.9.3/src/godoo_cli/version.py

@@ -0,0 +1 @@
+__version__ = "0.9.3"

godoo_cli-0.8.6/src/godoo_cli/commands/db/query.py

@@ -1,48 +0,0 @@
-import logging
-
-import typer
-from psycopg2 import ProgrammingError
-
-from ...cli_common import CommonCLI
-from ...helpers.cli import check_dangerous_command
-from .connection import DBConnection
-
-LOGGER = logging.getLogger(__name__)
-CLI = CommonCLI()
-
-
-@CLI.arg_annotator
-def query_database(
-    query: str = typer.Argument(..., help="SQL Query"),
-    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,
-):
-    """Run a Query against the database."""
-
-    check_dangerous_command()
-    # regex to check if SQL query contains writing command
-
-    connection = DBConnection(
-        hostname=db_host,
-        port=db_port,
-        username=db_user,
-        password=db_password,
-        db_name=db_name,
-    )
-    with connection.connect() as cursor:
-        try:
-            LOGGER.info("Running Query: %s", query)
-            cursor.execute(query)
-            LOGGER.info("Affected Rows: %s", cursor.rowcount)
-            try:
-                rows = cursor.fetchall()
-                for row in rows:
-                    print("\t".join(row))  # pylint: disable=print-used
-            except ProgrammingError:
-                pass
-        except Exception as e:
-            LOGGER.exception(e)
-            raise typer.Exit(1)

godoo_cli-0.8.6/src/godoo_cli/git/git_odoo.py

@@ -1,89 +0,0 @@
-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"))

godoo_cli-0.8.6/src/godoo_cli/version.py

@@ -1 +0,0 @@
-__version__ = "0.8.6"