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

openhab/Sitemaps.py

@@ -0,0 +1,88 @@
+from .Client import OpenHABClient
+
+class Sitemaps:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Sitemaps class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getSitemaps(self):
+        """
+        Get all available sitemaps.
+
+        :return: A list of sitemaps (JSON).
+        """
+        return self.client.get("/sitemaps")
+
+    def getSitemap(self, sitemapName: str, language=None, type=None, jsonCallback=None, includeHidden=False):
+        """
+        Get sitemap by name.
+
+        :param sitemapName: The name of the sitemap to retrieve.
+        :param language: Optional language setting (as header).
+        :param type: Optional query parameter for type.
+        :param jsonCallback: Optional query parameter for JSON callback.
+        :param includeHidden: Whether hidden widgets should be included.
+
+        :return: The sitemap object (JSON).
+        """
+        return self.client.get(f"/sitemaps/{sitemapName}", header={"type": type, "jsoncallback": jsonCallback, "includeHidden": includeHidden}, params={"Accept-Language": language} if language else {})
+
+    def getSitemapPage(self, sitemapName: str, pageId: str, subscriptionID=None, includeHidden=False):
+        """
+        Polls the data for one page of a sitemap.
+
+        :param sitemapName: The name of the sitemap.
+        :param pageId: The ID of the page.
+        :param subscriptionID: Optional query parameter for the subscription ID.
+        :param includeHidden: Whether hidden widgets should be included.
+
+        :return: The sitemap page (JSON).
+        """
+        return self.client.get(f"/sitemaps/{sitemapName}/{pageId}", params={"subscriptionID": subscriptionID, "includeHidden": includeHidden})
+
+    def getFullSitemap(self, sitemapName: str, subscriptionID=None, includeHidden=False):
+        """
+        Polls the data for a whole sitemap. Not recommended due to potentially high traffic.
+
+        :param sitemapName: The name of the sitemap.
+        :param subscriptionID: Optional query parameter for the subscription ID.
+        :param includeHidden: Whether hidden widgets should be included.
+
+        :return: The complete sitemap (JSON).
+        """
+        return self.client.get(f"/sitemaps/{sitemapName}/*", params={"subscriptionID": subscriptionID, "includeHidden": includeHidden})
+
+    def getSitemapEvents(self, subscriptionID: str, sitemap=None, pageId=None):
+        """
+        Get sitemap events.
+
+        :param subscriptionID: The ID of the subscription.
+        :param sitemap: The name of the sitemap (optional).
+        :param pageId: The ID of the page (optional).
+
+        :return: The events (JSON).
+        """
+        return self.client.get(f"/sitemaps/events/{subscriptionID}", params={"sitemap": sitemap, "pageId": pageId})
+
+    def getFullSitemapEvents(self, subscriptionID: str, sitemap=None):
+        """
+        Get sitemap events for a whole sitemap. Not recommended due to potentially high traffic.
+
+        :param subscriptionID: The ID of the subscription.
+        :param sitemap: The name of the sitemap (optional).
+
+        :return: The events for the entire sitemap (JSON).
+        """
+        return self.client.get(f"/sitemaps/events/{subscriptionID}/*", params={"sitemap": sitemap})
+
+    def subscribeToSitemapEvents(self):
+        """
+        Creates a sitemap event subscription.
+
+        :return: The response to the subscription request (JSON).
+        """
+        return self.client.post("/sitemaps/events/subscribe")

openhab/Systeminfo.py

@@ -0,0 +1,34 @@
+from .Client import OpenHABClient
+
+class Systeminfo:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Systeminfo class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getSystemInfo(self, language: str = None):
+        """
+        Gets information about the system.
+
+        :return: A Dictionary with system informations.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get("/systeminfo", header=header)
+
+    def getUomInfo(self, language: str = None):
+        """
+        Get all supported dimensions and their system units.
+
+        :return: A Dictionary with UOM informations.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get("/systeminfo/uom", header=header)

openhab/Tags.py

