half-orm-dev 0.17.3a4__py3-none-any.whl → 0.17.3a6__py3-none-any.whl

half_orm_dev/cli/commands/release.py

@@ -369,39 +369,118 @@ def release_hotfix(version: Optional[str] = None) -> None:
 
 
 @release.command('apply')
-@click.argument('version', type=str, required=False)
-def release_apply(version: Optional[str] = None) -> None:
+@click.option(
+    '--skip-tests',
+    is_flag=True,
+    help='Skip running pytest after applying patches'
+)
+def release_apply(skip_tests: bool) -> None:
     """
-    Test complete release before deployment (NOT IMPLEMENTED YET).
+    Apply all patches for integration testing.
+
+    Restores the database from production schema and applies ALL patches
+    (candidates + staged) to test the complete release integration.
+    Optionally runs pytest to validate the release.
 
-    Applies all patches from a release file to test the complete
-    release workflow before production deployment.
+    Unlike 'patch apply' which only applies validated (staged) patches,
+    this command applies ALL patches including candidates that haven't
+    passed individual validation yet. This enables testing the complete
+    release before promotion.
 
     \b
-    Args:
-        version: Release version to test (e.g., "1.3.5-rc1")
-                 If not provided, applies latest RC
+    Workflow:
+        1. Validate on release branch (ho-release/X.Y.Z)
+        2. Restore database from model/schema.sql
+        3. Apply all RC patches (if any)
+        4. Apply ALL TOML patches (candidates + staged)
+        5. Generate Python code
+        6. Run pytest (unless --skip-tests)
+
+    \b
+    Requirements:
+        - Must be on ho-release/X.Y.Z branch
+        - Development release must exist
 
     \b
     Examples:
-        Test latest RC:
+        Apply all patches and run tests:
         $ half_orm dev release apply
 
-        Test specific RC:
-        $ half_orm dev release apply 1.3.5-rc1
-
-        Test stage release:
-        $ half_orm dev release apply 1.3.5-stage
+        Apply patches without running tests:
+        $ half_orm dev release apply --skip-tests
 
     \b
-    Status: 🚧 Not implemented - planned for future release
+    Output:
+        ✓ Applied 5 patches for version 1.3.6
+        ✓ Tests passed (42 tests)
+
+        Or on failure:
+        ✗ Tests failed
+        <test output>
     """
-    click.echo("🚧 Release testing not implemented yet")
-    click.echo()
-    click.echo("Planned workflow:")
-    click.echo("  1. Restore database from model/schema.sql")
-    click.echo("  2. Apply all patches from release file")
-    click.echo("  3. Run comprehensive tests")
-    click.echo("  4. Validate final state")
-    click.echo()
-    raise NotImplementedError("Release apply not yet implemented")
+    try:
+        # Get repository instance
+        repo = Repo()
+        release_mgr = repo.release_manager
+
+        # Display context
+        click.echo("🔄 Applying all release patches for integration testing...")
+        click.echo()
+
+        # Apply release
+        result = release_mgr.apply_release(run_tests=not skip_tests)
+
+        # Display results
+        version = result['version']
+        patches = result['patches_applied']
+        candidates = result.get('candidates_merged', [])
+        patch_count = len(patches)
+
+        click.echo(f"✓ {utils.Color.green('Patches applied successfully!')}")
+        click.echo()
+        click.echo(f"  Version:  {utils.Color.bold(version)}")
+        click.echo(f"  Patches:  {utils.Color.bold(str(patch_count))}")
+        if candidates:
+            click.echo(f"  Candidates merged: {utils.Color.bold(str(len(candidates)))}")
+        click.echo()
+
+        # Show candidates merged (simulated merges)
+        if candidates:
+            click.echo("  Candidate branches merged (simulated):")
+            for patch_id in candidates:
+                click.echo(f"    • ho-patch/{patch_id}")
+            click.echo()
+
+        # Show patches applied
+        if patches:
+            click.echo("  Applied patches (SQL):")
+            for patch_id in patches:
+                click.echo(f"    • {patch_id}")
+            click.echo()
+
+        # Show test results
+        if skip_tests:
+            click.echo(f"⚠️  {utils.Color.bold('Tests skipped')} (--skip-tests flag)")
+        elif result['tests_passed'] is None:
+            click.echo(f"⚠️  {utils.Color.bold('Tests not run')} (pytest not found)")
+        elif result['tests_passed']:
+            click.echo(f"✓ {utils.Color.green('Tests passed!')}")
+        else:
+            click.echo(f"✗ {utils.Color.red('Tests failed!')}")
+            click.echo()
+            click.echo("Test output:")
+            click.echo(result['test_output'])
+            sys.exit(1)
+
+        click.echo()
+        click.echo("📝 Next steps:")
+        if result['tests_passed'] or result['tests_passed'] is None:
+            click.echo(f"  • Promote to RC: {utils.Color.bold('half_orm dev release promote rc')}")
+        else:
+            click.echo(f"  • Fix failing tests")
+            click.echo(f"  • Re-run: {utils.Color.bold('half_orm dev release apply')}")
+
+    except ReleaseManagerError as e:
+        click.echo(f"❌ {utils.Color.red('Release apply failed:')}", err=True)
+        click.echo(f"   {str(e)}", err=True)
+        sys.exit(1)

half_orm_dev/database.py

@@ -93,6 +93,10 @@ class Database:
         if get_release and self.__repo.devel:
             self.__last_release = self.last_release
 
+    @property
+    def name(self):
+        return self.__name
+
     @property
     def last_release(self):
         "Returns the last release"
@@ -177,10 +181,22 @@ class Database:
             *command_args
         )
 
-    def register_release(self, major, minor, patch, changelog=None):
-        "Register the release into half_orm_meta.hop_release"
+    def register_release(self, major, minor, patch, pre_release='', pre_release_num='', changelog=None):
+        """
+        Register the release into half_orm_meta.hop_release.
+
+        Args:
+            major: Major version number
+            minor: Minor version number
+            patch: Patch version number
+            pre_release: Pre-release type ('alpha', 'beta', 'rc', or '' for production)
+            pre_release_num: Pre-release number (e.g., '1' for rc1)
+            changelog: Optional changelog text
+        """
         return self.__model.get_relation_class('half_orm_meta.hop_release')(
-            major=major, minor=minor, patch=patch, changelog=changelog
+            major=major, minor=minor, patch=patch,
+            pre_release=pre_release, pre_release_num=pre_release_num,
+            changelog=changelog
         ).ho_insert()
 
     def _generate_schema_sql(self, version: str, model_dir: Path) -> Path:
