odoo-version-manager 0.0.10__tar.gz

odoo-version-manager-0.0.10/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Marc Wimmer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

odoo-version-manager-0.0.10/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.1
+Name: odoo-version-manager
+Version: 0.0.10
+Summary: Manage Versions of module along all odoo version
+Home-page: https://github.com/odoo-module-version-manager.git
+Author: Marc-Christian Wimmer
+Author-email: marc@zebroo.de
+License: MIT
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# odoo-version-manager
+
+Helps handling updates on main branch of a module to be deployed to all sub branches.
+It uses github workflows to accomplish this.
+
+## installing
+
+```bash
+pipx install odoo-version-manager
+odoo-version-manager completion -x
+```
+
+# usage
+
+## initial setup
+
+- create a repository like an OCA repository with some modules on branch **main**
+- decide which version the main branch is for example 16.0
+
+```
+odoo-version-manager setup 16.0
+```
+
+## set another odoo version for main branch
+
+If you move on and main branch becomes odoo version 18.0 instead of 16.0 do the following:
+
+```
+git checkout main
+git reset --hard origin/18.0
+odoo-version-manager setup 18.0
+```

odoo-version-manager-0.0.10/README.md

@@ -0,0 +1,32 @@
+# odoo-version-manager
+
+Helps handling updates on main branch of a module to be deployed to all sub branches.
+It uses github workflows to accomplish this.
+
+## installing
+
+```bash
+pipx install odoo-version-manager
+odoo-version-manager completion -x
+```
+
+# usage
+
+## initial setup
+
+- create a repository like an OCA repository with some modules on branch **main**
+- decide which version the main branch is for example 16.0
+
+```
+odoo-version-manager setup 16.0
+```
+
+## set another odoo version for main branch
+
+If you move on and main branch becomes odoo version 18.0 instead of 16.0 do the following:
+
+```
+git checkout main
+git reset --hard origin/18.0
+odoo-version-manager setup 18.0
+```

odoo-version-manager-0.0.10/odoo_version_manager/__init__.py

@@ -0,0 +1,50 @@
+import click
+import subprocess
+import os
+import sys
+from pathlib import Path
+from .config import pass_config
+from .config import Config
+import shellingham
+from click_default_group import DefaultGroup
+
+global_data = {
+    'config': None
+}
+
+@click.group()
+@pass_config
+def cli(config):
+    global_data['config'] = config
+
+
+
+@cli.command()
+def install_completion():
+    def setup_for_shell_generic(shell, shell_call):
+        path = Path(f"/etc/{shell}_completion.d")
+        NAME = shell_call.upper().replace("-", "_")
+        completion = subprocess.check_output([sys.argv[0]], env={f"_{NAME}_COMPLETE": f"{shell}_source"}, shell=True)
+        if path.exists():
+            if os.access(path, os.W_OK):
+                (path / shell_call).write_bytes(completion)
+                return
+
+        if not (path / shell_call).exists():
+            rc = Path(os.path.expanduser("~")) / f'.{shell}rc'
+            if not rc.exists():
+                return
+            complete_file = rc.parent / f'.{shell_call}-completion.sh'
+            complete_file.write_bytes(completion)
+            if complete_file.name not in rc.read_text():
+                content = rc.read_text()
+                content += '\nsource ~/' + complete_file.name
+                rc.write_text(content)
+
+    name = Path(sys.argv[0]).name
+    setup_for_shell_generic(shellingham.detect_shell()[0], name)
+    sys.exit(0)
+
+from . import odoo_version_manager
+from . import gitcommands
+from . import repo

odoo-version-manager-0.0.10/odoo_version_manager/config.py

