sincpro-framework 3.28.0__tar.gz → 3.28.2__tar.gz

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sincpro-framework
-Version: 3.28.0
+Version: 3.28.2
 Summary: Sincpro framework to use DDD, Clean architecture, Hexagonal architecture
 License: MIT
 License-File: LICENSE.md

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sincpro-framework"
-version = "3.28.0"
+version = "3.28.2"
 description = "Sincpro framework to use DDD, Clean architecture, Hexagonal architecture"
 authors = ["Gutierrez Andres <andru1236@gmail.com>"]
 readme = "README.md"

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/context/domain/drafts.py

@@ -16,7 +16,7 @@ after an expiry — so a tab still holding an old one cannot win.
 
 The draft is not the record. Activating it is the project's Command: read the stored record,
 `refuse_stale(draft, record)` (`sincpro_framework.ddd`) — a record changed since the draft started
-is `StaleAggregate` — then `assign(record, draft.values)`, save it and discard the draft.
+is `StaleAggregate` — then `apply_values(record, draft.values)`, save it and discard the draft.
 """
 
 from datetime import datetime

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/adapters/numbering.py

@@ -139,7 +139,7 @@ class DatabaseNumbering(INumbering):
 
             numbering.take("F", count=3, scope="branch-1/2026")   ->  range(41, 44)
 
-        1. Refused inside `previewing()` and for a count below one.
+        1. Refused inside `read_only()` and for a count below one.
         2. The session: the unit of work in play (refused when read-only), or a transaction of
            its own, warned in the log.
         3. The counter moved in one statement where the dialect has an upsert (Postgres,

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/domain/relations.py

@@ -15,7 +15,7 @@ from sqlalchemy import Table
 
 from sincpro_framework.ddd.criteria import Criteria
 from sincpro_framework.ddd.entity import relations
-from sincpro_framework.ddd.entity.relations import Resolver
+from sincpro_framework.ddd.entity.relations import RelationKind, Resolver
 
 REPOSITORY = "sincpro_repository"
 """The key under which a unit of work leaves its repository on the session, so a relation