@@ -271,6 +287,7 @@ class Database:
 
         # Construct versioned schema file path
         schema_file = model_dir / f"schema-{version}.sql"
+        temp_schema_file = model_dir / f".schema-{version}.sql.tmp"
 
         # Generate schema dump using pg_dump
         try:
@@ -278,16 +295,45 @@ class Database:
                 'pg_dump',
                 self.__name,
                 '--schema-only',
+                '--no-owner',
                 '-f',
-                str(schema_file)
+                str(temp_schema_file)
+            )
+
+            # Filter out version-specific lines for cross-version compatibility
+            content = temp_schema_file.read_text()
+            filtered_lines = []
+            # SET commands that are version-specific and should be removed
+            version_specific_sets = (
+                'SET transaction_timeout',  # PG17+
             )
+            for line in content.split('\n'):
+                # Skip \restrict and \unrestrict lines
+                if line.startswith('\\restrict') or line.startswith('\\unrestrict'):
+                    continue
+                # Skip "-- Dumped from/by" comments (version-specific)
+                if line.startswith('-- Dumped from') or line.startswith('-- Dumped by'):
+                    continue
+                # Skip version-specific SET commands
+                if any(line.startswith(s) for s in version_specific_sets):
+                    continue
+                filtered_lines.append(line)
+
+            schema_file.write_text('\n'.join(filtered_lines))
         except Exception as e:
             raise Exception(f"Failed to generate schema SQL: {e}") from e
+        finally:
+            # Clean up temporary file
+            if temp_schema_file.exists():
+                temp_schema_file.unlink()
 
         # Generate metadata dump (half_orm_meta data only)
+        # Keep only COPY statements to avoid version-specific SET commands
         metadata_file = model_dir / f"metadata-{version}.sql"
+        temp_file = model_dir / f".metadata-{version}.sql.tmp"
 
         try:
+            # Dump to temporary file
             self.execute_pg_command(
                 'pg_dump',
                 self.__name,
@@ -296,10 +342,29 @@ class Database:
                 '--table=half_orm_meta.hop_release',
                 '--table=half_orm_meta.hop_release_issue',
                 '-f',
-                str(metadata_file)
+                str(temp_file)
             )
+
+            # Filter to keep only COPY blocks (COPY ... FROM stdin; ... \.)
+            content = temp_file.read_text()
+            filtered_lines = []
+            in_copy_block = False
+            for line in content.split('\n'):
+                if line.startswith('COPY '):
+                    in_copy_block = True
+                if in_copy_block:
+                    filtered_lines.append(line)
+                if line == '\\.':
+                    in_copy_block = False
+                    filtered_lines.append('')  # Empty line between blocks
+
+            metadata_file.write_text('\n'.join(filtered_lines))
         except Exception as e:
             raise Exception(f"Failed to generate metadata SQL: {e}") from e
+        finally:
+            # Clean up temporary file
+            if temp_file.exists():
+                temp_file.unlink()
 
         # Create or update symlink
         symlink_path = model_dir / "schema.sql"

half_orm_dev/patch_manager.py

@@ -1916,7 +1916,7 @@ class PatchManager:
         # This also syncs .hop/ to all active branches automatically via decorator
         try:
             self._repo.commit_and_sync_to_active_branches(
-                message=f"[HOP] move patch #{patch_id} from candidate to stage %{version}"
+                message=f"[HOP] move patch #{patch_id} from candidate to stage %{version}\nFixes #{patch_id}."
             )
         except Exception as e:
             raise PatchManagerError(f"Failed to commit/push changes: {e}")

half_orm_dev/release_manager.py

@@ -744,27 +744,64 @@ class ReleaseManager:
         for patch_id in stage_patches:
             self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
 
-    def _generate_data_sql_file(self, patch_list: List[str], output_filename: str) -> Optional[Path]:
+    def _collect_all_version_patches(self, version: str) -> List[str]:
         """
-        Generate data-X.Y.Z.sql file from patches with @HOP:data annotation.
+        Collect all patches for a version including hotfixes.
+
+        Returns patches from:
+        1. Base release (X.Y.Z.txt)
+        2. All hotfixes in order (X.Y.Z-hotfix1.txt, X.Y.Z-hotfix2.txt, ...)
+
+        Args:
+            version: Base version string (e.g., "1.2.0")
+
+        Returns:
+            List of all patch IDs in application order
+
+        Examples:
+            # With 1.2.0.txt containing [a, b] and 1.2.0-hotfix1.txt containing [c]
+            patches = mgr._collect_all_version_patches("1.2.0")
+            # Returns: ["a", "b", "c"]
+        """
+        all_patches = []
+
+        # 1. Base release patches
+        base_file = f"{version}.txt"
+        all_patches.extend(self.read_release_patches(base_file))
+
+        # 2. Hotfix patches in order
+        hotfix_files = sorted(self._releases_dir.glob(f"{version}-hotfix*.txt"))
+        for hotfix_file in hotfix_files:
+            all_patches.extend(self.read_release_patches(hotfix_file.name))
+
+        return all_patches
+
+    def _generate_data_sql_file(self, patch_list: List[str], version: str) -> Optional[Path]:
+        """
+        Generate model/data-X.Y.Z.sql file from patches with @HOP:data annotation.
 
         Collects all SQL files marked with `-- @HOP:data` from the patch list
         and concatenates them into a single data SQL file for from-scratch
-        installations.
+        installations (clone, restore_database_from_schema).
+
+        This file is only generated for production releases. RC and hotfix
+        versions don't need this file because:
+        - In production upgrades, data is inserted by patch application
+        - This file is only for from-scratch installations
 
         Args:
             patch_list: List of patch IDs to process
-            output_filename: Name of the output file (e.g., "data-0.17.0-rc1.sql")
+            version: Version string (e.g., "0.17.0")
 
         Returns:
-            Path to generated file, or None if no data files found
+            Path to generated file (model/data-X.Y.Z.sql), or None if no data files found
 
         Examples:
             self._generate_data_sql_file(
                 ["456-auth", "457-roles"],
-                "data-0.17.0-rc1.sql"
+                "0.17.0"
             )
-            # Generates releases/data-0.17.0-rc1.sql with data from both patches
+            # Generates model/data-0.17.0.sql with data from both patches
         """
         if not patch_list:
             return None
