# 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 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).
Nachdem der Prozess veröffenticht würde, kann er mittels Python gestartet werden.
## 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.
Raw data
{
"_id": null,
"home_page": "https://github.com/atlas-engine/Client.py",
"name": "atlas-engine-client",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "workflow-engine atlas-engine client bpmn",
"author": "5Minds IT-Solutions GmbH & Co. KG",
"author_email": "ProcessCube@5Minds.de",
"download_url": "https://files.pythonhosted.org/packages/b1/e8/87627aae56e924bd44d5c42da730faa52274a120d6e5cf4679bb6f7af733/atlas_engine_client-3.1.1.tar.gz",
"platform": null,
"description": "# AtlasEngine mittels Python verwenden\n\nWenn es darum geht mit Python Prozess zu starten bzw. zu kontrollieren, *External Task* zu verarbeiten \nund Benutzer-Tasks auszuf\u00fchren, dann ist der `AtlasEngine`-Client richtig. In dieser README \nwird die Verwendung der unterschiedliche Aspekte anhand von Beispielen gezeigt:\n\n- [Vorbereitung der Umgebung](#vorbereitung-der-umgebung)\n- [Prozess starten](#prozesss-starten)\n- [*External Task* verarbeiten](#external-task-verarbeiten)\n- TODO: *User Task* bearbeiten\n- TODO: *Event* aus der Prozessengine verarbeiten\n\nDie Erweiterung der Client wird dagegen in [CONTRIBUTION.MD](CONTRIBUTION.MD) erkl\u00e4rt.\n\n# Vorbereitung der Umgebung\n\n## Installation des *BPMN-Studio*\n\nDie einfachster Version mit der Interaktion von Python und der Engine zu starten,\nist die Installation des *BPMN-Studio*, da es die Entwicklung von BPMN-Prozess unterst\u00fctzt\nund eine vorbereitete Engine mitbringt, die f\u00fcr die ersten Schritte ausreichend ist.\n\n### Prozess erstellen bzw. Beispiel verwenden\n\nUm den ersten Prozess nicht erstellen zu m\u00fcssen, ist der Prozess *[Hello World](samples/bpmn_models/hello_world.bpmn)* \nvorhanden, dieser muss in das *BPMN-Studio* geladen werden.\n\n\n\n### Prozess auf die Engine ver\u00f6ffentlichen\n\nUm den Prozess verwenden zu k\u00f6nnen, ist es notwendig, dass\ndieser auf doe Engine ver\u00f6ffentlicht worden ist. Dazu ist es notwendig, den Prozess zu \u00f6ffenen (1) und anschlie\u00dfend auf die Engine zu ver\u00f6ffentlichen (2).\n\n\n\nNachdem der Prozess ver\u00f6ffenticht w\u00fcrde, kann er mittels Python gestartet werden.\n\n\n\n## Prozess starten\n\nUm 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.\n\n### Beispiel mit nicht blockierendem Client\n\n```python\nimport logging\n\nfrom atlas_engine_client.process_model import ProcessModelClient\n\nlogger = logging.getLogger(__name__)\n\ndef main(engine_url):\n client = ProcessModelClient(engine_url)\n result = client.start_process_instance('hello_world')\n\n logger.info(f\"Started process instance with result {result}\")\n\nif __name__ == '__main__':\n engine_url = 'http://localhost:56000'\n\n format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n level = logging.DEBUG\n logging.basicConfig(level=level, format=format_template)\n\n main(engine_url)\n```\n\n### Beispiel mit blockierendem Client\n\n```python\nimport logging\n\nfrom atlas_engine_client.process_model import ProcessModelClient, StartCallbackType\n\nlogger = logging.getLogger(__name__)\n\ndef main(engine_url):\n client = ProcessModelClient(engine_url)\n result = client.start_process_instance('hello_world', \n 'the_start_event',\n 'the_end_event', \n start_callback=StartCallbackType.ON_ENDEVENT_REACHED\n )\n\n logger.info(f\"Started process instance with result {result}\")\n\nif __name__ == '__main__':\n engine_url = 'http://localhost:56000'\n\n format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n level = logging.DEBUG\n logging.basicConfig(level=level, format=format_template)\n\n main(engine_url)\n```\n\n## *External Task* verarbeiten\n\nIm Beispiel-Prozess ist bereit eine ServiceTask als *External Task* konfiguriert. \n\nF\u00fcr die Verwendung des *External Task* muss ein Topic (hier: `SampleExternalTask`) festgelegt werden und die URL der Engine (hier: `http://localhost:56000`) bekannt sein.\nNachdem die Informationen bekannt sind, kann der *External Task* mit dem angepassten Script abgearbeitet werden.\n\nOptionen f\u00fcr das Abonnieren von Auftr\u00e4gen:\n- max_tasks: Anzahl der Auftr\u00e4ge (task), die gleichzeitig verarbeitet werden sollen\n- long_polling_timeout_in_ms: Timeout f\u00fcr das Abonnieren\n- lock_duration_in_ms: Wir lange soll der Auftrag reseviert werden, bis er f\u00fcr weitere Worker zur Verf\u00fcgung steht\n\n### Beispiel mit einem Parameter f\u00fcr den Handler *_handler*\n\n```python\nimport logging\n\nfrom atlas_engine_client.external_task import ExternalTaskClient\n\nlogger = logging.getLogger(__name__)\n\ndef _handler(payload):\n logger.debug(\"so some work\")\n logger.debug(payload)\n logger.debug(\"some worker done.\")\n\n return {'some': 'result'}\n\ndef main(engine_url):\n client = ExternalTaskClient(engine_url)\n\n client.subscribe_to_external_task_for_topic(\"SampleExternalTask\", _handler, max_tasks=5)\n\n client.start()\n\nif __name__ == '__main__':\n engine_url = 'http://localhost:56000'\n\n format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n level = logging.INFO #logging.DEBUG\n logging.basicConfig(level=level, format=format_template)\n\n main(engine_url)\n```\n\n### Beispiel mit einem weiteren Parameter f\u00fcr den Handler *_handler*\n\n```python\nimport logging\n\nfrom atlas_engine_client.external_task import ExternalTaskClient\n\nlogger = logging.getLogger(__name__)\n\ndef _handler(payload, task):\n logger.debug(\"so some work\")\n logger.info(f\"payload: {payload} for task {task}\")\n logger.debug(\"some worker done.\")\n\n return {'some': 'result'}\n\ndef main(engine_url):\n client = ExternalTaskClient(engine_url)\n\n client.subscribe_to_external_task_for_topic(\"SampleExternalTask\", _handler)\n\n client.start()\n\nif __name__ == '__main__':\n engine_url = 'http://localhost:56000'\n\n format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n level = logging.INFO #logging.DEBUG\n logging.basicConfig(level=level, format=format_template)\n\n main(engine_url)\n```\n\n## Mitmachen\n\n### Deployment auf pypi\n\nAbh\u00e4ngigkeiten installieren\n```sh\npython -m pip install twine\n```\n\nQuellenpaket erstellen\n```sh\npython setup.py sdist\n````\n\nUpload zu pypi\n```sh\ntwine upload dist/*\n````\n\nDie Anmeldedaten f\u00fcr den Upload zu pypi stehen in 1Password im Tresor processengine.\n",
"bugtrack_url": null,
"license": "",
"summary": "A Client for the workflow engine of the ProcessCube platform.",
"version": "3.1.1",
"project_urls": {
"Homepage": "https://github.com/atlas-engine/Client.py"
},
"split_keywords": [
"workflow-engine",
"atlas-engine",
"client",
"bpmn"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "cfe9f21073b4f604a7c80dc8d9eb2fc2604440fc3dee496741e660a803df1ec3",
"md5": "9d07656d7d3d321c5aa29b0795229ed6",
"sha256": "0fd2b51afb3a9b4d7135dfb041cc05f7c7b8ac233e019b10e3769779d5e24841"
},
"downloads": -1,
"filename": "atlas_engine_client-3.1.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "9d07656d7d3d321c5aa29b0795229ed6",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 38410,
"upload_time": "2023-05-12T10:19:48",
"upload_time_iso_8601": "2023-05-12T10:19:48.990629Z",
"url": "https://files.pythonhosted.org/packages/cf/e9/f21073b4f604a7c80dc8d9eb2fc2604440fc3dee496741e660a803df1ec3/atlas_engine_client-3.1.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "b1e887627aae56e924bd44d5c42da730faa52274a120d6e5cf4679bb6f7af733",
"md5": "8d93b17ec1a1a1a12f2bd7c76050e4a8",
"sha256": "ef950b7fa5893ec14bc522d25ef84312ef48ac43b5b0c657057c8a2f1b93e6fe"
},
"downloads": -1,
"filename": "atlas_engine_client-3.1.1.tar.gz",
"has_sig": false,
"md5_digest": "8d93b17ec1a1a1a12f2bd7c76050e4a8",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 23163,
"upload_time": "2023-05-12T10:20:10",
"upload_time_iso_8601": "2023-05-12T10:20:10.880476Z",
"url": "https://files.pythonhosted.org/packages/b1/e8/87627aae56e924bd44d5c42da730faa52274a120d6e5cf4679bb6f7af733/atlas_engine_client-3.1.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-05-12 10:20:10",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "atlas-engine",
"github_project": "Client.py",
"github_not_found": true,
"lcname": "atlas-engine-client"
}
JSON
