half-orm-dev 1.0.0a14__tar.gz → 1.0.0a16__tar.gz

{half_orm_dev-1.0.0a14/half_orm_dev.egg-info → half_orm_dev-1.0.0a16}/PKG-INFO

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

@@ -931,6 +931,28 @@ class HGit:
             print(f"⚠️  Warning: Failed to delete local lock tag {lock_tag}: {e}")
 
 
+    def is_branch_locked(self, branch_name: str, timeout_minutes: int = 30) -> bool:
+        """Return True if a valid (non-stale) lock tag for branch_name exists on origin."""
+        self.fetch_tags()
+        safe_branch_name = branch_name.replace('/', '-')
+        lock_pattern = f"lock-{safe_branch_name}-*"
+        existing_locks = self.list_tags(pattern=lock_pattern)
+        if not existing_locks:
+            return False
+        lock_name = existing_locks[0]
+        remote_ref = self.__git_repo.git.ls_remote(
+            '--tags', 'origin', f'refs/tags/{lock_name}'
+        ).strip()
+        if not remote_ref:
+            return False
+        match = re.search(r'-(\d+)$', lock_name)
+        if not match:
+            return True
+        lock_timestamp_ms = int(match.group(1))
+        lock_time = datetime.fromtimestamp(lock_timestamp_ms / 1000.0, tz=timezone.utc)
+        age_minutes = (datetime.now(timezone.utc) - lock_time).total_seconds() / 60
+        return age_minutes <= timeout_minutes
+
     def list_tags(self, pattern: Optional[str] = None) -> List[str]:
         """
         List tags matching glob pattern.

{half_orm_dev-1.0.0a14 → half_orm_dev-1.0.0a16}/half_orm_dev/migration_manager.py

@@ -25,7 +25,9 @@ import re
 import subprocess
 import sys
 import importlib.util
+from configparser import ConfigParser
 from packaging import version
+import click
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
 from half_orm import utils
@@ -283,14 +285,44 @@ class MigrationManager:
                 )
                 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 subprocess.CalledProcessError as e:
-                # Could not compare - maybe origin/ho-prod doesn't exist yet
+            except (MigrationManagerError, subprocess.CalledProcessError):
+                raise
+            except Exception:
+                # Could not compare — maybe origin/ho-prod doesn't exist yet
                 pass
 
         # Get current version from .hop/config

{half_orm_dev-1.0.0a14 → half_orm_dev-1.0.0a16}/half_orm_dev/modules.py

@@ -48,11 +48,12 @@ HO_DATACLASSES = []
 HO_DATACLASSES_IMPORTS = set()
 HO_TYPEDICTS: list = []
 HO_TYPEDICTS_IMPORTS: set = set()
+HO_BASECLASSES: list = []
+HO_BASECLASSES_DICT_NAMES: set = set()
 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')
@@ -335,18 +336,6 @@ 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")
@@ -563,7 +552,9 @@ def __update_this_module(
         rel, package_name)
 
     t_qrn = list(rel._t_fqrn)[1:]
-    dict_class_name = f'{__get_full_class_name(*t_qrn)}Dict'
+    full_name = __get_full_class_name(*t_qrn)
+    dict_class_name = f'{full_name}Dict'
+    bc_name = f'BC_{full_name}'
 
     # Generate Python module
     with open(module_path, 'w', encoding='utf-8') as file_:
@@ -580,6 +571,7 @@ def __update_this_module(
                 class_name=class_name,
                 dc_name=rel._ho_dataclass_name(),
                 dict_class_name=dict_class_name,
+                bc_name=bc_name,
                 fqtn=fqtn,
                 kwargs=kwargs,
                 arg_names=arg_names,
@@ -605,19 +597,9 @@ def __update_this_module(
 
     HO_DATACLASSES.append(__gen_dataclass(rel, existing_fkeys))
     HO_TYPEDICTS.extend(__gen_typedict(rel, existing_fkeys))
+    HO_BASECLASSES.append(__gen_baseclass(rel, existing_fkeys))
 
-    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):
-    with open(os.path.join(package_dir, "ho_dataclasses.py"), "w", encoding='utf-8') as file_:
-        for relation in repo.database.model._relations():
-            t_qrn = relation[1][1:]
-            if t_qrn[0].find('half_orm') == 0:
-                continue
-            file_.write(f'class DC_{__get_full_class_name(*t_qrn)}: ...\n')
+    return module_path
 
 
 _TYPING_NAMES = frozenset(('Any', 'Dict', 'Iterator', 'List', 'Optional', 'Tuple', 'Union'))
@@ -675,20 +657,80 @@ def __gen_dc_relation() -> tuple:
     return class_str, needed_typing
 
 
-def __gen_dataclasses(package_dir, package_name):
+def __gen_baseclass(relation, fkeys) -> str:
+    """Generate a BC_* base class string with TypedDict-typed method overrides."""
+    rel = relation()
+    t_qrn = list(rel._t_fqrn)[1:]
+    full_name = __get_full_class_name(*t_qrn)
+    fqtn = '.'.join(t_qrn)
+    bc_name = f'BC_{full_name}'
+    dc_name = rel._ho_dataclass_name()
+    d = f'{full_name}Dict'
+    HO_BASECLASSES_DICT_NAMES.add(d)
+    lines = [
+        f"class {bc_name}(",
+        f"    MODEL.get_relation_class('{fqtn}', fields_aliases=None),",
+        f"    {dc_name}",
+        f"):",
+        f"    def __iter__(self) -> Iterator[{d}]:",
+        f"        return super().__iter__()",
+        f"",
+        f"    def ho_select(self, *args, distinct: bool = False, order_by: str = None, limit: int = None, offset: int = None, json_agg=None) -> Iterator[{d}]:",
+        f"        return super().ho_select(*args, distinct=distinct, order_by=order_by, limit=limit, offset=offset, json_agg=json_agg)",
+        f"",
+        f"    def ho_get(self, *args) -> {d}:",
+        f"        return super().ho_get(*args)",
+        f"",
+        f"    def ho_insert(self, *args, upsert: Optional[bool] = False) -> {d}:",
+        f"        return super().ho_insert(*args, upsert=upsert)",
+        f"",
+        f"    async def ho_aselect(self, *args, distinct: bool = False, order_by: str = None, limit: int = None, offset: int = None) -> List[{d}]:",
+        f"        return await super().ho_aselect(*args, distinct=distinct, order_by=order_by, limit=limit, offset=offset)",
+        f"",
+        f"    async def ho_aget(self, *args) -> {d}:",
+        f"        return await super().ho_aget(*args)",
+        f"",
+        f"    async def ho_ainsert(self, *args, upsert: bool = False) -> {d}:",
+        f"        return await super().ho_ainsert(*args, upsert=upsert)",
+    ]
+    return '\n'.join(lines)
+
+
+def __reset_baseclasses(repo, package_dir):
+    with open(os.path.join(package_dir, "ho_baseclasses.py"), "w", encoding='utf-8') as file_:
+        for relation in repo.database.model._relations():
+            t_qrn = relation[1][1:]
+            if t_qrn[0].find('half_orm') == 0:
+                continue
+            full_name = __get_full_class_name(*t_qrn)
+            file_.write(f'class DC_{full_name}: ...\n')
+            file_.write(f'class BC_{full_name}: ...\n')
+
+
+def __gen_baseclasses(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"# DO NOT EDIT — auto-generated by half-orm-dev\n\n")
+    with open(os.path.join(package_dir, "ho_baseclasses.py"), "w", encoding='utf-8') as file_:
+        file_.write("# DO NOT EDIT — auto-generated by half-orm-dev\n\n")
+        file_.write("from __future__ import annotations\n")
+        typing_names = sorted(dc_typing | {'Iterator', 'List', 'Optional', 'TYPE_CHECKING'})
+        file_.write(f"from typing import {', '.join(typing_names)}\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(f"from {package_name} import MODEL\n")
+        if HO_BASECLASSES_DICT_NAMES:
+            file_.write("if TYPE_CHECKING:\n")
+            file_.write(f"    from {package_name}.ho_typeddicts import (\n")
+            for name in sorted(HO_BASECLASSES_DICT_NAMES):
+                file_.write(f"        {name},\n")
+            file_.write("    )\n")
         file_.write("\n\n")
         file_.write(dc_relation_str)
         for dc in HO_DATACLASSES:
             file_.write(f"\n\n{dc}\n")
+        for bc in HO_BASECLASSES:
+            file_.write(f"\n\n{bc}\n")
 
 
 def generate(repo):
@@ -698,6 +740,8 @@ def generate(repo):
     HO_DATACLASSES_IMPORTS.clear()
     HO_TYPEDICTS.clear()
     HO_TYPEDICTS_IMPORTS.clear()
+    HO_BASECLASSES.clear()
+    HO_BASECLASSES_DICT_NAMES.clear()
     NO_APAPTER.clear()
 
     package_name = repo.name
@@ -721,7 +765,11 @@ def generate(repo):
     if not package_dir.exists():
         package_dir.mkdir(parents=True)
 
-    __reset_dataclasses(repo, str(package_dir))
+    __reset_baseclasses(repo, str(package_dir))
+    # Remove legacy ho_dataclasses.py if present (merged into ho_baseclasses.py)
+    legacy = Path(package_dir) / "ho_dataclasses.py"
+    if legacy.exists():
+        legacy.unlink()
 
     # Generate package __init__.py
     with open(package_dir / INIT_PY, 'w', encoding='utf-8') as file_:
@@ -742,12 +790,13 @@ def generate(repo):
 
     # Generate modules for each relation
     for relation in repo.database.model._relations():
-        paths = __update_this_module(repo, relation, str(package_dir), package_name)
-        if paths:
-            files_list.extend(paths)
+        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)
 
-    __gen_dataclasses(str(package_dir), package_name)
     __gen_typedicts(str(package_dir), package_name)
+    __gen_baseclasses(str(package_dir), package_name)
 
     if len(NO_APAPTER):
         print("MISSING ADAPTER FOR SQL TYPE")

{half_orm_dev-1.0.0a14 → half_orm_dev-1.0.0a16}/half_orm_dev/release_manager.py

@@ -1430,6 +1430,31 @@ class ReleaseManager:
                 f"Cannot read current production version from database: {e}"
             )
 
+        # Migration: production servers that still track ho-prod instead of
+        # ho-current. Create ho-current from the current version's immutable tag
+        # and switch to it — local-only, no push to origin.
+        if (
+            self._repo.production
+            and self._repo.hgit.branch == 'ho-prod'
+            and not self._repo.hgit.branch_exists('ho-current')
+        ):
+            current_tag = f'v{current_version}'
+            tag_exists = any(
+                t.name == current_tag
+                for t in self._repo.hgit._HGit__git_repo.tags
+            )
+            if not tag_exists:
+                raise ReleaseManagerError(
+                    f"Cannot migrate to ho-current: tag {current_tag} not found locally.\n"
+                    f"Run 'hop update' again after ensuring tags are fetched."
+                )
+            self._repo.hgit.create_branch_from_tag('ho-current', current_tag)
+            self._repo.hgit._HGit__git_repo.heads['ho-current'].checkout()
+            click.echo(
+                f"  ℹ Migrated to ho-current (created from {current_tag}, local only).\n"
+                f"    Production servers should now use ho-current instead of ho-prod."
+            )
+
         # 3. Build list of available releases with details
         available_releases = []
 
@@ -1855,25 +1880,31 @@ class ReleaseManager:
                 'final_version': upgrade_path[-1] if upgrade_path else current_version
             }
 
-        # === 5. Acquire lock, pull ho-prod, apply releases ===
-        # The lock ensures the pull does not fetch a partial state left by a
-        # push in progress on ho-prod (e.g. patch merge or release promote
-        # pushing files in several steps).
+        # === 5. Get release files and apply releases ===
+        # ho-prod:     acquire lock + pull (rolling branch, needs lock against partial pushes)
+        # ho-current:  fetch + reset --hard vX.Y.Z per version (immutable tags, no lock needed)
         lock_tag = None
         patches_applied = {}
+        on_ho_current = self._repo.hgit.branch == "ho-current"
         try:
-            lock_tag = self._repo.hgit.acquire_branch_lock('ho-prod')
-
-            # Pull ho-prod to get release files
-            # update_production only fetches tags, we need the actual release files
-            try:
-                self._repo.hgit.pull('origin', 'ho-prod')
-            except Exception as e:
-                raise ReleaseManagerError(f"Failed to pull ho-prod branch: {e}")
+            if on_ho_current:
+                try:
+                    self._repo.hgit.fetch_tags()
+                    self._repo.hgit._HGit__git_repo.remotes.origin.fetch()
+                except Exception as e:
+                    raise ReleaseManagerError(f"Failed to fetch from origin: {e}")
+            else:
+                lock_tag = self._repo.hgit.acquire_branch_lock('ho-prod')
+                try:
+                    self._repo.hgit.pull('origin', 'ho-prod')
+                except Exception as e:
+                    raise ReleaseManagerError(f"Failed to pull ho-prod branch: {e}")
 
             # Apply releases sequentially
             try:
                 for version in upgrade_path:
+                    if on_ho_current:
+                        self._repo.hgit._HGit__git_repo.git.reset('--hard', f'v{version}')
                     applied_patches = self._apply_release_to_production(version)
                     patches_applied[version] = applied_patches
             except Exception as e:
@@ -2033,12 +2064,21 @@ class ReleaseManager:
             # → Raises: "Repository has uncommitted changes"
         """
         # Check branch