@@ -777,16 +814,17 @@ class ReleaseManager:
                 # No data files found - skip generation
                 return None
 
-            # Generate output file
-            output_path = self._releases_dir / output_filename
+            # Generate output file in model/ directory
+            output_filename = f"data-{version}.sql"
+            output_path = Path(self._repo.model_dir) / output_filename
 
             with output_path.open('w', encoding='utf-8') as out_file:
                 # Write header
-                out_file.write(f"-- Data file for {output_filename.replace('.sql', '')}\n")
+                out_file.write(f"-- Data file for version {version}\n")
                 out_file.write(f"-- Generated from patches: {', '.join(patch_list)}\n")
                 out_file.write(f"-- This file contains reference data (DML) for from-scratch installations\n")
                 out_file.write(f"--\n")
-                out_file.write(f"-- Usage: psql -f {output_filename}\n")
+                out_file.write(f"-- Usage: Automatically loaded by restore_database_from_schema()\n")
                 out_file.write(f"--\n\n")
 
                 # Concatenate all data files
@@ -811,26 +849,30 @@ class ReleaseManager:
 
         except Exception as e:
             raise ReleaseManagerError(
-                f"Failed to generate data SQL file {output_filename}: {e}"
+                f"Failed to generate data SQL file data-{version}.sql: {e}"
             )
 
     def get_all_release_context_patches(self) -> List[str]:
         """
-        Récupère TOUS les patches du contexte de la prochaine release.
+        Get all validated patches for the next release context.
+
+        Sequential application of incremental RCs + staged patches from TOML.
+        - rc1: initial patches (e.g., 123, 456, 789)
+        - rc2: new patches (e.g., 999)
+        - rc3: new patches (e.g., 888, 777)
+        - TOML: only "staged" patches (validated via patch merge)
 
-        IMPORTANT: Application séquentielle des RC incrémentaux + TOML patches.
-        - rc1: patches initiaux (ex: 123, 456, 789)
-        - rc2: patches nouveaux (ex: 999)
-        - rc3: patches nouveaux (ex: 888, 777)
-        - TOML: TOUS les patches (candidates + staged) dans l'ordre
+        "candidate" patches are NOT included because they have not passed
+        the validation process (tests) that occurs during patch merge.
+        Only "staged" patches are guaranteed to have passed tests.
 
-        Résultat: [123, 456, 789, 999, 888, 777, ...]
+        The current patch is applied separately by apply_patch_complete_workflow.
 
-        Pas de déduplication car chaque RC est incrémental.
+        Note: A future "release apply" command could allow applying all patches
+        (candidates + staged) in a temporary branch for integration testing.
 
         Returns:
-            Liste ordonnée des patch IDs (séquence complète)
-            Inclut RC files + TOUS les patches du TOML (candidates + staged)
+            Ordered list of validated patch IDs (RC + staged)
 
         Examples:
             # Production: 1.3.5
@@ -839,14 +881,15 @@ class ReleaseManager:
             # 1.3.6-patches.toml: {"234": "candidate", "567": "staged"}
 
             patches = mgr.get_all_release_context_patches()
-            # → ["123", "456", "789", "999", "234", "567"]
+            # → ["123", "456", "789", "999", "567"]
+            # Note: "234" (candidate) is not included - not yet validated
 
-            # Pour apply-patch sur patch 888:
+            # For apply-patch on patch 234:
             # 1. Restore DB (1.3.5)
             # 2. Apply 123, 456, 789 (rc1)
             # 3. Apply 999 (rc2)
-            # 4. Apply 234, 567 (from TOML, all patches)
-            # 5. Apply 888 (patch courant)
+            # 4. Apply 567 (staged from TOML)
+            # 5. Apply 234 (current patch, applied separately)
         """
         next_version = self.get_next_release_version()
 
@@ -855,20 +898,21 @@ class ReleaseManager:
 
         all_patches = []
 
-        # 1. Appliquer tous les RC dans l'ordre (incrémentaux)
+        # 1. Apply all RCs in order (incremental)
         rc_files = self._get_label_files(next_version, 'rc')
         for rc_file in rc_files:
             patches = self.read_release_patches(rc_file)
-            # Chaque RC est incrémental, pas besoin de déduplication
+            # Each RC is incremental, no deduplication needed
             all_patches.extend(patches)
 
-        # 2. Appliquer TOUS les patches du TOML (candidates + staged)
-        # Pour les tests et la synchronisation, on veut tous les patches dans l'ordre
+        # 2. Apply only "staged" patches from TOML
+        # "candidate" patches are excluded because they have not yet passed
+        # the validation process (tests) that occurs during patch merge
+        # Current patch is applied separately by apply_patch_complete_workflow
         release_file = ReleaseFile(next_version, self._releases_dir)
         if release_file.exists():
-            # get_patches() sans argument retourne TOUS les patches dans l'ordre d'insertion
-            all_toml_patches = release_file.get_patches()
-            all_patches.extend(all_toml_patches)
+            staged_patches = release_file.get_patches(status="staged")
+            all_patches.extend(staged_patches)
 
         return all_patches
 
