half-orm-dev 1.0.0a12__tar.gz → 1.0.0a15__tar.gz

{half_orm_dev-1.0.0a12/half_orm_dev.egg-info → half_orm_dev-1.0.0a15}/PKG-INFO

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

@@ -2002,6 +2002,25 @@ class PatchManager:
             result = patch_mgr.merge_patch()
             # Merges into ho-release/0.17.0, moves to stage
         """
+        # 0. Remove stale local ho-* branches before any state change.
+        #    A stale branch (local but no longer on remote) causes
+        #    sync_hop_to_active_branches to leave staged-but-uncommitted
+        #    .hop/ changes that block subsequent checkouts, silently
+        #    skipping branches that should receive the TOML update.
+        try:
+            stale_result = self._repo.hgit.prune_local_branches(
+                pattern="ho-*",
+                dry_run=False,
+                exclude_current=True,
+            )
+            if stale_result.get('deleted'):
+                click.echo(
+                    f"  ℹ Removed {len(stale_result['deleted'])} stale local "
+                    f"branch(es): {', '.join(stale_result['deleted'])}"
+                )
+        except Exception as e:
+            raise PatchManagerError(f"Failed to clean up stale branches: {e}")
+
         # 1. Extract patch_id from current branch
         current_branch = self._repo.hgit.branch
         if not current_branch.startswith('ho-patch/'):

{half_orm_dev-1.0.0a12 → half_orm_dev-1.0.0a15}/half_orm_dev/repo.py

@@ -643,10 +643,19 @@ class Repo:
         # Get all active branches (including ho-prod, release branches, and patch branches)
         try:
             branches_status = self.hgit.get_active_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', [])]
-
-            # ho-staged/* branches are frozen after merge — excluded from sync
+            # Only sync branches that still exist on remote — stale local
+            # branches (e.g. ho-patch/X renamed to ho-staged/X) leave
+            # staged-but-uncommitted .hop/ changes after a failed pre-commit
+            # hook, blocking checkout of subsequent branches in the loop.
+            patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])
+                              if b.get('exists_on_remote', True)]
+            release_branches = [b['name'] for b in branches_status.get('release_branches', [])
+                                if b.get('exists_on_remote', True)]
+
+            # ho-staged/* branches are frozen after merge — excluded from sync.
+            # ho-prod is included but may have a protective hook (e.g. blocking
+            # direct commits); a commit failure on it is treated as a soft skip
+            # rather than aborting the whole sync (see Phase 1 loop below).
             all_branches = ['ho-prod'] + release_branches + patch_branches
 
             # Filter release branches to avoid syncing to future versions
@@ -685,140 +694,146 @@ class Repo:
             result['errors'].append(f"Failed to get active branches: {e}")
             return result
 
-        # Sync each target branch
+        # Phase 1 — local commits only (no push yet).
+        # All commits are made locally first so that a failure on any branch
+        # can be fully rolled back via git reset --hard, leaving a clean state.
+        original_shas = {}   # branch → SHA recorded after checkout/fast-forward
+        committed_branches = []  # branches that received a new local commit
+        commit_msg = f"[HOP] Sync .hop/ from {source_branch} ({reason})"
+
+        def _rollback_phase1():
+            """Undo all local commits made during Phase 1."""
+            for rb, sha in original_shas.items():
+                try:
+                    self.hgit.checkout(rb)
+                    self.hgit._HGit__git_repo.git.reset('--hard', sha)
+                except Exception:
+                    pass
+            try:
+                self.hgit.checkout(source_branch)
+                self.__config = Config(self.base_dir)
+            except Exception:
+                pass
+
         for branch in target_branches:
             try:
-                # 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.
+                # Fast-forward if behind remote (safe — no local commits lost)
                 remote_ref = f"origin/{branch}"
                 try:
                     synced, status = self.hgit.is_branch_synced(branch)
-                    # 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
                     pass
 
-                # Reload config for this branch
+                # Record SHA after fast-forward: this is the rollback target
+                original_shas[branch] = self.hgit._HGit__git_repo.head.commit.hexsha
+
                 self.__config = Config(self.base_dir)
 
-                # Use git checkout to copy .hop/ from source branch
-                # This updates/adds files but doesn't remove deleted files
+                # Copy .hop/ from source branch
                 self.hgit._HGit__git_repo.git.checkout(source_branch, '--', '.hop/')
 
-                # Also checkout additional files if specified
                 if additional_files:
                     for file_path in additional_files:
                         try:
                             self.hgit._HGit__git_repo.git.checkout(source_branch, '--', file_path)
                         except GitCommandError:
-                            # File might not exist in source branch, skip
                             pass
 
-                # Find files that exist in target but not in source and remove them
-                # IMPORTANT: Only remove files for versions that exist in source
-                # Don't remove release files (*-patches.toml, *.txt) for other versions
+                # Remove files that exist in target but no longer in source
                 try:
-                    # Get list of files in .hop/ on current branch (target)
                     target_files_output = self.hgit._HGit__git_repo.git.ls_files('.hop/')
                     target_files = set(f for f in target_files_output.split('\n') if f.strip())
-
-                    # Get list of files in .hop/ on source branch
                     source_files_output = self.hgit._HGit__git_repo.git.ls_tree('-r', '--name-only', source_branch, '.hop/')
                     source_files = set(f for f in source_files_output.split('\n') if f.strip())
-
-                    # Get versions present in source (from .toml and .txt release files)
                     source_versions = set()
                     for file_path in source_files:
-                        # Extract version from release files
                         if file_path.startswith('.hop/releases/'):
                             filename = file_path.replace('.hop/releases/', '')
-                            # Match patterns: X.Y.Z-patches.toml, X.Y.Z.txt, X.Y.Z-rcN.txt, X.Y.Z-hotfixN.txt
                             match = re.match(r'^(\d+\.\d+\.\d+)[-.]', filename)
                             if match:
                                 source_versions.add(match.group(1))
-
-                    # Files to delete = in target but not in source
-                    files_to_delete = target_files - source_files
-
-                    # Filter: only delete files for versions present in source
-                    # This prevents deleting release files for unrelated versions
                     safe_to_delete = []
-                    for file_path in files_to_delete:
+                    for file_path in target_files - source_files:
                         if not file_path:
                             continue
-                        # Check if it's a release file
                         if file_path.startswith('.hop/releases/'):
                             filename = file_path.replace('.hop/releases/', '')
                             match = re.match(r'^(\d+\.\d+\.\d+)[-.]', filename)
                             if match:
-                                file_version = match.group(1)
-                                # Only delete if this version exists in source
-                                if file_version in source_versions:
+                                if match.group(1) in source_versions:
                                     safe_to_delete.append(file_path)
                             else:
-                                # Not a versioned file, safe to delete
                                 safe_to_delete.append(file_path)
                         else:
-                            # Not in releases/, safe to delete
                             safe_to_delete.append(file_path)
-
-                    # Remove files
                     for file_path in safe_to_delete:
                         self.hgit._HGit__git_repo.git.rm(file_path)
-                except Exception as e:
-                    # If something fails in deletion detection, log but continue
-                    # The checkout already happened, so we have the updates
+                except Exception:
                     pass
 
-                # Stage all changes
                 self.hgit.add('.hop/')
                 if additional_files:
                     for file_path in additional_files:
                         try:
                             self.hgit.add(file_path)
                         except GitCommandError:
-                            pass  # File might not exist
+                            pass
 
-                # Check if there are changes
                 status = self.hgit._HGit__git_repo.git.status('--porcelain')
                 if not status.strip():
-                    # No changes, skip
                     result['skipped_branches'].append(branch)
+                    del original_shas[branch]  # nothing to roll back for this branch
                     continue
 
-                # Commit changes
-                commit_msg = f"[HOP] Sync .hop/ from {source_branch} ({reason})"
                 self.hgit.commit('-m', commit_msg)
 
-                # Record the SHA of the sync commit for potential revert
                 result['branch_commits'][branch] = (
                     self.hgit._HGit__git_repo.head.commit.hexsha
                 )
-
-                # Push to remote
-                self.hgit.push_branch(branch)
-
-                result['synced_branches'].append(branch)
+                committed_branches.append(branch)
 
             except Exception as e:
-                result['errors'].append(f"{branch}: {str(e)}")
+                if branch == 'ho-prod':
+                    # ho-prod may have a protective hook that blocks direct
+                    # commits. Clean up staged state so the next checkout
+                    # succeeds, then skip gracefully.
+                    try:
+                        self.hgit._HGit__git_repo.git.reset('HEAD')
+                        self.hgit._HGit__git_repo.git.checkout('--', '.hop/')
+                    except Exception:
+                        pass
+                    original_shas.pop('ho-prod', None)
+                    result['errors'].append(f"ho-prod: sync skipped (commit blocked): {e}")
+                else:
+                    # Any other branch failure aborts and rolls back all local commits.
+                    _rollback_phase1()
+                    raise RepoError(
+                        f"Sync commit failed on '{branch}': {e}\n"
+                        f"All local sync commits have been rolled back.\n"
+                        f"Run 'hop check' to diagnose."
+                    ) from e
 
-        # Return to source branch
+        # Return to source branch before pushing
         try:
             self.hgit.checkout(source_branch)
-            # Reload config for source branch
             self.__config = Config(self.base_dir)
         except Exception as e:
             result['errors'].append(f"Failed to return to {source_branch}: {e}")
 
+        # Phase 2 — push all committed branches.
+        # The distributed lock ensures no conflicting pushes; errors here are
+        # unexpected but collected rather than raised.
+        for branch in committed_branches:
+            try:
+                self.hgit.push_branch(branch)
+                result['synced_branches'].append(branch)
+            except Exception as e:
+                result['errors'].append(f"{branch}: push failed: {e}")
+
         return result
 
     def sync_and_validate_ho_prod(self):

{half_orm_dev-1.0.0a12 → half_orm_dev-1.0.0a15}/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.0a15/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.0a12 → half_orm_dev-1.0.0a15}/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.0a15/half_orm_dev/version.txt

@@ -0,0 +1 @@
+1.0.0-a15

{half_orm_dev-1.0.0a12 → half_orm_dev-1.0.0a15/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a12
+Version: 1.0.0a15
 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.0a12 → half_orm_dev-1.0.0a15}/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.0a12/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.0a12/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.0a12/half_orm_dev/version.txt

@@ -1 +0,0 @@
-1.0.0-a12