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

tests/items.py

@@ -0,0 +1,120 @@
+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, Items
+
+# 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")
+itemsApi = Items(client)
+
+# Beispiele für jede Methode in Items
+def examples():
+    
+    # Alle Items abrufen
+    allItems = itemsApi.getAllItems()
+    print("All Items:", allItems)
+
+    
+    # Ein einzelnes Item abrufen
+    testSwitch = itemsApi.getItem("testSwitch")
+    print("testSwitch Details:", testSwitch)
+    
+    # Neues Item hinzufügen oder aktualisieren
+    newItemData = {
+        "type": "Switch",
+        "name": "newSwitch",
+        "label": "New Switch",
+        "groupNames": ["Static"],
+        "tags": ["SwitchTag"],
+        "category": "Switch"
+    }
+    itemsApi.addOrUpdateItem("newSwitch", newItemData)
+    print("New Switch added/updated.")
+    
+    # Liste von Items hinzufügen oder aktualisieren
+    newItems = [
+        {
+            "type": "Number",
+            "name": "newNumber",
+            "label": "New Number",
+            "groupNames": ["Static"],
+            "tags": ["NumberTag"],
+            "category": "Number"
+        },
+        {
+            "type": "String",
+            "name": "newString",
+            "label": "New String",
+            "groupNames": ["Static"],
+            "tags": ["StringTag"],
+            "category": "String"
+        }
+    ]
+    itemsApi.addOrUpdateItems(newItems)
+    print("New Items added/updated.")
+    
+    # Befehl an ein Item senden
+    itemsApi.sendCommand("testSwitch", "ON")
+    print("Command sent to testSwitch.")
+
+    # Zustand eines Items aktualisieren
+    itemsApi.updateItemState("testNumber", "42")
+    print("State of testNumber updated.")
+
+    # Zustand eines Items abrufen
+    testSwitchState = itemsApi.getItemState("testSwitch")
+    print("testSwitch State:", testSwitchState)
+
+    # Ein Item löschen
+    itemsApi.deleteItem("newSwitch")
+    print("newSwitch deleted.")
+
+    # Gruppenmitglied hinzufügen
+    itemsApi.addGroupMember("Static", "newNumber")
+    print("newNumber added to Static group.")
+
+    # Gruppenmitglied entfernen
+    itemsApi.removeGroupMember("Static", "newNumber")
+    print("newNumber removed from Static group.")
+    
+    # Metadaten hinzufügen
+    metadata = {
+        "value": "metadata_value",
+        "config": {
+            "key1": "value1",
+            "key2": "value2"
+        }
+    }
+    itemsApi.addMetadata("testSwitch", "exampleNamespace", metadata)
+    print("Metadata added to testSwitch.")
+
+    # Metadaten entfernen
+    itemsApi.removeMetadata("testSwitch", "exampleNamespace")
+    print("Metadata removed from testSwitch.")
+
+    # Metadaten-Namespaces eines Items abrufen
+    metadataNamespaces = itemsApi.getMetadataNamespaces("testSwitch")
+    print("Metadata namespaces for testSwitch:", metadataNamespaces)
+    
+    # Item mit semantischer Klasse abrufen
+    #semanticItem = itemsApi.getSemanticItem("testLocation", "Location")
+    #print("Semantic item for testLocation:", semanticItem)
+
+    # Einem Item ein Tag hinzufügen
+    itemsApi.addTag("testSwitch", "NewTag")
+    print("Tag added to testSwitch.")
+
+    # Einem Item ein Tag entfernen
+    itemsApi.removeTag("testSwitch", "NewTag")
+    print("Tag removed from testSwitch.")
+
+    # Verwaiste Metadaten löschen
+    itemsApi.purgeOrphanedMetadata()
+    print("Orphaned metadata purged.")
+    
+# Funktion ausführen
+if __name__ == "__main__":
+    examples()

tests/link_events.py

@@ -0,0 +1,14 @@
+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, LinkEvents
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+linkEvents = LinkEvents(client)
+
+# Beispielaufrufe
+print(linkEvents.ItemChannelLinkAddedEvent("*", "*"))
+print(linkEvents.ItemChannelLinkRemovedEvent("*", "*"))

tests/links.py

