diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-observable.spec | 444 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 446 insertions, 0 deletions
@@ -0,0 +1 @@ +/observable-1.0.3.tar.gz diff --git a/python-observable.spec b/python-observable.spec new file mode 100644 index 0000000..94f77c0 --- /dev/null +++ b/python-observable.spec @@ -0,0 +1,444 @@ +%global _empty_manifest_terminate_build 0 +Name: python-observable +Version: 1.0.3 +Release: 1 +Summary: minimalist event system +License: MIT +URL: https://github.com/timofurrer/observable +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/24/57/013c2610cf93f9ae87e522be17d679bcba0e7cee2cd8da4dc8efddef1138/observable-1.0.3.tar.gz +BuildArch: noarch + + +%description +# observable +[](https://travis-ci.com/timofurrer/observable) +[](https://github.com/ambv/black) + +**pyobservable** is a minimalist event system for python. It provides you an easy-to-use interface to trigger arbitrary functions when specific events occur. + +```python +from observable import Observable + +obs = Observable() + +@obs.on("error") +def error_handler(message): + # do some fancy error handling + logging.error(f"An error occured: {message}") + +... + +def do_time_travel(): + # do some time traveling + ... + if year != 1291: + obs.trigger("error", "Time travel to 1291 didn't work") +``` + +**Note:** We are Python 3 only! Only Python Versions >= 3.5 are supported. Use [v0.3.2](https://pypi.org/project/observable/0.3.2/) for older Python Versions. + +## How to use + +Use a `pip` to install it from PyPI: + + pip install observable + +After completion you can start using `observable`: + +```python +from observable import Observable + +obs = Observable() +``` + +## Usage + +### `on`: Register event handler with `on` +There are two ways to register a function to an event.<br /> +The first way is to register the event with a decorator like this: + +```python +@obs.on("error") +def error_func(message): + print("Error: %s" % message) +``` + +The second way is to register it with a method call: + +```python +def error_func(message): + print("Error: %s" % message) +obs.on("error", error_func) +``` + +### `once`: Register event handler with `once` +`once` works like `on`, but once the event handler is triggered it will be removed and cannot be triggered again. + +### `trigger`: trigger event +You can trigger a registered event with the `trigger` method: + +```python +obs.trigger("error", "This is my error message") +``` + +If no handler for the event `error` could be found an `Observable.NoHandlerFound`-Exception will be raised. + +### `off`: remove handler and events +Remove a handler from a specified event: + +```python +obs.off("error", error_func) +``` + +```python +obs.off("error", [error_func, second_error_func]) +``` + +Remove all handlers from a specified event: + +```python +obs.off("error") +``` + +Clear all events: + +```python +obs.off() +``` + +### `get_all_handlers`, `get_handlers` and `is_registered`: Check which handlers are registered +Imagine you registered the following handlers: + +```python +@obs.on("success") +def success_func(): + print("Success!") + +@obs.on("error") +def error_func(message): + print("Error: %s" % message) +``` + +Then you can do the following to inspect the registered handlers: +```python +>>> obs.get_all_handlers() +{'success': [<function success_func at 0x7f7f32d0a1e0>], 'error': [<function error_func at 0x7f7f32d0a268>]} +>>> obs.get_handlers("success") +[<function success_func at 0x7f7f32d0a1e0>] +>>> obs.get_handlers("other_event") +[] +``` + +*** + +*<p align="center">This project is published under [MIT](LICENSE).<br>A [Timo Furrer](https://tuxtimo.me) project.<br>- :tada: -</p>* + + + + +%package -n python3-observable +Summary: minimalist event system +Provides: python-observable +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-observable +# observable +[](https://travis-ci.com/timofurrer/observable) +[](https://github.com/ambv/black) + +**pyobservable** is a minimalist event system for python. It provides you an easy-to-use interface to trigger arbitrary functions when specific events occur. + +```python +from observable import Observable + +obs = Observable() + +@obs.on("error") +def error_handler(message): + # do some fancy error handling + logging.error(f"An error occured: {message}") + +... + +def do_time_travel(): + # do some time traveling + ... + if year != 1291: + obs.trigger("error", "Time travel to 1291 didn't work") +``` + +**Note:** We are Python 3 only! Only Python Versions >= 3.5 are supported. Use [v0.3.2](https://pypi.org/project/observable/0.3.2/) for older Python Versions. + +## How to use + +Use a `pip` to install it from PyPI: + + pip install observable + +After completion you can start using `observable`: + +```python +from observable import Observable + +obs = Observable() +``` + +## Usage + +### `on`: Register event handler with `on` +There are two ways to register a function to an event.<br /> +The first way is to register the event with a decorator like this: + +```python +@obs.on("error") +def error_func(message): + print("Error: %s" % message) +``` + +The second way is to register it with a method call: + +```python +def error_func(message): + print("Error: %s" % message) +obs.on("error", error_func) +``` + +### `once`: Register event handler with `once` +`once` works like `on`, but once the event handler is triggered it will be removed and cannot be triggered again. + +### `trigger`: trigger event +You can trigger a registered event with the `trigger` method: + +```python +obs.trigger("error", "This is my error message") +``` + +If no handler for the event `error` could be found an `Observable.NoHandlerFound`-Exception will be raised. + +### `off`: remove handler and events +Remove a handler from a specified event: + +```python +obs.off("error", error_func) +``` + +```python +obs.off("error", [error_func, second_error_func]) +``` + +Remove all handlers from a specified event: + +```python +obs.off("error") +``` + +Clear all events: + +```python +obs.off() +``` + +### `get_all_handlers`, `get_handlers` and `is_registered`: Check which handlers are registered +Imagine you registered the following handlers: + +```python +@obs.on("success") +def success_func(): + print("Success!") + +@obs.on("error") +def error_func(message): + print("Error: %s" % message) +``` + +Then you can do the following to inspect the registered handlers: +```python +>>> obs.get_all_handlers() +{'success': [<function success_func at 0x7f7f32d0a1e0>], 'error': [<function error_func at 0x7f7f32d0a268>]} +>>> obs.get_handlers("success") +[<function success_func at 0x7f7f32d0a1e0>] +>>> obs.get_handlers("other_event") +[] +``` + +*** + +*<p align="center">This project is published under [MIT](LICENSE).<br>A [Timo Furrer](https://tuxtimo.me) project.<br>- :tada: -</p>* + + + + +%package help +Summary: Development documents and examples for observable +Provides: python3-observable-doc +%description help +# observable +[](https://travis-ci.com/timofurrer/observable) +[](https://github.com/ambv/black) + +**pyobservable** is a minimalist event system for python. It provides you an easy-to-use interface to trigger arbitrary functions when specific events occur. + +```python +from observable import Observable + +obs = Observable() + +@obs.on("error") +def error_handler(message): + # do some fancy error handling + logging.error(f"An error occured: {message}") + +... + +def do_time_travel(): + # do some time traveling + ... + if year != 1291: + obs.trigger("error", "Time travel to 1291 didn't work") +``` + +**Note:** We are Python 3 only! Only Python Versions >= 3.5 are supported. Use [v0.3.2](https://pypi.org/project/observable/0.3.2/) for older Python Versions. + +## How to use + +Use a `pip` to install it from PyPI: + + pip install observable + +After completion you can start using `observable`: + +```python +from observable import Observable + +obs = Observable() +``` + +## Usage + +### `on`: Register event handler with `on` +There are two ways to register a function to an event.<br /> +The first way is to register the event with a decorator like this: + +```python +@obs.on("error") +def error_func(message): + print("Error: %s" % message) +``` + +The second way is to register it with a method call: + +```python +def error_func(message): + print("Error: %s" % message) +obs.on("error", error_func) +``` + +### `once`: Register event handler with `once` +`once` works like `on`, but once the event handler is triggered it will be removed and cannot be triggered again. + +### `trigger`: trigger event +You can trigger a registered event with the `trigger` method: + +```python +obs.trigger("error", "This is my error message") +``` + +If no handler for the event `error` could be found an `Observable.NoHandlerFound`-Exception will be raised. + +### `off`: remove handler and events +Remove a handler from a specified event: + +```python +obs.off("error", error_func) +``` + +```python +obs.off("error", [error_func, second_error_func]) +``` + +Remove all handlers from a specified event: + +```python +obs.off("error") +``` + +Clear all events: + +```python +obs.off() +``` + +### `get_all_handlers`, `get_handlers` and `is_registered`: Check which handlers are registered +Imagine you registered the following handlers: + +```python +@obs.on("success") +def success_func(): + print("Success!") + +@obs.on("error") +def error_func(message): + print("Error: %s" % message) +``` + +Then you can do the following to inspect the registered handlers: +```python +>>> obs.get_all_handlers() +{'success': [<function success_func at 0x7f7f32d0a1e0>], 'error': [<function error_func at 0x7f7f32d0a268>]} +>>> obs.get_handlers("success") +[<function success_func at 0x7f7f32d0a1e0>] +>>> obs.get_handlers("other_event") +[] +``` + +*** + +*<p align="center">This project is published under [MIT](LICENSE).<br>A [Timo Furrer](https://tuxtimo.me) project.<br>- :tada: -</p>* + + + + +%prep +%autosetup -n observable-1.0.3 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-observable -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Apr 11 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.3-1 +- Package Spec generated @@ -0,0 +1 @@ +c023b66b93c2c24936c1ccafc23877da observable-1.0.3.tar.gz |