From 75d3d5750395713961c4234bc3bd3490173e839e Mon Sep 17 00:00:00 2001 From: Georg Plaz Date: Wed, 23 Jul 2025 20:40:20 +0200 Subject: [PATCH] Make Value inherit from Observable again Remove method __or__, since it conflicts with BoolValue.__or__. Replace with function combine_observables in module observables Rename some methods in Observable, so they functionality is less confusing when working with Values --- src/spellbind/observable_collections.py | 51 +++++++--- src/spellbind/observable_sequences.py | 20 ++-- src/spellbind/observables.py | 59 +++++++----- src/spellbind/values.py | 95 +++++++++++-------- .../test_bi_events/test_derive_bi_event.py | 20 ++-- .../test_bi_events/test_or_bi_events.py | 9 +- .../test_events/test_events/test_or_events.py | 6 +- .../test_derive_value_events.py | 26 ++--- .../test_value_events/test_or_value_events.py | 8 +- .../test_value_events/test_value_events.py | 2 +- 10 files changed, 178 insertions(+), 118 deletions(-) diff --git a/src/spellbind/observable_collections.py b/src/spellbind/observable_collections.py index 9795403..f177d26 100644 --- a/src/spellbind/observable_collections.py +++ b/src/spellbind/observable_collections.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, Any from typing_extensions import override @@ -10,7 +10,8 @@ from spellbind.deriveds import Derived from spellbind.event import BiEvent from spellbind.int_values import IntValue -from spellbind.observables import ValuesObservable, ValueObservable, BiObservable +from spellbind.observables import ValuesObservable, ValueObservable, Observer, ValueObserver, BiObserver, \ + Subscription from spellbind.str_values import StrValue from spellbind.values import Value, EMPTY_FROZEN_SET @@ -121,16 +122,29 @@ def _set_value(self, value: _S) -> None: 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[Derived]: return EMPTY_FROZEN_SET + @override + def observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.observe(observer, times=times) + + @override + def weak_observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.weak_observe(observer, times=times) + + @override + def unobserve(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S]) -> None: + self._on_change.unobserve(observer) + + @override + def is_observed(self, by: Callable[..., Any] | None = None) -> bool: + return self._on_change.is_observed(by=by) + class ValueCollection(ObservableCollection[Value[_S]], Generic[_S], ABC): @override @@ -161,11 +175,6 @@ def __init__(self, collection: ObservableCollection[_T], combiner: Callable[[Ite self._collection.on_change.observe(self._recalculate_value) self._on_change: BiEvent[_S, _S] = BiEvent[_S, _S]() - @property - @override - def observable(self) -> BiObservable[_S, _S]: - return self._on_change - def _recalculate_value(self) -> None: old_value = self._value self._value = self._combiner(self._collection) @@ -181,3 +190,21 @@ def value(self) -> _S: @override def derived_from(self) -> frozenset[Derived]: return EMPTY_FROZEN_SET + + @override + def observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.observe(observer, times=times) + + @override + def weak_observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.weak_observe(observer, times=times) + + @override + def unobserve(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S]) -> None: + self._on_change.unobserve(observer) + + @override + def is_observed(self, by: Callable[..., Any] | None = None) -> bool: + return self._on_change.is_observed(by=by) diff --git a/src/spellbind/observable_sequences.py b/src/spellbind/observable_sequences.py index 5952be3..bc20011 100644 --- a/src/spellbind/observable_sequences.py +++ b/src/spellbind/observable_sequences.py @@ -1,13 +1,12 @@ from __future__ import annotations -from functools import cached_property - -from typing_extensions import TypeIs, Self, override - from abc import ABC, abstractmethod +from functools import cached_property from typing import Sequence, Generic, MutableSequence, Iterable, overload, SupportsIndex, Callable, Iterator, \ TypeVar, Any +from typing_extensions import TypeIs, Self, override + from spellbind import int_values from spellbind.actions import AtIndicesDeltasAction, ClearAction, ReverseAction, OneElementChangedAction, \ AtIndexDeltaAction, \ @@ -19,7 +18,8 @@ from spellbind.event import ValueEvent from spellbind.int_values import IntVariable, IntValue from spellbind.observable_collections import ObservableCollection, ValueCollection -from spellbind.observables import ValueObservable, ValuesObservable, void_value_observable, void_values_observable +from spellbind.observables import ValueObservable, ValuesObservable, void_value_observable, void_values_observable, \ + combine_values_observables, combine_value_observables from spellbind.values import Value, NotConstantError, Constant _S = TypeVar("_S") @@ -251,7 +251,7 @@ def __init__(self, iterable: Iterable[_S] = ()): self._values = list(iterable) self._action_event = ValueEvent[AtIndicesDeltasAction[_S] | ClearAction[_S] | ReverseAction[_S]]() self._deltas_event = ValueEvent[AtIndicesDeltasAction[_S]]() - self._delta_observable = self._deltas_event.map_to_many( + self._delta_observable = self._deltas_event.map_to_values_observable( transformer=lambda deltas_action: deltas_action.delta_actions ) self._len_value = IntVariable(len(self._values)) @@ -558,15 +558,15 @@ def __init__(self, iterable: Iterable[Value[_S]] = ()): super().__init__(iterable) self._cells = {} - self._on_value_action = self.on_change.map(lambda action: action.map(lambda item: item.value)) + self._on_value_action = self.on_change.map_to_value_observable(lambda action: action.map(lambda item: item.value)) self._on_value_changed_event = ValueEvent[ValueChangedMultipleTimesAction[_S]]() - self._final_on_value_action = self._on_value_action.or_value(self._on_value_changed_event) + self._final_on_value_action = combine_value_observables(self._on_value_action, self._on_value_changed_event) self._on_value_delta_action = self.delta_observable.map(lambda action: action.map(lambda item: item.value)) - self._on_value_delta_action_event = self._on_value_changed_event.map_to_many( + self._on_value_delta_action_event = self._on_value_changed_event.map_to_values_observable( transformer=lambda deltas_action: deltas_action.delta_actions ) - self._final_on_value_delta_action = self._on_value_delta_action.or_values(self._on_value_delta_action_event) + self._final_on_value_delta_action = combine_values_observables(self._on_value_delta_action, self._on_value_delta_action_event) self.delta_observable.observe_single(self._on_value_sequence_delta) for value in self: diff --git a/src/spellbind/observables.py b/src/spellbind/observables.py index 5bca139..eed4e68 100644 --- a/src/spellbind/observables.py +++ b/src/spellbind/observables.py @@ -195,7 +195,7 @@ def unobserve(self, observer: Observer) -> None: ... @abstractmethod def is_observed(self, by: _O | None = None) -> bool: ... - def __or__(self, other: Observable) -> Observable: + def or_observable(self, other: Observable) -> Observable: return CombinedObservable((self, other), weakly=True) @@ -212,23 +212,23 @@ def weak_observe(self, observer: Observer | ValueObserver[_S_co], times: int | N @override def unobserve(self, observer: Observer | ValueObserver[_S_co]) -> None: ... - def map(self, transformer: Callable[[_S_co], _T], weakly: bool = False, - predicate: Callable[[_S_co], bool] | None = None) -> ValueObservable[_T]: + def map_to_value_observable(self, transformer: Callable[[_S_co], _T], weakly: bool = False, + predicate: Callable[[_S_co], bool] | None = None) -> ValueObservable[_T]: return MappedValueObservable(self, transformer, weakly=weakly, predicate=predicate) - def map_to_two(self, transformer: Callable[[_S_co], tuple[_T, _U]], weakly: bool = False, - predicate: Callable[[_S_co], bool] | None = None) -> BiObservable[_T, _U]: + def map_to_bi_observable(self, transformer: Callable[[_S_co], tuple[_T, _U]], weakly: bool = False, + predicate: Callable[[_S_co], bool] | None = None) -> BiObservable[_T, _U]: return SplitOneInTwoObservable(self, transformer, weakly=weakly, predicate=predicate) - def map_to_three(self, transformer: Callable[[_S_co], tuple[_T, _U, _V]], weakly: bool = False, - predicate: Callable[[_S_co], bool] | None = None) -> TriObservable[_T, _U, _V]: + def map_to_tri_observable(self, transformer: Callable[[_S_co], tuple[_T, _U, _V]], weakly: bool = False, + predicate: Callable[[_S_co], bool] | None = None) -> TriObservable[_T, _U, _V]: return SplitOneInThreeObservable(self, transformer, weakly=weakly, predicate=predicate) - def map_to_many(self, transformer: Callable[[_S_co], tuple[_T, ...]], weakly: bool = False, - predicate: Callable[[_S_co], bool] | None = None) -> ValuesObservable[_T]: + def map_to_values_observable(self, transformer: Callable[[_S_co], tuple[_T, ...]], weakly: bool = False, + predicate: Callable[[_S_co], bool] | None = None) -> ValuesObservable[_T]: return SplitOneInManyObservable(self, transformer, weakly=weakly, predicate=predicate) - def or_value(self, other: ValueObservable[_T]) -> ValueObservable[_S_co | _T]: + def or_value_observable(self, other: ValueObservable[_T]) -> ValueObservable[_S_co | _T]: return CombinedValueObservable((self, other), weakly=True) @@ -247,21 +247,18 @@ def weak_observe(self, observer: Observer | ValueObserver[_S_co] | BiObserver[_S @override def unobserve(self, observer: Observer | ValueObserver[_S_co] | BiObserver[_S_co, _T_co]) -> None: ... - def map_to_one(self, transformer: Callable[[_S_co, _T_co], _U], weakly: bool = False, - predicate: Callable[[_S_co, _T_co], bool] | None = None) -> ValueObservable[_U]: + def map_to_value_observable(self, transformer: Callable[[_S_co, _T_co], _U], weakly: bool = False, + predicate: Callable[[_S_co, _T_co], bool] | None = None) -> ValueObservable[_U]: return MergeTwoToOneObservable(self, transformer, weakly=weakly, predicate=predicate) - def map(self, transformer: Callable[[_S_co, _T_co], tuple[_U, _V]], weakly: bool = False, - predicate: Callable[[_S_co, _T_co], bool] | None = None) -> BiObservable[_U, _V]: + def map_to_bi_observable(self, transformer: Callable[[_S_co, _T_co], tuple[_U, _V]], weakly: bool = False, + predicate: Callable[[_S_co, _T_co], bool] | None = None) -> BiObservable[_U, _V]: return MappedBiObservable(self, transformer, weakly=weakly, predicate=predicate) - def map_to_three(self, transformer: Callable[[_S_co, _T_co], tuple[_U, _V, _W]], weakly: bool = False, - predicate: Callable[[_S_co, _T_co], bool] | None = None) -> TriObservable[_U, _V, _W]: + def map_to_tri_observable(self, transformer: Callable[[_S_co, _T_co], tuple[_U, _V, _W]], weakly: bool = False, + predicate: Callable[[_S_co, _T_co], bool] | None = None) -> TriObservable[_U, _V, _W]: return SplitTwoToThreeObservable(self, transformer, weakly=weakly, predicate=predicate) - def or_bi(self, other: BiObservable[_S_co, _T_co]) -> BiObservable[_S_co, _T_co]: - return CombinedBiObservable((self, other), weakly=True) - class TriObservable(BiObservable[_S_co, _T_co], Generic[_S_co, _T_co, _U_co], ABC): @abstractmethod @@ -278,9 +275,6 @@ def weak_observe(self, observer: Observer | ValueObserver[_S_co] | BiObserver[_S @override def unobserve(self, observer: Observer | ValueObserver[_S_co] | BiObserver[_S_co, _T_co] | TriObserver[_S_co, _T_co, _U_co]) -> None: ... - def or_tri(self, other: TriObservable[_S_co, _T_co, _U_co]) -> TriObservable[_S_co, _T_co, _U_co]: - return CombinedTriObservable((self, other), weakly=True) - class ValuesObservable(Observable, Generic[_S_co], ABC): @abstractmethod @@ -317,8 +311,25 @@ def map(self, transformer: Callable[[_S_co], _T_co], weakly: bool = False, predicate: Callable[[_S_co], bool] | None = None) -> ValuesObservable[_T_co]: return MappedValuesObservable(self, transformer, weakly=weakly, predicate=predicate) - def or_values(self, other: ValuesObservable[_T]) -> ValuesObservable[_S_co | _T]: - return CombinedValuesObservable((self, other), weakly=True) + +def combine_observables(*observables: Observable, observe_weakly: bool = False) -> Observable: + return CombinedObservable(observables, weakly=observe_weakly) + + +def combine_value_observables(*observables: ValueObservable[_S], observe_weakly: bool = False) -> ValueObservable[_S]: + return CombinedValueObservable(observables, weakly=observe_weakly) + + +def combine_bi_observables(*observables: BiObservable[_S, _T], observe_weakly: bool = False) -> BiObservable[_S, _T]: + return CombinedBiObservable(observables, weakly=observe_weakly) + + +def combine_tri_observables(*observables: TriObservable[_S, _T, _U], observe_weakly: bool = False) -> TriObservable[_S, _T, _U]: + return CombinedTriObservable(observables, weakly=observe_weakly) + + +def combine_values_observables(*observables: ValuesObservable[_S], observe_weakly: bool = False) -> ValuesObservable[_S]: + return CombinedValuesObservable(observables, weakly=observe_weakly) class _BaseObservable(Generic[_O], ABC): diff --git a/src/spellbind/values.py b/src/spellbind/values.py index 7930763..a42a336 100644 --- a/src/spellbind/values.py +++ b/src/spellbind/values.py @@ -1,15 +1,15 @@ from __future__ import annotations -from typing_extensions import deprecated, override - from abc import ABC, abstractmethod from contextlib import contextmanager from typing import TypeVar, Generic, Optional, Iterable, TYPE_CHECKING, Callable, Sequence, ContextManager, \ Generator, Any +from typing_extensions import deprecated, override + from spellbind.deriveds import Derived from spellbind.event import BiEvent -from spellbind.observables import Observer, ValueObserver, BiObservable, BiObserver, Subscription, void_bi_observable +from spellbind.observables import Observer, ValueObserver, BiObservable, BiObserver, Subscription, VOID_SUBSCRIPTION if TYPE_CHECKING: from spellbind.str_values import StrValue # pragma: no cover @@ -38,29 +38,11 @@ class NotConstantError(Exception): pass -class Value(Generic[_S], Derived, ABC): +class Value(BiObservable[_S, _S], Derived, Generic[_S], ABC): @property @abstractmethod def value(self) -> _S: ... - @property - @abstractmethod - def observable(self) -> BiObservable[_S, _S]: ... - - def observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], - times: int | None = None) -> Subscription: - return self.observable.observe(observer=observer, times=times) - - def weak_observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], - times: int | None = None) -> Subscription: - return self.observable.weak_observe(observer=observer, times=times) - - def unobserve(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S]) -> None: - self.observable.unobserve(observer=observer) - - def is_observed(self, by: Callable[..., Any] | None = None) -> bool: - return self.observable.is_observed(by=by) - def to_str(self) -> StrValue: from spellbind.str_values import ToStrValue return ToStrValue(self) @@ -229,11 +211,6 @@ def _set_value_bypass_bound_check(self, new_value: _S) -> None: self._value = new_value self._on_change(new_value, old_value) - @property - @override - def observable(self) -> BiObservable[_S, _S]: - return self._on_change - @override def bind(self, value: Value[_S], already_bound_ok: bool = False, bind_weakly: bool = True) -> None: if value is self: @@ -274,6 +251,24 @@ def unbind(self, not_bound_ok: bool = False) -> None: def derived_from(self) -> frozenset[Value[_S]]: return self._bound_to_set + @override + def observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.observe(observer=observer, times=times) + + @override + def weak_observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.weak_observe(observer=observer, times=times) + + @override + def unobserve(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S]) -> None: + self._on_change.unobserve(observer=observer) + + @override + def is_observed(self, by: Callable[..., Any] | None = None) -> bool: + return self._on_change.is_observed(by=by) + class Constant(Value[_S], Generic[_S]): _value: _S @@ -286,11 +281,6 @@ def __init__(self, value: _S) -> None: def value(self) -> _S: return self._value - @property - @override - def observable(self) -> BiObservable[_S, _S]: - return void_bi_observable() - @property @override def derived_from(self) -> frozenset[Derived]: @@ -314,6 +304,24 @@ def constant_value_or_raise(self) -> _S: def of(cls, value: _S) -> Constant[_S]: return Constant(value) + @override + def observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return VOID_SUBSCRIPTION + + @override + def weak_observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return VOID_SUBSCRIPTION + + @override + def unobserve(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S]) -> None: + pass + + @override + def is_observed(self, by: Callable[..., Any] | None = None) -> bool: + return False + @override def __eq__(self, other: object) -> bool: if not isinstance(other, Constant): @@ -334,11 +342,6 @@ def __init__(self, *derived_from: Value[Any]): value.weak_observe(self._on_dependency_changed) self._value = self._calculate_value() - @property - @override - def observable(self) -> BiObservable[_S, _S]: - return self._on_change - @property @override def derived_from(self) -> frozenset[Derived]: @@ -359,6 +362,24 @@ def _calculate_value(self) -> _S: ... def value(self) -> _S: return self._value + @override + def observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.observe(observer=observer, times=times) + + @override + def weak_observe(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S], + times: int | None = None) -> Subscription: + return self._on_change.weak_observe(observer=observer, times=times) + + @override + def unobserve(self, observer: Observer | ValueObserver[_S] | BiObserver[_S, _S]) -> None: + self._on_change.unobserve(observer=observer) + + @override + def is_observed(self, by: Callable[..., Any] | None = None) -> bool: + return self._on_change.is_observed(by=by) + class OneToOneValue(DerivedValueBase[_T], Generic[_S, _T]): _getter: Callable[[], _S] diff --git a/tests/test_events/test_bi_events/test_derive_bi_event.py b/tests/test_events/test_bi_events/test_derive_bi_event.py index 58e9842..344fc92 100644 --- a/tests/test_events/test_bi_events/test_derive_bi_event.py +++ b/tests/test_events/test_bi_events/test_derive_bi_event.py @@ -4,7 +4,7 @@ def test_bi_event_merge(): event = BiEvent[str, int]() - merged = event.map_to_one(lambda s, i: f"{s}-{i}") + merged = event.map_to_value_observable(lambda s, i: f"{s}-{i}") observer = OneParameterObserver() merged.observe(observer) event("foo", 1) @@ -15,7 +15,7 @@ def test_bi_event_merge(): def test_bi_event_merge_predicate(): event = BiEvent[str, int]() - merged = event.map_to_one(lambda s, i: f"{s}-{i}", predicate=lambda s, i: i % 2 == 0) + merged = event.map_to_value_observable(lambda s, i: f"{s}-{i}", predicate=lambda s, i: i % 2 == 0) observer = OneParameterObserver() merged.observe(observer) event("foo", 1) @@ -27,7 +27,7 @@ def test_bi_event_merge_predicate(): def test_bi_event_map(): event = BiEvent[str, int]() - mapped = event.map(lambda s, i: (s.upper(), i * 2)) + mapped = event.map_to_bi_observable(lambda s, i: (s.upper(), i * 2)) observer = TwoParametersObserver() mapped.observe(observer) event("foo", 1) @@ -38,7 +38,7 @@ def test_bi_event_map(): def test_bi_event_map_predicate(): event = BiEvent[str, int]() - mapped = event.map(lambda s, i: (s.upper(), i * 2), predicate=lambda s, i: i % 2 == 0) + mapped = event.map_to_bi_observable(lambda s, i: (s.upper(), i * 2), predicate=lambda s, i: i % 2 == 0) observer = TwoParametersObserver() mapped.observe(observer) event("foo", 1) @@ -50,7 +50,7 @@ def test_bi_event_map_predicate(): def test_bi_event_split_to_three(): event = BiEvent[str, int]() - split = event.map_to_three(lambda s, i: (s[0], s[1:], i)) + split = event.map_to_tri_observable(lambda s, i: (s[0], s[1:], i)) observer = ThreeParametersObserver() split.observe(observer) event("foo", 1) @@ -61,7 +61,7 @@ def test_bi_event_split_to_three(): def test_bi_event_split_to_three_predicate(): event = BiEvent[str, int]() - split = event.map_to_three( + split = event.map_to_tri_observable( lambda s, i: (s[0], s[1:], i), predicate=lambda s, i: len(s) > 2 ) @@ -84,7 +84,7 @@ def transform(s: str, i: int) -> str: transform_calls.append((s, i)) return f"{s}-{i}" - merged_event = event.map_to_one(transform) + merged_event = event.map_to_value_observable(transform) event("foo", 1) assert transform_calls == [] assert event_observer.calls == [("foo", 1)] @@ -101,7 +101,7 @@ def transform(s: str, i: int) -> str: def test_unobserve_derived_bi_event(): event = BiEvent[str, int]() observer = OneParameterObserver() - merged_event = event.map_to_one(lambda s, i: f"{s}-{i}") + merged_event = event.map_to_value_observable(lambda s, i: f"{s}-{i}") merged_event.observe(observer) assert event.is_observed() @@ -124,8 +124,8 @@ def merge_fn(s: str, i: int) -> str: merge_calls.append((s, i)) return f"{s}:{i}" - mapped = event.map(map_fn) - merged = mapped.map_to_one(merge_fn) + mapped = event.map_to_bi_observable(map_fn) + merged = mapped.map_to_value_observable(merge_fn) observer = OneParameterObserver() merged.observe(observer) diff --git a/tests/test_events/test_bi_events/test_or_bi_events.py b/tests/test_events/test_bi_events/test_or_bi_events.py index c702252..d6b37ee 100644 --- a/tests/test_events/test_bi_events/test_or_bi_events.py +++ b/tests/test_events/test_bi_events/test_or_bi_events.py @@ -1,11 +1,12 @@ from conftest import NoParametersObserver, Call, TwoParametersObserver, void_observer from spellbind.event import Event, BiEvent +from spellbind.observables import combine_bi_observables def test_adding_value_events_does_not_make_them_observed_until_derived_observed(): event0 = BiEvent[str, str]() event1 = BiEvent[str, str]() - combined_event = event0.or_bi(event1) + combined_event = combine_bi_observables(event0, event1) assert not event0.is_observed() assert not event1.is_observed() @@ -20,7 +21,7 @@ def test_adding_value_events_does_not_make_them_observed_until_derived_observed( def test_adding_value_events_observe_unobserve_makes_value_events_unobserved(): event0 = BiEvent[str, str]() event1 = BiEvent[str, str]() - combined_event = event0.or_bi(event1) + combined_event = combine_bi_observables(event0, event1) combined_event.observe(void_observer) combined_event.unobserve(void_observer) @@ -33,7 +34,7 @@ def test_adding_value_events_observe_unobserve_makes_value_events_unobserved(): def test_calling_either_value_event_triggers_combined_value_event(): event0 = BiEvent[str, str]() event1 = BiEvent[str, str]() - combined_event = event0.or_bi(event1) + combined_event = combine_bi_observables(event0, event1) observer = TwoParametersObserver() combined_event.observe(observer) @@ -47,7 +48,7 @@ def test_calling_either_value_event_triggers_combined_value_event(): def test_combine_value_event_with_event(): event0 = BiEvent[str, str]() event1 = Event() - combined_event = event0 | event1 + combined_event = event0.or_observable(event1) observer = NoParametersObserver() combined_event.observe(observer) diff --git a/tests/test_events/test_events/test_or_events.py b/tests/test_events/test_events/test_or_events.py index 539df64..0266f4d 100644 --- a/tests/test_events/test_events/test_or_events.py +++ b/tests/test_events/test_events/test_or_events.py @@ -6,7 +6,7 @@ def test_or_events_does_not_make_them_observed_until_derived_observed(): event0 = Event() event1 = Event() - combined_event = event0 | event1 + combined_event = event0.or_observable(event1) assert not event0.is_observed() assert not event1.is_observed() @@ -21,7 +21,7 @@ def test_or_events_does_not_make_them_observed_until_derived_observed(): def test_or_events_observe_unobserve_makes_events_unobserved(): event0 = Event() event1 = Event() - combined_event: Observable = event0 | event1 + combined_event: Observable = event0.or_observable(event1) combined_event.observe(void_observer) combined_event.unobserve(void_observer) @@ -34,7 +34,7 @@ def test_or_events_observe_unobserve_makes_events_unobserved(): def test_calling_either_event_triggers_combined_event(): event0 = Event() event1 = Event() - combined_event = event0 | event1 + combined_event = event0.or_observable(event1) observer = NoParametersObserver() combined_event.observe(observer) diff --git a/tests/test_events/test_value_events/test_derive_value_events.py b/tests/test_events/test_value_events/test_derive_value_events.py index e48f9a9..e5a58a3 100644 --- a/tests/test_events/test_value_events/test_derive_value_events.py +++ b/tests/test_events/test_value_events/test_derive_value_events.py @@ -4,7 +4,7 @@ def test_derive_one(): event = ValueEvent[str]() - derived = event.map(lambda s: len(s)) + derived = event.map_to_value_observable(lambda s: len(s)) observer = OneParameterObserver() derived.observe(observer) event("foo bar") @@ -15,7 +15,7 @@ def test_derive_one(): def test_derive_one_predicate(): event = ValueEvent[str]() - derived = event.map(lambda s: len(s), predicate=lambda s: len(s) % 2 == 0) + derived = event.map_to_value_observable(lambda s: len(s), predicate=lambda s: len(s) % 2 == 0) observer = OneParameterObserver() derived.observe(observer) event("foo bar") @@ -28,7 +28,7 @@ def test_derive_one_predicate(): def test_derive_two(): event = ValueEvent[str]() - derived = event.map_to_two(lambda s: (s[0:len(s) // 2], s[len(s) // 2:])) + derived = event.map_to_bi_observable(lambda s: (s[0:len(s) // 2], s[len(s) // 2:])) observer = TwoParametersObserver() derived.observe(observer) event("f") @@ -40,7 +40,7 @@ def test_derive_two(): def test_derive_two_predicate(): event = ValueEvent[str]() - derived = event.map_to_two(lambda s: (s[0:len(s) // 2], s[len(s) // 2:]), predicate=lambda s: len(s) % 2 == 0) + derived = event.map_to_bi_observable(lambda s: (s[0:len(s) // 2], s[len(s) // 2:]), predicate=lambda s: len(s) % 2 == 0) observer = TwoParametersObserver() derived.observe(observer) event("f") @@ -52,7 +52,7 @@ def test_derive_two_predicate(): def test_derive_three(): event = ValueEvent[str]() - derived = event.map_to_three(lambda s: (s[0:len(s) // 3], s[len(s) // 3:2 * len(s) // 3], s[2 * len(s) // 3:])) + derived = event.map_to_tri_observable(lambda s: (s[0:len(s) // 3], s[len(s) // 3:2 * len(s) // 3], s[2 * len(s) // 3:])) observer = ThreeParametersObserver() derived.observe(observer) event("foobar") @@ -63,8 +63,8 @@ def test_derive_three(): def test_derive_three_predicate(): event = ValueEvent[str]() - derived = event.map_to_three(lambda s: (s[0:len(s) // 3], s[len(s) // 3:2 * len(s) // 3], s[2 * len(s) // 3:]), - predicate=lambda s: len(s) % 3 == 0) + derived = event.map_to_tri_observable(lambda s: (s[0:len(s) // 3], s[len(s) // 3:2 * len(s) // 3], s[2 * len(s) // 3:]), + predicate=lambda s: len(s) % 3 == 0) observer = ThreeParametersObserver() derived.observe(observer) event("foobar") @@ -77,7 +77,7 @@ def test_derive_three_predicate(): def test_derive_many(): event = ValueEvent[str]() - derived = event.map_to_many(lambda s: s.split()) + derived = event.map_to_values_observable(lambda s: s.split()) observer = OneParameterObserver() derived.observe(observer) event("foobar") @@ -94,7 +94,7 @@ def test_derive_many(): def test_derive_many_predicate(): event = ValueEvent[str]() - derived = event.map_to_many(lambda s: s.split(), predicate=lambda s: " " in s) + derived = event.map_to_values_observable(lambda s: s.split(), predicate=lambda s: " " in s) observer = OneParameterObserver() derived.observe(observer) event("x") @@ -120,7 +120,7 @@ def plus_one(value: int) -> int: plus_one_calls.append(value) return value + 1 - derived_event = event.map(plus_one) + derived_event = event.map_to_value_observable(plus_one) event(3) assert plus_one_calls == [] assert event_observer.calls == [3] @@ -149,8 +149,8 @@ def times_two(value: int) -> int: times_two_calls.append(value) return value * 2 - derived_1 = event.map(plus_one) - derived_2 = derived_1.map(times_two) + derived_1 = event.map_to_value_observable(plus_one) + derived_2 = derived_1.map_to_value_observable(times_two) event(3) assert plus_one_calls == [] assert times_two_calls == [] @@ -166,7 +166,7 @@ def times_two(value: int) -> int: def test_unobserve_derived_event_silences_makes_event_unobserved(): event = ValueEvent[int]() observer = OneParameterObserver() - derived_event = event.map(lambda x: x + 1) + derived_event = event.map_to_value_observable(lambda x: x + 1) derived_event.observe(observer) assert event.is_observed() diff --git a/tests/test_events/test_value_events/test_or_value_events.py b/tests/test_events/test_value_events/test_or_value_events.py index 9c0a230..b8a7efb 100644 --- a/tests/test_events/test_value_events/test_or_value_events.py +++ b/tests/test_events/test_value_events/test_or_value_events.py @@ -5,7 +5,7 @@ def test_adding_value_events_does_not_make_them_observed_until_derived_observed(): event0 = ValueEvent[str]() event1 = ValueEvent[str]() - combined_event = event0.or_value(event1) + combined_event = event0.or_value_observable(event1) assert not event0.is_observed() assert not event1.is_observed() @@ -20,7 +20,7 @@ def test_adding_value_events_does_not_make_them_observed_until_derived_observed( def test_adding_value_events_observe_unobserve_makes_value_events_unobserved(): event0 = ValueEvent[str]() event1 = ValueEvent[str]() - combined_event = event0.or_value(event1) + combined_event = event0.or_value_observable(event1) combined_event.observe(void_observer) combined_event.unobserve(void_observer) @@ -33,7 +33,7 @@ def test_adding_value_events_observe_unobserve_makes_value_events_unobserved(): def test_calling_either_value_event_triggers_combined_value_event(): event0 = ValueEvent[str]() event1 = ValueEvent[str]() - combined_event = event0.or_value(event1) + combined_event = event0.or_value_observable(event1) observer = OneParameterObserver() combined_event.observe(observer) @@ -47,7 +47,7 @@ def test_calling_either_value_event_triggers_combined_value_event(): def test_combine_value_event_with_event(): event0 = ValueEvent[str]() event1 = Event() - combined_event = event0 | event1 + combined_event = event0.or_observable(event1) observer = NoParametersObserver() combined_event.observe(observer) diff --git a/tests/test_events/test_value_events/test_value_events.py b/tests/test_events/test_value_events/test_value_events.py index 9bb7543..e660943 100644 --- a/tests/test_events/test_value_events/test_value_events.py +++ b/tests/test_events/test_value_events/test_value_events.py @@ -239,7 +239,7 @@ def test_value_event_lazy_evaluate_only_called_when_derived_observed(): def lazy() -> int: lazy_calls.append("lazy") return 3 - derived = event.map(lambda x: x + 1) + derived = event.map_to_value_observable(lambda x: x + 1) event.emit_lazy(lazy) assert lazy_calls == [] derived.observe(void_observer)