tcod-ecs 5.5.2__tar.gz → 5.6.0__tar.gz

{tcod_ecs-5.5.2 → tcod_ecs-5.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tcod-ecs
-Version: 5.5.2
+Version: 5.6.0
 Summary: A type-hinted Entity Component System based on Python dictionaries and sets.
 Author-email: Kyle Benesch <4b796c65+github@gmail.com>
 Requires-Python: >=3.10
@@ -14,8 +14,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 License-File: LICENSE
 Requires-Dist: attrs >=23.1.0
-Requires-Dist: cattrs >=23.1.2
-Requires-Dist: typing-extensions >=4.14.0
+Requires-Dist: typing-extensions >=4.16.0
 Requires-Dist: attrs >=22.2.0 ; extra == "test"
 Requires-Dist: pytest >=7.2.0 ; extra == "test"
 Requires-Dist: pytest-cov >=4.0.0 ; extra == "test"

{tcod_ecs-5.5.2 → tcod_ecs-5.6.0}/pyproject.toml

@@ -18,11 +18,7 @@ classifiers = [
 ]
 dynamic = ["version", "description"]
 requires-python = ">=3.10"
-dependencies = [
-    "attrs >=23.1.0",
-    "cattrs >=23.1.2",
-    "typing-extensions >=4.14.0",
-]
+dependencies = ["attrs >=23.1.0", "typing-extensions >=4.16.0"]
 
 [tool.setuptools_scm]
 write_to = "tcod/ecs/_version.py"

{tcod_ecs-5.5.2 → tcod_ecs-5.6.0}/tcod/ecs/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '5.5.2'
-__version_tuple__ = version_tuple = (5, 5, 2)
+__version__ = version = '5.6.0'
+__version_tuple__ = version_tuple = (5, 6, 0)
 
-__commit_id__ = commit_id = 'g60f279cbb'
+__commit_id__ = commit_id = 'ga15c18076'

{tcod_ecs-5.5.2 → tcod_ecs-5.6.0}/tcod/ecs/entity.py

@@ -9,7 +9,6 @@ from typing import (
     Final,
     Generic,
     TypeVar,
-    cast,
     overload,
 )
 from weakref import WeakKeyDictionary, WeakValueDictionary
@@ -18,8 +17,8 @@ import attrs
 from typing_extensions import Self, Sentinel, TypeForm, deprecated
 
 import tcod.ecs.callbacks
-import tcod.ecs.query
 from tcod.ecs.constants import IsA
+from tcod.ecs.traits import Component, Tag
 from tcod.ecs.typing import ComponentKey
 
 if TYPE_CHECKING:
@@ -362,7 +361,7 @@ def _traverse_entities(start: Entity, traverse_parents: tuple[object, ...]) -> I
     traverse_parents = traverse_parents[::-1]
     visited = {start}
     stack = [start]
-    _relation_tags_by_entity = start.registry._relation_tags_by_entity
+    _relation_tags_by_entity = start.registry._any_by_key_by_entity_by_category["RelationTag"]
     while stack:
         entity = stack.pop()
         yield entity
@@ -418,7 +417,7 @@ class EntityComponents(MutableMapping[TypeForm[Any] | tuple[object, TypeForm[Any
     def __getitem__(self, key: ComponentKey[T]) -> T:
         """Return a component belonging to this entity, or an indirect parent."""
         assert self.__assert_key(key)
-        _components_by_entity = self.entity.registry._components_by_entity
+        _components_by_entity = self.entity.registry._any_by_key_by_entity_by_category["Component"]
         for entity in _traverse_entities(self.entity, self.traverse):
             components = _components_by_entity.get(entity)
             if components is None:
@@ -433,13 +432,9 @@ class EntityComponents(MutableMapping[TypeForm[Any] | tuple[object, TypeForm[Any
         """Assign a component directly to an entity."""
         assert self.__assert_key(key)
 
-        old_value = self.entity.registry._components_by_entity[self.entity].get(key)
+        old_value = self.entity.registry._any_by_key_by_entity_by_category["Component"].get(self.entity, {}).get(key)
 
-        if old_value is None:
-            tcod.ecs.query._touch_component(self.entity.registry, key)  # Component added
-
-        self.entity.registry._components_by_entity[self.entity][key] = value
-        self.entity.registry._components_by_type[key][self.entity] = value
+        self.entity.registry._set_data(self.entity, Component.from_key(key), "Component", key, value)
 
         tcod.ecs.callbacks._on_component_changed(key, self.entity, old_value, value)
 
@@ -447,25 +442,16 @@ class EntityComponents(MutableMapping[TypeForm[Any] | tuple[object, TypeForm[Any
         """Delete a directly held component from an entity."""
         assert self.__assert_key(key)
 
-        components = self.entity.registry._components_by_entity.get(self.entity)
-        if components is None:
-            raise KeyError(key)
-        old_value = components.get(key)
-
-        del components[key]
-        if not components:
-            del self.entity.registry._components_by_entity[self.entity]
+        old_value = self.entity.registry._any_by_key_by_entity_by_category["Component"].get(self.entity, {}).get(key)
 
-        del self.entity.registry._components_by_type[key][self.entity]
-        if not self.entity.registry._components_by_type[key]:
-            del self.entity.registry._components_by_type[key]
+        if not self.entity.registry._discard_data(self.entity, Component.from_key(key), "Component", key):
+            raise KeyError(key)
 
-        tcod.ecs.query._touch_component(self.entity.registry, key)  # Component removed
         tcod.ecs.callbacks._on_component_changed(key, self.entity, old_value, None)
 
     def keys(self) -> AbstractSet[ComponentKey[object]]:  # type: ignore[override]
         """Return the components held by this entity, including inherited components."""
-        _components_by_entity = self.entity.registry._components_by_entity
+        _components_by_entity = self.entity.registry._any_by_key_by_entity_by_category["Component"]
         if not self.traverse:
             return _components_by_entity.get(self.entity, {}).keys()
         set_: set[ComponentKey[object]] = set()
@@ -475,7 +461,7 @@ class EntityComponents(MutableMapping[TypeForm[Any] | tuple[object, TypeForm[Any
 
     def __contains__(self, key: object) -> bool:
         """Return True if this entity has the provided component key."""
-        _components_by_entity = self.entity.registry._components_by_entity
+        _components_by_entity = self.entity.registry._any_by_key_by_entity_by_category["Component"]
         return any(
             key in _components_by_entity.get(entity, ()) for entity in _traverse_entities(self.entity, self.traverse)
         )
@@ -583,12 +569,12 @@ class EntityComponents(MutableMapping[TypeForm[Any] | tuple[object, TypeForm[Any
             ...
         KeyError: <class 'str'>
         """
-        _components = self.entity.registry._components_by_entity.get(self.entity, {})
-        if __key not in _components:
+        data_by_key = self.entity.registry._any_by_key_by_entity_by_category["Component"].get(self.entity, {})
+        if __key not in data_by_key:
             if default is _raise:
                 raise KeyError(__key)
             return default
-        value: T | _T1 = _components[__key]
+        value: T | _T1 = data_by_key[__key]
         del self[__key]
         return value
 
@@ -598,9 +584,6 @@ class EntityComponents(MutableMapping[TypeForm[Any] | tuple[object, TypeForm[Any
             self(traverse=()).clear()
             return
         super().clear()
-        # MutableMapping.clear() only calls __delitem__ for existing components,
-        # so it leaves an already empty registry row behind.
-        self.entity.registry._components_by_entity.pop(self.entity, None)
 
 
 @attrs.define(eq=False, frozen=True, weakref_slot=False)
@@ -627,49 +610,30 @@ class EntityTags(MutableSet[Any]):
 
     def add(self, tag: object) -> None:
         """Add a tag to the entity."""
-        if tag in self.entity.registry._tags_by_entity[self.entity]:
-            return  # Already has tag
-        tcod.ecs.query._touch_tag(self.entity.registry, tag)  # Tag added
-
-        self.entity.registry._tags_by_entity[self.entity].add(tag)
-        self.entity.registry._tags_by_key[tag].add(self.entity)
+        self.entity.registry._set_data(self.entity, Tag(tag), "Tag", tag, True)  # noqa: FBT003
 
     def discard(self, tag: object) -> None:
         """Discard a tag directly held by an entity."""
-        if tag not in self.entity.registry._tags_by_entity.get(self.entity, ()):
-            return  # Already doesn't have tag
-        tcod.ecs.query._touch_tag(self.entity.registry, tag)  # Tag removed
-
-        self.entity.registry._tags_by_entity[self.entity].discard(tag)
-        if not self.entity.registry._tags_by_entity[self.entity]:
-            del self.entity.registry._tags_by_entity[self.entity]
-
-        self.entity.registry._tags_by_key[tag].discard(self.entity)
-        if not self.entity.registry._tags_by_key[tag]:
-            del self.entity.registry._tags_by_key[tag]
+        self.entity.registry._discard_data(self.entity, Tag(tag), "Tag", tag)
 
     def remove(self, tag: object) -> None:
         """Remove a tag directly held by an entity."""
-        tags = self.entity.registry._tags_by_entity.get(self.entity)
-        if tags is None or tag not in tags:
+        if not self.entity.registry._discard_data(self.entity, Tag(tag), "Tag", tag):
             raise KeyError(tag)
-        self.discard(tag)
 
     def clear(self) -> None:
         """Remove all tags directly in this entity."""
-        _tags_by_entity = self.entity.registry._tags_by_entity
-        while tags := _tags_by_entity.get(self.entity):
+        while tags := self.entity.registry._any_by_key_by_entity_by_category["Tag"].get(self.entity):
             self.discard(next(iter(tags)))
-        _tags_by_entity.pop(self.entity, None)
 
     def __contains__(self, x: object) -> bool:
         """Return True if this entity has the given tag."""
-        _tags_by_entity = self.entity.registry._tags_by_entity
+        _tags_by_entity = self.entity.registry._any_by_key_by_entity_by_category["Tag"]
         return any(x in _tags_by_entity.get(entity, ()) for entity in _traverse_entities(self.entity, self.traverse))
 
     def _as_set(self) -> set[object]:
         """Return all tags inherited by traversal rules into a single set with no duplicates."""
-        _tags_by_entity = self.entity.registry._tags_by_entity
+        _tags_by_entity = self.entity.registry._any_by_key_by_entity_by_category["Tag"]
         return set().union(
             *(_tags_by_entity.get(entity, ()) for entity in _traverse_entities(self.entity, self.traverse))
         )
@@ -701,42 +665,6 @@ class EntityTags(MutableSet[Any]):
         return self
 
 
-def _relations_lookup_add(registry: Registry, origin: Entity, tag: object, target: Entity) -> None:
-    """Add a relation tag/component to the lookup table and handle side effects."""
-    registry._relations_lookup[(tag, target)].add(origin)
-    registry._relations_lookup[(tag, ...)].add(origin)
-    registry._relations_lookup[(origin, tag, None)].add(target)
-    registry._relations_lookup[(..., tag, None)].add(target)
-    tcod.ecs.query._touch_relations(registry, ((tag, target), (tag, ...), (origin, tag, None), (..., tag, None)))
-
-
-def _relations_lookup_discard(registry: Registry, origin: Entity, tag: object, target: Entity) -> None:
-    """Discard a relation tag/component from the lookup table and handle side effects."""
-    tags = registry._relation_tags_by_entity.get(origin)
-    if tags is not None and target in tags.get(tag, ()):
-        return  # A tag relation still owns this index entry.
-    components = registry._relation_components_by_entity.get(origin)
-    if components is not None and target in components.get(cast("ComponentKey[object]", tag), ()):
-        return  # A component relation still owns this index entry.
-    registry._relations_lookup[(tag, target)].discard(origin)
-    if not registry._relations_lookup[(tag, target)]:
-        del registry._relations_lookup[(tag, target)]
-
-        registry._relations_lookup[(..., tag, None)].discard(target)
-        if not registry._relations_lookup[(..., tag, None)]:
-            del registry._relations_lookup[(..., tag, None)]
-
-    registry._relations_lookup[(origin, tag, None)].discard(target)
-    if not registry._relations_lookup[(origin, tag, None)]:
-        del registry._relations_lookup[(origin, tag, None)]
-
-        registry._relations_lookup[(tag, ...)].discard(origin)
-        if not registry._relations_lookup[(tag, ...)]:
-            del registry._relations_lookup[(tag, ...)]
-
-    tcod.ecs.query._touch_relations(registry, ((tag, target), (tag, ...), (origin, tag, None), (..., tag, None)))
-
-
 @attrs.define(eq=False, frozen=True, weakref_slot=False)
 class EntityRelationsMapping(MutableSet[Entity]):
     """A proxy attribute to access entity relation targets like a set.
@@ -761,39 +689,23 @@ class EntityRelationsMapping(MutableSet[Entity]):
 
     def add(self, target: Entity) -> None:
         """Add a relation target to this tag."""
-        registry = self.entity.registry
-        registry._relation_tags_by_entity[self.entity][self.key].add(target)
-
-        _relations_lookup_add(registry, self.entity, self.key, target)
+        self.entity.registry._set_relation_data(self.entity, Tag(self.key), "RelationTag", self.key, target, value=True)
 
     def discard(self, target: Entity) -> None:
         """Discard a directly held relation target from this tag."""
-        registry = self.entity.registry
-
-        registry._relation_tags_by_entity[self.entity][self.key].discard(target)
-        if not registry._relation_tags_by_entity[self.entity][self.key]:
-            del registry._relation_tags_by_entity[self.entity][self.key]
-            if not registry._relation_tags_by_entity[self.entity]:
-                del registry._relation_tags_by_entity[self.entity]
-
-        _relations_lookup_discard(registry, self.entity, self.key, target)
+        self.entity.registry._discard_relation_data(self.entity, Tag(self.key), "RelationTag", self.key, target)
 
     def remove(self, target: Entity) -> None:
         """Remove a directly held relation target from this tag.
 
-        This will raise KeyError of only an indirect relation target exists.
+        This will raise KeyError if only an indirect relation target exists.
         """
-        relations = self.entity.registry._relation_tags_by_entity.get(self.entity)
-        if relations is None:
-            raise KeyError(target)
-        targets = relations.get(self.key)
-        if targets is None or target not in targets:
+        if not self.entity.registry._discard_relation_data(self.entity, Tag(self.key), "RelationTag", self.key, target):
             raise KeyError(target)
-        self.discard(target)
 
     def __contains__(self, target: Entity) -> bool:  # type: ignore[override]
         """Return True if this relation contains the given value."""
-        _relation_tags_by_entity = self.entity.registry._relation_tags_by_entity
+        _relation_tags_by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationTag"]
         for entity in _traverse_entities(self.entity, self.traverse):
             by_entity = _relation_tags_by_entity.get(entity)
             if by_entity is None:
@@ -804,7 +716,7 @@ class EntityRelationsMapping(MutableSet[Entity]):
 
     def _as_set(self) -> set[Entity]:
         """Return the combined targets of this mapping via traversal with duplicates removed."""
-        _relation_tags_by_entity = self.entity.registry._relation_tags_by_entity
+        _relation_tags_by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationTag"]
         results: set[Entity] = set()
         for entity in _traverse_entities(self.entity, self.traverse):
             by_entity = _relation_tags_by_entity.get(entity)
@@ -823,7 +735,7 @@ class EntityRelationsMapping(MutableSet[Entity]):
 
     def clear(self) -> None:
         """Discard all targets for this tag relation."""
-        by_entity = self.entity.registry._relation_tags_by_entity.get(self.entity)
+        by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationTag"].get(self.entity)
         if by_entity is None:
             return
         for key in list(by_entity.get(self.key, ())):
@@ -869,7 +781,7 @@ class EntityRelations(MutableMapping[object, EntityRelationsMapping]):
 
     def __iter__(self) -> Iterator[Any]:
         """Iterate over the unique relation tags of this entity."""
-        _relation_tags_by_entity = self.entity.registry._relation_tags_by_entity
+        _relation_tags_by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationTag"]
         empty_dict: dict[object, set[Entity]] = {}
         yield from set().union(
             *(
@@ -884,7 +796,7 @@ class EntityRelations(MutableMapping[object, EntityRelationsMapping]):
 
     def clear(self) -> None:
         """Discard all tag relations from an entity."""
-        for key in list(self.entity.registry._relation_tags_by_entity.get(self.entity, ())):
+        for key in list(self.entity.registry._any_by_key_by_entity_by_category["RelationTag"].get(self.entity, ())):
             del self[key]
 
 
@@ -911,7 +823,7 @@ class EntityRelationsExclusive(MutableMapping[object, Entity]):
         If the relation has no target then raises KeyError.
         If the relation is not exclusive then raises ValueError.
         """
-        _relation_tags_by_entity = self.entity.registry._relation_tags_by_entity
+        _relation_tags_by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationTag"]
         for entity in _traverse_entities(self.entity, self.traverse):
             by_entity = _relation_tags_by_entity.get(entity)
             if by_entity is None:
@@ -977,7 +889,7 @@ class EntityComponentRelationMapping(MutableMapping[Entity, T], Generic[T]):
 
     def __getitem__(self, target: Entity) -> T:
         """Return the component related to a target entity."""
-        _relation_components_by_entity = self.entity.registry._relation_components_by_entity
+        _relation_components_by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationComponent"]
         for entity in _traverse_entities(self.entity, self.traverse):
             by_entity = _relation_components_by_entity.get(entity)
             if by_entity is None:
@@ -992,38 +904,20 @@ class EntityComponentRelationMapping(MutableMapping[Entity, T], Generic[T]):
 
     def __setitem__(self, target: Entity, component: T) -> None:
         """Assign a component to the target entity."""
-        registry = self.entity.registry
-
-        old_value = registry._relation_components_by_entity[self.entity][self.key].get(target)
-        if old_value is None:  # Relation added
-            tcod.ecs.query._touch_relations(
-                registry, ((self.key, target), (self.key, ...), (self.entity, self.key, None), (..., self.key, None))
-            )
-
-        registry._relation_components_by_entity[self.entity][self.key][target] = component
-
-        _relations_lookup_add(registry, self.entity, self.key, target)
+        self.entity.registry._set_relation_data(
+            self.entity, Component.from_key(self.key), "RelationComponent", self.key, target, component
+        )
 
     def __delitem__(self, target: Entity) -> None:
         """Delete a component assigned to the target entity."""
-        registry = self.entity.registry
-        by_entity = registry._relation_components_by_entity.get(self.entity)
-        if by_entity is None:
-            raise KeyError(target)
-        by_key = by_entity.get(self.key)
-        if by_key is None:
+        if not self.entity.registry._discard_relation_data(
+            self.entity, Component.from_key(self.key), "RelationComponent", self.key, target
+        ):
             raise KeyError(target)
-        del by_key[target]
-        if not by_key:
-            del by_entity[self.key]
-        if not by_entity:
-            del registry._relation_components_by_entity[self.entity]
-
-        _relations_lookup_discard(registry, self.entity, self.key, target)
 
     def keys(self) -> AbstractSet[Entity]:  # type: ignore[override]
         """Return all entities with an associated component value."""
-        _relation_components_by_entity = self.entity.registry._relation_components_by_entity
+        _relation_components_by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationComponent"]
         result: set[Entity] = set()
         for entity in _traverse_entities(self.entity, self.traverse):
             by_entity = _relation_components_by_entity.get(entity)
@@ -1107,12 +1001,14 @@ class EntityComponentRelations(MutableMapping[ComponentKey[Any], EntityComponent
 
         Does not clear relations targeting this entity.
         """
-        for component_key in list(self.entity.registry._relation_components_by_entity.get(self.entity, ())):
+        for component_key in list(
+            self.entity.registry._any_by_key_by_entity_by_category["RelationComponent"].get(self.entity, ())
+        ):
             self[component_key].clear()
 
     def keys(self) -> AbstractSet[ComponentKey[object]]:  # type: ignore[override]
         """Returns the components keys this entity has relations for."""
-        _relation_components_by_entity = self.entity.registry._relation_components_by_entity
+        _relation_components_by_entity = self.entity.registry._any_by_key_by_entity_by_category["RelationComponent"]
         return set().union(
             *(
                 _relation_components_by_entity.get(entity, ())

{tcod_ecs-5.5.2 → tcod_ecs-5.6.0}/tcod/ecs/query.py

@@ -13,6 +13,7 @@ from typing_extensions import Self, deprecated
 
 import tcod.ecs.entity
 from tcod.ecs.constants import IsA
+from tcod.ecs.traits import Component, Relation, traits_from_query
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator
@@ -20,7 +21,7 @@ if TYPE_CHECKING:
 
     from tcod.ecs.entity import Entity
     from tcod.ecs.registry import Registry
-    from tcod.ecs.typing import ComponentKey, _RelationQuery
+    from tcod.ecs.typing import ComponentKey, _RelationQuery, _Trait
 
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
@@ -35,14 +36,8 @@ class _QueryCache:
 
     queries: dict[_Query, AbstractSet[Entity]] = attrs.field(factory=dict)
     """Table of cached queries."""
-    by_components: defaultdict[ComponentKey[object], WeakSet[_Query]] = attrs.field(
-        factory=lambda: defaultdict(WeakSet)
-    )
-    """Which queries depend on which components."""
-    by_tags: defaultdict[object, WeakSet[_Query]] = attrs.field(factory=lambda: defaultdict(WeakSet))
-    """Which queries depend on which tags."""
-    by_relations: defaultdict[_RelationQuery, WeakSet[_Query]] = attrs.field(factory=lambda: defaultdict(WeakSet))
-    """Which queries depend on which relations."""
+    by_traits: defaultdict[_Trait, WeakSet[_Query]] = attrs.field(factory=lambda: defaultdict(WeakSet))
+    """Which queries depend on which traits."""
 
     dependencies: dict[_Query, set[tuple[Registry, _Query]]] = attrs.field(factory=lambda: defaultdict(set))
     """Tracks which queries depend on the queries of the current registry.
@@ -50,40 +45,18 @@ class _QueryCache:
     `dependencies[dependency] = {dependant}`
     """
 
+    def _drop_cached_query(self, query: _Query) -> None:
+        """Drop a cached query and all of its dependant queries."""
+        self.queries.pop(query, None)
+        for sub_registry, sub_query in self.dependencies.pop(query, ()):
+            sub_registry._query_cache._drop_cached_query(sub_query)
 
-def _drop_cached_query(cache: _QueryCache, query: _Query) -> None:
-    """Drop a cached query and all of its dependant queries."""
-    cache.queries.pop(query, None)
-    for sub_registry, sub_query in cache.dependencies.pop(query, ()):
-        _drop_cached_query(_get_query_cache(sub_registry), sub_query)
-
-
-def _touch_component(registry: Registry, component: ComponentKey[object]) -> None:
-    """Drop cached queries if a component change has invalidated them."""
-    cache = _get_query_cache(registry)
-    if component not in cache.by_components:
-        return
-    for touched_query in cache.by_components.pop(component, ()):
-        _drop_cached_query(cache, touched_query)
-
-
-def _touch_tag(registry: Registry, tag: object) -> None:
-    """Drop cached queries if a tag change has invalidated them."""
-    cache = _get_query_cache(registry)
-    if tag not in cache.by_tags:
-        return
-    for touched_query in cache.by_tags.pop(tag, ()):
-        _drop_cached_query(cache, touched_query)
-
-
-def _touch_relations(registry: Registry, relations: Iterable[_RelationQuery]) -> None:
-    """Drop cached queries if a relation change has invalidated them."""
-    cache = _get_query_cache(registry)
-    for relation in relations:
-        if relation not in cache.by_relations:
-            continue
-        for touched_query in cache.by_relations.pop(relation, ()):
-            _drop_cached_query(cache, touched_query)
+    def _touch_trait(self, trait: _Trait) -> None:
+        """Drop cached queries if a trait change has invalidated them."""
+        if trait not in self.by_traits:
+            return
+        for touched_query in self.by_traits.pop(trait, ()):
+            self._drop_cached_query(touched_query)
 
 
 def _check_suspicious_tags(tags: Iterable[object], stacklevel: int = 2) -> None:
@@ -106,29 +79,20 @@ def _fetch_relation_table(registry: Registry, relation: _RelationQuery) -> Abstr
 
     For advanced cases `BoundQuery` this returns the subset of entities following the query condition.
     """
-    if len(relation) == 2:  # noqa: PLR2004
-        tag, target = relation
-        if not isinstance(target, BoundQuery):
-            return registry._relations_lookup.get((tag, target), frozenset())
-
-        registry = target.registry
-        return set().union(*(registry._relations_lookup.get((tag, entity), ()) for entity in target))
-    origin, tag, target_none = relation
-    if not isinstance(origin, BoundQuery):
-        return registry._relations_lookup.get((origin, tag, target_none), frozenset())
-
-    registry = origin.registry
-    return set().union(*(registry._relations_lookup.get((entity, tag, None), ()) for entity in origin))
-
-
-def _get_query_cache(registry: Registry) -> _QueryCache:
-    """Return the cache owned by the given registry."""
-    return registry._query_cache
+    trait: Relation[Any] = Relation._from_query(relation)
+    if not isinstance(trait.target, BoundQuery):
+        return registry._any_by_entity_by_trait.get(trait, {}).keys()
+    return set().union(
+        *(
+            registry._any_by_entity_by_trait.get(Relation(trait.trait, entity, trait.inverse), ())
+            for entity in trait.target
+        )
+    )
 
 
 def _get_query(registry: Registry, query: _Query) -> AbstractSet[Entity]:
     """Return the entities for the given query and registry."""
-    cache = _get_query_cache(registry)
+    cache = registry._query_cache
     if cache is not None:
         cached_entities = cache.queries.get(query)
         if cached_entities is not None:
@@ -164,34 +128,21 @@ class _Query(Protocol):
         ...
 
     def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:
-        """Compile the entities of this query, returning a set which must not be modified."""
+        """Compile the entities of this query, returning a set which must not be modified by the caller."""
         ...
 
 
 @attrs.define(frozen=True)
-class _QueryComponent:
-    """Query all entities with the given component."""
-
-    _component: ComponentKey[object]
-
-    def _add_to_cache(self, registry: Registry, cache: _QueryCache) -> None:  # noqa: ARG002
-        cache.by_components[self._component].add(self)
-
-    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
-        return registry._components_by_type.get(self._component, {}).keys()
-
-
-@attrs.define(frozen=True)
-class _QueryTag:
-    """Query all entities with the given tag."""
+class _QueryTrait:
+    """Query all entities with the given trait."""
 
-    _tag: object
+    trait: _Trait
 
     def _add_to_cache(self, registry: Registry, cache: _QueryCache) -> None:  # noqa: ARG002
-        cache.by_tags[self._tag].add(self)
+        cache.by_traits[self.trait].add(self)
 
     def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
-        return registry._tags_by_key.get(self._tag, set())
+        return registry._any_by_entity_by_trait.get(self.trait, {}).keys()
 
 
 @attrs.define(frozen=True)
@@ -202,19 +153,13 @@ class _QueryRelation:
 
     def _add_to_cache(self, registry: Registry, cache: _QueryCache) -> None:
         """Add this query to the cache and mark it dependant on a registry query if the relation uses one."""
+        trait: Relation[Any] = Relation._from_query(self._relation)
 
-        def _get_registry_query() -> BoundQuery | None:
-            """Return the bound query of a relation if it exists."""
-            if isinstance(self._relation[0], BoundQuery):
-                return self._relation[0]
-            if isinstance(self._relation[-1], BoundQuery):
-                return self._relation[-1]
-            return None
-
-        cache.by_relations[self._relation].add(self)
-        w_query = _get_registry_query()
-        if w_query is not None:
-            _get_query_cache(w_query.registry).dependencies[w_query._query].add((registry, self))
+        target_query = trait.target
+        if isinstance(target_query, BoundQuery):
+            target_query.registry._query_cache.dependencies[target_query._query].add((registry, self))
+        else:
+            cache.by_traits[trait].add(self)
 
     def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
         return _fetch_relation_table(registry, self._relation)
@@ -302,10 +247,9 @@ class _QueryTraversalPropagation:
         while unchecked_set and (self._max_depth is None or depth < self._max_depth):
             depth += 1
             new_set: set[Entity] = set()
-            empty_set: frozenset[Entity] = frozenset()
             for traverse_key in self._traverse_keys:
                 for unchecked in unchecked_set:
-                    new_set |= registry._relations_lookup.get((traverse_key, unchecked), empty_set)
+                    new_set |= registry._any_by_entity_by_trait.get(Relation(traverse_key, unchecked), {}).keys()
             new_set -= cumulative_set
             cumulative_set |= new_set
             unchecked_set = new_set
@@ -355,8 +299,10 @@ class BoundQuery:
     ) -> Iterator[_Query]:
         """Convert parameters into queries."""
         traverse = tuple(traverse)
-        yield from (_QueryTraversalPropagation(_QueryComponent(component), traverse, depth) for component in components)
-        yield from (_QueryTraversalPropagation(_QueryTag(tag), traverse, depth) for tag in tags)
+        yield from (
+            _QueryTraversalPropagation(_QueryTrait(trait), traverse, depth)
+            for trait in traits_from_query(components=components, tags=tags)
+        )
         yield from (_QueryTraversalPropagation(_QueryRelation(relations), traverse, depth) for relations in relations)
 
     def all_of(
@@ -459,7 +405,7 @@ class BoundQuery:
             if component_key is Entity:
                 entity_components.append(entities)
                 continue
-            registry_components = self.registry._components_by_type[component_key]
+            registry_components = self.registry._any_by_entity_by_trait.get(Component.from_key(component_key), {})
             try:
                 entity_components.append([registry_components[entity] for entity in entities])
             except KeyError:  # Some matching entities inherit this component.