@@ -1869,7 +1913,7 @@ class ReleaseManager:
             # → Raises: "Backup exists and user declined overwrite"
         """
         # Create backups directory if doesn't exist
-        backups_dir = Path(self._repo.base_dir) / "backups"
+        backups_dir = Path(self._repo.base_dir) / ".hop" / "backups"
         backups_dir.mkdir(exist_ok=True)
 
         # Build backup filename
@@ -1893,6 +1937,7 @@ class ReleaseManager:
         try:
             self._repo.database.execute_pg_command(
                 'pg_dump',
+                self._repo.database.name,
                 '-f', str(backup_file),
             )
         except Exception as e:
@@ -2290,10 +2335,18 @@ class ReleaseManager:
             # 1. Apply patches to database (for validation)
             self._apply_release_patches(version)
 
-            # 2. Checkout release branch
+            # 2. Register the RC version in half_orm_meta.hop_release
+            version_parts = version.split('.')
+            major, minor, patch_num = map(int, version_parts)
+            self._repo.database.register_release(
+                major, minor, patch_num,
+                pre_release='rc', pre_release_num=str(rc_number)
+            )
+
+            # 3. Checkout release branch
             self._repo.hgit.checkout(release_branch)
 
-            # 3. Create RC tag on release branch
+            # 4. Create RC tag on release branch
             self._repo.hgit.create_tag(rc_tag, f"Release Candidate %{version}")
 
             # Push tag
@@ -2309,14 +2362,10 @@ class ReleaseManager:
 
             # Keep TOML file for continued development (don't delete it)
 
-            # Generate data-X.Y.Z-rcN.sql if any patches have @HOP:data files
-            rc_patches = self.read_release_patches(rc_file.name)
-            data_file = self._generate_data_sql_file(
-                rc_patches,
-                f"data-{version}-rc{rc_number}.sql"
-            )
+            # Note: data-X.Y.Z.sql is only generated for production releases
+            # RC releases don't need it - data is inserted via patch application
 
-            # Commit RC snapshot and data file (both in .hop/releases/)
+            # Commit RC snapshot (in .hop/releases/)
             # This also syncs .hop/ to all active branches automatically
             self._repo.commit_and_sync_to_active_branches(
                 message=f"[HOP] Promote release %{version} to RC {rc_number}"
@@ -2473,6 +2522,11 @@ class ReleaseManager:
                 # The database should already be in the correct state from RC
                 pass
 
+            # Register the release version in half_orm_meta.hop_release
+            version_parts = version.split('.')
+            major, minor, patch_num = map(int, version_parts)
+            self._repo.database.register_release(major, minor, patch_num)
+
             # Generate schema dump for this production version
             model_dir = Path(self._repo.model_dir)
             self._repo.database._generate_schema_sql(version, model_dir)
@@ -2488,13 +2542,12 @@ class ReleaseManager:
             if toml_file.exists():
                 toml_file.unlink()
 
-            # Generate data-X.Y.Z.sql if any patches have @HOP:data files
-            # This includes patches from stage (incremental after last RC)
+            # Generate model/data-X.Y.Z.sql if any patches have @HOP:data files
+            # This file is used for from-scratch installations (clone, restore)
             prod_patches = self.read_release_patches(prod_file.name)
-            self._generate_data_sql_file(
-                prod_patches,
-                f"data-{version}.sql"
-            )
+            data_file = self._generate_data_sql_file(prod_patches, version)
+            if data_file:
+                self._repo.hgit.add(str(data_file))
 
             self._repo.commit_and_sync_to_active_branches(
                 message=f"[HOP] Promote release %{version} to production",
@@ -2909,14 +2962,12 @@ class ReleaseManager:
                 if toml_file.exists():
                     self._repo.hgit.rm(str(toml_file))
 
-            # Generate data-X.Y.Z-hotfixN.sql if any patches have @HOP:data files
-            hotfix_patches = self.read_release_patches(hotfix_file.name)
-            data_file = self._generate_data_sql_file(
-                hotfix_patches,
-                f"data-{version}-hotfix{hotfix_num}.sql"
-            )
+            # Regenerate model/data-X.Y.Z.sql with all patches (original release + all hotfixes)
+            # This ensures from-scratch installations get all data
+            all_patches = self._collect_all_version_patches(version)
+            data_file = self._generate_data_sql_file(all_patches, version)
             if data_file:
-                self._repo.hgit.add(str(data_file))  # Add data file if generated
+                self._repo.hgit.add(str(data_file))
 
             # 6. Apply release patches and generate SQL dumps
             self._apply_release_patches(version, True)
@@ -2953,3 +3004,248 @@ class ReleaseManager:
             raise
         except Exception as e:
             raise ReleaseManagerError(f"Failed to promote hotfix: {e}")
+
+    def get_all_release_patches_for_testing(self) -> List[str]:
+        """
+        Get ALL patches for integration testing (candidates + staged).
+
+        Unlike get_all_release_context_patches() which excludes candidates,
+        this method returns ALL patches including those not yet validated.
+        Used by 'release apply' for complete integration testing.
+
+        Returns:
+            Ordered list of ALL patch IDs (RC + candidates + staged)
+
+        Examples:
+            # Production: 1.3.5
+            # 1.3.6-rc1.txt: 123, 456, 789
+            # 1.3.6-patches.toml: {"234": "candidate", "567": "staged"}
+
+            patches = mgr.get_all_release_patches_for_testing()
+            # → ["123", "456", "789", "234", "567"]
+            # All patches included for complete integration testing
+        """
+        next_version = self.get_next_release_version()
+
+        if not next_version:
+            return []
+
+        all_patches = []
+
+        # 1. Apply all RCs in order (incremental)
+        rc_files = self._get_label_files(next_version, 'rc')
+        for rc_file in rc_files:
+            patches = self.read_release_patches(rc_file)
+            all_patches.extend(patches)
+
+        # 2. Apply ALL patches from TOML (candidates + staged)
+        # For integration testing, we want to test the complete release
+        release_file = ReleaseFile(next_version, self._releases_dir)
+        if release_file.exists():
+            all_toml_patches = release_file.get_patches()  # No status filter = all
+            all_patches.extend(all_toml_patches)
+
+        return all_patches
+
+    def _cleanup_validate_branch(self, original_branch: Optional[str],
+                                  validate_branch: Optional[str]) -> None:
+        """
+        Cleanup temporary validation branch after apply_release.
+
+        Switches back to the original branch and deletes the temporary
+        validation branch. Errors are silently ignored for robustness.
+
+        Args:
+            original_branch: Branch to switch back to (may be None)
+            validate_branch: Temporary branch to delete (may be None)
+        """
+        try:
+            if original_branch:
+                self._repo.hgit.checkout(original_branch)
+        except Exception:
+            pass  # Best effort
+
+        try:
+            if validate_branch:
+                self._repo.hgit.delete_branch(validate_branch, force=True)
+        except Exception:
+            pass  # Best effort
+
+    def apply_release(self, run_tests: bool = True) -> dict:
+        """
+        Apply all patches from current release for integration testing.
+
+        Creates a temporary validation branch (ho-validate/release-X.Y.Z),
+        merges candidate patch branches, restores the database, applies ALL
+        patches (including candidates), optionally runs tests, then cleans up.
+        This simulates a complete release merge without modifying the release branch.
+
+        Unlike 'patch apply' which only applies staged patches,
+        'release apply' applies ALL patches (candidates + staged) to
+        validate the complete integration.
+
+        Args:
+            run_tests: Whether to run pytest after applying patches (default: True)
+
+        Returns:
+            Dict containing:
+            - version: Release version being tested
+            - patches_applied: List of patch IDs applied
+            - candidates_merged: List of candidate patch branches merged
+            - files_applied: List of SQL/Python files applied
+            - tests_passed: Boolean (None if tests not run)
+            - test_output: Test output (None if tests not run)
+            - status: 'success' or 'failed'
+            - error: Error message if failed
+
+        Raises:
+            ReleaseManagerError: If no release in development or apply fails
+
+        Workflow:
+            1. Detect current development release
+            2. Validate we're on release branch
+            3. Create temporary validation branch
+            4. Merge candidate patch branches (simulate future merges)
+            5. Restore database from production schema
+            6. Apply ALL patches (RC + staged + candidates)
+            7. Generate Python code
+            8. Optionally run tests
+            9. Cleanup: switch back and delete temp branch
+            10. Return results
+
+        Examples:
+            # Test current release with tests
+            result = release_mgr.apply_release()
+            if result['status'] == 'success':
+                print(f"Release {result['version']} ready!")
+
+            # Test without running tests
+            result = release_mgr.apply_release(run_tests=False)
+        """
+        import subprocess
+
+        validate_branch = None
+        original_branch = None
+
+        try:
+            # 1. Detect current development release
+            next_version = self.get_next_release_version()
+            if not next_version:
+                raise ReleaseManagerError(
+                    "No development release found.\n"
+                    "Create one with: half_orm dev release create <level>"
+                )
+
+            # 2. Validate we're on a release branch
+            original_branch = self._repo.hgit.branch
+            expected_branch = f"ho-release/{next_version}"
+            if original_branch != expected_branch:
+                raise ReleaseManagerError(
+                    f"Must be on release branch {expected_branch}\n"
+                    f"Currently on: {original_branch}\n"
+                    f"Switch with: git checkout {expected_branch}"
+                )
+
+            # 3. Create temporary validation branch
+            validate_branch = f"ho-validate/release-{next_version}"
+
+            # Delete existing validation branch if it exists
+            try:
+                self._repo.hgit.delete_branch(validate_branch, force=True)
+            except Exception:
+                pass  # Branch doesn't exist, that's fine
+
+            # Create and checkout validation branch
+            self._repo.hgit.create_branch(validate_branch)
+            self._repo.hgit.checkout(validate_branch)
+
+            # 4. Merge candidate patch branches to simulate future merges
+            # Staged patches are already merged on ho-release, only candidates need merging
+            release_file = ReleaseFile(next_version, self._releases_dir)
+            candidates_merged = []
+            if release_file.exists():
+                candidate_patches = release_file.get_patches(status="candidate")
+                for patch_id in candidate_patches:
+                    patch_branch = f"ho-patch/{patch_id}"
+                    try:
+                        self._repo.hgit.merge(patch_branch)
+                        candidates_merged.append(patch_id)
+                    except Exception as e:
+                        raise ReleaseManagerError(
+                            f"Failed to merge candidate branch {patch_branch}: {e}\n"
+                            f"Fix merge conflicts on the patch branch first."
+                        )
+
+            # 5. Restore database from production schema
+            self._repo.restore_database_from_schema()
+
+            # 6. Get and apply ALL patches (RC + staged + candidates)
+            all_patches = self.get_all_release_patches_for_testing()
+            all_applied_files = []
+
+            for patch_id in all_patches:
+                files = self._repo.patch_manager.apply_patch_files(
+                    patch_id, self._repo.model
+                )
+                all_applied_files.extend(files)
+
+            # 7. Generate Python code
+            from half_orm_dev import modules
+            modules.generate(self._repo)
+
+            # 8. Optionally run tests
+            tests_passed = None
+            test_output = None
+
+            if run_tests:
+                try:
+                    result = subprocess.run(
+                        ['pytest', '-v'],
+                        cwd=self._repo.base_dir,
+                        capture_output=True,
+                        text=True,
+                        timeout=600  # 10 minute timeout
+                    )
+                    tests_passed = result.returncode == 0
+                    test_output = result.stdout + result.stderr
+                except subprocess.TimeoutExpired:
+                    tests_passed = False
+                    test_output = "Tests timed out after 10 minutes"
+                except FileNotFoundError:
+                    tests_passed = None
+                    test_output = "pytest not found - tests skipped"
+
+            # 9. Cleanup: switch back to original branch and delete temp branch
+            self._repo.hgit.checkout(original_branch)
+            try:
+                self._repo.hgit.delete_branch(validate_branch, force=True)
+            except Exception:
+                pass  # Best effort cleanup
+
+            # 10. Return results
+            return {
+                'version': next_version,
+                'patches_applied': all_patches,
+                'candidates_merged': candidates_merged,
+                'files_applied': all_applied_files,
+                'tests_passed': tests_passed,
+                'test_output': test_output,
+                'status': 'success' if tests_passed is not False else 'failed',
+                'error': None
+            }
+
+        except ReleaseManagerError:
+            # Cleanup on error
+            self._cleanup_validate_branch(original_branch, validate_branch)
+            raise
+        except Exception as e:
+            # Cleanup on error
+            self._cleanup_validate_branch(original_branch, validate_branch)
+
+            # Restore DB to clean state on failure
+            try:
+                self._repo.restore_database_from_schema()
+            except Exception:
+                pass  # Best effort cleanup
+
+            raise ReleaseManagerError(f"Release apply failed: {e}")

half_orm_dev/repo.py

@@ -2218,17 +2218,19 @@ See docs/half_orm_dev.md for complete documentation.
 
     def restore_database_from_schema(self) -> None:
         """
