classic-signals 0.1.0__tar.gz

classic-signals-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Sergei Variasov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

classic-signals-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: classic-signals
+Version: 0.1.0
+Summary: Simple signals and handlers
+Home-page: https://github.com/variasov/classic-signals
+Author: Sergei Variasov
+Author-email: variasov@gmail.com
+Project-URL: Bug Tracker, https://github.com/variasov/classic-signals/issues
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: readerwriterlock~=1.0.9
+Requires-Dist: classic-components==1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest~=7.4.4; extra == "dev"
+Requires-Dist: pytest-cov~=4.1; extra == "dev"
+Requires-Dist: twine~=4.0; extra == "dev"
+Requires-Dist: build~=1.0; extra == "dev"
+
+# Classic Signals
+
+Данный пакет предоставляет возможность использовать сигналы и реакции в проекте.
+
+Они нужны для инверсии вызова. По сути, это паттерн Observer и немного сахара 
+сверху. В одном месте программы мы объявляем сигналы, пользуясь декоратором 
+signal, в других местах приложения пишем реакции на этих сигналов.
+Реакции - это любой вызываемый объект, принимающий один аргумент - инстанс 
+сигнала. Это может быть и просто функция или метод, для удобства завернутый
+в декоратор reaction. Последнее, что нужно, это инстанс класса Hub. В Hub 
+перед началом работы можно зарегистрировать реакции, потом можно вызвать у него
+метод notify, передав в него инстанс сигнала, и Hub вызовет все реакции, 
+относящиеся к сигналу.
+
+Пример:
+
+```python
+from classic.components import component
+from classic.signals import reaction, Hub, signal
+
+
+@signal
+class SomethingHappened:
+    """Под капотом сигналы - на самом деле датаклассы"""
+    some_field: int
+
+
+@signal
+class SomethingAnotherHappened:
+    some_field: int
+
+
+@component
+class SomeHandlers:
+
+    @reaction
+    def on_something_happened(self, signal: SomethingHappened):
+        print(f'Что-то произошло: {signal}')
+
+    @reaction
+    def on_something_another_happened(self, signal: SomethingAnotherHappened):
+        print(f'Что-то еще произошло: {signal}')
+
+
+hub = Hub()
+SomeHandlers(signals=hub)
+
+
+signal_1 = SomethingHappened(some_field=0)
+signal_2 = SomethingAnotherHappened(some_field=0)
+
+hub.notify(signal_1, signal_2)
+```
+
+

classic-signals-0.1.0/README.md

@@ -0,0 +1,55 @@
+# Classic Signals
+
+Данный пакет предоставляет возможность использовать сигналы и реакции в проекте.
+
+Они нужны для инверсии вызова. По сути, это паттерн Observer и немного сахара 
+сверху. В одном месте программы мы объявляем сигналы, пользуясь декоратором 
+signal, в других местах приложения пишем реакции на этих сигналов.
+Реакции - это любой вызываемый объект, принимающий один аргумент - инстанс 
+сигнала. Это может быть и просто функция или метод, для удобства завернутый
+в декоратор reaction. Последнее, что нужно, это инстанс класса Hub. В Hub 
+перед началом работы можно зарегистрировать реакции, потом можно вызвать у него
+метод notify, передав в него инстанс сигнала, и Hub вызовет все реакции, 
+относящиеся к сигналу.
+
+Пример:
+
+```python
+from classic.components import component
+from classic.signals import reaction, Hub, signal
+
+
+@signal
+class SomethingHappened:
+    """Под капотом сигналы - на самом деле датаклассы"""
+    some_field: int
+
+
+@signal
+class SomethingAnotherHappened:
+    some_field: int
+
+
+@component
+class SomeHandlers:
+
+    @reaction
+    def on_something_happened(self, signal: SomethingHappened):
+        print(f'Что-то произошло: {signal}')
+
+    @reaction
+    def on_something_another_happened(self, signal: SomethingAnotherHappened):
+        print(f'Что-то еще произошло: {signal}')
+
+
+hub = Hub()
+SomeHandlers(signals=hub)
+
+
+signal_1 = SomethingHappened(some_field=0)
+signal_2 = SomethingAnotherHappened(some_field=0)
+
+hub.notify(signal_1, signal_2)
+```
+
+

