half-orm-dev 1.0.0a20__tar.gz → 1.0.0a22__tar.gz

{half_orm_dev-1.0.0a20/half_orm_dev.egg-info → half_orm_dev-1.0.0a22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a20
+Version: 1.0.0a22
 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.0a20 → half_orm_dev-1.0.0a22}/half_orm_dev/cli/main.py

@@ -133,6 +133,38 @@ def create_cli_group():
                 cmd.callback = check_version_before_invoke(cmd.callback)
             super().add_command(cmd, name)
 
+        def get_command(self, ctx, cmd_name):
+            cmd = super().get_command(ctx, cmd_name)
+            if cmd is not None:
+                return cmd
+            # Unknown command — show a specific message when migration is needed.
+            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
+
+                @click.command(
+                    cmd_name,
+                    context_settings={
+                        'allow_extra_args': True,
+                        'ignore_unknown_options': True,
+                    },
+                )
+                @click.pass_context
+                def _migration_required(ctx):
+                    click.echo(
+                        f"\n⚠️  Command '{cmd_name}' is not available: migration required.\n\n"
+                        f"  Repository version: {config_version}\n"
+                        f"  Installed version:  {installed_version}\n\n"
+                        f"  Apply migration:  half_orm dev migrate\n"
+                        f"  Revert version:   pip install half-orm-dev=={config_version}\n",
+                        err=True,
+                    )
+                    sys.exit(1)
+
+                return _migration_required
+            return None
+
     @click.group(cls=VersionCheckGroup, invoke_without_command=True)
     @click.pass_context
     def dev(ctx):
@@ -141,8 +173,8 @@ def create_cli_group():
             error = hop.hop_upgrade_error
             required = error.required_version
             installed = error.installed_version
-            click.echo(f"\n  Ce repo requiers half-orm-dev {required} "
-                       f"(installed : {installed}).")
+            click.echo(f"\n  This repository requires half-orm-dev {required} "
+                       f"(installed: {installed}).")
             click.echo(f"  Installing the required version...")
             try:
                 subprocess.run(
@@ -151,7 +183,7 @@ def create_cli_group():
                 )
             except subprocess.CalledProcessError:
                 click.echo(f"\n  Installation failed.", err=True)
-                click.echo(f"  Run manually : pip install half-orm-dev=={required}", err=True)
+                click.echo(f"  Run manually: pip install half-orm-dev=={required}", err=True)
                 sys.exit(1)
             click.echo(f"  ✓ half-orm-dev {required} installed. Restarting...\n")
             os.execv(sys.argv[0], sys.argv)

{half_orm_dev-1.0.0a20 → half_orm_dev-1.0.0a22}/half_orm_dev/hgit.py

@@ -1471,8 +1471,15 @@ class HGit:
             is_local = branch in local_release_branches
             release_branch_infos.append(get_branch_info(branch, check_stage=True, is_local=is_local))
 
