automatic import of python-decouple

1 files changed, 414 insertions, 0 deletions

diff --git a/python-decouple.spec b/python-decouple.spec
new file mode 100644
index 0000000..b23aa05
--- /dev/null
+++ b/python-decouple.spec
@@ -0,0 +1,414 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-decouple
+Version:	0.0.7
+Release:	1
+Summary:	Decoupling logic
+License:	Apache 2.0
+URL:		https://github.com/andrey-avdeev/decouple
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/6c/e3/f70681dd89a96a701f22055caedc79cf88cebdeac9df827a5720bca80278/decouple-0.0.7.tar.gz
+BuildArch:	noarch
+
+
+%description
+# Decouple
+## Say NO to monolithic architecture.
+Decouple complex system to separated modules by mediator.
+
+```shell script
+pip install decouple
+```
+
+## Register event handler
+![register event handler](https://raw.githubusercontent.com/andrey-avdeev/decouple/master/docs/img/01_register.png)
+
+## Dispatch events
+![dispatch events](https://raw.githubusercontent.com/andrey-avdeev/decouple/master/docs/img/02_handle.png)
+
+## Example
+### Simple usage
+Code of example is [here](https://github.com/andrey-avdeev/decouple/tree/master/examples/simple)
+
+1. Write ModuleA - publisher
+```python
+from dataclasses import dataclass
+
+from decouple import Module, Event, Mediator
+
+
+class ModuleA(Module):
+    def __init__(self, mediator: Mediator = Mediator()):
+        super().__init__(mediator)
+
+    def start(self):
+        self.pub(StartEvent(a=7))
+
+
+@dataclass
+class StartEvent(Event):
+    a: int = 0  # must be serializable
+```
+
+2. Write ModuleB - subscriber
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        self.sub(StartEvent, self.handle_a)
+
+    def handle_start(self, event: StartEvent):
+        print(f'field a:{event.a}')
+
+```
+
+3. Compose both modules to the whole
+```python
+from examples.simple.module_a import ModuleA
+from examples.simple.module_b import ModuleB
+
+
+module_a = ModuleA()
+module_a.add(ModuleB())
+
+module_a.start()
+```
+
+### Priorities
+Manual control
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        # handler with higher priority will be triggered early
+        self.sub(StartEvent, self.handle_b, priority=0)
+        self.sub(StartEvent, self.handle_a, priority=100)
+
+    def handle_a(self, event: StartEvent):
+        # will be triggered first
+        print(f'field a:{event.a}')
+
+    def handle_b(self, event: StartEvent):
+        # will be triggered second
+        print(f'event.uuid:{event.uuid}, event.timestamp:{event.timestamp}')
+```
+Default priority depends on registration order
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        # priority of handlers call increased by 1 every registration for the same event
+        self.sub(StartEvent, self.handle_b)   # priority=1
+        self.sub(StartEvent, self.handle_a)   # priority=2
+
+    def handle_a(self, event: StartEvent):
+        # will be triggered second
+        print(f'field a:{event.a}')
+
+    def handle_b(self, event: StartEvent):
+        # will be triggered first
+        print(f'event.uuid:{event.uuid}, event.timestamp:{event.timestamp}')
+```
+
+# Feedback
+I will be glad to read your feedback in issues and pull requests.
+
+%package -n python3-decouple
+Summary:	Decoupling logic
+Provides:	python-decouple
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-decouple
+# Decouple
+## Say NO to monolithic architecture.
+Decouple complex system to separated modules by mediator.
+
+```shell script
+pip install decouple
+```
+
+## Register event handler
+![register event handler](https://raw.githubusercontent.com/andrey-avdeev/decouple/master/docs/img/01_register.png)
+
+## Dispatch events
+![dispatch events](https://raw.githubusercontent.com/andrey-avdeev/decouple/master/docs/img/02_handle.png)
+
+## Example
+### Simple usage
+Code of example is [here](https://github.com/andrey-avdeev/decouple/tree/master/examples/simple)
+
+1. Write ModuleA - publisher
+```python
+from dataclasses import dataclass
+
+from decouple import Module, Event, Mediator
+
+
+class ModuleA(Module):
+    def __init__(self, mediator: Mediator = Mediator()):
+        super().__init__(mediator)
+
+    def start(self):
+        self.pub(StartEvent(a=7))
+
+
+@dataclass
+class StartEvent(Event):
+    a: int = 0  # must be serializable
+```
+
+2. Write ModuleB - subscriber
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        self.sub(StartEvent, self.handle_a)
+
+    def handle_start(self, event: StartEvent):
+        print(f'field a:{event.a}')
+
+```
+
+3. Compose both modules to the whole
+```python
+from examples.simple.module_a import ModuleA
+from examples.simple.module_b import ModuleB
+
+
+module_a = ModuleA()
+module_a.add(ModuleB())
+
+module_a.start()
+```
+
+### Priorities
+Manual control
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        # handler with higher priority will be triggered early
+        self.sub(StartEvent, self.handle_b, priority=0)
+        self.sub(StartEvent, self.handle_a, priority=100)
+
+    def handle_a(self, event: StartEvent):
+        # will be triggered first
+        print(f'field a:{event.a}')
+
+    def handle_b(self, event: StartEvent):
+        # will be triggered second
+        print(f'event.uuid:{event.uuid}, event.timestamp:{event.timestamp}')
+```
+Default priority depends on registration order
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        # priority of handlers call increased by 1 every registration for the same event
+        self.sub(StartEvent, self.handle_b)   # priority=1
+        self.sub(StartEvent, self.handle_a)   # priority=2
+
+    def handle_a(self, event: StartEvent):
+        # will be triggered second
+        print(f'field a:{event.a}')
+
+    def handle_b(self, event: StartEvent):
+        # will be triggered first
+        print(f'event.uuid:{event.uuid}, event.timestamp:{event.timestamp}')
+```
+
+# Feedback
+I will be glad to read your feedback in issues and pull requests.
+
+%package help
+Summary:	Development documents and examples for decouple
+Provides:	python3-decouple-doc
+%description help
+# Decouple
+## Say NO to monolithic architecture.
+Decouple complex system to separated modules by mediator.
+
+```shell script
+pip install decouple
+```
+
+## Register event handler
+![register event handler](https://raw.githubusercontent.com/andrey-avdeev/decouple/master/docs/img/01_register.png)
+
+## Dispatch events
+![dispatch events](https://raw.githubusercontent.com/andrey-avdeev/decouple/master/docs/img/02_handle.png)
+
+## Example
+### Simple usage
+Code of example is [here](https://github.com/andrey-avdeev/decouple/tree/master/examples/simple)
+
+1. Write ModuleA - publisher
+```python
+from dataclasses import dataclass
+
+from decouple import Module, Event, Mediator
+
+
+class ModuleA(Module):
+    def __init__(self, mediator: Mediator = Mediator()):
+        super().__init__(mediator)
+
+    def start(self):
+        self.pub(StartEvent(a=7))
+
+
+@dataclass
+class StartEvent(Event):
+    a: int = 0  # must be serializable
+```
+
+2. Write ModuleB - subscriber
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        self.sub(StartEvent, self.handle_a)
+
+    def handle_start(self, event: StartEvent):
+        print(f'field a:{event.a}')
+
+```
+
+3. Compose both modules to the whole
+```python
+from examples.simple.module_a import ModuleA
+from examples.simple.module_b import ModuleB
+
+
+module_a = ModuleA()
+module_a.add(ModuleB())
+
+module_a.start()
+```
+
+### Priorities
+Manual control
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        # handler with higher priority will be triggered early
+        self.sub(StartEvent, self.handle_b, priority=0)
+        self.sub(StartEvent, self.handle_a, priority=100)
+
+    def handle_a(self, event: StartEvent):
+        # will be triggered first
+        print(f'field a:{event.a}')
+
+    def handle_b(self, event: StartEvent):
+        # will be triggered second
+        print(f'event.uuid:{event.uuid}, event.timestamp:{event.timestamp}')
+```
+Default priority depends on registration order
+```python
+from decouple import Module
+from examples.simple.module_a import StartEvent
+
+
+class ModuleB(Module):
+    def __init__(self):
+        super().__init__()
+
+        # priority of handlers call increased by 1 every registration for the same event
+        self.sub(StartEvent, self.handle_b)   # priority=1
+        self.sub(StartEvent, self.handle_a)   # priority=2
+
+    def handle_a(self, event: StartEvent):
+        # will be triggered second
+        print(f'field a:{event.a}')
+
+    def handle_b(self, event: StartEvent):
+        # will be triggered first
+        print(f'event.uuid:{event.uuid}, event.timestamp:{event.timestamp}')
+```
+
+# Feedback
+I will be glad to read your feedback in issues and pull requests.
+
+%prep
+%autosetup -n decouple-0.0.7
+
+%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-decouple -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Mon Apr 10 2023 Python_Bot <Python_Bot@openeuler.org> - 0.0.7-1
+- Package Spec generated