classic-signals-0.1.0/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools >= 40.6.0",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

classic-signals-0.1.0/setup.cfg

@@ -0,0 +1,40 @@
+[metadata]
+name = classic-signals
+version = 0.1.0
+description = Simple signals and handlers
+author = Sergei Variasov
+author_email = variasov@gmail.com
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/variasov/classic-signals
+project_urls = 
+	Bug Tracker = https://github.com/variasov/classic-signals/issues
+classifiers = 
+	Programming Language :: Python :: 3.10
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+	Development Status :: 4 - Beta
+
+[options]
+packages = find_namespace:
+python_requires = >=3.10
+package_dir = 
+	= sources
+install_requires = 
+	readerwriterlock~=1.0.9
+	classic-components==1.1.0
+
+[options.packages.find]
+where = sources
+
+[options.extras_require]
+dev = 
+	pytest~=7.4.4
+	pytest-cov~=4.1
+	twine~=4.0
+	build~=1.0
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

classic-signals-0.1.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()

classic-signals-0.1.0/sources/classic/signals/__init__.py

@@ -0,0 +1,4 @@
+from .signal import Signal, signal, is_signal
+from .reaction import is_reaction, filter_reactions
+from .hub import Hub
+from .decorator import reaction

classic-signals-0.1.0/sources/classic/signals/decorator.py

@@ -0,0 +1,17 @@
+from classic.components import add_extra_annotation
+
+from .hub import Hub
+from .reaction import Reaction
+
+
+def reaction(fn: Reaction) -> Reaction:
+    """
+    Декоратор, помечающий указанную функцию,
+    как реакцию на сигнал, чтобы затем Hub автоматически их регистрировал.
+
+    :param fn: функция
+    :return: та же самая функция
+    """
+    add_extra_annotation(fn, 'hub', Hub)
+    fn.__is_reaction = True
+    return fn

classic-signals-0.1.0/sources/classic/signals/hub.py

@@ -0,0 +1,108 @@
+from typing import Any, Optional
+import threading
+from collections import defaultdict
+from typing import Type
+
+from classic.components import Registry
+from readerwriterlock import rwlock
+
+from .reaction import filter_reactions, Reaction
+from .signal import Signal
+from . import utils
+
+
+class Hub(Registry):
+    """
+    Хранит знания о сигналах и привязанных к ним реакциям, принимает сигналы и
+    инициирует реакции на сигналы.
+    """
+
+    _reactions: dict[Signal, list[Reaction]]
+    _lock: rwlock.RWLockRead
+
+    def __init__(self):
+        self._reactions = defaultdict(list)
+        self._lock = rwlock.RWLockRead(threading.RLock)
+
+    def notify(self, *signals: Signal) -> None:
+        """
+        Вызывает зарегистрированные реакции для указаных сигналов.
+
+        :param signals: Сигналы, на которые требуется среагировать.
+        """
+        with self._lock.gen_rlock():
+            for signal in signals:
+                for reaction in self._reactions[signal.__class__]:
+                    reaction(signal)
+
+    def add_reaction(
+        self, reaction: Reaction,
+        signal: Optional[Type[Signal]] = None,
+    ) -> None:
+        """
+        Добавляет реакцию на сигнал.
+
+        Если сигнал не указан, то реакция будет добавлена в сигнал, указанный
+        в аннотации вызываемого объекта. Если аннотация не указана, вызовет
+        исключение AssertionError.
+
+        Проверка динамическая, построена на assert.
+
+        :param reaction: Вызываемый объект с одним аргументом - сигналом.
+        :param signal: Класс сигнала, на который должна реагировать реакция.
+        """
+        signal = signal or utils.get_signal_type(reaction)
+        with self._lock.gen_wlock():
+            if reaction not in self._reactions[signal]:
+                self._reactions[signal].append(reaction)
+
+    def remove_reaction(
+        self, reaction: Reaction,
+        signal: Optional[Type[Signal]] = None,
+    ) -> None:
+        """
+        Добавляет реакцию на сигнал.
+
+        Если сигнал не указан, то Hub переберет реакции для всех сигналов,
+        и уберет указанный отовсюду.
+
+        :param reaction: Вызываемый объект с одним аргументом - сигналом.
+        :param signal: Класс сигнала, на который должна реагировать реакция.
+        """
+        with self._lock.gen_wlock():
+            if signal:
+                try:
+                    self._reactions[signal].remove(reaction)
+                except ValueError:
+                    pass
+            else:
+                for reactions in self._reactions.values():
+                    try:
+                        reactions.remove(reaction)
+                    except ValueError:
+                        pass
+
+    def register(self, obj: Any) -> None:
+        """
+        Разбирает указанный объект на реакции, и добавляет их
+        к внутреннему реестру.
+
+        Реакцией считается метод, завернутый в декоратор reaction.
+
+        :param obj: Объект, содержащий реакции.
+        """
+        with self._lock.gen_wlock():
+            for reaction in filter_reactions(obj):
+                self.add_reaction(reaction)
+
+    def unregister(self, obj: Any) -> None:
+        """
+        Удаляет все реакции, определенные в объекте.
+
+        Реакцией считается метод, завернутый в декоратор reaction.
+
+        :param obj: Объект, содержащий реакции.
+        """
+        with self._lock.gen_wlock():
+            for reaction in filter_reactions(obj):
+                self.remove_reaction(reaction)