@@ -0,0 +1,86 @@
+import atexit
+import click
+import logging
+from pathlib import Path
+import sys
+import json
+import os
+from contextlib import contextmanager
+import configparser
+from paramiko.config import SSHConfig
+import subprocess
+
+BASE_PATH = Path(os.path.expanduser("~/.fetch_latest_file.d"))
+SSH_CONFIG = Path(os.path.expanduser("~/.ssh/config"))
+
+class Config(object):
+    def __init__(self):
+        super().__init__()
+        self.sources = {}
+        self.source = None
+        if BASE_PATH.exists():
+            for file in BASE_PATH.glob("*"):
+                if file.name.startswith('.'):
+                    continue
+                for section, config in self.parse_file(file):
+                    self.sources[section] = config
+
+        def cleanup():
+            pass
+
+        atexit.register(cleanup)
+
+    def parse_file(self, file):
+        config = configparser.ConfigParser()
+        config.read(file)
+        for section in config.sections():
+            yield (section, config[section])
+
+    @contextmanager
+    def shell(self):
+        config = self.get_source()
+
+        def execute(cmd):
+            output = subprocess.check_output([
+                "ssh", config['host'],
+            ] + cmd)
+            output = output.decode('utf-8').split("\n")
+            return output
+
+        yield config, execute
+
+    def add(self, filename, host, username, path, regex, destination):
+        path = BASE_PATH / Path(filename).name
+        config = configparser.ConfigParser()
+        BASE_PATH.mkdir(exist_ok=True, parents=True)
+        if path.exists():
+            config.read(path)
+        config[self.source] = {
+            "host": host,
+            "path": path,
+            "regex": regex,
+            "destination": destination,
+        }
+        if username:
+            config[self.source]['username'] = username
+        with open(path, 'w') as configfile:
+            config.write(configfile)
+
+    def get_source(self):
+        if not self.source:
+            raise Exception("Please define a source first!")
+        return self.sources[self.source]
+
+    def setup_logging(self):
+        FORMAT = '[%(levelname)s] %(asctime)s %(message)s'
+        formatter = logging.Formatter(FORMAT)
+        logging.basicConfig(format=FORMAT)
+        self.logger = logging.getLogger('')  # root handler
+        self.logger.setLevel(self.log_level)
+
+        stdout_handler = logging.StreamHandler(sys.stdout)
+        self.logger.addHandler(stdout_handler)
+        stdout_handler.setFormatter(formatter)
+
+
+pass_config = click.make_pass_decorator(Config, ensure=True)

odoo-version-manager-0.0.10/odoo_version_manager/consts.py

@@ -0,0 +1,5 @@
+gitcmd = ["git", "-c", "protocol.file.allow=always"]
+odoo_versions = [11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0]
+
+github_workflow_file = ".github/workflows/deploy_patches.yml"
+version_behind_main_branch = ".github/version_behind_main_branch"

odoo-version-manager-0.0.10/odoo_version_manager/filelock.py

@@ -0,0 +1,82 @@
+import os
+import time
+import errno
+
+
+class FileLockException(Exception):
+    pass
+
+
+class FileLock(object):
+    """A file locking mechanism that has context-manager support so
+    you can use it in a with statement. This should be relatively cross
+    compatible as it doesn't rely on msvcrt or fcntl for the locking.
+    """
+
+    def __init__(self, file_name, timeout=10, delay=0.05):
+        """Prepare the file locker. Specify the file to lock and optionally
+        the maximum timeout and the delay between each attempt to lock.
+        """
+        if timeout is not None and delay is None:
+            raise ValueError("If timeout is not None, then delay must not be None.")
+        self.is_locked = False
+        self.lockfile = os.path.join(os.getcwd(), "%s.lock" % file_name)
+        self.file_name = file_name
+        self.timeout = timeout
+        self.delay = delay
+
+    def acquire(self):
+        """Acquire the lock, if possible. If the lock is in use, it check again
+        every `wait` seconds. It does this until it either gets the lock or
+        exceeds `timeout` number of seconds, in which case it throws
+        an exception.
+        """
+        start_time = time.time()
+        while True:
+            try:
+                self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)
+                self.is_locked = True  # moved to ensure tag only when locked
+                break
+            except OSError as e:
+                if e.errno != errno.EEXIST:
+                    raise
+                if self.timeout is None:
+                    raise FileLockException(
+                        "Could not acquire lock on {}".format(self.file_name)
+                    )
+                if (time.time() - start_time) >= self.timeout:
+                    raise FileLockException("Timeout occured.")
+                time.sleep(self.delay)
+
+    #        self.is_locked = True
+
+    def release(self):
+        """Get rid of the lock by deleting the lockfile.
+        When working in a `with` statement, this gets automatically
+        called at the end.
+        """
+        if self.is_locked:
+            os.close(self.fd)
+            os.unlink(self.lockfile)
+            self.is_locked = False
+
+    def __enter__(self):
+        """Activated when used in the with statement.
+        Should automatically acquire a lock to be used in the with block.
+        """
+        if not self.is_locked:
+            self.acquire()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        """Activated at the end of the with statement.
+        It automatically releases the lock if it isn't locked.
+        """
+        if self.is_locked:
+            self.release()
+
+    def __del__(self):
+        """Make sure that the FileLock instance doesn't leave a lockfile
+        lying around.
+        """
+        self.release()

odoo-version-manager-0.0.10/odoo_version_manager/gitcommands.py