@@ -0,0 +1,82 @@
+from .Client import OpenHABClient
+import json
+
+class Tags:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Tags class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getTags(self, language=None):
+        """
+        Get all available semantic tags.
+
+        :param language: Optional header for language setting.
+
+        :return: A list of semantic tags (JSON).
+        """
+        return self.client.get("/tags", header={"Accept-Language": language} if language else {})
+
+    def createTag(self, tagData, language=None):
+        """
+        Creates a new semantic tag and adds it to the registry.
+
+        :param tagData: The data object for the tag to be created.
+        :param language: Optional header for language setting.
+
+        :return: The response to the tag creation request (JSON).
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.post("/tags", data=json.dumps(tagData), header=header)
+
+    def getTag(self, tagID: str, language=None):
+        """
+        Gets a semantic tag and its sub-tags.
+
+        :param tagID: The ID of the tag to retrieve.
+        :param language: Optional header for language setting.
+
+        :return: The tag object and its sub-tags (JSON).
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f"/tags/{tagID}", header=header)
+
+    def updateTag(self, tagID: str, tagData, language=None):
+        """
+        Updates a semantic tag.
+
+        :param tagID: The ID of the tag to be updated.
+        :param tagData: The new tag data.
+        :param language: Optional header for language setting.
+
+        :return: The response to the tag update request (JSON).
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.put(f"/tags/{tagID}", data=json.dumps(tagData), header=header)
+
+    def deleteTag(self, tagID: str, language=None):
+        """
+        Removes a semantic tag and its sub-tags from the registry.
+
+        :param tagID: The ID of the tag to be removed.
+        :param language: Optional header for language setting.
+
+        :return: The response to the tag deletion request (JSON).
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.delete(f"/tags/{tagID}", header=header)

openhab/Templates.py

@@ -0,0 +1,38 @@
+from .Client import OpenHABClient
+
+class Templates:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Templates class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllTemplates(self, language: str = None) -> list:
+        """
+        Get all available templates.
+
+        :param language: (Optional) Language setting for the Accept-Language header.
+        :return: A list of templates.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get("/templates", header=header)
+
+    def getTemplateByUID(self, templateUID: str, language: str = None) -> dict:
+        """
+        Gets a template corresponding to the given UID.
+
+        :param templateUID: The UID of the template.
+        :param language: (Optional) Language setting for the Accept-Language header.
+        
+        :return: A dictionary with the details of the template.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f"/templates/{templateUID}", header=header)

openhab/ThingTypes.py