@@ -0,0 +1,74 @@
+import sys
+import os
+import json
+import time
+
+# 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, Links
+
+# OpenHAB-Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+
+# Links-Klasse instanziieren
+linksApi = Links(client)
+
+# Test-Daten (basierend auf deiner Liste)
+testLinks = [
+    {"itemName": "Sunrise_Time", "channelUID": "astro:sun:home:rise#start"},
+    {"itemName": "Sunset_Time", "channelUID": "astro:sun:home:set#start"},
+    {"itemName": "Azimuth", "channelUID": "astro:sun:home:position#azimuth"},
+    {"itemName": "Elevation", "channelUID": "astro:sun:home:position#elevation"},
+    {"itemName": "Moon_Phase", "channelUID": "astro:moon:home:phase#name"},
+    {"itemName": "Moon_Azimuth", "channelUID": "astro:moon:home:position#azimuth"},
+    {"itemName": "Moon_Elevation", "channelUID": "astro:moon:home:position#elevation"},
+]
+
+try:
+    print("\n**1. Alle Links abrufen**")
+    allLinks = linksApi.getAllLinks()
+    print(json.dumps(allLinks, indent=2))
+    
+    itemName = "Sunrise_Time2"
+    channelUid = "astro:sun:home:rise#start"
+
+    print(f"\n**2. Einzelnen Link abrufen: {itemName} -> {channelUid}**")
+    try:
+        singleLink = linksApi.getIndividualLink(itemName, channelUid)
+        print(json.dumps(singleLink, indent=2))
+    except Exception as e:
+        print(f"Fehler: {e}")
+
+    print(f"\n**3. Lösche den Link: {itemName} -> {channelUid}**")
+    try:
+        unlinkResponse = linksApi.unlinkItemFromChannel(itemName, channelUid)
+        print(f"Link entfernt: {unlinkResponse}")
+        time.sleep(1)  # Kleine Pause für API-Stabilität
+    except Exception as e:
+        print(f"Fehler: {e}")
+
+    print(f"\n**4. Verknüpfe Item erneut: {itemName} -> {channelUid}**")
+    try:
+        config = {}  # Falls Konfiguration notwendig ist, hier ergänzen
+        linkResponse = linksApi.linkItemToChannel(itemName, channelUid, config)
+        print(f"Link erstellt: {json.dumps(linkResponse, indent=2)}")
+    except Exception as e:
+        print(f"Fehler: {e}")
+    
+    print("\n**5. Orphan-Links abrufen**")
+    try:
+        orphanLinks = linksApi.getOrphanLinks()
+        print(json.dumps(orphanLinks, indent=2))
+    except Exception as e:
+        print(f"Fehler bei Orphan-Links: {e}")
+
+    print("\n**6. Unbenutzte Links bereinigen**")
+    try:
+        purgeResponse = linksApi.purgeUnusedLinks()
+        print(f"Unbenutzte Links bereinigt: {purgeResponse}")
+    except Exception as e:
+        print(f"Fehler: {e}")
+
+except Exception as e:
+    print(f"**Gesamtfehler:** {e}")

tests/logging_test.py

@@ -0,0 +1,43 @@
+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, Logging
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+
+# Logging-Klasse instanziieren
+loggingApi = Logging(client)
+
+# Alle Loggers abrufen
+try:
+    loggers = loggingApi.getAllLoggers()
+    print("Alle Loggers:", loggers)
+except Exception as e:
+    print("Fehler beim Abrufen der Loggers:", e)
+
+# Einen einzelnen Logger abrufen
+loggerName = "org.openhab"
+try:
+    logger = loggingApi.getSingleLogger(loggerName)
+    print(f"Logger {loggerName}:", logger)
+except Exception as e:
+    print("Fehler beim Abrufen des Loggers:", e)
+
+# Logger modifizieren oder hinzufügen
+loggerName = "org.openhab"
+level = "DEBUG"
+try:
+    response = loggingApi.modifyOrAddLogger(loggerName, level)
+    print(f"Logger {loggerName} modifiziert:", response)
+except Exception as e:
+    print("Fehler beim Modifizieren des Loggers:", e)
+
+# Logger entfernen
+try:
+    response = loggingApi.removeLogger(loggerName)
+    print(f"Logger {loggerName} entfernt:", response)
+except Exception as e:
+    print("Fehler beim Entfernen des Loggers:", e)

tests/module_types.py

@@ -0,0 +1,14 @@
+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, ModuleTypes
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+moduleTypesApi = ModuleTypes(client)
+
+# Teste Modultypen
+print(moduleTypesApi.getModuleTypes())
+print(moduleTypesApi.getModuleType("timer.GenericCronTrigger"))

