half-orm-dev 1.0.0a6__tar.gz → 1.0.0a8__tar.gz

{half_orm_dev-1.0.0a6/half_orm_dev.egg-info → half_orm_dev-1.0.0a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a6
+Version: 1.0.0a8
 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.0a6 → half_orm_dev-1.0.0a8}/half_orm_dev/migration_manager.py

@@ -313,6 +313,9 @@ class MigrationManager:
                 f"Continuing with migration attempt."
             )
 
+        # 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)
 
@@ -370,6 +373,16 @@ class MigrationManager:
                     current_version, target_version, sync_result
                 )
 
+                # 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}"
+                    )
+
             except Exception as e:
                 # Don't fail migration if commit fails
                 result['errors'].append(f"Failed to create commit: {e}")
@@ -442,6 +455,127 @@ class MigrationManager:
         except Exception:
             pass  # remote tag may already be gone
 
+    def _ensure_active_branches_synced(self) -> None:
+        """Verify all active branches are in sync with origin before migration.
+
+        Branches that are behind are fast-forwarded automatically (no local commits
+        at risk).  Branches that are ahead or diverged block the migration — the
+        developer must push or resolve before proceeding.
+
+        Raises:
+            MigrationManagerError: if any active branch is ahead or diverged.
+        """
+        repo = self._repo
+        git_repo = repo.hgit._HGit__git_repo
+        current_branch = git_repo.active_branch.name
+
+        try:
+            branches_status = repo.hgit.get_active_branches_status()
+        except Exception:
+            return  # can't determine status, proceed cautiously
+
+        patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])]
+        release_branches = [b['name'] for b in branches_status.get('release_branches', [])]
+        staged_branches = [b['name'] for b in branches_status.get('staged_branches', [])]
+        active_branches = release_branches + patch_branches + staged_branches
+
+        blocked = []
+        for branch in active_branches:
+            try:
+                synced, status = repo.hgit.is_branch_synced(branch)
+                if synced:
+                    continue
+                if status == 'behind':
+                    # Fast-forward: no local commits at risk
+                    repo.hgit.checkout(branch)
+                    git_repo.git.merge('--ff-only', f'origin/{branch}')
+                elif status in ('ahead', 'diverged'):
+                    blocked.append((branch, status))
+            except Exception:
+                pass  # branch may not exist locally, skip
+
+        # Return to original branch
+        try:
+            repo.hgit.checkout(current_branch)
+        except Exception:
+            pass
+
+        if blocked:
+            ahead = [(b, s) for b, s in blocked if s == 'ahead']
+            diverged = [(b, s) for b, s in blocked if s == 'diverged']
+            parts = []
+            if ahead:
+                branch_list = ', '.join(b for b, _ in ahead)
+                parts.append(
+                    f"  Branches ahead of origin (unpushed commits) — push first:\n"
+                    + '\n'.join(f"    git push origin {b}" for b, _ in ahead)
+                )
+            if diverged:
+                parts.append(
+                    f"  Branches diverged from origin (local and remote have diverged) "
+                    f"— rebase or merge to resolve:\n"
+                    + '\n'.join(f"    {b}" for b, _ in diverged)
+                )
+            raise MigrationManagerError(
+                f"Migration blocked: active branches are not in sync with origin.\n"
+                + '\n'.join(parts)
+            )
+
+    def _regenerate_modules_after_migration(
+        self, from_version: str, to_version: str
+    ) -> None:
+        """Regenerate the project modules after a migration and sync to all active branches.
+
+        Runs generate(), commits the changed files on ho-prod, then replays those
+        changes on every active branch by checking out the package directory from ho-prod.
+        Skips silently if generate() produced no changes.
+        """
+        from half_orm_dev import modules as _modules
+
+        repo = self._repo
+        git_repo = repo.hgit._HGit__git_repo
+        package_name = repo.name
+        package_dir = str(Path(repo.base_dir) / package_name)
+
+        commit_msg = (
+            f"[HOP] Regenerate modules (migration {from_version} → {to_version})"
+        )
+
+        # Collect active branches before moving around
+        try:
+            branches_status = repo.hgit.get_active_branches_status()
+        except Exception:
+            branches_status = {}
+
+        patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])]
+        release_branches = [b['name'] for b in branches_status.get('release_branches', [])]
+        staged_branches = [b['name'] for b in branches_status.get('staged_branches', [])]
+        # ho-prod first, then active branches
+        all_branches = ['ho-prod'] + release_branches + patch_branches + staged_branches
+
+        for branch in all_branches:
+            try:
+                repo.hgit.checkout(branch)
+                # generate() reads existing files and preserves developer code sections
+                _modules.generate(repo)
+                repo.hgit.add(package_dir)
+                if not git_repo.git.diff('--cached', '--name-only').strip():
+                    continue
+                repo.hgit.commit('-m', commit_msg)
+                try:
+                    repo.hgit.push_branch(branch)
+                except Exception as push_err:
+                    sys.stderr.write(
+                        f"Warning: could not push {branch} after module regeneration "
+                        f"(diverged branch?): {push_err}\n"
+                    )
+            except Exception as e:
+                sys.stderr.write(
+                    f"Warning: could not regenerate modules on {branch}: {e}\n"
+                )
+
+        repo.hgit.checkout('ho-prod')
+
     def _create_migration_commit_message(
         self,
         from_version: str,

{half_orm_dev-1.0.0a6 → half_orm_dev-1.0.0a8}/half_orm_dev/modules.py

@@ -20,6 +20,7 @@ history with the last release applied.
 """
 
 import importlib
+import inspect
 import os
 import re
 import shutil
@@ -43,10 +44,7 @@ def read_template(file_name):
         return file_.read()
 
 NO_APAPTER = {}
-HO_DATACLASSES = [
-'''import dataclasses
-from half_orm.relation import DC_Relation
-from half_orm.field import Field''']
+HO_DATACLASSES = []
 HO_DATACLASSES_IMPORTS = set()
 HO_TYPEDICTS: list = []
 HO_TYPEDICTS_IMPORTS: set = set()
@@ -54,6 +52,7 @@ INIT_MODULE_TEMPLATE = read_template('init_module_template')
 MODULE_TEMPLATE_1 = read_template('module_template_1')
 MODULE_TEMPLATE_2 = read_template('module_template_2')
 MODULE_TEMPLATE_3 = read_template('module_template_3')
+MODULE_STUB_TEMPLATE = read_template('module_stub_template')
 WARNING_TEMPLATE = read_template('warning')
 CONFTEST = read_template('conftest_template')
 TEST = read_template('relation_test')
@@ -336,6 +335,18 @@ def __gen_typedict(relation, fkeys) -> list:
     return extra_classes + [main_class]
 
 
+def __gen_stub_file(module_path: str, class_name: str, dict_class_name: str, package_name: str) -> str:
+    """Generate a .pyi stub alongside the module for IDE type inference."""
+    stub_path = module_path[:-3] + '.pyi'
+    with open(stub_path, 'w', encoding='utf-8') as f:
+        f.write(MODULE_STUB_TEMPLATE.format(
+            package_name=package_name,
+            dict_class_name=dict_class_name,
+            class_name=class_name,
+        ))
+    return stub_path
+
+
 def __gen_typedicts(package_dir: str, package_name: str) -> None:
     with open(os.path.join(package_dir, "ho_typeddicts.py"), "w", encoding='utf-8') as file_:
         file_.write(f"# TypedDicts for {package_name}\n\n")
@@ -545,7 +556,9 @@ def __update_this_module(
     HO_DATACLASSES.append(__gen_dataclass(rel, existing_fkeys))
     HO_TYPEDICTS.extend(__gen_typedict(rel, existing_fkeys))
 
-    return module_path
+    stub_path = __gen_stub_file(module_path, class_name, dict_class_name, package_name)
+
+    return [module_path, stub_path]
 
 
 def __reset_dataclasses(repo, package_dir):
@@ -557,20 +570,86 @@ def __reset_dataclasses(repo, package_dir):
             file_.write(f'class DC_{__get_full_class_name(*t_qrn)}: ...\n')
 
 
+_TYPING_NAMES = frozenset(('Any', 'Dict', 'Iterator', 'List', 'Optional', 'Tuple', 'Union'))
+
+
+def __gen_dc_relation() -> tuple:
+    """Introspect Relation to generate DC_Relation with signatures and docstrings.
+
+    Returns (class_str, frozenset of typing names needed).
+    """
+    from half_orm.relation import Relation
+
+    def _fmt_doc(doc: str) -> str:
+        lines = doc.splitlines()
+        if len(lines) == 1:
+            return f'        """{doc}"""'
+        parts = [f'        """{lines[0]}']
+        for line in lines[1:]:
+            parts.append(f'        {line}' if line.strip() else '')
+        parts.append('        """')
+        return '\n'.join(parts)
+
+    method_blocks = []
+    for name in sorted(dir(Relation)):
+        if not name.startswith('ho_'):
+            continue
+        raw = inspect.getattr_static(Relation, name)
+        is_classmethod = isinstance(raw, classmethod)
+        underlying = raw.__func__ if isinstance(raw, (classmethod, staticmethod)) else raw
+        if not callable(underlying):
+            continue
+        is_async = inspect.iscoroutinefunction(underlying)
+        try:
+            sig_str = str(inspect.signature(underlying))
+        except (ValueError, TypeError):
+            continue
+        doc = inspect.getdoc(underlying)
+        block = []
+        if is_classmethod:
+            block.append('    @classmethod')
+        prefix = '    async def' if is_async else '    def'
+        block.append(f'{prefix} {name}{sig_str}:')
+        if doc:
+            block.append(_fmt_doc(doc))
+        block.append('        ...')
+        method_blocks.append('\n'.join(block))
+
+    full_body = '\n\n'.join(method_blocks)
+    needed_typing = frozenset(t for t in _TYPING_NAMES if t in full_body)
+    class_str = (
+        'class DC_Relation:\n'
+        '    # auto-generated by half-orm-dev — do not edit\n\n'
+        + full_body + '\n'
+    )
+    return class_str, needed_typing
+
+
 def __gen_dataclasses(package_dir, package_name):
+    dc_relation_str, dc_typing = __gen_dc_relation()
     with open(os.path.join(package_dir, "ho_dataclasses.py"), "w", encoding='utf-8') as file_:
-        file_.write(f"# dataclasses for {package_name}\n\n")
-        hd_imports = list(HO_DATACLASSES_IMPORTS)
-        hd_imports.sort()
-        for to_import in hd_imports:
-            file_.write(f"import {to_import}\n")
-        file_.write("\n")
+        file_.write(f"# DO NOT EDIT — auto-generated by half-orm-dev\n\n")
+        file_.write("import dataclasses\n")
+        file_.write("from half_orm.field import Field\n")
+        if dc_typing:
+            file_.write(f"from typing import {', '.join(sorted(dc_typing))}\n")
+        for mod in sorted(HO_DATACLASSES_IMPORTS):
+            file_.write(f"import {mod}\n")
+        file_.write("\n\n")
+        file_.write(dc_relation_str)
         for dc in HO_DATACLASSES:
-            file_.write(f"\n{dc}\n")
+            file_.write(f"\n\n{dc}\n")
 
 
 def generate(repo):
     """Synchronize the modules with the structure of the relation in PG."""
+    # Reset accumulators — allows safe repeated calls in the same process
+    HO_DATACLASSES.clear()
+    HO_DATACLASSES_IMPORTS.clear()
+    HO_TYPEDICTS.clear()
+    HO_TYPEDICTS_IMPORTS.clear()
+    NO_APAPTER.clear()
+
     package_name = repo.name
     base_dir = Path(repo.base_dir)
     package_dir = base_dir / package_name
@@ -613,10 +692,9 @@ def generate(repo):
 
     # Generate modules for each relation
     for relation in repo.database.model._relations():
-        module_path = __update_this_module(repo, relation, str(package_dir), package_name)
-        if module_path:
-            files_list.append(module_path)
-            # Tests are no longer added to files_list (they live in tests/ directory)
+        paths = __update_this_module(repo, relation, str(package_dir), package_name)
+        if paths:
+            files_list.extend(paths)
 
     __gen_dataclasses(str(package_dir), package_name)
     __gen_typedicts(str(package_dir), package_name)

{half_orm_dev-1.0.0a6 → half_orm_dev-1.0.0a8}/half_orm_dev/repo.py

@@ -690,18 +690,10 @@ class Repo:
                 remote_ref = f"origin/{branch}"
                 try:
                     synced, status = self.hgit.is_branch_synced(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
-                        )
-                    # Only reset when the remote is ahead of local ("behind") or
-                    # branches have diverged.  Never reset an "ahead" branch —
-                    # that would orphan local commits that have not been pushed
-                    # yet (e.g. the "Create patch directory" commit from
-                    # `hop patch create` before the first push).
-                    if not synced and status in ("behind", "diverged"):
+                    # Only fast-forward when origin is strictly ahead (no local commits
+                    # at risk). Never reset on diverged branches — that would destroy
+                    # unmerged local work.
+                    if not synced and status == "behind":
                         self.hgit._HGit__git_repo.git.reset('--hard', remote_ref)
                 except GitCommandError:
                     # Remote branch may not exist yet, continue without reset

half_orm_dev-1.0.0a8/half_orm_dev/templates/module_stub_template

@@ -0,0 +1,8 @@
+# DO NOT EDIT — auto-generated by half-orm-dev
+from typing import Iterator
+from {package_name}.ho_typeddicts import {dict_class_name}
+
+class {class_name}:
+    def __iter__(self) -> Iterator[{dict_class_name}]: ...
+    def ho_get(self, *args) -> {dict_class_name}: ...
+    async def ho_aget(self, *args) -> {dict_class_name}: ...

{half_orm_dev-1.0.0a6 → half_orm_dev-1.0.0a8}/half_orm_dev/templates/module_template_1

@@ -6,10 +6,7 @@ WARNING!
 
 {warning}
 """
-from typing import TYPE_CHECKING, Iterator
 from half_orm.model import register
 from {package_name} import MODEL, ho_dataclasses
-if TYPE_CHECKING:
-    from {package_name}.ho_typeddicts import {dict_class_name}
 fields_aliases=None
 

half_orm_dev-1.0.0a8/half_orm_dev/templates/module_template_3

@@ -0,0 +1,3 @@
+    #pylint: disable=line-too-long, too-many-arguments, redefined-builtin, too-many-positional-arguments
+    def __init__(self, {kwargs}):
+        super().__init__({arg_names}, **kwargs)

half_orm_dev-1.0.0a8/half_orm_dev/version.txt

@@ -0,0 +1 @@
+1.0.0-a8

{half_orm_dev-1.0.0a6 → half_orm_dev-1.0.0a8/half_orm_dev.egg-info}/PKG-INFO

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

@@ -64,6 +64,7 @@ half_orm_dev/templates/MANIFEST.in
 half_orm_dev/templates/README
 half_orm_dev/templates/conftest_template
 half_orm_dev/templates/init_module_template
+half_orm_dev/templates/module_stub_template
 half_orm_dev/templates/module_template_1
 half_orm_dev/templates/module_template_2
 half_orm_dev/templates/module_template_3

half_orm_dev-1.0.0a6/half_orm_dev/templates/module_template_3

@@ -1,12 +0,0 @@
-    #pylint: disable=line-too-long, too-many-arguments, redefined-builtin, too-many-positional-arguments
-    def __init__(self, {kwargs}):
-        super().__init__({arg_names}, **kwargs)
-
-    def __iter__(self) -> 'Iterator[{dict_class_name}]':
-        return super().__iter__()
-
-    def ho_get(self, *args) -> '{dict_class_name}':
-        return super().ho_get(*args)
-
-    async def ho_aget(self, *args) -> '{dict_class_name}':
-        return await super().ho_aget(*args)

half_orm_dev-1.0.0a6/half_orm_dev/version.txt

@@ -1 +0,0 @@
-1.0.0-a6