@@ -0,0 +1,42 @@
+from .Client import OpenHABClient
+
+class ThingTypes:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the ThingTypes class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllThingTypes(self, bindingId: str = None, language: str = None) -> list:
+        """
+        Gets all available thing types without config description, channels, and properties.
+
+        :param bindingId: (Optional) Filter by binding ID.
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A list of thing types.
+        """
+        params = {}
+        if bindingId:
+            params["bindingId"] = bindingId
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get("/thing-types", header={"Content-Type": "application/json"}, params=params)
+
+    def getThingType(self, thingTypeUID: str, language: str = None) -> dict:
+        """
+        Gets a thing type by UID.
+
+        :param thingTypeUID: The UID of the thing type.
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A dictionary with the details of the thing type or an empty response with status 204.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f"/thing-types/{thingTypeUID}", header=header)

openhab/Things.py

@@ -0,0 +1,199 @@
+from .Client import OpenHABClient
+import json
+
+class Things:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Things class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllThings(self, summary: bool = False, staticDataOnly: bool = False, language: str = None):
+        """
+        Get all available things.
+
+        :param summary: If True, returns only the summary fields.
+        :param staticDataOnly: If True, returns a cacheable list.
+        :param language: The preferred language for the response.
+
+        :return: JSON response with the things.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get('/things', params={'summary': summary, 'staticDataOnly': staticDataOnly}, header=header)
+
+    def createThing(self, thingData: dict, language: str = None):
+        """
+        Creates a new thing and adds it to the registry.
+
+        :param thingData: The JSON object containing the thing data.
+        :param language: The preferred language for the response.
+
+        :return: The API response.
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.post('/things', data=json.dumps(thingData), header=header)
+
+    def getThingByUID(self, thingUID: str, language: str = None):
+        """
+        Gets a thing by UID.
+
+        :param thingUID: The UID of the thing.
+        :param language: The preferred language for the response.
+
+        :return: JSON response with the thing data.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f'/things/{thingUID}', header=header)
+
+    def updateThing(self, thingUID: str, thingData: dict, language: str = None):
+        """
+        Updates a thing.
+
+        :param thingUID: The UID of the thing.
+        :param thingData: The JSON object containing the updated thing data.
+        :param language: The preferred language for the response.
+
+        :return: The API response.
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.put(f'/things/{thingUID}', data=json.dumps(thingData), header=header)
+
+    def deleteThing(self, thingUID: str, force: bool = False, language: str = None):
+        """
+        Removes a thing from the registry. Set 'force' to __true__ if you want the thing to be removed immediately.
+
+        :param thingUID: The UID of the thing.
+        :param force: If True, the thing will be immediately removed.
+        :param language: The preferred language for the response.
+
+        :return: The API response.
+        """
+        return self.client.delete(f'/things/{thingUID}', params={'force': force}, header={'Accept-Language': language} if language else {})
+
+    def updateThingConfiguration(self, thingUID: str, configurationData: dict, language: str = None):
+        """
+        Updates a thing's configuration.
+
+        :param thingUID: The UID of the thing.
+        :param configurationData: The configuration data of the thing.
+        :param language: The preferred language for the response.
+
+        :return: The API response.
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.put(f'/things/{thingUID}/config', data=json.dumps(configurationData), header=header)
+
+    def getThingConfigStatus(self, thingUID: str, language: str = None):
+        """
+        Gets the thing's configuration status.
+
+        :param thingUID: The UID of the thing.
+        :param language: The preferred language for the response.
+
+        :return: JSON response with the thing's configuration status.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f'/things/{thingUID}/config/status', header=header)
+    
+    def setThingStatus(self, thingUID: str, enabled: bool, language: str = None):
+        """
+        Sets the thing's enabled status.
+
+        :param thingUID: The UID of the thing.
+        :param enabled: If True, the thing will be enabled.
+        :param language: The preferred language for the response.
+
+        :return: The API response.
+        """
+        header = {"Content-Type": "text/plain"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.put(f'/things/{thingUID}/enable', data="true" if enabled else "false", header=header)
+
+    def enableThing(self, thingUID: str):
+        return self.setThingStatus(thingUID, True)
+    
+    def disableThing(self, thingUID: str):
+        return self.setThingStatus(thingUID, False)
+
+    def updateThingFirmware(self, thingUID: str, firmwareVersion: str, language: str = None):
+        """
+        Updates the firmware of a thing.
+
+        :param thingUID: The UID of the thing.
+        :param firmwareVersion: The firmware version.
+        :param language: The preferred language for the response.
+
+        :return: The API response.
+        """
+        header = {"Content-Type": "application/json", "Accept": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.put(f'/things/{thingUID}/firmware/{firmwareVersion}', header=header)
+
+    def getThingFirmwareStatus(self, thingUID: str, language: str = None):
+        """
+        Gets the thing's firmware status.
+
+        :param thingUID: The UID of the thing.
+        :param language: The preferred language for the response.
+
+        :return: JSON response with the firmware status.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f'/things/{thingUID}/firmware/status', header=header)
+
+    def getThingFirmwares(self, thingUID: str, language: str = None):
+        """
+        Gets all available firmwares for the provided thing UID.
+
+        :param thingUID: The UID of the thing.
+        :param language: The preferred language for the response.
+
+        :return: A list of available firmwares.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f'/things/{thingUID}/firmwares', header=header)
+
+    def getThingStatus(self, thingUID: str, language: str = None):
+        """
+        Gets the thing's status.
+
+        :param thingUID: The UID of the thing.
+        :param language: The preferred language for the response.
+
+        :return: JSON response with the thing's status.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f'/things/{thingUID}/status', header=header)

openhab/Transformations.py

