half-orm-dev 1.0.0a2__tar.gz → 1.0.0a5__tar.gz

{half_orm_dev-1.0.0a2/half_orm_dev.egg-info → half_orm_dev-1.0.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a2
+Version: 1.0.0a5
 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.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/cli/commands/__init__.py

@@ -15,6 +15,7 @@ from .upgrade import upgrade
 from .check import check
 from .set_git_origin import set_git_origin
 from .migrate import migrate
+from .revert_migration import revert_migration
 from .bootstrap import bootstrap
 from .todo import apply_release
 from .todo import rollback
@@ -35,6 +36,7 @@ ALL_COMMANDS = {
     'check': check,            # Project health check and updates
     'set-git-origin': set_git_origin,  # Update git remote origin URL
     'migrate': migrate,        # Repository migration after upgrade
+    'revert-migration': revert_migration,  # Revert last migration
     'bootstrap': bootstrap,    # Execute data initialization scripts
     # 🚧 (stubs)
     'apply_release': apply_release,

half_orm_dev-1.0.0a5/half_orm_dev/cli/commands/revert_migration.py

@@ -0,0 +1,49 @@
+"""
+revert-migration command - Revert the last migration.
+
+Uses the annotated git tag ho-migration/<version> created during migration
+to identify the exact commits to revert on each branch.
+
+Not available after a production promotion (the tag is deleted at that point).
+"""
+
+import click
+from half_orm_dev.repo import Repo, RepoError
+from half_orm_dev.migration_manager import MigrationManagerError
+from half_orm import utils
+
+
+@click.command('revert-migration')
+def revert_migration() -> None:
+    """
+    Revert the last migration applied by 'half_orm dev migrate'.
+
+    Uses the annotated tag ho-migration/<version> to locate the exact
+    commits and runs 'git revert --no-edit' on each affected branch.
+
+    \b
+    Constraints:
+      • Must be on ho-prod branch
+      • Not possible after a production promotion
+
+    \b
+    Multiple migrations:
+      Call repeatedly to roll back a chain of migrations (LIFO order).
+      Each call reverts the migration with the highest version number.
+    """
+    try:
+        repo = Repo()
+
+        if not repo.checked:
+            click.echo(utils.Color.red("❌ Not in a hop repository"), err=True)
+            raise click.Abort()
+
+        repo.revert_migration()
+        click.echo(f"✓ {utils.Color.green('Migration reverted successfully.')}")
+
+    except (RepoError, MigrationManagerError) as e:
+        click.echo(utils.Color.red(f"❌ {e}"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(utils.Color.red(f"❌ Unexpected error: {e}"), err=True)
+        raise click.Abort()

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/cli/main.py

@@ -62,7 +62,8 @@ class Hop:
             return ['update', 'upgrade', 'bootstrap']
         else:
             # DEVELOPMENT ENVIRONMENT - Patch development
-            return ['patch', 'release', 'check', 'bootstrap', 'set-git-origin']
+            return ['patch', 'release', 'check', 'bootstrap', 'set-git-origin',
+                    'revert-migration']
 
     @property
     def repo_checked(self):

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/hgit.py

@@ -411,6 +411,19 @@ class HGit:
         origin = self.__git_repo.remote('origin')
         origin.push(tag_name)
 
+    def delete_remote_tag(self, tag_name: str) -> None:
+        """
+        Delete tag from remote.
+
+        Args:
+            tag_name: Tag name to delete (e.g., "ho-migration/1.0.0")
+
+        Examples:
+            hgit.delete_remote_tag("ho-migration/1.0.0")
+        """
+        origin = self.__git_repo.remote('origin')
+        origin.push(refspec=f':refs/tags/{tag_name}')
+
     def fetch_from_origin(self) -> None:
         """
         Fetch all references from origin remote with pruning.

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/migration_manager.py

@@ -31,6 +31,11 @@ from typing import List, Dict, Optional, Tuple
 from half_orm import utils
 from half_orm_dev.decorators import with_dynamic_branch_lock
 
+try:
+    from half_orm.migrations import get_breaking_changes_dir
+except (ImportError, AttributeError):
+    get_breaking_changes_dir = None  # type: ignore[assignment]
+
 
 class MigrationManagerError(Exception):
     """Base exception for MigrationManager operations."""
@@ -195,22 +200,38 @@ class MigrationManager:
                         f"Migration {migration_file.name} missing migrate() function"
                     )
 
-                # Execute migration and collect sync_files if returned
+                # Execute migration.
+                # The repo is guaranteed clean before migration starts, so the
+                # git index is empty here.  Everything staged by this script is
+                # exclusively a migration-induced change.
                 migration_result = module.migrate(self._repo)
 
                 result['applied_files'].append(migration_file.name)
 
-                # Collect sync_files from migration result
-                if isinstance(migration_result, dict):
-                    sync_files = migration_result.get('sync_files', [])
-                    if sync_files:
-                        result['sync_files'].extend(sync_files)
+                # Auto-detect files staged by the script (via hgit.add()).
+                # Since the index was empty before migration, git diff --cached
+                # returns exactly the files this script modified.
+                git_repo = self._repo.hgit._HGit__git_repo
+                auto_staged = set(
+                    git_repo.git.diff('--cached', '--name-only').splitlines()
+                )
+
+                # Merge with sync_files explicitly declared by the script.
+                declared = (
+                    list(migration_result.get('sync_files', []))
+                    if isinstance(migration_result, dict) else []
+                )
+                all_sync = list(dict.fromkeys(declared + list(auto_staged)))
+                if all_sync:
+                    result['sync_files'].extend(all_sync)
 
             except Exception as e:
                 error_msg = f"Error in {migration_file.name}: {e}"
                 result['errors'].append(error_msg)
                 raise MigrationManagerError(error_msg) from e
 
+        # Deduplicate across all scripts (git diff --cached is cumulative)
+        result['sync_files'] = list(dict.fromkeys(result['sync_files']))
         return result
 
     @with_dynamic_branch_lock(lambda self, *args, **kwargs: 'ho-prod')
@@ -344,6 +365,11 @@ class MigrationManager:
                 result['commit_pushed'] = True
                 result['sync_result'] = sync_result
 
+                # Create annotated tag encoding all commit SHAs for potential revert
+                self._create_migration_tag(
+                    current_version, target_version, sync_result
+                )
+
             except Exception as e:
                 # Don't fail migration if commit fails
                 result['errors'].append(f"Failed to create commit: {e}")
@@ -355,6 +381,67 @@ class MigrationManager:
 
         return result
 
+    @with_dynamic_branch_lock(lambda self, *args, **kwargs: 'ho-prod')
+    def revert_migration(self) -> None:
+        """
+        Revert the most recently tagged migration.
+
+        Acquires a lock on ho-prod (via decorator), finds the ho-migration/*
+        tag with the highest version, and runs `git revert --no-edit` on each
+        affected branch (active branches first, then ho-prod).  The tag is
+        deleted (local + remote) after a successful revert.
+
+        Raises:
+            MigrationManagerError: if no migration tag exists (never migrated,
+                or already locked by a production promotion).
+        """
+        git_repo = self._repo.hgit._HGit__git_repo
+
+        migration_tags = sorted(
+            [t for t in git_repo.tags if t.name.startswith('ho-migration/')],
+            key=lambda t: version.parse(t.name[len('ho-migration/'):]),
+            reverse=True,
+        )
+        if not migration_tags:
+            raise MigrationManagerError(
+                "No migration tag found — revert is not possible "
+                "(migration was never run, or already locked by a "
+                "production promotion)."
+            )
+        tag = migration_tags[0]
+
+        # Parse annotation: "Migration from X to Y\nho-prod:<sha>\nbranch:<sha>…"
+        shas: Dict = {}
+        for line in tag.tag.message.splitlines()[1:]:
+            if ':' in line:
+                branch, sha = line.split(':', 1)
+                shas[branch.strip()] = sha.strip()
+
+        if 'ho-prod' not in shas:
+            raise MigrationManagerError(
+                f"Migration tag {tag.name} is malformed (missing ho-prod SHA)."
+            )
+
+        # Revert sync commits on active branches first
+        for branch, sha in shas.items():
+            if branch == 'ho-prod':
+                continue
+            git_repo.git.checkout(branch)
+            git_repo.git.revert(sha, '--no-edit')
+            self._repo.hgit.push_branch(branch)
+
+        # Revert migration commit on ho-prod last
+        git_repo.git.checkout('ho-prod')
+        git_repo.git.revert(shas['ho-prod'], '--no-edit')
+        self._repo.hgit.push_branch('ho-prod')
+
+        # Remove tag (local + remote)
+        self._repo.hgit.delete_local_tag(tag.name)
+        try:
+            self._repo.hgit.delete_remote_tag(tag.name)
+        except Exception:
+            pass  # remote tag may already be gone
+
     def _create_migration_commit_message(
         self,
         from_version: str,
@@ -389,6 +476,42 @@ class MigrationManager:
 
         return '\n'.join(lines)
 
+    def _create_migration_tag(
+        self, from_version: str, to_version: str, sync_result: Dict
+    ) -> None:
+        """
+        Create annotated tag ho-migration/{to_version} encoding commit SHAs.
+
+        The annotation stores the ho-prod commit SHA and the SHA of each sync
+        commit on active branches, enabling revert_migration() to undo the
+        migration precisely.
+
+        If the tag already exists (e.g. a previous failed migration left it),
+        it is deleted first.
+        """
+        tag_name = f"ho-migration/{to_version}"
+
+        # Remove stale tag if present
+        if self._repo.hgit.tag_exists(tag_name):
+            self._repo.hgit.delete_local_tag(tag_name)
+            try:
+                self._repo.hgit.delete_remote_tag(tag_name)
+            except Exception:
+                pass  # remote tag may not exist
+
+        ho_prod_sha = self._repo.hgit._HGit__git_repo.head.commit.hexsha
+        branch_commits = (
+            sync_result.get('sync_result', {}).get('branch_commits', {})
+        )
+
+        lines = [f"Migration from {from_version} to {to_version}"]
+        lines.append(f"ho-prod:{ho_prod_sha}")
+        for branch, sha in branch_commits.items():
+            lines.append(f"{branch}:{sha}")
+
+        self._repo.hgit.create_tag(tag_name, message='\n'.join(lines))
+        self._repo.hgit.push_tag(tag_name)
+
     def _update_pyproject_dependency_version(self, target_version: str) -> None:
         """
         Update half_orm_dev version in pyproject.toml.
@@ -506,8 +629,14 @@ class MigrationManager:
         except Exception:
             return results
 
-        for component in ('hop', 'half_orm'):
-            bc_dir = self._migrations_root / component
+        component_dirs = {'hop': self._migrations_root / 'hop'}
+        if get_breaking_changes_dir is not None:
+            try:
+                component_dirs['half_orm'] = get_breaking_changes_dir()
+            except Exception:
+                pass  # older half-orm — ignore silently
+
+        for component, bc_dir in component_dirs.items():
             if not bc_dir.is_dir():
                 continue
             for bc_file in sorted(bc_dir.glob('BREAKING_CHANGES-*.md')):

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/modules.py

@@ -48,6 +48,8 @@ HO_DATACLASSES = [
 from half_orm.relation import DC_Relation
 from half_orm.field import Field''']
 HO_DATACLASSES_IMPORTS = set()
+HO_TYPEDICTS: list = []
+HO_TYPEDICTS_IMPORTS: 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')
@@ -194,7 +196,12 @@ def __gen_dataclass(relation, fkeys):
     # Invert user-defined aliases: constraint_name → alias
     aliases = {constraint: alias for alias, constraint in fkeys.items() if alias != ''}
     for constraint_name, fkey in rel._ho_fkeys.items():
-        attr_name = aliases.get(constraint_name, constraint_name)
+        if constraint_name in aliases:
+            attr_name = aliases[constraint_name]
+        elif constraint_name.startswith('_reverse_fkey_'):
+            attr_name = 'rfk_' + constraint_name[len('_reverse_fkey_'):]
+        else:
+            attr_name = 'fk_' + constraint_name
         try:
             fk_fqrn = list(fkey()._t_fqrn)
             fdc_name = f'DC_{__get_full_class_name(fk_fqrn[1], fk_fqrn[2])}'
@@ -204,6 +211,144 @@ def __gen_dataclass(relation, fkeys):
     return '\n'.join([f'@dataclasses.dataclass\nclass {dc_name}(DC_Relation):'] + fields + post_init)
 
 
+def __get_type_annotation(field) -> tuple:
+    """Return (type_str, extra_imports) for a TypedDict field annotation.
+
+    Array types (SQL prefix '_') map to List[T].
+    """
+    sql_type = field._metadata['fieldtype']
+    is_array = sql_type.startswith('_')
+    base_sql_type = sql_type[1:] if is_array else sql_type
+
+    py_type = SQL_ADAPTER.get(base_sql_type)
+    imports: set = set()
+
+    if py_type is None or py_type is Any:
+        type_str = 'Any'
+    elif py_type.__module__ != 'builtins':
+        imports.add(py_type.__module__)
+        name = py_type.__name__ if hasattr(py_type, '__name__') else 'Any'
+        type_str = f'{py_type.__module__}.{name}'
+    else:
+        type_str = py_type.__name__
+
+    if is_array:
+        return f'List[{type_str}]', imports
+    return type_str, imports
+
+
+def __json_scalar_type(sql_type_name: str) -> str:
+    """Map a JSON schema scalar type name to a Python type string.
+
+    Updates HO_TYPEDICTS_IMPORTS as needed.
+    """
+    py_type = SQL_ADAPTER.get(sql_type_name.lower())
+    if py_type is None or py_type is Any:
+        return 'Any'
+    if py_type.__module__ != 'builtins':
+        HO_TYPEDICTS_IMPORTS.add(py_type.__module__)
+        name = py_type.__name__ if hasattr(py_type, '__name__') else 'Any'
+        return f'{py_type.__module__}.{name}'
+    return py_type.__name__
+
+
+def __gen_json_typedicts(name_prefix: str, schema) -> tuple:
+    """Recursively generate TypedDict classes from a Field.json_schema structure.
+
+    Returns (class_strings, top_class_name).
+    class_strings are in dependency order (nested classes before the class using them).
+
+    YAML value conventions:
+        scalar string  → SQL type name  (e.g. 'text', 'integer', 'uuid')
+        [scalar]       → List[T]
+        [dict]         → List[NestedDict]
+        dict           → NestedDict
+    """
+    if not isinstance(schema, dict):
+        return [], 'Any'
+
+    classes = []
+    fields = []
+
+    for key, val in schema.items():
+        if isinstance(val, str):
+            type_str = __json_scalar_type(val)
+            fields.append(f"    {key}: Optional[{type_str}]")
+        elif isinstance(val, list) and len(val) == 1:
+            item = val[0]
+            if isinstance(item, str):
+                inner = __json_scalar_type(item)
+                fields.append(f"    {key}: Optional[List[{inner}]]")
+            elif isinstance(item, dict):
+                child_prefix = name_prefix + ''.join(w.capitalize() for w in key.split('_'))
+                nested, child_name = __gen_json_typedicts(child_prefix, item)
+                classes.extend(nested)
+                fields.append(f"    {key}: Optional[List['{child_name}']]")
+            else:
+                fields.append(f"    {key}: Optional[Any]")
+        elif isinstance(val, dict):
+            child_prefix = name_prefix + ''.join(w.capitalize() for w in key.split('_'))
+            nested, child_name = __gen_json_typedicts(child_prefix, val)
+            classes.extend(nested)
+            fields.append(f"    {key}: Optional['{child_name}']")
+        else:
+            fields.append(f"    {key}: Optional[Any]")
+
+    class_name = f'{name_prefix}Dict'
+    body = '\n'.join(fields) if fields else '    pass'
+    classes.append(f'class {class_name}(TypedDict, total=False):\n{body}')
+    return classes, class_name
+
+
+def __gen_typedict(relation, fkeys) -> list:
+    """Generate TypedDict class(es) for a relation.
+
+    Returns a list of class strings: nested JSON TypedDicts first, then the main class.
+    Only database columns are included — FK accessor attributes are not part of a row dict.
+    json/jsonb fields with a json_schema generate nested TypedDict classes.
+    """
+    rel = relation()
+    t_qrn = list(rel._t_fqrn)[1:]
+    dict_class_name = f'{__get_full_class_name(*t_qrn)}Dict'
+
+    extra_classes = []
+    fields = []
+    for field_name, field in rel._ho_fields.items():
+        json_schema = getattr(field, 'json_schema', None)
+        if json_schema is not None and isinstance(json_schema, dict):
+            field_cc = ''.join(w.capitalize() for w in field_name.split('_'))
+            json_classes, top_name = __gen_json_typedicts(
+                f'{dict_class_name[:-4]}{field_cc}', json_schema
+            )
+            extra_classes.extend(json_classes)
+            type_str = top_name
+        else:
+            type_str, imports = __get_type_annotation(field)
+            HO_TYPEDICTS_IMPORTS.update(imports)
+        line = f"    {field_name}: Optional[{type_str}]"
+        error = utils.check_attribute_name(field_name)
+        if error:
+            line = f"# {line}  # FIX ME! {error}"
+        fields.append(line)
+
+    body = '\n'.join(fields) if fields else '    pass'
+    main_class = f'class {dict_class_name}(TypedDict, total=False):\n{body}'
+    return extra_classes + [main_class]
+
+
+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")
+        file_.write("from __future__ import annotations\n")
+        file_.write("from typing import TypedDict, Optional, List, Any\n")
+        td_imports = sorted(HO_TYPEDICTS_IMPORTS)
+        for mod in td_imports:
+            file_.write(f"import {mod}\n")
+        file_.write("\n")
+        for td in HO_TYPEDICTS:
+            file_.write(f"\n{td}\n")
+
+
 def __get_modules_list(dir, files_list, files):
     all_ = []
     for file_ in files:
@@ -357,6 +502,9 @@ def __update_this_module(
     inheritance_import, inherited_classes = __get_inheritance_info(
         rel, package_name)
 
+    t_qrn = list(rel._t_fqrn)[1:]
+    dict_class_name = f'{__get_full_class_name(*t_qrn)}Dict'
+
     # Generate Python module
     with open(module_path, 'w', encoding='utf-8') as file_:
         documentation = "\n".join([line and f"    {line}" or "" for line in str(rel).split("\n")[1:]])
@@ -370,6 +518,7 @@ def __update_this_module(
                 inherited_classes=inherited_classes,
                 class_name=class_name,
                 dc_name=rel._ho_dataclass_name(),
+                dict_class_name=dict_class_name,
                 fqtn=fqtn,
                 kwargs=kwargs,
                 arg_names=arg_names,
@@ -394,6 +543,7 @@ def __update_this_module(
                 class_name=class_name))
 
     HO_DATACLASSES.append(__gen_dataclass(rel, existing_fkeys))
+    HO_TYPEDICTS.extend(__gen_typedict(rel, existing_fkeys))
 
     return module_path
 
@@ -469,6 +619,7 @@ def generate(repo):
             # 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)
 
     if len(NO_APAPTER):
         print("MISSING ADAPTER FOR SQL TYPE")

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/release_manager.py

@@ -2497,6 +2497,12 @@ class ReleaseManager:
 
         # Save original branch for rollback
         original_branch = self._repo.hgit.branch
+        # Save schema.sql symlink target so rollback can restore it if
+        # _generate_schema_sql updates it before a failure.
+        _schema_sql = Path(self._repo.model_dir) / 'schema.sql'
+        original_schema_link = (
+            os.readlink(str(_schema_sql)) if _schema_sql.is_symlink() else None
+        )
 
         try:
             # 5. Create temporary branch from release branch (validation only)
@@ -2547,6 +2553,15 @@ class ReleaseManager:
                 staged_patches = release_file.get_patches(status="staged")
                 self._create_prod_snapshot(version, staged_patches, release_file, model_dir)
 
+                # 10b. Passe 2: validate all bootstrap scripts against final schema.
+                # schema.sql now points to schema-X.Y.Z.sql (just generated).
+                # restore_database_from_schema() resets the DB and runs ALL pending
+                # bootstrap scripts in order — exactly what a fresh clone does.
+                # Any failure here aborts promotion before the commit.
+                print(f"\n🔍 Validating bootstrap scripts against schema {version}...")
+                self._repo.restore_database_from_schema()
+                print(f"✓ Bootstrap validation passed")
+
                 # 11. Commit the merge with all promote changes included
                 self._repo.hgit.add(".")
                 self._repo.hgit.commit("-m", commit_msg)
@@ -2600,6 +2615,16 @@ class ReleaseManager:
                 result['deleted_branches'] = deleted_branches
                 result['migrated_to'] = next_patch_version if migrate_candidates else None
                 result['migrated_patches'] = candidates if migrate_candidates else []
+
+                # Lock migration revert: delete all ho-migration/* tags so that
+                # revert_migration() is no longer possible after going to production.
+                for tag in list(self._repo.hgit._HGit__git_repo.tags):
+                    if tag.name.startswith('ho-migration/'):
+                        self._repo.hgit.delete_local_tag(tag.name)
+                        try:
+                            self._repo.hgit.delete_remote_tag(tag.name)
+                        except Exception:
+                            pass  # remote tag may already be gone
             else:
                 result['branch'] = release_branch
 
@@ -2615,6 +2640,15 @@ class ReleaseManager:
                 except GitCommandError:
                     pass
 
+                # Restore tracked files deleted/modified outside of git control
+                # during the merge window (by _generate_schema_sql and
+                # _create_prod_snapshot). merge_abort resets the index but
+                # not working-tree files that were deleted directly on disk.
+                try:
+                    self._repo.hgit.checkout('HEAD', '--', '.')
+                except GitCommandError:
+                    pass
+
                 # Return to original branch
                 try:
                     self._repo.hgit.checkout(original_branch)
@@ -2631,6 +2665,17 @@ class ReleaseManager:
                 except GitCommandError:
                     pass  # Already deleted (prod validation complete) or never created
 
+                # Restore schema.sql symlink if _generate_schema_sql changed it
+                # before the failure (merge_abort does not undo symlink changes
+                # made outside of the merge commit itself).
+                if original_schema_link is not None:
+                    try:
+                        if _schema_sql.is_symlink() and os.readlink(str(_schema_sql)) != original_schema_link:
+                            _schema_sql.unlink()
+                            _schema_sql.symlink_to(original_schema_link)
+                    except OSError:
+                        pass
+
             except (GitCommandError, TypeError) as cleanup_error:
                 print(f"  Warning: Cleanup failed: {cleanup_error}", file=sys.stderr)
 

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/repo.py

@@ -621,7 +621,8 @@ class Repo:
         result = {
             'synced_branches': [],
             'skipped_branches': [],
-            'errors': []
+            'errors': [],
+            'branch_commits': {},  # branch → commit SHA of the sync commit created
         }
 
         if not self.hgit:
@@ -798,6 +799,11 @@ class Repo:
                 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)
 
@@ -862,12 +868,14 @@ class Repo:
 
             # 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\""
+                    f"  git add . && git commit -m \"your message\"\n"
+                    f"Dirty files:\n{status}"
                 )
 
             # Switch to ho-prod temporarily
@@ -988,6 +996,11 @@ class Repo:
 
         return result
 
+    def revert_migration(self) -> None:
+        """Revert the most recently tagged migration. Delegates to MigrationManager."""
+        mgr = MigrationManager(self)
+        mgr.revert_migration()
+
     @property
     def base_dir(self):
         "Returns the base dir of the repository"
@@ -2483,11 +2496,14 @@ Each script is executed only once unless `--force` is used.
             # up_to_version prevents bootstraps from future versions from running.
             from half_orm_dev.bootstrap_manager import BootstrapManager
             bootstrap_mgr = BootstrapManager(self)
-            bootstrap_mgr.run_bootstrap(
+            result = bootstrap_mgr.run_bootstrap(
                 exclude_patch_id=exclude_bootstrap_patch_id,
                 exclude_version=exclude_bootstrap_version,
                 up_to_version=exclude_bootstrap_version
             )
+            if result['errors']:
+                error_msg = "\n".join([f"  • {f}: {e}" for f, e in result['errors']])
+                raise RepoError(f"Bootstrap execution failed:\n{error_msg}")
 
         except RepoError:
             # Re-raise RepoError as-is

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/templates/module_template_1

@@ -6,7 +6,10 @@ 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.0a2 → half_orm_dev-1.0.0a5}/half_orm_dev/templates/module_template_3

@@ -1,3 +1,6 @@
     #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)
+
+    def __iter__(self) -> 'Iterator[{dict_class_name}]':
+        return super().__iter__()

half_orm_dev-1.0.0a5/half_orm_dev/version.txt

@@ -0,0 +1 @@
+1.0.0-a5

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5/half_orm_dev.egg-info}/PKG-INFO

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

@@ -22,6 +22,7 @@ half_orm_dev/version.txt
 half_orm_dev.egg-info/PKG-INFO
 half_orm_dev.egg-info/SOURCES.txt
 half_orm_dev.egg-info/dependency_links.txt
+half_orm_dev.egg-info/entry_points.txt
 half_orm_dev.egg-info/requires.txt
 half_orm_dev.egg-info/top_level.txt
 half_orm_dev/cli/__init__.py
@@ -36,6 +37,7 @@ half_orm_dev/cli/commands/migrate.py
 half_orm_dev/cli/commands/patch.py
 half_orm_dev/cli/commands/release.py
 half_orm_dev/cli/commands/restore.py
+half_orm_dev/cli/commands/revert_migration.py
 half_orm_dev/cli/commands/set_git_origin.py
 half_orm_dev/cli/commands/sync.py
 half_orm_dev/cli/commands/todo.py
@@ -50,7 +52,6 @@ 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/half_orm/BREAKING_CHANGES-1.0.0.md
 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.0a5/half_orm_dev.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+half_orm = half_orm.cli:main

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a5}/pyproject.toml

@@ -33,6 +33,9 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 
+[project.scripts]
+half_orm = "half_orm.cli:main"
+
 [project.urls]
 Homepage = "https://github.com/half-orm/half-orm-dev"
 
@@ -49,8 +52,7 @@ half_orm_dev = [
     "patches/**/*",
     "scripts/*",
     "version.txt",
-    "migrations/hop/*.md",
-    "migrations/half_orm/*.md"
+    "migrations/hop/*.md"
 ]
 
 [tool.setuptools.dynamic]

half_orm_dev-1.0.0a2/half_orm_dev/migrations/half_orm/BREAKING_CHANGES-1.0.0.md

@@ -1,50 +0,0 @@
-# half-orm 1.0.0 — Breaking Changes
-
-## `ho_get()` returns a `dict` and raises on 0 or >1 rows
-
-`ho_get()` now returns a plain `dict` directly (no longer a Relation
-object).  It raises:
-- `NotFoundError` if no row matches
-- `MultipleRowsError` if more than one row matches
-
-**Before:**
-```python
-obj = MyTable(id=1).ho_get()  # returned a Relation
-```
-
-**After:**
-```python
-row = MyTable(id=1).ho_get()  # returns dict, or raises
-```
-
-The async counterpart `ho_aget()` has been added with the same semantics.
-
-## Deprecated query-builder setters removed
-
-`ho_limit`, `ho_offset`, `ho_order_by`, `ho_distinct` no longer exist as
-property setters.  Pass them as keyword arguments to `ho_select()`.
-
-**Before:**
-```python
-rel.ho_limit = 10
-rel.ho_order_by = "name"
-for row in rel.ho_select():
-    ...
-```
-
-**After:**
-```python
-for row in rel.ho_select(limit=10, order_by="name"):
-    ...
-```
-
-## `FKEYS_PROPERTIES` / `FKEYS` class attributes removed
-
-Use `Fkeys` only.  Any subclass that still defines `FKEYS_PROPERTIES` or
-`FKEYS` will raise an error at class definition time.
-
-## `ho_cast()` raises `CastError` for invalid inheritance targets
-
-`ho_cast(TargetClass)` now raises `half_orm.relation.CastError` if
-`TargetClass` is not in the PostgreSQL inheritance hierarchy of the
-source table.

half_orm_dev-1.0.0a2/half_orm_dev/version.txt

@@ -1 +0,0 @@
-1.0.0-a2