half-orm-dev 1.0.0a30__tar.gz → 1.0.0a32__tar.gz

{half_orm_dev-1.0.0a30/half_orm_dev.egg-info → half_orm_dev-1.0.0a32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a30
+Version: 1.0.0a32
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later
@@ -21,8 +21,10 @@ License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: GitPython
 Requires-Dist: click
+Requires-Dist: packaging
 Requires-Dist: pydash
 Requires-Dist: pytest
+Requires-Dist: pytest-asyncio
 Requires-Dist: half_orm<1.1.0,>=1.0.0a1
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Requires-Dist: tomli_w>=1.0.0
@@ -384,29 +386,31 @@ half_orm dev upgrade [--to-release X.Y.Z]
 half_orm dev upgrade --dry-run
 ```
 
-### Data Bootstrap
+### Bootstrap - Data Initialization
 
-Mark patch files with `-- @HOP:bootstrap` (SQL) or `# @HOP:bootstrap` (Python) to declare reference data.
-The marker **must be on the first line** of the file:
+Bootstrap scripts initialize application data on empty databases. Place SQL and Python files in the `bootstrap/` directory:
 
-```sql
--- @HOP:bootstrap
-INSERT INTO roles (name) VALUES ('admin'), ('user') ON CONFLICT DO NOTHING;
 ```
-
-```python
-# @HOP:bootstrap
-# (no shebang — the file is executed directly by half-orm-dev)
-MyModel(field='value').ho_insert()
+bootstrap/
+├── 01-init-roles.sql
+├── 02-seed-config.py
+└── 03-reference-data.sql
 ```
 
-These files are automatically:
-- Copied to `bootstrap/` during `patch merge`
-- Executed during production `upgrade`
-- Tracked in database (each script runs once)
+Files are executed **alphabetically** during:
+- **Development**: Each `patch apply` (allows iteration on bootstrap scripts)
+- **Production**: Initial `clone` only (one-time initialization)
+
+For production data changes, use **patches** (not bootstrap).
 
-> **Note:** If the marker is not on the first line it is silently ignored.
-> A warning is displayed during `patch apply` to help catch this mistake.
+**Python files** can define a `run(model)` function to share the database connection:
+
+```python
+def run(model):
+    # model is the halfORM Model instance with active connection
+    MyModel = model.get_relation_class('schema.table')
+    MyModel(field='value').ho_insert()
+```
 
 **Note:** Use `half_orm dev <command> --help` for detailed help on each command.
 

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/README.md

@@ -353,29 +353,31 @@ half_orm dev upgrade [--to-release X.Y.Z]
 half_orm dev upgrade --dry-run
 ```
 
-### Data Bootstrap
+### Bootstrap - Data Initialization
 
-Mark patch files with `-- @HOP:bootstrap` (SQL) or `# @HOP:bootstrap` (Python) to declare reference data.
-The marker **must be on the first line** of the file:
+Bootstrap scripts initialize application data on empty databases. Place SQL and Python files in the `bootstrap/` directory:
 
-```sql
--- @HOP:bootstrap
-INSERT INTO roles (name) VALUES ('admin'), ('user') ON CONFLICT DO NOTHING;
 ```
-
-```python
-# @HOP:bootstrap
-# (no shebang — the file is executed directly by half-orm-dev)
-MyModel(field='value').ho_insert()
+bootstrap/
+├── 01-init-roles.sql
+├── 02-seed-config.py
+└── 03-reference-data.sql
 ```
 
-These files are automatically:
-- Copied to `bootstrap/` during `patch merge`
-- Executed during production `upgrade`
-- Tracked in database (each script runs once)
+Files are executed **alphabetically** during:
+- **Development**: Each `patch apply` (allows iteration on bootstrap scripts)
+- **Production**: Initial `clone` only (one-time initialization)
+
+For production data changes, use **patches** (not bootstrap).
 
-> **Note:** If the marker is not on the first line it is silently ignored.
-> A warning is displayed during `patch apply` to help catch this mistake.
+**Python files** can define a `run(model)` function to share the database connection:
+
+```python
+def run(model):
+    # model is the halfORM Model instance with active connection
+    MyModel = model.get_relation_class('schema.table')
+    MyModel(field='value').ho_insert()
+```
 
 **Note:** Use `half_orm dev <command> --help` for detailed help on each command.
 

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/half_orm_dev/cli/commands/__init__.py

@@ -15,7 +15,6 @@ 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 .rollback import rollback
 from .recover import recover
 from .todo import apply_release
@@ -36,7 +35,6 @@ ALL_COMMANDS = {
     '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,
 
@@ -58,7 +56,6 @@ __all__ = [
     'upgrade',
     'check',
     'migrate',
-    'bootstrap',
     'rollback',
     'recover',
     # Adapted commands

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/half_orm_dev/cli/commands/check.py

@@ -162,7 +162,7 @@ def _display_check_results(repo, result: dict, dry_run: bool, verbose: bool):
         click.echo(f"\n🔧 {utils.Color.bold('Orphaned patches')} ({len(orphaned_patches)}):")
         for patch_id in sorted(orphaned_patches):
             click.echo(f"  • {patch_id}")
-        click.echo(f"  {utils.Color.blue('(Use \"half_orm dev release attach-patch <id>\" to reattach)')}")
+        click.echo(f"""  {utils.Color.blue('(Use "half_orm dev release attach-patch <id>" to reattach)')}""")
 
     # Show standalone patch branches (not in candidates/stage)
     standalone_patches = [b for b in patch_branches

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/half_orm_dev/cli/commands/recover.py

@@ -41,6 +41,6 @@ def recover() -> None:
 
     if result['errors']:
         for error in result['errors']:
-            click.echo(utils.Color.yellow(f"Warning: {error}"), err=True)
+            click.echo(utils.Color.bold(f"Warning: {error}"), err=True)
 
     click.echo(utils.Color.green("Recovery complete."))

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/half_orm_dev/cli/main.py

@@ -60,7 +60,7 @@ class Hop:
             return ['sync-package', 'check']
 
         # DEVELOPMENT ENVIRONMENT - Patch development
-        return ['patch', 'release', 'check', 'bootstrap', 'set-git-origin',
+        return ['patch', 'release', 'check', 'set-git-origin',
                 'revert-migration', 'recover']
 
     @property

half_orm_dev-1.0.0a32/half_orm_dev/file_executor.py

@@ -0,0 +1,221 @@
+"""
+Shared utilities for executing SQL and Python files.
+
+This module provides common file execution functionality for patch application
+and bootstrap initialization.
+"""
+
+import ast
+import importlib.util
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+class FileExecutionError(Exception):
+    """Raised when file execution fails."""
+    pass
+
+
+def execute_sql_file(file_path: Path, database_model) -> None:
+    """
+    Execute SQL file against database using halfORM Model.
+
+    Args:
+        file_path: Path to SQL file
+        database_model: halfORM Model instance
+
+    Raises:
+        FileExecutionError: If SQL execution fails
+    """
+    try:
+        sql_content = file_path.read_text(encoding='utf-8')
+
+        # Skip empty files
+        if not sql_content.strip():
+            return
+
+        database_model.execute_query(sql_content)
+
+    except Exception as e:
+        raise FileExecutionError(f"SQL execution failed in {file_path.name}: {e}") from e
+
+
+def execute_sql_file_psql(file_path: Path, database, database_name: str) -> None:
+    """
+    Execute SQL file using psql command.
+
+    Uses psql directly instead of halfORM Model, useful for files that
+    may contain transaction control or other psql-specific features.
+
+    Args:
+        file_path: Path to SQL file
+        database: Database instance with execute_pg_command method
+        database_name: Name of the database to connect to
+
+    Raises:
+        FileExecutionError: If psql execution fails
+    """
+    try:
+        database.execute_pg_command('psql', '-d', database_name, '-f', str(file_path))
+    except Exception as e:
+        raise FileExecutionError(f"psql execution failed for {file_path.name}: {e}") from e
+
+
+def execute_python_file(file_path: Path, cwd: Optional[Path] = None) -> str:
+    """
+    Execute Python script as subprocess.
+
+    Args:
+        file_path: Path to Python file
+        cwd: Working directory for execution (default: file's parent directory)
+
+    Returns:
+        stdout from the script execution
+
+    Raises:
+        FileExecutionError: If Python execution fails
+    """
+    if cwd is None:
+        cwd = file_path.parent
+
+    try:
+        result = subprocess.run(
+            [sys.executable, str(file_path)],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+
+    except subprocess.CalledProcessError as e:
+        error_msg = f"Python execution failed in {file_path.name}"
+        if e.stderr:
+            error_msg += f": {e.stderr.strip()}"
+        raise FileExecutionError(error_msg) from e
+    except Exception as e:
+        raise FileExecutionError(f"Failed to execute Python file {file_path.name}: {e}") from e
+
+
+def _has_run_entrypoint(file_path: Path) -> bool:
+    """Return True if the file defines a top-level run() function."""
+    try:
+        tree = ast.parse(file_path.read_text(encoding='utf-8'))
+    except (OSError, SyntaxError):
+        return False
+    return any(
+        isinstance(node, ast.FunctionDef) and node.name == 'run'
+        for node in tree.body
+    )
+
+
+def execute_python_bootstrap(file_path: Path, model, cwd: Optional[Path] = None) -> str:
+    """
+    Execute a Python bootstrap script.
+
+    Fast path — if the script defines a top-level run(model) function it is
+    loaded in-process via importlib and called with the live database model,
+    sharing the existing connection.
+
+    Slow path — scripts without run(model) are executed as a subprocess
+    (backwards-compatible with pre-API scripts).
+
+    Args:
+        file_path: Path to Python bootstrap script
+        model: halfORM Model instance (shared database connection)
+        cwd: Working directory for execution (default: file's parent)
+
+    Returns:
+        Return value of run() converted to str, or subprocess stdout.
+        Empty string if run() returns None.
+
+    Raises:
+        FileExecutionError: If execution fails
+    """
+    if cwd is None:
+        cwd = file_path.parent
+
+    if not _has_run_entrypoint(file_path):
+        return execute_python_file(file_path, cwd)
+
+    module_name = f"_hop_bootstrap_{file_path.stem.replace('-', '_').replace('.', '_')}"
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+
+    cwd_str = str(cwd)
+    inserted = cwd_str not in sys.path
+    if inserted:
+        sys.path.insert(0, cwd_str)
+
+    try:
+        spec.loader.exec_module(module)
+        result = module.run(model)
+        return str(result) if result is not None else ''
+    except FileExecutionError:
+        raise
+    except Exception as e:
+        raise FileExecutionError(
+            f"Python execution failed in {file_path.name}: {e}"
+        ) from e
+    finally:
+        if inserted and cwd_str in sys.path:
+            sys.path.remove(cwd_str)
+        sys.modules.pop(module_name, None)
+
+
+def execute_bootstrap_files(bootstrap_dir: Path, model) -> None:
+    """
+    Execute all bootstrap files in alphabetic order.
+
+    Bootstrap files are SQL and Python files in the bootstrap/ directory that
+    initialize application data on empty databases. They are executed in
+    alphabetic order (no numeric parsing needed).
+
+    Args:
+        bootstrap_dir: Path to bootstrap directory
+        model: halfORM Model instance (shared database connection)
+
+    Raises:
+        FileExecutionError: If any file execution fails
+
+    Example:
+        bootstrap_dir = Path('/path/to/project/bootstrap')
+        execute_bootstrap_files(bootstrap_dir, model)
+
+        # Executes files in order:
+        # - 01-init-users.sql
+        # - 02-seed-config.py
+        # - 03-reference-data.sql
+    """
+    if not bootstrap_dir.exists():
+        return
+
+    # Collect all SQL and Python files
+    files = []
+    for file_path in bootstrap_dir.iterdir():
+        if file_path.is_file() and file_path.suffix in ('.sql', '.py'):
+            files.append(file_path)
+
+    if not files:
+        return
+
+    # Sort alphabetically by filename
+    files.sort(key=lambda f: f.name)
+
+    # Execute each file
+    for file_path in files:
+        try:
+            if file_path.suffix == '.sql':
+                execute_sql_file(file_path, model)
+            elif file_path.suffix == '.py':
+                execute_python_bootstrap(file_path, model, cwd=bootstrap_dir)
+        except FileExecutionError:
+            # Re-raise FileExecutionError as-is (already has good error message)
+            raise
+        except Exception as e:
+            # Wrap unexpected errors
+            raise FileExecutionError(
+                f"Failed to execute bootstrap file {file_path.name}: {e}"
+            ) from e

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/half_orm_dev/hgit.py

@@ -560,6 +560,49 @@ class HGit:
         finally:
             marker.unlink(missing_ok=True)
 
+    def setup_production_branches(self) -> None:
+        """
+        Create local tracking branches for all remote ho-prod-* branches.
+
+        This ensures production servers have local access to all versioned
+        production branches (ho-prod, ho-prod-X.Y.Z) for rollback support.
+
+        Workflow:
+            1. List all remote branches matching origin/ho-prod*
+            2. For each remote branch, create local tracking branch if missing
+            3. Skip if local branch already exists
+
+        Used in:
+            - Production clone: after initial checkout
+            - Production upgrade: after fetch to get new releases
+
+        Examples:
+            # After clone or fetch
+            hgit.setup_production_branches()
+            # → Creates ho-prod-0.1.0, ho-prod-0.1.1, etc. from origin
+        """
+        # Get all remote branches matching ho-prod*
+        remote_branches = []
+        for ref in self.__git_repo.remote('origin').refs:
+            branch_name = ref.name.replace('origin/', '')
+            if branch_name.startswith('ho-prod'):
+                remote_branches.append(branch_name)
+
+        # Create local tracking branches for each remote ho-prod* branch
+        for branch_name in remote_branches:
+            try:
+                # Check if local branch already exists
+                if branch_name in [b.name for b in self.__git_repo.branches]:
+                    continue
+
+                # Create local tracking branch
+                remote_ref = self.__git_repo.remote('origin').refs[branch_name]
+                self.__git_repo.create_head(branch_name, remote_ref)
+
+            except Exception:
+                # Skip branches that can't be created (shouldn't happen)
+                pass
+
     def delete_local_branch(self, branch_name: str) -> None:
         """
         Delete local branch.

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/half_orm_dev/migration_manager.py

@@ -543,6 +543,7 @@ class MigrationManager:
                     else:
                         repo.restore_database_from_schema(skip_bootstrap=True)
                 else:
+                    #XXX EST-CE QUE POUR ho-patch/* on ne devrait pas utiliser from_release_schema ?
                     # ho-prod and ho-patch/*: use production schema
                     repo.restore_database_from_schema(skip_bootstrap=True)
 

{half_orm_dev-1.0.0a30 → half_orm_dev-1.0.0a32}/half_orm_dev/migrations/0/17/4/00_toml_dict_format.py

@@ -18,10 +18,10 @@ from pathlib import Path
 import subprocess
 import sys
 
-try:
+if sys.version_info >= (3, 11):
+     import tomllib as tomli
+else:
     import tomli
-except ImportError:
-    import tomllib as tomli
 
 try:
     import tomli_w