half-orm-dev 0.16.0a1__py3-none-any.whl

half_orm_dev/changelog.py

@@ -0,0 +1,117 @@
+"""The changelog module
+
+Manages the CHANGELOG file. The file contains the log of the patches (released) and in preparation.
+
+A line is of the form:
+<hop version>\t<release number>\t<commit>\t<previous commit>
+
+* hop version allows to check that the good hop version is used to apply the patch in production
+* release number is an ordered list of release number
+* commit is the git sha1 corresponding to the release of the patch. If empty, the patch is in
+  preparation.
+* previous commit is the last commit on hop_main before the rebase of hop_<release>
+
+"""
+
+import os
+
+from half_orm import utils
+from .utils import hop_version
+
+class Changelog:
+    "The Changelog class..."
+    __log_list = []
+    __log_dict = {}
+    __releases = []
+    def __init__(self, repo):
+        self.__repo = repo
+        self.__file = os.path.join(self.__repo.base_dir, '.hop', 'CHANGELOG')
+        if not os.path.exists(self.__file):
+            utils.write(
+                self.__file,
+                f'{hop_version()}\t{self.__repo.database.last_release_s}\tInitial\t\n')
+            self.__repo.hgit.add(self.__file)
+            self.__repo.hgit.commit('-m', '[hop] Initial CHANGELOG')
+        self.__seq()
+
+    def __seq(self):
+        self.__log_list = [elt.strip('\n').split('\t') for elt in utils.readlines(self.__file)]
+        self.__log_dict = {elt[1]: elt for elt in self.__log_list}
+        self.__releases = list(self.__log_dict.keys())
+
+    @staticmethod
+    def _sort_releases(releases):
+        "Sort the releases"
+        int_releases = list([tuple(int(elt) for elt in release.split('.'))
+            for release in releases])
+        int_releases.sort()
+        releases = list([".".join(str(elt) for elt in release)
+            for release in int_releases])
+        return releases
+
+    def new_release(self, release):
+        """Update with the release the .hop/CHANGELOG file"""
+        releases = self.__releases
+        releases.append(release)
+        releases = Changelog._sort_releases(releases)
+        utils.write(self.__file, '')
+        for elt in releases:
+            rel = self.__log_dict.get(elt)
+            if rel:
+                utils.write(self.__file, f'{rel[0]}\t{rel[1]}\t{rel[2]}\t{rel[3]}\n', mode='a+')
+            else:
+                utils.write(self.__file, f'{hop_version()}\t{release}\t\t\n', mode='a+')
+        self.__seq()
+
+    def update_release(self, release, commit, previous_commit):
+        "Add the commit sha1 to the release in the .hop/CHANGELOG file"
+        out = []
+        previous = self.previous(release, 1)
+        for line in utils.readlines(self.__file):
+            if line and line.split()[1] not in {release, previous}:
+                out.append(line)
+            elif line.split()[1] == previous:
+                elt = line.split()
+                out.append(f'{elt[0]}\t{elt[1]}\t{elt[2]}\t{previous_commit}\n')
+            else:
+                out.append(f'{hop_version()}\t{release}\t{commit}\t\n')
+        utils.write(self.__file, ''.join(out))
+        self.__repo.hgit.add(self.__file)
+        # self.__repo.hgit.commit('-m', f'[hop][{release}] CHANGELOG')
+        self.__seq()
+
+    def previous(self, release, index):
+        "Return previous release of release."
+        index_of_release = self.__releases.index(release)
+        return self.__releases[index_of_release - index]
+
+    @property
+    def file(self):
+        "Return the name of the changelog file"
+        return self.__file
+
+    @property
+    def last_release(self):
+        "Return the sequence"
+        releases = [elt[1] for elt in self.__log_list if elt[2]]
+        return releases[-1]
+
+    @property
+    def releases_in_dev(self):
+        "Returns the list of patches in dev (not released)"
+        return [elt[1] for elt in self.__log_list if not elt[2]]
+
+    @property
+    def releases_to_apply_in_prod(self):
+        "Returns the list of releases to apply in production"
+        current = self.__repo.database.last_release_s
+        releases_to_apply = []
+        to_apply = False
+        for elt in self.__log_list:
+            if elt[1] == current:
+                # we're here
+                to_apply = True
+                continue
+            if to_apply and elt[2]:
+                releases_to_apply.append(elt[1])
+        return releases_to_apply