-        if self._repo.hgit.branch != "ho-prod":
+        current_branch = self._repo.hgit.branch
+        if current_branch not in ("ho-prod", "ho-current"):
             raise ReleaseManagerError(
-                f"Must be on ho-prod branch for production upgrade. "
-                f"Current branch: {self._repo.hgit.branch}"
+                f"Must be on ho-prod or ho-current branch for production upgrade. "
+                f"Current branch: {current_branch}"
             )
 
+        # For ho-current: reject if a lock is held on ho-prod (dev operation in progress)
+        if current_branch == "ho-current":
+            if self._repo.hgit.is_branch_locked("ho-prod"):
+                raise ReleaseManagerError(
+                    "Cannot upgrade: ho-prod is currently locked by a development operation.\n"
+                    "Wait for the operation to complete and retry."
+                )
+
         # Check repo is clean
         if not self._repo.hgit.repos_is_clean():
             raise ReleaseManagerError(

{half_orm_dev-1.0.0a14 → half_orm_dev-1.0.0a16}/half_orm_dev/repo.py

@@ -541,23 +541,31 @@ class Repo:
                     create_commit=True
                 )
 
-                result['migration_run'] = True
                 result['errors'] = migration_result.get('errors', [])
 
-                # Clean up orphaned ho-staged/* branches (patch IDs in .txt = already in production)
-                if hasattr(self, 'release_manager'):
-                    try:
-                        deleted = self.release_manager.cleanup_orphaned_staged_branches()
-                        result['orphaned_staged_deleted'] = deleted
-                    except Exception:
-                        result['orphaned_staged_deleted'] = []
+                if migration_result.get('already_synced'):
+                    # Migration was already done by another developer; branches are now synced.
+                    result['migration_run'] = False
+                    result['already_synced'] = True
+                    if not silent:
+                        print(f"✓ Branches synced to migration {current_version} (applied by another developer)")
+                else:
+                    result['migration_run'] = True
 