tests/persistence.py

@@ -0,0 +1,78 @@
+import sys
+import os
+import json
+
+# 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, Persistence
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+
+# Persistence-Klasse instanziieren
+persistenceApi = Persistence(client)
+
+# Alle Persistence-Dienste abrufen
+try:
+    services = persistenceApi.getAllServices()
+    print("Alle Persistence-Dienste:", json.dumps(services, indent=4))
+except Exception as e:
+    print("Fehler beim Abrufen der Persistence-Dienste:", e)
+
+# Konfiguration eines bestimmten Persistence-Dienstes abrufen
+serviceId = "mapdb"
+try:
+    config = persistenceApi.getServiceConfiguration(serviceId)
+    print(f"Konfiguration für {serviceId}:", json.dumps(config, indent=4))
+except Exception as e:
+    print("Fehler beim Abrufen der Konfiguration:", e)
+
+# Konfiguration eines bestimmten Persistence-Dienstes setzen
+newConfig = {"retention": "30d"}
+try:
+    updatedConfig = persistenceApi.setServiceConfiguration(serviceId, newConfig)
+    print(f"Aktualisierte Konfiguration für {serviceId}:", json.dumps(updatedConfig, indent=4))
+except Exception as e:
+    print("Fehler beim Setzen der Konfiguration:", e)
+
+# Konfiguration eines bestimmten Persistence-Dienstes löschen
+try:
+    deleteResponse = persistenceApi.deleteServiceConfiguration(serviceId)
+    print(f"Konfiguration für {serviceId} gelöscht:", json.dumps(deleteResponse, indent=4))
+except Exception as e:
+    print("Fehler beim Löschen der Konfiguration:", e)
+
+# Items für einen Persistence-Dienst abrufen
+try:
+    items = persistenceApi.getItemsForService(serviceId)
+    print(f"Items für den Dienst {serviceId}:", json.dumps(items, indent=4))
+except Exception as e:
+    print("Fehler beim Abrufen der Items:", e)
+
+# Persistence-Daten für ein Item abrufen
+itemName = "TemperatureSensor1"
+startTime = "2025-01-01T00:00:00.000Z"
+endTime = "2025-01-31T23:59:59.999Z"
+try:
+    itemData = persistenceApi.getItemPersistenceData(serviceId, itemName, startTime=startTime, endTime=endTime)
+    print(f"Persistence-Daten für {itemName}:", json.dumps(itemData, indent=4))
+except Exception as e:
+    print("Fehler beim Abrufen der Persistence-Daten für Item:", e)
+
+# Persistence-Daten für ein Item speichern
+time = "2025-01-27T15:30:00.000Z"  # Zeit im richtigen Format
+state = "22.5"  # Beispiel für den Zustand des Items
+try:
+    response = persistenceApi.storeItemData(serviceId, itemName, time, state)
+    print("Daten erfolgreich gespeichert:", response)
+except Exception as e:
+    print("Fehler beim Speichern der Daten:", e)
+
+# Persistence-Daten für ein Item löschen
+startTimeDelete = "2025-01-01T00:00:00.000Z"
+endTimeDelete = "2025-01-31T23:59:59.999Z"
+try:
+    deleteItemResponse = persistenceApi.deleteItemData(serviceId, itemName, startTimeDelete, endTimeDelete)
+    print(f"Persistence-Daten für {itemName} gelöscht:", json.dumps(deleteItemResponse, indent=4))
+except Exception as e:
+    print("Fehler beim Löschen der Persistence-Daten für Item:", e)

tests/profile_types.py

@@ -0,0 +1,13 @@
+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, ProfileTypes
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+profileTypesApi = ProfileTypes(client)
+
+# Teste Profiltypen
+print(profileTypesApi.getProfileTypes())

tests/rules.py