-        Restore database from model/schema.sql and model/metadata-X.Y.Z.sql.
+        Restore database from model/schema.sql, metadata, and data files.
 
         Restores database to clean production state by dropping all user schemas
-        a clean baseline before applying patch files during patch development.
+        and loading schema, metadata, and reference data. Used for from-scratch
+        installations (clone) and patch development (patch apply).
 
         Process:
         1. Verify model/schema.sql exists (file or symlink)
         2. Drop all user schemas with CASCADE (no superuser privileges needed)
         3. Load schema structure from model/schema.sql using psql -f
         4. Load half_orm_meta data from model/metadata-X.Y.Z.sql using psql -f (if exists)
-        5. Reload halfORM Model metadata cache
+        5. Load reference data from model/data-*.sql files up to current version
+        6. Reload halfORM Model metadata cache
 
         The method uses DROP SCHEMA CASCADE instead of dropdb/createdb, allowing
         operation without CREATEDB privilege or superuser access. This makes it
@@ -2238,20 +2240,24 @@ See docs/half_orm_dev.md for complete documentation.
         - Accepts model/schema.sql as regular file or symlink
         - Symlink typically points to versioned schema-X.Y.Z.sql file
         - Follows symlink automatically during psql execution
-        - Deduces metadata file version from schema.sql symlink target
-        - If metadata-X.Y.Z.sql doesn't exist, continues without error (backward compatibility)
+        - Deduces version from schema.sql symlink target for metadata and data files
+        - Missing metadata/data files are silently skipped (backward compatibility)
+
+        Data Files:
+        - model/data-X.Y.Z.sql contains reference data from @HOP:data patches
+        - All data files up to current version are loaded in version order
+        - Example: for version 1.2.0, loads data-0.1.0.sql, data-1.0.0.sql, data-1.2.0.sql
 
         Error Handling:
         - Raises RepoError if model/schema.sql not found
         - Raises RepoError if schema drop fails