-                # Log success if not silent
-                if not silent:
-                    if migration_result.get('migrations_applied'):
-                        print(f"✓ Applied {len(migration_result['migrations_applied'])} migration(s)")
-                    else:
-                        print(f"✓ Updated repository version to {current_version}")
+                    # Clean up orphaned ho-staged/* branches (patch IDs in .txt = already in production)
+                    if hasattr(self, 'release_manager'):
+                        try:
+                            deleted = self.release_manager.cleanup_orphaned_staged_branches()
+                            result['orphaned_staged_deleted'] = deleted
+                        except Exception:
+                            result['orphaned_staged_deleted'] = []
+
+                    # Log success if not silent
+                    if not silent:
+                        if migration_result.get('migrations_applied'):
+                            print(f"✓ Applied {len(migration_result['migrations_applied'])} migration(s)")
+                        else:
+                            print(f"✓ Updated repository version to {current_version}")
 
             finally:
                 # Always try to return to original branch if we switched
@@ -1600,6 +1608,19 @@ class Repo:
 
         result['branch_sync'] = sync_result
 
+        # 0c. Reload config and validate version after pull/sync.
+        # Another developer may have run the migration and pushed a new hop_version.
+        # The pull + sync above may have updated .hop/config on the current branch;
+        # we must detect that before any further operation.
+        if self.hgit:
+            try:
+                self.__config = Config(self.__base_dir)
+                self._validate_version()
+            except OutdatedHalfORMDevError:
+                raise
+            except Exception:
+                pass  # offline or version parsing error — don't block
+
         # 1. Check and update Git hooks
         if not dry_run:
             result['hooks'] = self.install_git_hooks()

