half-orm 0.18.8__tar.gz → 0.18.10__tar.gz

{half_orm-0.18.8/half_orm.egg-info → half_orm-0.18.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: half_orm
-Version: 0.18.8
+Version: 0.18.10
 Summary: A simple PostgreSQL to Python mapper.
 Home-page: https://github.com/half-orm/half-orm
 Author: Joël Maïzi

{half_orm-0.18.8 → half_orm-0.18.10}/half_orm/fkey.py

@@ -119,40 +119,48 @@ class FKey:
     def values(self):
         return [list(elt.values()) for elt in self.__to_relation.ho_select(*self.__fk_names)]
 
-    def set(self, __to=None):
+    def set(self, ho_to_rel=None, **kwargs):
         """Bind this foreign key to a relation, adding a JOIN condition.
 
-        After calling ``.set(other_rel)``, queries on the owning relation
-        automatically include a JOIN against ``other_rel`` filtered by
-        ``other_rel``'s constraints.
+        After calling ``.set(...)``, queries on the owning relation
+        automatically include a JOIN against the related table filtered by
+        the given constraints.
 
-        Called with no argument, ``.set()`` joins against all rows of the
-        related table (tautological predicate) — equivalent to
-        ``.set(RelatedClass())``.
+        Three calling forms — no import of the related class required:
+
+        - ``.set()`` — joins all rows (tautological predicate).
+        - ``.set(field=value, ...)`` — joins with constraints, instantiating
+          the related class internally.
+        - ``.set(rel)`` — joins against an already-built
+          :class:`~half_orm.relation.Relation` instance.
 
         Args:
-            __to (Relation | None): the relation to join against. If omitted,
-                the related table is instantiated with no constraints.
+            ho_to_rel (Relation | None): an existing relation to join against.
+                Mutually exclusive with ``**kwargs``.
+            **kwargs: field constraints forwarded to the related class
+                constructor. Ignored when ``ho_to_rel`` is provided.
 
         Returns:
             self — for chaining.
 
         Raises:
-            RuntimeError: if ``__to`` is not a :class:`~half_orm.relation.Relation` instance.
+            RuntimeError: if ``ho_to_rel`` is not a :class:`~half_orm.relation.Relation` instance.
+            RuntimeError: if ``ho_to_rel`` and ``**kwargs`` are both provided.
             RuntimeError: if setting this FK would create a cycle in the join graph.
 
         Example:
-            is a post whose author's last name starts with 'Mar':
+            Without importing the related class:
                 ```python
                 post = Post()
-                post.author_fk.set(Author(last_name=('like', 'Mar%')))
-                print(post.ho_count())
+                post.author_fk.set()                            # all authors
+                post.author_fk.set(last_name=('like', 'Mar%')) # filtered
                 ```
 
-            join with all rows of the related table:
+            With an existing relation:
                 ```python
                 post = Post()
-                post.author_fk.set()   # equivalent to post.author_fk.set(Author())
+                post.author_fk.set(Author(last_name=('like', 'Mar%')))
+                # equivalent to: Author(last_name=('like', 'Mar%')).post_rfk().ho_count()
                 ```
 
         *New in version 0.18.6:* raises ``RuntimeError`` if setting this FK would create a cycle in the join graph.
@@ -160,8 +168,12 @@ class FKey:
         # pylint: disable=import-outside-toplevel
         from half_orm.relation import Relation
 
-        if __to is None:
-            __to = self.__get_rel(normalize_qrn(self.__fk_fqrn))()
+        if ho_to_rel is not None and kwargs:
+            raise RuntimeError("FKey.set: cannot pass both a Relation and keyword arguments")
+        if ho_to_rel is None:
+            __to = self.__get_rel(normalize_qrn(self.__fk_fqrn))(**kwargs)
+        else:
+            __to = ho_to_rel
         if not issubclass(__to.__class__, Relation):
             raise RuntimeError("Fkey.set excepts an argument of type Relation")
         from_ = self.__relation

{half_orm-0.18.8 → half_orm-0.18.10}/half_orm/relation.py

@@ -429,9 +429,15 @@ class Relation:
     def ho_assert_is_singleton(self):
         """Assert that this predicate identifies exactly one row, without querying the database.
 
-        A predicate is a *singleton* when every field of a unique identifier
-        (primary key or any ``UNIQUE NOT NULL`` constraint) is set with the
-        ``=`` comparator. The check is purely structural — no SQL is executed.
+        A predicate is a *singleton* when:
+
+        * every field of a unique identifier (primary key or any
+          ``UNIQUE NOT NULL`` constraint) is set with the ``=`` comparator, **or**
+        * a FK join constrains a unique identifier of this relation: the fields
+          on *this* side of the join form a PK or UNIQUE NOT NULL, and the
+          corresponding fields on the joined relation are all fixed with ``=``.
+
+        The check is purely structural — no SQL is executed.
 
         Returns:
             self — for chaining before a write operation.
@@ -465,6 +471,22 @@ class Relation:
         for ukey in self._ho_ukeys:
             if _fully_set(ukey):
                 return self
+        # A FK join uniquely identifies self when:
+        #   - the fields on self involved in the join form a PK or UNIQUE NOT NULL, AND
+        #   - the corresponding fields on the joined relation are all fixed with '='.
+        def _all_eq(names, rel):
+            return all(
+                rel._ho_fields.get(n.strip('"')) is not None
+                and rel._ho_fields[n.strip('"')].is_set()
+                and rel._ho_fields[n.strip('"')]._comp() == '='
+                for n in names
+            )
+        for fkey, fk_rel in self._ho_join_to.items():
+            self_fields = frozenset(fkey.names)
+            on_pk = bool(self._ho_pkey) and self_fields == frozenset(self._ho_pkey.keys())
+            on_ukey = any(self_fields == frozenset(uk.keys()) for uk in self._ho_ukeys)
+            if (on_pk or on_ukey) and _all_eq(fkey.fk_names, fk_rel):
+                return self
         if not self._ho_pkey and not self._ho_ukeys:
             raise relation_errors.NotASingletonError(
                 f"{self.__class__.__name__} has no primary key or unique NOT NULL constraint.")
@@ -896,10 +918,24 @@ Fkeys = {"""
     def ho_is_set(self):
         """Return True if one field at least is set or if self has been
         constrained by at least one of its foreign keys or self is the
-        result of a combination of Relations (using set operators).
+        result of a combination of Relations (using set operators) where
+        at least one operand is itself constrained.
         """
-        joined_to = bool(self._ho_join_to)
-        return (joined_to or bool(self._ho_set_operators.operator) or bool(self._ho_neg) or
+        joined_to = any(jt_.ho_is_set() for jt_ in self._ho_join_to.values())
+        op = self._ho_set_operators.operator
+        if op:
+            left_set = self._ho_set_operators.left.ho_is_set()
+            right = self._ho_set_operators.right
+            right_set = right is not None and right.ho_is_set()
+            if op == "or":
+                # A() | B → all rows if any operand is unconstrained
+                set_op_constrained = left_set and right_set
+            else:
+                # "and" / "and not": unconstrained operand is transparent
+                set_op_constrained = left_set or right_set
+        else:
+            set_op_constrained = False
+        return (joined_to or set_op_constrained or bool(self._ho_neg) or
                 bool({field for field in self._ho_fields.values() if field.is_set()}))
 
     def __get_set_fields(self):

half_orm-0.18.10/half_orm/version.txt

@@ -0,0 +1 @@
+0.18.10

{half_orm-0.18.8 → half_orm-0.18.10/half_orm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: half_orm
-Version: 0.18.8
+Version: 0.18.10
 Summary: A simple PostgreSQL to Python mapper.
 Home-page: https://github.com/half-orm/half-orm
 Author: Joël Maïzi

half_orm-0.18.8/half_orm/version.txt

@@ -1 +0,0 @@
-0.18.8