@@ -0,0 +1,58 @@
+from .Client import OpenHABClient
+import json
+
+class Transformations:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Transformations class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getTransformations(self):
+        """
+        Get a list of all transformations.
+
+        :return: A list of transformations (JSON).
+        """
+        return self.client.get("/transformations")
+
+    def getTransformation(self, transformationUID: str):
+        """
+        Get a single transformation.
+
+        :param transformationUID: The transformationUID of the transformation to retrieve.
+
+        :return: The transformation (JSON).
+        """
+        return self.client.get(f"/transformations/{transformationUID}")
+
+    def updateTransformation(self, transformationUID: str, transformationData):
+        """
+        Update a single transformation.
+
+        :param transformationUID: The transformationUID of the transformation to update.
+        :param transformationData: The new data for the transformation.
+
+        :return: The response to the transformation update request (JSON).
+        """
+        return self.client.put(f"/transformations/{transformationUID}", data=json.dumps(transformationData), header={"Content-Type": "application/json"})
+
+    def deleteTransformation(self, transformationUID: str):
+        """
+        Delete a single transformation.
+
+        :param transformationUID: The transformationUID of the transformation to delete.
+
+        :return: The response to the transformation delete request (JSON).
+        """
+        return self.client.delete(f"/transformations/{transformationUID}")
+
+    def getTransformationServices(self):
+        """
+        Get all transformation services.
+
+        :return: A list of transformation services (JSON).
+        """
+        return self.client.get("/transformations/services")

openhab/UI.py

@@ -0,0 +1,75 @@
+from .Client import OpenHABClient
+import json
+
+class UI:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the UI class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getUiComponents(self, namespace: str, summary: bool = False):
+        """
+        Get all registered UI components in the specified namespace.
+
+        :param namespace: The namespace for which UI components should be retrieved.
+        :param summary: If True, only summary fields will be returned.
+
+        :return: A list of UI components (JSON).
+        """
+        return self.client.get(f"/ui/components/{namespace}", params={'summary': summary} if summary else {})
+
+    def addUiComponent(self, namespace: str, componentData):
+        """
+        Add a UI component in the specified namespace.
+
+        :param namespace: The namespace where the UI component should be added.
+        :param componentData: The data of the UI component (JSON) to be added.
+
+        :return: The response to the request (JSON).
+        """
+        return self.client.post(f"/ui/components/{namespace}", data=json.dumps(componentData), header={"Content-Type": "application/json"})
+
+    def getUiComponent(self, namespace: str, componentUID: str):
+        """
+        Get a specific UI component in the specified namespace.
+
+        :param namespace: The namespace where the UI component is located.
+        :param componentUID: The UID of the UI component to retrieve.
+
+        :return: The UI component (JSON).
+        """
+        return self.client.get(f"/ui/components/{namespace}/{componentUID}")
+
+    def updateUiComponent(self, namespace: str, componentUID: str, componentData):
+        """
+        Update a specific UI component in the specified namespace.
+
+        :param namespace: The namespace where the UI component should be updated.
+        :param componentUID: The UID of the UI component to update.
+        :param componentData: The new data for the UI component (JSON).
+
+        :return: The response to the request (JSON).
+        """
+        return self.client.put(f"/ui/components/{namespace}/{componentUID}", data=json.dumps(componentData))
+
+    def deleteUiComponent(self, namespace: str, componentUID: str):
+        """
+        Remove a specific UI component in the specified namespace.
+
+        :param namespace: The namespace where the UI component should be removed.
+        :param componentUID: The UID of the UI component to delete.
+
+        :return: The response to the request (JSON).
+        """
+        return self.client.delete(f"/ui/components/{namespace}/{componentUID}")
+
+    def getUiTiles(self):
+        """
+        Get all registered UI tiles.
+
+        :return: A list of UI tiles (JSON).
+        """
+        return self.client.get("/ui/tiles")

openhab/UUID.py

@@ -0,0 +1,18 @@
+from .Client import OpenHABClient
+
+class UUID:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the UUID class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getUUID(self) -> str:
+        """
+        A unified unique id.
+
+        :return: The UUID as String.
+        """
+        return self.client.get("/uuid").strip()