half-orm-dev 0.17.5a3__tar.gz → 0.17.5a5__tar.gz

{half_orm_dev-0.17.5a3/half_orm_dev.egg-info → half_orm_dev-0.17.5a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.5a3
+Version: 0.17.5a5
 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-0.17.5a3 → half_orm_dev-0.17.5a5}/half_orm_dev/bootstrap_manager.py

@@ -78,7 +78,12 @@ class BootstrapManager:
             # Schema might not exist yet, ignore
             pass
 
-    def get_bootstrap_files(self, up_to_version: Optional[str] = None) -> List[Path]:
+    def get_bootstrap_files(
+        self,
+        up_to_version: Optional[str] = None,
+        exclude_version: Optional[str] = None,
+        for_version: Optional[str] = None
+    ) -> List[Path]:
         """
         List bootstrap files sorted by numeric prefix.
 
@@ -87,8 +92,11 @@ class BootstrapManager:
 
         Args:
             up_to_version: If provided, only return files with version <= this version.
-                          Used during restore_database_from_schema to avoid executing
-                          bootstraps for future releases.
+            exclude_version: If provided, exclude files for exactly this version.
+                            Used during promote to skip the version being promoted
+                            (its bootstraps run after patches are applied).
+            for_version: If provided, only return files for exactly this version.
+                        Used after patches to run only the promoted version's bootstraps.
 
         Returns:
             List of Path objects for bootstrap files in execution order
@@ -103,11 +111,20 @@ class BootstrapManager:
                 if not re.match(r'^\d+-', file_path.name):
                     continue
 
-                # If up_to_version is specified, filter out files from newer versions
-                if up_to_version:
-                    file_version = self._extract_version_from_filename(file_path.name)
-                    if file_version != 'unknown' and not self._version_le(file_version, up_to_version):
+                file_version = self._extract_version_from_filename(file_path.name)
+
+                # If for_version is specified, only include files for exactly this version
+                if for_version:
+                    if file_version != for_version:
+                        continue
+                else:
+                    # If exclude_version is specified, skip files for that version
+                    if exclude_version and file_version == exclude_version:
                         continue
+                    # If up_to_version is specified, filter out files from newer versions
+                    if up_to_version:
+                        if file_version != 'unknown' and not self._version_le(file_version, up_to_version):
+                            continue
 
                 files.append(file_path)
 
@@ -140,17 +157,24 @@ class BootstrapManager:
             # Table might not exist yet (pre-migration)
             return set()
 
-    def get_pending_files(self, up_to_version: Optional[str] = None) -> List[Path]:
+    def get_pending_files(
+        self,
+        up_to_version: Optional[str] = None,
+        exclude_version: Optional[str] = None,
+        for_version: Optional[str] = None
+    ) -> List[Path]:
         """
         Get bootstrap files not yet executed.
 
         Args:
             up_to_version: If provided, only return files with version <= this version.
+            exclude_version: If provided, exclude files for exactly this version.
+            for_version: If provided, only return files for exactly this version.
 
         Returns:
             List of Path objects for files pending execution
         """
-        all_files = self.get_bootstrap_files(up_to_version)
+        all_files = self.get_bootstrap_files(up_to_version, exclude_version=exclude_version, for_version=for_version)
         executed = self.get_executed_files()
 
         return [f for f in all_files if f.name not in executed]
@@ -201,7 +225,9 @@ class BootstrapManager:
         dry_run: bool = False,
         force: bool = False,
         exclude_patch_id: Optional[str] = None,
-        up_to_version: Optional[str] = None
+        up_to_version: Optional[str] = None,
+        exclude_version: Optional[str] = None,
+        for_version: Optional[str] = None
     ) -> dict:
         """
         Execute pending bootstrap files.
@@ -215,6 +241,8 @@ class BootstrapManager:
             up_to_version: If provided, only execute files with version <= this version.
                           Used during restore_database_from_schema to avoid executing
                           bootstraps for future releases.
