automatic import of python-reactivepyopeneuler20.03

3 files changed, 404 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..9c54610 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/ReactivePy-2.0.0.dev0.tar.gz
diff --git a/python-reactivepy.spec b/python-reactivepy.spec
new file mode 100644
index 0000000..29e2754
--- /dev/null
+++ b/python-reactivepy.spec
@@ -0,0 +1,402 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-ReactivePy
+Version:	2.0.0.dev0
+Release:	1
+Summary:	Reactive properties and owners for Python classes.
+License:	GNU General Public License v3 (GPLv3)
+URL:		https://github.com/Dan6erbond/ReactivePy
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/56/e5/1421d7530933ecfeeba9aa79a12aa90379dbee2f4514058dbf7a1c89490b/ReactivePy-2.0.0.dev0.tar.gz
+BuildArch:	noarch
+
+
+%description
+# ReactivePy
+
+A simple library to manage reactive properties within an object using custom descriptors and update methods.
+
+- [ReactivePy](#reactivepy)
+  - [About ReactivePy](#about-reactivepy)
+    - [`all_reactive` Decorator](#all_reactive-decorator)
+    - [Using Type `bool`](#using-type-bool)
+  - [`async` / `await` in ReactivePy](#async--await-in-reactivepy)
+
+## About ReactivePy
+
+ReactivePy lets you create objects that contain reactive properties. Those can be updated in bulk, which allows ReactivePy to notify its observers of changes. The callback can then read the history, update value as well as the name of the attribute.
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo")
+        self.age = ReactiveProperty(6)
+
+foo = Foo()
+
+def on_change(*args):
+    for arg in args: print(arg.name, "updated to", arg)
+
+def on_name_change(curr: Any, org: Any):
+    print("Name updated from", org, "to", curr)
+
+foo.on_change(on_update, foo.name, foo.age)
+foo.name.on_change(on_name_update)
+
+foo._bulk_update(name="Bar", age=12)
+```
+
+Reactive properties can also be strong-typed raising a `TypeError` if the value they're being set to doesn't match the `field_type` defined in the constructor. Strong-typing a property looks like this:
+
+```python
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo", field_type=str)
+```
+
+### `all_reactive` Decorator
+
+The `ReactiveOwner.all_reactive` owner can be used on classes, where all public attributes should be reactive, which will additionally override the `__setattr__` method to convert any attribute writes.
+
+```python
+from reactive import all_reactive, ReactiveOwner
+
+@all_reactive
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = "Foo"
+```
+
+Additionally the parameters `only_type` and `not_type` can be specified, as a single type, list or tuple of types which will have only those types converted to `class ReactiveProperty` or not.
+
+### Using Type `bool`
+
+Since the type `bool` cannot be used as a base class, when retrieving its value, users must explicitly use `ReactiveProperty.value` attribute:
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.boolean = ReactiveProperty(True)
+
+foo = Foo()
+print(foo.boolean.value)
+
+>>> True
+```
+
+## `async` / `await` in ReactivePy
+
+Oftentimes reactive models get updated from an external API source in which case it makes sense to use asynchronous programming to avoid the main program from being blocked by network requests. ReactivePy supports the `async`/`await` syntax by offering a `_async_bulk_update()` function, with an equivalent signature to `_bulk_update`, but will also call coroutine callbacks.
+
+Reactive properties cannot async change callbacks, but this can be compensated for by supplying the properties a callback should respond to by adding it as an argument to `on_change`:
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo")
+        self.age = ReactiveProperty(6)
+
+foo = Foo()
+
+async def on_change(*args):
+    for arg in args: print(arg.name, "updated to", arg.value)
+
+async def on_name_change(*args):
+    print("Name updated from", args[0].history[-1], "to", args[0].value)
+
+foo.on_change(on_update, foo.name, foo.age)
+foo.on_change(on_name_update, foo.name)
+
+foo._async_bulk_update(name="Bar", age=12)
+```
+
+
+
+
+%package -n python3-ReactivePy
+Summary:	Reactive properties and owners for Python classes.
+Provides:	python-ReactivePy
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-ReactivePy
+# ReactivePy
+
+A simple library to manage reactive properties within an object using custom descriptors and update methods.
+
+- [ReactivePy](#reactivepy)
+  - [About ReactivePy](#about-reactivepy)
+    - [`all_reactive` Decorator](#all_reactive-decorator)
+    - [Using Type `bool`](#using-type-bool)
+  - [`async` / `await` in ReactivePy](#async--await-in-reactivepy)
+
+## About ReactivePy
+
+ReactivePy lets you create objects that contain reactive properties. Those can be updated in bulk, which allows ReactivePy to notify its observers of changes. The callback can then read the history, update value as well as the name of the attribute.
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo")
+        self.age = ReactiveProperty(6)
+
+foo = Foo()
+
+def on_change(*args):
+    for arg in args: print(arg.name, "updated to", arg)
+
+def on_name_change(curr: Any, org: Any):
+    print("Name updated from", org, "to", curr)
+
+foo.on_change(on_update, foo.name, foo.age)
+foo.name.on_change(on_name_update)
+
+foo._bulk_update(name="Bar", age=12)
+```
+
+Reactive properties can also be strong-typed raising a `TypeError` if the value they're being set to doesn't match the `field_type` defined in the constructor. Strong-typing a property looks like this:
+
+```python
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo", field_type=str)
+```
+
+### `all_reactive` Decorator
+
+The `ReactiveOwner.all_reactive` owner can be used on classes, where all public attributes should be reactive, which will additionally override the `__setattr__` method to convert any attribute writes.
+
+```python
+from reactive import all_reactive, ReactiveOwner
+
+@all_reactive
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = "Foo"
+```
+
+Additionally the parameters `only_type` and `not_type` can be specified, as a single type, list or tuple of types which will have only those types converted to `class ReactiveProperty` or not.
+
+### Using Type `bool`
+
+Since the type `bool` cannot be used as a base class, when retrieving its value, users must explicitly use `ReactiveProperty.value` attribute:
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.boolean = ReactiveProperty(True)
+
+foo = Foo()
+print(foo.boolean.value)
+
+>>> True
+```
+
+## `async` / `await` in ReactivePy
+
+Oftentimes reactive models get updated from an external API source in which case it makes sense to use asynchronous programming to avoid the main program from being blocked by network requests. ReactivePy supports the `async`/`await` syntax by offering a `_async_bulk_update()` function, with an equivalent signature to `_bulk_update`, but will also call coroutine callbacks.
+
+Reactive properties cannot async change callbacks, but this can be compensated for by supplying the properties a callback should respond to by adding it as an argument to `on_change`:
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo")
+        self.age = ReactiveProperty(6)
+
+foo = Foo()
+
+async def on_change(*args):
+    for arg in args: print(arg.name, "updated to", arg.value)
+
+async def on_name_change(*args):
+    print("Name updated from", args[0].history[-1], "to", args[0].value)
+
+foo.on_change(on_update, foo.name, foo.age)
+foo.on_change(on_name_update, foo.name)
+
+foo._async_bulk_update(name="Bar", age=12)
+```
+
+
+
+
+%package help
+Summary:	Development documents and examples for ReactivePy
+Provides:	python3-ReactivePy-doc
+%description help
+# ReactivePy
+
+A simple library to manage reactive properties within an object using custom descriptors and update methods.
+
+- [ReactivePy](#reactivepy)
+  - [About ReactivePy](#about-reactivepy)
+    - [`all_reactive` Decorator](#all_reactive-decorator)
+    - [Using Type `bool`](#using-type-bool)
+  - [`async` / `await` in ReactivePy](#async--await-in-reactivepy)
+
+## About ReactivePy
+
+ReactivePy lets you create objects that contain reactive properties. Those can be updated in bulk, which allows ReactivePy to notify its observers of changes. The callback can then read the history, update value as well as the name of the attribute.
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo")
+        self.age = ReactiveProperty(6)
+
+foo = Foo()
+
+def on_change(*args):
+    for arg in args: print(arg.name, "updated to", arg)
+
+def on_name_change(curr: Any, org: Any):
+    print("Name updated from", org, "to", curr)
+
+foo.on_change(on_update, foo.name, foo.age)
+foo.name.on_change(on_name_update)
+
+foo._bulk_update(name="Bar", age=12)
+```
+
+Reactive properties can also be strong-typed raising a `TypeError` if the value they're being set to doesn't match the `field_type` defined in the constructor. Strong-typing a property looks like this:
+
+```python
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo", field_type=str)
+```
+
+### `all_reactive` Decorator
+
+The `ReactiveOwner.all_reactive` owner can be used on classes, where all public attributes should be reactive, which will additionally override the `__setattr__` method to convert any attribute writes.
+
+```python
+from reactive import all_reactive, ReactiveOwner
+
+@all_reactive
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = "Foo"
+```
+
+Additionally the parameters `only_type` and `not_type` can be specified, as a single type, list or tuple of types which will have only those types converted to `class ReactiveProperty` or not.
+
+### Using Type `bool`
+
+Since the type `bool` cannot be used as a base class, when retrieving its value, users must explicitly use `ReactiveProperty.value` attribute:
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.boolean = ReactiveProperty(True)
+
+foo = Foo()
+print(foo.boolean.value)
+
+>>> True
+```
+
+## `async` / `await` in ReactivePy
+
+Oftentimes reactive models get updated from an external API source in which case it makes sense to use asynchronous programming to avoid the main program from being blocked by network requests. ReactivePy supports the `async`/`await` syntax by offering a `_async_bulk_update()` function, with an equivalent signature to `_bulk_update`, but will also call coroutine callbacks.
+
+Reactive properties cannot async change callbacks, but this can be compensated for by supplying the properties a callback should respond to by adding it as an argument to `on_change`:
+
+```python
+from reactive import ReactiveOwner, ReactiveProperty
+
+class Foo(ReactiveOwner):
+    def __init__(self):
+        super().__init__()
+        self.name = ReactiveProperty("Foo")
+        self.age = ReactiveProperty(6)
+
+foo = Foo()
+
+async def on_change(*args):
+    for arg in args: print(arg.name, "updated to", arg.value)
+
+async def on_name_change(*args):
+    print("Name updated from", args[0].history[-1], "to", args[0].value)
+
+foo.on_change(on_update, foo.name, foo.age)
+foo.on_change(on_name_update, foo.name)
+
+foo._async_bulk_update(name="Bar", age=12)
+```
+
+
+
+
+%prep
+%autosetup -n ReactivePy-2.0.0.dev0
+
+%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-ReactivePy -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 2.0.0.dev0-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..e48ab13
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+7f002f3696607635343a3a7dd88664b8  ReactivePy-2.0.0.dev0.tar.gz