@@ -0,0 +1,151 @@
+import sys
+import os
+import time
+
+# 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, Rules
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+rulesApi = Rules(client)
+
+def rulesExamples():
+    try:
+        # Alle Regeln abrufen
+        allRules = rulesApi.getRules()
+        print("All Rules:", allRules)
+    except Exception as e:
+        print("Error getting all rules:", e)
+    
+    try:
+        # Details zu einer Regel abrufen
+        testRule = rulesApi.getRule("test_color-1")
+        print("testRule Details:", testRule)
+    except Exception as e:
+        print("Error getting rule details:", e)
+    
+    try:
+        # Neue Regel hinzufügen
+        newRuleData = {
+            "uid": "newRule",
+            "name": "New Rule",
+            "description": "This is a new rule",
+            "triggers": [],
+            "conditions": [],
+            "actions": []
+        }
+        rulesApi.createRule(newRuleData)
+        print("New Rule created.")
+    except Exception as e:
+        print("Error creating rule:", e)
+    
+    try:
+        # Regel aktualisieren
+        updatedRuleData = {"name": "Updated Rule"}
+        rulesApi.updateRule("newRule", updatedRuleData)
+        print("Rule updated.")
+    except Exception as e:
+        print("Error updating rule:", e)
+    
+    try:
+        # Regel aktivieren
+        rulesApi.setRuleState("newRule", True)
+        print("newRule enabled.")
+    except Exception as e:
+        print("Error enabling rule:", e)
+    
+    try:
+        # Regel deaktivieren
+        rulesApi.setRuleState("newRule", False)
+        print("newRule disabled.")
+    except Exception as e:
+        print("Error disabling rule:", e)
+    
+    try:
+        # Regel löschen
+        rulesApi.deleteRule("newRule")
+        print("newRule deleted.")
+    except Exception as e:
+        print("Error deleting rule:", e)
+
+    try:
+        # Triggers abrufen
+        triggers = rulesApi.getTriggers("test_color-1")
+        print("Triggers:", triggers)
+    except Exception as e:
+        print("Error getting triggers:", e)
+    
+    try:
+        # Bedingungen abrufen
+        conditions = rulesApi.getConditions("test_color-1")
+        print("Conditions:", conditions)
+    except Exception as e:
+        print("Error getting conditions:", e)
+    
+    try:
+        # Aktionen abrufen
+        actions = rulesApi.getActions("test_color-1")
+        print("Actions:", actions)
+    except Exception as e:
+        print("Error getting actions:", e)
+    
+    try:
+        # Regelkonfiguration abrufen
+        config = rulesApi.getConfiguration("test_color-1")
+        print("Configuration:", config)
+    except Exception as e:
+        print("Error getting configuration:", e)
+    
+    try:
+        # Regelkonfiguration aktualisieren
+        rulesApi.updateConfiguration("test_color-1", {"param": "value"})
+        print("Configuration updated.")
+    except Exception as e:
+        print("Error updating configuration:", e)
+    
+    try:
+        # Regel sofort ausführen
+        rulesApi.runNow("test_color-1")
+        print("Rule executed immediately.")
+    except Exception as e:
+        print("Error running rule:", e)
+    
+    try:
+        # Modul abrufen
+        module = rulesApi.getModule("test_color-1", "actions", "script")
+        print("Module:", module)
+    except Exception as e:
+        print("Error getting module:", e)
+    
+    try:
+        # Modulkonfiguration abrufen
+        moduleConfig = rulesApi.getModuleConfig("test_color-1", "actions", "script")
+        print("Module Configuration:", moduleConfig)
+    except Exception as e:
+        print("Error getting module configuration:", e)
+
+    try:
+        # Modul-Konfigurationsparameter abrufen
+        paramValue = rulesApi.getModuleConfigParam("test_color-1", "actions", "script", "exampleParam")
+        print("Module Config Param:", paramValue)
+    except Exception as e:
+        print("Error getting module config param:", e)
+
+    try:
+        # Modul-Konfigurationsparameter setzen
+        rulesApi.setModuleConfigParam("test_color-1", "actions", "script", "exampleParam", "newValue")
+        print("Module Config Param updated.")
+    except Exception as e:
+        print("Error setting module config param:", e)
+    
+    try:
+        # Zeitplansimulation ausführen
+        simulationResult = rulesApi.simulateSchedule("2025-02-03T10:20:00.987Z", "2025-02-03T10:38:00.987Z")
+        print("Schedule Simulation Result:", simulationResult)
+    except Exception as e:
+        print("Error simulating schedule:", e)
+
+# Funktion ausführen
+if __name__ == "__main__":
+    rulesExamples()

tests/services.py