+            exclude_version: If provided, exclude files for exactly this version.
+            for_version: If provided, only execute files for exactly this version.
 
         Returns:
             Dict with execution results:
@@ -231,11 +259,11 @@ class BootstrapManager:
         }
 
         if force:
-            files_to_execute = self.get_bootstrap_files(up_to_version)
+            files_to_execute = self.get_bootstrap_files(up_to_version, exclude_version=exclude_version, for_version=for_version)
         else:
-            files_to_execute = self.get_pending_files(up_to_version)
+            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)
+            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]
 

{half_orm_dev-0.17.5a3 → half_orm_dev-0.17.5a5}/half_orm_dev/decorators.py

@@ -4,6 +4,7 @@ Decorators for half-orm-dev.
 Provides common decorators for ReleaseManager and PatchManager.
 """
 
+import signal
 import sys
 import inspect
 from functools import wraps
@@ -13,9 +14,6 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
     """
     Decorator to protect methods with a dynamic branch lock.
 
-    Unlike with_branch_lock which uses a static branch name, this decorator
-    calls a function to determine the branch name at runtime.
-
     IMPORTANT: Automatically syncs .hop/ directory to all other active branches
     after the decorated method completes (from locked branch to all others).
 
@@ -77,8 +75,21 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
                 return result
             finally:
                 # Always release lock (even on error)
+                # Block SIGINT during cleanup to prevent Ctrl+C from
+                # interrupting lock release and leaving an orphan tag.
                 if lock_tag:
-                    self._repo.hgit.release_branch_lock(lock_tag)
+                    interrupted = False
+                    original_handler = signal.getsignal(signal.SIGINT)
+                    signal.signal(signal.SIGINT, lambda s, f: setattr(
+                        wrapper, '_interrupted', True) or None)
+                    wrapper._interrupted = False
+                    try:
+                        self._repo.hgit.release_branch_lock(lock_tag)
+                    finally:
+                        interrupted = wrapper._interrupted
+                        signal.signal(signal.SIGINT, original_handler)
+                    if interrupted:
+                        raise KeyboardInterrupt()
 
         return wrapper
     return decorator

{half_orm_dev-0.17.5a3 → half_orm_dev-0.17.5a5}/half_orm_dev/patch_manager.py

@@ -572,9 +572,10 @@ class PatchManager:
 
                 if release_schema_path and release_schema_path.exists():
                     # New workflow: restore from release schema (includes all staged patches)
-                    # Bootstrap scripts run automatically, excluding current patch
+                    # Exclude bootstraps for this version — apply_patch_files will
+                    # execute the current patch's bootstrap below.
                     self._repo.restore_database_from_release_schema(
-                        version, exclude_bootstrap_patch_id=patch_id
+                        version, exclude_bootstrap_version=version
                     )
 
                     # Apply only the current patch
@@ -583,9 +584,10 @@ class PatchManager:
                 else:
                     # Backward compatibility: old workflow
                     # Also generates release schema for migration of existing projects
-                    # Bootstrap scripts run automatically, excluding current patch
+                    # Exclude bootstraps for this version — apply_patch_files will
+                    # execute them when applying staged patches below.
                     self._repo.restore_database_from_schema(
-                        exclude_bootstrap_patch_id=patch_id
+                        exclude_bootstrap_version=version
                     )
 
                     # Get and apply all staged release patches
@@ -692,11 +694,6 @@ class PatchManager:
 
         # Apply files in lexicographic order
         for patch_file in structure.files:
-            # Skip bootstrap files - they are executed via run_bootstrap() after merge
-            if is_bootstrap_file(patch_file.path):
-                click.echo(f"  • {patch_file.name} (bootstrap - skipped, will run after merge)")
-                continue
-
             if patch_file.is_sql:
                 click.echo(f"  • {patch_file.name}")
                 try:
@@ -1061,6 +1058,11 @@ class PatchManager:
             shutil.copy(file_path, dest)
             copied.append(new_name)
 
