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

half_orm_dev/release_manager.py

@@ -680,6 +680,8 @@ class ReleaseManager:
         """
         Lit les patch IDs d'un fichier de release.
 
+        Format: patch_id:merge_commit (one per line)
+
         Ignore:
         - Lignes vides
         - Commentaires (#)
@@ -695,41 +697,107 @@ class ReleaseManager:
             for line in f:
                 line = line.strip()
                 if line and not line.startswith('#'):
-                    patch_ids.append(line)
+                    patch_id = line.split(':')[0]
+                    patch_ids.append(patch_id)
 
         return patch_ids
 
-    def _apply_release_patches(self, version: str, hotfix=False) -> None:
+    def read_release_patches_with_commits(self, filename: str) -> dict:
+        """
+        Lit les patch IDs et merge_commits d'un fichier de release.
+
+        Format: patch_id:merge_commit (one per line)
+
+        Returns:
+            dict: {patch_id: merge_commit}
+
+        Example:
+            # File content:
+            # 1-premier:ce96282f
+            # 2-second:8e10f11b
+            patches = read_release_patches_with_commits("0.1.0-rc1.txt")
+            # → {"1-premier": "ce96282f", "2-second": "8e10f11b"}
+        """
+        file_path = self._releases_dir / filename
+
+        if not file_path.exists():
+            return {}
+
+        patches = {}
+        with open(file_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    patch_id, merge_commit = line.split(':', 1)
+                    patches[patch_id] = merge_commit
+
+        return patches
+
+    def _apply_release_patches(self, version: str, hotfix=False, force_apply=False) -> None:
         """
         Apply all patches for a release version to the database.
 
-        Restores database from baseline and applies patches in order:
+        If a release schema exists (release-X.Y.Z.sql) and force_apply=False,
+        uses it directly. Otherwise, restores database from baseline and
+        applies patches in order:
         1. All RC patches (rc1, rc2, etc.)
         2. Stage patches
 
+        For staged patches with merge_commit recorded, checks out each commit
+        before applying the patch to ensure the correct Python code context.
+
         Args:
             version: Release version (e.g., "0.1.0")
+            hotfix: If True, skip RC patches (hotfix workflow)
+            force_apply: If True, always apply patches individually even if
+                        release schema exists (used for production validation)
 
         Raises:
             ReleaseManagerError: If patch application fails
         """
-        # Restore database from baseline
+        # Check if release schema exists (new workflow)
+        release_schema_path = self._repo.get_release_schema_path(version)
+        if release_schema_path.exists() and not force_apply:
+            # New workflow: restore from release schema (already contains all staged patches)
+            self._repo.restore_database_from_release_schema(version)
+            return
+
+        # Fallback: old workflow - restore database from baseline
         self._repo.restore_database_from_schema()
 
-        # Apply all RC patches in order
+        current_branch = self._repo.hgit.branch
+
+        # Collect patches already applied from RC files
+        applied_patches = set()
+
+        # Apply all RC patches in order (with merge_commit checkout)
         if not hotfix:
             rc_files = self._get_label_files(version, 'rc')
             for rc_file in rc_files:
-                rc_patches = self.read_release_patches(rc_file.name)
-                for patch_id in rc_patches:
+                rc_patches = self.read_release_patches_with_commits(rc_file.name)
+                for patch_id, merge_commit in rc_patches.items():
+                    if merge_commit:
+                        self._repo.hgit.checkout(merge_commit)
                     self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
+                    applied_patches.add(patch_id)
 
-        # Apply staged patches from TOML file (if in development) or from snapshot (if released)
-        # Try TOML file first (development)
+        # Apply staged patches from TOML file that are NOT already in RC files
+        # (patches added after promote_to_rc)
         release_file = ReleaseFile(version, self._releases_dir)
         if release_file.exists():
             # Development: read from TOML
             stage_patches = release_file.get_patches(status="staged")
+
+            # Apply only patches not already applied from RC
+            for patch_id in stage_patches:
+                if patch_id in applied_patches:
+                    continue  # Already applied from RC file
+
+                merge_commit = release_file.get_merge_commit(patch_id)
+                if merge_commit:
+                    # Checkout the merge commit to have correct Python code
+                    self._repo.hgit.checkout(merge_commit)
+                self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
         else:
             # Production: read from hotfix snapshot if it exists
             # This handles the case where we're applying a hotfix release
@@ -741,8 +809,14 @@ class ReleaseManager:
                 # No patches to apply
                 stage_patches = []
 
-        for patch_id in stage_patches:
-            self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
+            # For production snapshots (no TOML), apply patches without checkout
+            # (merge_commit info not available in .txt files)
+            for patch_id in stage_patches:
+                if patch_id not in applied_patches:
+                    self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
+
+        # Return to original branch
+        self._repo.hgit.checkout(current_branch)
 
     def _collect_all_version_patches(self, version: str) -> List[str]:
         """
