half-orm-dev 0.17.2a3__tar.gz → 0.17.2a4__tar.gz

{half_orm_dev-0.17.2a3/half_orm_dev.egg-info → half_orm_dev-0.17.2a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.2a3
+Version: 0.17.2a4
 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.2a4/half_orm_dev/decorators.py

@@ -0,0 +1,133 @@
+"""
+Decorators for half-orm-dev.
+
+Provides common decorators for ReleaseManager and PatchManager.
+"""
+
+import sys
+import inspect
+from functools import wraps
+
+
+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).
+
+    Args:
+        branch_getter: Callable that takes (self, *args, **kwargs) and returns branch name
+        timeout_minutes: Lock timeout in minutes (default: 30)
+
+    Usage:
+        def _get_release_branch(self, patch_id, *args, **kwargs):
+            # Logic to determine release branch from patch_id
+            return f"ho-release/{version}"
+
+        @with_dynamic_branch_lock(_get_release_branch)
+        def close_patch(self, patch_id):
+            # Will lock the release branch determined by _get_release_branch
+            ...
+
+    Notes:
+        - branch_getter is called with the same arguments as the decorated function
+        - The lock is ALWAYS released in the finally block, even on error
+        - After success, .hop/ is automatically synced from locked branch to all others
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            lock_tag = None
+            locked_branch = None
+            try:
+                # 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)
+
+                # 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(
+                        reason=f"{func.__name__}"
+                    )
+                    # Log sync errors but don't fail the operation
+                    if sync_result.get('errors'):
+                        for error in sync_result['errors']:
+                            print(f"Warning: .hop/ sync error: {error}", file=sys.stderr)
+                except Exception as e:
+                    # Don't fail the decorated method if sync fails
+                    print(f"Warning: Failed to sync .hop/ to active branches: {e}", file=sys.stderr)
+
+                return result
+            finally:
+                # Always release lock (even on error)
+                if lock_tag:
+                    self._repo.hgit.release_branch_lock(lock_tag)
+
+        return wrapper
+    return decorator
+
+class Node:
+    def __init__(self, name):
+        self.name = name
+        self.children = []
+
+class Node:
+    def __init__(self, name):
+        self.name = name
+        self.children = []
+
+def print_tree(node, depth=0):
+    print("  " * depth + node.name)
+    for child in node.children:
+        print_tree(child, depth + 1)
+
+
+def trace_package(package_root: str):
+    def decorator(func):
+
+        def wrapper(*args, **kwargs):
+            root = Node(func.__qualname__)
+            stack = [root]
+
+            def tracer(frame, event, arg):
+                filename = frame.f_code.co_filename
+
+                # On garde uniquement les appels venant du package
+                if package_root not in filename:
+                    return tracer
+
+                if event == 'call':
+                    name = frame.f_code.co_qualname
+                    node = Node(name)
+                    stack[-1].children.append(node)
+                    stack.append(node)
+
+                elif event == 'return':
+                    if len(stack) > 1:
+                        stack.pop()
+
+                return tracer
+
+            sys.settrace(tracer)
+            try:
+                result = func(*args, **kwargs)
+            finally:
+                sys.settrace(None)
+
+                print("\n=== Arbre d'exécution ===")
+                print_tree(root)
+                print("=========================\n")
+
+            return result   # 🔥 retour normal, aucune modification
+
+        return wrapper
+    return decorator

{half_orm_dev-0.17.2a3 → half_orm_dev-0.17.2a4}/half_orm_dev/hgit.py

@@ -247,6 +247,10 @@ class HGit:
         "Proxy to git.add method"
         return self.__git_repo.git.add(*args, **kwargs)
 
+    def rm(self, *args, **kwargs):
+        "Proxy to git.rm method"
+        return self.__git_repo.git.rm(*args, **kwargs)
+
     def commit(self, *args, **kwargs):
         "Proxy to git.commit method"
         return self.__git_repo.git.commit(*args, **kwargs)

{half_orm_dev-0.17.2a3 → half_orm_dev-0.17.2a4}/half_orm_dev/migration_manager.py

@@ -234,23 +234,24 @@ class MigrationManager:
         return result
 
     @with_dynamic_branch_lock(lambda self, *args, **kwargs: 'ho-prod')
-    def run_migrations(self, target_version: str, create_commit: bool = True, notify_branches: bool = True) -> Dict:
+    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.
 