+            # Record as already executed — the bootstrap SQL was already
+            # run by apply_patch_files during validation, so run_bootstrap
+            # must skip it to avoid double execution.
+            bootstrap_mgr.record_execution(new_name, version)
+
             click.echo(f"  • Copied bootstrap file: {new_name}")
 
         return copied
@@ -2033,11 +2035,15 @@ class PatchManager:
         # 5. Merge patch branch into release branch
         try:
             self._repo.hgit.merge(patch_branch, message=f'''[HOP] Merge #{patch_id} into %"{version}"''')
-        except Exception as e:
-            raise PatchManagerError(
-                f"Failed to merge {patch_branch} into {release_branch}: {e}\n"
-                f"You may need to resolve conflicts manually."
-            )
+        except (GitCommandError, Exception) as e:
+            # Auto-resolve conflicts in generated files (package dir).
+            # Generated files are regenerated by modules.generate() so
+            # conflicts there can be safely auto-resolved.
+            if not self._auto_resolve_generated_conflicts(e, patch_branch, release_branch):
+                raise PatchManagerError(
+                    f"Failed to merge {patch_branch} into {release_branch}: {e}\n"
+                    f"You may need to resolve conflicts manually."
+                )
 
         # 5b. Get merge commit hash
         merge_commit = self._repo.hgit.last_commit()
@@ -2212,6 +2218,55 @@ class PatchManager:
         # Return to original branch
         self._repo.hgit.checkout(original_branch)
 
