Ensure @OverRide is added to every overriding method/property

Add @OverRide decorators and test that enforces decorator on overriding methods/properties

Author: FancyNeuron

src/spellbind/actions.py

@@ -4,6 +4,8 @@
 from abc import ABC
 from typing import TypeVar, Generic, overload, TYPE_CHECKING, TypeAlias, Callable, Iterable
 
+from typing_extensions import override
+
 from spellbind.values import Value, OneToOneValue, Constant, SimpleVariable, TwoToOneValue, \
     ManyToSameValue, ThreeToOneValue
 
@@ -137,12 +139,14 @@ def create(transformer: Callable[[Iterable[bool]], bool], values: Iterable[BoolL
 
 class BoolConstant(BoolValue, Constant[bool]):
     @classmethod
+    @override
     def of(cls, value: bool) -> BoolConstant:
         if value:
             return TRUE
         return FALSE
 
     @property
+    @override
     def logical_not(self) -> BoolConstant:
         return BoolConstant.of(not self.value)
 
@@ -153,6 +157,7 @@ class BoolVariable(SimpleVariable[bool], BoolValue):
 
 class ThreeToBoolValue(ThreeToOneValue[_S, _T, _U, bool], BoolValue):
     @staticmethod
+    @override
     def create(transformer: Callable[[_S, _T, _U], bool],
                first: _S | Value[_S], second: _T | Value[_T], third: _U | Value[_U]) -> BoolValue:
         return ThreeToBoolValue(transformer, first, second, third)

src/spellbind/bool_values.py

@@ -1,4 +1,4 @@
-from typing import Callable, TypeVar, Generic, Iterable, Sequence
+from typing import Callable, TypeVar, Generic, Iterable, Sequence, override
 
 from spellbind.emitters import Emitter, TriEmitter, BiEmitter, ValueEmitter, ValuesEmitter
 from spellbind.observables import Observable, ValueObservable, BiObservable, TriObservable, Observer, \
@@ -12,17 +12,21 @@
 
 
 class Event(_BaseObservable[Observer], Observable, Emitter):
+    @override
     def _get_parameter_count(self) -> int:
         return 0
 
+    @override
     def __call__(self) -> None:
         self._emit_nothing()
 
 
 class ValueEvent(Generic[_S], _SingleBaseObservable[Observer | ValueObserver[_S]], ValueObservable[_S], ValueEmitter[_S]):
+    @override
     def _get_parameter_count(self) -> int:
         return 1
 
+    @override
     def __call__(self, value: _S) -> None:
         self._emit_single(value)
 
@@ -31,9 +35,11 @@ def emit_lazy(self, func: Callable[[], _S]) -> None:
 
 
 class BiEvent(Generic[_S, _T], _BaseObservable[Observer | ValueObserver[_S] | BiObserver[_S, _T]], BiObservable[_S, _T], BiEmitter[_S, _T]):
+    @override
     def _get_parameter_count(self) -> int:
         return 2
 
+    @override
     def __call__(self, value_0: _S, value_1: _T) -> None:
         self._emit_n((value_0, value_1))
 
@@ -42,14 +48,17 @@ class TriEvent(Generic[_S, _T, _U],
                _BaseObservable[Observer | ValueObserver[_S] | BiObserver[_S, _T] | TriObserver[_S, _T, _U]],
                TriObservable[_S, _T, _U],
                TriEmitter[_S, _T, _U]):
+    @override
     def _get_parameter_count(self) -> int:
         return 3
 
+    @override
     def __call__(self, value_0: _S, value_1: _T, value_2: _U) -> None:
         self._emit_n((value_0, value_1, value_2))
 
 
 class ValuesEvent(Generic[_S], _BaseValuesObservable[Observer | ValuesObserver[_S]], ValuesObservable[_S], ValuesEmitter[_S]):
+    @override
     def __call__(self, value: Iterable[_S]) -> None:
         self._emit_single(value)
 

src/spellbind/event.py

@@ -3,7 +3,7 @@
 import math
 import operator
 from abc import ABC
-from typing import Generic, Callable, Sequence, TypeVar, overload
+from typing import Generic, Callable, Sequence, TypeVar, overload, override
 
 from typing_extensions import Self
 from typing_extensions import TYPE_CHECKING
@@ -206,17 +206,20 @@ class FloatConstant(FloatValue, Constant[float]):
     _cache: dict[float, FloatConstant] = {}
 
     @classmethod
+    @override
     def of(cls, value: float) -> FloatConstant:
         try:
             return FloatConstant._cache[value]
         except KeyError:
             return FloatConstant(value)
 
+    @override
     def __abs__(self):
         if self.value >= 0:
             return self
         return FloatConstant.of(-self.value)
 
+    @override
     def __neg__(self):
         return FloatConstant.of(-self.value)
 
@@ -245,9 +248,11 @@ def __init__(self, transformer: Callable[[float], _S], of: FloatLike):
         super().__init__(*[v for v in (of,) if isinstance(v, Value)])
 
     @property
+    @override
     def value(self) -> _S:
         return self._value
 
+    @override
     def _calculate_value(self) -> _S:
         return self._transformer(self._getter())
 
@@ -277,12 +282,14 @@ def __init__(self, transformer: Callable[[Sequence[float]], _S], *values: FloatL
         self._transformer = transformer
         super().__init__(*[v for v in self._input_values if isinstance(v, Value)])
 
+    @override
     def _calculate_value(self) -> _S:
         gotten_values = [getter() for getter in self._value_getters]
         return self._transformer(gotten_values)
 
 
 class ManyFloatsToFloatValue(ManyFloatsToOneValue[float], FloatValue):
+    @override
     def decompose_float_operands(self, operator_: Callable) -> Sequence[FloatLike]:
         if self._transformer == operator_:
             return self._input_values
@@ -299,11 +306,13 @@ def __init__(self, transformer: Callable[[float, float], _S],
         self._second_getter = _create_float_getter(second)
         super().__init__(*[v for v in (first, second) if isinstance(v, Value)])
 
+    @override
     def _calculate_value(self) -> _S:
         return self._transformer(self._first_getter(), self._second_getter())
 
 
 class TwoFloatsToFloatsValue(TwoFloatsToOneValue[float], FloatValue):
+    @override
     def decompose_float_operands(self, operator_: Callable) -> Sequence[FloatLike]:
         if self._transformer == operator_:
             return self._of_first, self._of_second
@@ -322,11 +331,13 @@ def __init__(self, transformer: Callable[[float, float, float], _S],
         self._third_getter = _create_float_getter(third)
         super().__init__(*[v for v in (first, second, third) if isinstance(v, Value)])
 
+    @override
     def _calculate_value(self) -> _S:
         return self._transformer(self._first_getter(), self._second_getter(), self._third_getter())
 
 
 class ThreeFloatToFloatValue(ThreeFloatToOneValue[float], FloatValue):
+    @override
     def decompose_float_operands(self, operator_: Callable) -> Sequence[FloatLike]:
         if self._transformer == operator_:
             return self._of_first, self._of_second, self._of_third
@@ -335,6 +346,7 @@ def decompose_float_operands(self, operator_: Callable) -> Sequence[FloatLike]:
 
 class ThreeToFloatValue(ThreeToOneValue[_S, _T, _U, float], FloatValue):
     @classmethod
+    @override
     def create(cls, transformer: Callable[[_S, _T, _U], float],
                first: _S | Value[_S], second: _T | Value[_T], third: _U | Value[_U]) -> FloatValue:
         return ThreeToFloatValue(transformer, first, second, third)
@@ -344,6 +356,7 @@ class AbsFloatValue(OneFloatToOneValue[float], FloatValue):
     def __init__(self, value: FloatLike):
         super().__init__(abs, value)
 
+    @override
     def __abs__(self) -> Self:
         return self
 
@@ -352,6 +365,7 @@ class NegateFloatValue(OneFloatToFloatValue, FloatValue):
     def __init__(self, value: FloatLike):
         super().__init__(operator.neg, value)
 
+    @override
     def __neg__(self) -> FloatValue:
         of = self._of
         if isinstance(of, FloatValue):

src/spellbind/float_values.py

@@ -3,7 +3,7 @@
 import operator
 from abc import ABC, abstractmethod
 from functools import cached_property
-from typing import Iterable, Callable, Any
+from typing import Iterable, Callable, Any, override
 
 from typing_extensions import TypeIs
 
@@ -66,6 +66,7 @@ def __init__(self, sequence: IntValueSequence):
 
 class IntValueSequence(ValueSequence[int], IntValueCollection, ABC):
     @cached_property
+    @override
     def unboxed(self) -> ObservableIntSequence:
         return UnboxedIntValueSequence(self)
 

src/spellbind/int_collections.py

@@ -2,7 +2,7 @@
 
 import operator
 from abc import ABC
-from typing import overload, Generic, Callable, Iterable
+from typing import overload, Generic, Callable, Iterable, override
 
 from typing_extensions import Self, TypeVar
 
@@ -197,6 +197,7 @@ class TwoToIntValue(Generic[_S, _T], TwoToOneValue[_S, _T, int], IntValue):
 
 class ThreeToIntValue(Generic[_S, _T, _U], ThreeToOneValue[_S, _T, _U, int], IntValue):
     @staticmethod
+    @override
     def create(transformer: Callable[[_S, _T, _U], int], first: _S | Value[_S], second: _T | Value[_T], third: _U | Value[_U]) -> IntValue:
         return ThreeToIntValue(transformer, first, second, third)
 
@@ -205,17 +206,20 @@ class IntConstant(IntValue, Constant[int]):
     _cache: dict[int, IntConstant] = {}
 
     @classmethod
+    @override
     def of(cls, value: int) -> IntConstant:
         try:
             return cls._cache[value]
         except KeyError:
             return IntConstant(value)
 
+    @override
     def __abs__(self):
         if self.value >= 0:
             return self
         return IntConstant.of(-self.value)
 
+    @override
     def __neg__(self):
         return IntConstant.of(-self.value)
 
@@ -239,6 +243,7 @@ class AbsIntValue(OneToOneValue[int, int], IntValue):
     def __init__(self, value: Value[int]):
         super().__init__(abs, value)
 
+    @override
     def __abs__(self) -> Self:
         return self
 
@@ -247,6 +252,7 @@ class NegateIntValue(OneToOneValue[int, int], IntValue):
     def __init__(self, value: Value[int]):
         super().__init__(operator.neg, value)
 
+    @override
     def __neg__(self) -> IntValue:
         of = self._of
         if isinstance(of, IntValue):

src/spellbind/int_values.py

@@ -2,7 +2,7 @@
 
 import functools
 from abc import ABC, abstractmethod
-from typing import TypeVar, Generic, Collection, Callable, Iterable, Iterator
+from typing import TypeVar, Generic, Collection, Callable, Iterable, Iterator, override
 
 from spellbind.actions import CollectionAction, DeltaAction, DeltasAction, ClearAction
 from spellbind.event import BiEvent
@@ -29,6 +29,7 @@ def delta_observable(self) -> ValuesObservable[DeltaAction[_S_co]]: ...
     @abstractmethod
     def length_value(self) -> IntValue: ...
 
+    @override
     def __len__(self) -> int:
         return self.length_value.value
 
@@ -115,19 +116,23 @@ def _set_value(self, value: _S):
             self._on_change(value, old_value)
 
     @property
+    @override
     def value(self) -> _S:
         return self._value
 
     @property
+    @override
     def observable(self) -> BiObservable[_S, _S]:
         return self._on_change
 
     @property
+    @override
     def derived_from(self) -> frozenset[Value]:
         return EMPTY_FROZEN_SET
 
 
 class ValueCollection(ObservableCollection[Value[_S]], Generic[_S], ABC):
+    @override
     def reduce_to_int(self,
                       add_reducer: Callable[[int, Value[_S]], int],
                       remove_reducer: Callable[[int, Value[_S]], int],
@@ -156,6 +161,7 @@ def __init__(self, collection: ObservableCollection[_T], combiner: Callable[[Ite
         self._on_change: BiEvent[_S, _S] = BiEvent[_S, _S]()
 
     @property
+    @override
     def observable(self) -> BiObservable[_S, _S]:
         return self._on_change
 
@@ -166,9 +172,11 @@ def _recalculate_value(self):
             self._on_change(self._value, old_value)
 
     @property
+    @override
     def value(self) -> _S:
         return self._value
 
     @property
+    @override
     def derived_from(self) -> frozenset[Value]:
         return EMPTY_FROZEN_SET