classic-signals-0.1.0/sources/classic/signals/reaction.py

@@ -0,0 +1,27 @@
+from typing import Any, List, Callable, TypeVar
+import inspect
+
+
+Reaction = TypeVar('Reaction', bound=Callable[[Any], Any])
+
+
+def is_reaction(obj: Any) -> bool:
+    """
+    Проверяет, является ли объект реакцией.
+
+    :param obj: объект
+    :returns: bool, True, если указанный объект является реакцией.
+    """
+    return callable(obj) and getattr(obj, '__is_reaction', False)
+
+
+def filter_reactions(obj: Any) -> List[Reaction]:
+    """
+    Возвращает список реакций, определенных в объекте.
+    :param obj: Объект с методами, помеченными декоратором reaction.
+    """
+    return [
+        member
+        for name, member
+        in inspect.getmembers(obj, predicate=is_reaction)
+    ]

classic-signals-0.1.0/sources/classic/signals/signal.py

@@ -0,0 +1,25 @@
+from typing import Any, TypeVar
+from dataclasses import dataclass
+
+
+Signal = TypeVar('Signal')
+
+
+def signal(cls: Signal) -> Signal:
+    """
+    Декоратор, помечающий класс как сигнал.
+
+    :param cls: Класс, определяемый как сигнал.
+    """
+    new_cls = dataclass(cls, eq=False, frozen=True)
+    new_cls.__is_signal = True
+    return new_cls
+
+
+def is_signal(obj: Any) -> bool:
+    """
+    Проверяет, является ли объект сигналом.
+
+    :param obj: Объект для проверки.
+    """
+    return hasattr(obj, '__is_signal')

classic-signals-0.1.0/sources/classic/signals/utils.py

@@ -0,0 +1,42 @@
+import inspect
+
+from .signal import is_signal
+
+
+def validate_signature_length(signature: inspect.Signature) -> bool:
+    """
+    Проверяет, что сигнатура функции имеет длину 1.
+    :param signature: сигнатура функции
+    """
+    # TODO: Needed another, more stable way for detecting methods and functions
+    #       inspect.ismethod works only on instances, not on class functions
+    needed_len = 2 if 'self' in signature.parameters else 1
+
+    params_len = len(signature.parameters)
+    return params_len == needed_len
+
+
+def get_last_param(signature: inspect.Signature):
+    """
+    Нам нужно взять последний ключ в словаре,
+    но мы не можем сделать:
+    >>> dict.keys()[-1]
+    """
+    name = next(reversed(signature.parameters.keys()))
+    return signature.parameters[name]
+
+
+def get_signal_type(handler):
+    """
+    Возвращает тип сигнала, на который реагирует функция.
+    :param handler: функция реакции
+    :return: тип сигнала
+    """
+    signature = inspect.signature(handler)
+    assert validate_signature_length(signature), \
+        f'Reaction for event, must have only 1 parameter!'
+
+    argument = get_last_param(signature)
+    assert is_signal(argument.annotation)
+
+    return argument.annotation