@@ -2249,6 +2323,24 @@ class ReleaseManager:
         except Exception as e:
             raise ReleaseManagerError(f"Failed to checkout release branch: {e}")
 
+        # Generate release schema file
+        # Use existing release schema as base if available, otherwise use prod
+        try:
+            base_release = self._find_base_release_schema(version)
+            if base_release:
+                self._repo.restore_database_from_release_schema(base_release)
+            else:
+                self._repo.restore_database_from_schema()
+
+            release_schema_path = self._repo.generate_release_schema(version)
+
+            # Commit release schema on release branch
+            self._repo.hgit.add(str(release_schema_path))
+            self._repo.hgit.commit('-m', f"[HOP] Add release schema for %{version}")
+            self._repo.hgit.push()
+        except Exception as e:
+            raise ReleaseManagerError(f"Failed to generate release schema: {e}")
+
         return {
             'version': version,
             'branch': release_branch,
@@ -2289,6 +2381,53 @@ class ReleaseManager:
         patches_files.sort(key=version_key)
         return patches_files[0].stem.replace('-patches', '')
 
+    def _find_base_release_schema(self, new_version: str) -> Optional[str]:
+        """
+        Find the base release schema for a new release.
+
+        When creating a new release, determines which schema to use as base:
+        - If a release with lower version exists and has a release schema, use it
+        - Otherwise, return None (will use production schema)
+
+        This handles parallel releases:
+        - Creating 0.18.0 (minor) when 0.17.1 (patch) exists → use release-0.17.1.sql
+
+        Note: Only one release per level can exist at a time (sequential promotion rule).
+
+        Args:
+            new_version: Version being created (e.g., "0.18.0")
+
+        Returns:
+            Version string of base release, or None if should use prod schema
+        """
+        from packaging.version import Version
+
+        new_ver = Version(new_version)
+        model_dir = Path(self._repo.model_dir)
+
+        # Find all existing release schema files
+        release_schemas = list(model_dir.glob("release-*.sql"))
+        if not release_schemas:
+            return None
+
+        # Find the release with highest version lower than new_version
+        best_match = None
+        best_ver = None
+
+        for schema_file in release_schemas:
+            match = re.match(r'release-(\d+\.\d+\.\d+)\.sql$', schema_file.name)
+            if match:
+                ver_str = match.group(1)
+                try:
+                    ver = Version(ver_str)
+                    if ver < new_ver and (best_ver is None or ver > best_ver):
+                        best_ver = ver
+                        best_match = ver_str
+                except Exception:
+                    continue
+
+        return best_match
+
     @with_dynamic_branch_lock(lambda self: "ho-prod")
     def promote_to_rc(self) -> dict:
         """
@@ -2355,10 +2494,14 @@ class ReleaseManager:
             # Stay on release branch for rename operations
             # (allows continued development on this release)
 
-            # Create RC snapshot from staged patches
+            # Create RC snapshot from staged patches (with merge_commit)
             rc_file = self._releases_dir / f"{version}-rc{rc_number}.txt"
             staged_patches = release_file.get_patches(status="staged")
-            rc_file.write_text("\n".join(staged_patches) + "\n" if staged_patches else "", encoding='utf-8')
+            lines = []
+            for patch_id in staged_patches:
+                merge_commit = release_file.get_merge_commit(patch_id)
+                lines.append(f"{patch_id}:{merge_commit}" if merge_commit else patch_id)
+            rc_file.write_text("\n".join(lines) + "\n" if lines else "", encoding='utf-8')
 
             # Keep TOML file for continued development (don't delete it)
 
@@ -2498,29 +2641,13 @@ class ReleaseManager:
                         "ho-prod has been restored to its previous state."
                     )
 
-            # 3. Apply only NEW patches from TOML file (if any) and generate schema
-            # Note: RC patches have already been applied during promote_to_rc
-            stage_patches = release_file.get_patches(status="staged")
-
-            if stage_patches:
-                # There are new patches after RC - apply them
-                # First, restore from latest RC schema
-                latest_rc = self._get_latest_label_number(version, "rc")
-                rc_schema_version = f"{version}-rc{latest_rc}" if latest_rc > 0 else "0.0.0"
-
-                # Restore from RC schema if it exists, otherwise from baseline
-                try:
-                    self._repo.restore_database_from_schema(rc_schema_version)
-                except:
-                    self._repo.restore_database_from_schema()
-
-                # Apply new stage patches
-                for patch_id in stage_patches:
-                    self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
-            else:
-                # No new patches - just restore from latest RC
-                # The database should already be in the correct state from RC
-                pass
+            # 3. Apply all patches (RC + staged) to database
+            # Uses _apply_release_patches which handles:
+            # - Reading RC files with merge_commits (patch_id:merge_commit format)
+            # - Checking out each merge_commit before applying patch
+            # - Reading staged patches from TOML with merge_commits
+            # force_apply=True to validate by applying patches even if release schema exists
+            self._apply_release_patches(version, force_apply=True)
 
             # Register the release version in half_orm_meta.hop_release
             version_parts = version.split('.')
@@ -2542,6 +2669,11 @@ class ReleaseManager:
             if toml_file.exists():
                 toml_file.unlink()
 
+            # Delete release schema file (no longer needed - prod schema takes over)
+            release_schema_file = model_dir / f"release-{version}.sql"
+            if release_schema_file.exists():
+                release_schema_file.unlink()
+
             # 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)

half_orm_dev/repo.py

@@ -1199,10 +1199,7 @@ class Repo:
         # Step 1b: Validate git origin URL (EARLY validation)
         self._validate_git_origin_url(git_origin)
 
-        # Step 2: Check database configuration exists
-        self._verify_database_configured(package_name)
-
-        # Step 3: Connect to database and detect mode
+        # Step 2: Connect to database and detect mode
         devel_mode = self._detect_development_mode(package_name)
 
         # Step 4: Setup project directory
@@ -1645,56 +1642,6 @@ class Repo:
         # Store normalized name for later use
         return normalized_name
 
-
-    def _verify_database_configured(self, package_name):
-        """
-        Verify database is configured via init-database command.
-
-        Checks that database configuration file exists and is accessible.
-        Does NOT create the database - assumes init-database was run first.
-
-        Args:
-            package_name (str): Database name to verify
-
-        Raises:
-            DatabaseNotConfiguredError: If configuration file doesn't exist
-            DatabaseConnectionError: If cannot connect to configured database
-
-        Process:
-            1. Check ~/.half_orm/<package_name> exists
-            2. Attempt connection to verify database is accessible
-            3. Store connection for later use
-
-        Examples:
-            # Database configured
-            _verify_database_configured("my_blog")  # Success
-
-            # Database not configured
-            _verify_database_configured("unconfigured_db")
-            # Raises: DatabaseNotConfiguredError with helpful message
-        """
-        # Try to load database configuration
-        config = Database._load_configuration(package_name)
-
-        if config is None:
-            raise ValueError(
-                f"Database '{package_name}' is not configured.\n"
-                f"Please run: half_orm dev init-database {package_name} [OPTIONS]\n"
-                f"See 'half_orm dev init-database --help' for more information."
-            )
-
-        # Try to connect to verify database is accessible
-        try:
-            model = Model(package_name)
-            # Store model for later use
-            return model
-        except OperationalError as e:
-            raise OperationalError(
-                f"Cannot connect to database '{package_name}'.\n"
-                f"Database may not exist or connection parameters may be incorrect.\n"
-                f"Original error: {e}"
-            )
-
     def _detect_development_mode(self, package_name):
         """
         Detect development mode based on metadata presence in database.
@@ -2335,6 +2282,130 @@ See docs/half_orm_dev.md for complete documentation.
             # Catch any unexpected errors
             raise RepoError(f"Database restoration failed: {e}") from e
 
+    def generate_release_schema(self, version: str) -> Path:
+        """
+        Generate release schema SQL dump.
+
+        Creates .hop/model/release-{version}.sql with current database structure,
+        metadata, and data. This file represents the complete state of a release
+        in development (prod + all staged patches).
+
+        Used by:
+        - release create: Generate initial release schema from prod baseline
+        - patch merge: Update release schema after patch integration
+
+        Args:
+            version: Release version string (e.g., "0.17.1", "0.18.0")
+
+        Returns:
+            Path to generated release schema file
+
+        Raises:
+            RepoError: If pg_dump fails or model_dir doesn't exist
+
+        Examples:
+            # After merging patch into release
+            schema_path = repo.generate_release_schema("0.17.1")
+            # Creates: .hop/model/release-0.17.1.sql
+        """
+        model_dir = Path(self.model_dir)
+
+        if not model_dir.exists():
+            raise RepoError(f"Model directory does not exist: {model_dir}")
+
+        release_schema_file = model_dir / f"release-{version}.sql"
+        temp_file = model_dir / f".release-{version}.sql.tmp"
+
+        try:
+            # Dump complete database (schema + data) to temp file
+            self.database.execute_pg_command(
+                'pg_dump',
+                self.name,
+                '--no-owner',
+                '-f',
+                str(temp_file)
+            )
+
+            # Filter out version-specific lines for cross-version compatibility
+            content = temp_file.read_text()
+            filtered_lines = []
+            version_specific_sets = (
+                'SET transaction_timeout',  # PG17+
+            )
+            for line in content.split('\n'):
+                if line.startswith('\\restrict') or line.startswith('\\unrestrict'):
+                    continue
+                if line.startswith('-- Dumped from') or line.startswith('-- Dumped by'):
+                    continue
+                if any(line.startswith(s) for s in version_specific_sets):
+                    continue
+                filtered_lines.append(line)
+
+            release_schema_file.write_text('\n'.join(filtered_lines))
+
+            return release_schema_file
+
+        except Exception as e:
+            raise RepoError(f"Failed to generate release schema: {e}") from e
+        finally:
+            if temp_file.exists():
+                temp_file.unlink()
+
+    def restore_database_from_release_schema(self, version: str) -> None:
+        """
+        Restore database from release schema file.
+
+        Restores database from .hop/model/release-{version}.sql which contains
+        the complete state of a release in development (prod + staged patches).
+
+        If the release schema file doesn't exist, falls back to
+        restore_database_from_schema() for backward compatibility.
+
+        Args:
+            version: Release version string (e.g., "0.17.1")
+
+        Raises:
+            RepoError: If restoration fails
+
+        Examples:
+            # Before applying a candidate patch
+            repo.restore_database_from_release_schema("0.17.1")
+            # Database now has prod schema + all staged patches for 0.17.1
+        """
+        release_schema_path = Path(self.model_dir) / f"release-{version}.sql"
+
+        # Fallback to production schema if release schema doesn't exist
+        if not release_schema_path.exists():
+            self.restore_database_from_schema()
+            return
+
+        try:
+            # Drop all user schemas
+            self._reset_database_schemas()
+
+            # Load release schema
+            self.database.execute_pg_command(
+                'psql', '-d', self.name, '-f', str(release_schema_path)
+            )
+
+            # Reload half_orm metadata cache
+            self.model.reconnect(reload=True)
+
+        except Exception as e:
+            raise RepoError(f"Failed to restore from release schema: {e}") from e
+
+    def get_release_schema_path(self, version: str) -> Path:
+        """
+        Get path to release schema file.
+
+        Args:
+            version: Release version string
+
+        Returns:
+            Path to .hop/model/release-{version}.sql (may not exist)
+        """
+        return Path(self.model_dir) / f"release-{version}.sql"
+
     def _deduce_metadata_path(self, schema_path: Path) -> Path | None:
         """
         Deduce metadata file path from schema.sql symlink target.

half_orm_dev/version.txt

@@ -1 +1 @@
-0.17.3-a7
+0.17.3-a9

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.3a7
+Version: 0.17.3a9
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later
@@ -23,7 +23,7 @@ Requires-Dist: GitPython
 Requires-Dist: click
 Requires-Dist: pydash
 Requires-Dist: pytest
-Requires-Dist: half_orm<0.18.0,>=0.17.1
+Requires-Dist: half_orm<0.18.0,>=0.17.3
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Requires-Dist: tomli_w>=1.0.0
 Dynamic: license-file

{half_orm_dev-0.17.3a7.dist-info → half_orm_dev-0.17.3a9.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=0sq96tseMUWAluoxoxwbTIJrzvBYMzW163D8Ssdj73g,62793
+half_orm_dev/database.py,sha256=bV7QpgT6R-LpCJcaAKOo5qJ0jD03JenSoLV4f7ZdTag,56377
 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=HAnQR4m8E0hyKCpPme_XiHI4K7qFkCT2DvSgCaa524s,100993
+half_orm_dev/patch_manager.py,sha256=yFVaSDid6VJAclQre-J-QWjyDIDNHi6EzRybtMEguow,110669
 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=AXjjtIWAdv0yy6DkP_eGYKqDDvejmbxnz_QiMRLvwws,125510
-half_orm_dev/repo.py,sha256=h-nsB6z2xph9ortO02g9DcPXeef9Rk2D5WI3Yc3h1M4,98253
+half_orm_dev/release_file.py,sha256=2sfWYqjqfOuMtPDH6qNanXUD9UMaZ7yt912o6aZ0GYI,10570
+half_orm_dev/release_manager.py,sha256=IBjQ26ostzXYu5PF-cx-Z7Wezt8SpG9SkeoTnTNFt2c,130985
+half_orm_dev/repo.py,sha256=W14IR-G737QgVgWV6FMC3zVJfG87X9VbzOC3DLJoJng,100601
 half_orm_dev/utils.py,sha256=M3yViUFfsO7Cp9MYSoUSkCZ6R9w_4jW45UDZUOT8FhI,1493
-half_orm_dev/version.txt,sha256=3Ff9bgyfOMEi-lwqWRSvH9yY70F6xBUQBQXzA7QjBbI,10
+half_orm_dev/version.txt,sha256=mcwJgjmZIdLLkWl4QWMi2Zy-eHfrnal7--Y_GUibulg,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
@@ -30,6 +30,7 @@ half_orm_dev/cli/commands/update.py,sha256=OarpDkC8hF08UUv1l2i-2qpHICgpB6WDn9ziY
 half_orm_dev/cli/commands/upgrade.py,sha256=9puvnanp6D2n3cQGcmK1-AI6Z_GlTYPZcaZgN1m5wDE,6297
 half_orm_dev/migrations/0/17/1/00_move_to_hop.py,sha256=esXYcdgNUJfUQUCtD_BBxHbdQi7_s4nWJ8bJYNIUfY4,4000
 half_orm_dev/migrations/0/17/1/01_txt_to_toml.py,sha256=CJQo4-DTI0tPBD6VXNo0HsNkG2fkSxHAcQ-5cwXVt_4,4995
+half_orm_dev/migrations/0/17/4/00_toml_dict_format.py,sha256=5LYVExrAhVmS_Fkp2uhs9j5xtWrp3FhzDhrwn3_CQdI,6224
 half_orm_dev/patches/log,sha256=n7MNnGR09Obd87gXLzIi6zA76sI4RhOJzC25wb0TbKE,22
 half_orm_dev/patches/0/1/0/00_half_orm_meta.database.sql,sha256=gMZ94YlyrftxcqDn0l-ToCTee4A_bnP58DpHcIT_T1w,1074
 half_orm_dev/patches/0/1/0/01_alter_half_orm_meta.hop_release.sql,sha256=nhRbDi6sUenvVfOnoRuWSbLEC1cEfzrXbxDof2weq04,183
@@ -51,9 +52,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.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.3a9.dist-info/licenses/AUTHORS,sha256=eWxqzRdLOt2gX0FMQj_wui03Od3jdlwa8xNe9tl84g0,113
+half_orm_dev-0.17.3a9.dist-info/licenses/LICENSE,sha256=ufhxlSi6mttkGQTsGWrEoB3WA_fCPJ6-k07GSVBgyPw,644
+half_orm_dev-0.17.3a9.dist-info/METADATA,sha256=5j_555Q9_75zj0GZADXj-PUEf-lXJ7xL-v5tZJzWO7w,16149
+half_orm_dev-0.17.3a9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+half_orm_dev-0.17.3a9.dist-info/top_level.txt,sha256=M5hEsWfn5Kw0HL-VnNmS6Jw-3cwRyjims5a8cr18eTM,13
+half_orm_dev-0.17.3a9.dist-info/RECORD,,