{half_orm_dev-1.0.0a14 → half_orm_dev-1.0.0a16}/half_orm_dev/templates/module_template_1

@@ -7,6 +7,5 @@ WARNING!
 {warning}
 """
 from half_orm.model import register
-from {package_name} import MODEL, ho_dataclasses
-fields_aliases=None
+from {package_name} import MODEL, ho_baseclasses
 

half_orm_dev-1.0.0a16/half_orm_dev/templates/module_template_2

@@ -0,0 +1,7 @@
+
+@register
+class {class_name}(ho_baseclasses.{bc_name}):
+    """
+{documentation}
+    """
+

{half_orm_dev-1.0.0a14 → half_orm_dev-1.0.0a16}/half_orm_dev/templates/module_template_3

@@ -1,3 +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)
+        super().__init__({arg_names}, **kwargs)

half_orm_dev-1.0.0a16/half_orm_dev/version.txt

@@ -0,0 +1 @@
+1.0.0-a16

{half_orm_dev-1.0.0a14 → half_orm_dev-1.0.0a16/half_orm_dev.egg-info}/PKG-INFO

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

@@ -64,7 +64,6 @@ 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.0a14/half_orm_dev/templates/module_stub_template

@@ -1,8 +0,0 @@
-# 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.0a14/half_orm_dev/templates/module_template_2

@@ -1,7 +0,0 @@
-
-@register
-class {class_name}(MODEL.get_relation_class('{fqtn}', fields_aliases=fields_aliases), ho_dataclasses.{dc_name}):
-    """
-{documentation}
-    """
-

half_orm_dev-1.0.0a14/half_orm_dev/version.txt

@@ -1 +0,0 @@
-1.0.0-a14