python-openhab-rest-client 0.1.0__py3-none-any.whl

tests/tags.py

@@ -0,0 +1,53 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, Tags
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+tagsApi = Tags(client)
+
+# Beispiele für die Tags-API
+def tagsExamples():
+    # Alle Tags abrufen
+    allTags = tagsApi.getTags()
+    print("All Tags:", allTags)
+
+    # Ein neues Tag erstellen
+    # Beispiel für das Tag-Datenobjekt
+    newTagData = {
+        "uid": "CustomTag",
+        "name": "CustomTag",
+        "label": "My Custom Tag",
+        "description": "This is a custom tag",
+        "synonyms": ["Custom", "Tag"],
+        "editable": True
+    }
+
+    try:
+        response = tagsApi.createTag(newTagData)
+        print("Tag Created:", response)
+    except Exception as e:
+        print("Error creating tag:", e)
+
+    # Details zu einem Tag abrufen
+    tagDetails = tagsApi.getTag("Property_Voltage")
+    print("Details for newTag:", tagDetails)
+
+    # Ein Tag aktualisieren
+    updatedTagData = {
+        "id": "Property_Voltage",
+        "label": "Updated Tag"
+    }
+    tagsApi.updateTag("Property_Voltage", newTagData)
+    print("newTag updated.")
+
+    # Ein Tag löschen
+    tagsApi.deleteTag("Property_Voltage")
+    print("newTag deleted.")
+
+# Funktion ausführen
+if __name__ == "__main__":
+    tagsExamples()

tests/templates.py

@@ -0,0 +1,28 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, Templates
+
+# OpenHABClient initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+templatesApi = Templates(client)
+
+# Alle Templates abrufen
+try:
+    allTemplates = templatesApi.getAllTemplates()
+    print("Alle Templates:")
+    for template in allTemplates:
+        print(f"- {template['uid']}: {template['label']}")
+except Exception as e:
+    print(f"Fehler beim Abrufen der Templates: {e}")
+
+# Spezifisches Template abrufen
+try:
+    templateUid = "example_template_uid"  # Beispiel-UID
+    specificTemplate = templatesApi.getTemplateByUID(templateUid)
+    print("\nDetails des spezifischen Templates:")
+    print(specificTemplate)
+except Exception as e:
+    print(f"Fehler beim Abrufen des spezifischen Templates: {e}")

tests/test.py

@@ -0,0 +1,11 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from openhab import OpenHABClient
+
+# Client initialisieren (ersetze 'http://openhab-url' mit deiner URL und 'auth_token' mit deinem Token)
+#client = OpenHABClient(base_url='http://openhab-url', auth_token='your_auth_token')
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")

tests/thing_events.py

@@ -0,0 +1,17 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, ThingEvents
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+thingEvents = ThingEvents(client)
+
+# Beispielaufrufe
+print(thingEvents.ThingAddedEvent("*"))
+print(thingEvents.ThingRemovedEvent("*"))
+print(thingEvents.ThingUpdatedEvent("*"))
+print(thingEvents.ThingStatusInfoEvent("*"))
+print(thingEvents.ThingStatusInfoChangedEvent("*"))

tests/thing_types.py

@@ -0,0 +1,28 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, ThingTypes
+
+# OpenHABClient initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+thingTypesApi = ThingTypes(client)
+
+# Alle Thing-Typen abrufen
+try:
+    allThingTypes = thingTypesApi.getAllThingTypes()
+    print("Alle Thing-Typen:")
+    for thingType in allThingTypes:
+        print(f"- {thingType['UID']}: {thingType['label']}")
+except Exception as e:
+    print(f"Fehler beim Abrufen der Thing-Typen: {e}")
+
+# Spezifischen Thing-Typ abrufen
+try:
+    thingTypeUid = "mqtt:homeassistant"  # Beispiel-UID
+    specificThingType = thingTypesApi.getThingType(thingTypeUid)
+    print("\nDetails des spezifischen Thing-Typs:")
+    print(specificThingType)
+except Exception as e:
+    print(f"Fehler beim Abrufen des spezifischen Thing-Typs: {e}")