+        # ho-prod is always active — include it without special treatment.
+        prod_branch_info = None
+        local_prod = self.branch_exists('ho-prod')
+        if local_prod or 'ho-prod' in remote_branch_names:
+            prod_branch_info = get_branch_info('ho-prod', is_local=local_prod)
+
         return {
             'current_branch': current_branch,
+            'prod_branch': prod_branch_info,
             'patch_branches': patch_branch_infos,
             'staged_branches': staged_branch_infos,
             'release_branches': release_branch_infos

{half_orm_dev-1.0.0a20 → half_orm_dev-1.0.0a22}/half_orm_dev/migration_manager.py

@@ -10,10 +10,11 @@ Directory structure:
     ├── log                    # List of applied migrations (version format)
     └── major/                 # Major version
         └── minor/             # Minor version
-            └── patch/         # Patch version
+            └── patch/         # Patch version (stable migrations here)
                 ├── 00_migration_name.py
                 ├── 01_another_migration.py
-                └── README.md
+                └── a20/       # Pre-release migrations (4th level, PEP 440)
+                    └── 01_migration_name.py
 
 Each migration file must define:
     - migrate(repo): Execute the migration
@@ -66,75 +67,92 @@ class MigrationManager:
         # Path to migrations directory (in half_orm_dev package)
         self._migrations_root = Path(__file__).parent / 'migrations'
 
-    def _version_to_path(self, version: Tuple[int, int, int]) -> Path:
+    def _version_to_path(self, version_str: str) -> Path:
         """
-        Convert version tuple to migration directory path.
+        Convert a version string to its migration directory path.
+
+        For stable versions (e.g., "0.17.5") returns major/minor/patch/.
+        For pre-release versions (e.g., "1.0.0a20") returns major/minor/patch/pre/
+        where pre is the pre-release segment (e.g., "a20").
 
         Args:
-            version: Tuple of (major, minor, patch)
+            version_str: PEP 440 version string
 
         Returns:
             Path to migration directory
         """
-        major, minor, patch = version
-        return self._migrations_root / str(major) / str(minor) / str(patch)
+        v = version.parse(version_str)
+        major, minor, patch = v.release[:3]
+        base = self._migrations_root / str(major) / str(minor) / str(patch)
+        if v.pre:
+            pre_str = ''.join(str(p) for p in v.pre)
+            return base / pre_str
+        return base
 
     def get_pending_migrations(self, current_version: str, target_version: str) -> List[Tuple[str, Path]]:
         """
         Get list of migrations that need to be applied.
 
         Compares current version (from .hop/config) with target version (from hop_version())
-        and returns all migrations in between.
+        and returns all migrations in between, sorted by PEP 440 version order.
+
+        Directory structure:
+            migrations/major/minor/patch/         ← stable version scripts
+            migrations/major/minor/patch/a20/     ← pre-release scripts (4th level)
 
         Args:
-            current_version: Current version from .hop/config (e.g., "0.17.0")
-            target_version: Target version from hop_version() (e.g., "0.17.1")
+            current_version: Current version from .hop/config (e.g., "0.17.0" or "1.0.0-a19")
+            target_version: Target version from hop_version() (e.g., "0.17.1" or "1.0.0-a20")
 
         Returns:
-            List of (version_str, migration_dir_path) tuples in order
+            List of (version_str, migration_dir_path) tuples in PEP 440 order
         """
-        current = version.parse(current_version).release
-        target = version.parse(target_version).release
+        current = version.parse(current_version)
+        target = version.parse(target_version)
 
-        pending = []
+        candidates = []
 
-        # Walk through version directories to find migrations between current and target
-        # Start from current version + 1 up to target version
-        for major in range(0, target[0] + 1):
-            major_dir = self._migrations_root / str(major)
-            if not major_dir.exists():
+        for major_dir in sorted(self._migrations_root.iterdir(), key=lambda p: int(p.name) if p.name.isdigit() else -1):
+            if not major_dir.is_dir() or not major_dir.name.isdigit():
                 continue
+            major = int(major_dir.name)
 
-            minor_max = target[1] if major == target[0] else 999
-            for minor in range(0, minor_max + 1):
-                minor_dir = major_dir / str(minor)
-                if not minor_dir.exists():
+            for minor_dir in sorted(major_dir.iterdir(), key=lambda p: int(p.name) if p.name.isdigit() else -1):
+                if not minor_dir.is_dir() or not minor_dir.name.isdigit():
                     continue
+                minor = int(minor_dir.name)
 
-                patch_max = target[2] if major == target[0] and minor == target[1] else 999
-                for patch in range(0, patch_max + 1):
-                    patch_dir = minor_dir / str(patch)
-                    if not patch_dir.exists():
-                        continue
-
-                    version_tuple = (major, minor, patch)
-
-                    # Skip if this version is <= current version
-                    if version_tuple <= current:
+                for patch_dir in sorted(minor_dir.iterdir(), key=lambda p: int(p.name) if p.name.isdigit() else -1):
+                    if not patch_dir.is_dir() or not patch_dir.name.isdigit():
                         continue
-
-                    # Skip if this version is > target version
-                    if version_tuple > target:
-                        continue
-
-                    version_str = f"{major}.{minor}.{patch}"
-
-                    # Check if this version has any migration files
-                    migration_files = list(patch_dir.glob('*.py'))
-                    if migration_files:
-                        pending.append((version_str, patch_dir))
-
-        return pending
+                    patch = int(patch_dir.name)
+                    base_version_str = f"{major}.{minor}.{patch}"
+
+                    # 4th level: pre-release subdirectories (e.g., a20/, b1/, rc2/)
+                    for pre_dir in sorted(patch_dir.iterdir()):
+                        if not pre_dir.is_dir() or not re.match(r'^[a-z]+\d+$', pre_dir.name):
+                            continue
+                        pre_version_str = f"{base_version_str}{pre_dir.name}"
+                        try:
+                            v = version.parse(pre_version_str)
+                        except Exception:
+                            continue
+                        if current < v <= target and list(pre_dir.glob('*.py')):
+                            candidates.append((pre_version_str, pre_dir))
+
+                    # Stable version scripts at patch level
+                    stable_files = list(patch_dir.glob('*.py'))
+                    if stable_files:
+                        try:
+                            v = version.parse(base_version_str)
+                        except Exception:
+                            continue
+                        if current < v <= target:
+                            candidates.append((base_version_str, patch_dir))
+
+        # Sort by PEP 440 version (pre-releases sort before their stable counterpart)
+        candidates.sort(key=lambda x: version.parse(x[0]))
+        return candidates
 
     def _load_migration_module(self, migration_file: Path):
         """
@@ -506,10 +524,12 @@ class MigrationManager:
         except Exception:
             return  # can't determine status, proceed cautiously
 
+        prod_info = branches_status.get('prod_branch')
+        prod_branches = [prod_info['name']] if prod_info else []
         patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])]
         release_branches = [b['name'] for b in branches_status.get('release_branches', [])]
         # ho-staged/* branches are frozen after merge — excluded from sync checks
-        active_branches = release_branches + patch_branches
+        active_branches = prod_branches + release_branches + patch_branches
 
         blocked = []
         for branch in active_branches:

half_orm_dev-1.0.0a22/half_orm_dev/migrations/1/0/0/a20/01_update_gitignore.py

@@ -0,0 +1,36 @@
+"""
+Migration 1.0.0a20 — Add production-specific entries to .gitignore
+
+Adds .hop/production and .hop/.fetching to .gitignore so that production
+server marker files are not tracked by git.
+"""
+
+GITIGNORE_ENTRIES = ['.hop/production', '.hop/.fetching']
+
+
+def get_description():
+    return "Add .hop/production and .hop/.fetching to .gitignore"
+
+
+def migrate(repo):
+    from pathlib import Path
+
+    base_dir = repo._Repo__base_dir
+    gitignore_path = Path(base_dir) / '.gitignore'
+
+    if not gitignore_path.exists():
+        return {}
+
+    content = gitignore_path.read_text()
+    lines = content.splitlines()
+    missing = [e for e in GITIGNORE_ENTRIES if e not in lines]
+
+    if not missing:
+        return {}
+
+    with gitignore_path.open('a') as f:
+        f.write('\n' + '\n'.join(missing) + '\n')
+
+    repo.stage_maintenance_file('.gitignore')
+
+    return {'sync_files': ['.gitignore']}

{half_orm_dev-1.0.0a20 → half_orm_dev-1.0.0a22}/half_orm_dev/repo.py

@@ -491,7 +491,6 @@ class Repo:
                 "  Run 'hop migrate' on a development machine first, then deploy."
             )
 
-        self._migration_running = True
         try:
             # Create migration manager
             migration_mgr = MigrationManager(self)
@@ -506,25 +505,38 @@ class Repo:
 
             result['migration_needed'] = True
 
-            # Migration must be run on ho-prod branch
-            # If not on ho-prod, switch automatically if working directory is clean
             current_branch = self.hgit.branch if self.hgit else 'unknown'
             switched_branch = False
 
+            # Dirty check done ONCE here, before any operation.
+            # After this point _migration_running disables further dirty checks:
+            # all modifications are the migration's responsibility and will be committed.
+            if self.hgit and self.hgit.git_repo.is_dirty(untracked_files=False):
+                config_version = self.__config.hop_version if hasattr(self, '_Repo__config') else '0.0.0'
+                status = self.hgit.git_repo.git.status('--short')
+                raise RepoError(
+                    f"Repository migration required but working directory has uncommitted changes.\n\n"
+                    f"  Repository version: {config_version}\n"
+                    f"  Installed version:  {current_version}\n"
+                    f"  Current branch:     {current_branch}\n\n"
+                    f"  Please commit or stash your changes:\n"
+                    f"    git stash\n"
+                    f"    OR\n"
+                    f"    git add . && git commit -m \"your message\"\n"
+                    f"Dirty files:\n{status}"
+                )
+
+            # Verify all active branches (including ho-prod) are in sync before
+            # switching branches or touching anything.
+            try:
+                migration_mgr._ensure_active_branches_synced()
+            except Exception as e:
+                raise RepoError(str(e)) from e
+
+            # From here, all modifications are made by the migration itself.
+            self._migration_running = True
+
             if not self.hgit or self.hgit.branch != 'ho-prod':
-                # Check if working directory is clean
-                if self.hgit and self.hgit.git_repo.is_dirty(untracked_files=False):
-                    config_version = self.__config.hop_version if hasattr(self, '_Repo__config') else '0.0.0'
-                    raise RepoError(
-                        f"Repository migration required but working directory has uncommitted changes.\n\n"
-                        f"  Repository version: {config_version}\n"
-                        f"  Installed version:  {current_version}\n"
-                        f"  Current branch:     {current_branch}\n\n"
-                        f"  Please commit or stash your changes:\n"
-                        f"    git stash\n"
-                        f"    OR\n"
-                        f"    git add . && git commit -m \"your message\"\n"
-                    )
 
                 # Working directory is clean, switch to ho-prod
                 try:
@@ -896,17 +908,21 @@ class Repo:
             git_repo = self.hgit.git_repo
             current_branch = git_repo.active_branch.name
 
-            # Check if working directory is clean
-            if git_repo.is_dirty(untracked_files=False):
-                status = git_repo.git.status('--short')
-                raise RepoError(
-                    f"Working directory has uncommitted changes.\n"
-                    f"Please commit or stash your changes before running this command:\n"
-                    f"  git stash\n"
-                    f"  OR\n"
-                    f"  git add . && git commit -m \"your message\"\n"
-                    f"Dirty files:\n{status}"
-                )
+            # Check if working directory is clean.
+            # Skipped during migration: _migration_running means the dirty check
+            # was already done once at the start of run_migrations_if_needed(),
+            # and all subsequent modifications are committed by the migration itself.
+            if not getattr(self, '_migration_running', False):
+                if git_repo.is_dirty(untracked_files=False):
+                    status = git_repo.git.status('--short')
+                    raise RepoError(
+                        f"Working directory has uncommitted changes.\n"
+                        f"Please commit or stash your changes before running this command:\n"
+                        f"  git stash\n"
+                        f"  OR\n"
+                        f"  git add . && git commit -m \"your message\"\n"
+                        f"Dirty files:\n{status}"
+                    )
 
             # Switch to ho-prod temporarily
             git_repo.heads['ho-prod'].checkout()
@@ -1391,6 +1407,30 @@ class Repo:
         # step 12: Protect ho-prod from direct commits
         self.install_git_hooks()
 
+    def stage_maintenance_file(self, relative_path: str) -> None:
+        """Stage a file modified by an automated maintenance operation."""
+        if not hasattr(self, '_maintenance_files'):
+            self._maintenance_files = []
+        abs_path = os.path.join(self.__base_dir, relative_path)
+        if os.path.exists(abs_path):
+            self.hgit.git_repo.index.add([relative_path])
+            if relative_path not in self._maintenance_files:
+                self._maintenance_files.append(relative_path)
+
+    def commit_maintenance_files(self, message: str = 'update maintenance files') -> bool:
+        """Commit all staged maintenance files in a single [HOP] commit (skip hooks)."""
+        if not getattr(self, '_maintenance_files', None):
+            return False
+        try:
+            self.hgit.git_repo.index.commit(
+                f'[HOP] {message}',
+                skip_hooks=True,
+            )
+            self._maintenance_files = []
+            return True
+        except Exception:
+            return False
+
     def install_git_hooks(self, force: bool = False) -> dict:
         """
         Install or update Git hooks from templates.
@@ -1457,17 +1497,6 @@ class Repo:
                 if action == 'installed' or overall_action == 'skipped':
                     overall_action = action
 
-        # Ensure production-specific entries are in .gitignore (idempotent).
-        gitignore_path = Path(self.__base_dir) / '.gitignore'
-        if gitignore_path.exists():
-            content = gitignore_path.read_text()
-            lines = content.splitlines()
-            missing = [e for e in ('.hop/production', '.hop/.fetching')
-                       if e not in lines]
-            if missing:
-                with gitignore_path.open('a') as f:
-                    f.write('\n' + '\n'.join(missing) + '\n')
-
         return {
             'installed': any_installed,
             'action': overall_action

half_orm_dev-1.0.0a22/half_orm_dev/version.txt

@@ -0,0 +1 @@
+1.0.0-a22

{half_orm_dev-1.0.0a20 → half_orm_dev-1.0.0a22/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a20
+Version: 1.0.0a22
 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.0a20 → half_orm_dev-1.0.0a22}/half_orm_dev.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ half_orm_dev/migrations/0/17/4/02_move_patches_to_subdirs.py
 half_orm_dev/migrations/0/17/5/01_update_pyproject_dependency.py
 half_orm_dev/migrations/0/18/0/00_add_async_support.py
 half_orm_dev/migrations/0/18/0/01_update_default_tests.py
+half_orm_dev/migrations/1/0/0/a20/01_update_gitignore.py
 half_orm_dev/migrations/hop/BREAKING_CHANGES-1.0.0.md
 half_orm_dev/patches/log
 half_orm_dev/patches/0/1/0/00_half_orm_meta.database.sql

half_orm_dev-1.0.0a20/half_orm_dev/version.txt

@@ -1 +0,0 @@
-1.0.0-a20