classic-signals-0.1.0/sources/classic_signals.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: classic-signals
+Version: 0.1.0
+Summary: Simple signals and handlers
+Home-page: https://github.com/variasov/classic-signals
+Author: Sergei Variasov
+Author-email: variasov@gmail.com
+Project-URL: Bug Tracker, https://github.com/variasov/classic-signals/issues
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: readerwriterlock~=1.0.9
+Requires-Dist: classic-components==1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest~=7.4.4; extra == "dev"
+Requires-Dist: pytest-cov~=4.1; extra == "dev"
+Requires-Dist: twine~=4.0; extra == "dev"
+Requires-Dist: build~=1.0; extra == "dev"
+
+# Classic Signals
+
+Данный пакет предоставляет возможность использовать сигналы и реакции в проекте.
+
+Они нужны для инверсии вызова. По сути, это паттерн Observer и немного сахара 
+сверху. В одном месте программы мы объявляем сигналы, пользуясь декоратором 
+signal, в других местах приложения пишем реакции на этих сигналов.
+Реакции - это любой вызываемый объект, принимающий один аргумент - инстанс 
+сигнала. Это может быть и просто функция или метод, для удобства завернутый
+в декоратор reaction. Последнее, что нужно, это инстанс класса Hub. В Hub 
+перед началом работы можно зарегистрировать реакции, потом можно вызвать у него
+метод notify, передав в него инстанс сигнала, и Hub вызовет все реакции, 
+относящиеся к сигналу.
+
+Пример:
+
+```python
+from classic.components import component
+from classic.signals import reaction, Hub, signal
+
+
+@signal
+class SomethingHappened:
+    """Под капотом сигналы - на самом деле датаклассы"""
+    some_field: int
+
+
+@signal
+class SomethingAnotherHappened:
+    some_field: int
+
+
+@component
+class SomeHandlers:
+
+    @reaction
+    def on_something_happened(self, signal: SomethingHappened):
+        print(f'Что-то произошло: {signal}')
+
+    @reaction
+    def on_something_another_happened(self, signal: SomethingAnotherHappened):
+        print(f'Что-то еще произошло: {signal}')
+
+
+hub = Hub()
+SomeHandlers(signals=hub)
+
+
+signal_1 = SomethingHappened(some_field=0)
+signal_2 = SomethingAnotherHappened(some_field=0)
+
+hub.notify(signal_1, signal_2)
+```
+
+

classic-signals-0.1.0/sources/classic_signals.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+sources/classic/signals/__init__.py
+sources/classic/signals/decorator.py
+sources/classic/signals/hub.py
+sources/classic/signals/reaction.py
+sources/classic/signals/signal.py
+sources/classic/signals/utils.py
+sources/classic_signals.egg-info/PKG-INFO
+sources/classic_signals.egg-info/SOURCES.txt
+sources/classic_signals.egg-info/dependency_links.txt
+sources/classic_signals.egg-info/requires.txt
+sources/classic_signals.egg-info/top_level.txt
+tests/test_hub.py
+tests/test_reaction.py
+tests/test_signal.py

classic-signals-0.1.0/sources/classic_signals.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

classic-signals-0.1.0/sources/classic_signals.egg-info/requires.txt

@@ -0,0 +1,8 @@
+readerwriterlock~=1.0.9
+classic-components==1.1.0
+
+[dev]
+pytest~=7.4.4
+pytest-cov~=4.1
+twine~=4.0
+build~=1.0

classic-signals-0.1.0/sources/classic_signals.egg-info/top_level.txt

@@ -0,0 +1 @@
+classic

classic-signals-0.1.0/tests/test_hub.py