-        - Raises RepoError if psql schema load fails
-        - Raises RepoError if psql metadata load fails (when file exists)
+        - Raises RepoError if psql schema/metadata/data load fails
         - Database state rolled back on any failure
 
         Usage Context:
+        - Called by clone_repo workflow (from-scratch installation)
         - Called by apply-patch workflow (Step 1: Database Restoration)
-        - Ensures clean state before applying patch SQL files
-        - Part of isolated patch testing strategy
+        - Ensures clean state with all reference data before applying patches
 
         Returns:
             None
@@ -2263,31 +2269,23 @@ See docs/half_orm_dev.md for complete documentation.
         Examples:
             # Restore database from model/schema.sql before applying patch
             repo.restore_database_from_schema()
-            # Database now contains clean production schema + half_orm_meta data
+            # Database now contains: schema + metadata + reference data
 
             # Typical apply-patch workflow
-            repo.restore_database_from_schema()  # Step 1: Clean state + metadata
+            repo.restore_database_from_schema()  # Step 1: Clean state + all data
             patch_mgr.apply_patch_files("456-user-auth", repo.model)  # Step 2: Apply patch
 
-            # With versioned schema and metadata
+            # With versioned files
             # If schema.sql → schema-1.2.3.sql exists
-            # Then metadata-1.2.3.sql is loaded automatically (if it exists)
-
-            # Error handling
-            try:
-                repo.restore_database_from_schema()
-            except RepoError as e:
-                print(f"Database restoration failed: {e}")
-                # Handle error: check schema.sql exists, verify permissions
+            # Then loads: metadata-1.2.3.sql, data-0.1.0.sql, data-1.0.0.sql, data-1.2.3.sql
 
         Notes:
             - Uses DROP SCHEMA CASCADE - no superuser or CREATEDB privilege required
             - Works on cloud databases (AWS RDS, Azure Database, etc.)
             - Uses Model.reconnect(reload=True) to refresh metadata cache
             - Supports both schema.sql file and schema.sql -> schema-X.Y.Z.sql symlink
-            - Metadata file is optional (backward compatibility with older schemas)
+            - Metadata and data files are optional (backward compatibility)
             - All PostgreSQL commands use repository connection configuration
