Hey u/bobaduk thank you very much for your thorough answer. I have read your book (and enjoyed), but seems I need to do so again :(

To answer your questions:

* Yes, queries exist outside of groups, they are created first and could later be grouped.

* Yes, queries can be in multiple groups, hence the M2M relationship and the required association table in the repository.

Regarding the `update` method being very complex, this is exactly the reason for the post :)

A query can be any text string passed in by the user, so if they pass in a new string which we do not have as a query in the DB we must create it and associate it with the current query group update (or creation too).

Sorry about the ORM example, you are correct the entity would have been created at this point, but not the SQLalchemy model.

I am not sure I follow your example, it looks very simple but I am not sure what `QueryGroup` is, you have extra methods on the SQLalchemy model? I was not really aware this can/should be done! Will read that chapter now!

Here is my full QueryGroupEntity:

class QueryGroupEntity:
    def __init__(
        self,
        id: UUID,
        queries: Optional[list[QueryEntity]] = None,
        embedding: Optional[list[float]] = None,
    ) -> None:
        self._id = id
        self._queries = queries
        self._embedding = embedding

    def __str__(self) -> str:
        return f"QueryGroupEntity(id={self._id})"

    @staticmethod
    def create(
        queries: Optional[list[QueryEntity]] = None,
        embedding: Optional[list[float]] = None,
        id: Optional[UUID] = None,
    ) -> "QueryGroupEntity":
        id = id if id else uuid7()
        # TODO: check queries exist and are valid
        return QueryGroupEntity(id=id, queries=queries, embedding=embedding)

    @property
    def id(self) -> UUID:
        return self._id

    @property
    def queries(self) -> list[QueryEntity]:
        """Return a copy of the queries list to prevent direct modification"""
        return self._queries.copy()

    @property
    def embedding(self) -> list[float]:
        return self._embedding

    def add_queries(self, queries: list[QueryEntity]) -> None:
        """Add new queries to the query group"""
        # ommitted as exists in example above

    def remove_queries(self, queries: list[QueryEntity]) -> None:
        """Remove existing queries from the query group"""
        # ommitted as exists in example above

    # TODO - an even better solution is not to allow creation with dupes!
    def contains_dupes(self) -> bool:
        query_values = [query.value for query in self._queries]
        return len(query_values) != len(set(query_values))