@@ -0,0 +1,93 @@
+
+def check_all_reaction_called(handlers, some_signal, another_signal):
+    assert handlers.some_field is None
+    assert handlers.another_field is None
+
+    hub = handlers.hub
+    hub.notify(some_signal)
+    hub.notify(another_signal)
+
+    assert handlers.some_field == some_signal
+    assert handlers.another_field == another_signal
+
+
+def check_nothing_is_called(handlers, some_signal, another_signal):
+    assert handlers.some_field is None
+    assert handlers.another_field is None
+
+    hub = handlers.hub
+    hub.notify(some_signal)
+    hub.notify(another_signal)
+
+    assert handlers.some_field is None
+    assert handlers.another_field is None
+
+
+def test_composite_handlers(component_handlers, some_signal, another_signal):
+    check_all_reaction_called(component_handlers, some_signal, another_signal)
+
+
+def test_manual_handlers_call_after_registration(
+    manual_handlers, some_signal, another_signal
+):
+    manual_handlers.register()
+    check_all_reaction_called(manual_handlers, some_signal, another_signal)
+    manual_handlers.unregister()
+
+
+def test_manual_handlers_dont_call_without_registration(
+    manual_handlers, some_signal, another_signal
+):
+    check_nothing_is_called(manual_handlers, some_signal, another_signal)
+
+
+def test_manual_handlers_dont_call_after_deregistration(
+    manual_handlers, some_signal, another_signal
+):
+    manual_handlers.register()
+    manual_handlers.unregister()
+    check_nothing_is_called(manual_handlers, some_signal, another_signal)
+
+
+def test_manual_handlers_call_after_manual_registration(
+    manual_handlers, some_signal, another_signal
+):
+    manual_handlers.register_manually()
+    check_all_reaction_called(manual_handlers, some_signal, another_signal)
+    manual_handlers.unregister_manually()
+
+
+def test_manual_handlers_dont_call_without_manual_registration(
+    manual_handlers, some_signal, another_signal
+):
+    check_nothing_is_called(manual_handlers, some_signal, another_signal)
+
+
+def test_manual_handlers_dont_call_after_manual_deregistration(
+    manual_handlers, some_signal, another_signal
+):
+    manual_handlers.register_manually()
+    manual_handlers.unregister_manually()
+    check_nothing_is_called(manual_handlers, some_signal, another_signal)
+
+
+def test_manual_handlers_call_after_manual_registration_without_signals(
+    manual_handlers, some_signal, another_signal
+):
+    manual_handlers.register_manually_without_signals()
+    check_all_reaction_called(manual_handlers, some_signal, another_signal)
+    manual_handlers.unregister_manually_without_signals()
+
+
+def test_manual_handlers_dont_call_without_manual_registration_without_signals(
+    manual_handlers, some_signal, another_signal
+):
+    check_nothing_is_called(manual_handlers, some_signal, another_signal)
+
+
+def test_manual_handlers_dont_call_after_manual_deregistration_without_signals(
+    manual_handlers, some_signal, another_signal
+):
+    manual_handlers.register_manually_without_signals()
+    manual_handlers.unregister_manually_without_signals()
+    check_nothing_is_called(manual_handlers, some_signal, another_signal)

classic-signals-0.1.0/tests/test_reaction.py

@@ -0,0 +1,22 @@
+from classic.signals import Hub, is_reaction, filter_reactions
+
+
+def test_is_reaction_true(handlers):
+    assert is_reaction(handlers.reaction_1)
+
+
+def test_is_reaction_false(handlers):
+    assert not is_reaction(handlers.reaction_3)
+
+
+def test_filter_reactions(handlers):
+    reactions = filter_reactions(handlers)
+    assert len(reactions) == 2
+
+
+def test_reaction_decorator(handlers):
+    assert getattr(handlers.reaction_1, '__is_reaction', False)
+    assert getattr(
+        handlers.reaction_1,
+        '__extra_annotations__',
+    ) == {'hub': Hub}

classic-signals-0.1.0/tests/test_signal.py

@@ -0,0 +1,21 @@
+from dataclasses import is_dataclass
+
+from classic.signals import is_signal
+
+
+class SomeClass:
+    pass
+
+
+def test_signal_decorator(some_signal):
+    assert hasattr(some_signal, '__is_signal')
+    assert is_dataclass(some_signal)
+
+
+def test_is_signal_true(some_signal):
+    assert is_signal(some_signal)
+
+
+def test_is_signal_false():
+    some_class = SomeClass()
+    assert not is_signal(some_class)