%global _empty_manifest_terminate_build 0
Name:		python-atlas-engine-client
Version:	2.7.0
Release:	1
Summary:	A Client for the workflow engine of the ProcessCube platform.
License:	MIT License
URL:		https://github.com/atlas-engine/Client.py
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/fa/4b/a3fc92a1bdf5adda785fb9fe5abc3805fffa0075e1438e1d014ad9f586b2/atlas_engine_client-2.7.0.tar.gz
BuildArch:	noarch

Requires:	python3-aiohttp
Requires:	python3-asyncio
Requires:	python3-nest-asyncio
Requires:	python3-dataclasses-json
Requires:	python3-requests

%description
# AtlasEngine mittels Python verwenden

Wenn es darum geht mit Python Prozess zu starten bzw. zu kontrollieren, *External Task* zu verarbeiten 
und Benutzer-Tasks auszuführen, dann ist der `AtlasEngine`-Client richtig. In dieser README 
wird die Verwendung der unterschiedliche Aspekte anhand von Beispielen gezeigt:

- [Vorbereitung der Umgebung](#vorbereitung-der-umgebung)
- [Prozess starten](#prozesss-starten)
- [*External Task* verarbeiten](#external-task-verarbeiten)
- TODO: *User Task* bearbeiten
- TODO: *Event* aus der Prozessengine verarbeiten

Die Erweiterung der Client wird dagegen in [CONTRIBUTION.MD](CONTRIBUTION.MD) erklärt.

# Vorbereitung der Umgebung

## Installation des *BPMN-Studio*

Die einfachster Version mit der Interaktion von Python und der Engine zu starten,
ist die Installation des *BPMN-Studio*, da es die Entwicklung von BPMN-Prozess unterstützt
und eine vorbereitete Engine mitbringt, die für die ersten Schritte ausreichend ist.

### Prozess erstellen bzw. Beispiel verwenden

Um den ersten Prozess nicht erstellen zu müssen, ist der Prozess *[Hello World](samples/bpmn_models/hello_world.bpmn)* 
vorhanden, dieser muss in das *BPMN-Studio* geladen werden.

![Prozess laden](docs/open_process.png)

### Prozess auf die Engine veröffentlichen

Um den Prozess verwenden zu können, ist es notwendig, dass
dieser auf doe Engine veröffentlicht worden ist. Dazu ist es notwendig, den Prozess zu öffenen (1) und anschließend auf die Engine zu veröffentlichen (2).

![Prozess veröffentlichen](docs/deploy_process.png)

Nachdem der Prozess veröffenticht würde, kann er mittels Python gestartet werden.

![Prozess veröffentlicht](docs/deployed_process.png)

## Prozess starten

Um einen Prozess zu startet ist die Prozess-Id (hier: `hello_world`) und die URL (hier: `http://localhost:56000`) unter der die Engine zu erreichen ist, notwendig. Nachdem die Informationen bekannt sind, kann der Prozess mit dem entsprechenden angepassten Script mit Hilfe von Python gestartet werden.

### Beispiel mit nicht blockierendem Client

```python
import logging

from atlas_engine_client.process_model import ProcessModelClient

logger = logging.getLogger(__name__)

def main(engine_url):
    client = ProcessModelClient(engine_url)
    result = client.start_process_instance('hello_world')

    logger.info(f"Started process instance with result {result}")

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

### Beispiel mit blockierendem Client

```python
import logging

from atlas_engine_client.process_model import ProcessModelClient, StartCallbackType

logger = logging.getLogger(__name__)

def main(engine_url):
    client = ProcessModelClient(engine_url)
    result = client.start_process_instance('hello_world', 
        'the_start_event',
        'the_end_event', 
        start_callback=StartCallbackType.ON_ENDEVENT_REACHED
    )

    logger.info(f"Started process instance with result {result}")

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

## *External Task* verarbeiten

Im Beispiel-Prozess ist bereit eine ServiceTask als *External Task* konfiguriert. 

Für die Verwendung des *External Task* muss ein Topic (hier: `SampleExternalTask`) festgelegt werden und die URL der Engine (hier: `http://localhost:56000`) bekannt sein.
Nachdem die Informationen bekannt sind, kann der *External Task* mit dem angepassten Script abgearbeitet werden.

Optionen für das Abonnieren von Aufträgen:
- max_tasks: Anzahl der Aufträge (task), die gleichzeitig verarbeitet werden sollen
- long_polling_timeout_in_ms: Timeout für das Abonnieren
- lock_duration_in_ms: Wir lange soll der Auftrag reseviert werden, bis er für weitere Worker zur Verfügung steht

### Beispiel mit einem Parameter für den Handler *_handler*

```python
import logging

from atlas_engine_client.external_task import ExternalTaskClient

logger = logging.getLogger(__name__)

def _handler(payload):
    logger.debug("so some work")
    logger.debug(payload)
    logger.debug("some worker done.")

    return {'some': 'result'}

def main(engine_url):
    client = ExternalTaskClient(engine_url)

    client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler, max_tasks=5)

    client.start()

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.INFO #logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

### Beispiel mit einem weiteren Parameter für den Handler *_handler*

```python
import logging

from atlas_engine_client.external_task import ExternalTaskClient

logger = logging.getLogger(__name__)

def _handler(payload, task):
    logger.debug("so some work")
    logger.info(f"payload: {payload} for task {task}")
    logger.debug("some worker done.")

    return {'some': 'result'}

def main(engine_url):
    client = ExternalTaskClient(engine_url)

    client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler)

    client.start()

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.INFO #logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

## Mitmachen

### Deployment auf pypi

Abhängigkeiten installieren
```sh
python -m pip install twine
```

Quellenpaket erstellen
```sh
python setup.py sdist
````

Upload zu pypi
```sh
twine upload dist/*
````

Die Anmeldedaten für den Upload zu pypi stehen in 1Password im Tresor processengine.


%package -n python3-atlas-engine-client
Summary:	A Client for the workflow engine of the ProcessCube platform.
Provides:	python-atlas-engine-client
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-atlas-engine-client
# AtlasEngine mittels Python verwenden

Wenn es darum geht mit Python Prozess zu starten bzw. zu kontrollieren, *External Task* zu verarbeiten 
und Benutzer-Tasks auszuführen, dann ist der `AtlasEngine`-Client richtig. In dieser README 
wird die Verwendung der unterschiedliche Aspekte anhand von Beispielen gezeigt:

- [Vorbereitung der Umgebung](#vorbereitung-der-umgebung)
- [Prozess starten](#prozesss-starten)
- [*External Task* verarbeiten](#external-task-verarbeiten)
- TODO: *User Task* bearbeiten
- TODO: *Event* aus der Prozessengine verarbeiten

Die Erweiterung der Client wird dagegen in [CONTRIBUTION.MD](CONTRIBUTION.MD) erklärt.

# Vorbereitung der Umgebung

## Installation des *BPMN-Studio*

Die einfachster Version mit der Interaktion von Python und der Engine zu starten,
ist die Installation des *BPMN-Studio*, da es die Entwicklung von BPMN-Prozess unterstützt
und eine vorbereitete Engine mitbringt, die für die ersten Schritte ausreichend ist.

### Prozess erstellen bzw. Beispiel verwenden

Um den ersten Prozess nicht erstellen zu müssen, ist der Prozess *[Hello World](samples/bpmn_models/hello_world.bpmn)* 
vorhanden, dieser muss in das *BPMN-Studio* geladen werden.

![Prozess laden](docs/open_process.png)

### Prozess auf die Engine veröffentlichen

Um den Prozess verwenden zu können, ist es notwendig, dass
dieser auf doe Engine veröffentlicht worden ist. Dazu ist es notwendig, den Prozess zu öffenen (1) und anschließend auf die Engine zu veröffentlichen (2).

![Prozess veröffentlichen](docs/deploy_process.png)

Nachdem der Prozess veröffenticht würde, kann er mittels Python gestartet werden.

![Prozess veröffentlicht](docs/deployed_process.png)

## Prozess starten

Um einen Prozess zu startet ist die Prozess-Id (hier: `hello_world`) und die URL (hier: `http://localhost:56000`) unter der die Engine zu erreichen ist, notwendig. Nachdem die Informationen bekannt sind, kann der Prozess mit dem entsprechenden angepassten Script mit Hilfe von Python gestartet werden.

### Beispiel mit nicht blockierendem Client

```python
import logging

from atlas_engine_client.process_model import ProcessModelClient

logger = logging.getLogger(__name__)

def main(engine_url):
    client = ProcessModelClient(engine_url)
    result = client.start_process_instance('hello_world')

    logger.info(f"Started process instance with result {result}")

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

### Beispiel mit blockierendem Client

```python
import logging

from atlas_engine_client.process_model import ProcessModelClient, StartCallbackType

logger = logging.getLogger(__name__)

def main(engine_url):
    client = ProcessModelClient(engine_url)
    result = client.start_process_instance('hello_world', 
        'the_start_event',
        'the_end_event', 
        start_callback=StartCallbackType.ON_ENDEVENT_REACHED
    )

    logger.info(f"Started process instance with result {result}")

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

## *External Task* verarbeiten

Im Beispiel-Prozess ist bereit eine ServiceTask als *External Task* konfiguriert. 

Für die Verwendung des *External Task* muss ein Topic (hier: `SampleExternalTask`) festgelegt werden und die URL der Engine (hier: `http://localhost:56000`) bekannt sein.
Nachdem die Informationen bekannt sind, kann der *External Task* mit dem angepassten Script abgearbeitet werden.

Optionen für das Abonnieren von Aufträgen:
- max_tasks: Anzahl der Aufträge (task), die gleichzeitig verarbeitet werden sollen
- long_polling_timeout_in_ms: Timeout für das Abonnieren
- lock_duration_in_ms: Wir lange soll der Auftrag reseviert werden, bis er für weitere Worker zur Verfügung steht

### Beispiel mit einem Parameter für den Handler *_handler*

```python
import logging

from atlas_engine_client.external_task import ExternalTaskClient

logger = logging.getLogger(__name__)

def _handler(payload):
    logger.debug("so some work")
    logger.debug(payload)
    logger.debug("some worker done.")

    return {'some': 'result'}

def main(engine_url):
    client = ExternalTaskClient(engine_url)

    client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler, max_tasks=5)

    client.start()

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.INFO #logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

### Beispiel mit einem weiteren Parameter für den Handler *_handler*

```python
import logging

from atlas_engine_client.external_task import ExternalTaskClient

logger = logging.getLogger(__name__)

def _handler(payload, task):
    logger.debug("so some work")
    logger.info(f"payload: {payload} for task {task}")
    logger.debug("some worker done.")

    return {'some': 'result'}

def main(engine_url):
    client = ExternalTaskClient(engine_url)

    client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler)

    client.start()

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.INFO #logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

## Mitmachen

### Deployment auf pypi

Abhängigkeiten installieren
```sh
python -m pip install twine
```

Quellenpaket erstellen
```sh
python setup.py sdist
````

Upload zu pypi
```sh
twine upload dist/*
````

Die Anmeldedaten für den Upload zu pypi stehen in 1Password im Tresor processengine.


%package help
Summary:	Development documents and examples for atlas-engine-client
Provides:	python3-atlas-engine-client-doc
%description help
# AtlasEngine mittels Python verwenden

Wenn es darum geht mit Python Prozess zu starten bzw. zu kontrollieren, *External Task* zu verarbeiten 
und Benutzer-Tasks auszuführen, dann ist der `AtlasEngine`-Client richtig. In dieser README 
wird die Verwendung der unterschiedliche Aspekte anhand von Beispielen gezeigt:

- [Vorbereitung der Umgebung](#vorbereitung-der-umgebung)
- [Prozess starten](#prozesss-starten)
- [*External Task* verarbeiten](#external-task-verarbeiten)
- TODO: *User Task* bearbeiten
- TODO: *Event* aus der Prozessengine verarbeiten

Die Erweiterung der Client wird dagegen in [CONTRIBUTION.MD](CONTRIBUTION.MD) erklärt.

# Vorbereitung der Umgebung

## Installation des *BPMN-Studio*

Die einfachster Version mit der Interaktion von Python und der Engine zu starten,
ist die Installation des *BPMN-Studio*, da es die Entwicklung von BPMN-Prozess unterstützt
und eine vorbereitete Engine mitbringt, die für die ersten Schritte ausreichend ist.

### Prozess erstellen bzw. Beispiel verwenden

Um den ersten Prozess nicht erstellen zu müssen, ist der Prozess *[Hello World](samples/bpmn_models/hello_world.bpmn)* 
vorhanden, dieser muss in das *BPMN-Studio* geladen werden.

![Prozess laden](docs/open_process.png)

### Prozess auf die Engine veröffentlichen

Um den Prozess verwenden zu können, ist es notwendig, dass
dieser auf doe Engine veröffentlicht worden ist. Dazu ist es notwendig, den Prozess zu öffenen (1) und anschließend auf die Engine zu veröffentlichen (2).

![Prozess veröffentlichen](docs/deploy_process.png)

Nachdem der Prozess veröffenticht würde, kann er mittels Python gestartet werden.

![Prozess veröffentlicht](docs/deployed_process.png)

## Prozess starten

Um einen Prozess zu startet ist die Prozess-Id (hier: `hello_world`) und die URL (hier: `http://localhost:56000`) unter der die Engine zu erreichen ist, notwendig. Nachdem die Informationen bekannt sind, kann der Prozess mit dem entsprechenden angepassten Script mit Hilfe von Python gestartet werden.

### Beispiel mit nicht blockierendem Client

```python
import logging

from atlas_engine_client.process_model import ProcessModelClient

logger = logging.getLogger(__name__)

def main(engine_url):
    client = ProcessModelClient(engine_url)
    result = client.start_process_instance('hello_world')

    logger.info(f"Started process instance with result {result}")

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

### Beispiel mit blockierendem Client

```python
import logging

from atlas_engine_client.process_model import ProcessModelClient, StartCallbackType

logger = logging.getLogger(__name__)

def main(engine_url):
    client = ProcessModelClient(engine_url)
    result = client.start_process_instance('hello_world', 
        'the_start_event',
        'the_end_event', 
        start_callback=StartCallbackType.ON_ENDEVENT_REACHED
    )

    logger.info(f"Started process instance with result {result}")

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

## *External Task* verarbeiten

Im Beispiel-Prozess ist bereit eine ServiceTask als *External Task* konfiguriert. 

Für die Verwendung des *External Task* muss ein Topic (hier: `SampleExternalTask`) festgelegt werden und die URL der Engine (hier: `http://localhost:56000`) bekannt sein.
Nachdem die Informationen bekannt sind, kann der *External Task* mit dem angepassten Script abgearbeitet werden.

Optionen für das Abonnieren von Aufträgen:
- max_tasks: Anzahl der Aufträge (task), die gleichzeitig verarbeitet werden sollen
- long_polling_timeout_in_ms: Timeout für das Abonnieren
- lock_duration_in_ms: Wir lange soll der Auftrag reseviert werden, bis er für weitere Worker zur Verfügung steht

### Beispiel mit einem Parameter für den Handler *_handler*

```python
import logging

from atlas_engine_client.external_task import ExternalTaskClient

logger = logging.getLogger(__name__)

def _handler(payload):
    logger.debug("so some work")
    logger.debug(payload)
    logger.debug("some worker done.")

    return {'some': 'result'}

def main(engine_url):
    client = ExternalTaskClient(engine_url)

    client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler, max_tasks=5)

    client.start()

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.INFO #logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

### Beispiel mit einem weiteren Parameter für den Handler *_handler*

```python
import logging

from atlas_engine_client.external_task import ExternalTaskClient

logger = logging.getLogger(__name__)

def _handler(payload, task):
    logger.debug("so some work")
    logger.info(f"payload: {payload} for task {task}")
    logger.debug("some worker done.")

    return {'some': 'result'}

def main(engine_url):
    client = ExternalTaskClient(engine_url)

    client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler)

    client.start()

if __name__ == '__main__':
    engine_url = 'http://localhost:56000'

    format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    level = logging.INFO #logging.DEBUG
    logging.basicConfig(level=level, format=format_template)

    main(engine_url)
```

## Mitmachen

### Deployment auf pypi

Abhängigkeiten installieren
```sh
python -m pip install twine
```

Quellenpaket erstellen
```sh
python setup.py sdist
````

Upload zu pypi
```sh
twine upload dist/*
````

Die Anmeldedaten für den Upload zu pypi stehen in 1Password im Tresor processengine.


%prep
%autosetup -n atlas-engine-client-2.7.0

%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-atlas-engine-client -f filelist.lst
%dir %{python3_sitelib}/*

%files help -f doclist.lst
%{_docdir}/*

%changelog
* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 2.7.0-1
- Package Spec generated