half-orm-dev 0.17.3a5__py3-none-any.whl → 0.17.3a7__py3-none-any.whl

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/scripts/repair-metadata.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+Repair script for half-orm-dev metadata files.
+
+This script regenerates all metadata-X.Y.Z.sql files with correct hop_release
+entries by:
+1. Clearing half_orm_meta.hop_release (keeping only 0.0.0)
+2. For each version tag (vX.Y.Z or vX.Y.Z-rcN):
+   - Insert the version with the tag's date
+   - Generate metadata-X.Y.Z.sql (or metadata-X.Y.Z-rcN.sql)
+
+Usage:
+    cd /path/to/your/project
+    python /path/to/half-orm-dev/scripts/repair-metadata.py [--dry-run]
+
+Options:
+    --dry-run    Show what would be done without modifying anything
+    --verbose    Show detailed information
+"""
+
+import argparse
+import re
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+
+def get_version_tags() -> List[Tuple[str, str, datetime]]:
+    """
+    Get all version tags with their dates from git.
+
+    Returns:
+        List of (tag_name, version_string, date) tuples sorted by version.
+        tag_name: e.g., "v0.1.0", "v0.1.0-rc1"
+        version_string: e.g., "0.1.0", "0.1.0-rc1"
+        date: datetime object
+    """
+    result = subprocess.run(
+        ['git', 'tag', '--format=%(refname:short) %(creatordate:iso)'],
+        capture_output=True, text=True, check=True
+    )
+
+    tags = []
+    for line in result.stdout.strip().split('\n'):
+        if not line.strip():
+            continue
+
+        parts = line.split(' ', 1)
+        if len(parts) != 2:
+            continue
+
+        tag_name, date_str = parts
+
+        # Match vX.Y.Z or vX.Y.Z-rcN
+        match = re.match(r'^v(\d+\.\d+\.\d+(?:-rc\d+)?)$', tag_name)
+        if not match:
+            continue
+
+        version_str = match.group(1)
+
+        # Parse date (format: "2025-11-21 15:09:14 +0100")
+        try:
+            # Remove timezone for simpler parsing
+            date_part = ' '.join(date_str.split()[:2])
+            date = datetime.strptime(date_part, '%Y-%m-%d %H:%M:%S')
+        except ValueError:
+            continue
+
+        tags.append((tag_name, version_str, date))
+
+    # Sort by version (handle X.Y.Z and X.Y.Z-rcN)
+    def version_key(item):
+        version_str = item[1]
+        # Split base version and rc part
+        if '-rc' in version_str:
+            base, rc = version_str.split('-rc')
+            rc_num = int(rc)
+        else:
+            base = version_str
+            rc_num = 9999  # Production comes after all RCs
+
+        parts = [int(p) for p in base.split('.')]
+        return (*parts, rc_num)
+
+    return sorted(tags, key=version_key)
+
+
+def parse_version_string(version_str: str) -> Tuple[int, int, int, str, str]:
+    """
+    Parse version string into components.
+
+    Args:
+        version_str: e.g., "0.1.0" or "0.1.0-rc1"
+
+    Returns:
+        Tuple of (major, minor, patch, pre_release, pre_release_num)
+    """
+    if '-rc' in version_str:
+        base, rc = version_str.split('-rc')
+        pre_release = 'rc'
+        pre_release_num = rc
+    else:
+        base = version_str
+        pre_release = ''
+        pre_release_num = ''
+
+    parts = base.split('.')
+    return (int(parts[0]), int(parts[1]), int(parts[2]), pre_release, pre_release_num)
+
+
+def find_model_dir() -> Optional[Path]:
+    """Find the .hop/model directory in current working directory."""
+    cwd = Path.cwd()
+    model_dir = cwd / ".hop" / "model"
+
+    if model_dir.is_dir():
+        return model_dir
+    return None
+
+
+def get_database_name() -> Optional[str]:
+    """Get database name from half_orm config."""
+    try:
+        from half_orm.model import Model
+        model = Model._model
+        if model:
+            return model._dbname
+    except:
+        pass
+
+    # Try reading from .hop/config
+    config_path = Path.cwd() / ".hop" / "config"
+    if config_path.exists():
+        import configparser
+        config = configparser.ConfigParser()
+        config.read(config_path)
+        if 'database' in config and 'name' in config['database']:
+            return config['database']['name']
+
+    return None
+
+
+def clear_hop_release_table(db_name: str, dry_run: bool = False) -> None:
+    """
+    Clear hop_release table keeping only 0.0.0.
+
+    Args:
+        db_name: Database name
+        dry_run: If True, only show what would be done
+    """
+    sql = "DELETE FROM half_orm_meta.hop_release WHERE NOT (major = 0 AND minor = 0 AND patch = 0);"
+
+    if dry_run:
+        print(f"Would execute: {sql}")
+        return
+
+    subprocess.run(
+        ['psql', '-d', db_name, '-c', sql],
+        check=True, capture_output=True
+    )
+
+
+def insert_version(db_name: str, major: int, minor: int, patch: int,
+                   pre_release: str, pre_release_num: str,
+                   date: datetime, dry_run: bool = False) -> None:
+    """
+    Insert a version into hop_release table.
+
+    Args:
+        db_name: Database name
+        major, minor, patch: Version components
+        pre_release: 'rc' or ''
+        pre_release_num: RC number or ''
+        date: Release date
+        dry_run: If True, only show what would be done
+    """
+    date_str = date.strftime('%Y-%m-%d')
+    time_str = date.strftime('%H:%M:%S')
+
+    sql = f"""INSERT INTO half_orm_meta.hop_release
+              (major, minor, patch, pre_release, pre_release_num, date, time)
+              VALUES ({major}, {minor}, {patch}, '{pre_release}', '{pre_release_num}', '{date_str}', '{time_str}');"""
+
+    if dry_run:
+        print(f"Would execute: {sql}")
+        return
+
+    subprocess.run(
+        ['psql', '-d', db_name, '-c', sql],
+        check=True, capture_output=True
+    )
+
+
+def generate_metadata_file(db_name: str, version_str: str, model_dir: Path,
+                           dry_run: bool = False) -> Path:
+    """
+    Generate metadata-X.Y.Z.sql file using pg_dump.
+
+    Only keeps COPY blocks to avoid version-specific SET commands
+    and ensure compatibility across PostgreSQL versions.
+
+    Args:
+        db_name: Database name
+        version_str: Version string (e.g., "0.1.0" or "0.1.0-rc1")
+        model_dir: Path to model directory
+        dry_run: If True, only show what would be done
+
+    Returns:
+        Path to generated file
+    """
+    metadata_file = model_dir / f"metadata-{version_str}.sql"
+
+    if dry_run:
+        print(f"Would generate: {metadata_file}")
+        return metadata_file
+
+    # Dump to stdout
+    result = subprocess.run([
+        'pg_dump', db_name,
+        '--data-only',
+        '--table=half_orm_meta.database',
+        '--table=half_orm_meta.hop_release',
+        '--table=half_orm_meta.hop_release_issue',
+    ], check=True, capture_output=True, text=True)
+
+    # Filter to keep only COPY blocks (COPY ... FROM stdin; ... \.)
+    filtered_lines = []
+    in_copy_block = False
+    for line in result.stdout.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))
+
+    return metadata_file
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Regenerate half-orm-dev metadata files from git tags.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__
+    )
+    parser.add_argument(
+        '--dry-run',
+        action='store_true',
+        help='Show what would be done without modifying anything'
+    )
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='Show detailed information'
+    )
+    parser.add_argument(
+        '--database',
+        type=str,
+        help='Database name (auto-detected if not specified)'
+    )
+    parser.add_argument(
+        '--model-dir',
+        type=Path,
+        help='Path to model directory (default: .hop/model)'
+    )
+
+    args = parser.parse_args()
+
+    # Find model directory
+    if args.model_dir:
+        model_dir = args.model_dir
+    else:
+        model_dir = find_model_dir()
+
+    if model_dir is None or not model_dir.is_dir():
+        print("Error: Could not find .hop/model directory", file=sys.stderr)
+        print("Make sure you're in a half-orm-dev managed project directory", file=sys.stderr)
+        sys.exit(1)
+
+    # Get database name
+    db_name = args.database or get_database_name()
+    if not db_name:
+        print("Error: Could not determine database name", file=sys.stderr)
+        print("Use --database option to specify it", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Model directory: {model_dir}")
+    print(f"Database: {db_name}")
+    print()
+
+    if args.dry_run:
+        print("=== DRY RUN MODE - No changes will be made ===")
+        print()
+
+    # Get version tags
+    tags = get_version_tags()
+
+    if not tags:
+        print("No version tags found (expected format: vX.Y.Z or vX.Y.Z-rcN)")
+        sys.exit(0)
+
+    print(f"Found {len(tags)} version tags")
+    print()
+
+    # Step 1: Clear hop_release table (keep 0.0.0)
+    print("Step 1: Clearing hop_release table (keeping 0.0.0)...")
+    clear_hop_release_table(db_name, dry_run=args.dry_run)
+    print("  Done")
+    print()
+
+    # Step 2: Process each version
+    print("Step 2: Processing versions...")
+    for tag_name, version_str, date in tags:
+        major, minor, patch, pre_release, pre_release_num = parse_version_string(version_str)
+
+        if args.verbose:
+            print(f"  {tag_name} -> {version_str} ({date})")
+
+        # Insert version with correct date
+        insert_version(
+            db_name, major, minor, patch,
+            pre_release, pre_release_num, date,
+            dry_run=args.dry_run
+        )
+
+        # Generate metadata file
+        metadata_file = generate_metadata_file(
+            db_name, version_str, model_dir,
+            dry_run=args.dry_run
+        )
+
+        print(f"  ✓ {version_str} ({date.strftime('%Y-%m-%d')})")
+
+    print()
+    print("=" * 50)
+    print(f"Summary:")
+    print(f"  Versions processed: {len(tags)}")
+
+    if not args.dry_run:
+        print()
+        print("Next steps:")
+        print("  1. Review the changes: git status")
+        print("  2. Commit: git add .hop/model/metadata-*.sql && git commit -m 'fix: regenerate metadata files'")
+
+
+if __name__ == "__main__":
+    main()

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-a5
+0.17.3-a7

{half_orm_dev-0.17.3a5.dist-info → half_orm_dev-0.17.3a7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.3a5
+Version: 0.17.3a7
 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.3a5.dist-info → half_orm_dev-0.17.3a7.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=8TrtH5NbTiPCbyoitxCt9d1niU0Dy2FQpTU0Tk6eN44,60150
+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=0CNWDPWEFxvsh-LOwmQYBJrdnemZeKHAor8h-ujNOZU,113418
-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=y931XH1lr3gWvyG3HmKG57MJ1dNev8yovnduThBr1Fo,10
+half_orm_dev/version.txt,sha256=3Ff9bgyfOMEi-lwqWRSvH9yY70F6xBUQBQXzA7QjBbI,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
@@ -35,10 +35,11 @@ half_orm_dev/patches/0/1/0/00_half_orm_meta.database.sql,sha256=gMZ94YlyrftxcqDn
 half_orm_dev/patches/0/1/0/01_alter_half_orm_meta.hop_release.sql,sha256=nhRbDi6sUenvVfOnoRuWSbLEC1cEfzrXbxDof2weq04,183
 half_orm_dev/patches/0/1/0/02_half_orm_meta.view.hop_penultimate_release.sql,sha256=Bd0lXJ6vC0JNe06yqTWYVSrwVDElCI3McSS5pm-Ijlo,306
 half_orm_dev/patches/sql/half_orm_meta.sql,sha256=Vl2YzEWpWdam-tC0ZE8iNMeTRzEHpxtNhdBThbHb2u4,5864
+half_orm_dev/scripts/repair-metadata.py,sha256=qUP4v5I16ONBfI18_mqyrDIOlpTPoa4MozQSy4-N-lg,10248
 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 +51,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.3a5.dist-info/licenses/AUTHORS,sha256=eWxqzRdLOt2gX0FMQj_wui03Od3jdlwa8xNe9tl84g0,113
-half_orm_dev-0.17.3a5.dist-info/licenses/LICENSE,sha256=ufhxlSi6mttkGQTsGWrEoB3WA_fCPJ6-k07GSVBgyPw,644
-half_orm_dev-0.17.3a5.dist-info/METADATA,sha256=a9yyDuOYwjsFEdL7c0zEffJklVMmkhswKOQUHJLG-LU,16149
-half_orm_dev-0.17.3a5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-half_orm_dev-0.17.3a5.dist-info/top_level.txt,sha256=M5hEsWfn5Kw0HL-VnNmS6Jw-3cwRyjims5a8cr18eTM,13
-half_orm_dev-0.17.3a5.dist-info/RECORD,,
+half_orm_dev-0.17.3a7.dist-info/licenses/AUTHORS,sha256=eWxqzRdLOt2gX0FMQj_wui03Od3jdlwa8xNe9tl84g0,113
+half_orm_dev-0.17.3a7.dist-info/licenses/LICENSE,sha256=ufhxlSi6mttkGQTsGWrEoB3WA_fCPJ6-k07GSVBgyPw,644
+half_orm_dev-0.17.3a7.dist-info/METADATA,sha256=w85PxMvXeM6dp9I7qkdppzYR_8bVd3O-6hF3dCfTnG8,16149
+half_orm_dev-0.17.3a7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+half_orm_dev-0.17.3a7.dist-info/top_level.txt,sha256=M5hEsWfn5Kw0HL-VnNmS6Jw-3cwRyjims5a8cr18eTM,13
+half_orm_dev-0.17.3a7.dist-info/RECORD,,

{half_orm_dev-0.17.3a5.dist-info → half_orm_dev-0.17.3a7.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