@@ -0,0 +1,165 @@
+import os
+from pathlib import Path
+from .tools import yieldlist, X, wait_git_lock
+from .consts import gitcmd as git
+
+
+class GitCommands(object):
+    def __init__(self, path=None):
+        self.path = Path(path or os.getcwd())
+        self.path_absolute = self.path.absolute()
+
+    @property
+    def configdir(self):
+        from .repo import Repo
+
+        stop_at = Repo(self.path_absolute).root_repo
+        here = self.path_absolute
+        while True:
+            default = here / ".git"
+            if default.exists() and default.is_dir():
+                return default
+            if default.is_file():
+                path = default.read_text().strip().split("gitdir:")[1].strip()
+                return (here / path).resolve()
+
+            if here == stop_at:
+                break
+            here = here.parent
+        raise Exception("Config dir not found")
+
+    def X(self, *params, allow_error=False, env=None, output=None):
+        if output is None:
+            output = False
+        with wait_git_lock(self.path_absolute):
+            kwparams = {
+                "output": output,
+                "allow_error": allow_error,
+                "env": env,
+            }
+            if self.path.exists():
+                # case not existing at recreating cache dir e.g.
+                kwparams["cwd"] = self.path
+            return X(*params, **kwparams)
+
+    def out(self, *params, allow_error=False, env=None):
+        return X(*params, output=True, cwd=self.path, allow_error=allow_error, env=env)
+
+    def _parse_git_status(self):
+        for line in X(
+            *(
+                git
+                + [
+                    "status",
+                    "--porcelain",
+                    "--untracked-files=all",
+                ]
+            ),
+            cwd=self.path_absolute,
+            output=True,
+        ).splitlines():
+            # splits: A  asdas
+            #         M   asdasd
+            #          M  asdsad
+            #         ??  asasdasd
+            modifier = line[:2]
+            path = line.strip().split(" ", 1)[1].strip()
+            if path.startswith(".."):
+                continue
+
+            yield modifier, Path(path)
+
+    @property
+    @yieldlist
+    def staged_files(self):
+        for modifier, path in self._parse_git_status():
+            if modifier[0] in ["A", "M", "D"]:
+                yield path
+
+    @property
+    @yieldlist
+    def dirty_existing_files(self):
+        for modifier, path in self._parse_git_status():
+            if modifier[0] == "M" or modifier[1] == "M" or modifier[1] == "D":
+                yield path
+
+    @property
+    @yieldlist
+    def all_dirty_files(self):
+        return self.untracked_files + self.dirty_existing_files
+
+    @property
+    @yieldlist
+    def all_dirty_files_absolute(self):
+        res = self.untracked_files + self.dirty_existing_files
+        res = list(map(lambda x: self.path_absolute / x, res))
+        return res
+
+    @property
+    @yieldlist
+    def untracked_files(self):
+        for modifier, path in self._parse_git_status():
+            if modifier == "??" or modifier[0] == "A":
+                yield path
+
+    @property
+    @yieldlist
+    def untracked_files_absolute(self):
+        for file in self.untracked_files:
+            yield self.path_absolute / file
+
+    @property
+    def dirty(self):
+        return bool(list(self._parse_git_status()))
+
+    def is_submodule(self, path):
+        path = self._combine(path)
+        for line in X(
+            *(git + ["submodule", "status"]), output=True, cwd=self.path_absolute
+        ).splitlines():
+            line = line.strip()
+            _, _path, _ = line.split(" ", 2)
+            if _path == str(path.relative_to(self.path_absolute)):
+                return path
+
+    def _combine(self, path):
+        """
+        Makes a new path
+        """
+        path = self.path / path
+        path.relative_to(self.path)
+        return path
+
+    def output_status(self):
+        self.X(*(git + ["status"]))
+
+    def get_all_branches(self):
+        res = list(
+            map(
+                lambda x: x.strip(),
+                self.out(
+                    *(git + ["for-each-ref", "--format=%(refname:short)", "refs/heads"])
+                ).splitlines(),
+            )
+        )
+        return res
+
+    @property
+    def dirty(self):
+        files = []
+        for modifier, path in self._parse_git_status():
+            if str(path) == "gimera.yml":
+                continue
+            files.append(path)
+        return bool(files)
+
+    def simple_commit_all(self, msg="."):
+        self.X(*(git + ["add", "."]))
+        self.X(*(git + ["commit", "--allow-empty", "-am", msg]))
+
+    @property
+    def hex(self):
+        return self.out(*(git + ["log", "-n", "1", "--pretty=%H"]))
+
+    def checkout(self, ref, force=False):
+        self.X(*(git + ["checkout", "-f" if force else None, ref]))