-            - Version deduction: schema.sql → schema-1.2.3.sql ⇒ metadata-1.2.3.sql
         """
         # 1. Verify model/schema.sql exists
         schema_path = Path(self.model_dir) / "schema.sql"
@@ -2318,15 +2316,16 @@ See docs/half_orm_dev.md for complete documentation.
                     self.database.execute_pg_command(
                         'psql', '-d', self.name, '-f', str(metadata_path)
                     )
-                    # Optional: Log success (can be removed if too verbose)
-                    # print(f"✓ Loaded metadata from {metadata_path.name}")
                 except Exception as e:
                     raise RepoError(
                         f"Failed to load metadata from {metadata_path.name}: {e}"
                     ) from e
             # else: metadata file doesn't exist, continue without error (backward compatibility)
 
-            # 5. Reload half_orm metadata cache
+            # 5. Load data files from model/data-*.sql (all versions up to current)
+            self._load_data_files(schema_path)
+
+            # 6. Reload half_orm metadata cache
             self.model.reconnect(reload=True)
 
         except RepoError:
@@ -2380,6 +2379,76 @@ See docs/half_orm_dev.md for complete documentation.
 
         return metadata_path
 
+    def _load_data_files(self, schema_path: Path) -> None:
+        """
+        Load all data files from model/data-*.sql up to current version.
+
+        Data files contain reference data (DML) from patches with @HOP:data annotation.
+        They are loaded in version order for from-scratch installations.
+
+        Args:
+            schema_path: Path to model/schema.sql (used to deduce current version)
+
+        Process:
+            1. Deduce current version from schema.sql symlink
+            2. Find all data-*.sql files in model/
+            3. Sort by version (semantic versioning)
+            4. Load each file up to current version using psql -f
+
+        Examples:
+            # schema.sql → schema-1.2.0.sql
+            # model/ contains: data-0.1.0.sql, data-1.0.0.sql, data-1.2.0.sql, data-2.0.0.sql
+            # Loads: data-0.1.0.sql, data-1.0.0.sql, data-1.2.0.sql (skips 2.0.0)
+        """
+        # Deduce current version from schema.sql symlink
+        if not schema_path.is_symlink():
+            return  # No version info, skip data loading
+
+        try:
+            target = Path(os.readlink(schema_path))
+        except OSError:
+            return
+
+        match = re.match(r'schema-(\d+\.\d+\.\d+)\.sql$', target.name)
+        if not match:
+            return
+
+        current_version = match.group(1)
+        current_tuple = tuple(map(int, current_version.split('.')))
+
+        # Find all data files
+        model_dir = schema_path.parent
+        data_files = list(model_dir.glob("data-*.sql"))
+
+        if not data_files:
+            return  # No data files to load
+
+        # Parse and sort by version
+        versioned_files = []
+        for data_file in data_files:
+            match = re.match(r'data-(\d+\.\d+\.\d+)\.sql$', data_file.name)
+            if match:
+                version = match.group(1)
+                version_tuple = tuple(map(int, version.split('.')))
+                versioned_files.append((version_tuple, data_file))
+
+        # Sort by version tuple
+        versioned_files.sort(key=lambda x: x[0])
+
+        # Load each file up to current version
+        for version_tuple, data_file in versioned_files:
+            if version_tuple > current_tuple:
+                break  # Stop at versions beyond current
+
+            try:
+                self.database.execute_pg_command(
+                    'psql', '-d', self.name, '-f', str(data_file)
+                )
+            except Exception as e:
+                raise RepoError(
+                    f"Failed to load data from {data_file.name}: {e}"
+                ) from e
+
     @classmethod
     def clone_repo(cls,
                 git_origin: str,

half_orm_dev/templates/README

@@ -170,10 +170,11 @@ half_orm dev upgrade <version>  # Deploy specific version
 {package_name}/
 ├── .hop/                       # half-orm-dev metadata
 │   ├── config                  # Repository configuration
-│   ├── model/                  # Database schemas
+│   ├── model/                  # Database schemas and data
 │   │   ├── schema.sql          # Current production schema (symlink)
 │   │   ├── schema-X.Y.Z.sql    # Versioned schemas
-│   │   └── metadata-X.Y.Z.sql  # half_orm_meta data dumps
+│   │   ├── metadata-X.Y.Z.sql  # half_orm_meta data dumps
+│   │   └── data-X.Y.Z.sql      # Reference data from @HOP:data patches
 │   └── releases/               # Release tracking files
 │       ├── X.Y.Z-patches.toml  # Development releases (mutable)
 │       ├── X.Y.Z-rcN.txt       # Release candidates (immutable)
@@ -199,6 +200,39 @@ All development happens on patch branches, merged into release branches, then pr
 
 ---
 
+## 💾 Data Persistence (@HOP:data)
+
+For reference data that must be loaded with every database installation (lookup tables, default roles, etc.), use the `@HOP:data` annotation:
+
+```sql
+-- @HOP:data
+-- This file will be included in model/data-X.Y.Z.sql
+
+INSERT INTO roles (name, description)
+VALUES ('admin', 'Administrator')
+ON CONFLICT (name) DO NOTHING;
+
+INSERT INTO permissions (name)
+VALUES ('read'), ('write'), ('delete')
+ON CONFLICT DO NOTHING;
+```
+
+### How it works
+
+1. **In patches**: SQL files starting with `-- @HOP:data` contain reference data
+2. **Production promote**: All `@HOP:data` files are consolidated into `model/data-X.Y.Z.sql`
+3. **Clone/Restore**: Data files are loaded automatically after schema restoration
+4. **Production upgrade**: Data is inserted via normal patch application (no special handling)
+
+### Best practices
+
+- Use `ON CONFLICT DO NOTHING` or `ON CONFLICT DO UPDATE` for idempotency
+- Keep data files small and focused (one concern per file)
+- Number your SQL files to control execution order: `01_roles.sql`, `02_permissions.sql`
+- Only use for **reference data**, not user-generated data
+
+---
+
 ## 📚 Documentation
 
 - **half-orm-dev**: https://github.com/half-orm/half-orm-dev

half_orm_dev/version.txt

@@ -1 +1 @@
-0.17.3-a4
+0.17.3-a6

{half_orm_dev-0.17.3a4.dist-info → half_orm_dev-0.17.3a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.3a4
+Version: 0.17.3a6
 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-0.17.3a4.dist-info → half_orm_dev-0.17.3a6.dist-info}/RECORD

@@ -1,17 +1,17 @@
 half_orm_dev/__init__.py,sha256=0JpUPey1gacxXuIFGcpD2nTGso73fkak72qzTHttAJk,18
 half_orm_dev/cli_extension.py,sha256=kwX3M11_rwr0pFcqHK_bpI3Pp4ztfTCVz2gLfTmzfeA,1066
-half_orm_dev/database.py,sha256=aRfCvxolJPN0kQUoEleaVjZAnyiWo-dEXq8xkKYC8pM,60088
+half_orm_dev/database.py,sha256=0sq96tseMUWAluoxoxwbTIJrzvBYMzW163D8Ssdj73g,62793
 half_orm_dev/decorators.py,sha256=JKv_Z_JZUr-s-Vz551temHZhhecPfbvyhTbByRDjVAQ,4901
 half_orm_dev/hgit.py,sha256=VdzCCQ__xG1IGJaGq4-rrhbA1bNkDw_dBqkUNIeTONg,58045
 half_orm_dev/migration_manager.py,sha256=9RpciH8nyQrF0xV31kAeaYKkQl24Di1VHt-mAjjHhzM,14854
 half_orm_dev/modules.py,sha256=4jfVb2yboRgb9mcO0sMF-iLigcZFTHEm4VRLN6GQXM4,16796
-half_orm_dev/patch_manager.py,sha256=rq0C1W6sXExMsgLwIXr7nwhpcRW28z5l5Tjy-vsqvwE,100973
+half_orm_dev/patch_manager.py,sha256=HAnQR4m8E0hyKCpPme_XiHI4K7qFkCT2DvSgCaa524s,100993
 half_orm_dev/patch_validator.py,sha256=QNe1L6k_xwsnrOTcb3vkW2D0LbqrCRcZOGPnVyspVRk,10871
 half_orm_dev/release_file.py,sha256=0c9NBhAQ6YpiC3HWj8VtZcfvvZxW2ITk1NEQ60AO0sI,9880
-half_orm_dev/release_manager.py,sha256=wCJUKLCDkOgbytqSBaU_NArLcJZPVnwP2W5UiRMwz1Y,113367
-half_orm_dev/repo.py,sha256=GOgJnDRa1g5sAVX1xi00ff90tF9L8e0S_KhCc3SoCZ0,95685
+half_orm_dev/release_manager.py,sha256=AXjjtIWAdv0yy6DkP_eGYKqDDvejmbxnz_QiMRLvwws,125510
+half_orm_dev/repo.py,sha256=h-nsB6z2xph9ortO02g9DcPXeef9Rk2D5WI3Yc3h1M4,98253
 half_orm_dev/utils.py,sha256=M3yViUFfsO7Cp9MYSoUSkCZ6R9w_4jW45UDZUOT8FhI,1493
-half_orm_dev/version.txt,sha256=EHE9HXre16bBNUi8QiB6DlSqUvIFkJnA01jyvO9CKrM,10
+half_orm_dev/version.txt,sha256=ODC9rbINfRfZYa57a3OOULq415Mxf7YFomwPl96Qm3M,10
 half_orm_dev/cli/__init__.py,sha256=0CbMj8OIhZmglWakK7NhYPn302erUTEg2VHOdm1hRTQ,163
 half_orm_dev/cli/main.py,sha256=3SVTl5WraNTSY6o7LfvE1dUHKg_RcuVaHHDIn_oINv4,11701
 half_orm_dev/cli/commands/__init__.py,sha256=UhWf0AnWqy4gyFo2SJQv8pL_YJ43pE_c9TgopcjzKDg,1490
@@ -21,7 +21,7 @@ half_orm_dev/cli/commands/clone.py,sha256=JUDDt-vz_WvGkm5HDFuZ3KZbclLyPaE4h665n8
 half_orm_dev/cli/commands/init.py,sha256=N0TXUL1ExW-DdpNrs4xiXymtSHHLh5fCbPMTBjw2Iwg,12548
 half_orm_dev/cli/commands/migrate.py,sha256=iEz3DoFX22WwaYDo_WUKaF-pFohaLWoUrDmdLCin2wc,4047
 half_orm_dev/cli/commands/patch.py,sha256=sl8mv1mlq-KnKItFV_HBfZ93G5CbdviQRIAYocuMDDo,12810
-half_orm_dev/cli/commands/release.py,sha256=Ywsp4FBDGSHkss3RYLb52SzhGP8x4RsFUbppHXKQvdk,14736
+half_orm_dev/cli/commands/release.py,sha256=yPp_3NaukhZF3smo6zNsFKtxHwB2RgZnUlomdlM6Sno,17574
 half_orm_dev/cli/commands/restore.py,sha256=n9SP8n1EQUduvDoA0qxpSUQpphc48X-NovnocyGl98I,236
 half_orm_dev/cli/commands/sync.py,sha256=D0Prr8W1ySYjP3D8H4MB05KHccFbhB8z2qB3Bs00swA,274
 half_orm_dev/cli/commands/todo.py,sha256=kL5QU-IjPWmnrKG8L4qk1vb5PDZfY88EFExICiNeLhA,2981
@@ -38,7 +38,7 @@ half_orm_dev/patches/sql/half_orm_meta.sql,sha256=Vl2YzEWpWdam-tC0ZE8iNMeTRzEHpx
 half_orm_dev/templates/.gitignore,sha256=RmvQ9D46T9vpRxhYjjY5WUjGVbuyFUMsH059wC7sPBM,140
 half_orm_dev/templates/MANIFEST.in,sha256=53BeBuKi8UtBWB6IG3VQZk9Ow8Iye6Zs14sP-gVyVDA,25
 half_orm_dev/templates/Pipfile,sha256=u3lGJSk5HZwz-EOTrOdBYrkhGV6zgVtrrRPivrO5rmA,182
-half_orm_dev/templates/README,sha256=wE7X1-FB_n8c8cEkTkaPSivszTEK5t1eYkbKh0-M9zI,6293
+half_orm_dev/templates/README,sha256=YgNl52Jk7jvwTaB7fLgrXHxOtCECQEl8AqgvImrzaWA,7522
 half_orm_dev/templates/conftest_template,sha256=DopLw67b5cptCYUtmAcQzr5Gz_kzNwpMO6r3goihiks,1206
 half_orm_dev/templates/init_module_template,sha256=o3RAnhGayYUF7NEyI8bcI6JHmAZb2wPVNF-FdrjOnQU,345
 half_orm_dev/templates/module_template_1,sha256=hRa0PiI6-dpBKNXJ9PuDuGocdrq712ujlSJGfJcXOh8,271
@@ -50,9 +50,9 @@ half_orm_dev/templates/sql_adapter,sha256=kAP5y7Qml3DKsbZLUeoVpeXjbQcWltHjkDznED
 half_orm_dev/templates/warning,sha256=4hlZ_rRdpmkXxOeRoVd9xnXBARYXn95e-iXrD1f2u7k,490
 half_orm_dev/templates/git-hooks/pre-commit,sha256=Hf084pqeiOebrv4xzA0aiaHbIXswmmNO-dSIXUfzMK0,4707
 half_orm_dev/templates/git-hooks/prepare-commit-msg,sha256=zknOGGoaWKC97zfga2Xl2i_psnNo9MJbrEBuN91eHNw,1070
-half_orm_dev-0.17.3a4.dist-info/licenses/AUTHORS,sha256=eWxqzRdLOt2gX0FMQj_wui03Od3jdlwa8xNe9tl84g0,113
-half_orm_dev-0.17.3a4.dist-info/licenses/LICENSE,sha256=ufhxlSi6mttkGQTsGWrEoB3WA_fCPJ6-k07GSVBgyPw,644
-half_orm_dev-0.17.3a4.dist-info/METADATA,sha256=XZ8XlqVBMYhf9Z-PBBfUWGKkvTUwhtWnir80HpWi8RA,16149
-half_orm_dev-0.17.3a4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-half_orm_dev-0.17.3a4.dist-info/top_level.txt,sha256=M5hEsWfn5Kw0HL-VnNmS6Jw-3cwRyjims5a8cr18eTM,13
-half_orm_dev-0.17.3a4.dist-info/RECORD,,
+half_orm_dev-0.17.3a6.dist-info/licenses/AUTHORS,sha256=eWxqzRdLOt2gX0FMQj_wui03Od3jdlwa8xNe9tl84g0,113
+half_orm_dev-0.17.3a6.dist-info/licenses/LICENSE,sha256=ufhxlSi6mttkGQTsGWrEoB3WA_fCPJ6-k07GSVBgyPw,644
+half_orm_dev-0.17.3a6.dist-info/METADATA,sha256=POjMIdgH4C38nJeXy2VOtLR7jknjFrhhUmfrSCyimbQ,16149
+half_orm_dev-0.17.3a6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+half_orm_dev-0.17.3a6.dist-info/top_level.txt,sha256=M5hEsWfn5Kw0HL-VnNmS6Jw-3cwRyjims5a8cr18eTM,13
+half_orm_dev-0.17.3a6.dist-info/RECORD,,

{half_orm_dev-0.17.3a4.dist-info → half_orm_dev-0.17.3a6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any