+    def _auto_resolve_generated_conflicts(
+        self,
+        merge_error: Exception,
+        patch_branch: str,
+        target_branch: str = None
+    ) -> bool:
+        """
+        Auto-resolve merge conflicts when they only affect generated files.
+
+        Generated files (under the package directory) are regenerated by
+        modules.generate() after patch apply, so conflicts there are harmless
+        and can be safely resolved by accepting either side.
+
+        Args:
+            merge_error: The exception from the failed merge
+            patch_branch: The patch branch being merged
+            target_branch: Optional target branch name (for error messages)
+
+        Returns:
+            True if conflicts were auto-resolved, False otherwise
+        """
+        package_name = self._repo.name
+        git = self._repo.hgit._HGit__git_repo.git
+
+        try:
+            diff_output = git.diff('--name-only', '--diff-filter=U')
+            if not isinstance(diff_output, str) or not diff_output.strip():
+                return False
+            conflicted = diff_output.strip().splitlines()
+        except Exception:
+            return False
+
+        non_generated = [
+            f for f in conflicted
+            if not f.startswith(f"{package_name}/")
+        ]
+
+        if non_generated:
+            return False
+
+        # All conflicts are in generated files — auto-resolve
+        # and conclude the interrupted merge commit.
+        click.echo(f"  • Auto-resolving conflicts in generated files...")
+        for f in conflicted:
+            git.checkout('--theirs', f)
+        git.add(*conflicted)
+        git.commit('--no-verify', '--no-edit')
+        return True
+
     def _validate_patch_before_merge(
         self,
         patch_id: str,
@@ -2267,11 +2322,15 @@ class PatchManager:
             click.echo(f"  • Merging {patch_branch} into temp branch...")
             try:
                 self._repo.hgit.merge(patch_branch, message=f"[VALIDATE] Test merge #{patch_id}")
-            except Exception as e:
-                raise PatchManagerError(
-                    f"Failed to merge {patch_branch} during validation: {e}\n"
-                    f"Please resolve conflicts before closing the patch."
-                )
+            except (GitCommandError, Exception) as e:
+                # Auto-resolve conflicts in generated files (package dir).
+                # Generated files are regenerated by modules.generate() so
+                # conflicts there can be safely auto-resolved.
+                if not self._auto_resolve_generated_conflicts(e, patch_branch):
+                    raise PatchManagerError(
+                        f"Failed to merge {patch_branch} during validation: {e}\n"
+                        f"Please resolve conflicts before closing the patch."
+                    )
 
             # 3. Run patch apply and verify no modifications
             click.echo(f"  • Running patch apply to verify idempotency...")
@@ -2308,18 +2367,31 @@ class PatchManager:
                 # Generate modules
                 modules.generate(self._repo)
 
-                # Check if any files were modified
+                # Stage generated files (package dir) — they are always
+                # regenerated from DB state so changes there are expected.
+                package_name = self._repo.name
+                package_dir = Path(self._repo.base_dir) / package_name
+                if package_dir.exists():
+                    self._repo.hgit.add(str(package_dir))
+
+                # Check if any NON-generated files were modified
                 if not self._repo.hgit.repos_is_clean():
                     modified_files = self._repo.hgit.get_modified_files()
-                    raise PatchManagerError(
-                        f"Patch validation failed: patch apply modified files!\n"
-                        f"This indicates the patch is not idempotent or schema is out of sync.\n\n"
-                        f"Modified files:\n" + "\n".join(f"  • {f}" for f in modified_files) + "\n\n"
-                        f"Actions required:\n"
-                        f"  1. Verify patch SQL is idempotent (uses CREATE IF NOT EXISTS, etc.)\n"
-                        f"  2. Ensure schema.sql is up to date with all previous patches\n"
-                        f"  3. Run 'half_orm dev patch apply' on your patch branch to test"
-                    )
+                    # Filter out generated files (already staged)
+                    non_generated = [
+                        f for f in modified_files
+                        if not f.startswith(f"{package_name}/")
+                    ]
+                    if non_generated:
+                        raise PatchManagerError(
+                            f"Patch validation failed: patch apply modified files!\n"
+                            f"This indicates the patch is not idempotent or schema is out of sync.\n\n"
+                            f"Modified files:\n" + "\n".join(f"  • {f}" for f in non_generated) + "\n\n"
+                            f"Actions required:\n"
+                            f"  1. Verify patch SQL is idempotent (uses CREATE IF NOT EXISTS, etc.)\n"
+                            f"  2. Ensure schema.sql is up to date with all previous patches\n"
+                            f"  3. Run 'half_orm dev patch apply' on your patch branch to test"
+                        )
 
                 click.echo(f"  • {utils.Color.green('✓')} Patch apply succeeded with no modifications")
 
@@ -2361,6 +2433,15 @@ class PatchManager:
         finally:
             # 6. Cleanup: Delete temp branch and return to original branch
             try:
+                # Discard any staged/unstaged changes in the generated package
+                # dir so checkout doesn't fail (they were staged during validation).
+                package_name = self._repo.name
+                try:
+                    self._repo.hgit._HGit__git_repo.git.reset('HEAD', '--', f'{package_name}/')
+                    self._repo.hgit._HGit__git_repo.git.checkout('--', f'{package_name}/')
+                except Exception:
+                    pass
+
                 # Return to original branch
                 if self._repo.hgit.branch != original_branch:
                     self._repo.hgit.checkout(original_branch)

{half_orm_dev-0.17.5a3 → half_orm_dev-0.17.5a5}/half_orm_dev/release_manager.py

@@ -733,7 +733,7 @@ class ReleaseManager:
 
         return patches
 
-    def _apply_release_patches(self, version: str, hotfix=False, force_apply=False) -> None:
+    def _apply_release_patches(self, version: str, hotfix=False, force_apply=False, exclude_bootstrap_version: str = None) -> None:
         """
         Apply all patches for a release version to the database.
 
@@ -751,6 +751,8 @@ class ReleaseManager:
             hotfix: If True, skip RC patches (hotfix workflow)
             force_apply: If True, always apply patches individually even if
                         release schema exists (used for production validation)
+            exclude_bootstrap_version: If provided, skip bootstrap scripts for
+                this version during restore (they will be run after patches).
 
         Raises:
             ReleaseManagerError: If patch application fails
@@ -759,11 +761,15 @@ class ReleaseManager:
         release_schema_path = self._repo.get_release_schema_path(version)
         if release_schema_path.exists() and not force_apply:
             # New workflow: restore from release schema (already contains all staged patches)
-            self._repo.restore_database_from_release_schema(version)
+            self._repo.restore_database_from_release_schema(
+                version, exclude_bootstrap_version=exclude_bootstrap_version
+            )
             return
 
         # Fallback: old workflow - restore database from baseline
-        self._repo.restore_database_from_schema()
+        self._repo.restore_database_from_schema(
+            exclude_bootstrap_version=exclude_bootstrap_version
+        )
 
         current_branch = self._repo.hgit.branch
 
@@ -821,7 +827,7 @@ class ReleaseManager:
         # Return to original branch
         self._repo.hgit.checkout(current_branch)
 
-    def _run_bootstrap_scripts(self, up_to_version: str = None) -> None:
+    def _run_bootstrap_scripts(self, up_to_version: str = None, for_version: str = None) -> None:
         """
         Execute pending bootstrap scripts after patch application.
 
@@ -830,7 +836,7 @@ class ReleaseManager:
 
         Args:
             up_to_version: If provided, only execute bootstraps for versions <= this.
-                          Used to avoid running bootstraps for future releases.
+            for_version: If provided, only execute bootstraps for exactly this version.
 
         Raises:
             ReleaseManagerError: If bootstrap execution fails
@@ -844,14 +850,14 @@ class ReleaseManager:
             return
 
         # Get pending files (filtered by version if specified)
-        pending = bootstrap_mgr.get_pending_files(up_to_version)
+        pending = bootstrap_mgr.get_pending_files(up_to_version, for_version=for_version)
         if not pending:
             return
 
         print(f"\n📦 Executing {len(pending)} bootstrap script(s)...")
 
         try:
-            result = bootstrap_mgr.run_bootstrap(up_to_version=up_to_version)
+            result = bootstrap_mgr.run_bootstrap(up_to_version=up_to_version, for_version=for_version)
 
             if result['errors']:
                 errors = result['errors']
@@ -896,82 +902,6 @@ class ReleaseManager:
 
         return all_patches
 
-    def _generate_data_sql_file(self, patch_list: List[str], version: str) -> Optional[Path]:
-        """
-        Generate model/data-X.Y.Z.sql file from patches with @HOP:data annotation.
-
-        Collects all SQL files marked with `-- @HOP:data` from the patch list
-        and concatenates them into a single data SQL file for from-scratch
-        installations (clone, restore_database_from_schema).
-
-        This file is only generated for production releases. RC and hotfix
-        versions don't need this file because:
-        - In production upgrades, data is inserted by patch application
-        - This file is only for from-scratch installations
-
-        Args:
-            patch_list: List of patch IDs to process
-            version: Version string (e.g., "0.17.0")
-
-        Returns:
-            Path to generated file (model/data-X.Y.Z.sql), or None if no data files found
-
-        Examples:
-            self._generate_data_sql_file(
-                ["456-auth", "457-roles"],
-                "0.17.0"
-            )
-            # Generates model/data-0.17.0.sql with data from both patches
-        """
-        if not patch_list:
-            return None
-
-        try:
-            # Collect all data files from patches
-            data_files = self._repo.patch_manager._collect_data_files_from_patches(patch_list)
-
-            if not data_files:
-                # No data files found - skip generation
-                return None
-
-            # Generate output file in model/ directory
-            output_filename = f"data-{version}.sql"
-            output_path = Path(self._repo.model_dir) / output_filename
-
-            with output_path.open('w', encoding='utf-8') as out_file:
-                # Write header
-                out_file.write(f"-- Data file for version {version}\n")
-                out_file.write(f"-- Generated from patches: {', '.join(patch_list)}\n")
-                out_file.write(f"-- This file contains reference data (DML) for from-scratch installations\n")
-                out_file.write(f"--\n")
-                out_file.write(f"-- Usage: Automatically loaded by restore_database_from_schema()\n")
-                out_file.write(f"--\n\n")
-
-                # Concatenate all data files
-                for data_file in data_files:
-                    # Write separator comment
-                    out_file.write(f"-- ========================================\n")
-                    out_file.write(f"-- Source: {data_file}\n")
-                    out_file.write(f"-- ========================================\n\n")
-
-                    # Write file content (skip first line which is -- @HOP:data)
-                    content = data_file.read_text(encoding='utf-8')
-                    lines = content.split('\n')
-
-                    # Skip first line if it's the annotation
-                    if lines and lines[0].strip() == "-- @HOP:data":
-                        lines = lines[1:]
-
-                    out_file.write('\n'.join(lines))
-                    out_file.write('\n\n')
-
-            return output_path
-
-        except Exception as e:
-            raise ReleaseManagerError(
-                f"Failed to generate data SQL file data-{version}.sql: {e}"
-            )
-
     def get_all_release_context_patches(self) -> List[str]:
         """
         Get all validated patches for the next release context.
@@ -2569,12 +2499,14 @@ class ReleaseManager:
             self._repo.hgit.checkout("-b", temp_branch)
 
             # 6. Apply patches to database (validation)
-            self._apply_release_patches(version, force_apply=is_prod)
-
-            # 7. Execute bootstrap scripts (only for this version and earlier)
-            self._run_bootstrap_scripts(up_to_version=version)
+            # Bootstrap SQL in patches is executed by apply_patch_files.
+            # Bootstraps from bootstrap/ for OTHER versions run during restore.
+            # Bootstraps for THIS version are excluded (already run via patches).
+            self._apply_release_patches(
+                version, force_apply=is_prod, exclude_bootstrap_version=version
+            )
 
-            # 8. Register version in database
+            # 7. Register version in database
             version_parts = version.split('.')
             major, minor, patch_num = map(int, version_parts)
             if is_prod:
@@ -2673,7 +2605,7 @@ class ReleaseManager:
 
                 # Delete temporary branch if it exists
                 try:
-                    self._repo.hgit.delete_local_branch(temp_branch, force=True)
+                    self._repo.hgit.delete_local_branch(temp_branch)
                     print(f"  Deleted temporary branch {temp_branch}")
                 except Exception:
                     pass  # Branch might not exist
@@ -2781,12 +2713,6 @@ class ReleaseManager:
         if release_schema_file.exists():
             release_schema_file.unlink()
 
-        # Generate data file
-        prod_patches = self.read_release_patches(prod_file.name)
-        data_file = self._generate_data_sql_file(prod_patches, version)
-        if data_file:
-            self._repo.hgit.add(str(data_file))
-
     def _cleanup_release_branch(self, release_branch: str) -> list:
         """Delete release branch after production promotion."""
         deleted_branches = []
@@ -3226,13 +3152,6 @@ class ReleaseManager:
                 if toml_file.exists():
                     self._repo.hgit.rm(str(toml_file))
 
-            # Regenerate model/data-X.Y.Z.sql with all patches (original release + all hotfixes)
-            # This ensures from-scratch installations get all data
-            all_patches = self._collect_all_version_patches(version)
-            data_file = self._generate_data_sql_file(all_patches, version)
-            if data_file:
-                self._repo.hgit.add(str(data_file))
-
             # 6. Apply release patches and generate SQL dumps
             self._apply_release_patches(version, True)
 

{half_orm_dev-0.17.5a3 → half_orm_dev-0.17.5a5}/half_orm_dev/repo.py

@@ -652,6 +652,24 @@ class Repo:
                 # Checkout to target branch
                 self.hgit.checkout(branch)
 
+                # Reset to origin (source of truth) before syncing .hop/
+                # This avoids non-fast-forward push failures when another
+                # actor has already synced this branch.
+                remote_ref = f"origin/{branch}"
+                try:
+                    synced, status = self.hgit.compare_with_remote(branch)
+                    if not synced and status == "diverged":
+                        print(
+                            f"Warning: branch {branch} has diverged from origin. "
+                            f"Resetting to origin (source of truth).",
+                            file=sys.stderr
+                        )
+                    if not synced:
+                        self.hgit._HGit__git_repo.git.reset('--hard', remote_ref)
+                except Exception:
+                    # Remote branch may not exist yet, continue without reset
+                    pass
+
                 # Reload config for this branch
                 self.__config = Config(self.base_dir)
 
@@ -2304,7 +2322,7 @@ Each script is executed only once unless `--force` is used.
             self.model.execute_query('CREATE SCHEMA public')
             self.model.execute_query('GRANT ALL ON SCHEMA public TO public')
 
-    def restore_database_from_schema(self, exclude_bootstrap_patch_id: Optional[str] = None) -> None:
+    def restore_database_from_schema(self, exclude_bootstrap_patch_id: Optional[str] = None, exclude_bootstrap_version: Optional[str] = None) -> None:
         """
         Restore database from model/schema.sql, metadata, and data files.
 
@@ -2417,13 +2435,14 @@ Each script is executed only once unless `--force` is used.
             self.model.reconnect(reload=True)
 
             # 7. Execute bootstrap scripts
-            # Note: In patch apply context, we want ALL bootstraps to run
-            # (staged patches + prod). Only the current patch is excluded.
-            # Version filtering is done separately in promote to prod/rc.
+            # In patch apply context: ALL bootstraps run (only current patch excluded).
+            # In promote context: exclude_bootstrap_version skips the version being
+            # promoted (its bootstraps run after patches are applied).
             from half_orm_dev.bootstrap_manager import BootstrapManager
             bootstrap_mgr = BootstrapManager(self)
             bootstrap_mgr.run_bootstrap(
-                exclude_patch_id=exclude_bootstrap_patch_id
+                exclude_patch_id=exclude_bootstrap_patch_id,
+                exclude_version=exclude_bootstrap_version
             )
 
         except RepoError:
@@ -2563,7 +2582,8 @@ Each script is executed only once unless `--force` is used.
     def restore_database_from_release_schema(
         self,
         version: str,
-        exclude_bootstrap_patch_id: Optional[str] = None
+        exclude_bootstrap_patch_id: Optional[str] = None,
+        exclude_bootstrap_version: Optional[str] = None
     ) -> None:
         """
         Restore database from release schema file.
@@ -2578,6 +2598,8 @@ Each script is executed only once unless `--force` is used.
             version: Release version string (e.g., "0.17.1")
             exclude_bootstrap_patch_id: If provided, skip bootstrap files
                 belonging to this patch (used during patch apply)
+            exclude_bootstrap_version: If provided, skip bootstrap files for
+                this version (used during promote)
 
         Raises:
             RepoError: If restoration fails
@@ -2591,7 +2613,10 @@ Each script is executed only once unless `--force` is used.
 
         # Fallback to production schema if release schema doesn't exist
         if not release_schema_path.exists():
-            self.restore_database_from_schema(exclude_bootstrap_patch_id)
+            self.restore_database_from_schema(
+                exclude_bootstrap_patch_id,
+                exclude_bootstrap_version=exclude_bootstrap_version
+            )
             return
 
         try:
@@ -2609,7 +2634,10 @@ Each script is executed only once unless `--force` is used.
             # Execute bootstrap scripts
             from half_orm_dev.bootstrap_manager import BootstrapManager
             bootstrap_mgr = BootstrapManager(self)
-            bootstrap_mgr.run_bootstrap(exclude_patch_id=exclude_bootstrap_patch_id)
+            bootstrap_mgr.run_bootstrap(
+                exclude_patch_id=exclude_bootstrap_patch_id,
+                exclude_version=exclude_bootstrap_version
+            )
 
         except Exception as e:
             raise RepoError(f"Failed to restore from release schema: {e}") from e

half_orm_dev-0.17.5a5/half_orm_dev/version.txt

@@ -0,0 +1 @@
+0.17.5-a5

{half_orm_dev-0.17.5a3 → half_orm_dev-0.17.5a5/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.5a3
+Version: 0.17.5a5
 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-0.17.5a3/half_orm_dev/version.txt

@@ -1 +0,0 @@
-0.17.5-a3