+        After successful completion, the decorator automatically syncs .hop/
+        directory to all active branches (ho-patch/*, ho-release/*).
+
         Args:
             target_version: Target version string (e.g., "0.17.1")
             create_commit: Whether to create Git commit after migration
-            notify_branches: Whether to create empty commits on active branches
 
         Returns:
             Dict with migration results including:
                 - migrations_applied: List of applied migrations
                 - commit_created: Whether migration commit was created
-                - notified_branches: List of branches that were notified
         """
         result = {
             'target_version': target_version,
@@ -296,28 +297,30 @@ class MigrationManager:
             self._repo, '_Repo__config'
         ) else "0.0.0"
 
+        # If already at target version, nothing to do
+        if current_version == target_version:
+            return result
+
         # Get pending migrations
         pending = self.get_pending_migrations(current_version, target_version)
 
-        if not pending:
-            # No migrations to apply
-            return result
-
-        # Apply each migration
-        for version_str, migration_dir in pending:
-            try:
-                migration_result = self.apply_migration(version_str, migration_dir)
-                result['migrations_applied'].append(migration_result)
+        # Apply each migration if there are any
+        if pending:
+            for version_str, migration_dir in pending:
+                try:
+                    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
+                except MigrationManagerError as e:
+                    result['errors'].append(str(e))
+                    raise
 
-        # Update hop_version in .hop/config
+        # 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()
-            self._repo.hgit.add(str(Path('.hop') / 'config'))
 
         # Create Git commit if requested
         if create_commit and self._repo.hgit:
@@ -328,32 +331,25 @@ class MigrationManager:
                     result['migrations_applied']
                 )
 
-                # Commit the changes added by the script
-                self._repo.hgit.commit('-m', commit_msg)
+                # Commit and sync to active branches
+                sync_result = self._repo.commit_and_sync_to_active_branches(
+                    message=commit_msg,
+                    reason=f"migration {current_version} → {target_version}"
+                )
 
                 result['commit_created'] = True
                 result['commit_message'] = commit_msg
-
-                # Push to remote
-                try:
-                    self._repo.hgit.push()
-                    result['commit_pushed'] = True
-                except Exception as e:
-                    result['errors'].append(f"Failed to push commit: {e}")
-                    result['commit_pushed'] = False
+                result['commit_pushed'] = True
+                result['sync_result'] = sync_result
 
             except Exception as e:
                 # Don't fail migration if commit fails
                 result['errors'].append(f"Failed to create commit: {e}")
 
-        # Notify active branches if requested
-        if notify_branches and create_commit and result['commit_created']:
-            try:
-                notified = self._notify_active_branches(current_version, target_version)
-                result['notified_branches'] = notified
-            except Exception as e:
-                # Don't fail migration if notification fails
-                result['errors'].append(f"Failed to notify branches: {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.
 
         return result
 
@@ -369,111 +365,28 @@ class MigrationManager:
         Args:
             from_version: Starting version
             to_version: Target version
-            migrations: List of migration result dicts
+            migrations: List of migration result dicts (can be empty)
 
         Returns:
             Commit message string
         """
         lines = [
-            f"[HOP] Migration from {from_version} to {to_version}",
-            "",
-            "Applied migrations:"
+            f"[HOP] Migration from {from_version} to {to_version}"
         ]
 
-        for migration in migrations:
-            version = migration['version']
-            files = migration['applied_files']
-            lines.append(f"  - {version}: {', '.join(files)}")
+        if migrations:
+            lines.append("")
+            lines.append("Applied migrations:")
+            for migration in migrations:
+                version = migration['version']
+                files = migration['applied_files']
+                lines.append(f"  - {version}: {', '.join(files)}")
+        else:
+            lines.append("")
+            lines.append("No migration scripts needed (version update only)")
 
         return '\n'.join(lines)
 
-    def _notify_active_branches(self, from_version: str, to_version: str) -> List[str]:
-        """
-        Apply migration to active branches (ho-patch/*, ho-release/*).
-
-        Applies the same migrations on all active branches, creates commits,
-        and pushes them to origin. This prevents merge conflicts when branches
-        merge ho-prod later.
-
-        Args:
-            from_version: Starting version
-            to_version: Target version
-
-        Returns:
-            List of branch names that were migrated
-        """
-        migrated_branches = []
-
-        # Get active branches from origin using hgit method
-        branches_status = self._repo.hgit.get_active_branches_status()
-
-        # Extract branch names from patch_branches and release_branches
-        patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])]
-        release_branches = [b['name'] for b in branches_status.get('release_branches', [])]
-
-        # Combine all active branches (excluding ho-prod)
-        active_branches = [b for b in patch_branches + release_branches if b != 'ho-prod']
-
-        # Current branch (should be ho-prod)
-        current_branch = self._repo.hgit.branch
-
-        # Apply migration on each active branch
-        for branch in active_branches:
-            try:
-                # Checkout branch
-                self._repo.hgit.checkout(branch)
-
-                # Reload config for this branch
-                from half_orm_dev.repo import Config
-                self._repo._Repo__config = Config(self._repo.base_dir)
-
-                # Get pending migrations for this branch
-                branch_version = self._repo._Repo__config.hop_version
-                pending = self.get_pending_migrations(branch_version, to_version)
-
-                if not pending:
-                    # Already migrated or no migration needed
-                    continue
-
-                # Apply each migration
-                for version_str, migration_dir in pending:
-                    self.apply_migration(version_str, migration_dir)
-
-                # Update hop_version in .hop/config
-                self._repo._Repo__config.hop_version = to_version
-                self._repo._Repo__config.write()
-                self._repo.hgit.add(Path('.hop') / 'config')
-
-                # Create commit message
-                commit_msg = self._create_migration_commit_message(
-                    branch_version,
-                    to_version,
-                    [{'version': v, 'applied_files': []} for v, _ in pending]
-                )
-
-                # commit the changes added by the script
-                self._repo.hgit.commit('-m', commit_msg)
-
-                # Push the commit
-                self._repo.hgit.push_branch(branch)
-
-                migrated_branches.append(branch)
-
-            except Exception as e:
-                print(f"Warning: Failed to migrate branch {branch}: {e}", file=sys.stderr)
-
-        # Return to original branch (ho-prod)
-        if current_branch:
-            try:
-                self._repo.hgit.checkout(current_branch)
-                # Reload config for original branch
-                from half_orm_dev.repo import Config
-                self._repo._Repo__config = Config(self._repo.base_dir)
-            except Exception:
-                pass
-
-        return migrated_branches
-
     def check_migration_needed(self, current_tool_version: str) -> bool:
         """
         Check if migration is needed.