tests/things.py

@@ -0,0 +1,75 @@
+import sys
+import os
+import time
+import traceback
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, Things
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+thingsApi = Things(client)
+
+
+def safeCall(description, func, *args, **kwargs):
+    try:
+        print(f"{description}...")
+        response = func(*args, **kwargs)
+        print("Erfolgreich:", response)
+    except Exception as e:
+        print(f"Fehler bei {description}: {e}")
+        traceback.print_exc()  # Stacktrace ausgeben
+
+# 1. Alle Things abrufen
+#safeCall("Alle Things abrufen", thingsApi.getAllThings)
+
+# 2. Ein spezifisches Thing per UID abrufen
+thingUID = "mqtt:topic:mybroker:newthing"
+safeCall(f"Thing {thingUID} abrufen", thingsApi.getThingByUID, thingUID)
+
+# 3. Ein neues Thing erstellen
+newThing = {
+    "UID": "mqtt:topic:mybroker:newthing",
+    "label": "Neues MQTT Thing",
+    "thingTypeUID": "mqtt:topic",
+    "bridgeUID": "mqtt:broker:mybroker",
+    "configuration": {},
+    "channels": []
+}
+safeCall("Neues Thing erstellen", thingsApi.createThing, newThing)
+
+#time.sleep(2)  # Warte, damit OpenHAB das neue Thing registrieren kann
+
+thingUID = "mqtt:topic:mybroker:newthing"
+# 4. Ein Thing aktualisieren
+updatedData = {"label": "Aktualisiertes MQTT Thing"}
+#safeCall(f"Thing {thingUID} aktualisieren", thingsApi.updateThing, thingUID, updatedData)
+
+# 5. Ein Thing löschen
+#safeCall(f"Thing {thingUID} löschen", thingsApi.deleteThing, thingUID, force=True)
+
+# 6. Die Konfiguration eines Things aktualisieren
+configUpdate = {"retain": True}
+safeCall(f"Thing {thingUID} Konfiguration aktualisieren", thingsApi.updateThingConfiguration, thingUID, configUpdate)
+
+# 7. Den Status eines Things abrufen
+#safeCall(f"Thing {thingUID} Status abrufen", thingsApi.getThingStatus, thingUID)
+
+# 8. Ein Thing aktivieren oder deaktivieren
+safeCall(f"Thing {thingUID} aktivieren", thingsApi.enableThing, thingUID, enabled=True)
+
+# 9. Den Firmware-Status abrufen
+safeCall(f"Thing {thingUID} Firmware-Status abrufen", thingsApi.getThingFirmwareStatus, thingUID)
+
+# 10. Eine Firmware aktualisieren
+firmwareVersion = "1.2.3"
+safeCall(f"Thing {thingUID} Firmware auf {firmwareVersion} aktualisieren", thingsApi.updateThingFirmware, thingUID, firmwareVersion)
+
+# 11. Alle verfügbaren Firmwares für ein Thing abrufen
+safeCall(f"Thing {thingUID} verfügbare Firmwares abrufen", thingsApi.getThingFirmwares, thingUID)
+
+# 12. Den Konfigurationsstatus eines Things abrufen
+safeCall(f"Thing {thingUID} Konfigurationsstatus abrufen", thingsApi.getThingConfigStatus, thingUID)
+
+print("Alle API-Tests abgeschlossen.")

tests/transformations.py