@@ -135,7 +135,7 @@ class TableRelation(relations.Relation):
 
     def __init__(
         self,
-        kind: str,
+        kind: RelationKind | str,
         related: type,
         identified_by: str = "",
         resolver: Resolver | None = None,
@@ -152,7 +152,7 @@ class TableRelation(relations.Relation):
         every kind's options at once. `through` and `related_key` are read by `many_to_many`
         only; `owned` and `orphans` by a to-many `foreign_key` only.
 
-            TableRelation("many_to_many", Tag, "dataset_id", through=dataset_tag,
+            TableRelation(RelationKind.MANY_TO_MANY, Tag, "dataset_id", through=dataset_tag,
                      related_key="tag_id")
                 ->  as TableRelation.many_to_many(Tag, dataset_tag, "dataset_id", "tag_id")
 
@@ -203,7 +203,7 @@ class TableRelation(relations.Relation):
         own its parent, and `owned` is read only on a to-many.
         """
         return cls(
-            "foreign_key",
+            RelationKind.FOREIGN_KEY,
             related,
             identified_by,
             scope=scope,
@@ -226,7 +226,7 @@ class TableRelation(relations.Relation):
         """Same database: the pairs live in `through`, `this_key` pointing here and
         `related_key` pointing at the related aggregate."""
         return cls(
-            "many_to_many",
+            RelationKind.MANY_TO_MANY,
             related,
             this_key,
             through=through,
@@ -239,4 +239,4 @@ class TableRelation(relations.Relation):
         cls, related: type, identified_by: str, scope: Criteria | None = None
     ) -> "TableRelation":
         """Same database, no foreign key: this aggregate holds a list of the related ids."""
-        return cls("id_list", related, identified_by, scope=scope)
+        return cls(RelationKind.ID_LIST, related, identified_by, scope=scope)

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/infrastructure/database.py

@@ -38,7 +38,7 @@ from sincpro_framework.data_layer.orm.sqlalchemy.infrastructure.read_tracking im
 from sincpro_framework.data_layer.orm.sqlalchemy.infrastructure.transaction_hooks import (
     install as hooks_per_transaction,
 )
-from sincpro_framework.ddd.editing.preview import is_previewing
+from sincpro_framework.ddd.editing.preview import is_read_only
 from sincpro_framework.ddd.entity import utc_now
 from sincpro_framework.ddd.repositories.repository import refuse_writing_in_preview
 
@@ -276,7 +276,7 @@ class Database:
 
 
 def _refused_in_preview(session: Session) -> None:
-    """A flush with something to write, inside `previewing()`, is refused: `record_changes`,
+    """A flush with something to write, inside `read_only()`, is refused: `record_changes`,
     the commit of a unit of work tracking changes, a record added to the session by hand.
 
     Outside the guard: a statement sent on a raw connection, and a thread started without the
@@ -306,14 +306,14 @@ def _reads_only(sql: str) -> bool:
 
 
 def _statement_refused_in_preview(state: Any) -> None:
-    """A statement sent through a session inside `previewing()` that writes or locks is refused:
+    """A statement sent through a session inside `read_only()` that writes or locks is refused:
     an INSERT, UPDATE or DELETE, a text statement that is not a read, a read that locks rows.
 
         UPDATE … / text("DELETE …")             →  ProgrammingError
         SELECT … FOR UPDATE                      →  ProgrammingError
         SELECT … / text("SELECT …")             →  runs, without an autoflush
     """
-    if not is_previewing():
+    if not is_read_only():
         return
     if state.is_select:
         # A read inside a preview never flushes what the unit of work holds pending: that

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/services/aggregation.py

@@ -20,6 +20,7 @@ from sincpro_framework.ddd.criteria import (
     Grouping,
     GroupingLevel,
     Measure,
+    MeasureFunction,
     PivotCell,
     Resolution,
 )
@@ -50,7 +51,7 @@ NATIVE_BOOLEAN_FOLDS = frozenset({"postgresql", "duckdb"})
 them» is a minimum of 1 and «any of them» a maximum of 1."""
 
 
-def _boolean_fold(function: str, column: Any, dialect: str) -> Any:
+def _boolean_fold(function: MeasureFunction, column: Any, dialect: str) -> Any:
     """`bool_and` / `bool_or` over a boolean column, in the dialect's own words.
 
     in      bool_and, Invoice.paid, "postgresql"   →  out  bool_and(invoice.paid)
@@ -58,7 +59,9 @@ def _boolean_fold(function: str, column: Any, dialect: str) -> Any:
     """
     if dialect in NATIVE_BOOLEAN_FOLDS:
         return getattr(func, function)(column)
-    return (func.min(column) if function == "bool_and" else func.max(column)) == 1
+    return (
+        func.min(column) if function is MeasureFunction.BOOL_AND else func.max(column)
+    ) == 1
 
 
 def measure_columns(
@@ -99,19 +102,19 @@ def measure_columns(
         meta.field(measure.field)
         column = sql_translator.column_attribute(model, measure.field)
 
-        if measure.function == "count_distinct":
+        if measure.function is MeasureFunction.COUNT_DISTINCT:
             columns.append(func.count(distinct(column)).label(name))
-        elif measure.function in ("percentile", "median"):
+        elif measure.function in (MeasureFunction.PERCENTILE, MeasureFunction.MEDIAN):
             if dialect in WITHOUT_PERCENTILES:
                 raise exceptions.InvalidCriteria(
                     f"'{dialect}' does not compute percentiles; ask for one over a database "
                     "that does, or answer it in memory"
                 )
-            fraction = 0.5 if measure.function == "median" else measure.argument
+            fraction = 0.5 if measure.function is MeasureFunction.MEDIAN else measure.argument
             columns.append(
                 func.percentile_cont(fraction).within_group(column.asc()).label(name)
             )
-        elif measure.function in ("bool_and", "bool_or"):
+        elif measure.function in (MeasureFunction.BOOL_AND, MeasureFunction.BOOL_OR):
             Grouping(measures={name: measure}).check_measures(
                 {measure.field: meta.field(measure.field).type.value}
             )

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/services/cascade.py

@@ -52,7 +52,7 @@ from sincpro_framework.data_layer.orm.sqlalchemy.services.model_introspection im
 )
 from sincpro_framework.data_layer.orm.sqlalchemy.services.upsert import unique_on
 from sincpro_framework.ddd.entity.entity_collection import identity_name, identity_of
-from sincpro_framework.ddd.entity.relations import key_pair
+from sincpro_framework.ddd.entity.relations import RelationKind, key_pair
 from sincpro_framework.sincpro_logger import logger
 
 WRITTEN = {Held.ASSIGNED: Held.WHOLE, Held.BLIND: Held.CUT}
@@ -228,7 +228,11 @@ def owned_by(model: type) -> list[Owned]:
     owned: list[Owned] = []
     for name, relation in mapping_registry.relations_of(model).items():
         declared = meta.fields.get(name)
-        to_many = declared is not None and declared.many and relation.kind == "foreign_key"
+        to_many = (
+            declared is not None
+            and declared.many
+            and relation.kind is RelationKind.FOREIGN_KEY
+        )
         if not to_many or getattr(relation, "owned", True) is False:
             continue
         here, there = key_pair(meta.identity, relation, many=True)
@@ -258,7 +262,7 @@ def linked_by(model: type) -> list[Linked]:
     for name, relation in mapping_registry.relations_of(model).items():
         through = getattr(relation, "through", None)
         related_key = getattr(relation, "related_key", None)
-        if relation.kind == "many_to_many" and through is not None and related_key:
+        if relation.kind is RelationKind.MANY_TO_MANY and through is not None and related_key:
             linked.append(Linked(name, through, relation.identified_by, related_key))
     return linked
 
@@ -357,6 +361,29 @@ def _refuse_a_child_removed_before(records: list[Any]) -> None:
             )
 
 
+def _refuse_a_reference_not_stored(plan: Plan, saved: set[int]) -> None:
+    """A many-to-many that references a record never stored is refused before any statement:
+    a pair points at a row, and a reference never writes the record it names — so the pair
+    would point at nothing, silently on an engine that does not check its foreign keys.
+
+        Ticket(labels=[Label(name="new")]); save(ticket)
+            ->  ProgrammingError: Ticket.labels references Label 0192…, which is not stored …
+        save([label, ticket])       ->  written: the label is part of this save
+
+    Context: a form never reaches here with one — the ids it sends are read from the store
+    (`EntityReads.referenced`); it is the domain building a reference by hand.
+    """
+    for record, name in plan.linked:
+        for one in HeldRelations(record).value(name) or ():
+            if getattr(one, "is_new", False) and id(one) not in saved:
+                raise exceptions.ProgrammingError(
+                    f"{type(record).__name__}.{name} references {type(one).__name__} "
+                    f"{identity_of(one)}, which is not stored: a many-to-many links stored "
+                    f"records — save the {type(one).__name__} first, or in the same call: "
+                    f"save([{type(one).__name__.lower()}, {type(record).__name__.lower()}])"
+                )
+
+
 def _paired(session: Session, plan: Plan, record: Any, linked: Linked, how: Held) -> bool:
     """The pairs one many-to-many of `record` inserts and deletes, put on the plan; whether it
     changes any.
@@ -420,7 +447,8 @@ def planned_save(session: Session, records: list[Any]) -> Plan:
             ->  Plan(writes=[invoice, l1], moved=[]): a new root has no version to raise
 
     1. Walk each root and, through every relation it writes, its children, depth first: the
-       roots are always written, a child only when it is new or changed.
+       roots are always written, a child only when it is new or changed; a many-to-many may
+       reference only stored records, or records of this same save.
        1.1 Each child gets the root's key on the field that holds it.
        1.2 A relation nobody read is skipped; a read one only saves what it holds; a blind
            assignment does the same and is logged.
@@ -490,6 +518,7 @@ def planned_save(session: Session, records: list[Any]) -> Plan:
     for one in records:
         visit(one, explicit=True, root=one)
     _refuse_a_child_removed_before(plan.writes)
+    _refuse_a_reference_not_stored(plan, seen)
 
     orphans: list[Any] = []
     for (owner, name), (owned, read_by_key) in settling.items():

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/services/data_mapper.py

@@ -44,14 +44,14 @@ from sincpro_framework.data_layer.orm.sqlalchemy.services.relation_resolver impo
     resolve_whole,
 )
 from sincpro_framework.ddd.entity import relations
-from sincpro_framework.ddd.entity.computed import computations_of
+from sincpro_framework.ddd.entity.computed import computed_fields_of
 from sincpro_framework.ddd.entity.entity_collection import identity_name
 from sincpro_framework.ddd.entity.entity_meta import (
     annotations_of,
     related_class,
     without_optional,
 )
-from sincpro_framework.ddd.entity.relations import key_pair
+from sincpro_framework.ddd.entity.relations import RelationKind, key_pair
 from sincpro_framework.ddd.query import serialising
 
 
@@ -64,6 +64,8 @@ class RelatedAttribute:
 
     A data descriptor, so it wins over the value a dataclass `__init__` stores: a record built
     in memory holds what its constructor was given, a record the mapper loaded starts unresolved.
+    It is the vocabulary's `RelationAttribute`: `joined_by`, `holds_whole`, `held_in_part` and
+    `named_by_id` are what the domain asks it, without reading anything.
     """
 
     def __init__(
@@ -163,7 +165,7 @@ class RelatedAttribute:
         """Whether a save of the record writes this relation — the only case its reading is
         worth a query before an assignment."""
         if (
-            self.relation.kind != "foreign_key"
+            self.relation.kind is not RelationKind.FOREIGN_KEY
             or getattr(self.relation, "owned", None) is False
         ):
             return False
@@ -177,7 +179,7 @@ class RelatedAttribute:
             Sale.lines       →  ("id", "sale_id")    a new line takes the sale's id
             Sale.customer    →  None                 another aggregate, not written from here
 
-        What `assign` asks before building a line a form sent without its key: the form cannot
+        What `apply_values` asks before building a line a form sent without its key: the form cannot
         know it, least of all for a sale that is not stored yet.
         """
         if not self._written_by_root(record):
@@ -192,10 +194,10 @@ class RelatedAttribute:
             Sale.lines       →  False    the lines are parts, sent whole
             Run.dataset      →  False
 
-        What `EntityReads.referenced` asks before `assign`: the ids a form sends are read as the
+        What `EntityReads.referenced` asks before `apply_values`: the ids a form sends are read as the
         records they name.
         """
-        return self.relation.kind == "many_to_many"
+        return self.relation.kind is RelationKind.MANY_TO_MANY
 
     def __set__(self, record: Any, value: Any) -> None:
         """An assignment replaces the set. Context: inside a unit of work, a stored record whose
@@ -307,7 +309,7 @@ def computed_properties(entity: type, table: Table) -> dict[str, Any]:
     refused here, at boot, naming the field and the column, and not on the first query.
     """
     found: dict[str, Any] = {}
-    for name, computation in computations_of(entity).items():
+    for name, computation in computed_fields_of(entity).items():
         if computation.sql is None:
             continue
         try:

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/services/model_introspection.py

@@ -47,18 +47,19 @@ from sincpro_framework.ddd.entity.entity_meta import (
     with_computed,
     without_optional,
 )
-from sincpro_framework.ddd.entity.relations import key_pair
+from sincpro_framework.ddd.entity.relations import RelationKind, key_pair
 from sincpro_framework.ddd.multi_language import MultiLanguage
 
 
-def _relational_type(kind: str, many: bool) -> FieldType:
-    """The field type a relation is described as.
+def _relational_type(kind: RelationKind | None, many: bool) -> FieldType:
+    """The field type a relation is described as; one nothing declared (`None`) is read by its
+    cardinality, as a foreign key is.
 
-    ("many_to_many", _)       ->  MANY2MANY
-    ("foreign_key", True)     ->  ONE2MANY
-    ("foreign_key", False)    ->  MANY2ONE
+    (MANY_TO_MANY, _)         ->  MANY2MANY
+    (FOREIGN_KEY, True)       ->  ONE2MANY
+    (None, False)             ->  MANY2ONE
     """
-    if kind == "many_to_many":
+    if kind is RelationKind.MANY_TO_MANY:
         return FieldType.MANY2MANY
     return FieldType.ONE2MANY if many else FieldType.MANY2ONE
 
@@ -230,7 +231,7 @@ class ModelIntrospection:
             if relation is None and (related is None or not is_mapped(related)):
                 continue
             related_name = relation.related.__name__ if relation is not None else related.__name__  # type: ignore[union-attr]
-            logical = _relational_type(relation.kind if relation else "", many)
+            logical = _relational_type(relation.kind if relation else None, many)
             identified_by = relation.identified_by if relation is not None else None
             # The pair is published expanded, whichever way it was declared, so a client reads how
             # the two sides meet without knowing the cardinality convention `identified_by` obeys.

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/services/relation_resolver.py

@@ -42,6 +42,7 @@ from sincpro_framework.ddd.entity.entity_collection import (
 from sincpro_framework.ddd.entity.entity_meta import FieldType, Meta
 from sincpro_framework.ddd.entity.relations import (
     Groups,
+    RelationKind,
     cut,
     key_pair,
     limit_of,
@@ -329,27 +330,27 @@ def _resolve(
     the scope is merged here and nowhere else, so every kind honours it alike."""
     node = _scoped(declared, node)
     limit = limit_of(node, whole)
-    if declared.kind == "resolver":
+    if declared.kind is RelationKind.RESOLVER:
         return resolve_elsewhere(meta, parents, declared, node, many, limit)
     relation = cast("TableRelation", declared)
     match relation.kind:
-        case "foreign_key" if many:
+        case RelationKind.FOREIGN_KEY if many:
             return _by_foreign_key_on_related(
                 prepare, session, meta, parents, relation, node, limit, dropped
             )
-        case "foreign_key":
+        case RelationKind.FOREIGN_KEY:
             return _by_foreign_key_here(
                 prepare, session, meta, parents, relation, node, dropped
             )
-        case "many_to_many":
+        case RelationKind.MANY_TO_MANY:
             return _through_table(
                 prepare, session, meta, parents, relation, node, limit, dropped
             )
-        case "id_list":
+        case RelationKind.ID_LIST:
             return _by_id_list(
                 prepare, session, meta, parents, relation, node, limit, dropped
             )
-        case "resolver":
+        case RelationKind.RESOLVER:
             return resolve_elsewhere(meta, parents, relation, node, many, limit)
     raise ValueError(f"unknown relation kind {relation.kind!r}")
 

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/orm/sqlalchemy/services/workflows/writing.py

@@ -200,8 +200,8 @@ class Writing(RepositoryState, Extends):
         for batch in _by_dependency(plan.detached):
             session.add_all(batch)
             self._written(session, batch)
-        with session.no_autoflush:
-            for statement in plan.unlinks:
+        for statement in plan.unlinks:
+            with session.no_autoflush, named(f"a pair of {statement.table.name}"):
                 session.execute(statement)
         for level in reversed(plan.removals):
             for one in level:
@@ -210,8 +210,8 @@ class Writing(RepositoryState, Extends):
         for batch in _by_dependency(plan.writes):
             session.add_all(batch)
             self._written(session, batch)
-        with session.no_autoflush:
-            for statement in plan.links:
+        for statement in plan.links:
+            with session.no_autoflush, named(f"a pair of {statement.table.name}"):
                 session.execute(statement)
         plan.written()
         self._store_facts(session, [*plan.stored, *plan.removed])

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/data_layer/repositories/memory_repository.py

@@ -61,13 +61,14 @@ from sincpro_framework.ddd.criteria import (
     Grouping,
     GroupingLevel,
     Measure,
+    MeasureFunction,
     Node,
     Operator,
     Resolution,
     Sort,
 )
 from sincpro_framework.ddd.entity import ArchivableMixin, Entity, extensions, utc_now
-from sincpro_framework.ddd.entity.computed import computations_of
+from sincpro_framework.ddd.entity.computed import computed_fields_of
 from sincpro_framework.ddd.entity.entity_collection import (
     Count,
     Dropped,
@@ -132,25 +133,25 @@ def _percentile(values: list[Any], fraction: float) -> Any:
     return ordered[below] + (ordered[above] - ordered[below]) * reach
 
 
-MEASURES: dict[str, Callable[..., Any]] = {
-    "count": lambda values: len(values),
-    "count_distinct": lambda values: len(set(values)),
-    "sum": lambda values: sum(values),
-    "min": lambda values: min(values, default=None),
-    "max": lambda values: max(values, default=None),
-    "avg": lambda values: (sum(values) / len(values)) if values else None,
-    "percentile": _percentile,
-    "median": lambda values: _percentile(values, 0.5),
-    "bool_and": lambda values: all(values) if values else None,
-    "bool_or": lambda values: any(values) if values else None,
+MEASURES: dict[MeasureFunction, Callable[..., Any]] = {
+    MeasureFunction.COUNT: lambda values: len(values),
+    MeasureFunction.COUNT_DISTINCT: lambda values: len(set(values)),
+    MeasureFunction.SUM: lambda values: sum(values),
+    MeasureFunction.MIN: lambda values: min(values, default=None),
+    MeasureFunction.MAX: lambda values: max(values, default=None),
+    MeasureFunction.AVG: lambda values: (sum(values) / len(values)) if values else None,
+    MeasureFunction.PERCENTILE: _percentile,
+    MeasureFunction.MEDIAN: lambda values: _percentile(values, 0.5),
+    MeasureFunction.BOOL_AND: lambda values: all(values) if values else None,
+    MeasureFunction.BOOL_OR: lambda values: any(values) if values else None,
 }
 
 
 def _measure_of(values: list[Any], measure: Measure) -> Any:
     """One measure over the values a group holds. The only place that knows a percentile takes
     its fraction and every other function takes nothing."""
-    if measure.function == "percentile":
-        return MEASURES["percentile"](values, measure.argument)
+    if measure.function is MeasureFunction.PERCENTILE:
+        return MEASURES[MeasureFunction.PERCENTILE](values, measure.argument)
     return MEASURES[measure.function](values)
 
 
@@ -590,7 +591,7 @@ class MemoryRepository(
         """The record with its computed fields set from `python`, which is what a store in memory
         answers where a database would run the field's `sql`. A field with only `sql` stays at its
         default here, and `_refuse_unanswerable` stops a criteria from asking for it."""
-        for name, computation in computations_of(type(record)).items():
+        for name, computation in computed_fields_of(type(record)).items():
             if computation.python is not None:
                 setattr(record, name, computation.python(record))
         return record
@@ -600,7 +601,7 @@ class MemoryRepository(
         value would be a second implementation that quietly differs: it is refused, naming it.
         """
         for name in names:
-            computation = computations_of(aggregate).get(name)
+            computation = computed_fields_of(aggregate).get(name)
             if computation is not None and computation.python is None:
                 raise exceptions.InvalidCriteria(
                     f"{aggregate.__name__}.{name} is computed in SQL and has no `python`: a "

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/ddd/__init__.py

@@ -35,12 +35,9 @@ from sincpro_framework.ddd.criteria import (
     Specification,
     Today,
 )
-from sincpro_framework.ddd.editing.drafts import (
-    refuse_stale,
-)
-from sincpro_framework.ddd.editing.editing import assign, recompute, recompute_whole
+from sincpro_framework.ddd.editing.editing import apply_values, recompute
 from sincpro_framework.ddd.editing.edits import Edit, EditAction, EntityEdits, ResponseEdit
-from sincpro_framework.ddd.editing.preview import Advice, advise, is_previewing, previewing
+from sincpro_framework.ddd.editing.preview import FormWarning, read_only, warn_form
 from sincpro_framework.ddd.entity import (
     ArchivableMixin,
     AuditedMixin,
@@ -49,8 +46,8 @@ from sincpro_framework.ddd.entity import (
     new_entity_id,
     utc_now,
 )
+from sincpro_framework.ddd.entity.computations import Computations, Compute
 from sincpro_framework.ddd.entity.computed import computed
-from sincpro_framework.ddd.entity.derivations import Derivations, Derive
 from sincpro_framework.ddd.entity.entity_collection import (
     Changes,
     Count,
@@ -67,7 +64,13 @@ from sincpro_framework.ddd.entity.presentation import (
     Presentation,
     When,
 )
-from sincpro_framework.ddd.entity.relations import BusResolver, Relation, Resolver
+from sincpro_framework.ddd.entity.relations import (
+    BusResolver,
+    Relation,
+    RelationAttribute,
+    RelationKind,
+    Resolver,
+)
 from sincpro_framework.ddd.events import (
     ChangeTrackingMixin,
     DeliverableEventMixin,
@@ -105,8 +108,8 @@ from sincpro_framework.ddd.reads.reads import (
     Get,
     GetMany,
     LiteralSearch,
-    Preview,
-    ResponsePreview,
+    PreviewEntity,
+    ResponsePreviewEntity,
     Search,
     history_of,
 )
@@ -127,7 +130,7 @@ from sincpro_framework.ddd.repositories.hooks import Hook, Hooks
 from sincpro_framework.ddd.value_object import ValueObject
 
 __all__ = [
-    "Advice",
+    "FormWarning",
     "AggregateNotFound",
     "AggregateRepository",
     "All",
@@ -149,8 +152,8 @@ __all__ = [
     "CurrencyMismatch",
     "Cursor",
     "DeliverableEventMixin",
-    "Derivations",
-    "Derive",
+    "Computations",
+    "Compute",
     "DomainError",
     "DomainEvent",
     "DomainEvents",
@@ -198,15 +201,17 @@ __all__ = [
     "Pivot",
     "PivotCell",
     "Presentation",
-    "Preview",
+    "PreviewEntity",
     "Query",
     "ReadsAggregates",
     "Relation",
     "RelationNotResolved",
+    "RelationAttribute",
+    "RelationKind",
     "Resolver",
     "ResponseEdit",
     "ResponsePaginatedQuery",
-    "ResponsePreview",
+    "ResponsePreviewEntity",
     "ResponseRecord",
     "ResponseRecords",
     "Search",
@@ -224,18 +229,15 @@ __all__ = [
     "When",
     "WritesAggregates",
     "WritesInBulk",
-    "advise",
-    "assign",
+    "warn_form",
+    "apply_values",
     "computed",
     "detail_of",
     "history_of",
-    "is_previewing",
     "matching",
     "new_entity_id",
     "presentation_of",
-    "previewing",
+    "read_only",
     "recompute",
-    "recompute_whole",
-    "refuse_stale",
     "utc_now",
 ]

{sincpro_framework-3.28.0 → sincpro_framework-3.28.2}/sincpro_framework/ddd/criteria/__init__.py

@@ -42,6 +42,7 @@ from sincpro_framework.ddd.criteria.domain.grouping import (
     Grouping,
     GroupingLevel,
     Measure,
+    MeasureFunction,
     Pivot,
     PivotCell,
 )
@@ -98,6 +99,7 @@ __all__ = [
     "Grouping",
     "GroupingLevel",
     "Measure",
+    "MeasureFunction",
     "Node",
     "Not",
     "Now",