half-orm-dev 1.0.0a26__tar.gz → 1.0.0a28__tar.gz

{half_orm_dev-1.0.0a26/half_orm_dev.egg-info → half_orm_dev-1.0.0a28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a26
+Version: 1.0.0a28
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/bootstrap_manager.py

@@ -62,8 +62,8 @@ class BootstrapManager:
         """
         Ensure half_orm_meta.bootstrap table exists.
 
-        Creates the table if it doesn't exist. This handles the case
-        where the table hasn't been created yet (pre-migration databases).
+        Creates the table if it doesn't exist, then reloads the model so
+        get_relation_class('half_orm_meta.bootstrap') can find it.
         """
         sql = """
         CREATE TABLE IF NOT EXISTS half_orm_meta.bootstrap (
@@ -73,6 +73,7 @@ class BootstrapManager:
         );
         """
         self._repo.database.model.execute_query(sql)
+        self._repo.database.model.reconnect(reload=True)
 
     def get_bootstrap_files(
         self,
@@ -135,9 +136,6 @@ class BootstrapManager:
         """
         Get set of already executed filenames from database.
 
-        Queries half_orm_meta.bootstrap table to get filenames
-        that have already been executed.
-
         Returns:
             Set of filename strings that have been executed
         """
@@ -145,10 +143,8 @@ class BootstrapManager:
         # return empty set so all bootstrap files are treated as pending.
         try:
             self._ensure_bootstrap_table()
-            result = self._repo.database.model.execute_query(
-                "SELECT filename FROM half_orm_meta.bootstrap"
-            )
-            return {row[0] for row in result} if result else set()
+            HopBootstrap = self._repo.database.model.get_relation_class('half_orm_meta.bootstrap')
+            return {row.filename for row in HopBootstrap()}
         except Exception:
             return set()
 
@@ -198,22 +194,18 @@ class BootstrapManager:
         except FileExecutionError as e:
             raise BootstrapManagerError(str(e)) from e
 
-    def record_execution(self, filename: str, version: str) -> None:
+    def record_execution(self, filename: str, version: str, force: bool = False) -> None:
         """
         Record execution in half_orm_meta.bootstrap table.
 
         Args:
             filename: Name of the executed file
             version: Version extracted from filename
+            force: If True, upsert (update executed_at on re-run). If False,
+                   plain insert — a duplicate raises an error revealing a guard bug.
         """
-        sql = """
-        INSERT INTO half_orm_meta.bootstrap (filename, version)
-        VALUES (%s, %s)
-        ON CONFLICT (filename) DO UPDATE SET
-            version = EXCLUDED.version,
-            executed_at = NOW()
-        """
-        self._repo.database.model.execute_query(sql, (filename, version))
+        HopBootstrap = self._repo.database.model.get_relation_class('half_orm_meta.bootstrap')
+        HopBootstrap(filename=filename, version=version).ho_insert(upsert=force)
 
     def run_bootstrap(
         self,
@@ -253,14 +245,14 @@ class BootstrapManager:
             'errors': []
         }
 
+        executed_set = self.get_executed_files()
+        all_files = self.get_bootstrap_files(up_to_version, exclude_version=exclude_version, for_version=for_version)
+
         if force:
-            files_to_execute = self.get_bootstrap_files(up_to_version, exclude_version=exclude_version, for_version=for_version)
+            files_to_execute = all_files
         else:
-            files_to_execute = self.get_pending_files(up_to_version, exclude_version=exclude_version, for_version=for_version)
-            # Calculate skipped
-            all_files = self.get_bootstrap_files(up_to_version, exclude_version=exclude_version, for_version=for_version)
-            executed = self.get_executed_files()
-            result['skipped'] = [f.name for f in all_files if f.name in executed]
+            files_to_execute = [f for f in all_files if f.name not in executed_set]
+            result['skipped'] = [f.name for f in all_files if f.name in executed_set]
 
         if not files_to_execute:
             return result
@@ -278,10 +270,15 @@ class BootstrapManager:
                 result['executed'].append(filename)
                 continue
 
+            if filename in executed_set:
+                result['skipped'].append(filename)
+                continue
+
             try:
                 click.echo(f"  • Executing {filename}...")
                 self.execute_file(file_path)
-                self.record_execution(filename, file_version)
+                self.record_execution(filename, file_version, force=force)
+                executed_set.add(filename)
                 result['executed'].append(filename)
             except BootstrapManagerError as e:
                 result['errors'].append((filename, str(e)))

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/cli/commands/migrate.py

@@ -65,7 +65,7 @@ def migrate(verbose: bool) -> None:
         # Get current versions
         from half_orm_dev.utils import hop_version
         installed_version = hop_version()
-        config_version = repo._Repo__config.hop_version if hasattr(repo, '_Repo__config') else '0.0.0'
+        config_version = repo.config.hop_version
 
         # Migration needed (comparison > 0)
         click.echo(f"⚠️  {utils.Color.bold('Migration needed:')}")

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/cli/commands/set_git_origin.py

@@ -37,7 +37,7 @@ def set_git_origin(new_origin):
 
     # 1. Update .hop/config
     repo.git_origin = new_origin
-    repo._Repo__config.write()
+    repo.config.write()
     click.echo(f"  ✓ .hop/config updated")
 
     # 2. Update pyproject.toml Homepage

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/cli/main.py

@@ -141,7 +141,7 @@ def create_cli_group():
             if hop.repo_checked and hop._Hop__repo.needs_migration():
                 from half_orm_dev.utils import hop_version
                 installed_version = hop_version()
-                config_version = hop._Hop__repo._Repo__config.hop_version
+                config_version = hop._Hop__repo.repo.config.hop_version
 
                 @click.command(
                     cmd_name,
@@ -198,7 +198,7 @@ def create_cli_group():
                     from half_orm_dev.utils import hop_version
                     from half_orm_dev.repo import RepoError
                     installed_version = hop_version()
-                    config_version = hop._Hop__repo._Repo__config.hop_version
+                    config_version = hop._Hop__repo.repo.config.hop_version
                     current_branch = hop._Hop__repo.hgit.branch if hop._Hop__repo.hgit else 'unknown'
 
                     click.echo(f"\n{'='*70}")

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/decorators.py

@@ -39,6 +39,8 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
     def decorator(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
+            # Support both Manager classes (self._repo) and Repo itself (self)
+            repo = getattr(self, '_repo', self)
             lock_tag = None
             locked_branch = None
             try:
@@ -48,20 +50,20 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
                 # 2. All branches are fetched (prune)
                 # 3. Repository hop_version is validated against installed version
                 # 4. Operation is blocked if version is outdated (prevents dangerous operations)
-                self._repo.sync_and_validate_ho_prod()
+                repo.sync_and_validate_ho_prod()
 
                 # Determine branch name dynamically
                 locked_branch = branch_getter(self, *args, **kwargs)
 
                 # Acquire lock
-                lock_tag = self._repo.hgit.acquire_branch_lock(locked_branch, timeout_minutes=timeout_minutes)
+                lock_tag = repo.hgit.acquire_branch_lock(locked_branch, timeout_minutes=timeout_minutes)
 
                 # Execute the method
                 result = func(self, *args, **kwargs)
 
                 # After success, sync .hop/ from current branch to all other active branches
                 try:
-                    sync_result = self._repo.sync_hop_to_active_branches(
+                    sync_result = repo.sync_hop_to_active_branches(
                         reason=f"{func.__name__}"
                     )
                     # Log sync errors but don't fail the operation
@@ -84,7 +86,7 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
                         wrapper, '_interrupted', True) or None)
                     wrapper._interrupted = False
                     try:
-                        self._repo.hgit.release_branch_lock(lock_tag)
+                        repo.hgit.release_branch_lock(lock_tag)
                     finally:
                         interrupted = wrapper._interrupted
                         signal.signal(signal.SIGINT, original_handler)

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/hgit.py

@@ -7,6 +7,7 @@ import sys
 import subprocess
 import fnmatch
 import git
+from contextlib import contextmanager
 from git.exc import GitCommandError
 from typing import List, Optional
 import time
@@ -23,6 +24,7 @@ class HGit:
         self.__repo = repo
         self.__base_dir = None
         self.__git_repo: git.Repo = None
+        self.__snapshot: dict = {}
         if repo:
             self.__origin = repo.git_origin
             self.__base_dir = repo.base_dir
@@ -78,6 +80,7 @@ class HGit:
             )
 
         self.__current_branch = self.branch
+        self.__snapshot = self.capture_branches_snapshot()
 
     def __str__(self):
         res = ['[Git]']
@@ -267,6 +270,92 @@ class HGit:
         "Proxy to git.commit method"
         return self.__git_repo.git.checkout(*args, **kwargs)
 
+    @contextmanager
+    def on_branch(self, branch: str, silent: bool = False):
+        """Temporarily switch to branch, yield, then return to original branch."""
+        original = self.branch
+        switched = branch != original
+        if switched:
+            if not silent:
+                print(f"  Switching to {branch}...")
+            self.__git_repo.git.checkout(branch)
+            if not silent:
+                print(f"  ✓ Now on {branch}")
+        try:
+            yield
+        finally:
+            if switched:
+                try:
+                    if not silent:
+                        print(f"  Returning to {original}...")
+                    self.__git_repo.git.checkout(original)
+                    if not silent:
+                        print(f"  ✓ Back on {original}")
+                except Exception as e:
+                    if not silent:
+                        print(f"  ⚠  Could not return to {original}: {e}", file=sys.stderr)
+                        print(f"  You are now on {branch}", file=sys.stderr)
+
+    @property
+    def snapshot(self) -> dict:
+        """Return the last stored branches snapshot."""
+        return self.__snapshot
+
+    def update_snapshot(self) -> None:
+        """Refresh the stored snapshot to reflect current branch HEADs."""
+        self.__snapshot = self.capture_branches_snapshot()
+
+    def capture_branches_snapshot(self) -> dict:
+        """Return {branch_name: HEAD_SHA} for all active local branches."""
+        snapshot = {}
+        try:
+            branches_status = self.get_active_branches_status()
+        except Exception:
+            return snapshot
+
+        candidates = []
+        prod = branches_status.get('prod_branch')
+        if prod:
+            candidates.append(prod['name'])
+        for b in branches_status.get('release_branches', []):
+            if b.get('exists_on_remote', True):
+                candidates.append(b['name'])
+        for b in branches_status.get('patch_branches', []):
+            if b.get('exists_on_remote', True):
+                candidates.append(b['name'])
+
+        for name in candidates:
+            try:
+                snapshot[name] = self.__git_repo.heads[name].commit.hexsha
+            except Exception:
+                pass
+        return snapshot
+
+    def rollback_to_snapshot(self, snapshot: dict = None) -> dict:
+        """Reset each branch to its captured SHA.
+
+        Uses the stored snapshot when none is provided.
+        Returns {'reset': [branch, ...], 'errors': [(branch, msg), ...]}.
+        """
+        target = snapshot if snapshot is not None else self.__snapshot
+        result = {'reset': [], 'errors': []}
+        original = self.branch
+
+        for branch, sha in target.items():
+            try:
+                self.__git_repo.heads[branch].checkout()
+                self.__git_repo.git.reset('--hard', sha)
+                result['reset'].append(branch)
+            except Exception as e:
+                result['errors'].append((branch, str(e)))
+
+        try:
+            self.__git_repo.heads[original].checkout()
+        except Exception as e:
+            result['errors'].append(('__restore_original__', str(e)))
+
+        return result
+
     def checkout_paths_from_branch(self, branch: str, paths: list) -> None:
         """
         Checkout specific paths from another branch into working directory.

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/migration_manager.py

@@ -254,26 +254,31 @@ class MigrationManager:
         result['sync_files'] = list(dict.fromkeys(result['sync_files']))
         return result
 
-    @with_dynamic_branch_lock(lambda self, *args, **kwargs: 'ho-prod')
     def run_migrations(self, target_version: str, create_commit: bool = True) -> Dict:
         """
-        Run all pending migrations up to target version.
-
-        IMPORTANT: This method acquires a lock on ho-prod branch via decorator.
-        Should only be called when on ho-prod branch.
+        Run all pending migrations from the current repo version up to target_version.
 
-        After successful completion, the decorator automatically syncs .hop/
-        directory to all active branches (ho-patch/*, ho-release/*).
+        Must be called via Repo.run_migrations_if_needed() (enforced by guard).
+        Must be called while on the ho-prod branch.
 
         Args:
-            target_version: Target version string (e.g., "0.17.1")
-            create_commit: Whether to create Git commit after migration
+            target_version: Target version string (e.g., "1.0.0-a26")
+            create_commit: Whether to create a Git commit after migration
 
         Returns:
-            Dict with migration results including:
-                - migrations_applied: List of applied migrations
-                - commit_created: Whether migration commit was created
+            Dict with keys:
+                - target_version: str
+                - migrations_applied: List of per-migration result dicts
+                - commit_created: bool
+                - commit_message: str (only when commit_created is True)
+                - sync_result: dict from commit_and_sync_to_active_branches
+                - errors: List of non-fatal warning strings
         """
+        if not getattr(self._repo, '_migration_running', False):
+            raise MigrationManagerError(
+                "run_migrations() must be called via Repo.run_migrations_if_needed()."
+            )
+
         result = {
             'target_version': target_version,
             'migrations_applied': [],
@@ -282,165 +287,56 @@ class MigrationManager:
             'notified_branches': []
         }
 
-        # Fetch from origin to ensure we have latest refs
-        try:
-            self._repo.hgit.fetch_from_origin()
-        except Exception as e:
-            result['errors'].append(f"Failed to fetch from origin: {e}")
-            raise MigrationManagerError(f"Cannot run migration: failed to fetch from origin: {e}")
-
-        # Verify ho-prod is up to date with origin/ho-prod
-        current_branch = self._repo.hgit.branch
-        if current_branch == 'ho-prod':
-            try:
-                # Check if ho-prod is synced with origin/ho-prod
-                result_check = subprocess.run(
-                    ['git', 'rev-list', '--left-right', '--count', 'ho-prod...origin/ho-prod'],
-                    cwd=self._repo.base_dir,
-                    capture_output=True,
-                    text=True,
-                    check=True
-                )
-                ahead, behind = map(int, result_check.stdout.strip().split())
-                if behind > 0:
-                    # Check whether the migration was already applied on origin/ho-prod.
-                    already_done = False
-                    try:
-                        remote_config_text = self._repo.hgit._HGit__git_repo.git.show(
-                            'origin/ho-prod:.hop/config'
-                        )
-                        _cp = ConfigParser()
-                        _cp.read_string(remote_config_text)
-                        remote_version = _cp['halfORM'].get('hop_version', '')
-                        if remote_version == target_version:
-                            already_done = True
-                    except Exception:
-                        pass
-
-                    if already_done:
-                        # Another developer already ran the migration.
-                        # Pull and sync all active branches, then return.
-                        click.echo(
-                            f"  ℹ Migration to {target_version} already applied by another developer.\n"
-                            f"  Pulling and syncing all active branches..."
-                        )
-                        self._repo.hgit._HGit__git_repo.remotes.origin.pull('ho-prod')
-                        self._repo.hgit.sync_active_branches(pattern="ho-*")
-                        # Reload config so the rest of the tool sees the new version
-                        self._repo._Repo__config.read()
-                        result['already_synced'] = True
-                        return result
-
-                    raise MigrationManagerError(
-                        f"ho-prod is {behind} commits behind origin/ho-prod. "
-                        f"Please pull changes first: git pull origin ho-prod"
-                    )
-                if ahead > 0:
-                    result['errors'].append(f"Warning: ho-prod is {ahead} commits ahead of origin/ho-prod")
-            except (MigrationManagerError, subprocess.CalledProcessError):
-                raise
-            except Exception:
-                # Could not compare — maybe origin/ho-prod doesn't exist yet
-                pass
+        current_version = self._repo.config.hop_version
 
-        # Get current version from .hop/config
-        current_version = self._repo._Repo__config.hop_version if hasattr(
-            self._repo, '_Repo__config'
-        ) else "0.0.0"
-
-        # If already at target version, nothing to do
-        try:
-            comparison = self._repo.compare_versions(current_version, target_version)
-
-            if comparison >= 0:
-                # Already at or past target version (0 = equal, 1 = higher)
-                return result
-        except Exception as e:
-            # If version comparison fails (invalid format), log and continue
-            # This allows migration to proceed even if version format is unexpected
-            result['errors'].append(
-                f"Could not compare versions {current_version} and {target_version}: {e}. "
-                f"Continuing with migration attempt."
-            )
+        comparison = self._repo.compare_versions(current_version, target_version)
+        if comparison >= 0:
+            return result
 
-        # Ensure all active branches are in sync with origin before touching anything
-        self._ensure_active_branches_synced()
-
-        # Get pending migrations
         pending = self.get_pending_migrations(current_version, target_version)
 
-        # Apply each migration if there are any
-        if pending:
+        try:
             for version_str, migration_dir in pending:
-                try:
-                    migration_result = self.apply_migration(version_str, migration_dir)
-                    result['migrations_applied'].append(migration_result)
+                migration_result = self.apply_migration(version_str, migration_dir)
+                result['migrations_applied'].append(migration_result)
 
-                except MigrationManagerError as e:
-                    result['errors'].append(str(e))
-                    raise
+            # hop_version setter calls write() internally — one write only
+            self._repo.config.hop_version = target_version
 
-        # Update hop_version in .hop/config (current_version != target_version)
-        # This ensures the version is updated even when upgrading between versions
-        # that have no migration scripts (e.g., 0.17.1-a2 → 0.17.2-a3)
-        if hasattr(self._repo, '_Repo__config'):
-            self._repo._Repo__config.hop_version = target_version
-            self._repo._Repo__config.write()
-
-        # Update half_orm_dev version in pyproject.toml
-        self._update_pyproject_dependency_version(target_version)
+            self._update_pyproject_dependency_version(target_version)
+        except Exception:
+            self._repo.hgit.rollback_to_snapshot()
+            raise
 
-        # Collect all sync_files from migrations + pyproject.toml
-        all_sync_files = ['pyproject.toml']  # Always sync pyproject.toml
+        all_sync_files = ['pyproject.toml']
         for migration in result['migrations_applied']:
             all_sync_files.extend(migration.get('sync_files', []))
-        # Remove duplicates while preserving order
         all_sync_files = list(dict.fromkeys(all_sync_files))
 
-        # Create Git commit if requested
         if create_commit and self._repo.hgit:
-            try:
-                commit_msg = self._create_migration_commit_message(
-                    current_version,
-                    target_version,
-                    result['migrations_applied']
-                )
-
-                # Commit and sync to active branches (including migration files)
-                sync_result = self._repo.commit_and_sync_to_active_branches(
-                    message=commit_msg,
-                    reason=f"migration {current_version} → {target_version}",
-                    files=all_sync_files
-                )
-
-                result['commit_created'] = True
-                result['commit_message'] = commit_msg
-                result['commit_pushed'] = True
-                result['sync_result'] = sync_result
+            commit_msg = self._create_migration_commit_message(
+                current_version, target_version, result['migrations_applied']
+            )
 
-                # Create annotated tag encoding all commit SHAs for potential revert
-                self._create_migration_tag(
-                    current_version, target_version, sync_result
-                )
+            sync_result = self._repo.commit_and_sync_to_active_branches(
+                message=commit_msg,
+                reason=f"migration {current_version} → {target_version}",
+                files=all_sync_files
+            )
 
-                # Pseudo-patch: regenerate modules and sync to active branches
-                try:
-                    self._regenerate_modules_after_migration(
-                        current_version, target_version
-                    )
-                except Exception as regen_err:
-                    result['errors'].append(
-                        f"Module regeneration after migration failed: {regen_err}"
-                    )
+            result['commit_created'] = True
+            result['commit_message'] = commit_msg
+            result['sync_result'] = sync_result
 
+            try:
+                self._create_migration_tag(current_version, target_version, sync_result)
             except Exception as e:
-                # Don't fail migration if commit fails
-                result['errors'].append(f"Failed to create commit: {e}")
+                result['errors'].append(f"Migration tag creation failed: {e}")
 
-        # Note: Branch synchronization is now handled automatically by the
-        # @with_dynamic_branch_lock decorator when the method completes.
-        # The decorator calls repo.sync_hop_to_active_branches() for all
-        # operations on ho-prod, ensuring .hop/ is always synced.
+            try:
+                self._regenerate_modules_after_migration(current_version, target_version)
+            except Exception as e:
+                result['errors'].append(f"Module regeneration after migration failed: {e}")
 
         return result
 
@@ -624,12 +520,11 @@ class MigrationManager:
             b['name'] for b in branches_status.get('release_branches', [])
             if b.get('exists_on_remote', True)
         ]
-        # ho-patch/* branches are excluded: their schema includes tables that
-        # don't yet exist in production, so restoring the production schema
-        # before generate() would delete the modules for those new tables and
-        # erase user-written code (Fkeys, business methods). The developer
-        # will re-run `hop patch apply` which regenerates with the correct schema.
-        all_branches = ['ho-prod'] + release_branches
+        # ho-patch/* branches receive .hop/ and pyproject.toml updates but skip
+        # module regeneration: their schema may include tables not yet in
+        # production, so generate() would delete modules for those new tables.
+        # The developer re-runs `hop patch apply` to regenerate with the correct schema.
+        all_branches = ['ho-prod'] + release_branches + patch_branches
 
         for branch in all_branches:
             try:
@@ -651,7 +546,8 @@ class MigrationManager:
                     # ho-prod and ho-patch/*: use production schema
                     repo.restore_database_from_schema(skip_bootstrap=True)
 
-                _modules.generate(repo)
+                if not branch in patch_branches:
+                    _modules.generate(repo)
                 repo.hgit.add(package_dir)
                 if not git_repo.git.diff('--cached', '--name-only').strip():
                     continue
@@ -796,10 +692,7 @@ class MigrationManager:
         Returns:
             True if migration/update is needed
         """
-        if not hasattr(self._repo, '_Repo__config'):
-            return False
-
-        config_version = self._repo._Repo__config.hop_version
+        config_version = self._repo.config.hop_version
 
         # If no hop_version is configured, no migration needed
         if not config_version:

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/migrations/0/17/5/01_update_pyproject_dependency.py

@@ -55,7 +55,7 @@ def migrate(repo):
         print(f"  pyproject.toml not found.")
         if click.confirm("  Create pyproject.toml from template?", default=True):
             try:
-                package_name = repo._Repo__config.package_name
+                package_name = repo.config.package_name
                 template_path = os.path.join(TEMPLATE_DIRS, 'pyproject.toml')
                 template = utils.read(template_path)
 

{half_orm_dev-1.0.0a26 → half_orm_dev-1.0.0a28}/half_orm_dev/migrations/0/18/0/00_add_async_support.py

@@ -59,7 +59,7 @@ def migrate(repo):
     import click
 
     base_dir = Path(repo.base_dir)
-    package_name = repo._Repo__config.package_name
+    package_name = repo.config.package_name
 
     _migrate_init(repo, base_dir, package_name, click)
     _migrate_conftest(repo, base_dir, package_name, click)