@@ -0,0 +1,38 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, Transformations
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+transformationsApi = Transformations(client)
+
+# Alle Transformationen abrufen
+transformationsList = transformationsApi.getTransformations()
+print(transformationsList)
+
+# Eine spezifische Transformation abrufen
+uid = "en.map"
+transformation = transformationsApi.getTransformation(uid)
+print(transformation)
+
+# Eine Transformation aktualisieren
+updatedData = {
+    "uid": "my_custom_map",
+    "label": "My Custom Map",
+    "type": "map",
+    "configuration": {"function": "CLOSED=geschlossen\nOPEN=offen\nNULL=unbekannt\n"},
+    "editable": True
+}
+#updatedTransformation = transformationsApi.updateTransformation(uid, updatedData)
+#print(updatedTransformation)
+
+# Eine Transformation löschen
+#deletedTransformation = transformationsApi.deleteTransformation(uid)
+#print(deletedTransformation)
+
+# Alle Transformation-Dienste abrufen
+services = transformationsApi.getTransformationServices()
+print(services)

tests/ui.py

@@ -0,0 +1,70 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, UI
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+uiApi = UI(client)
+
+# Alle UI-Komponenten im Namespace "home" abrufen
+namespace = "home"
+uiComponents = uiApi.getUiComponents(namespace)
+print("Alle UI-Komponenten:\n")
+print(uiComponents)
+
+# Eine neue UI-Komponente hinzufügen
+componentData = {
+    "component": "Button",
+    "config": {
+        "label": "Turn On Light",
+        "action": "turn_on"
+    },
+    "slots": {
+        "slot1": [{"component": "Icon", "config": {"icon": "light"}}]
+    },
+    "uid": "unique-button-uid",
+    "tags": ["button", "light-control"],
+    "props": {
+        "uri": "/control/light",
+        "parameters": [
+            {"name": "light", "label": "Light", "type": "TEXT", "required": True}
+        ]
+    },
+    "timestamp": "2025-01-27T15:37:35.741Z",
+    "type": "button"
+}
+newComponent = uiApi.addUiComponent(namespace, componentData)
+print("Neue UI-Komponente:\n")
+print(newComponent)
+
+# Eine spezifische UI-Komponente abrufen
+componentUid = "unique-button-uid"
+component = uiApi.getUiComponent(namespace, componentUid)
+print("Einzelne UI-Komponente:\n")
+print(component)
+
+# Eine UI-Komponente aktualisieren
+updatedComponentData = {
+    "component": "Button",
+    "config": {
+        "label": "Turn Off Light",
+        "action": "turn_off"
+    },
+    "uid": "unique-button-uid"
+}
+updatedComponent = uiApi.updateUiComponent(namespace, componentUid, updatedComponentData)
+print("Geänderte UI-Komponente:\n")
+print(updatedComponent)
+
+# Eine UI-Komponente löschen
+deletedComponent = uiApi.deleteUiComponent(namespace, componentUid)
+print("Gelöschte UI-Komponente:\n")
+print(deletedComponent)
+
+# Alle UI-Kacheln abrufen
+uiTiles = uiApi.getUiTiles()
+print("Kacheln einer UI-Komponente:\n")
+print(uiTiles)

tests/uuid.py

@@ -0,0 +1,18 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad (eine Ebene höher) zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, UUID
+
+# Client initialisieren (ersetze 'http://openhab-url' mit deiner URL und 'auth_token' mit deinem Token)
+# client = OpenHABClient(base_url='http://openhab-url', auth_token='your_auth_token')
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+uuidApi = UUID(client)
+
+# Rufe die UUID ab
+try:
+    openhabUuid = uuidApi.getUUID()
+    print(f"Die UUID von OpenHAB ist: {openhabUuid}")
+except Exception as e:
+    print(f"Fehler beim Abrufen der UUID: {e}")

tests/voice.py

