half-orm 1.0.0rc15__tar.gz → 1.0.0rc17__tar.gz

{half_orm-1.0.0rc15/half_orm.egg-info → half_orm-1.0.0rc17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm
-Version: 1.0.0rc15
+Version: 1.0.0rc17
 Summary: A database-first ORM for PostgreSQL
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License: GPL-3.0

{half_orm-1.0.0rc15 → half_orm-1.0.0rc17}/half_orm/model.py

@@ -53,6 +53,28 @@ def _sql_to_json_type(sql_type: str) -> str:
     base = sql_type.lstrip('_')
     return _SQL_TO_JSON.get(base, 'string')
 
+def _normalize_with_half_orm_meta(value):
+    """Normalize the `with_half_orm_meta` constructor argument.
+
+    Accepts:
+        - True / False: expose every / no half_orm_meta.* relation.
+        - a comma-separated string, or any other iterable of strings, of
+          fully-qualified dotted relation names (e.g.
+          "half_orm_meta.identity.user") — an explicit opt-in allowlist.
+          Note the schema itself may contain dots (it is everything before
+          the LAST dot), but since `classes()`/`desc()` compare against the
+          same "schema.relname" join, no split is actually needed here.
+
+    Returns True, False, or a frozenset of dotted names.
+    """
+    if value is True or value is False:
+        return value
+    if isinstance(value, str):
+        names = {v.strip() for v in value.split(',') if v.strip()}
+    else:
+        names = {str(v).strip() for v in value if str(v).strip()}
+    return frozenset(names) if names else False
+
 register = register_class
 
 class Model:
@@ -71,6 +93,17 @@ class Model:
 
             ``name`` is the only mandatory key when using peer authentication.
         scope (str | None): package name used to resolve registered subclasses.
+        with_half_orm_meta (bool | str | Iterable[str]): controls whether
+            "half_orm_meta.*" relations (half_orm_dev's own metadata schemas)
+            are exposed through :meth:`classes`/:meth:`desc`. ``False``
+            (default): none are exposed. ``True``: all of them are. A
+            comma-separated string, or any other iterable of strings, of
+            fully-qualified dotted relation names (e.g.
+            ``"half_orm_meta.identity.user"``): only those specific
+            relations are exposed — an explicit opt-in allowlist. Exposed
+            half_orm_meta relations are always returned as a generic
+            :meth:`get_relation_class` instance, never imported from a
+            generated package module.
 
     Raises:
         MissingConfigFile: if the configuration file is not found.
@@ -80,12 +113,13 @@ class Model:
     __deja_vu = {}
     _classes_ = {}
     __sql_trace = False
-    def __init__(self, config_file: None, scope: str=None):
+    def __init__(self, config_file: None, scope: str=None, with_half_orm_meta=False):
         self._dbinfo = {}
         self._production_mode = True
         self.__load_config(config_file)
         self._scope = scope and scope.split('.')[0]
         self.__thread_local = threading.local()
+        self.__with_half_orm_meta = _normalize_with_half_orm_meta(with_half_orm_meta)
         self.__schema_generation = 0
         self.__aconn = None
         self.__connect()
@@ -168,10 +202,11 @@ class Model:
         conn.adapters.register_dumper(Null, NullDumper)
         conn.adapters.register_dumper(Field, FieldDumper)
         conn.adapters.register_dumper(dict, JsonbDumper)
-        self.__pg_meta = pg_meta.PgMeta(conn, reload)
+        self.__pg_meta = pg_meta.PgMeta(conn, self.__with_half_orm_meta, reload)
         if reload:
             self.__schema_generation += 1
             self._classes_[self._dbname] = {}
+            self.__deja_vu[self.__dbname] = self
         self.__thread_local.conn = conn
         self.__thread_local.schema_generation = self.__schema_generation
         if self.__dbname not in self.__class__.__deja_vu:
@@ -388,16 +423,42 @@ class Model:
         return self.__aconn
 
     async def _aexecute_query(self, query, values=None):
-        """Internal async query executor — no crud_only check. Called by Relation.__aexecute."""
+        """Internal async query executor — no crud_only check. Called by Relation.__aexecute.
+
+        Mirrors _connection's sync auto-reconnect (see that property's
+        docstring: "Connection dropped unexpectedly (conn.closed):
+        reconnects automatically"). The async connection is only ever
+        opened once, explicitly, via aconnect() (a plain property can't
+        await a reconnect the way _connection does) — so without this, a
+        connection that goes idle-closed between requests (Postgres or an
+        intermediate proxy dropping it) breaks every ho_a* call until the
+        process restarts. Reconnect proactively if already flagged closed,
+        or by reconnecting once and retrying if the drop is only surfaced
+        when the query itself is attempted.
+        """
         values = self._unwrap_values(values)
-        cursor = self._aconnection.cursor(row_factory=dict_row)
-        try:
-            await cursor.execute(query, values)
-        except psycopg.Error as exc:
+
+        def _log_error():
             vals = ''
             if not self._production_mode:
                 vals = f"values: {values}\n"
             utils.error(f"Query execution failed:\nquery: {query}\n{vals}")
+
+        if self.__aconn is not None and self.__aconn.closed:
+            await self.aconnect()
+        try:
+            cursor = self._aconnection.cursor(row_factory=dict_row)
+            await cursor.execute(query, values)
+        except (psycopg.OperationalError, psycopg.InterfaceError):
+            await self.aconnect()
+            try:
+                cursor = self._aconnection.cursor(row_factory=dict_row)
+                await cursor.execute(query, values)
+            except psycopg.Error as exc:
+                _log_error()
+                raise exc
+        except psycopg.Error as exc:
+            _log_error()
             raise exc
         return cursor
 
@@ -722,10 +783,23 @@ class Model:
             package_name = relation[1][0]
             module_name = ".".join(relation[1][1:])
             if module_name.find('half_orm_meta') == 0:
-                continue
-            class_name = pg_meta.camel_case(relation[1][-1])
-            module = importlib.import_module(f".{module_name}", package_name)
-            yield getattr(module, class_name), relation[0]
+                allow = self.__with_half_orm_meta
+                if allow is True or (allow and module_name in allow):
+                    yield self.get_relation_class(module_name), relation[0]
+            else:
+                # getattr() on the freshly imported module reads the actual
+                # (possibly `@register`-ed) class straight from its namespace,
+                # regardless of the model._classes_ registry — which reload
+                # (reconnect(reload=True)) clears without re-running already
+                # imported modules, so get_relation_class() alone could go
+                # stale. Fall back to it only when there's no generated
+                # package to import from, or its conventional class is missing.
+                try:
+                    class_name = pg_meta.camel_case(relation[1][-1])
+                    module = importlib.import_module(f".{module_name}", package_name)
+                    yield getattr(module, class_name), relation[0]
+                except (ModuleNotFoundError, AttributeError):
+                    yield self.get_relation_class(module_name), relation[0]
 
     @property
     def sql_trace(self) -> bool:

{half_orm-1.0.0rc15 → half_orm-1.0.0rc17}/half_orm/pg_meta.py

@@ -207,18 +207,32 @@ class PgMeta:
         meta (_Meta): A singleton instance of the `_Meta` class.
     """
     meta = _Meta()
-    def __init__(self, connection, reload=False):
+    def __init__(self, connection, with_half_orm_meta, reload=False):
         """Initializes a new instance of the `PgMeta` class.
 
         Args:
             connection (psycopg.extensions.connection): A connection object to a PostgreSQL database.
+            with_half_orm_meta (bool | frozenset[str]): already-normalized value
+                from Model — True (expose all half_orm_meta.* relations),
+                False (expose none), or a frozenset of allowed
+                "schema.relname" dotted names (opt-in allowlist).
             reload (bool, optional): A flag indicating whether to reload the metadata from the database. \
             Defaults to False.
         """
         self.__dbname = connection.info.get_parameters()['dbname']
+        self.__with_half_orm_meta = with_half_orm_meta
         if not PgMeta.meta.deja_vu(self.__dbname) or reload:
             self.__load_metadata(connection)
 
+    def __meta_allowed(self, schema, relname):
+        """True if this half_orm_meta.* relation should be exposed by desc()."""
+        allow = self.__with_half_orm_meta
+        if allow is True:
+            return True
+        if not allow:
+            return False
+        return f'{schema}.{relname}' in allow
+
     def metadata(self, dbname):
         """Retrieves the metadata for the specified database name.
 
@@ -354,7 +368,8 @@ class PgMeta:
         ret_val = []
         entry = self.metadata(dbname)['byname']
         for key in entry:
-            if key[1].find('half_orm_meta') == 0: continue
+            if key[1].find('half_orm_meta') == 0 and not self.__meta_allowed(key[1], key[2]):
+                continue
             inh = []
             tablekind = entry[key]['tablekind']
             if entry[key]['inherits']:

{half_orm-1.0.0rc15 → half_orm-1.0.0rc17}/half_orm/relation.py

@@ -31,7 +31,7 @@ from keyword import iskeyword
 import psycopg
 from psycopg.rows import dict_row
 from half_orm import relation_errors
-from half_orm.transaction import Transaction
+from half_orm.transaction import Transaction, AsyncTransaction
 from half_orm.field import Field
 from half_orm import utils
 from half_orm.sql_ast import (
@@ -2061,6 +2061,40 @@ def transaction(fct):
     return wrapper
 
 
+def atransaction(fct):
+    """Async decorator that wraps a Relation coroutine method in a database transaction.
+
+    Async counterpart of :func:`transaction`: drives the model's async
+    connection (see :class:`~half_orm.transaction.AsyncTransaction`)
+    instead of the sync one. The decorated method must be a coroutine
+    function and use ``ho_a*`` methods for its INSERT / UPDATE / DELETE
+    operations — ``await model.aconnect()`` must have been called first.
+
+    Nested ``@atransaction`` calls use PostgreSQL savepoints: a failure in
+    an inner method rolls back only that inner scope.
+
+    Example:
+        transaction decorator usage:
+            ```python
+            from half_orm.relation import atransaction
+
+            @register
+            class Author(blog.get_relation_class('blog.author')):
+                @atransaction
+                async def apublish_many(self, posts):
+                    for title, content in posts:
+                        await self.post_rfk(title=title, content=content).ho_ainsert()
+            ```
+
+    *New in version 0.18.0.*
+    """
+    @wraps(fct)
+    async def wrapper(self, *args, **kwargs):
+        async with AsyncTransaction(self._ho_model):
+            return await fct(self, *args, **kwargs)
+    return wrapper
+
+
 def ho_list(*relations):
     """Combine relations into a single OR predicate, avoiding N SQL queries.
 

{half_orm-1.0.0rc15 → half_orm-1.0.0rc17}/half_orm/transaction.py

@@ -104,3 +104,96 @@ class Transaction:
 
     def is_set(self):
         return self.__transaction.get('level', 0) > 0
+
+
+class AsyncTransaction:
+    """Async context manager for atomic database operations.
+
+    Async counterpart of :class:`Transaction`: drives the model's async
+    connection (``model._aconnection``, set up via ``await
+    model.aconnect()``) instead of the sync one. Wraps one or more
+    ``ho_a*`` operations in a single transaction: commits on success, rolls
+    back on exception. Transactions are tracked per-model-instance (keyed
+    by ``id(model)``) — unlike :class:`Transaction`, there is no per-thread
+    isolation, since asyncio concurrency is task-based rather than
+    thread-based and a model's async connection is only ever driven from
+    one place at a time regardless of which thread runs the event loop.
+
+    Nested ``async with AsyncTransaction(model)`` blocks use PostgreSQL
+    savepoints automatically: an exception in an inner block rolls back
+    only that inner block, leaving the outer transaction intact.
+
+    Args:
+        model (Model): the :class:`~half_orm.model.Model` instance whose
+            async connection should be used.
+
+    Example:
+        Atomic insert of two related rows:
+            ```python
+            from half_orm.transaction import AsyncTransaction
+
+            async with AsyncTransaction(blog):
+                alice = await Author(
+                    first_name='Alice', last_name='Martin',
+                    email='alice@example.com',
+                ).ho_ainsert()
+                await Post(
+                    title='First post', content='Hello world',
+                    author_id=alice['id'],
+                ).ho_ainsert()
+            # both rows are committed, or neither is
+            ```
+
+    *New in version 0.18.0.*
+    """
+
+    __transactions: dict = {}
+
+    def __call__(self, model):
+        transactions = self.__class__.__transactions
+        self.__id = id(model)
+        self.__transaction = None
+        if self.__id not in transactions:
+            transactions[self.__id] = {
+                'level': 0, 'model': model,
+                'sp_counter': 0, 'sp_stack': [],
+            }
+        self.__transaction = transactions[self.__id]
+
+    __init__ = __call__
+
+    async def __aenter__(self):
+        conn = self.__transaction['model']._aconnection
+        if conn.autocommit:
+            await conn.set_autocommit(False)
+        if self.__transaction['level'] > 0:
+            self.__transaction['sp_counter'] += 1
+            sp_name = f'sp_{self.__transaction["sp_counter"]}'
+            self.__transaction['sp_stack'].append(sp_name)
+            async with conn.cursor() as cur:
+                await cur.execute(f'SAVEPOINT {sp_name}')
+        self.__transaction['level'] += 1
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.__transaction['level'] -= 1
+        conn = self.__transaction['model']._aconnection
+        if self.__transaction['level'] > 0:
+            sp_name = self.__transaction['sp_stack'].pop()
+            async with conn.cursor() as cur:
+                if exc_type is not None:
+                    await cur.execute(f'ROLLBACK TO SAVEPOINT {sp_name}')
+                await cur.execute(f'RELEASE SAVEPOINT {sp_name}')
+        else:
+            try:
+                await conn.commit()
+                await conn.set_autocommit(True)
+            except psycopg.Error:
+                await conn.rollback()
+        return False
+
+    @property
+    def level(self):
+        return self.__transaction.get('level')
+
+    def is_set(self):
+        return self.__transaction.get('level', 0) > 0

{half_orm-1.0.0rc15 → half_orm-1.0.0rc17}/half_orm/utils.py

@@ -45,15 +45,25 @@ def write(file_, data, mode='w'):
     with open(file_, mode=mode, encoding='utf-8') as text_io_wrapper:
         return text_io_wrapper.write(data)
 
-def error(msg: str, exit_code: int=None):
+def error(msg: str, exit_code: int=None, show_caller: bool=False):
     "Write error message on stderr and exit if exit is not None"
     sys.stderr.write(f'{Color.bold("half-orm ERROR")}: {Color.red(msg)}')
+    if show_caller:
+        caller = get_caller_info()
+        if caller:
+            sys.stderr.write(f'  {caller["filename"]}:{caller["lineno"]}, in {caller["function"]}\n'
+                             f'  {caller["code_context"]}\n')
     if exit_code:
         sys.exit(exit_code)
 
-def warning(msg: str, context="half-orm"):
+def warning(msg: str, context="half-orm", show_caller: bool=False):
     "Write warning message on stderr"
     sys.stderr.write(f'{Color.bold(context + " WARNING")}: {msg}')
+    if show_caller:
+        caller = get_caller_info()
+        if caller:
+            sys.stderr.write(f'  {caller["filename"]}:{caller["lineno"]}, in {caller["function"]}\n'
+                             f'  {caller["code_context"]}\n')
 
 class TraceDepth: #pragma: no coverage
     "Trace dept class"

half_orm-1.0.0rc17/half_orm/version.txt

@@ -0,0 +1 @@
+1.0.0rc17

{half_orm-1.0.0rc15 → half_orm-1.0.0rc17/half_orm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm
-Version: 1.0.0rc15
+Version: 1.0.0rc17
 Summary: A database-first ORM for PostgreSQL
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License: GPL-3.0

{half_orm-1.0.0rc15 → half_orm-1.0.0rc17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta:__legacy__"
 
 [project]
 name = "half_orm"
-version = "1.0.0rc15"
+version = "1.0.0rc17"
 description = "A database-first ORM for PostgreSQL"
 readme = "README.md"
 license = { text = "GPL-3.0" }

half_orm-1.0.0rc15/half_orm/version.txt

@@ -1 +0,0 @@
-1.0.0rc15