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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a2
+Version: 1.0.0a4
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a4}/half_orm_dev/cli/commands/__init__.py

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

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

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

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

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

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

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

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

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

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

@@ -48,6 +48,8 @@ HO_DATACLASSES = [
 from half_orm.relation import DC_Relation
 from half_orm.field import Field''']
 HO_DATACLASSES_IMPORTS = set()
+HO_TYPEDICTS: list = []
+HO_TYPEDICTS_IMPORTS: set = set()
 INIT_MODULE_TEMPLATE = read_template('init_module_template')
 MODULE_TEMPLATE_1 = read_template('module_template_1')
 MODULE_TEMPLATE_2 = read_template('module_template_2')
@@ -194,7 +196,12 @@ def __gen_dataclass(relation, fkeys):
     # Invert user-defined aliases: constraint_name → alias
     aliases = {constraint: alias for alias, constraint in fkeys.items() if alias != ''}
     for constraint_name, fkey in rel._ho_fkeys.items():
-        attr_name = aliases.get(constraint_name, constraint_name)
+        if constraint_name in aliases:
+            attr_name = aliases[constraint_name]
+        elif constraint_name.startswith('_reverse_fkey_'):
+            attr_name = 'rfk_' + constraint_name[len('_reverse_fkey_'):]
+        else:
+            attr_name = 'fk_' + constraint_name
         try:
             fk_fqrn = list(fkey()._t_fqrn)
             fdc_name = f'DC_{__get_full_class_name(fk_fqrn[1], fk_fqrn[2])}'
@@ -204,6 +211,163 @@ def __gen_dataclass(relation, fkeys):
     return '\n'.join([f'@dataclasses.dataclass\nclass {dc_name}(DC_Relation):'] + fields + post_init)
 
 
+def __get_type_annotation(field) -> tuple:
+    """Return (type_str, extra_imports) for a TypedDict field annotation.
+
+    Array types (SQL prefix '_') map to List[T].
+    """
+    sql_type = field._metadata['fieldtype']
+    is_array = sql_type.startswith('_')
+    base_sql_type = sql_type[1:] if is_array else sql_type
+
+    py_type = SQL_ADAPTER.get(base_sql_type)
+    imports: set = set()
+
+    if py_type is None or py_type is Any:
+        type_str = 'Any'
+    elif py_type.__module__ != 'builtins':
+        imports.add(py_type.__module__)
+        name = py_type.__name__ if hasattr(py_type, '__name__') else 'Any'
+        type_str = f'{py_type.__module__}.{name}'
+    else:
+        type_str = py_type.__name__
+
+    if is_array:
+        return f'List[{type_str}]', imports
+    return type_str, imports
+
+
+def __json_scalar_type(sql_type_name: str) -> str:
+    """Map a JSON schema scalar type name to a Python type string.
+
+    Updates HO_TYPEDICTS_IMPORTS as needed.
+    """
+    py_type = SQL_ADAPTER.get(sql_type_name.lower())
+    if py_type is None or py_type is Any:
+        return 'Any'
+    if py_type.__module__ != 'builtins':
+        HO_TYPEDICTS_IMPORTS.add(py_type.__module__)
+        name = py_type.__name__ if hasattr(py_type, '__name__') else 'Any'
+        return f'{py_type.__module__}.{name}'
+    return py_type.__name__
+
+
+def __gen_json_typedicts(name_prefix: str, schema) -> tuple:
+    """Recursively generate TypedDict classes from a Field.json_schema structure.
+
+    Returns (class_strings, top_class_name).
+    class_strings are in dependency order (nested classes before the class using them).
+
+    YAML value conventions:
+        scalar string  → SQL type name  (e.g. 'text', 'integer', 'uuid')
+        [scalar]       → List[T]
+        [dict]         → List[NestedDict]
+        dict           → NestedDict
+    """
+    if not isinstance(schema, dict):
+        return [], 'Any'
+
+    classes = []
+    fields = []
+
+    for key, val in schema.items():
+        if isinstance(val, str):
+            type_str = __json_scalar_type(val)
+            fields.append(f"    {key}: Optional[{type_str}]")
+        elif isinstance(val, list) and len(val) == 1:
+            item = val[0]
+            if isinstance(item, str):
+                inner = __json_scalar_type(item)
+                fields.append(f"    {key}: Optional[List[{inner}]]")
+            elif isinstance(item, dict):
+                child_prefix = name_prefix + ''.join(w.capitalize() for w in key.split('_'))
+                nested, child_name = __gen_json_typedicts(child_prefix, item)
+                classes.extend(nested)
+                fields.append(f"    {key}: Optional[List['{child_name}']]")
+            else:
+                fields.append(f"    {key}: Optional[Any]")
+        elif isinstance(val, dict):
+            child_prefix = name_prefix + ''.join(w.capitalize() for w in key.split('_'))
+            nested, child_name = __gen_json_typedicts(child_prefix, val)
+            classes.extend(nested)
+            fields.append(f"    {key}: Optional['{child_name}']")
+        else:
+            fields.append(f"    {key}: Optional[Any]")
+
+    class_name = f'{name_prefix}Dict'
+    body = '\n'.join(fields) if fields else '    pass'
+    classes.append(f'class {class_name}(TypedDict, total=False):\n{body}')
+    return classes, class_name
+
+
+def __gen_typedict(relation, fkeys) -> list:
+    """Generate TypedDict class(es) for a relation.
+
+    Returns a list of class strings: nested JSON TypedDicts first, then the main class.
+    FK fields starting with 'rfk_' (reverse) are typed List['TargetDict'];
+    all other FK fields are typed 'TargetDict'.
+    json/jsonb fields with a json_schema generate nested TypedDict classes.
+    """
+    rel = relation()
+    t_qrn = list(rel._t_fqrn)[1:]
+    dict_class_name = f'{__get_full_class_name(*t_qrn)}Dict'
+
+    extra_classes = []
+    fields = []
+    for field_name, field in rel._ho_fields.items():
+        json_schema = getattr(field, 'json_schema', None)
+        if json_schema is not None and isinstance(json_schema, dict):
+            field_cc = ''.join(w.capitalize() for w in field_name.split('_'))
+            json_classes, top_name = __gen_json_typedicts(
+                f'{dict_class_name[:-4]}{field_cc}', json_schema
+            )
+            extra_classes.extend(json_classes)
+            type_str = top_name
+        else:
+            type_str, imports = __get_type_annotation(field)
+            HO_TYPEDICTS_IMPORTS.update(imports)
+        line = f"    {field_name}: Optional[{type_str}]"
+        error = utils.check_attribute_name(field_name)
+        if error:
+            line = f"# {line}  # FIX ME! {error}"
+        fields.append(line)
+
+    aliases = {constraint: alias for alias, constraint in fkeys.items() if alias != ''}
+    for constraint_name, fkey in rel._ho_fkeys.items():
+        if constraint_name in aliases:
+            attr_name = aliases[constraint_name]
+        elif constraint_name.startswith('_reverse_fkey_'):
+            attr_name = 'rfk_' + constraint_name[len('_reverse_fkey_'):]
+        else:
+            attr_name = 'fk_' + constraint_name
+        try:
+            fk_fqrn = list(fkey()._t_fqrn)
+            target_name = f'{__get_full_class_name(fk_fqrn[1], fk_fqrn[2])}Dict'
+        except Exception:
+            target_name = dict_class_name
+        if attr_name.startswith('rfk_'):
+            fields.append(f"    {attr_name}: Optional[List['{target_name}']]")
+        else:
+            fields.append(f"    {attr_name}: Optional['{target_name}']")
+
+    body = '\n'.join(fields) if fields else '    pass'
+    main_class = f'class {dict_class_name}(TypedDict, total=False):\n{body}'
+    return extra_classes + [main_class]
+
+
+def __gen_typedicts(package_dir: str, package_name: str) -> None:
+    with open(os.path.join(package_dir, "ho_typeddicts.py"), "w", encoding='utf-8') as file_:
+        file_.write(f"# TypedDicts for {package_name}\n\n")
+        file_.write("from __future__ import annotations\n")
+        file_.write("from typing import TypedDict, Optional, List, Any\n")
+        td_imports = sorted(HO_TYPEDICTS_IMPORTS)
+        for mod in td_imports:
+            file_.write(f"import {mod}\n")
+        file_.write("\n")
+        for td in HO_TYPEDICTS:
+            file_.write(f"\n{td}\n")
+
+
 def __get_modules_list(dir, files_list, files):
     all_ = []
     for file_ in files:
@@ -394,6 +558,7 @@ def __update_this_module(
                 class_name=class_name))
 
     HO_DATACLASSES.append(__gen_dataclass(rel, existing_fkeys))
+    HO_TYPEDICTS.extend(__gen_typedict(rel, existing_fkeys))
 
     return module_path
 
@@ -469,6 +634,7 @@ def generate(repo):
             # Tests are no longer added to files_list (they live in tests/ directory)
 
     __gen_dataclasses(str(package_dir), package_name)
+    __gen_typedicts(str(package_dir), package_name)
 
     if len(NO_APAPTER):
         print("MISSING ADAPTER FOR SQL TYPE")

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

@@ -2600,6 +2600,16 @@ class ReleaseManager:
                 result['deleted_branches'] = deleted_branches
                 result['migrated_to'] = next_patch_version if migrate_candidates else None
                 result['migrated_patches'] = candidates if migrate_candidates else []
+
+                # Lock migration revert: delete all ho-migration/* tags so that
+                # revert_migration() is no longer possible after going to production.
+                for tag in list(self._repo.hgit._HGit__git_repo.tags):
+                    if tag.name.startswith('ho-migration/'):
+                        self._repo.hgit.delete_local_tag(tag.name)
+                        try:
+                            self._repo.hgit.delete_remote_tag(tag.name)
+                        except Exception:
+                            pass  # remote tag may already be gone
             else:
                 result['branch'] = release_branch
 

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

@@ -621,7 +621,8 @@ class Repo:
         result = {
             'synced_branches': [],
             'skipped_branches': [],
-            'errors': []
+            'errors': [],
+            'branch_commits': {},  # branch → commit SHA of the sync commit created
         }
 
         if not self.hgit:
@@ -798,6 +799,11 @@ class Repo:
                 commit_msg = f"[HOP] Sync .hop/ from {source_branch} ({reason})"
                 self.hgit.commit('-m', commit_msg)
 
+                # Record the SHA of the sync commit for potential revert
+                result['branch_commits'][branch] = (
+                    self.hgit._HGit__git_repo.head.commit.hexsha
+                )
+
                 # Push to remote
                 self.hgit.push_branch(branch)
 
@@ -988,6 +994,11 @@ class Repo:
 
         return result
 
+    def revert_migration(self) -> None:
+        """Revert the most recently tagged migration. Delegates to MigrationManager."""
+        mgr = MigrationManager(self)
+        mgr.revert_migration()
+
     @property
     def base_dir(self):
         "Returns the base dir of the repository"

half_orm_dev-1.0.0a4/half_orm_dev/version.txt

@@ -0,0 +1 @@
+1.0.0-a4

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a2
+Version: 1.0.0a4
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-1.0.0a2 → half_orm_dev-1.0.0a4}/half_orm_dev.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ half_orm_dev/version.txt
 half_orm_dev.egg-info/PKG-INFO
 half_orm_dev.egg-info/SOURCES.txt
 half_orm_dev.egg-info/dependency_links.txt
+half_orm_dev.egg-info/entry_points.txt
 half_orm_dev.egg-info/requires.txt
 half_orm_dev.egg-info/top_level.txt
 half_orm_dev/cli/__init__.py
@@ -36,6 +37,7 @@ half_orm_dev/cli/commands/migrate.py
 half_orm_dev/cli/commands/patch.py
 half_orm_dev/cli/commands/release.py
 half_orm_dev/cli/commands/restore.py
+half_orm_dev/cli/commands/revert_migration.py
 half_orm_dev/cli/commands/set_git_origin.py
 half_orm_dev/cli/commands/sync.py
 half_orm_dev/cli/commands/todo.py
@@ -50,7 +52,6 @@ half_orm_dev/migrations/0/17/4/02_move_patches_to_subdirs.py
 half_orm_dev/migrations/0/17/5/01_update_pyproject_dependency.py
 half_orm_dev/migrations/0/18/0/00_add_async_support.py
 half_orm_dev/migrations/0/18/0/01_update_default_tests.py
-half_orm_dev/migrations/half_orm/BREAKING_CHANGES-1.0.0.md
 half_orm_dev/migrations/hop/BREAKING_CHANGES-1.0.0.md
 half_orm_dev/patches/log
 half_orm_dev/patches/0/1/0/00_half_orm_meta.database.sql

half_orm_dev-1.0.0a4/half_orm_dev.egg-info/entry_points.txt

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

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

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

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

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

half_orm_dev-1.0.0a2/half_orm_dev/version.txt

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