@@ -0,0 +1,119 @@
+import sys
+import os
+
+# Füge den Projektwurzelpfad zum Python-Suchpfad hinzu
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from openhab import OpenHABClient, Voice
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+voiceApi = Voice(client)
+
+# Beispiele für die Voice-API mit Fehlerbehandlung
+def voiceExamples():
+    try:
+        # 1. Standardstimme abrufen
+        print(1)
+        defaultVoice = voiceApi.getDefaultVoice()
+        print("Default Voice:", defaultVoice)
+    except Exception as e:
+        print(f"Fehler beim Abrufen der Standardstimme: {e}")
+
+    try:
+        # 2. Liste aller Stimmen abrufen
+        print(2)
+        allVoices = voiceApi.getVoices()
+        print("All Voices:", allVoices)
+    except Exception as e:
+        print(f"Fehler beim Abrufen aller Stimmen: {e}")
+        allVoices = []
+
+    try:
+        # 3. Text mit einer Stimme ausgeben
+        print(3)
+        if allVoices:
+            voiceId = allVoices[0]['id']
+            response = voiceApi.sayText("Hello from OpenHAB!", voiceID=voiceId, sinkId="your_audio_sink_id")
+            print(f"Text spoken using Voice {voiceId}:", response)
+    except Exception as e:
+        print(f"Fehler beim Sprechen des Textes: {e}")
+
+    try:
+        # 4. Liste aller Interpreter abrufen
+        print(4)
+        interpreters = voiceApi.getInterpreters(language="en")
+        print("Interpreters:", interpreters)
+    except Exception as e:
+        print(f"Fehler beim Abrufen der Interpreter: {e}")
+        interpreters = []
+
+    try:
+        # 5. Text interpretieren (Standard-Interpreter)
+        print(5)
+        interpretedText = voiceApi.interpretText("Turn on the lights", language="en", IDs=[])
+        print("Interpreted Text:", interpretedText)
+    except Exception as e:
+        print(f"Fehler beim Interpretieren des Textes: {e}")
+
+    try:
+        # 6. Mehrere Interpreter zur Interpretation ansprechen
+        print(6)
+        if interpreters:
+            interpreterIds = [interpreter['id'] for interpreter in interpreters[:2]]  # Max. 2 Interpreter
+            interpretedTextBatch = voiceApi.interpretTextBatch("Turn off the heater", language="en", IDs=interpreterIds)
+            print("Batch Interpreted Text:", interpretedTextBatch)
+    except Exception as e:
+        print(f"Fehler beim Batch-Interpretieren des Textes: {e}")
+
+    try:
+        # 7. Details eines einzelnen Interpreters abrufen
+        print(7)
+        if interpreters:
+            interpreterId = interpreters[0]['id']
+            interpreterDetails = voiceApi.getInterpreter(interpreterId, language="en")
+            print(f"Interpreter details for {interpreterId}:", interpreterDetails)
+    except Exception as e:
+        print(f"Fehler beim Abrufen des Interpreters: {e}")
+
+    try:
+        print(8)
+        # 8. Dialog starten
+        dialogResponse = voiceApi.startDialog(
+            sourceID="audioSource1", 
+            keyword="Hello", 
+            sttID="sttSystem", 
+            ttsID="ttsSystem", 
+            voiceID="voice1", 
+            sinkID="audioOut"
+        )
+        print("Dialog started:", dialogResponse)
+    except Exception as e:
+        print(f"Fehler beim Starten des Dialogs: {e}")
+
+    try:
+        # 9. Dialog stoppen
+        print(9)
+        dialogStopResponse = voiceApi.stopDialog(sourceID="audioSource1")
+        print("Dialog stopped:", dialogStopResponse)
+    except Exception as e:
+        print(f"Fehler beim Stoppen des Dialogs: {e}")
+
+    try:
+        # 10. Listen and Answer ausführen
+        print(10)
+        listenAndAnswerResponse = voiceApi.listenAndAnswer(
+            sourceID="audioSource1", 
+            sttID="sttSystem", 
+            ttsID="ttsSystem", 
+            voiceID="voice1", 
+            hliIDs=["interpreter1", "interpreter2"], 
+            sinkID="audioOut", 
+            listeningItem="light_switch"
+        )
+        print("Listen and Answer response:", listenAndAnswerResponse)
+    except Exception as e:
+        print(f"Fehler bei Listen and Answer: {e}")
+
+# Funktion ausführen
+if __name__ == "__main__":
+    voiceExamples()