@@ -0,0 +1,52 @@
+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, Services
+
+def main():
+    # OpenHAB-Client initialisieren
+    client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+
+    serviceId = "org.openhab.i18n"
+    
+    # Services-API-Objekt erstellen
+    servicesApi = Services(client)
+
+    # 1. Alle Services abrufen
+    print("Alle Services:")
+    allServices = servicesApi.getServices(language="de")
+    print(allServices)
+
+    # 2. Einzelnen Service abrufen
+    print("Einzelner Service:")
+    singleService = servicesApi.getService(serviceId)
+    print(singleService)
+    
+    # 3. Konfiguration eines spezifischen Services abrufen
+    print(f"\nKonfiguration für den Service {serviceId}:")
+    serviceConfig = servicesApi.getServiceConfig(serviceId)
+    print(serviceConfig)
+    
+    # 4. Konfiguration für einen Service aktualisieren
+    newConfig = {
+        "enabled": True,
+        "setting1": "newValue1"
+    }
+    print(f"\nAktualisierte Konfiguration für {serviceId}:")
+    oldConfig = servicesApi.updateServiceConfig(serviceId, newConfig)
+    print("Alte Konfiguration:", oldConfig)
+    
+    # 5. Konfiguration eines Services löschen
+    print(f"\nService-Konfiguration für {serviceId} löschen:")
+    deletedConfig = servicesApi.deleteServiceConfig(serviceId)
+    print("Gelöschte Konfiguration:", deletedConfig)
+
+    # 6. Alle Kontexte eines Services abrufen
+    print(f"\nKontexte für {serviceId}:")
+    serviceContexts = servicesApi.getServiceContexts(serviceId)
+    print(serviceContexts)
+
+if __name__ == "__main__":
+    main()

tests/sitemaps.py

@@ -0,0 +1,65 @@
+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, Sitemaps
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+sitemapsApi = Sitemaps(client)
+
+# Beispiele für die Sitemaps-API
+def sitemapsExamples():
+    # 1. Alle Sitemaps abrufen
+    try:
+        allSitemaps = sitemapsApi.getSitemaps()
+        print("All Sitemaps:", allSitemaps)
+    except Exception as e:
+        print("Error fetching all sitemaps:", e)
+
+    # 2. Details zu einer bestimmten Sitemap abrufen (z.B. 'Sitemap')
+    try:
+        testSitemap = sitemapsApi.getSitemap("Sitemap")
+        print("Sitemap Details:", testSitemap)
+    except Exception as e:
+        print("Error fetching Sitemap details:", e)
+
+    # 3. Eine bestimmte Seite einer Sitemap abrufen
+    try:
+        sitemapPage = sitemapsApi.getSitemapPage("astro", "astro")
+        print("Sitemap Page Details:", sitemapPage)
+    except Exception as e:
+        print("Error fetching sitemap page:", e)
+
+    # 4. Alle Daten einer ganzen Sitemap abrufen
+    try:
+        fullSitemap = sitemapsApi.getFullSitemap("astro")
+        print("Full Sitemap Details:", fullSitemap)
+    except Exception as e:
+        print("Error fetching full sitemap:", e)
+
+    # 5. Ereignisse für eine Sitemap abrufen
+    try:
+        sitemapEvents = sitemapsApi.getSitemapEvents("013328fd-d3fd-4de4-8f7d-efe01bad7eac", sitemap="Sitemap")
+        print("Sitemap Events:", sitemapEvents)
+    except Exception as e:
+        print("Error fetching sitemap events:", e)
+
+    # 6. Ereignisse für die gesamte Sitemap abrufen
+    try:
+        fullSitemapEvents = sitemapsApi.getFullSitemapEvents("013328fd-d3fd-4de4-8f7d-efe01bad7eac", sitemap="Sitemap")
+        print("Full Sitemap Events:", fullSitemapEvents)
+    except Exception as e:
+        print("Error fetching full sitemap events:", e)
+
+    # 7. Eine Subscription für Sitemap-Ereignisse erstellen
+    try:
+        subscribeResponse = sitemapsApi.subscribeToSitemapEvents()
+        print("Subscription Response:", subscribeResponse)
+    except Exception as e:
+        print("Error subscribing to sitemap events:", e)
+
+# Funktion ausführen
+if __name__ == "__main__":
+    sitemapsExamples()

tests/systeminfo.py

@@ -0,0 +1,14 @@
+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, Systeminfo
+
+# Client initialisieren
+client = OpenHABClient(url="http://127.0.0.1:8080", username="openhab", password="habopen")
+systemInfoApi = Systeminfo(client)
+
+# Teste Systeminformationen
+print(systemInfoApi.getSystemInfo())
+print(systemInfoApi.getUomInfo())