half_orm_dev/cli_extension.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+CLI extension integration for half-orm-dev
+
+Provides the halfORM development tools through the unified half_orm CLI interface.
+Generates/Patches/Synchronizes a hop Python package with a PostgreSQL database.
+"""
+
+import sys
+import click
+from half_orm.cli_utils import create_and_register_extension
+
+# Import existing halfORM_dev functionality
+from half_orm_dev.repo import Repo
+from half_orm import utils
+
+class Hop:
+    """Sets the options available to the hop command"""
+    __available_cmds = []
+    __command = None
+    
+    def __init__(self):
+        self.__repo: Repo = Repo()
+        if not self.repo_checked:
+            Hop.__available_cmds = ['new']
+        else:
+            if not self.__repo.devel:
+                # Sync-only mode
+                Hop.__available_cmds = ['sync-package']
+            else:
+                # Full mode - check environment
+                if self.__repo.production:
+                    Hop.__available_cmds = ['upgrade', 'restore']
+                else:
+                    Hop.__available_cmds = ['prepare', 'apply', 'release', 'undo']
+    
+    @property
+    def repo_checked(self):
+        """Returns whether we are in a repo or not."""
+        return self.__repo.checked
+
+    @property
+    def model(self):
+        """Returns the model (half_orm.model.Model) associated to the repo."""
+        return self.__repo.model
+
+    @property
+    def state(self):
+        """Returns the state of the repo."""
+        return self.__repo.state
+
+    @property
+    def command(self):
+        """The command invoked (click)"""
+        return self.__command
+
+def add_commands(main_group):
+    """
+    Required entry point for halfORM extensions.
+    
+    Args:
+        main_group: The main Click group for the half_orm command
+    """
+    
+    # Create hop instance to determine available commands
+    hop = Hop()
+    
+    @create_and_register_extension(main_group, sys.modules[__name__])
+    def dev():
+        """halfORM development tools - project management, patches, and database synchronization"""
+        pass
+    
+    # Define all possible commands
+    @click.command()
+    @click.argument('package_name')
+    @click.option('-d', '--devel', is_flag=True, help="Development mode")
+    def new(package_name, devel=False):
+        """Creates a new hop project named <package_name>."""
+        hop._Hop__repo.init(package_name, devel)
+
+    @click.command()
+    @click.option(
+        '-l', '--level',
+        type=click.Choice(['patch', 'minor', 'major']), help="Release level.")
+    @click.option('-m', '--message', type=str, help="The git commit message")
+    def prepare(level, message=None):
+        """Prepares the next release."""
+        hop._Hop__command = 'prepare'
+        hop._Hop__repo.prepare_release(level, message)
+        sys.exit()
+
+    @click.command()
+    def apply():
+        """Apply the current release."""
+        hop._Hop__command = 'apply'
+        hop._Hop__repo.apply_release()
+
+    @click.command()
+    @click.option(
+        '-d', '--database-only', is_flag=True,
+        help='Restore the database to the previous release.')
+    def undo(database_only):
+        """Undo the last release."""
+        hop._Hop__command = 'undo'
+        hop._Hop__repo.undo_release(database_only)
+
+    @click.command()
+    def upgrade():
+        """Apply one or many patches.
+        
+        Switches to hop_main, pulls should check the tags.
+        """
+        hop._Hop__command = 'upgrade_prod'
+        hop._Hop__repo.upgrade_prod()
+
+    @click.command()
+    @click.argument('release')
+    def restore(release):
+        """Restore to release."""
+        hop._Hop__repo.restore(release)
+
+    @click.command()
+    @click.option('-p', '--push', is_flag=True, help='Push git repo to origin')
+    def release(push=False):
+        """Commit and optionally push the current release."""
+        hop._Hop__repo.commit_release(push)
+
+    @click.command()
+    def sync_package():
+        """Synchronize the Python package with the database model."""
+        hop._Hop__repo.sync_package()
+
+    # Map command names to command functions
+    all_commands = {
+        'new': new,
+        'prepare': prepare,
+        'apply': apply,
+        'undo': undo,
+        'release': release,
+        'sync-package': sync_package,
+        'upgrade': upgrade,
+        'restore': restore
+    }
+    
+    # 🎯 COMPORTEMENT ADAPTATIF RESTAURÉ
+    # Only add commands that are available in the current context
+    for cmd_name in hop._Hop__available_cmds:
+        if cmd_name in all_commands:
+            dev.add_command(all_commands[cmd_name])
+    
+    # Add callback to show state when no subcommand (like original hop)
+    original_callback = dev.callback
+    
+    @click.pass_context
+    def enhanced_callback(ctx, *args, **kwargs):
+        if ctx.invoked_subcommand is None:
+            # Show repo state when no subcommand is provided
+            if hop.repo_checked:
+                click.echo(hop.state)
+            else:
+                click.echo(hop.state)
+                click.echo("\nNot in a hop repository.")
+                click.echo(f"Try {utils.Color.bold('half_orm dev new [--devel] <package_name>')} or change directory.\n")
+        else:
+            # Call original callback if there is one
+            if original_callback:
+                return original_callback(*args, **kwargs)
+    
+    dev.callback = enhanced_callback

half_orm_dev/database.py

@@ -0,0 +1,127 @@
+"""Provides the Database class
+"""
+
+import os
+import subprocess
+import sys
+
+from psycopg2 import OperationalError
+from half_orm.model import Model
+from half_orm.model_errors import UnknownRelation
+from half_orm import utils
+from half_orm_dev.db_conn import DbConn
+from .utils import HOP_PATH
+
+
+class Database:
+    """Reads and writes the halfORM connection file
+    """
+
+    def __init__(self, repo, get_release=True):
+        self.__repo = repo
+        self.__model = None
+        self.__last_release = None
+        self.__connection_params: DbConn = DbConn(self.__repo.name)
+        if self.__repo.name:
+            try:
+                self.__model = Model(self.__repo.name)
+                self.__init(self.__repo.name, get_release)
+            except OperationalError as err:
+                if not self.__repo.new:
+                    utils.error(err, 1)
+
+    def __call__(self, name):
+        return self.__class__(self.__repo)
+
+    def __init(self, name, get_release=True):
+        self.__name = name
+        self.__connection_params = DbConn(name)
+        if get_release and self.__repo.devel:
+            self.__last_release = self.last_release
+
+    @property
+    def last_release(self):
+        "Returns the last release"
+        self.__last_release = next(
+            self.__model.get_relation_class('half_orm_meta.view.hop_last_release')().ho_select())
+        return self.__last_release
+
+    @property
+    def last_release_s(self):
+        "Returns the string representation of the last release X.Y.Z"
+        return '{major}.{minor}.{patch}'.format(**self.last_release)
+
+    @property
+    def model(self):
+        "The model (halfORM) of the database"
+        return self.__model
+
+    @property
+    def state(self):
+        "The state (str) of the database"
+        res = ['[Database]']
+        res.append(f'- name: {self.__name}')
+        res.append(f'- user: {self.__connection_params.user}')
+        res.append(f'- host: {self.__connection_params.host}')
+        res.append(f'- port: {self.__connection_params.port}')
+        prod = utils.Color.blue(
+            True) if self.__connection_params.production else False
+        res.append(f'- production: {prod}')
+        if self.__repo.devel:
+            res.append(f'- last release: {self.last_release_s}')
+        return '\n'.join(res)
+
+    @property
+    def production(self):
+        "Returns wether the database is tagged in production or not."
+        return self.__connection_params.production
+
+    def init(self, name):
+        """Called when creating a new repo.
+        Tries to read the connection parameters and then connect to
+        the database.
+        """
+        try:
+            self.__init(name, get_release=False)
+        except FileNotFoundError:
+            pass
+        return self.__init_db()
+
+    def __init_db(self):
+        """Tries to connect to the database. If unsuccessful, creates the
+        database end initializes it with half_orm_meta.
+        """
+        try:
+            self.__model = Model(self.__name)
+        except OperationalError:
+            sys.stderr.write(f"The database '{self.__name}' does not exist.\n")
+            create = input('Do you want to create it (Y/n): ') or "y"
+            if create.upper() == 'Y':
+                self.execute_pg_command('createdb')
+            else:
+                utils.error(
+                    f'Aborting! Please remove {self.__name} directory.\n', exit_code=1)
+        self.__model = Model(self.__name)
+        if self.__repo.devel:
+            try:
+                self.__model.get_relation_class('half_orm_meta.hop_release')
+            except UnknownRelation:
+                hop_init_sql_file = os.path.join(
+                    HOP_PATH, 'patches', 'sql', 'half_orm_meta.sql')
+                self.execute_pg_command(
+                    'psql', '-f', hop_init_sql_file, stdout=subprocess.DEVNULL)
+                self.__model.reconnect(reload=True)
+                self.__last_release = self.register_release(
+                    major=0, minor=0, patch=0, changelog='Initial release')
+        return self(self.__name)
+
+    @property
+    def execute_pg_command(self):
+        "Helper: execute a postgresql command"
+        return self.__connection_params.execute_pg_command
+
+    def register_release(self, major, minor, patch, changelog):
+        "Register the release into half_orm_meta.hop_release"
+        return self.__model.get_relation_class('half_orm_meta.hop_release')(
+            major=major, minor=minor, patch=patch, changelog=changelog
+        ).ho_insert()

half_orm_dev/db_conn.py

@@ -0,0 +1,134 @@
+"""Provides the DbConn class.
+"""
+
+import os
+import subprocess
+import sys
+
+from getpass import getpass
+from configparser import ConfigParser
+
+from half_orm.model import CONF_DIR
+from half_orm import utils
+
+CONF_NOT_FOUND = '''
+The configuration file {} is missing.
+You must create it before proceeding.
+
+'''
+
+class DbConn:
+    """Handles the connection parameters to the database.
+    Provides the execute_pg_command."""
+    __conf_dir = CONF_DIR # HALFORM_CONF_DIR
+    def __init__(self, name):
+        self.__name = name
+        self.__user = None
+        self.__password = None
+        self.__host = None
+        self.__port = None
+        self.__production = None
+        if name:
+            self.__connection_file = os.path.join(self.__conf_dir, self.__name)
+            if os.path.exists(self.__connection_file):
+                self.__init()
+
+    @property
+    def production(self):
+        "prod"
+        return self.__production
+
+    def __init(self):
+        "Reads the config file and sets the connection parameters"
+        config = ConfigParser()
+        config.read([self.__connection_file])
+
+        self.__name = config.get('database', 'name')
+
+        self.__user = config.get('database', 'user', fallback=None)
+        self.__password = config.get('database', 'password', fallback=None)
+        self.__host = config.get('database', 'host', fallback=None)
+        self.__port = config.get('database', 'port', fallback=None)
+
+        self.__production = config.getboolean('database', 'production', fallback=False)
+
+    @property
+    def host(self):
+        "Returns host name"
+        return self.__host
+    @property
+    def port(self):
+        "Returns port"
+        return self.__port
+    @property
+    def user(self):
+        "Returns user"
+        return self.__user
+
+    def set_params(self, name):
+        """Asks for the connection parameters.
+        """
+        if not os.access(self.__conf_dir, os.W_OK):
+            sys.stderr.write(f"You don't have write access to {self.__conf_dir}.\n")
+            if self.__conf_dir == '/etc/half_orm': # only on linux
+                utils.error(
+                    "Set the HALFORM_CONF_DIR environment variable if you want to use a\n"
+                    "different directory.\n", exit_code=1)
+        print(f'Connection parameters to the database {self.__name}:')
+        self.__user = os.environ['USER']
+        self.__user = input(f'. user ({self.__user}): ') or self.__user
+        self.__password = getpass('. password: ')
+        if self.__password == '' and \
+                (input(
+                    '. is it an ident login with a local account? [Y/n] ') or 'Y').upper() == 'Y':
+            self.__host = self.__port = ''
+        else:
+            self.__host = input('. host (localhost): ') or 'localhost'
+            self.__port = input('. port (5432): ') or 5432
+
+        self.__production = input('Production (False): ') or False
+
+        self.__write_config()
+
+        return self
+
+    def __write_config(self):
+        "Helper: write file in utf8"
+        self.__connection_file = os.path.join(self.__conf_dir, self.__name)
+        config = ConfigParser()
+        config['database'] = {
+            'name': self.__name,
+            'user': self.__user,
+            'password': self.__password,
+            'host': self.__host,
+            'port': self.__port,
+            'production': self.__production
+        }
+        with open(self.__connection_file, 'w', encoding='utf-8') as configfile:
+            config.write(configfile)
+
+    def execute_pg_command(self, cmd, *args, **kwargs):
+        """Helper. Executes a postgresql
+        """
+        if not kwargs.get('stdout'):
+            kwargs['stdout'] = subprocess.DEVNULL
+        cmd_list = [cmd]
+        env = os.environ.copy()
+        password = self.__password
+        if password:
+            env['PGPASSWORD'] = password
+        if self.__user:
+            cmd_list += ['-U', self.__user]
+        if self.__port:
+            cmd_list += ['-p', self.__port]
+        if self.__host:
+            cmd_list += ['-h', self.__host]
+        cmd_list.append(self.__name)
+        if args:
+            cmd_list += args
+        try:
+            subprocess.run(
+                cmd_list, env=env, shell=False, check=True,
+                **kwargs)
+        except subprocess.CalledProcessError as err:
+            utils.error(f'{err}\ndatabase: {self.__name} with user: {self.__user}, host: {self.__host}, port: {self.__port}\n', exit_code=err.returncode)