tcod-ecs 5.1.0__tar.gz → 5.2.0__tar.gz

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tcod-ecs
-Version: 5.1.0
+Version: 5.2.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.8
@@ -236,13 +236,45 @@ True
 
 ## Relations
 
-Use `Entity.relation_components[component_key][target] = component` to associate a target entity with a component.
-Use `Entity.relation_tag[tag] = target` to associate a tag exclusively with a target entity.
-Use `Entity.relation_tags_many[tag].add(target)` to associate a tag with multiple targets.
+Entity relations are unidirectional from an origin entity to possibly multiple target entities.
 
-Relation queries are a little more complex than other queries.
-Relation tags and relation components share the same space then queried, so 'normal' tags should not be in the format of a component key.
-Relations are unidirectional, but you can query either end of a relation.
+- Use `origin.relation_tag[tag] = target` to associate an origins tag exclusively with the target entity.
+  This uses standard assignment and is useful for tags which would not make sense with multiple targets.
+  Reading `origin.relation_tag[tag]` returns a single target while enforcing the invariant of only having one target.
+- Use `origin.relation_tags_many[tag].add(target)` to associate a tag with multiple targets.
+  This supports `set`-like syntax such as adding or removing multiple targets at once.
+  This allows for many-to-many relations.
+- Use `origin.relation_components[component_key][target] = component` to associate a target entity with a component.
+  This allows storing data along with a relation.
+  This supports `dict`-like syntax.
+  The `component_key` can be queried like a normal tag.
+
+### Relation queries
+
+Relations are queried with `registry.Q.all_of(relations=[...])`.
+This expects 2-item or 3-item tuples following these rules:
+
+- Use `(tag, target)` to match the origin entities with the relation `tag` to `target`.
+- If `tag` is a component key then component relations are also matched.
+  This means you should be careful with tags which look like component keys.
+- `target` can be a specific entity. This means only entities relating to that specific entity will be matched.
+- `target` can be query itself. This means only entities relating to a match from the sub-query are matched.
+- `target` can be `...` which means an entity with a relation to any entity is matched.
+- To reverse the direction use a 3-item tuple `(origin, tag, None)`. `origin` can be anything a `target` could be.
+
+Relations using sub-queries may be chained together.
+See [Sander Mertens - Why it is time to start thinking of games as databases](https://ajmmertens.medium.com/why-it-is-time-to-start-thinking-of-games-as-databases-e7971da33ac3) to understand the repercussion of this.
+
+You can use the following table to help with constructing relation queries:
+
+| Matches                                                             |                  Syntax                  |
+| ------------------------------------------------------------------- | :--------------------------------------: |
+| Origins with a relation `tag` to `target_entity`                    |          `(tag, target_entity)`          |
+| Origins with a relation `tag` to any target entity                  |    `(tag, ...)` (Literal dot-dot-dot)    |
+| Origins with a relation `tag` to any targets matching a sub-query   |     `(tag, registry.Q.all_of(...))`      |
+| Targets of the relation `tag` from `origin_entity`                  |       `(origin_entity, tag, None)`       |
+| Targets of the relation `tag` from any origin entity                | `(..., tag, None)` (Literal dot-dot-dot) |
+| Targets of the relation `tag` from any origins matching a sub-query |  `(registry.Q.all_of(...), tag, None)`   |
 
 ```py
 >>> @attrs.define
@@ -273,17 +305,3 @@ True
 
 ```
 
-### Relation queries
-
-You can use the following table to help with constructing relation queries.
-`tag` is a component key if you are querying for a component relation.
-
-| Includes                                                            |                  Syntax                  |
-| ------------------------------------------------------------------- | :--------------------------------------: |
-| Entities with a relation tag to the given target                    |          `(tag, target_entity)`          |
-| Entities with a relation tag to any target                          |    `(tag, ...)` (Literal dot-dot-dot)    |
-| Entities with a relation tag to the targets in the given query      |     `(tag, registry.Q.all_of(...))`      |
-| The target entities of a relation of a given entity                 |       `(origin_entity, tag, None)`       |
-| The target entities of any entity with the given relation tag       | `(..., tag, None)` (Literal dot-dot-dot) |
-| The target entities of the queried entities with the given relation |     `(tag, registry.Q.all_of(...))`      |
-

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/README.md

@@ -207,13 +207,45 @@ True
 
 ## Relations
 
-Use `Entity.relation_components[component_key][target] = component` to associate a target entity with a component.
-Use `Entity.relation_tag[tag] = target` to associate a tag exclusively with a target entity.
-Use `Entity.relation_tags_many[tag].add(target)` to associate a tag with multiple targets.
+Entity relations are unidirectional from an origin entity to possibly multiple target entities.
+
+- Use `origin.relation_tag[tag] = target` to associate an origins tag exclusively with the target entity.
+  This uses standard assignment and is useful for tags which would not make sense with multiple targets.
+  Reading `origin.relation_tag[tag]` returns a single target while enforcing the invariant of only having one target.
+- Use `origin.relation_tags_many[tag].add(target)` to associate a tag with multiple targets.
+  This supports `set`-like syntax such as adding or removing multiple targets at once.
+  This allows for many-to-many relations.
+- Use `origin.relation_components[component_key][target] = component` to associate a target entity with a component.
+  This allows storing data along with a relation.
+  This supports `dict`-like syntax.
+  The `component_key` can be queried like a normal tag.
 
-Relation queries are a little more complex than other queries.
-Relation tags and relation components share the same space then queried, so 'normal' tags should not be in the format of a component key.
-Relations are unidirectional, but you can query either end of a relation.
+### Relation queries
+
+Relations are queried with `registry.Q.all_of(relations=[...])`.
+This expects 2-item or 3-item tuples following these rules:
+
+- Use `(tag, target)` to match the origin entities with the relation `tag` to `target`.
+- If `tag` is a component key then component relations are also matched.
+  This means you should be careful with tags which look like component keys.
+- `target` can be a specific entity. This means only entities relating to that specific entity will be matched.
+- `target` can be query itself. This means only entities relating to a match from the sub-query are matched.
+- `target` can be `...` which means an entity with a relation to any entity is matched.
+- To reverse the direction use a 3-item tuple `(origin, tag, None)`. `origin` can be anything a `target` could be.
+
+Relations using sub-queries may be chained together.
+See [Sander Mertens - Why it is time to start thinking of games as databases](https://ajmmertens.medium.com/why-it-is-time-to-start-thinking-of-games-as-databases-e7971da33ac3) to understand the repercussion of this.
+
+You can use the following table to help with constructing relation queries:
+
+| Matches                                                             |                  Syntax                  |
+| ------------------------------------------------------------------- | :--------------------------------------: |
+| Origins with a relation `tag` to `target_entity`                    |          `(tag, target_entity)`          |
+| Origins with a relation `tag` to any target entity                  |    `(tag, ...)` (Literal dot-dot-dot)    |
+| Origins with a relation `tag` to any targets matching a sub-query   |     `(tag, registry.Q.all_of(...))`      |
+| Targets of the relation `tag` from `origin_entity`                  |       `(origin_entity, tag, None)`       |
+| Targets of the relation `tag` from any origin entity                | `(..., tag, None)` (Literal dot-dot-dot) |
+| Targets of the relation `tag` from any origins matching a sub-query |  `(registry.Q.all_of(...), tag, None)`   |
 
 ```py
 >>> @attrs.define
@@ -243,17 +275,3 @@ True
 True
 
 ```
-
-### Relation queries
-
-You can use the following table to help with constructing relation queries.
-`tag` is a component key if you are querying for a component relation.
-
-| Includes                                                            |                  Syntax                  |
-| ------------------------------------------------------------------- | :--------------------------------------: |
-| Entities with a relation tag to the given target                    |          `(tag, target_entity)`          |
-| Entities with a relation tag to any target                          |    `(tag, ...)` (Literal dot-dot-dot)    |
-| Entities with a relation tag to the targets in the given query      |     `(tag, registry.Q.all_of(...))`      |
-| The target entities of a relation of a given entity                 |       `(origin_entity, tag, None)`       |
-| The target entities of any entity with the given relation tag       | `(..., tag, None)` (Literal dot-dot-dot) |
-| The target entities of the queried entities with the given relation |     `(tag, registry.Q.all_of(...))`      |

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/pyproject.toml

@@ -46,16 +46,6 @@ Changelog = "https://github.com/HexDecimal/python-tcod-ecs/blob/main/CHANGELOG.m
 Documentation = "https://python-tcod-ecs.readthedocs.io"
 Source = "https://github.com/HexDecimal/python-tcod-ecs"
 
-[tool.black] # https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#configuration-via-a-file
-target-version = ["py38"]
-line-length = 120
-
-[tool.isort] # https://pycqa.github.io/isort/docs/configuration/options.html
-py_version = "38"
-line_length = 120
-profile = "black"
-skip_gitignore = true
-
 [tool.mypy] # https://mypy.readthedocs.io/en/stable/config_file.html
 files = "."
 exclude = ['^build/', '^\.']
@@ -86,44 +76,23 @@ testpaths = ["."]
 exclude_lines = ['^\s*\.\.\.', "if TYPE_CHECKING:", "# pragma: no cover"]
 
 [tool.ruff]
-# https://beta.ruff.rs/docs/rules/
-select = [
-    "C90", # mccabe
-    "E",   # pycodestyle
-    "W",   # pycodestyle
-    "F",   # Pyflakes
-    "I",   # isort
-    "UP",  # pyupgrade
-    "YTT", # flake8-2020
-    "ANN", # flake8-annotations
-    "S",   # flake8-bandit
-    "B",   # flake8-bugbear
-    "C4",  # flake8-comprehensions
-    "DTZ", # flake8-datetimez
-    "EM",  # flake8-errmsg
-    "EXE", # flake8-executable
-    "RET", # flake8-return
-    "ICN", # flake8-import-conventions
-    "PIE", # flake8-pie
-    "PT",  # flake8-pytest-style
-    "SIM", # flake8-simplify
-    "PTH", # flake8-use-pathlib
-    "PL",  # Pylint
-    "TRY", # tryceratops
-    "RUF", # NumPy-specific rules
-    "G",   # flake8-logging-format
-    "D",   # pydocstyle
-]
+line-length = 120
+
+[tool.ruff.lint] # https://docs.astral.sh/ruff/rules/
+select = ["ALL"]
 ignore = [
-    "E501",   # line-too-long
-    "S101",   # assert
     "ANN101", # missing-type-self
     "ANN102", # missing-type-cls
-    "D206",   # indent-with-spaces
-    "W191",   # tab-indentation
+    "COM",    # flake8-commas, handled by formatter
+    "E501",   # line-too-long
+    "S101",   # assert
+    "SLF001", # private-member-access
+    "T10",    # flake8-debugger
+    "T20",    # flake8-print
 ]
-line-length = 120
 
-[tool.ruff.pydocstyle]
-# Use Google-style docstrings.
-convention = "google"
+[tool.ruff.lint.isort]
+required-imports = ["from __future__ import annotations"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google" # Use Google-style docstrings.

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/__init__.py

@@ -1,4 +1,5 @@
 """A type-hinted Entity Component System based on Python dictionaries and sets."""
+
 from __future__ import annotations
 
 import importlib.metadata

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/_converter.py

@@ -12,9 +12,9 @@ def _is_defaultdict_type(type_hint: object) -> bool:
     return get_origin(type_hint) is defaultdict
 
 
-def _setup_defaultdict_factory(type_hint: type[defaultdict[Any, Any]] | type[object]) -> Callable[[], Any]:
+def _setup_defaultdict_factory(type_hint: type[defaultdict[Any, Any] | object]) -> Callable[[], Any]:
     """Return the factory value for a defaultdict given its value type-hint."""
-    assert type_hint is not Any
+    assert type_hint is not Any  # type: ignore[comparison-overlap]
     if get_origin(type_hint) is not defaultdict:
         return get_origin(type_hint) or type_hint
     return functools.partial(defaultdict, _setup_defaultdict_factory(get_args(type_hint)[1]))

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '5.1.0'
-__version_tuple__ = version_tuple = (5, 1, 0)
+__version__ = version = '5.2.0'
+__version_tuple__ = version_tuple = (5, 2, 0)

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/callbacks.py

@@ -1,14 +1,14 @@
 """ECS callback management."""
+
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union
 
 from typing_extensions import TypeAlias
 
-from tcod.ecs.typing import ComponentKey
-
 if TYPE_CHECKING:
     from tcod.ecs.entity import Entity
+    from tcod.ecs.typing import ComponentKey
 
 _T = TypeVar("_T")
 

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/constants.py

@@ -1,4 +1,7 @@
 """Special constants and sentinel values."""
+
+from __future__ import annotations
+
 from typing import Final
 
 from sentinel_value import sentinel

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/entity.py

@@ -1,8 +1,8 @@
 """Entity management and interface tools."""
+
 from __future__ import annotations
 
 import warnings
-from collections.abc import Set
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -30,6 +30,8 @@ from tcod.ecs.constants import IsA
 from tcod.ecs.typing import ComponentKey
 
 if TYPE_CHECKING:
+    from collections.abc import Set as AbstractSet
+
     from _typeshed import SupportsKeysAndGetItem
 
     from tcod.ecs.registry import Registry
@@ -79,7 +81,7 @@ class Entity:
             warnings.warn("Use '.registry' instead of '.world'", DeprecationWarning, stacklevel=2)
         return self.registry
 
-    def __new__(cls, registry: Registry, uid: object = object) -> Entity:
+    def __new__(cls, registry: Registry, uid: object = object) -> Entity:  # noqa: PYI034
         """Return a unique entity for the given `registry` and `uid`.
 
         If an entity already exists with a matching `registry` and `uid` then that entity is returned.
@@ -333,7 +335,7 @@ class Entity:
             >>> registry["foo"]
             <Entity(uid='foo')>
         """
-        uid_str = f"object at 0x{id(self.uid):X}" if self.uid.__class__ == object else repr(self.uid)
+        uid_str = f"object at 0x{id(self.uid):X}" if self.uid.__class__ is object else repr(self.uid)
         items = [f"{self.__class__.__name__}(uid={uid_str})"]
         name = self.name
         if name is not None:  # Switch to older style
@@ -425,7 +427,7 @@ class EntityComponents(MutableMapping[Union[Type[Any], Tuple[object, Type[Any]]]
         for entity in _traverse_entities(self.entity, self.traverse):
             try:
                 return _components_by_entity[entity][key]  # type: ignore[no-any-return]
-            except KeyError:
+            except KeyError:  # noqa: PERF203
                 pass
         raise KeyError(key)
 
@@ -460,7 +462,7 @@ class EntityComponents(MutableMapping[Union[Type[Any], Tuple[object, Type[Any]]]
         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) -> Set[ComponentKey[object]]:  # type: ignore[override]
+    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
         if not self.traverse:
@@ -512,12 +514,10 @@ class EntityComponents(MutableMapping[Union[Type[Any], Tuple[object, Type[Any]]]
                 yield key_name, key_component
 
     @overload
-    def __ior__(self, value: SupportsKeysAndGetItem[ComponentKey[Any], Any]) -> Self:
-        ...
+    def __ior__(self, value: SupportsKeysAndGetItem[ComponentKey[Any], Any]) -> Self: ...
 
     @overload
-    def __ior__(self, value: Iterable[tuple[ComponentKey[Any], Any]]) -> Self:
-        ...
+    def __ior__(self, value: Iterable[tuple[ComponentKey[Any], Any]]) -> Self: ...
 
     def __ior__(
         self, value: SupportsKeysAndGetItem[ComponentKey[Any], Any] | Iterable[tuple[ComponentKey[Any], Any]]
@@ -612,7 +612,7 @@ class EntityTags(MutableSet[Any]):
         """Return the number of tags this entity has."""
         return len(self._as_set())
 
-    def __ior__(self, other: Set[object]) -> Self:
+    def __ior__(self, other: AbstractSet[object]) -> Self:
         """Add tags in-place.
 
         .. versionadded:: 3.3
@@ -621,7 +621,7 @@ class EntityTags(MutableSet[Any]):
             self.add(to_add)
         return self
 
-    def __isub__(self, other: Set[Any]) -> Self:
+    def __isub__(self, other: AbstractSet[Any]) -> Self:
         """Remove tags in-place.
 
         .. versionadded:: 3.3
@@ -788,10 +788,10 @@ 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
-        EMPTY_DICT: dict[object, set[Entity]] = {}
+        empty_dict: dict[object, set[Entity]] = {}
         yield from set().union(
             *(
-                _relation_tags_by_entity.get(entity, EMPTY_DICT).keys()
+                _relation_tags_by_entity.get(entity, empty_dict).keys()
                 for entity in _traverse_entities(self.entity, self.traverse)
             )
         )
@@ -926,7 +926,7 @@ class EntityComponentRelationMapping(Generic[T], MutableMapping[Entity, T]):
 
         _relations_lookup_discard(registry, self.entity, self.key, target)
 
-    def keys(self) -> Set[Entity]:  # type: ignore[override]
+    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
         result: set[Entity] = set()
@@ -1004,7 +1004,7 @@ class EntityComponentRelations(MutableMapping[ComponentKey[Any], EntityComponent
         for component_key in list(self.entity.registry._relation_components_by_entity.get(self.entity, ())):
             self[component_key].clear()
 
-    def keys(self) -> Set[ComponentKey[object]]:  # type: ignore[override]
+    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
         return set().union(

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/query.py

@@ -1,10 +1,10 @@
 """Tools for querying Registry objects."""
+
 from __future__ import annotations
 
 import itertools
 import warnings
 from collections import defaultdict
-from collections.abc import Set
 from typing import TYPE_CHECKING, Any, Iterable, Iterator, Protocol, TypeVar, overload
 from weakref import WeakKeyDictionary, WeakSet
 
@@ -13,11 +13,13 @@ from typing_extensions import Self
 
 import tcod.ecs.entity
 from tcod.ecs.constants import IsA
-from tcod.ecs.typing import ComponentKey, _RelationQuery
 
 if TYPE_CHECKING:
+    from collections.abc import Set as AbstractSet
+
     from tcod.ecs.entity import Entity
     from tcod.ecs.registry import Registry
+    from tcod.ecs.typing import ComponentKey, _RelationQuery
 
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
@@ -34,7 +36,7 @@ _query_caches: WeakKeyDictionary[Registry, _QueryCache] = WeakKeyDictionary()
 class _QueryCache:
     """Main data structure for the query cache."""
 
-    queries: dict[_Query, Set[Entity]] = attrs.field(factory=dict)
+    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)
@@ -100,7 +102,7 @@ def _check_suspicious_tags(tags: Iterable[object], stacklevel: int = 2) -> None:
         )
 
 
-def _fetch_relation_table(registry: Registry, relation: _RelationQuery) -> Set[Entity]:
+def _fetch_relation_table(registry: Registry, relation: _RelationQuery) -> AbstractSet[Entity]:
     """Get the entity table for this relation.
 
     For simple cases where target/origin is `Entity | ...` this returns the set directly from the lookup table.
@@ -130,7 +132,7 @@ def _get_query_cache(registry: Registry) -> _QueryCache:
     return cache
 
 
-def _get_query(registry: Registry, query: _Query) -> Set[Entity]:
+def _get_query(registry: Registry, query: _Query) -> AbstractSet[Entity]:
     """Return the entities for the given query and registry."""
     cache = _get_query_cache(registry)
     if cache is not None:
@@ -167,7 +169,7 @@ class _Query(Protocol):
         """Add this query to the local cache."""
         ...
 
-    def _compile(self, registry: Registry, cache: _QueryCache) -> Set[Entity]:
+    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:
         """Compile the entities of this query, returning a set which must not be modified."""
         ...
 
@@ -178,10 +180,10 @@ class _QueryComponent:
 
     _component: ComponentKey[object]
 
-    def _add_to_cache(self, registry: Registry, cache: _QueryCache) -> None:
+    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) -> Set[Entity]:
+    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
         return registry._components_by_type.get(self._component, {}).keys()
 
 
@@ -191,10 +193,10 @@ class _QueryTag:
 
     _tag: object
 
-    def _add_to_cache(self, registry: Registry, cache: _QueryCache) -> None:
+    def _add_to_cache(self, registry: Registry, cache: _QueryCache) -> None:  # noqa: ARG002
         cache.by_tags[self._tag].add(self)
 
-    def _compile(self, registry: Registry, cache: _QueryCache) -> Set[Entity]:
+    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
         return registry._tags_by_key.get(self._tag, set())
 
 
@@ -220,7 +222,7 @@ class _QueryRelation:
         if w_query is not None:
             _get_query_cache(w_query.registry).dependencies[w_query._query].add((registry, self))
 
-    def _compile(self, registry: Registry, cache: _QueryCache) -> Set[Entity]:
+    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
         return _fetch_relation_table(registry, self._relation)
 
 
@@ -242,7 +244,7 @@ class _QueryLogicalAnd:
         for dependency in itertools.chain(self._all_of, self._none_of):
             cache.dependencies[dependency].add((registry, self))
 
-    def _compile(self, registry: Registry, cache: _QueryCache) -> Set[Entity]:
+    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
         if len(self._all_of) == 1 and not self._none_of:  # Only one sub-query, simply return the results of it
             return _get_query(registry, next(iter(self._all_of)))  # Avoids an extra copy of a set
         requires = sorted(  # Place the smallest sets first to speed up intersections
@@ -271,7 +273,7 @@ class _QueryLogicalOr:
         for dependency in self._any_of:
             cache.dependencies[dependency].add((registry, self))
 
-    def _compile(self, registry: Registry, cache: _QueryCache) -> Set[Entity]:
+    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
         if len(self._any_of) == 1:  # If there is only one sub-query then simply return the results of it
             return _get_query(registry, next(iter(self._any_of)))  # Avoids an extra copy of a set
         entities: set[Entity] = set()
@@ -300,7 +302,7 @@ class _QueryTraversalPropagation:
         cache.dependencies[self._sub_query].add((registry, self))
         cache.dependencies[self._get_traverse_query()].add((registry, self))
 
-    def _compile(self, registry: Registry, cache: _QueryCache) -> Set[Entity]:
+    def _compile(self, registry: Registry, cache: _QueryCache) -> AbstractSet[Entity]:  # noqa: ARG002
         cumulative_set = set(_get_query(registry, self._sub_query))  # All entities touched by this traversal
         relations_set = _get_query(
             registry, self._get_traverse_query()
@@ -341,7 +343,7 @@ class BoundQuery:
             warnings.warn("Use '.registry' instead of '.world'", DeprecationWarning, stacklevel=2)
         return self.registry
 
-    def get_entities(self) -> Set[Entity]:
+    def get_entities(self) -> AbstractSet[Entity]:
         """Return entities matching the current query as a read-only set.
 
         This is useful for post-processing the results of a query using set operations.
@@ -350,6 +352,10 @@ class BoundQuery:
         """
         return _get_query(self.registry, self._query)
 
+    def __bool__(self) -> bool:
+        """Return True if any entity matches this query."""
+        return bool(self.get_entities())
+
     @staticmethod
     def __as_queries(
         components: Iterable[ComponentKey[object]] = (),
@@ -364,7 +370,7 @@ class BoundQuery:
         yield from (_QueryTraversalPropagation(_QueryTag(tag), traverse, depth) for tag in tags)
         yield from (_QueryTraversalPropagation(_QueryRelation(relations), traverse, depth) for relations in relations)
 
-    def all_of(  # noqa: PLR0913
+    def all_of(
         self,
         components: Iterable[ComponentKey[object]] = (),
         *,
@@ -381,7 +387,7 @@ class BoundQuery:
             & self._query,
         )
 
-    def none_of(  # noqa: PLR0913
+    def none_of(
         self,
         components: Iterable[ComponentKey[object]] = (),
         *,
@@ -403,42 +409,36 @@ class BoundQuery:
         return iter(self.get_entities())
 
     @overload
-    def __getitem__(self, key: tuple[ComponentKey[_T1]]) -> Iterable[tuple[_T1]]:
-        ...
+    def __getitem__(self, key: tuple[ComponentKey[_T1]]) -> Iterable[tuple[_T1]]: ...
 
     @overload
-    def __getitem__(self, key: tuple[ComponentKey[_T1], ComponentKey[_T2]]) -> Iterable[tuple[_T1, _T2]]:
-        ...
+    def __getitem__(self, key: tuple[ComponentKey[_T1], ComponentKey[_T2]]) -> Iterable[tuple[_T1, _T2]]: ...
 
     @overload
     def __getitem__(
         self, key: tuple[ComponentKey[_T1], ComponentKey[_T2], ComponentKey[_T3]]
-    ) -> Iterable[tuple[_T1, _T2, _T3]]:
-        ...
+    ) -> Iterable[tuple[_T1, _T2, _T3]]: ...
 
     @overload
     def __getitem__(
         self, key: tuple[ComponentKey[_T1], ComponentKey[_T2], ComponentKey[_T3], ComponentKey[_T4]]
-    ) -> Iterable[tuple[_T1, _T2, _T3, _T4]]:
-        ...
+    ) -> Iterable[tuple[_T1, _T2, _T3, _T4]]: ...
 
     @overload
     def __getitem__(
         self,
         key: tuple[ComponentKey[_T1], ComponentKey[_T2], ComponentKey[_T3], ComponentKey[_T4], ComponentKey[_T5]],
-    ) -> Iterable[tuple[_T1, _T2, _T3, _T4, _T5]]:
-        ...
+    ) -> Iterable[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
 
     @overload
-    def __getitem__(self, key: tuple[ComponentKey[object], ...]) -> Iterable[tuple[Any, ...]]:
-        ...
+    def __getitem__(self, key: tuple[ComponentKey[object], ...]) -> Iterable[tuple[Any, ...]]: ...
 
     def __getitem__(self, key: tuple[ComponentKey[object], ...]) -> Iterable[tuple[Any, ...]]:
         """Collect components from a query."""
         assert key is not None
         assert isinstance(key, tuple)
 
-        Entity = tcod.ecs.entity.Entity
+        Entity = tcod.ecs.entity.Entity  # noqa: N806
 
         entities = list(self.all_of(components=set(key) - {Entity}).get_entities())
         entity_components = []

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/registry.py

@@ -1,16 +1,19 @@
 """Registry management tools."""
+
 from __future__ import annotations
 
 import warnings
 from collections import defaultdict
-from typing import Any, DefaultDict, Dict, Iterable, Mapping, NoReturn, Set, TypeVar
+from typing import TYPE_CHECKING, Any, DefaultDict, Dict, Final, Iterable, Mapping, NoReturn, Set, TypeVar
 
 import attrs
 
 import tcod.ecs._converter
 import tcod.ecs.query
 from tcod.ecs.entity import Entity
-from tcod.ecs.typing import ComponentKey, _RelationTargetLookup
+
+if TYPE_CHECKING:
+    from tcod.ecs.typing import ComponentKey, _RelationTargetLookup
 
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
@@ -110,9 +113,9 @@ class Registry:
 
     dict[entity][tag] = {target_entities}
     """
-    _relation_components_by_entity: defaultdict[
-        Entity, defaultdict[ComponentKey[object], dict[Entity, Any]]
-    ] = attrs.field(init=False, factory=lambda: defaultdict(_defaultdict_of_dict))
+    _relation_components_by_entity: defaultdict[Entity, defaultdict[ComponentKey[object], dict[Entity, Any]]] = (
+        attrs.field(init=False, factory=lambda: defaultdict(_defaultdict_of_dict))
+    )
     """Random access relations owning components.
 
     dict[entity][ComponentKey][target_entity] = component
@@ -177,7 +180,7 @@ class Registry:
         global_: Entity | None = state.pop("global_", None)  # Migrate from version <=1.2.0
 
         # These attributes contain redundant data and will be removed
-        REDUNDANT_ATTRIBUTES = frozenset(
+        redundant_attributes: Final = frozenset(
             {
                 "_components_by_entity",  # <=3.4.0
                 "_tags_by_key",  # <=3.4.0
@@ -185,7 +188,7 @@ class Registry:
                 "_names_by_entity",  # <=3.4.0
             }
         )
-        for ignored in REDUNDANT_ATTRIBUTES:
+        for ignored in redundant_attributes:
             state.pop(ignored, None)
 
         converter = tcod.ecs._converter._get_converter()
@@ -306,7 +309,7 @@ class Registry:
         return entity
 
     @property
-    def Q(self) -> tcod.ecs.query.BoundQuery:
+    def Q(self) -> tcod.ecs.query.BoundQuery:  # noqa: N802
         """Start a new Query for this registry.
 
         Alias for ``tcod.ecs.Query(registry)``.

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/typing.py

@@ -1,4 +1,5 @@
 """Common type-hints for tcod.ecs."""
+
 from __future__ import annotations
 
 import sys
@@ -30,7 +31,7 @@ _RelationTargetLookup: TypeAlias = Union[Entity, EllipsisType]
 _RelationQueryTarget: TypeAlias = Union[_RelationTargetLookup, BoundQuery]
 """Possible target for relation queries."""
 
-_RelationQuery: TypeAlias = Union[Tuple[object, _RelationQueryTarget], Tuple[_RelationQueryTarget, object, None]]
+_RelationQuery: TypeAlias = Union[Tuple[object, _RelationQueryTarget], Tuple[_RelationQueryTarget, object, None]]  # noqa: PYI047
 """Query format for relations.
 
 One of 4 formats:

{tcod_ecs-5.1.0 → tcod_ecs-5.2.0}/tcod/ecs/world.py

@@ -1,4 +1,6 @@
 # noqa: D100
+from __future__ import annotations
+
 __all__ = ("World",)
 
 from tcod.ecs.registry import Registry as World